In this hands-on tutorial, we dive into bit manipulation in x86-64 assembly using Yasm on Ubuntu. We cover the basics of logical operations like AND, OR, XOR, and NOT, then move into shifting (logical vs arithmetic), rotating bits, and why signed vs unsigned matters for shifts.

I explain each concept on paper first, then show real code examples running in GDB to prove how the bits change. We look at patterns in registers, see what happens with negative numbers in two’s complement, and even touch on how shifts can multiply or divide by powers of 2.

Perfect if you’re learning low-level programming, reverse engineering, or just curious about how bits work under the hood. No prior assembly knowledge needed, but it’ll help if you’ve seen my other videos.

Like and subscribe for more assembly tutorials!

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, we’re going to talk all about manipulating bits in x86-64 Yasm assembly within

Ubuntu.

But if you’re not using Yasm or you’re not on Ubuntu, this video is probably going to

be pretty useful to you anyway, because I’m going to talk about the basic concept of manipulating

bits in various ways.

We’re going to talk about some basic logical operators like ANDing, ORing, XORing, and

XORing, and then we’re going to talk about shifting the bits to the left and the right,

and then we’re going to talk about the difference between shifting without any respect for whether

the number inside of the bits is an actual integer, or whether we just consider them

to just be bits by themselves, or whether we’re actually respecting the bits as numbers,

and also we’re going to look at the rotation instruction.

So first I’m going to explain this, I’m going to write it down in a pad, and then I’m going

show you a program that actually does it just so we can prove that it all works.

Okay, so for starters, let me open up a little notepad here.

What the heck am I even talking about? Let me write this down because I forgot this on my

first take I spent like five minutes, blew right past the explanation of and and or and xor because

I forgot that that was supposed to be part of this video. We’re going to look at and or and xor

at least for now and then we’re going to look at shifting and then we’re going to look at rotating.

at rotating. Okay so first off what is anding? I’ve explained that in another video but long

story short and just requires that two bits that you’re comparing against each other are both a one

in order to receive a one and so any other pair like a zero versus a one or one versus a zero or

two zeros are just going to be a zero. So and means both bits that you’re comparing have to be a one

The OR is pretty easy.

If either of the bits is a 1, then the result is going to be 1.

So if I say 1 versus 1, the result is going to be 1.

If I say 0 versus 1, the result is going to be a 1.

Or if I say 1 versus 0, the result is going to be a 1.

In the only case where you end up with a 0, it’s just going to be 0 versus 0 results in a 0.

To upgrade to exclusive OR, basically exactly 1 bit needs to be a 1.

bit needs to be a one and if two or zero are a one then the result is a zero which means here when

we have the two ones at the top the answer is going to be a zero these are the two stay the

same and this one stays the same so that’s xor again i have another video where i explain this

a little bit better but i’m just doing like a quick overview shifting is pretty interesting

because let me do a pattern let’s say zero one one zero suppose we just have four bits

to the left or to the right. So imagine left, if I shift them to the left, then what I’m really

doing is I’m just taking off that zero on the end and padding on the right with a zero. And then if

I’m shifting to the right, then well, it’s to the right. I’m just going to, you know, take off,

let’s see the zero on the right side and pad with the zero on the left. Be careful though, because

or logical shifting. I haven’t actually shifted with respect to the original number. Think

about this. That number right there on line three, if we just consider that an unsigned

integer or just bits, then what I just did with the shifting is fine. But what if that

was a two’s complement number that can represent a signed integer? If it’s two’s complement

or if it’s just like a signed integer, then the leftmost bit being a zero tells me that

result of my left shift, there’s a one now in that first position, which tells me that’s

probably a negative number.

We could face a similar problem with shifting to the right.

I mean, we didn’t this time.

It just looks like it actually shifted and the answer is going to end up being right.

But what if we shifted something else right?

Let’s see, what am I going to do here?

One, one, zero, zero.

What if I shifted that number one to the right?

The answer would be zero, you know, one, one, zero, right?

you know 110 right but then that’s wrong because the original number was negative because there’s

a one in the first position but the result is a zero so if i’m not careful about what instructions

i’m using and how to respect whether the number i’m shifting is actually considered an integer

assigned integer or if it’s just bits if i don’t respect that then i could end up ruining the

number so keep that in mind we’re going to do several examples of that i’m not going to show

shift by hand I’m just going to show you what the instructions in the assembler

will do so then the other thing that we should talk about is rotating so imagine

that I rotate this number one to the right well nothing really happens

visually but what you’re supposed to do if we rotate to the right you take the

number on the very right side and you just pop it onto the front so it sort of

it doesn’t fall off and get replaced by a zero or get replaced by a one depending

moves to the other side so if I shift this again maybe let’s shift it one more

time to the right I’m gonna take that one and pop it off the right side and

put it on the very front so see do you see how there it’s kind of rotating I do

this one more time actually let me copy paste this I’ll take that number on the

right side pop it off put it back on the front then if I do it again take that

zero pop it off put it back on the front notice how it eventually gets back to

the original pattern and I would have to rotate you know exactly four times to

to get that to happen same same thing applies for rotating to the left i’m not going to show you

because uh it’s it’s the same thing as rotating to the right just in a different direction

one thing that i forgot to say a moment ago when i was talking about shifting is uh think about this

if we shift to the right pretend that uh we don’t really care that much let’s let me put some extra

zeros here so that we don’t have to carry too much we don’t have to care too much about what’s

happening with positive or negative. If you know how to convert to binary, which I’ve explained in

other videos, then you’ll know this number is, let’s see, there’s a one and a two, and then these

positions are four and eight. So this should be a 12, right? If I shift this to the right,

I should be dividing this by two because the base of binary is two. So every time you kind of like

move to the left in terms of what digit you’re looking at, you’re increasing the power of that

every time you move to the right you’re decreasing the power of the digit by two

so that means if I shift the entire thing to the right I should be dividing the whole thing by two

right not just one bit so if I just take a zero off of there and put it on there I’ve now shifted

all the bits shifted all the bits one to the right I should end up with the six let’s just

compute what it is there’s a one there and there’s a two there and there’s a four there what’s four

plus two that’s six so this is actually six in binary or the original number divided by two

because we shifted to the right on the other hand if I take this number one more time and

just kind of shift it to the left I should multiply it by two so that means I should

expect to see a 24 let me just remove one of those zeros and put it on the right side there

this is not a rotation I’m just kind of like filling in zeros I’m keeping it simple with

the shifted number this is a 1, a 2, and a 4 again if you don’t know how to convert

from binary to decimal or back see my other videos so then we basically have

an 8 here and a 16 what’s 8 plus 16 that’s 24 24 is twice of 12 so we have

multiplied by 2 so you could multiply by 4 by shifting twice multiply by 8 by

shifting 3 times you know whatever you want to do but shifting is is like a

is like a shortcut besides just to move the bits it’s also a shortcut to multiply and divide by two

okay so that’s the basic idea let me start working on a little program here for you before I continue

I just want you to know that my program it’s got stuff in it already we’ve got a make file here

if I uh I edit the make file I just have a make file set up to build the program so again this

is specific to just you know bits we’re not going to talk about make files see my other videos if

you want to know how to make your own make file same thing for this gdb.txt file I’ve just put

commands that I’m going to send to gdb my debugger of choice this is not a gdb video I haven’t

actually made my gdb video yet so look out for that in this in the somewhat near future

so we’re just going to focus on the actual program for now anyway so I’ve got a solution

Anyway, so I’ve got a solution already set up here.

Let me start copy pasting some stuff in there.

Going to copy paste my data section.

So first off,

my sample program is just gonna have codes for writing,

you know, with the system call

and exiting with the system call.

And then I’m gonna output to standard output

and I’m gonna do a zero return code.

If you don’t know that,

see my other videos that I’ve already put out.

I’m gonna make a sample string where I just say,

I just say hello my name is Gibson Montgomery Gibson that’s not my name but I love those names

I’m just going to say hello basically when the program starts then I have some bit strings here

that will help me with the you know help me demonstrate some of the bitwise operations

the ending and the oring and the shifting and whatever and then I’m going to put a negative

number here as a variable just to prove to you that sometimes the bitwise or logical shifting

break a number if the number is supposed to actually be assigned integer and and use that

as evidence for why you should use arithmetic shifting so now I’m going to start my program

here let’s see my entry point should start at line 30 I got to be super careful about this

because if I don’t know 26 if I don’t then all of my debug statements are going to have to be

it lined up correctly so i’m basically just going to print the hello message and then maybe you know

what at the very end i’m going to exit from the system with a system call so basically if we run

this program again system calls and everything like that are not part of this video see my other

videos but uh if this works we should see just like a simple message okay so that’s it my name

Conmary Gibson. Okay.

So then the next thing that I’m going to do is I’m going to show you a bitwise

and operation. So I’m going to copy paste that should start on line 42.

And if I get this wrong, the debugging is going to be awful.

I was trying to make this a pure assembly program without a bunch of extra work.

I guess I could have linked GCC so I could just print results to the terminal,

but whatever too late now. So it starts on 42.

and ends on 51 okay so I think that’s good so the instruction for ending doing

a logical and between two registers which are full of bits and then what

will happen is every bit gets anded against its own course or I guess the

corresponding bit in the other other register is just and so what I’m doing

first is I’m gonna set up the registers so I’m gonna move the a sequence which

sequence, which if you look up is just, you know, I put a bunch of bits. So like in hex,

I like to type hex more than binary when I’m just kind of putting stuff in there.

So, you know, each F is basically four ones. So it’s going to be like, I guess, 16 ones,

and then a bunch of zeros, and then, you know, a few ones, and then some zeros and ones.

So I’m just making a little pattern for bits A. Don’t think that they mean anything right now.

And I’m going to make a different pattern with bits B. And when we look into the debugger,

And when we look into the debugger, we should see the before and after patterns so we can kind of see what the AND instruction did.

So I’m going to move bits A and bits B into R10 and R11.

Then I’m going to move, so these are going to be like the original bits that we can inspect later.

this AND instruction against R11 which is the B pattern. So I’m basically taking the A pattern

and I’m ANDing it against the B pattern but I’m also loading up the registers so we can see

the A pattern then the B pattern and then the result of ANDing them together.

Finally on line 50 here I’m using a NOPE which is just a non-operation so that I can easily

break the debugger so we can sort of inspect the program and see what’s going on inside of there.

program and see what’s going on inside of there. You know what, let me, uh, let me open this up

again here so that I can control where I’m breaking. So 48 is where the nope is. That’s

totally wrong. I’ve already ruined my program somehow. It’s going to be 50, I guess. All right,

50. And what I’m doing inside of this, and again, this is not a GDB video. I’m just saying,

let’s break at line 50 so I can kind of poke around. And I’m going to comment all these

And I’m going to comment all these things out for now.

That’s going to happen at the very end.

It’s going to be majestic.

How many different things we can look at.

So I’m telling GDB not to execute any of these instructions, except for the, uh,

the break point instructions.

So we can just break on line 50.

Okay.

Hopefully this works.

I’m going to now use make debug, which under the hood is just going to be compiling and

then telling GDB to launch with the name of my program inside of it.

And then to execute those things.

and then to execute those things.

So it hits breakpoint number 50.

There’s a bunch of crap that gets printed.

And I can now inspect my registers.

I’m going to go info R for just info registers.

And let’s see.

So we had R10, 11, and 12.

So if we look at the terminal, you can see that R10, the hex version,

has the original pattern of the A sequence,

and then R11 has the original pattern of the B sequence.

original pattern of the b sequence if we do a logical and and put the result into r12 then

you should see let me just double check that that’s definitely r12 yeah then you should see

the result of ending all of the f’s together remember that an f is just four ones so i’m kind

of simplifying it a little bit you could make yours more complicated with lots of randomness

in your ones and zeros just to prove it to yourself but notice how r12 only has an f

So like FF means F, F0 means 0, F0 means 0, you know, and so forth.

0F means 0.

So only where you see two Fs will you see an F in the final target pattern.

So that’s a logical AND, and that’s how you do it in Yasm Assembly.

You just load up a register with some bits, R12.

We loaded them up with the first pattern.

And then we take the second pattern and say that’s what I want to AND it against.

that’s what I want to end it against. And you can have that in a register or I think an immediate

or a memory location. So we’re just ending these registers together. And you know that they’re

loaded up with patterns A and B. So nothing too hard at this point. Let’s do a, let’s look at

bitwise or this should start on line 52 or I’m screwing myself. 52. Okay. 52. So same thing,

up R10 and R11 with the bit patterns and then we’re going to move the first bit pattern

into R12 so that we can or it against the second pattern and so basically R10 and 11

will have the original bit patterns R12 will have the result of oring them.

Then we’ll do a nope on line 60 so I want to break here on line 60.

Yep I ruined all my line numbers. What did I do wrong? I think I just have it offset by 2 now

two now for some reason so if we just kind of run the program now in the debugger again i’m going to

quit and then yes if we clear and make debug probably clear was unnecessary we’re broken at

line 60 if i say info registers the registers in question are oh shoot um 10 11 and 12 right so

we look at 10 and 11 they have the same pattern as before and 12 has a lot more f’s because if

has a lot more F’s because if either of the patterns had an F,

then the resulting pattern would have an F.

So this is a logical OR.

Same idea as AND in terms of the way you format the instruction and the OPS,

but it ORs instead of ANDs.

Okay, no problem.

Let’s move on.

Next thing I want to show you is the XOR, which is pretty cool.

By the way, so far we’re just operating on bits.

We don’t consider these bits to actually be numbers.

maybe they are but we should probably be careful about that anyway so I’m going to say let’s check

out our bitwise xor which is exclusive or which means exactly one bit in any pair needs to be a

one for the resulting bit to be a one and of course per usual all bits will be checked against each

other in the pair of of bit patterns it’ll be one bit at a time from each pattern that gets checked

Okay, so it starts on 62 and then we got a nope there.

Okay.

So same thing that we did before.

We’re just loading up two registers with the bit patterns and then R12 is going to be the

result of exclusive oring or X oring the two bit patterns.

So that means we’re going to break on line 70.

Now, let me just get rid of my other break point, change that 68 to a 70.

And now I should quit.

bug we’re at 70 good info registers so I think we said it was 10 and 11 had the original bit patterns

and notice the resulting bit pattern it only has an f in a position where there was exactly

one f between the two input patterns so

wait did I just do something wrong here what did I just do wrong

hang on a second I’m seeing something bad x or r12 am I looking at r12

Yeah.

R10 and 11.

Did I just do something wrong?

10 and 11 and then we load 10 up into 12 and then we XOR it by 11 and then it stores it

in 12.

Something’s a little fishy here.

Exactly one.

XOR.

I don’t like that.

Oh, I understand now.

Okay.

So that was a little scary.

This has shifted because the printout is not great.

Because the printout is not great. See how there’s like a blank space here?

That threw me off. So you have to imagine that all of the bit patterns are kind of shifted.

Maybe I should just copy paste this.

I was worried that I suddenly didn’t know how to do an XOR in assembly.

So let me get rid of these integers here.

Notice how there’s just a blank space that shifted everything and threw it off in terms of the display.

So I’m going to do this.

And what should really happen now is that there should be a zero here.

A zero at the front.

a zero at the front now everything would make more sense sometimes the display likes to just

kind of truncate things and just assume that everything will be read correctly but it wasn’t

so notice uh in the first position both of the uh both the input patterns are are an f so the

output pattern will be a zero you can imagine under the hood there was a bunch of ones and

then a bunch of ones and that resulted in a bunch of zeros uh here we’ve got like an f and a zero so

the result is going to be an f and then f and a zero and after zero zero and an f is an f

f um and then where you see zeros that means uh there was not exactly one uh one in each bit

position so for the let’s say the first one that’s a bunch of zeros for both input patterns so that’s

why there’s a zero there then for the next two each of them had all ones or just the two f’s

uh so that’s why x or says it’s a zero and so forth right so like at the end two f’s making

Okay, that was a little scary.

I’m glad I figured that out quickly instead of taking a million years.

Okay.

So now let’s do another example.

We’re done with XOR.

Now let’s look at bitwise knot.

I forgot to explain knot.

I’m not going to redo this video.

But let me just say that a knot is just inverting the bit.

So if we have a zero, it becomes a one.

And if we have a one, it becomes a zero.

If you knot against a register that has lots of bits or a memory location that has lots

of bits, you can do that and just every single bit in the sequence will just be flipped from

a zero to a one or vice versa.

So let’s see, we just did bitwise XOR.

Now we’re going to do a knot starting on line 72, I guess.

And then we’re going to do another nope there.

Okay.

All right.

So now let’s get rid of the break point at the line 70 and put it at line 78 instead.

78.

Oh man, this video is going to take forever.

Okay.

So now let’s check out bitwise knot.

We’re going to have R10.

Oh, I guess I should improve this because what I’m doing is I’m moving everything into

everything into R10 and then I’m just nodding R10 so we can’t really compare R10 against itself.

That’s not fun. Let me instead move R10 into R11 so that I can nod R11 so that we can

see two different registers at least. Okay, so let me just update my solution real fast.

move r11 r10 okay so now it stops at 75 and that one stops at 75 okay cool

now we got our breakpoint should be at line 79 not 78 now we’re ready to run it and see what the

does clear and make debug info registers so we should have r10 r11 again the formatting is a

so I’m just going to copy paste it up here. I’m going to do this, get rid of the numbers,

pad on the left for the missing zeros, and then now you can see clearly that all of the

F’s were flipped to zero. Again, that means, you know, each F had four ones inside of it,

so all those ones were flipped to a zero, so that’s why it’s a zero. Okay, so nodding, pretty easy,

this and show the next example which was gonna be let’s see seven let’s check out bitwise rotation

i’m going to copy paste all the way up to that nope there should start on line 81

i paused before i took a drink of water hopefully i reminded myself later to edit the drink of water

out i don’t know maybe you’ll be wondering why my mustache is wet right now if i did not edit it out

I did not edit it out.

Okay, so let’s check out bitwise rotation.

So I’m gonna set up R10 and 11 and 12 and 13 and 14,

all with the A pattern.

And then I’m gonna start rotating things.

So first I’m gonna rotate to the left R11 and then R12.

I’m gonna rotate by one position on R11

and then two positions on R12.

And then I’m going to rotate

rotate by one position for R13 and then two positions for R14 so we should see

some interesting patterns. The NOPE is now on line 94 so I’m gonna break there

instead whoops so I’m gonna change that and I’m now off by three it’s getting

precarious and then I’m gonna uncomment all of my little print statements to

show you the value of the registers after I rotate it so we should see like

printed in the terminal just to prove to you what’s going to happen okay so man I got to

remember what’s happening now first thing that I did was I printed r10 to show you one type of

rotation and then I printed r10 again to show you another type of rotation so we should see the

original and then the two rotated values and then the original again and then the other two rotated

values so here’s the original we’re printing it in binary with the special print command in gdb

in GDB, which is just like P slash T and then the register. So this is the original pattern

right here. And if you just kind of squint at it for a while, you can realize that the dollar

sign two pattern has been, uh, shifted once to the left. Actually, let me just make sure that

I’m doing a shift and not a rotate. I’m accidentally saying the word, uh, rotate, I think. And, uh,

that’s, oh no, no, it is rotate. Yeah. We’re going to shift later, I guess.

I guess. Okay, so we are definitely rotating. So we should see some wrap around. I guess I used

bad bit patterns for the wrap around. But just imagine that, you know, in this pattern right here,

this one, if we’re rotating to the left, this one fell off and it got placed on the right side of

of the next pattern it’s going to be the same thing basically so but this is rotation so we

wouldn’t be reusing the bits that fell off but anyway you can see that if I rotated to the left

by one position that whole thing is is kind of shifted to the left I shouldn’t use the word shift

and then for the second pattern we did a rotation by two positions so all the bits are just kind of

moved to the left compared to the very first pattern okay so no problem then the next thing

that we’re looking at is just you know rotating to the right and you can tell that everything is

offset by one here and it’s offset by two here so rotating to the left by one position by two

positions rotating to the right by one position or by two positions that’s rotation in a nutshell

okay so then the next thing that we’re going to do we’re on 94 now

um let’s see logical shifting nope nope nope I’m gonna grab some code that will shift both

logically and arithmetically so we can kind of see the difference

okay so show maybe I should change this to show some some shifting

because uh if I just say it’s logical then yeah sure uh the shift function uh the shift

those are logical shifts but then down here when it’s a sal and sar those are arithmetic shifts

I don’t know maybe maybe I can do that maybe I can just

duplicate the comment maybe to make it more more intuitive so show arithmetic shifts

Okay, I think that looks pretty good. Let me paste that into 105 on my solution so I don’t get out of sync here.

So what’s going to happen here? We’re basically going to load up R10 with a negative number.

I’ve chosen the number negative 12 because I kind of feel like it at least shows you a little bit for dividing and stuff like that.

So we’re loading up R10 with a negative number, and then R11 is going to get R10, but then we’re going to shift it left by two positions.

positions so that should be multiplying it by four but this is well a bitwise

shifting so it it’s not going to necessarily respect the fact that the

number is in twos complement so this is not a good idea if you consider r tend

to be a number because sometimes the result might be right and sometimes the

result might be wrong here it says math won’t work in my comment but sometimes

it will accidentally work but you still want to consider it to be non-working

It’s only good for bit shifting.

Then we’re going to put R12, we’re going to give it the same value as R10 and then we’re

just going to shift it to the right by two positions.

This will definitely break because when you shift to the right, the sine bit is going

to get padded with a zero rather than what the actual sine bit was originally.

So that will almost certainly break it almost every time.

Then we’re going to use arithmetic shifts which just respect the fact that the original

number is two’s complement.

two’s complement so you know like we have this negative 12 number it’s going to end up being

bits but the uh the shl and the shr instructions are not going to respect the fact that it’s

negative 12 they’re just going to consider them to be bits but the sal shifting to the left

arithmetically and the sar shifting to the right arithmetically are going to respect that respect

the fact that it’s two’s complement so let’s see we’ve got all this stuff and then we’ve got a

We’ve got all this stuff and then we’ve got a non-operation here.

You know, again, like per usual, when we’re shifting, when we’re rotating, when we’re

oaring, anding, whatever, it’s just the instruction name followed by both the source and the

destination operand.

And then the second operand is only going to be source.

So if we have a shifting left R11, then the result is going to be stored in R11, but it’s

going to take as the source R11 and shift it to the left by two positions.

to the left by two positions and so forth.

Okay.

So we have all of that.

We’re going to nope on line one of what is it?

One, one 14.

So that means I’m going to stop breaking on 94 and I’m going to break on one 14.

I thought it was four lines off and now I’m only two lines off.

I think I just did something else wrong here between my source.

Let’s see.

Is the nope on one 14 up there?

Yeah, it is.

Okay.

Guess I didn’t do that much wrong.

Okay.

Okay, so let’s run this, but this code up here was just going to print bit patterns

related to our rotations.

I don’t really want that anymore.

So I’m going to uncomment all of these other prints that relate to our shifts.

And this is going to be a nightmare to read and interpret, but I’m going to try.

I really should have written a more complicated program that can just print them in the terminal

so I don’t have to like read the debugger.

Whatever, it’s brain exercise.

size. And I think this actually is the end of the program. 119 is the last line. Yeah. Okay.

So we just need to run this and see what happens. So really we’re interested in these, uh, you know,

shifting to the left twice, shifting to the right twice bit wise, and then shifting to the left

twice, arithmetically shifting to the right twice, arithmetically. Okay. So we’ll go back to the

terminal here and quit. And then I’m going to do make debug. And now there’s a bunch of junk.

here’s the original number and then we’re gonna bitwise shift left binary

notice how it just sort of you know it shifted everything to the left and you

know we’re not using we’re not printing hex anymore because I want you to see

the binary and then you know like the patterns are just shifted to to the left

like see here’s the first one if we’re looking at the right side and then here

is the first one if we’re looking at the right side for the shifted version

A similar deal for shift right except we lost a couple of numbers there because of the display

so I’m going to copy paste both of these real fast.

Per usual we lost numbers due to the display so I’m going to say notice how we have two

numbers missing here if I added zeros on the right side that’s going to change the actual

value so I’m going to have to add them to the left and now we can clearly see that the

shifted four positions I think to the left wait did I do that where did I where did I even just

copy paste from original shift left and shift right okay so shift right is what it’s supposed

to be doing let me just double check here shift right is printing r12 and what does r12 have it

shifting right by two. Okay.

Oh, I’m supposed to compare it to the very first one.

Let me just double check that I have this correct now.

Why is it

shifting to the right? Oh gosh, I think I just lost track of myself. Let me just,

give me a second here. Or 14.

I’m forgetting where I copy and paste. Okay. Bitwise shift right is

bitwise shift right is R12, not R14. Oh gosh. Did I do it wrong? Were you cringing at home?

Maybe this will work. And the two, that’s kind of the same thing that I did before. No, no,

it’s different. Okay. So I had it wrong before. Now I finally have it right. So you can see that

So you can see that the bit pattern is shifted twice to the right and then on the left two zeros show up which would have destroyed a number.

Okay.

So we shift it to the right and now we’re ready to look at arithmetic shift to the left and right.

And let’s see do we have enough bits to actually print everything?

This one should look like it’s shifted to the right just because of the way it prints.

So that means this one is totally lined up.

Okay so let me grab the original pattern here.

grab the original pattern here so this is the original pattern and then if I go shift left

in binary I’ll just put an L here and then I’ll put shift right in binary

there we have enough bits I think in both cases so we don’t have to pad

so now if we look at the original pattern and then we shift left arithmetically twice

twice notice how it does kind of look like it survived right like this one moved over to the

left twice because the sine bits are just kind of falling off but there’s enough of them that it’s

not going to change the sine bit thank you two’s complement but when we shift to the right

arithmetically normally we would have padded on the left with zeros remember we had zeros there

on the left before but now that we’re respecting the arithmetic uh the the padding is correct now

is correct now for two’s complement so that’s why there are ones there instead of zeros

and then if you kind of look at it it’s like well we shifted twice to the right let me get

rid of the left because we already understand that now it seems to be that the pattern is uh

every bit is shifted over to the right the correct number of times the zeros dropped off the side

and um the sine bits were padded on the left so everything seems to be correct and then just to

to kind of prove to you that what we’re seeing is real, I just have the same things printed

all over again from scratch in decimal. So originally we had our R10 as negative 12.

And then if we do a bitwise shift to the left, it multiplies it by four. And so we’re accidentally

correct here. Remember, this is a bitwise shift, so it doesn’t respect two’s complement. So just,

we happen to have a starting number that would end up looking correct after we shifted it to the left.

And then when we do a bitwise shift to the right, again, this could be disaster because we’re not

respecting two’s complement or the sine bit. And that’s exactly what happened. You know, definitely

if we’re shifting to the right, that should be 12 divided by four equals three or negative three.

But instead we get this gigantic huge number because the sine bit got killed with the zeros

killed with the zeros that were padded on the left. And then we finally try to shift left

arithmetically. We end up still with negative 48, which is the correct number. If we’re going to

shift left twice, that’s multiplying 12 by 4 and that’s 48 or negative 48. And then when we shift

to the right, that should divide it by 2 twice because we’re shifting to the right by two

positions. So that should be 12 divided by 4, which is negative 3 or sorry, negative 12 divided

which is negative three so everything seems to be working except for a couple of moments of

stumbling on my part which i hope you laughed at um and i think this is the end of the program so

now hopefully you’re an expert in uh ending oring x oring nodding shifting left and right uh bitwise

rotating. We’ve done it all in this one video. How long did this video take? 40 minutes?

Anyway, thank you so much for watching this video. I hope you learned a little bit of stuff

and you had a little bit of fun. I’ll see you in 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,

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

media website that you’re looking at right now. It would really mean the world to me and it’ll

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

better videos, or just I’ll be able to keep making videos in general. So please do me a kindness

and subscribe. 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.

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

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. I’m like

It would really it really mean the world to me. I would really appreciate it. So

Again, thank you so much for watching this video and enjoy the cool music as I fade into the darkness, which is coming for us all.

Thank you.

The post x86-64 Assembly Bit Manipulation: AND, OR, XOR, NOT, Shifts & Rotates Tutorial appeared first on NeuralLantern.com.

Ever wondered why C strings are just character arrays that magically know where they end? It’s all because of the null terminator – that sneaky \0 at the end.

In this video we break it down super simply:

• What a C string actually is (spoiler: just bytes)
• Why old-school assembly needed separate length labels
• How adding a single zero byte fixed everything
• Quick look at ASCII codes for “Hello”
• Why \0 is the perfect terminator (and how to write it in code)
• How loops know when to stop reading the string
• Real example in assembly with and without null termination

Perfect if you’re learning C, diving into low-level programming, or just curious about what’s really happening when you write “hello” in C.

Introduction to Null Terminators 00:00:00
What is a C String? 00:00:11
Problems with Explicit Length in Assembly 00:01:06
Idea of a Special Terminator Symbol 00:01:24
Introduction to ASCII 00:02:20
Why ASCII is Outdated – Move to UTF 00:03:59
Example – “Hello” as ASCII Bytes 00:06:32
Mapping “Hello” to ASCII Codes 00:07:00
How Strings are Stored in Memory 00:08:46
The Null Terminator (\0) Explained 00:09:39
Null is ASCII Code 0 (NUL) 00:10:02
Escape Sequence \0 in Code 00:10:49
How Loops Use Null Terminator to Stop 00:11:55
Null-Terminated Strings in Assembly 00:12:41
Summary of C Strings 00:13:23
Outro and Call to Action 00:13:32

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

hey there let’s quickly talk about null terminators in c strings

so first off what’s a c string it’s basically just a character array it’s just an array of numbers

and the numbers will be interpreted as characters and what’s a null terminator it’s pretty easy it’s

just a a way to terminate the string so that a program can automatically determine where the

string ends in assembly a lot of times we’ll have you know a string like we’ll

say oh gosh I don’t want to write this out right now we’ll say you know my

string and we’ll define it as an array of bytes and then we’ll say you know

hello or something right and then later in order to tell the assembly program

how long the string is we’ll use an extra symbol this is not really an

My string length is going to be equal to, this is the ASM assembly by the way in case

you’re wondering, some kind of special symbol, my string length.

And then now we have defined the actual string and then the length of the string.

But this is kind of annoying, right?

We have to define an extra thing to say how long the string is.

And then we have to pass two different things that are kind of the same name later on when

we want to print a string.

But that’s not really the best way to do it.

that’s not really the best way to do it what if instead we just put a special symbol I don’t know

what should I put right now put a special zero I’ll just put like a question mark and we’ll say

that the question mark is a special symbol and then when we want to have part of our program

print the string we can just only give it the string and it can scan the string and as soon

as it sees that special symbol let’s say the question mark for now it’ll know when to stop

processing it or whatever we could allow the program to scan in advance to compute the the

length and maybe store it somewhere so we can keep using it we can allow the program to just

continuously print out characters maybe they’re buffered or something or processing characters

and then just stop when we get to the question mark but the point is it’s a little bit less work

for us to have a special symbol at the very end okay so a spoiler the symbol is going to be a zero

Now let’s look at a special table that is called ASCII.

Well, it’s not, the table’s not called ASCII,

but this is sort of like a scheme that was invented a long time ago.

I forget what this stands for.

It’s like American standard, maybe character something, something.

It’s basically for American purposes.

A long time ago, we decided, you know what?

I’d like to represent characters using one byte per character.

bits or you know a value that can go between 0 and 255 and we’ll just start assigning these numbers

to different characters so you can see here on this ascii table it’s kind of like an old thing

let me turn on my little annotator you can see on this table well the letter h is mapped

to the number 72. so this is this was arbitrary at the time now it’s a standard because everybody

accepts uh you know ascii uh in certain parts of your programs it’s kind of a little out of date

of a little out of date now because you know in the modern era it’s a lot smarter for your programs

to support a world of different characters you know for all different languages than only to

support characters that are common in english and even here there’s probably some stuff missing that

english users would probably want to add like certain accents and symbols and things like that

so you know the the letter o lowercase o it’s 111 uh the letter o uppercase is 79 so we’ve got you

so we’ve got you know a basic idea of mapping so for the purposes of this example i’m just

gonna assume we’re using ascii to make things easier okay so that’s an ascii table um

oh i guess i should say that the modern scheme that we usually use is called utf let me just uh

write that down on a notepad right now so we’ve got utf right now it’s just a different standard

but the same idea you know with ASCII we only had one byte with UTF we have a wide variety of

choices we can do UTF-8 which basically also means one byte it closely map maps to ASCII I

think all or almost all the characters will map to ASCII and then we have UTF-16 which means two

bytes or 16 bits and then we have UTF-32 which is basically four bytes or 32 bits as far as I

while. UTF-32 should be able to handle all the characters that all the languages of the world

commonly use. Just to double check, if you take two to the something power where the power, let’s

say y, two to the y, where y is the number of bits in question, then you can get an idea for the

number of combinations that you can represent. So two to the 32nd power, that’s about four billion.

I should have known that off the top of my head. That’s about four billion possible combinations.

So I don’t know.

I think in my opinion, probably 32 is enough for all symbols in the world, for all languages

in the world.

I’m not sure.

If not, then we would probably want to use UTF-64 if that exists, which definitely would

cover all symbols in the world.

But that’s really not the point of this video.

I just wanted to mention it because if you’re writing an application on your own, you want

to start your own business or you’re, you know, you’re working for someone, you probably

almost certainly do not want to use ASCII.

do not want to use ascii you probably want your database and your program to be able to use utf

16 or 32 because you want to be able to support international users and that’s not going to work

i had a website a long time ago that i wrote the database was in uh it was like latin 8 or

some scheme in the database where it was basically ascii just you know eight bits per character and i

could type characters in their native language and they were kind of disappointed and i lost a

lot of business until i realized oh i should upgrade my database and my program to support

utf but anyway the point of this video is not international character support the point of this

video is what is a null terminator and how do you use it in a c string so i’m going to get back on

Hello. Okay, so we got hello. This would basically be an array of characters or an array of in ASCII

one byte characters. So I’ll put like a number here and a number here and there’ll be five numbers.

What numbers are they? Well, if we’re using ASCII, then we should map these

using the ASCII table. So again, in the ASCII table here, what is capital H?

the number 72 and then the lowercase e that’s going to be the number 101 so i’ll just maybe do

like an arrow here the number 101 and then the capital h is going to be the number 72 and then

we got two l’s lowercase so that’s going to be this right here and that’s going to be the number

108 and then lowercase o that’s going to be the number 111 so basically you know you just go

through the characters you want to represent and map them using the ascii table or hopefully

table or hopefully an actual lookup table inside your program and then you can do the same thing

backwards you know what is what does 72 mean it means h so i’m going to erase this for now

and i’m going to go back to my little notepad here and i’m just going to fill out the numbers

so the first is going to be 72 oh actually before i fill these out hang on let me just

show you that this is basically what we’re trying to translate here so we got like an uppercase h

In many programming languages, definitely C++, which is the one I’m thinking of, we would use double quotes for an actual long string, like a proper string, a literal string, or like an STD string or something.

And we would use an array of single quoted characters to say this is one character that maps to one or more bytes, in this case, one byte.

So I’m going to say H-E-L-L-O and put them all in single quotes.

And then we’ll just sort of like translate the numbers here.

translate the numbers here. So we said the H was 72 because it was capital. It was like a lower

number. And then the E is going to be 101. And then the L is 108. We’ll do two of those 108.

And then the O was a 111. So you can imagine somewhere in an array of data in the computer,

there’s the number 72, 101, 108, you know, whatever. And even further thinking about it,

about it a little more deeply the number 72 is not actually in the machine it’s really a sequence of

ones and zeros right so just imagine that inside the machine there’s just a ton of ones and zeros

for this particular sequence you know five times eight which would be the number of uh you know

eight is like the number of bits per byte since we’re doing one byte characters um what is that

40 let me just double check here i want to make sure i’m saying things that are somewhat correct

that are somewhat correct we’ll do eight times five whoops i think i screwed something up

eight times five 40 yeah okay so you can imagine 40 ones and zeros just inside the machine

anyway so we talked about before not wanting to specify the length of a string so we’ll just

place a special marker instead of a question mark we’ll use the number zero so i’m going to put a

I forgot if I actually pointed this out or not. I’ll just do this to be sure.

Somewhere on this, you can see that the number zero in decimal, or zero in hexa, or zero in octal,

you’re welcome, you know how to do those other systems, is just considered null. So it’s sort

of a control code, or it’s not necessarily a symbol, it’s more of a control code. We’ll say

the number 72 that means h capital h but if we see the number zero that means null and in the

scheme that we’re going to use we will say that null terminates the string that’s why we call it

a null terminator so null terminators are basically just zeros that terminate the string

i could put null here inside of the the character representation just to kind of show you

other languages and we want to do single quoted characters we can usually use an escape sequence

which is just basically slash zero this is not a video about escape sequences but imagine that

every time there is a slash a forward slash and then you know one character after that then the

character will be interpreted zero for example if we just put zero by itself then that actually would

be the ascii code for zero or just the character code for zero in this particular case zero is uh

where the heck is the zero you can’t even find it oh there it is right there that’s like so the

the character zero is represented by the number 48 but that’s not what we actually want we want

the actual number zero because we’re trying to get a null terminator so anyway we couldn’t just put

a regular zero in there because it would be interpreted as 48 instead we put a slash which

tells the computer that the thing that follows is a control character so that will be interpreted as

interpreted as actually a zero or null terminator.

So now that we know how to put a null terminator in an array of characters and we know what

it’s going to look like if we’re just talking about numbers, we now know that if you have

a program that has let’s say a for loop and it’s kind of like going through, you know,

do all the characters, if it’s going through every single character one by one and doing

something to them, printing them, modifying, adding them to an algorithm, whatever.

this for loop or actually this should probably be a while loop since for loops

are kind of limited and the while loop will know when to break because as soon as it sees a

character that is actually just the number zero it’ll say oh i found the null terminator i will

now ignore this and break the loop i won’t do anything with this character because the null

is a terminator it’s not part of the string um what else you know actually i think that’s pretty

much it if you’re in assembly uh i’m just going to go back to yasm assembly for a second because i

like i like to talk about that lately and imagine we have like a string called my string and we say

it’s a sequence of bytes and i say hello you know this is how you would do this in x84 60 x 84 64

yasm assembly on ubuntu or just linux then uh you know this string right here is just a string with

null terminate with no null terminator you want to add a null terminator to the end of it so that

null terminator to the end of it so that you can write a better function that would scan your string

and print it without knowing in advance how long it was then you just do a comma zero at the end

and now you can easily write a function to scan or read or process your strings because this is

really what’s what’s happening under the hood it’s just like a sequence of characters and then it

ends with the zero and there you go that’s the basics of c strings with null terminators

this video i hope you had fun and learned a little bit of stuff 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

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 troll me if you

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.

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

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

Thank you.

The post Why C Strings End with \0 – Null Terminated Strings Explained Simply appeared first on NeuralLantern.com.

Join me as I break down a simple yet powerful x86-64 YASM assembly program to copy files using system calls! Learn how to open input files, create output files, and use a looping buffer for efficient data transfer. I’ll demo the code, explain file handles, permissions, and error handling, and even verify the copy with MD5 checksums. Perfect for intermediate assembly programmers or anyone curious about low-level file operations. Check out my other videos for more assembly tips, and don’t forget to subscribe!

Introduction to File Copy Program 00:00:00
System Calls in YASM Assembly 00:00:06
Opening Input File 00:00:17
Creating Output File 00:00:22
Using Looping Buffer 00:00:28
Assembly Program Prerequisites 00:00:37
Overview of Source File 00:00:53
Data Section and Strings 00:01:06
Copy Buffer Length 00:01:21
File Permissions Explanation 00:02:05
System Call Codes 00:02:57
File Descriptors and Exit Codes 00:03:24
Text Section and Entry Point 00:03:45
Welcome Message Function 00:04:01
Print Null Terminated String 00:04:16
Running Initial Program 00:06:26
MD5 Checksum Explanation 00:07:00
File Tests Function Introduction 00:07:28
Open File Read Function 00:09:52
Checking File Handle 00:14:00
File Handle Concept 00:14:25
Error Handling Importance 00:15:24
Testing File Open 00:23:00
Create File Function 00:31:16
Testing File Creation 00:32:36
Copy File Function 00:36:14
Stack Buffer Creation 00:38:16
While Loop for Copying 00:40:14
Read System Call 00:40:47
Write System Call 00:45:03
Checking Read/Write Operations 00:46:51
Final Program Run 00:49:00
Verifying File Copy with MD5 00:49:22
Testing with Larger Input 00:51:20
Optimizing Buffer Size 00:53:41
Conclusion and Call to Subscribe 00:54:41

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 and explain a simple program that copies a file

using system calls in an x8664 yasm assembly program

we’re going to use the system calls to open an input file and read characters from it we’re

going to use another system call to create a destination file and write characters to it

we’re going to use a looping buffer,

which should be kind of fun in the middle.

And I’m just going to do my best to explain as much as I can.

I should say though that before you can watch this video,

you probably already need to know how to program an assembly,

at least in a basic level, Yasm assembly.

And so if you don’t know how to do that yet,

this video is probably going to be confusing for you.

You probably need to look at my other videos dealing with Yasm assembly and

system calls and so forth.

So I’m just going to show you real fast what’s actually going on in this source

actually going on in this source file so far.

So this is my assembly program.

It’s not finished.

I’m going to write it on screen for you.

For the most part, you can see I’ve got a data section here and then I just have a

bunch of null terminated strings.

So I’ve got a string saying, hey, the module started.

We’re about to open the file.

We’re about to create the file.

We failed to do something.

We’re done copying.

You know, we terminated the program, you know, whatever.

Right. So I just have some strings.

No big deal.

Down here, I have something called the copy buffer length, which is which is just

length with just which is just the size of the buffer that I’m going to use

between the input file and the output file so a two byte buffer is really

inefficient it’s too small but I made it two bytes just to show to you that are

looping you know a read area is going to actually work because if I make a buffer

that’s too big if it’s bigger than the file then we won’t actually know if the

if the buffer loop works or not so I’m just gonna put two here could change

that later if we wanted to we’re gonna be reading from a file called input and

called input and writing to a file called output so that’s no big deal in order to open a file with

a system call for read mode we’re just going to use a zero as the flags that just means read mode

and then for the creation of the file we’re going to use some standard permissions this is not a

permissions video I’m going to probably release a permissions video at some later point in time

not too important right now but basically this 640 is the heart of what permissions we’re actually

what permissions we’re actually looking at.

Q is quad word.

And six just means that the owner can read

and write to the file.

Four means that anyone who is in the same group

as the file has been assigned to,

which is usually the owner,

can just read it but not write to it.

And then everybody else,

people who are not the owner

and who are not in the right group,

they have no access to it.

Just a simple security feature of Linux

for file permissions.

You can go a lot further than this in the terminal,

in the terminal, but for this assembly program,

we’re just gonna use basics.

We’re not gonna use ACLs.

I don’t even know how to do that in assembly.

System call codes.

So again, if you don’t understand system calls,

you gotta watch my other videos first,

but we have a code of zero to read from a file,

one to write to a file, two to open a file,

three to close and open file.

Probably should have put that one before create,

but I don’t really care.

85 is the code to create a file for writing,

to create a file for writing and then 60 is the code to exit from the program.

So then we have file descriptors.

Descriptor number one is a standard output.

Descriptor number two is standard error.

And it’s always one and two, no matter what program you’re dealing with.

Unless you have some kind of really crazy non-standard thing going on.

And then for the exit codes, we’re just going to say exit zero for success and exit one

for failure.

Now to the actual tech section where our instructions are in the assembly program.

in the assembly program.

So you can see section text here.

We’ve got a global entry point called underscore start.

So this is not a GCC program that requires a main entry point.

This is a pure assembly program that requires

an underscore start entry point.

Again, see my other videos for more assembly explanation.

I’m gonna call on a method,

well, not a method of regular function called welcome.

Just to print a little welcome message,

you can see right here, that’s all that’s doing.

It’s just loading, you know, a string,

sending it to standard output, and calling on a helper function that I made called print null

terminated string. When it’s done with that, it just uses the call code to exit the program.

No big deal. Nothing too advanced so far. I have the tests function commented out because I want

to write that in front of you. And if you look at what I have inside of print null terminated string,

this is not the point of the video, so I’m just going to skim it. It’s not super important.

called print null terminated string that takes in a pointer to a character array

and a file handle for where you want to print it and what it’ll do is it’ll come

in grab the incoming arguments it’s only got two arguments so it uses r12 and r13

to store those arguments and then r14 is the result of calling another helper

called string length you can imagine my string length function just kind of

scans the string until it finds a null terminator aka the number zero not the

zero but actually a zero in order to figure out how long the string is and then it can use a

regular system call to print the string to the right file descriptor so we’re going to be doing

most mostly this kind of this exact same thing when we copy the file so I’m just definitely not

going to explain it if you don’t know pushes and pops and epilogues and prologues see my other

videos crlf is just going to print a carriage return new line so it or sorry carriage return

sorry, carriage return line feed.

So that’s just like making the cursor go to the next line.

Not a big deal.

We just print a string basically.

And then I have a custom die function

that allows us to die with a failure code of one.

Oh, I forgot to mark that.

Let’s see, 206 exit fail.

I’m just gonna put that down here.

Yeah, instead of hard coding values,

it’s a lot better to use variables if you can or defines.

So all that’s gonna do is just kind of print

an error message and then exit

then exit with the you know the appropriate

Exit code which is just going to be one because this is a simple program

So CRLF print an alternated string dying string length a welcome message all this fun pretty stuff

That doesn’t really do anything except make the program more fun to look at so I’m going to run it here and make sure that actually works

Okay

Nice, okay, so if I run it you can see that the the make file system again

file system again this is not a make file video so I’m not going to show you

my make file see my other videos if you want to learn more about make files but

you can see that the assembly program says that it started and then it just

exited then the make file continues to run these extra commands that I have

set up so this is not part of the assembly program this is just taking a

checksum an MD5 checksum of the input file and then an MD5 checksum of the

what empty five checksums are i’ll probably release a video sometime in the future if you’re

interested on all my platforms just talking about why we why you would use a checksum but for now

just imagine this is a fingerprint so if the fingerprints don’t match that means the files

don’t match right now the output file doesn’t even exist so it just is an error and that’s why the

make file thinks there’s an error because the output file didn’t exist so that’s the basics

of kind of getting started with this you know bare bones program now let’s start looking at running

program. Now let’s start looking at running the file tests. So file tests, we got to make a new

method. I’m going to stick it down here. Let’s see. I got a solution up so that I don’t have to

spend too much time typing. I’m going to try my best to balance between copy pasting and just

typing very quickly. But let’s see, where’s the file test? So we got this. I’m going to put the

I’m feeling pretty lazy.

I’m just going to copy paste the whole thing.

Copy paste the whole thing.

So now this method right here is going to get called the file tests.

I keep saying method because I teach C++ a lot too.

File tests.

If we go down further, this function is called file tests.

Here’s the signature.

It doesn’t take any arguments.

It just kind of does stuff.

It doesn’t return anything.

And here are the registers that I’m going to use.

the input file handle, the output file handle, and then the count of bytes read from the input

file at any given time inside of our looping buffer reader section. So the first thing I’ve

got to do is I’ve got to open a file to read. The second thing I’ve got to do is create a file to

write. And then I’m going to copy the input file to the output file. And then I’m going to print

a message saying, hey, everything was successful. And then I’m going to close both files. Notice how

anything i’m just sort of calling other functions do the work for me again if you don’t know the

prologue and epilogue stuff or calling functions and returning you should see my other videos

but i just like to use helper functions assembly is like so unwieldy right it’s it just gets out

of control so quick and so confusing so fast so anytime you can just you know take a chunk out

of your assembly code and move it somewhere to another module or to another function

going to make your life a lot easier and make debugging a lot easier people who try to write

the entire portion of their program in just one gigantic function those are the people who usually

end up spending 10 times longer debugging for no reason at all so i believe in the power of modular

thinking so anyway what are we going to do inside of the open file read function it’s not too bad

to be honest let’s see if i can find it real quick open file read i’m going to copy paste it because

Again, I’m pretty lazy.

I’ll just explain what it is though.

So down here we need a function called open file read.

So I’m just going to do that.

And you can see the signature that I’ve chosen for this is, you know, I like to

write all my functions in C++, uh, kind of lingo or prototypes so that I can have a

better understanding of what the assembly is actually supposed to do.

So you can see the function called open file read.

I want it to take two arguments.

two arguments the first argument should be a pointer to a string that represents the file

name that i want to open and it should be null terminated again if you look back at my uh at

my strings up here they all have little zeros at the end so they are all null terminated anyway uh

so that’s the first argument that’s going to show up as rdi in assembly and then the second argument

is the flags for opening the file so i think probably that was redundant if i if i name this

that was redundant if i if i name this open file read then i think it should be obvious that the

flags are just going to be the read flags only so i probably didn’t even need to provide this

that was bad design on my part you could write a better one on your own where it’s just one argument

and if the name is read then just use the read flags but if the maybe if you want to leave the

flags in there you could just say open file only it’s up to you anyway so it attempts to open a

successful it’ll return the file handle that’s the long return type right here

long file handle if it fails then it will just basically complain and exit

the program you probably want a more sophisticated way of handling errors in

your program I just decided to complain and exit the entire program because this

is you know not supposed to be super complicated I just want to show you how

to copy files and then for me I like to leave comments that just sort of explain

And once my functions get so complicated that I actually run out of registers,

then that tells me I probably need to just make another function,

you know, split the work up in some way.

So far, so good.

I only end up reusing the same registers for multiple purposes occasionally.

I’m not a hardcore assembly programmer.

I’m just, you know, I’m like medium.

So I’m going to use R12 and 13 and 14.

That’s why we have the prolog pushing all those registers to preserve them

pushing all those registers to preserve them because they’re callee saved and then the epilogue

epilogue that just kind of pops them i’ve got a label here for the function remember a function

is just a label and then a return statement as long as you obey and respect the abi like preserving

certain registers then you should be okay first thing i’m going to do is grab the incoming

arguments so i’m going to grab the file name which is a pointer which means it’s just a 64-bit

integer i can stick that into a register and then the flags same thing so i’m going to grab

rdi and rsi the incoming arguments i’m going to stick them into r12 and r13 so the character

pointer in the flags and then i’m going to attempt to open the file with a system call so

system call is right there line 168 if you look up the table for system calls in my favorite book

that i usually recommend or any table that knows the system call codes for x86-64 assembly

call code to open a file is some number i’ve assigned that to sys open if we look up here

open is code 2 so that’s why i you know i don’t want to remember the numbers it’s bad to hard

code number so i just i just put it as a define and then the first argument that it wants in rdi

is the name of the file so i just gave it r12 i guess i probably could have just used rdi

directly in the system call but that tends to make me nervous reusing the argument registers

registers, I like to have them somewhere where they’re not going to be destroyed.

If I like, let’s say I accidentally added some code here on line 163.

If I wanted to reuse RDI and I accidentally added some code there,

then RDI would have been destroyed.

Would have cost me a bunch of time debugging my program.

Although I admit it’s not super efficient to do it that way.

Then we’re going to do the file status

flags as the second argument, and then we just do a system call right away.

register gives you the result of your system call.

Notice how we use RAX to send in the call code.

And then the system call sends us back its return result also in the RAX

register. So I’m just going to save that right away to R14.

You can see up here, it’s just the file handle.

So we can assume maybe at this point that we have a file handle sitting in R14.

You know, what is a file handle when you ask the system to open a file for you?

The operating system under the hood is just going to do a bunch of stuff to

bunch of stuff to actually open a file it’s going to go it’s going to take the string

that you sent it and it’s going to parse it and figure out you know how do i how do i interpret

where that actually is on disk i’m going to look at like the file system in the past that you

provided i’m going to look at the mount points and i’m going to figure out like where exactly on disk

does that file start and then the operating system stores that the operating system stores the file

name it stores where you’re looking at the file currently stores a bunch of stuff that you don’t

a bunch of stuff that you don’t want to have to remember you know it creates data structures under

the hood and all it’ll give you back in return is a file handle for simplicity because then later

you can use that file handle to just sort of say I would like to write some bytes to a file or I

would like to read some bytes from an open file here’s the handle you gave me previously and then

it’ll just work assuming you have a valid handle so the handle is kind of the most important part

failed because it’s a mistake i’ve said this in other videos it’s a mistake that new programmers

make or lazy programmers make uh let’s suppose for the sake of argument uh uh file open sys call

pretend we’re in c plus plus and there is some sort of an api function that we can call either

directly to the system or some person’s library and it’ll open a file for us so maybe like a

just say we call this right so i’m going to do like a little comment if inside of your program you just

call it with the you know some some path and then you assume that what you have is a valid you know

handle if you assume that what you got back is a valid handle or maybe this is not a function

just assume that the call succeeded, your program is probably going to have errors when you least

expect it. And it’s not going to look good. Especially if you release a function like this

to the public, or if you have like a professor who’s like grading your code and they are testing

to see if you’re checking for return codes and stuff like that. That’s not a smart idea, right?

Like you shouldn’t, should not, shouldn’t proceed as if everything went according to plan. What,

just proceeding as if everything went according to plan.

You want to use an if statement, right?

You want to say if the handle has some value that seems to be valid,

like for example, more than zero in the case of opening a file,

I would say probably more than two because all of our programs

always have automatically assigned file handles of zero and one and two

to represent standard input, standard output, and standard error.

But I think usually people just say like,

if it’s greater than zero, then it’s fine.

zero then it’s fine uh you know for me i might put greater than two but more than zero is fine

the point is check to make sure that it actually succeeded

do i have spell check on this thing oh god you’re all going to see my true spelling let me see if i

can get it on real fast plug-ins what how come this oh okay now it’s highlighted

If we’ve succeeded based on some kind of a comparison of the return result,

then we’ll proceed in one way.

Otherwise we’ll respond to the error by, you know, doing something else.

Somehow, like writing a log file, sending an email, complaining to the user,

doing any number of things where you can actually respond to the error.

Maybe you probably want to change your execution path.

Like if the file successfully opened, then go ahead and start writing to it

or reading from it or whatever.

But if the file did not successfully open,

want to do something else in the program and not just start trying to read from the file so anyway

super super good idea and so that’s why i’m going to implement that inside of assembly 2. so instead

of just immediately using the file handle i’m going to check it i’m going to say let’s compare

it to the number zero if we succeeded then let’s go to another label called uh read success i

personally when i’m doing branching logic i like to say open file read is the name of the function

read is the name of the function and I’ll just I’ll just uh uh append some kind of a suffix

to the original function name that way it’s it’s easier to avoid collisions when you have lots of

functions and lots of labels and things like that so I’m basically saying if we succeeded I’m going

to jump to this label which is down here and so uh this video also is not about branching logic

and and how to implement those instructions you can probably infer it by looking at my code but

it by looking at my code but you know see another video in the future for that topic anyway if we

succeeded in opening the file handle then we’re just going to say oh we were successful and then

we’re going to uh um let’s see we’re going to print the name of the file that we just successfully

opened and then we’re going to send the file handle into rax so that this function has a return

So when you open a file to read successfully, the caller will receive the file handle.

You might be wondering yourself, wait a minute, wait a minute, wait a minute.

It just gave us the file handle in RAX.

Remember, we got to respect the ABI.

Anytime we jump anywhere or call another function or call another syscall,

which a lot of these things do,

we will probably lose the value of registers that are not callee preserved.

And that’s definitely RAX.

I mean, just doing any system call like this print null terminated string function does.

print null terminated string function does that’s going to destroy rex so that’s why i saved it away

first in r14 then at the very end of the function right before i return i’m just going to grab r14

and send it into rex again respect the abi do not return data as a return value in r14 or any other

register you have to use the designated registers and in this case an integer that you’re returning

x anyway so that’s the gist of that let me go back up for a second uh so notice how

we’re we’re sort of comparing oh gosh i just i just reconfigured my annotator and i bought a

new drawpad i wonder if this is going to work ah it works there’s a bunch of stuff i added too

so notice how uh we try to open the file and then we sort of compare the file handle to see if we

off to the success area down here oh my green’s not working oh it’s tricky it’s tricky i gotta

hit it in a certain way there we go if it succeeds we go down here to the success label so we

basically at that point um totally ignore all of the fail code right we’re just like branching

around on the other hand if it fails then execution falls through because it’s not going to jump

if uh if if r14 is not greater than or equal to zero so if we fail maybe i should put this in a

red if we fail then it’s going to fall through to the next label and then the next instructions

some people like to say let’s uh let’s jump to the success label and then if not let’s jump to

the fail label that can buy you a little bit more uh i don’t know jump length if you have a giant

program but in this case i’m just going to let it fall through it saves us one jump instruction

and so if it fails then it’s going to say first off let’s print a message that we failed

to standard error if you want a refresher on standard input standard output and standard error

see my other videos and then it’s going to print the name of the file that failed so that’s this

part right here it’s going to say hey we we failed to print or sorry we failed to open this file name

for reading and it’s going to print a new line there with the crlf thing

and then it’s actually going to exit the program at that point it’s going to say all right we

failed and so the whole program just just quits and that’s my die function that i showed you

earlier it’s just going to call the system call code for quitting and it’s going to give a return

code of one to indicate to anyone automating our program including new make that well our program

failed at least it failed okay so we got all that and then we got the success and so now you kind

of know the idea behind opening a file let’s do that real fast just for fun so file tests

um oh i know what to do i’ll just comment out these uh instructions just so that we’re only

doing the file open yeah that’s pretty good and then we won’t close anything just yet

so now let me run this in the terminal real fast make run it says it successfully opened

it says it successfully opened the file input.txt

and then the program exited.

No problem, that error code one,

that’s because the output file doesn’t actually exist.

So don’t worry about that.

And let’s change the name of the input file

just to show you that it can fail and we can detect it.

I’m gonna put a two there

so that the program will try to open an input file

that doesn’t actually exist.

And then I’ll run it again.

Notice how it says fail to open file input2.txt.

And then it says terminating program after failure to open file.

And then this time, notice how the make file never got far enough

so that it tried to print the MD5 sums of the input and output files.

The assembly program just failed.

And so GNU make said, I’m not going to proceed any further.

Kind of useful when your program gives good exit codes, right?

Because then other programs know when to stop

or maybe what to do depending on what’s happening.

So I’m just going to fix this real fast.

down here and maybe the next thing I want to add is closing the files so we’ve got a function to

open a file for reading and then we have a function down here that is not implemented yet

for closing the files so I’m going to do let’s see what is r12 r12 is the input file so I’m

going to close r12 so basically this function it’s going to it’s going to take one argument

handle. So that’s why I’m giving the file handle of the input file as the first argument. And then

I’m just going to call it. So let’s copy paste close file underneath this. So I’m going to do

like some more space. And let me let me go get this from my solution close file.

And it’s going to be a pretty simple one. Really nothing much to it. I’m just going to write my

C++ prototype saying, well, it takes in one argument and it’s a handle. It doesn’t return

argument and it’s a handle it doesn’t return anything it attempts to close a

file and I’m just gonna use R12 to hold the incoming argument your programs at

home should probably be a little bit better than mine you should check to see

if the file successfully closed or not and respond in some kind of a way but

for me I’m just saying I don’t really care I already showed you that we can

check for a return value so I’m allowed to be lazy now and just sort of try to

close it and then just assume it all went according to plan so grabbing the

So grabbing the incoming arguments here.

That’s why I’m using R12.

That’s why I’m doing a push-pop pair.

And then the system call code to close is pretty easy.

You just say, here’s the code to close.

Stick that in RAX.

Let me go up real fast.

Notice how sysclose is the call code number three

on line 43 there.

So I send it the call code three to say, let’s close a file.

It only wants one argument, which is just,

what is the file handle that you want me to close?

what is the file handle that you want me to close remember before the operating system created a

bunch of stuff under the hood and gave you a file handle you can then use the file handle

to close a file read a file write to the file whatever to the file so it’s pretty easy once

i’ve set up the incoming arguments to the system then i actually use the system call instruction

syscall and then i can assume it’s probably closed at that point then a return statement at the end

like any additional thing happening.

It should just be, it said it successfully opened the file

and then it just exited.

Okay, now we’re ready to add a little bit more.

Let’s create a file to write.

So this is going to be the same thing basically

as opening a file to read,

except it’s going to be a different call code

and we’ll give it initial file permissions

rather than a read mode flag.

But then we’ll just get a file handle in return.

get a file handle in return.

And I’ve also stuck this into another function, of course.

So the file name to write line 109.

If you just scroll up real fast here, or if I scroll up real fast,

it’s a line 27 here, just output.txt.

And then the file permissions that we want to use.

I’m going to scroll up here.

That’s the second argument to the system call code.

That’s just the stuff that I talked about a little while ago where it’s like,

we want the user to be able to read and write to the file.

to be able to read and write to the file we want people in the same group to be able to read only

and we want everyone else to not be able to do anything basic linux permissions not a big deal

at the end you should probably maybe note that uh you know this q i think i might have said this

before this q just means quad word and these zeros are always going to be the same so really it’s just

like three numbers representing file permissions i’ll go over that in more detail in some other

So for now, we know that we’re going to open a file name to we’re going to open a file

for writing doesn’t have to exist yet.

We’ll give it some default permissions.

And those are the incoming arguments to the function that we’re going to call now called

create file.

When that file when that function comes back, assuming it didn’t decide to exit the program

because we failed to open the file, we will receive the file handle in our ex per usual.

And so I’m just going to stash that away real fast into our 13.

Remember R12 has the handle to the input file.

R13 has the handle to the output file.

And then, you know, for me personally,

I put that in comments to help myself remember

what I’m even doing,

because things can get confusing really, really fast.

And while we’re at it,

before we even write the create file function,

I might as well just uncomment these things at the bottom,

just to say, let’s close both files properly.

You always want to do that.

let’s copy paste the create file function let’s see I didn’t do that already right yeah okay

so let’s do that maybe like right here I’m going to go grab it from my solution real fast create

file okay about as complicated as opening a file just because I put in some some checking logic to

see if it successfully opened the file which is a good idea so here’s my function create file

arguments. Oh shoot, file creation hand. Let’s see, am I using R13? Yeah, oh, I mislabeled that.

Instead of saying flags, it should be permissions. So let me just do perms here. Long perms,

file creation perms, perm. I wish I could get a perm, if you know what I mean. Anyway, so,

you know, we just have like the file name that comes in and the permissions that come in,

And it’s going to return a handle just like we did with the read file for opening function.

But this time we’re going to do something slightly different.

So the system call is going to be the code for creating a file.

SYS create, which is not real unless you define it.

So if we just look up, I define that as.

Where is it?

Create 85.

So like right here, code 85 for system create.

Again, not a smart idea to hard code numbers.

Defines are way better.

numbers defines are way better. So then the first argument that it wants is the name of the file.

That’s the incoming argument that I took into R12. It has to be a null terminated string. It’s going

to be output.txt. Then the second argument is the file’s permissions. So that’s R13 that I took here

from the second argument, long perms. Once I’ve set up those things, I can do the system call

right away. The system, again, will try to open the file. It’ll try to create the file,

set up some data structures under the hood. If it succeeds, it’ll give me a valid file handle

in RAX, the return register. If not, then things have failed and I need to respond to that. So

I’m just going to stash the file handle in R14 right away. That’s why I’m also preserving R14

in the push pop pair that I have, R14 up at the top and the bottom.

So now we got to check whether or not we successfully created the file. Again,

logic is just opening up off a reading I’m going to compare our 14 to zero if

it’s greater than zero I’m going to assume it’s a valid file handle so jump

if it’s greater than or equal to to that label create file success I’m still

using my appending can naming convention so the name of the function is create

file so that means the success area is create file and then append underscore

success and so then I’m just gonna you know print a cute message saying hey we

successfully created the file. Yay.

Same thing that we looked at before basically.

And then I’m going to return the file handle in RAX.

If we fail, same thing that we did before when we were opening a read file,

I’m just going to complain basically to the user and then call on my little

die function to properly exit the assembly program with a

exit code of one, you know,

and I could enhance that to exit with different codes. Like maybe exit code.

Maybe exit code one means the read file didn’t work and exit code two means the

write file didn’t work and exit code three means we failed for some reason

while we were copying the data, you know, whatever you want.

I’m keeping it kind of simple.

So we got all that.

Again, this is not different than reading just, you know, the call codes pretty

much and, you know, the arguments, but the idea is the same.

So now we’re ready to uncomment.

I think we actually already did that.

We’re ready to let the program try to create the file.

to create the file and the only thing we need to add after that is the copying portion and the

successful message so let’s see if this works do clear and make run so you can see that the program

starts running here and then it says okay the module started and then it says we successfully

opened the read file and then we successfully created the output file notice how the make file

doesn’t fail when it tries to call the md5 checksum of the output file because now it actually exists

because now it actually exists if we list the program uh list the directory here you’ll see

that the out file has actually been created it just has a length of zero because there’s nothing

inside of it notice also that the permissions match what we intended the initial user can read

and write or the owning user can read and write the group can only read and everybody else can do

nothing to heck with you we could change that real fast just to show you i can get this r to

show you i can get this r to turn into an rw just by modifying permissions up here

you know giving permissions to a group uh just is a nice way of allowing multiple users

to have a shared file location you know add them all to the same group and then set that group

onto the file and then set the group permissions to allow people to do whatever you want them to

do read or read and write or whatever so let’s see where the perms i’m going to change this

So now the group people should be able to read and write.

I can’t remember if this will work because the file already exists.

Let me give it a try.

Okay.

I ran it one more time and it looks like it did not create the file because it already

existed.

So let me just remove output.txt.

There should be another system call code you could use to just check to see if a file

exists or if you wanted to be kind of hacky, you could just try to open the file and see

open the file and see if it succeeded and then close it right away.

I wonder if there is a call code for just exists only.

I don’t remember off the top of my head.

So I’m going to remove it and then run the program again.

And then we should see now.

Yeah, now that the file didn’t exist and was newly created.

Now those new permissions that we added are reflected.

So the group, anybody who’s on the group can read and write.

And obviously the group is just the same as my new user by default.

But again, you could be more complicated than that.

you were running a multi-user system

and you wanted to share folders or whatever.

Okay, so I’m gonna remove output real fast

and I’m just gonna revert the permissions to 640

so that the group really can’t do very much

except just read it.

And then if I, oh shoot.

LS, okay, yeah.

So now you can see it reverted.

Okay, so we got the out file.

I’m starting to get lost here.

I’m starting to get lost here. What am I doing? I’m supposed to copy the data, I think. So file

tests and we are copying the file. I think I just uncommented that. Really? Oh, no, no, no. I’m

looking at my solution repo. Okay. That’s what I’m doing wrong. So we’ll look into your repo or your

the copy file I was like what how did I how did that program run if I already uncommented that

and we’ll we’ll uncomment this message for now no let’s leave it until we actually finish everything

so now we got to do the copy file function so where’s that okay I’m going to copy paste this

whole thing you know what this would have been like a five hour video if I actually had to type

this by hand I can’t even remember how long it took me to write this program I think it was like

off the top of my head. So this would be a nightmare to type, I think, on video, even if I

kind of already know how to do it now. So let’s see, string length, print an alternated string.

This is close file. This is create file. Okay, so I’m just going to do copy.

File is going to be right before close file and right after create file. Okay, so copy file.

Notice the signature that I’ve chosen for this one. It doesn’t return anything. So

So that’s like not great design.

You know, I need to check to see if the copying operations inside of my loop actually succeeded

and maybe return something to indicate success or failure or at least exit the program.

But I’m not doing that right now.

I’m just keeping it a little bit more simple.

It takes two arguments.

The first thing is the input handle and the second thing is the output handle.

Conveniently, we have both of those now at this point.

And then here’s my register usage.

through r15 to just sort of grab the incoming arguments here for r12 and 13 and then

r14 grabs the beginning of the temporary buffer which i’m going to make on the stack because i

think i’m so cool instead of making it as a global in the bss section and then uh

r15 is going to hold the result from the copy operation or i guess the the write operation so

Sorry, the read operation only.

Oh, I think I’m only checking the read bytes instead of the read and the write bytes.

I’ll talk about that in a second.

So I could upgrade my program a little bit more if I wanted to.

But basically R15 is going to be my temporary variable that looks at the return value to

say, hey, did we do we read anything?

Like how much did we read?

So copy file.

This is not a video about making local variables.

So just trust me on this.

so that I can use it to save the location of the stack pointer.

Then I’m going to make a copy buffer on the stack

just by subtracting the stack pointer

because the stack grows downward in memory location numbers.

And then the base pointer is going to help me remember

where the stack was when I started.

I’m just going to say that that’s going to be the first byte in my buffer.

And I’m going to move that into R14.

And let’s see, what did I do?

Let’s see, what did I do?

Think about from the stack.

Oh, did I write like a good program or a bad program?

I feel like I should have actually saved the base pointer and not the stack pointer there.

Let me see if this runs.

If it does run, I probably have a naughty program that might self-corrupt sometimes.

And it might be a good idea to move the base pointer as the first.

Because this is not a stack video, but basically the stack grows downward.

that means you’re sort of like extending its reach you’re allocating like a free space

if i take where the stack

nope nope nope i got it right i’m sorry if i take where the stack ends up after i extend it then i

have a lower address right because it grows downward to memory if i then say that the new

tip where it grew not where it grew from but where it grew to if i say that’s the first bite in a

in a buffer then when you’re actually using the buffer you increase memory locations as you’re

filling up a buffer so then that’s going to grow back towards where the stack started so it should

be fine i think if i if i did go ahead and reverse this if i used rbp instead of rsp there then i

think i would be going in the wrong direction and just corrupting memory so just so you know

this is not a stack video but just so you know so here’s a little label again i’m just kind of

iteration label and at the bottom I’m just kind of jumping back up to that label so this is a loop

you can imagine this is a while loop maybe I should draw that for fun I gotta find more excuses

to use my drophead so this is kind of like a while loop I’ll say while true maybe and here’s like the

body and then here’s like maybe the end of the body and so this jump statement just kind of goes back

this thing’s going to frustrate me so the first thing that happens is we read a portion

of the input file into the buffer so what are we doing we’re just using another system call

we’re saying let’s use the call code for read I can’t remember what that was it might have been

uh whoops oh I cleared the dang drawing oh hang on I have undo I think wait I have that I’m gonna

Okay, I’m not going to mess with it because this will actually terminate my whole program.

One of these keys, I forgot which one, will just kill the whole annotator.

So if we go up to SYS read in the defines, you can see that it is just call code zero.

So that means I’m telling the system I would like to read something.

First argument it wants is a file descriptor for the input file.

In a different video, I showed you how to use exactly this sort of thing to read standard

of thing to read standard input from the user or from another program that launched your program

but in this case r12 it’s not going to be the file handle zero for standard input it’s going

to be the actual file handle of the file that you’re trying to read from whatever that may have

been whatever the os gave you and then here here’s the address of where to store our characters and

if you look up again we decided to remember where the first byte in our buffer on the stack was or

like a local array like oh shoot let’s do it again let’s do more drawings you have like a function

right in c and then here it’s like we declared a local variable maybe not int maybe a character

array we’ll call it a or how about b for buffer and then we just gave it you know let’s say eight

bytes or something for the buffer i think i still have it set to two bytes obviously you want to use

more bytes for efficiency but just to prove that the loop actually works i’m keeping it small like

keeping it small like I said before whoa what’s all that you see that it’s like smearing okay

that’s not good so uh anyway we remembered where the uh buffer starts and it’s going to be r14

and then the copy buffer length is being you know used here uh and I think I have that set up to uh

from the input file and we want to read into our temporary buffer and we want to read at most

this many characters and then we say system call and it does all the work for us to read that many

characters and then we want to remember how many bytes were actually read because that could be

different from the number of bytes we requested maybe we’re at the end of the file maybe the

system is having like some kind of a buffer issue or something so we just want to remember how many

this little token up there to remind myself the temporary bytes read should

go there. Notice also that when we created the stack,

this is not a stack video again,

but like I made the stack buffer equal to the length of the buffer that I

actually wanted to use. So I use the same symbol,

copy buffer length and copy buffer length.

So then it’s going to try to figure out, okay,

how many bytes did we actually read? Let me,

let me do that while loop thing again. Cause I’m, I’m feeling it.

I’m feeling it.

feeling it did i really have to write the word true especially my bad penmanship so we’re doing

while true and then i’ll just say like read you know do some kind of a call to read maybe we’ll

say n equals read like a long you know the the r15 uh register is like the number of bytes that we

actually read and then we do a comparison here so we’re saying you know if you know n is um

if it’s equal to zero then we’re going to jump to the position in the while loop where we’re

um done which is actually past the while loop if you scroll down you’ll kind of see it so i’m just

going to say break so basically if we read zero bytes then we’re done reading bytes we’re just

finished so we just break the while loop and that’s what’s going to happen here when we say

the end of the body and you’ll see that in a second so then otherwise if we’re not done that

means execution is not going to jump it’s going to just fall through to the next statement here

and that’s going to be another system call code to write to the output file and it’s going to be

very similar we just load it up with the system call code for write let me just double check

is code one and then we’re going to give it the target for output which is going to be

a file handle so you know r13 r13 right here that’s a file handle that’s where we want to

write and then the next argument that it wants is the buffer and that’s going to be r14 which

is where we just what’s going on green grain there we go i’m having issues that’s uh the

that’s uh the buffer that we just read into right so if you look here r14 green oh my gosh okay so

green we uh read from uh the buffer pointed to by r14 and then we uh we read into the buffer

pointed to by r14 and then we are using that same buffer pointed to by r14 in order to grab

R15 says how many files or sorry, how many bytes?

Green, I’m having such problems.

R15 says how many bytes do you want to write to the file?

That should be our return value from before, right?

Because we want to read a certain number of bytes from the file

and then write exactly that many bytes.

If we did more, we would be writing some junk data probably.

And if we wrote less, then we would be missing data in the output file

that was originally in the input file.

So you want to do it exactly.

in the input file so you want to do it exactly and of course i’m just doing a system call here

but like i said before your program should probably be a little bit smarter and check

rax after you write to the file just to make sure that you know how many bytes were actually written

like what if you what if you read a hundred bytes but then you wrote 90 bytes only right that would

be like a bad situation so you’d want to do some branching logic there so that if you read 100 and

100 and you wrote 90 you probably want to backtrack the position of the file by like 10.

You know just to make sure that you can actually get all of the bytes into the output file

and seeking backwards 10 that’s just another system call. It’s not in this program but it’s

not too bad. You just make another system call give it the right call code tell it how far back

you want to go no problem. So then when by the time we make it here we’re going to jump back

We’re going to jump back up to the iterate label.

Let’s see, where’s that?

Yeah, right there.

We’re going to jump back up to the iterate label.

So basically this is how the while loop continues looping.

So let me clear that real fast.

Eventually when we’re out of data to read, you know, that’s because if we try to read

and we end up with zero bytes, that means we’re done.

We’ll break the while loop.

Then we’re going to go down here.

Notice how it says copy file done.

What I was talking about before, just sort of jumping past the end of the body.

so if we are done we jump to copy file done and all it does is just restore a

bunch of registers for us and then return to the caller so copy file we have that

handled now and if I go back up here file tests I guess I can I feel bad about

this I can uncomment the success message but we probably should have done more

checking on the reads and the rights just to make sure that we actually wrote

to make sure that we actually wrote the correct amount of characters and everything succeeded

every time and if not we exit the program and only if everything went well then we print a

successful message at this point in this program the way it’s written it could totally fail and

it’ll still say that it was successful so just keep that in mind that’s bad bad for your users

okay i think we have everything that we need now i can probably just run the program and

run. Notice now, oh shoot, I didn’t even show this to you before. Let me just emphasize this

one more time real fast. So I’m going to comment out the part where we actually copy the file

and I’m going to remove the output file. Then I’m going to run the whole program again. Notice how

the two MD5 sums are different. So remember before I said that MD5 sums, they’re basically

fingerprints. They’re not actually considered secure in the modern era. I just use them because

and fun if you are interested in security you probably want to use a

modern hashing algorithm so don’t use md5 but I am but don’t but I am and it’s

basically saying the fingerprint here of input is different than the fingerprint

here of the output quickly indicating to me that the files are different so if I

list the contents of the directory obviously that’s true because the output

file is empty still but if I uncomment this part here where I’m actually

here where I’m actually copying the file then I should see that the fingerprints

match and then if I look at what’s inside of the output file it should match

what’s inside of the input file really fast let me open up a terminal and I’ll

just cat the input file so this is all I added you know why hello there add some

stuff this is definitely more than two characters so we can be sure that our

buffer loop is actually working and so I’m gonna do clear and make run and now

And now the output file, notice how it has a matching file size.

It’s got 38 bytes in there.

Same thing for the input.

And then the thumbprints or, you know, the signatures, whatever you want to call it,

the hashes, they match exactly, indicating that we probably have two identical files.

Even with MD5, even though it’s old and not considered secure,

the chances of two files kind of having random differences,

not hacked differences, but just like random differences,

and having the same fingerprint is like astronomically almost impossible so if i do

cat input oops input.txt that’s what’s in there like we showed before and if i cat the output

now it is uh the same thing why hello there added some stuff for both i could make this as big as i

wanted to just for fun maybe let’s do uh let’s do a nano on the input file

I’ll just add like I don’t even know what I’m doing I’m just going to type a bunch of stuff

oh wait what is this remember that thing that people got taught a long time ago it was like

the quick brown fox jumped over the lazy dog and this was supposed to be all the letters of the

alphabet there was an there’s another one that I just heard about and I don’t remember exactly

look it up on the internet it’s it’s pretty cool i think i need to memorize this and stop using the

lazy dog it was um something like those sphinx of quartz hear my vow or something like that

you know what i’m gonna look it up for you right now i don’t want to do the wrong thing

it’s really cool uh i’ll type brown fox and then uh

Hear my vow.

Oh, Sphinx of black quartz.

Judge my vow.

That’s what it is.

Okay, so I’m going to go back to my little VM here.

Sphinx of black quartz.

Judge my…

I didn’t even write vow correctly.

Judge my vow.

And I think that has all the letters in the alphabet too.

probably less spaces. I wonder if that’s, I mean, that’s what the internet says. If this is true,

and it has all the letters of the alphabet, that’s going to be awesome. I’m going to memorize that

for sure. Sphinx of black quartz, judge my vow. Anyway, so I’m just kind of adding stuff into

this file. And if I run, let me save that here. I’ll do a clear. And then I’ll do, um,

I’ll cat the input file here, and then cat the output file. So you can see they’re different.

again let me remove the output file just in case I can’t remember if I’m supposed

to remove it manually or if I put that into the program we’ll just try it like

this so now they match and then if I cat again the output file notice how it’s a

perfect copy of the input file nice so I think that’s pretty much everything

that I wanted to show you maybe um well maybe we can use a more efficient buffer

we can use a more efficient buffer now that it’s done the copy buffer we could change this to like

eight kilobytes or something we should end up with the same result let me run this just as is

and see if it ends up being the same thing without erasing the file first yeah it looks good let me

remove the output file and then run it one more time so make run and then uh cat the output file

yeah okay so it still works but um you know whereas before we were just using a two byte buffer

two byte buffer there’s like very little chance except maybe at the end of the file that we would

request more data than the file had but using the return value of the read operation always told us

exactly how much was read by the operating system on the other hand if we have a giant buffer we

could request way more bytes than the file could ever have because that file is way less than eight

kilobytes so again we still want to look at the return value to make sure we know how many bytes

how many bytes should be sent into the right file.

So I guess that’s everything that I wanted to tell you

about reading and writing files using system calls.

I hope you’ve learned a lot of stuff

and you enjoyed this video and had a little bit of fun.

Thank you so much for watching.

I’m going to cut the video.

I’ll see you, whoops.

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

I do hope you did learn something and have some fun

If you could do me a please a small little favor. Could you please subscribe and follow this channel or these videos or

Whatever it is you do on the current social media website that you’re looking at right now

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

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So please do do me a kindness and and subscribe

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

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 Master File Copying with System Calls in x86-64 YASM Assembly appeared first on NeuralLantern.com.

Want to master command line arguments in Yasm assembly? This video breaks down how to access and process args in x86-64 hybrid programs linked with GCC. From understanding argv and argc to looping through arguments, we cover it all with practical examples. Perfect for programmers diving into assembly or looking to level up their low-level coding skills. Check out my other videos for more on Yasm and pure assembly! Subscribe for more coding tutorials. #AssemblyProgramming #YasmAssembly #GCC #x86_64

Introduction 00:00:00
Command Line Arguments Overview 00:00:03
Yasm Assembly and GCC Linking 00:00:07
Hybrid Program Explanation 00:01:27
Makefile Overview 00:02:16
Assembly Program Structure 00:03:16
Main Entry Point and Registers 00:03:51
Accessing Command Line Arguments 00:04:26
Argument Count and Pointers 00:05:03
Loop Initialization for Arguments 00:08:57
Loop Logic and Dereferencing 00:10:52
Printing Arguments 00:13:02
Incrementing Pointers in Loop 00:14:08
Running the Program 00:15:35
Practical Application of Arguments 00:17:24
Conclusion and Next Steps 00:17:51
Call to Subscribe and Outro 00:18: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

Hello there. In this video,

I’m going to talk to you about how to accept incoming command line arguments to

an x86-64 Yasm assembly program that is probably linking to

GCC and is thus probably a hybrid program under the hood.

If you don’t know how to program in Yasm assembly yet,

check out my other videos. If you don’t understand command line arguments yet,

yet check my other videos I’m going to assume a lot of knowledge here I’m

really just going to show you how to pull the arguments inside of assembly

using using the GCC setup that they’ve given you so just a quick just a very

quick recap this is not a command line arguments video if we have the program

echo and we give it like one argument of just the word hello then it’s it’s

going to receive one command line argument in addition to its program

echo as argument zero and hello as argument index one.

And it’s just going to be able to look at them and say,

oh, the user wants me to print this hello string.

So it just prints it.

And so that’s kind of how you can tell a program what to do,

either when you’re running them directly

or having one program automate another program.

Anyway, so in our Yasm assembly programs,

how do we actually get that out?

Well, for starters, we are dynamically linking.

Sorry, not dynamically linking.

We are linking a hybrid program.

So I just want to make sure that you understand this is the right video for you.

If you’re trying to do this in pure assembly, or if you need to know that for some reason,

then you’ll probably want to watch the next video that I publish.

But for now, this is a hybrid program.

Hybrid programs, for those of you who don’t know, it just means you have modules that

are written in different source code and they’re compiled differently, different source code

languages.

So you might have a source code file that’s written in C++ another one that’s written in C another one that’s written in assembly

And you compile them all down to their own object files and then you link them together into an executable

If GCC is part of the linking process

Then it’s going to end up giving you a main function as your entry point and it’s going to make things a little bit easier

Here’s my make file. I’m just going to skim through it real fast. This is not a make file video

So if you don’t understand it go look at my other videos

But basically I’m just going to assemble with Yasm and I’m going to use G++ as the linker

and I’m going to gobble up all of the object files. Here’s like a little menu.

I have a target for running and building only. And here’s the main thing that I’m doing. This

is not really a hybrid program. This is just kind of a pure assembly program that is linked with GCC,

but you can imagine you could add other source files in C and C++ and still totally get away

GCC. But anyway, I’m just compiling one source code of assembly and,

and compiling it down to an object file right here.

And then when it comes time to linking, uh, you can kind of tell here, uh,

especially if you’re familiar with make files that I’m just gobbling up all the

object files and linking them together into the executable.

So that’s as far as I’ll go there again,

I’ve got another video that totally explains a lot more in my assembly program.

video just for pure assembly so if you don’t understand assembly see my other videos but for

now we’re just going to say i’ve got a data section it’s got a couple of null terminated strings we’ve

got a hello message a begin message a goodbye message carriage return line feed string i’ve

got the system call codes for you know printing to standard output and to exit the program and then

i’ve got the standard output file handle and then my exit code zero for success again this is all

other videos. So because I’m linking with GCC, my text section here, the actual place where the

instructions are, not the data, is going to have a main entry point. So of course, if you had a

hybrid program, you could have main somewhere else in a different module and then just call on a

function that was inside of assembly. You could totally do that. But for now, I’m just going to

say this is the only source code file. So I mark main as global and I put main right here. And then

I preserve all of the Kali saved registers that I’m supposed to by pushing them at the beginning and popping them in reverse order at the end.

And then I return a return value.

Standard assembly stuff covered in other videos.

But here’s the key for getting command line arguments in assembly.

If you recall, the ABI specifies that in x86-64 programs, the first argument is always supposed to come into a function as RDI in the RDI register.

register or rather I should say the first integer argument I haven’t talked

about to float arguments in any of my videos yet in the future you should

probably search for other videos that that explain how to do float arguments

but for now all of the arguments I’m talking about in this video are just

integer arguments and pointer arguments which is kind of the same thing a

pointer is an integer it’s a 64-bit integer but we’ll just use it as a

using it as an integer so anyway first argument comes in on RDI second argument

comes in on RSI and you can imagine that basically this is the thing you’re

probably used to seeing in your C++ programs if we do this int main and then

integer arg C and then a character pointer arg V and then an array those are

those two registers right there I probably want to change this into long

because you know rdi is in 64-bit form but an integer is an unsigned 32-bit int.

I don’t like that so I’m just going to put long. I probably should put unsigned but I don’t really

care. Anyway so we’re just going to grab those two things so obviously rdi is probably pretty

easy for you to guess how to use it’s just the number of arguments. In this program we’re going

to use it to control a loop counter that’s going to loop through all incoming arguments.

which is going to be the name of the program in this case it’ll be I think

just main is what I called it which is confusing against the entry point I

admit it but imagine that my main program that sits in the file system is

actually called program or hello or whatever so that’s the number of

arguments in RDI and then RSI notice how it’s a character pointer to an array of

characters that means it’s actually a pointer to a pointer and the reason for

every argument on the command line like for instance if i went back here and i said echo

hello let’s just do without quotes hello you i’ve given it two arguments and so when the program

launches it’s going to receive three total it’s going to receive its own program name at index zero

echo it’s going to receive at index one the first argument hello and it’s going to receive at index

two the second argument as you it prints them both so how does echo know how many arguments i have

strings. Remember argc is the number of arguments so that’s kind of easy but how does it dereference

all of the strings if there could be any number of strings? Well that’s this right here.

This whole symbol argv is a pointer and it points to an array of pointers, of character

pointers. That’s why it’s written like this like an array. So it’s a pointer that points

points to an array.

So like if you go to that location in memory,

then what you will see there for the first eight bytes

is just the address of some other memory location where a string has been stored.

Then if you advance that pointer another eight bytes for it,

you know, in memory, because all pointers are eight bytes or 64 bits,

then again, you’ll see that that value of that next eight bytes

is actually a memory location that points to another string somewhere else.

So these strings could be all over the place,

But the pointers to those strings are contiguous in memory starting with what you were given in RSI.

So it’s a character pointer pointer or an array of character pointers, however you want to imagine that.

Anyway, so we’ll grab those and then I’ll just show you how to use them down further in the code.

For starters, I’m calling on an intro function which just basically prints some stuff.

I have a custom function that I wrote called print null terminated string.

That’s not the point of this video.

I have that explained in other videos a little bit.

So it’s up to you if you want to even care.

Right now I just want to be able to print something.

And then let’s see.

So after we print our welcome message in the intro, then we print another message basically

saying okay now we’re about to start printing all the arguments.

Okay cool.

Nothing complicated at this point.

Then I have another label here with my preferred style of adding a suffix after the function

after the function that I’m currently inside of.

And I’m going to say, all right, this is where I initialize my loop.

This is not a looping video, so I’m going to skim through it kind of.

But I’m basically going to say, let’s start the loop as basically saying

the index of the argument that we’re currently looking at is zero

because we’ll start with zero.

So that means we’ll print like if we were going to, if our program was named Echo,

we would also print Echo itself and not just all the incoming arguments

that the user might have typed.

index zero and then we’re going to use r15 as the current character pointer so r15 its current

character pointer is going to be coming from r13 which was the argv argument so that means

r15 is now going to hold a pointer uh let’s see it’s going to hold

when you have an array and the array is contiguous in memory then the pointer itself that points to

the array is also a pointer to the first item that’s just kind of the way it works like if we

have 10 items and it’s an array then your pointer to that array is also a pointer to the first item

in the array if that makes sense so if r13 was a pointer to an array it’s also a pointer to the

go off to a null terminated string i know that sounds weird you got to get used to double dereferencing

here so all we really need to do to access uh the first pointer to the actual string is take the

array pointer that we have and dereference it one time so remember we’re receiving an argv

a pointer to a pointer or like a you know a double pointer if we dereference it once then we should

terminated string. Anyway, so that’s the initialization part. I’m going to start looking

at the first string here and I’m going to say we’re at index zero. And then here’s the top of

my loop. You can imagine this is a while loop. This is not a while video, but you know, there it is.

And we’re just going to ask first, are we actually done? Do we need to break the loop? I like to do

that at the top of my while loop. And how we’ll do that is we’ll say, all right, R14 is the index

the number of arguments so notice how like right here we grabbed RDI right

into R12 right away so basically I’m saying if the index we’re currently

looking at is greater than or equal to the number of arguments then we’re

actually already done remember if we’re using zero based indexing and you

suppose that you have three items in your array their indexes would be zero

So that means if the size of your array is three, like the count, like the RFC, that

means the last valid index is two.

It’s one less than the size.

You know, it’s one less than the count.

So I’m saying at this point that if we ever reach an index number that is equal to the

size, then we’ve already finished.

We do not need to look at the current item.

So I’m comparing those two registers.

You know, where are we looking at versus what is the count?

You know, what is the index we’re looking at versus the count?

If the index we’re looking at is greater than or equal to the count, then that means we’re done.

I’m going to jump out of the loop to a label called main loop done.

So then, you know, that’s down here.

Basically, we just say goodbye and then we jump to our exit function.

And all that does is it just returns from main with some kind of a success code.

You know, so just you can imagine in C++, it’s just return zero.

So, you know, breaking the loop doesn’t really do anything except end the program and say goodbye.

However, if we did not jump, then the, let’s see if we did not jump, let’s, let’s see if

we did jump, we compared it, we realized that we’re done.

Then it’s going to jump down to the, to the done.

But if we’re not done, execution is going to fall through to the next statement.

So that means we’re going to end up doing something with the current item inside of

our loop.

So what are we going to do?

We’re going to dereference R15.

was your pointer to a pointer it was your double pointer there if we dereference it once then

instead of being a pointer to an array of pointers it’s going to be a pointer to one string one one

character that starts one string so dereferencing it once means you know i put brackets around the

double pointer it’s now dereferenced once that means rdi is going to receive a pointer to one

into my function my function takes two arguments it wants a pointer to a string and it wants

the file descriptor to print to again other videos explain you know printing to standard

output but i’m just going to print the string so this part right here should actually print

the argument and then after we’re done with that uh well maybe i should change this

so that it’s a little bit more clear i’m going to maybe push this down and say

these lines up here actually do something they do the printing by

dereferencing and then here we just sort of increment along the array of pointers

and jump back to the top of the loop so what are we doing here with r14

remember r14 was the index that we’re currently looking at so we we start

looking at index 0 line 83 is going to say let’s next look at index 1 and then

this part right here add 8 to r15 that just basically means remember r15 was

remember r15 was the double pointer the double pointer like i said before it’s looking at an

array of pointers so it’s actually a pointer to a pointer if i increase the memory location that

r15 holds then it’s now looking at the next pointer it’s moving through the array r15 at

that point would no longer be a valid pointer to the original array it’s sort of like a running

pointer it’s kind of like scanning all of the pointers but a pointer is eight bytes so if we’re

a pointer is eight bytes so if we’re just looking at the first pointer and we increase the memory

location that we’re looking at by eight bytes now we’re looking at the second pointer so then on the

next iteration of the loop if we dereference then we’re going to end up dereferencing to the second

string then i just print a little new line here honestly probably should have put that up top

sloppy code i was doing this quickly and then we jump to the top of the loop so then we just

going up to the top of the loop and printing arguments and advancing to the

next pointer. And we just keep going at it.

Let me see if this works. Hopefully I didn’t mess this up while I was screwing

around. All right. So I’m going to do this make run. Okay.

So under the hood inside of my make file,

maybe let’s open the make file real fast just so you can see.

I’m just going to nano it real fast here under the hood.

So when I call the program to run, notice how I’m giving it arguments.

You can see right here on this line, or actually let me get the line numbers up.

You can see on line 48, I am calling my executable, which is named main.

In the make file, I’m using a variable, so don’t worry about that.

But I’m giving it four arguments.

And I’m just saying first arg, second arg, third arg, fourth arg.

So that’s why you see that printed in the previous screen.

screen it’s just going through all the arguments that I gave it it’s saying

first arg second arg third arg fourth arg notice how it knows when to stop

because of the argc that came in on RDI now that the program is built you know

I’ve got my main executable which I named main which I said before was kind

of confusing now that I’ve got it I can just execute it again and give it like

one argument of like hello notice how it prints hello on a line by itself you do

do it again dudes and notice how every argument I give it it just prints it no

matter how many I do I can go a b c d e f g I could probably do this so many

times that I exhaust you know a long integer which is would be a horrible

endeavor but yeah everything that I put on there it just loops through it and

prints it so when you are linking with GCC because you’re probably using a

if you’re just linking with GCC.

GCC makes it really, really easy

to access the command line arguments.

Imagine now instead of just printing these things,

you used them to somehow decide

what your program was gonna do.

Maybe the user will give you a sub command.

Like if you’re a Git user, we say Git status, right?

So the Git says like, oh, you Git launches

and it goes, you want the status of something?

Yeah, sure.

So in your program now,

you could read what the user typed,

figure out a way to parse it and interpret it

have your program’s behavior adjust to whatever the user typed in okay that’s it for this video

the next video I’m going to post is how to do basically exactly the same thing but using pure

assembly without linking against GCC so like LD is going to be the linker just like pure assembly

no extra libraries okay thank you so much for watching this video I hope you learned a little

tell your friends and i’ll see you in the next video

hey everybody thanks for watching this video again from the bottom of my heart i really appreciate it

i do hope you did learn something and have some fun uh 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

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

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

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

Thank you.

The post Command Line Arguments in Yasm Assembly with GCC: A Practical Guide appeared first on NeuralLantern.com.

Want to master command line arguments in pure x86-64 YASM assembly on Linux? This video breaks down how to access argc and argv directly from the stack, without GCC libraries. Follow along as we write a program to loop through and print user-provided arguments, complete with a visual stack explanation. Whether you’re new to assembly or leveling up, this tutorial offers clear, practical insights for coding low-level programs. Check out my other videos for more assembly tips, and subscribe for more coding goodness!

Introduction to Command Line Arguments 00:00:00
Target Architecture and Assumptions 00:00:04
Recap of Command Line Arguments 00:00:56
Accessing Arguments in Pure Assembly 00:01:47
Program Structure and Data Section 00:02:19
Stack Pointer and Argument Count 00:04:16
Accessing Argument Vector (argv) 00:07:14
Looping Through Arguments 00:12:16
Incrementing to Next Argument 00:16:45
Visualizing the Stack 00:19:24
Running the Program with Arguments 00:21:56
Conclusion and Call to Subscribe 00:23:48

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 accepting command line arguments in a pure assembly program

written for x86-64 aka amd yasm assembly

on linux anyway so uh there are going to be a lot of topics that i that i sort of mention in this

video that are not actually covered in this video so if you feel yourself getting lost like for

program in assembly in the first place.

If you don’t know what command line arguments are,

if you don’t know the terminal, things like that,

you probably want to check out my previous videos

because they will be explained in detail.

For now, I’m just going to assume you know how to do all this basic stuff.

And the only thing that I need to show you

is how to write a program in Yasm assembly that can

grab your command line arguments.

So, you know, just to do a quick recap of what I’m even talking about.

echo we can launch it with no arguments it doesn’t do anything but we can give

it some arguments we can say hello and then we can say goodbye and that’s two

arguments that I’m giving to echo echo will grab on to the arguments it was

given it’s actually going to receive three arguments the index zero argument

being the name of itself its own program and then the next two arguments being

the stuff that I typed after the program but you can see that it somehow figured

two arguments as strings and print them right so imagine you have an assembly

program and you want the user to be able to launch your program and add

arguments at the end of the command line and have your program behave in some

certain way according to what the user wants the question then becomes how do

you access those arguments it’s a little bit easier in GCC look at my other video

that I posted about the topic for GCC linked assembly programs it’s a little

You pretty much just look at RDI and RSI to get your argc and your character pointer array.

When you’re dealing with pure assembly though, the GCC libraries don’t bundle up the command

line arguments in a really convenient way for you.

You’ve got to look for them elsewhere.

It’s honestly not that much harder.

It’s just a little, feels a little weird.

I think at least for me, I was hoping to see the arguments in a register and I did not.

But anyway, so here’s my program.

Again, this is not an assembly programming video.

an assembly programming video if you need to know how to program assembly see my other videos for

now i’m just going to quickly go over it i’ve got my data section in yasm i am printing out a couple

of strings or i i have a couple of strings defined i’m saying like the module has started i’m going

to begin printing arguments i have some system call codes so that i can write just to standard

output and so that i can exit the program this is pure assembly so we don’t actually return from

we just get jumped into and then we call exit normally and then here’s the standard output pipe

again another video covers that and then i’ve got the exit success code again another video covers

that but basically you know exiting zero is usually what you do for success then i’ve got the

text section which holds all my assembly instructions and this is my entry point we don’t

really need to uh push and pop these registers because we’re just going to exit the program when

it’s totally fine we would need to preserve Kali saved registers if we were

jumping into a main function or if this was a different function that was being

jumped into but we’re not so we don’t have to anyway here’s my entry point the

underscore start for a pure assembly program and then I’m going to grab the

incoming arguments when you’re linking with GCC which we’re not doing here in

this video then the arguments come in very easily they just come in argc

up in RDI and arg sorry argc comes into RDI and the character pointer array comes in as RSI so you

can imagine in GCC this would be integer main and then integer argc character pointer array argv

right hopefully you’ve done this in a higher level language so you have a better idea of what I’m

talking about if not I guess that’s okay it will still allow you to grab even if you don’t

it will still allow you to grab,

even if you don’t understand this in C++.

So argc is actually the stack pointer.

The stack pointer register, RSP,

always tells you where the top of the stack is,

like what’s the last piece of data

that we actually have sitting on the stack.

So that’s gonna be the count of arguments.

argc is always gonna be the stack pointer.

So if you dereference the stack pointer register,

pointer register then what you’re doing is you know the stack pointer register

actually points to memory locations within the stack so if the memory

location that it’s looking at is where argc is stored then you dereference it

with the brackets and you’ll actually get argc so right away I’m just gonna

steal argc off the top of the stack and this is a good idea to do right away

because if you start doing other stuff you might end up modifying the stack

especially if you start calling functions and things like that and and

and and these these pieces of information will be lost or they’ll be a lot harder to find so right

away i’m just going to say argc goes directly into r12 and i have a little comment reminder

for myself at the top saying r12 is now argc same thing for uh r13 i’m going to say that’s a pointer

to my character pointer array i talked about this in depth on my other video where we talked about

an assembly program but basically if you look at uh if you look at argv right here it’s not just a

pointer and it’s not just an array it’s a pointer to an array and if you recall in higher level

languages or just i guess anything an array itself is a pointer because argv the symbol let’s say we

were in a higher level language argv can only point to one thing so it’s going to point to the very

but the beginning of your array is not going to be one string like one argument that the user gave

you because the user could give you many arguments instead it’s an array of pointers

so it’s a character pointer array meaning argv is a pointer to a pointer

the first item in any array is what is pointed to by the symbol so like imagine if we had just

had just for the sake of argument imagine if we had an integer array let’s say we had like 500

integers in like a c++ program so the symbol a is what i’m trying to say the symbol a

is really a pointer that points to the first integer in that array and then later of course

you can dereference that pointer with some sort of an index to get the index 5 integer or the

the array and a pointer to the first item.

Or I guess you could say it’s both a pointer to the array

and a pointer to the first item,

because it’s kind of the same thing.

So that means if we grab argv,

then we’ll be grabbing a pointer.

If we then dereference that pointer,

it would tell us where another pointer is.

And then that other pointer would point to a string

representing the first argument.

first argument so we’ll explain that more as i do this loop i’m going to i’m going to show you

some code that actually loops through all the arguments anyway the thing about where to find

that argv is it’s just the next pointer or i guess it’s the it’s the next item that the stack holds

so remember i told you that rsp when this when this function comes in rsp is a pointer to wherever

we’re we’re looking what memory location the top of the stack is so if we dereference that we get

So if we dereference that, we get argc.

Well, we just need to go find the next previous item in the stack

and then dereference that so that we can get the first pointer or argv,

you know, the first pointer to a pointer,

or the first double pointer in your array of pointer to pointers.

Why am I doing plus eight?

This might actually make sense as is,

sense as is but it’s important to understand that when you add stuff to the stack you’re actually

decreasing the memory locations uh that you are pointing to so like if i if i increase a stack

this is not a stack video there’s other videos that i have for that um if we add something to

the top of a stack you imagine the stack growing visually in a in a vertical direction like it’s

growing up right but inside of the computer the memory locations are actually going down

If we’re looking at the stack pointer and we’re adding eight, what it’s saying is that

we’re looking back into memory that was already added for the stack.

So that’s like if we grew the stack, that would be subtracting from the memory location.

So like looking further up in the stack would be subtracting from the memory location because

the stack grows upward in the abstract, but downward in memory locations.

So that means if we add eight, that means we’re going in the other direction.

that means we’re going in the other direction.

We’re looking downward into the stack.

So what that means is that the top two items on the stack

are first argc and then second, that first pointer,

you know, the argv argument.

And that’s how we access it with plus eight.

Why is it a plus eight instead of plus something else?

Because all pointers on 64-bit systems are 64-bit integers

and 64-bit integers are eight bytes.

If we’re talking about eight bytes, sorry,

if we’re talking about eight bits per byte.

So this is just how you access it.

What about this other thing going on here?

What’s this LEA instruction?

Usually you see a move instruction, right?

So we basically want to look at the stack pointer,

but look one level lower.

And each item on the stack is also going to be eight bytes.

We want to look one item lower on the stack,

and then we want to dereference it.

but we don’t want to dereference and store the dereferenced value we still want to grab the

actual pointer the thing is I shouldn’t have said dereference in the first place these are dereferencing

brackets right so like up here on line 46 when you put brackets around rsp it dereferences whatever

value rsp holds so therefore when you put brackets around this you kind of expect that you’re going

to be dereferencing right but we don’t want to dereference we just want the original address that

showing us. So the problem with this is that when we say RSP plus eight,

we can’t actually do a mathematical formula unless we’re inside of brackets, which means we

can’t do them in a move instruction without accidentally dereferencing and losing a pointer

to the actual array of pointers. If we dereferenced like this, we would just end up with,

you know, a pointer to one string. So the way around this is instead of using the move instruction,

instead of using the move instruction we use the lea instruction the lea instruction allows us to

put a formula inside of brackets so that the assembler won’t get confused but then it won’t

put the dereferenced value into r13 it’ll just put the actual value of whatever we see

with that formula meaning it’ll give us the memory location of the item sitting one under the top of

this at this point r13 is now the memory location of the of the item sitting one underneath the top

of the stack and then we can de-reference that later in order to look at all of our arguments

so the next part of our code is just going to print an intro message so there’s like this intro

string up here hello and um i’m basically going to call a custom function that i made to just sort of

Printing. Don’t worry about this code right here.

This is not the point of the video.

I just made a custom function that just kind of helped me print.

Don’t worry about that.

The real meat of this video is that we’re going to loop through all arguments

and just print every single argument that the user provided.

So you can imagine this is maybe the top of a while loop here.

Notice how, oh, I forgot to replace main with start with start.

I had another version of this program that used main.

pretend we have this is called the main loop instead of the the main functions

loop anyway so main loop initialize first thing I’m going to do is I’m going

to initialize the loop by saying we’re looking at index 0 okay no problem so

we’re looking at index 0 we want to do that we want to look at all the

arguments you know we want to look at index 0 and index 1 and index 2 and we

just want to keep going until we’re out of arguments remember that we also have

the number of arguments coming from argc now sitting in r12. So that means if we have a

counter that starts at zero with r14 and then we know how many arguments there are in r12,

we should be able to know when the loop stops. So just a reminder that, you know, the loops here,

the arrays here are zero-based indexed or zero-index based, which means, for example,

that’s three arguments but the array of arguments is going to have indexes zero and one and two

which means the last valid index is going to be two or the size minus one think about that if you

have five arguments the last index that is valid is going to be four size minus one because it’s

zero based so we can use that logic to figure out if we’re done so we start off with an index of zero

here and then at the top of the loop i’m just going to quickly ask are we done how do we know

are we done how do we know if we’re done we compare the current index we’re

looking at with the count and we say if the current index we’re looking at is

greater than or equal to the count then we know we’re already done we don’t need

to look at any more indexes why am I saying is is the index greater than or

equal to the count because remember if we have five arguments then the last

valid index is four therefore if we find ourselves looking at index five we know

already done five is equal to or greater than five, but four is not equal to or greater

than five.

So that’s why I’m using this logic here.

I’m saying if we’re done, then jump to the done label.

Basically what’s the done label?

It’s main loop done.

All it really does is it says goodbye and then it just exits the program with a system

call.

Again, I have other videos that explain system calls and all that stuff.

So if we’re done, we, uh, we jumped down to the done area, but if not, then execute

to the done area but if not then execution will fall through to this next loop or sorry this next

label which is not necessarily we don’t really need a label there but i i like to put i like to

put it there just to help myself remember this is what it looks like in terms of a while loop you

know i have like here’s the top of the while loop here’s the little comparison part of the while loop

here’s the body like the opening braces of the while loop and then here’s sort of like the

closing braces i just like to do that but anyway after we decided that we are not done and we drop

done and we drop through to the next actual instruction we’re just going to

print the next argument so what’s the next argument we will dereference r13

remember up here we took the second item sitting like you know one under the top

of the stack and we just stuck it into r13 so this is r13 is now the address of

the second item on the stack if we de-reference it then that’s going to give

then that’s going to give us a pointer to our um sorry it’s going to give us a pointer to the first

item to the first string i should say to the first string uh the f this the string of the first

argument so if we dereference you know let me say this one more time just to make sure that i’m

item, you know, the item right under the top of the stack, that’s going to be a pointer

to the first argument string.

So if we just simply dereference R13, then we’re basically telling RDI, here’s a pointer

to the string that we want to print.

Okay, so then I just call my helper function to print that string to standard output, no

problem.

And then we have to figure out like, how do we increment to go to the next string?

might have been unclear earlier because gcc does it in a different way but on the stack

every item underneath the the top of the stack is a is another pointer it’s part of the original argv

array it’s another pointer to a different string so basically if i increase r14 here then i’m

increasing the index counter that’ll help us eventually terminate but notice how here i’m

Remember R13 is the second item, you know, the item right under the top of the stack.

And if I dereference that, then I now have a pointer to the first argument string.

If I want to go one lower into the stack, then I just add eight to that register’s value.

Because again, remember, the stack grows downward in memory.

So if I increase the value, then I’m sort of like going through previous items that were put into the stack.

So imagine the stack here, it’s got like,

you know, argc sitting on top

and then underneath argc,

it’s got a pointer to the first argument.

And then under that in the stack,

it’s got a pointer to the second argument.

And then under that in the stack,

it’s got a pointer to the third argument.

Then under that, it’s got a pointer

to the next argument and so forth.

So every time we wanna go to the next arguments pointer,

the next arguments string pointer,

we just add eight to that R13 register,

which was originally just pointing at the first string.

so again why eight because pointers are 64-bit integers therefore they are eight bytes so I’m

just literally increasing the index by one and then I’m moving that register r13 to point to

the next pointer that way next time I dereference it up here on line 70 I’ll be dereferencing the

next string and these strings don’t need to be contiguous they could be located anywhere it’s

that is contiguous but it’s just full of pointers to other strings or sorry it’s full of if we de

reference the stack pointer at any point then we will get the address of a string so then we will

get a pointer to a string this double pointer stuff sometimes i get tongue tongue tired okay so uh

when we’re done printing and incrementing then we just jump to the top of the loop

And then finally, when we’re done, well, we’re done.

Let me draw this out for you, because I think the way I’m explaining it might be

a little bit unclear, so I just want to make sure that I’m being totally clear on

this, okay, so I’ve got my little annotator here and you can imagine here’s a stack

and it visually grows up.

We can imagine that every time we add an item to the stack, it grows up.

Like if you wanted to take a five, stick it on top of the stack.

Well, then it would end up on the top of the stack, right?

No problem.

Right? No problem.

Oh, maybe this needs to be bigger because of my pen size.

So let’s do it like that.

What the heck happened?

I lost the whole desktop.

There we go.

So we have this and this and this and this.

And so there’s probably some kind of a value sitting on top of the stack.

When we started the program,

RSP is a register that just has the memory location of the top of the stack,

you know, the most recently added item.

you know the most recently added item we know that this was actually arg c so if we dereferenced rsp

that’ll go to wherever rx is and get it so we can basically say that rx is sitting on the top of

the stack so you know we dereference our rsp which holds a memory location to this place in memory

we just had an integer stored an eight byte integer okay cool so then the next lowest i guess

the next highest item or the next lower item is arg v at index zero which is the same thing as

just saying arg v remember a pointer to the array is really a pointer to the first item

the next lower item is arg v at index one and so forth so we can just keep doing this we can keep

keep doing this we can keep going lower and lower and lower on the stack by adding eight to r13

because remember r13 originally pointed uh you know to this item right here i don’t know i’ll

say like r13 maybe starts off pointing uh to the first argument because that’s the way we have it

set up so every time the loop iterates if we dereference r13 then we’re getting a pointer to

when we add eight bytes to r13 we’re really just moving it down to the next pointer that we can

dereference hopefully that was a little bit more clear than what i said before or maybe you’re just

a visual learner um you know it’s a good idea to try to explain things in many different ways

but long story short we’re going down down down further in the stack to get more arguments and

we’re just printing them and so now that we’ve explained it all we should be able to just run

clear and make run and under the hood let me just show you real fast what I’ve got inside of my make

file under the hood when we do make run you don’t need to know about make files I have a video that

explains all of this don’t worry but well I mean you don’t need to know it to understand this video

but you probably do need to know it notice how when I call the executable which in this case is

I give it some arguments.

I give it just some strings.

First arg, second arg, third arg, fourth arg.

So that’s the same thing as if I typed echo first arg,

second arg, third arg, fourth arg, right?

That’s what echo is doing.

So in the make file, I’m just giving it those arguments.

And then our program now is looping

through all of the arguments.

It knows when to stop because we grabbed argc

and it knows where those strings are located

are located because the pointers to those strings are just sitting on the stack so if we deref twice

we’re derefing we’re doing a double dereference a pointer to a pointer

at least we could say r13 is a pointer to a pointer but the actual values sitting inside

the stack are just pointers to strings um so let’s just do this in a slightly different way

clear and then I’ll say main because that’s the name of the program that I

compiled you can imagine this is could be named something else and I’ll just put

hello you are super cool now so I’m giving it one two three four five

arguments in addition to main so it should print six things main hello you

are super cool now so notice how it prints main hello you are super cool now

Alright, that’s pretty much everything that I wanted to show you for the pure assembly

version of Grappin Command Line Arguments.

Thank you so much for listening.

It’s a little late for me.

The sun’s starting to come up.

I’ve got to go and eat a bunch of cookies.

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

Thank you so much for watching this video.

I will see you in the next one.

Happy studying and coding and all that stuff.

Hey everybody!

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

I really appreciate it.

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

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

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

and grow this community.

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

or just i’ll be able to keep making videos in general so please do do me a kindness and uh and

subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because i

know somebody subscribed or followed it just wakes me up and i get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could you control me if

you want to just wake me up in the middle of the night just subscribe and then i’ll i’ll just wake

up i promise that’s what will happen also uh if you look at the middle of the screen right now you

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

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for uh

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

up what’s going on you know just send me a comment whatever i also wake up for those in the middle of

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

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

cool music as as i fade into the darkness which is coming for us all

Thank you.

The post Master Command Line Arguments in x86-64 Assembly with YASM appeared first on NeuralLantern.com.

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

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

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

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

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

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

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

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

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

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

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

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

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

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

This is where the real work happens.

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

I’m going to be assembling to x86 64.

I like to out.

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

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

is going to be called a main.

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

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

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

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

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

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

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

That’s it for the make pile

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

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

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

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

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

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

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

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

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

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

We just need standard output, but not standard input.

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

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

And then the BSS section.

Actually, I’m going to get rid of that

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

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

We’re going to begin our entry point.

If you are writing a pure assembly program

and this is your entry point module,

make a function called underscore start.

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

It’ll actually just call the system exit service.

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

can call it from the outside.

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

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

This is just like a very basic pure assembly program.

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

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

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

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

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

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

It will refuse to compile.

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

And then I actually run the executable.

So only below this line that I have highlighted right now

is gonna be the actual program.

So you can see all it really did was just,

you know, print the message and then exit.

Just, you know, a little note here.

I’ve probably said this in other videos,

but the return code zero is kind of a standard

to indicate success for programs,

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

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

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

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

should consider the program to have exited in error.

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

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

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

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

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

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

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

and relinked because I changed that source code.

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

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

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

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

So I recompiled it because I just changed it again,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

It’s a go-to statement, essentially.

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

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

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

I think that it’ll crash.

Here we go.

SegFault, core dumped, oh no.

So, hey, it crashed.

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

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

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

So it should still crash, I think.

Let’s try that again.

Yep, it crashed again.

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

properly to the operating system.

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

There’s never an argument for the return statement.

You just simply return to the caller.

This uses the stack.

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

the future.

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

to get back from it.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

It printed the same exact message.

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

runs the program.

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

that same function many times.

We’ll call say hello.

Let’s say we call it five times.

This should work.

I’m going to run the program again.

Notice how it printed that message five times.

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

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

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

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

50 times,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So that’s going to be repeated.

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

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

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

we can pass as arguments every time.

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

the idea.

Maybe we will, oh, print something.

Okay.

So print something.

Maybe we’ll do the signature here.

Print something will not return any value.

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

And I’ll do a description up here.

Print a message given by a character pointer.

A pointer to a string.

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

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

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

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

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

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

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

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

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

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

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

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

Okay.

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

Okay.

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

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

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

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

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

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

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

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

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

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

RDI is the first incoming integer argument.

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

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

then the first one is going to be RDI.

So that means by the time print something gets called,

by the time we come into this code right here,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay, so we saved both of those.

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

And then when we load RSI…

Oh, that’ll be when we hit RDX.

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

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

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

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

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

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

You could either write that down

or you could consider breaking up your function

into multiple functions.

That’s totally valid

and it probably will make your life a lot easier.

Anyway, so I’m gonna say register usage

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

And then I’m gonna say R13 is gonna be

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

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

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

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

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

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

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

little reminder here.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

register values should appear to be untouched to the caller.

Remember these registers are not local variables.

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

So every program that runs every function that gets called,

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

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

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

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

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

and we will preserve the R13 with another push.

We then have to restore them.

So right now when we do this push,

that just means that whatever value R12 and R13 had

is going to go to the stack.

So we’re going to hit memory.

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

We’re going to push it onto memory

in order to preserve the value.

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

And then right before we return,

we’ll just pop those values.

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

We’re going to go to the stack.

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

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

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

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

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

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

and the R12s are on the outside.

That logic would persist if we pushed,

or if we had to preserve more Kali saved registers,

if we were using more stuff.

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

will return data to you backwards in the reverse order

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

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

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

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

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

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

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

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

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

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

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

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

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

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

load up the argument registers and call print something.

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

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

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

I’ll double check the book after this.

And what do we want to do?

We want to basically, inside of say hello,

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

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

length from the global variables.

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

This still ends up being three lines.

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

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

So it’s like slightly faster to do.

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

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

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

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

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

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

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

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

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

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

something function.

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

we’re ready to go.

Let’s see if this works.

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

Oh, that was so fast.

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

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

and then don’t do anything.

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

anything because it was too fast.

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

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

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

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

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

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

Boring, sorry.

And we’ll do a crlf there.

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

Okay, let me just finish message one length,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So, so CRLF and then length.

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

because it’s going to be a function.

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

known as CRLF.

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

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

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

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

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

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

So let’s test that out.

I took the CRLF off of message one.

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

Now, what did I just do wrong?

On number 28 and 29, instructions expected after label.

I guess I forgot to complete something.

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

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

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

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

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

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

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

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

I don’t know how you feel,

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

I would probably be a little irritated.

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

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

to try to make this as compact as possible.

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

So we print the message.

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

So great works.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

We can get rid of this system call code here.

Probably a good idea at this point.

And then we just say print hello string.

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

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

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

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

Lion 61, forgot to update the symbol name.

Oh, there we go.

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

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

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

to my advantage.

Okay, so we got that working now.

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

How about three?

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

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

Message three.

This is message three unless I got that wrong.

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

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

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

message.

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

All right.

So then I’m going to do that again.

And then all three messages get printed.

Nice.

So now one more thing.

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

Again, this will not cover floats.

This does not show you how to return floats.

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

That’s going to be a different video.

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

that is the register that is designated for return values.

So what about this?

Instead of just returning the exit success code

that I’ve defined up above,

we’ll return whatever some function call gives us.

Maybe I’ll make another function down here

and then I’ll say a function

that just returns a simple long value.

And we’ll call this function gimme long.

We’ll call this function gimme long.

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

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

RAX to be loaded up.

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

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

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

or defines and hit memory only if you need to.

And try not to hard code immediate into your code

if you can possibly avoid it.

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

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

But I’m gonna just hard code something here.

No, I always second guess myself.

I’m gonna say exit gimme.

I’m gonna define something up here.

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

for the gimme.

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

About 33, I don’t even know.

So we’re defining exitGimme as a symbol

to just be a replacement of just the number 33.

So down here, I’m going to say,

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

Nice, okay.

And so that means it’s the official return value

once you call gimme long.

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

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

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

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

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

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

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

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

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

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

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

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

I’m going to push R12.

You should probably even preserve registers in the start function

because something might, or in your entry point,

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

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

to have a main entry point within a hybrid program.

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

and then pop R12 at the very end.

Pop R12.

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

because by the time we get there,

it’s gonna exit the program.

I’ll do this here.

I’ll just try to be a good citizen.

I’m not actually sure if we need this

for a pure assembly function,

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

And what is it gonna cost you?

Just a touch memory,

just one time right before the program exits.

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

Okay, so epilog,

probably I might be showing you bad practice

by preserving things in the underscore start function.

But again, you will definitely wanna do this

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

So we do prolog R12, epilog R12.

I made a comment there.

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

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

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

but I think it’ll be okay.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Try it out.

Try to do something different.

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

at least the entry point for start.

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

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

still have to preserve.

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

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

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

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

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

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

I really appreciate it.

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

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

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

that you’re looking at right now.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

which is coming for us all.

Thank you.

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

Ready to master x86-64 assembly? This video breaks down system services, showing you how to use syscalls to print messages, handle file descriptors, and exit programs cleanly. We’ll walk through a real assembly program, explain key concepts like standard output and file handles, and share tips from a top book on the subject. Whether you’re new to assembly or sharpening your skills, this tutorial is packed with clear examples and practical advice. Subscribe for more coding deep dives, and check out our upcoming file I/O video! #AssemblyProgramming #SystemCalls #x86_64 #CodingTutorials

Introduction to System Services 00:00:00
System Services in x86-64 Assembly 00:00:04
Recommended Book on Assembly 00:00:35
What is a System Service? 00:01:01
Example Assembly Program 00:01:21
Syscall Instruction Explanation 00:02:52
Standard Output and File Descriptors 00:04:01
Printing a String with Syscall 00:05:16
Exiting a Program with Syscall 00:07:21
Exit Codes and Program Success 00:08:02
Book Reference for System Services 00:09:51
Detailed System Write Service 00:11:01
Checking System Call Return Values 00:12:08
File Operations with System Calls 00:14:35
Closing Files and Best Practices 00:15:50
Other System Call Codes 00:16:43
File Permissions and Modes 00:17:20
Handling System Call Results 00:19:03
Future Video Plans and Wrap-Up 00:20:40
Call to Subscribe and Outro 00:21:28

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 we’re going to talk a little bit about system services

in an x86-64 machine while programming in assembly

this video is going to focus on yasm assembly but this should also work for any other assembly

language that you program as long as you have the right kind of cpu x86-64 is also known as

that in mind okay so for starters let’s see here’s a wonderful book i love pushing this book i did

not write it the person who wrote it is a genius it’s called x86 64 assembly language programming

with the boot to it’s a free and open source book so anybody can go get it find his website

and here’s the version i’m using and honestly a really old version of this book is still really

good he just keeps you know making little improvements but it was it was good even a

even a long time ago. Anyway, so what is a system service? For starters, before I go into this book

a little bit more, what is the system service? Suppose for the sake of argument that I’ve

already written an assembly program, a pure assembly program, not a hybrid module program

or anything. If you want to learn assembly, see my other videos, but for now I’m just going to

assume you kind of already know how, so I’m just going to open up a pre-made program here.

I’m going to do nano so I can edit the assembly file just so you can see what’s inside of here.

just so you can see what’s inside of here.

Okay, so I hope the red is not too hard to see.

Oh, the tabs got ruined on Nano.

Hang on, let me see if I can just open this up in Genie.

Should have done that to begin with, okay.

Yeah, okay, I wrote it in Genie

and I guess I don’t have the tabs set up in Nano very well.

Okay, so here’s like my assembly program.

You know, I just have a little string here

string length and CRLF for like a line feed and some file descriptors and stuff

that I talk about in other videos here’s the entry point of the program just like

a little start entry point because it’s pure assembly and all I’m gonna do is

I’m gonna print a message right I’m just gonna print a little hello message and

then call on CRLF all CRLF does is just it just prints a new line so the program

if i run it right now you’ll just see what happens if i say let’s see clear and make run

then you can see there’s some stuff happening up here in the make file which i forgot to update

the title ignore that basically the real action is this line right here hello i’m printing using

a system service if you already know assembly then you have probably already seen this before

and it seems a little boring that’s good but i just want you to know that we’re using a system

system service to actually do the printing.

Kind of take it for granted here.

This little instruction called syscall.

What is a syscall?

Well, it’s just basically you set up some variables, some,

some codes, some data, whatever in, in some special registers.

One of the registers lets the system know what you want it to do.

One of the registers is like, or I guess all the following registers

if they’re needed, are just input to the system call that you’re trying to do.

do so in this case rax is letting the system know i want you to do this this code i want you to do

this certain thing i have a defined set up here called system right but if you look up in my

little defines area it’s just a number one so that means if i set the number one in rax i’m letting

the system know that i want it to write to some pipe to some file then you know depending on what

code you’re using rdi rsi rdx and other things may be needed or maybe not be needed at all

in this case when i’m writing somewhere it wants three arguments so i have to use rdi rsi and rdx

because those are the three arguments the first argument that it wants is where to print

see my other videos for a more in-depth explanation of file descriptors and pipes but just long story

pipes standard input standard output and standard error standard out is a pipe

number one let’s see where’s that yeah it’s just assigned a number one so

every program has its own number one pipe which is just standard output and I

guess I should say that it gets piped to file descriptor one it’s kind of like an

ambiguous term sort of but the system right call will write data to a file

file and if i give it a file handle of just one that lets the system know oh actually i want to

write to this standard output for the one particular process that we’re inside of but

you could open any file that you want and get like a file handle to it and the operating system will

realize oh you know i i associate that file handle i gave you with this certain open file that you

created or opened for reading or whatever um and so when you give the handle back it knows where

knows where to write. So in this case,

it’s treating the standard output just like a file,

just a file with a special handle of just one.

I’ll talk about that more in another video.

Then the next two arguments it wants is just the,

a pointer to the first character of the message that you want to print.

And then just an integer representing the length of the message that you want

to print. And if we just look up here again at my little hello,

my hello symbol points to an array of bytes, just characters.

bytes just characters there is no null terminator on there it’s just bytes only

and so when I give it you know message hello by itself what I’m really giving

it is a pointer to that H letter just a pointer to the memory look you know I’m

pointing to the memory location of the very first character in that string and

then for the length I’m just using a special token little shortcut thing

where you just put a dollar sign minus and then the name of another string and

and then the name of another string,

and then the assembler will compute the length of that string.

So this right here is the same thing as me

just typing the exact length of the string.

I don’t even know what it is.

I don’t feel like counting it.

You can at home if you want.

One, two, three, four, I’m not gonna do it.

Anyway, so we basically just say,

you know, I would like to write somewhere.

I would like to write to the standard output file,

file handle, I would like to, you know, to that pipe.

I would like to write, you know, this string,

you know this string and then i would like to tell you that this is how long that string is

and then after you set all that stuff up you just say system call and the system will go ahead and

do all of the hard work for you it’ll go figure out how to actually write data to the file and

you know figure out how to do everything that it’s supposed to do and all you have to do is

a little system call here right after this you can see that i have a call crlf that’s just a function

call i talked about functions in other videos but basically you know i’m just calling a function here

you know i’m just calling a function here and it does the same thing it makes a system call but

instead of printing the hello string it’s printing my crlf string and if you just kind of look at what

my crlf is it’s just these two characters 13 and 10 so like you know slash r slash n for carriage

return line feed that’s why i call it crlf so all this program does just print a message and then a

new line and then at the very end it does another system call to properly exit the program if this

hybrid program and I had like the entry point of main, you know, that the GCC libraries give you,

then I would probably just want to return at the end of this function. But since this is pure

assembly, I can actually just exit the program and be fine. So exit with success is a different

system call code. Notice how I have the symbol system exit loaded into RAX. And if you look up

here, system exit is just the code 60. So if I send a code of one into RAX, that means I want to write

a code of 60 somewhere that means i want to exit the program the only argument that takes is rdi

which is just what is the exit code that you want to return to the operating system so um

if you recall from some of my other videos let’s see if we do echo hello echo always succeeds at

least as far as i know there’s like it’s like really hard to make it fail if i echo hello then

the program echo launches and it will succeed by just printing the word hello like see how it just

like see how it just does that so that means after that command i could echo the special

variable dollar sign question mark just to see what the echo command exited with right it should

be a zero because it succeeded so you can see now a zero under the hello on the other hand

if i concatenate um let’s say a file that exists i should also get you know an error code that is a

So it’s a zero at the very end.

But if I try to concatenate a file that doesn’t actually exist,

I’ll put a OS release two because that doesn’t exist.

Notice how the cat command fails because it couldn’t find the file and the exit

code is a one.

So all you’re doing when setting RDI here is just controlling what exit code you

want your program to exit with.

This isn’t very convenient for a human running a program.

Maybe if you want to look at the exit code for some reason, but this is really,

really convenient for programs that want to automate other programs.

programs just keep in mind if you have a program that is executing another

program and it wants to see if that program succeeded the exit code is one

of the easiest ways to find out if the program succeeded so this is the whole

idea of this entire program we’re just using two system calls to print

something and then to exit the program hopefully this makes sense and now I

want to go show you this wonderful wonderful book if I didn’t already say

If I didn’t already say this before, sorry if I already did.

This book is written by a genius.

It’s called this.

Here’s the guy who wrote the book.

And here’s the version that I’m using, but old versions are good.

You can get this book for free on his website if you go find it.

So I’m just going to go to this assembly book, which deals with a lot of Yasm assembly tips

and tricks and tutorials and explanations and things.

And I’m going to go to the section labeled after system services.

So for me, this is a chapter 13 system services, just to give you a little explanation of what

this is.

You know, this is basically what I said.

It gives you, you know, a chance for your application to ask the operating system to

do something for you that you don’t want to program from scratch in assembly or that you

can’t program.

But here’s the real juicy details here.

If we go to, yeah, yeah.

Okay.

C, which is section 23.0 system services.

There’s a whole bunch of system services in here that you can, uh, that you can read about.

So for starters, if we go down a little bit, notice how it says basic system services.

If we go down a little bit, you can see right here, the system write service that we’ve

been using in the sample assembly program.

You know, when we’re just printing, we say code one is to write something.

And so this is what the table says.

you place inside of RAX before syscall.

Call code 1 is going to be to write characters and then it tells you what arguments it needs.

So like RDI is the file descriptor where do you want to write to.

Just like I said before you could give it a file handle that you already received from

opening a file or creating a file.

Or you could give it 0 or 1 or 2 if you want to try to write to one of the pipes although

actually file descriptor 0 is standard input I don’t think that would actually work.

zero to reading if you wanted to read the user’s input or or you know any input that that program

was given through its standard input rsi is just the address of the characters to write like we

talked about before and then rdx is the count of the characters to write notice how there are no

more arguments and that’s why i only gave it three arguments besides rex notice how it says here if

unsuccessful it returns a negative value if successful it returns the count of characters

count of characters actually written this is a really really good idea if you think about it

um a lot of new programmers they don’t really look at return codes when they call system services

or built-in c functions or built-in c++ functions they just kind of call it and hope for the best

but imagine if you uh if you try to write a huge long string in uh using system write call code one

and maybe some of the characters did write but the system decided to only write i don’t know half for

reason maybe it ran out of buffer maybe you know it interrupted you know your right or something

like that so it could happen what that would mean is that the return value it would be greater than

zero indicating that some characters were written but it’ll tell you exactly how many characters

were written so you’ll know that you got to keep calling the sys call until all the characters were

successfully written why would you do this i don’t know maybe you have a gigantic string like maybe

like a several gigabyte file and you wanted to copy it to another file so you’ll be calling

system write over and over again and system write it’s only going to write so many bytes at the same

time so you use the return value to figure out how far forward in the read buffer you need to advance

or you know whatever so that you can well write the entire complete file or the entire complete

string or whatever it is without any gaps without it being truncated and so forth and then of course

And then of course, if it returns a negative value, then it totally failed.

Like you tried to write to a bad file handle, like standard input or a file handle that

was closed or a file handle that was open for reading only, something like that.

And then you can use some if else, you know, branching logic.

I mean, not if else in assembly, it’s just going to be comparison and conditional jumping

or branching.

But you can have more control over your program, right?

Because you want your program to be able to respond to errors.

Let me just quickly cruise through all of the other options and let you know that

and let you know that in another video I’m gonna do a full tutorial for how to

copy one file to another by opening one file for reading and then like using

system calls to read from it and then open another file for writing and then

you know use system calls to write to it and I’m gonna do that looping buffer

stuff that I talked about before anyway so but for now I’m just gonna go through

the rest of these system call codes let’s see so first off we got open well

Well, if you want to open a file, then you just give it call code 2 and you pass in the

address here, you know, RDI, you say, here’s the address of a null terminated file name.

So that means somewhere in memory, you have to have the file name that you want to open

with a null terminator, like a zero at the end of the string, either the full path or

relative path to wherever the program is currently running.

And then RSI is going to be file status flags.

And what does that mean?

And what does that mean? We can actually just search for that.

I’m going to say control C to copy,

and then I’m going to do control F to search for that.

And let’s see what page of mine right now, 340.

If I go down to the search results for that,

it just explains what the file modes are. So if you put value zero,

that means read only you’re opening the file and read only mode value one.

That means a write only a value to allows reading and writing to the file.

So if you don’t know what that means, well, there it was.

What was I just on before?

40?

Oh, gosh.

Completely lost my…

Oh, yeah, 40.

Okay, so opening pretty easy, right?

Like if you didn’t know this before, you didn’t necessarily read me.

You could just look at this table and go, what do I want to do?

I want to open.

So here’s the code.

Here’s the address that it needs.

When you’re done opening a file, when you’re done working with a file,

you want to close that file unless the whole program is going to terminate.

unless the whole program is going to terminate at that point you i mean maybe you have a function

that gets called somewhat often and you kind of always have to open a file and sort of look at

something or write something and maybe you want to close it when the function is over right you

don’t want to have a file handle just open forever that’s a waste of memory and it might introduce

bad behavior to your program if you just have a bunch of file handles floating around that you

forgot about so it’s proper to close a file when you’re finished with it that’s just going to be

and it only wants one argument.

It just wants the file descriptor of the file that you wanted to close.

So if you open a file for a reading or to create it,

you get a file descriptor back.

You should probably hang on to it somewhere on the stack

or like in a global variable or like, you know, in a register or whatever.

Then when you’re done doing something to that file

and you’re sure that it’s time to close it,

just give that handle right back when you call code three to close it.

Then you can sort of like seek, you know,

forward and backwards to the file if you want to.

You can fork the current process.

You can fork the current process that’s kind of advanced for this video.

You can exit.

Remember before we exited from that program with code 60.

So that’s it. Call code 60.

If you didn’t watch this video, you could have gone through this table and just said,

Oh, you know, I want to terminate the executing process.

I do a system call with code 60 and I’ll give the exit status to RDI,

which is typically zero for success.

Bunch of other stuffs create, get the time of day,

and then the file modes that we talked about before.

we talked about before and then file permissions. Let’s see, where’s the permission. I think it’s

when you want to create a file. Yeah, right here. If we wanted to create a file, that’s code 85.

RDI is the name of the file, you know, like a pointer to the string. RSI is the file mode flags.

And then you’re thinking like, what are the file mode flags? Just go down here and then here you

go. All the file modes that you could ever want. You just look at it and go, well, I guess I can

I guess I can just copy paste this number right here and it’ll end up being, you know,

whatever is described on the left and the right.

Like the group has read, write and execute permissions and so forth.

I mean, really, if you look at this long enough, you’ll kind of realize that this is a quad

word because it has a Q on the end of it.

And the rest is just an octal file permissions notation where this first number here, notice

how the first two are zeros, but this first actual number here is something that applies

to the user and then the next one applies to the group the next one applies to others who are not

part of the user or group and this video is not about file permissions I’ll probably make one

later if I think people will actually watch it but yeah you can just kind of like look it up here if

you want to and just copy paste that into a define somewhere let’s see what else I just want to show

you a little code snip just to illustrate a little bit more what I was talking about before

for. People usually make this mistake, they’ll do see this is what people will usually do like new

programmers. Suppose this is a function pretend we’re in C or C++. For the time being, you call

some sort of a system function or an API of some other library. And you just you just hope that it

works, you just call it and then your program continues underneath, right? It’s a bad idea,

because maybe that failed, maybe there’s some action you need to take. So instead, it’s a really

really good idea to check the return result or i should say an even better idea is check the

documentation usually these types of you know c system calls or function calls or api calls or

whatever they’ll return something indicating success or failure sometimes the documentation

will tell you oh you’ve got to put like a pointer to some other data structure in the arguments

and then the result comes there of course just read the documentation but usually it’s just

So you want to grab the result and then check the result.

In this case I’m assuming this is sort of a standard function that will return zero

or greater on success like the system write call or the system read call and return less

than zero if it fails.

So here I’m just responding, you know, if it’s like if the result was greater than zero

then it’s like, yay we can proceed.

Maybe I’ll continue with my program in some way and if it’s not then I’ll print a complaint

then I’ll print a complaint to the user and then I’ll take some sort of an action

like I’ll write to a log file, send an email somewhere, you know,

do something to try and recover from the error and alert admins to the error.

And in this case, I’m just throwing an exception.

This video is not about exceptions, but so I just want you to know,

this is a good design pattern to not just discard the result of a call to

something. You should check the result and see what you’re supposed to do.

Let’s see, what else did I want to tip?

system services, file handles.

Yeah, okay, I think that’s everything that I wanted to tell you.

In future videos, I’m going to talk about, you know, some of this stuff much more in-depth,

like with my file.io video that I’m going to publish pretty soon, which is, you know,

it lets you read and write to files, and it uses a loop to read a little bit at a time.

Okay, thank you so much for watching this video.

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

I’m outie.

Or something.

Goodbye.

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 joy

that’s exactly what happens every single time so you could do it as a nice favor

could you control me if you want to just wake me up in the middle of the night

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

also if you look at the middle of the screen right now you should see a QR

code which you can scan in order to go to the website which I think is also

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

website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and if

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 music

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

Thank you.

The post Mastering System Services in x86-64 Assembly Programming appeared first on NeuralLantern.com.

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

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

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hi there!

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

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

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

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

have seen a segfault.

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

Segments used to be really, really important.

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

I’ll just talk a little bit about them.

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

just because even in higher level languages,

your languages will typically be compiled down to assembly

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

So if you’re not interested in Yasm Assembly,

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

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

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

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

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

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

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

Perhaps actually this is not the best editor.

I don’t know why I pulled this up.

Let me get Gene here.

It’s a little bit better.

Gene.

There we go.

Maybe I’ll save it somewhere.

I’ll say segments assembly.

And then now the comment gets highlighted.

Okay.

So in assembly in the ASM assembly,

we denote various segments by using the section keywords.

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

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

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

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

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

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

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

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

Think of higher level languages.

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

everything else a local variable or a member variable.

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

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

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

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

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

Sorry, sorry, DW would be for a word.

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

So here quad word is eight bytes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Or say if you have another function in another module,

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

we could say, you know, my other function.

Something like that.

Just mark it as global.

Or sorry, not global.

Extern.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

stack pointer and then decrease the stack pointer.

It doesn’t really help a whole lot.

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

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

But just keep in mind that the stack

is where local variables are stored

and you can use it in assembly and C++

and other higher level languages.

You can even make virtual stacks

in any type of program almost

to just sort of have a stack like structure.

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

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

And the stack tends to have a fixed size.

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

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

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

like its return address.

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

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

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

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

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

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

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

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

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

functions without ever returning, you could overflow the stack.

So that’s not good.

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

Oh shoot.

Did I actually make this?

Where is the, it’s on the desktop.

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

Let’s do a stack overflow.

Let me do desktop here.

Let’s do stack overflow.

That’s CBP.

I’m just going to make a quick program.

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

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

I’ll make a function called F.

And F just calls itself.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay, well thanks for not warning me.

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

We just made a stack that was too huge.

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

You can definitely overflow it.

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

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

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

well, maybe, well, what do you think?

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

The heap is where you allocate dynamic data.

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

you’re creating like a dynamic allocation of data.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I’m probably about to crash this computer.

So maybe this video won’t finish recording.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So maybe the start offset is 1000.

It’s like totally unrealistic, but just pretend.

The start offset is 1000.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Thank goodness.

Or the whole computer would have been down.

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

But you can see it spiked, right?

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

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

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

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

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

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

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

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

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

Whereas the stack will crash a lot faster.

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

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

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

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

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

Okay.

Thank you for watching this video.

I will see you at a later date and time.

Hey everybody.

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

I really appreciate it.

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

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

as you do on the current social media website

that you’re looking at right now,

it would really mean the world to me

and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos,

longer videos, better videos,

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

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping

in the middle of the night

and I just wake up

because I know somebody subscribed or followed.

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

That’s exactly what happens every single time.

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

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

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

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

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

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

and all that good stuff and

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

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

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

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

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

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

Thank you.

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

Ready to dive into x86-64 assembly? This beginner-friendly video breaks down CPU registers like RAX, RBX, and more in Yasm assembly. Learn how to use general-purpose registers, respect the ABI to avoid debugging nightmares, and optimize code by minimizing RAM hits. We’ll cover callee-saved registers, function arguments, and why you shouldn’t mess with the stack pointer. Perfect for coders looking to master low-level programming. Grab the free book mentioned and subscribe for more assembly tips! #AssemblyProgramming #x86

Introduction to Registers 00:00:00
x86-64 Yasm Assembly 00:00:04
Recommended Book 00:00:09
Move Instruction Example 00:01:04
64-bit Registers Overview 00:01:52
General Purpose Registers 00:02:24
Two’s Complement for Integers 00:03:37
Floating Point Registers Introduction 00:03:54
ABI Importance 00:04:55
Function Return Values 00:08:01
C++ to Assembly Translation 00:08:43
Avoiding System RAM 00:11:45
Optimizing with Registers 00:13:04
Callee Saved Registers 00:14:16
Preserving Registers with Push/Pop 00:16:40
Stack and Local Variables 00:22:00
Function Arguments in Registers 00:25:12
Stack Pointer and Base Pointer 00:31:29
Instruction Pointer (RIP) 00:36:30
Temporary Registers (R10, R11) 00:36:49
Accessing 32-bit Register Portions 00:38:29
Floating Point Registers Details 00:42:53
Conclusion and Call to Subscribe 00:45:35

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hello there.

Let’s talk about registers in assembly.

More specifically, x8664 Yasm assembly.

Okay, so first off, check out this book.

It’s a wonderful book.

The author is a genius.

It’s called x8664 assembly language programming with Ubuntu.

It’s free.

website and you know grab your copy it’s wonderful it’s released under a copy left license

author’s a genius whenever i’m trying to remember things about cpu registers for assembly

i always go to this section i say callie saved i search for callie saved i already had it there

callie saved and it ends up being section 12.8.2 register usage so before we do that let me just

that let me just give you a little quick example so you kind of know what I’m

talking about here hopefully everybody’s seen this instruction by now this is a

move instruction in Yasm x86 64 assembly it just moves data from one place to

another it takes two operands so you know we have like operand one and

operand two basically operand one is the destination operand so we could put

destination there if we wanted to operand two is the source we could put

that actually won’t, you know, compile or assemble,

but I’m just saying that’s what those positions are for.

So here’s an example of a register receiving the value 10.

We use the move instruction and we say,

we would like to move something into the REX register.

We would like to move the value 10 into the REX register.

And there you have it. There’s a move instruction. Okay.

So REX is a register.

that it is a 64-bit register in our 64-bit CPUs every single register or

sorry every single general purpose register and the plot registers they

have 64 bits available for us to use 64 bits like you know ones and zeros it’s

like a very very very big number a long time ago we had 32 bit registers and so

these are like you know twice as mathematically robust or whatever you

allows the registers to address, you know, the 64 bit memory addressing space,

which helps us go beyond four gigabytes of RAM in our modern computers,

helps us go far beyond what we can even achieve right now.

So we have a register called RAX and there’s a list of other registers on this

page here. So basically, you know,

we have the RAX register and the RBX register and the RCX register and so

forth. I have a hard time remembering all these names,

remembering all these names so I go to this book when I forget but otherwise

you know you can kind of think of like ABCD and then just surround them with

RNX you know our kind of for register and X for extra big maybe so we’ve got

the RAX RBX RCX and RDX registers and then we have a bunch of other ones

through R15 but first before we do that let me just emphasize that these are

general purpose registers to be used for integers or data you can put

characters in there for strings you can put just like you know whatever data you

want inside the machine we use twos complement to represent integers so it’s

it’s fine the instructions that you will do for addition and other mathematical

but don’t put floating point numbers in these registers because the computer the

system the machine won’t know how to operate on that data the thing is

integers are stored as twos complement I’m going to talk about that more in

another video and floats are stored in something called I triple E seven five

four standard which is just like a crazy different way of storing floating point

numbers that makes more sense for floating point numbers but because the

differently in the machine you can’t really use normal instructions like you

can’t add two floats together the same with the same instruction that you would

add two integers together you would have to use special floating point registers

and special floating point instructions I’ll talk about floats at the end of

this video I hope but basically just keep in mind these are general purpose

registers to be used for integers in data only okay so what am I talking

Okay, so what am I talking about?

What are we seeing here on the side here?

Why does it say return value?

What is going on with Kali saved and fourth argument and third argument and so forth?

So there’s a standard that you’re supposed to use when you program.

You can get yourself into a lot of hot water or you can dramatically increase your debugging

time if you don’t do this.

standard called the ABI which I think is short for application binary interface but basically I just

like to say the ABI respect the ABI there’s a plan that people came up with that says this is how you

should use these registers don’t use them in a different way and that way if everybody is writing

you know modules and they’re all going to interact together like I write a module you write a module

the abi then it’s it’s pretty much guaranteed that we can we can expect certain things like

our registers won’t become corrupted after a function call or that we’re not going to corrupt

someone else’s uh function or you know whatever right so you can also use this to benefit yourself

even if you’re the only person who is writing your code and you’re not calling on anyone else’s

function um then you know like how are you going to remember like what was i using this register

Was I supposed to save that one?

Was I supposed to preserve it?

How was I going to return data from that function?

Was I going to use this register or the other register?

It’s hard to remember what you,

what you yourself even did like a month ago.

So if you respect this plan,

then your functions will work not only

with other people’s functions,

but with your own functions from a month ago.

The other thing too, is we have system calls, right?

So you have like a system call.

Let’s say we want to move something into REX.

something into REX, maybe I want to exit the system or something.

Just forget about this.

This is not a system call video.

Suppose I want to do a system call, right?

The system call itself is also going to respect the ABI.

So if you start calling other

services in the system call instruction, like if you want to open a file,

close a file, read a file, write a file, whatever.

If you don’t respect the ABI and the system call is respecting the ABI,

might have some of your data corrupted so it’s a really really good idea to respect the abi

in fact think about it this way what if uh what if you wrote a bunch of functions for a long long

time and then like a year later you couldn’t you couldn’t remember what you were doing you know

last year oh what was the return register uh and it costs you a bunch of extra time debugging

eventually you’ll probably decide to write your write your own standard okay from now on i’m always

going to use this register for return values and i’m going to use this register for the first

and i’m going to use this register for the first argument and i’m going to write you probably

come up with a plan right that’s basically the abi the abi covers more than just how to use

registers but um register usage is covered in the abi so why would you put yourself through

a bunch of heartache and then eventually come up with your own plan when you could have just

been following the correct plan in the first place right so everybody should respect the abi

I wanted to talk next about the return value.

Okay, so let me write up a little function here.

Let me just say that we have a C++ function.

And we’ll just say it’s like void f.

And we’ll say it calls on g.

And then we’ll have another function called g.

And actually, maybe it’s not void.

Maybe it actually does return a long.

returns the number five or something. Okay.

Hopefully you’ve seen some kind of a higher level language before like C++

so that you can understand what’s going on here.

We’re just making two functions and one is calling the other.

And the second one is just returning a value to the first one.

So in assembly, the equivalent of this would be,

let’s make a label with the name of the function and then a little colon,

and then just put a return instruction at the end of it. Wham,

it, wham, you’ve got a function. It’s not going to work very well, but you do have a function at

this point. So F, uh, I’m going to try to copy the C++, uh, function. So it’s a really good idea.

Whenever you’re writing a function in assembly, try to imagine what the prototype would be for

C++ and just put it as a comment at the top. So I know how the F function is going to behave in

my assembly module because I put a comment up there just kind of reminding me what the prototype

for C++. It doesn’t really do anything. It just sort of runs. So that’s okay. And then I’ll make

another function down here. I’ll do the long G again in a comment, and then I’ll do the actual

assembly version. I’ll say G colon, and then I’ll return. So just by putting that comment up,

I kind of can remind myself now that the G function is supposed to return some kind of a value.

up here, you know, do how about let’s say, I don’t want to start adding a bunch of local

variables right now.

Pretend that we’re going to print the return value of the call to G somehow we’re going

to use C out or whatever.

We’re going to send it to a variable, whatever.

I’m just going to try to keep the assembly as simple as possible.

But anyway, the point is G returns something.

you know, a value in your assembly function.

Well, remember that higher level languages,

part of why they’re so awesome

is they do a lot of extra work for us under the hood

and they actually provide illusions to us

that make programming easier.

For example, there are no functions

going on inside the actual machine.

I mean, I guess from a certain point of view there are,

but basically the machine is just sort of like moving data

and jumping to instructions

and jumping back from somewhere.

And, you know, it’s just sort of like jumping around

and executing instructions.

and executing instructions there’s no actual function it’s so it’s like if you want to pretend

that you have a function in assembly well there is a return instruction that will help you jump

back to wherever you came from most recently but we have to we have to implement more is what i’m

saying so how do we return a value in an assembly function we just have to load up the return value

it as return value that just means we have to load rax up with something so for example we wanted to

return the number five so i’m just going to load it up with the number five and then return

now we’ve pretty much translated a c plus plus function into uh an assembly function i mean

that’s really what’s happening under the hood when you compile your c plus plus program

it’s um it’s just you know translating all the c plus plus into assembly

Another thing that I should probably point out is that you should use registers as often as possible

and you should try your best not to touch memory.

Of course at some point you have to touch memory when you want to save your final result or send

it off somewhere or whatever but you know imagine that you have an assembly function and you’re

doing lots and lots of calculations you’re performing an algorithm or something your

program will be so much more efficient by like a factor of a hundred or probably more if you don’t

if you don’t hit system ram because every time you hit system ram like a global variable or the

stack or something then um your cpu you know typically in the uncashed uh scenario your cpu

has to go talk to the system bus on your motherboard and then you know send a message

to system ram and then wait for the system ram to figure out what it’s doing and then get a response

back so when your program is executing on the cpu you can encounter a stall which is like your

like a hundred clock cycles or more like it’s a long time at least in the most basic case

and how do you avoid that just use registers only when you’re doing lots of calculations the

registers are built into the cpu they’re part of the cpu’s hardware so they are lightning fast

compared to system ram or your disk or whatever

i probably say this a lot but you know part of the reason you would even want to code an assembly

Maybe you have a big program that does a lot of stuff and eventually you profile the program

and you realize, Hey, this one part of the program is really slow because it gets called

constantly and it’s not super efficient.

That might be a good use case for writing a hybrid program where you have multiple modules.

Some of your modules are in a higher level language and some of your modules are in assembly.

So you take your most important function that slows down your program that gets called all

like a big loop or something and you rewrite it to assembly so that you can

have more control over how often you touch system RAM to try to make the

whole thing more efficient and you know reduce the number of instructions and

just like whatever and you can improve the product of the efficiency of your

program so anyway you want to try to avoid hitting system RAM your registers

are built in the CPU there’s 64 bits that gives us 64 bits of address space

can reach you know back in the day we had 32 bit systems that means you could only have a memory

stick that was about four gigabytes so now we can go much further so um yeah that’s what’s going on

with our registers on the cpu back to the return value okay so we have return value here goes into

the rax register and then the next thing here is it’s saying that the rbx register is something

remember we said that uh we have to respect the abi right like you have to respect this convention

uh because if you don’t you’re going to cost yourself debug time and your

functions probably won’t be interoperable interoperable with other people’s functions

or the system call uh instruction well so one of the things about the abi is some of the registers

are designated as the function that is being called has to be the thing that saves the register’s

registers value so that it doesn’t corrupt for the caller. Imagine this if I had a function

called f I’m going to do like f and g here suppose the function f is going to move something into

let’s say r12 or actually let’s do rbx move the value 10 into rbx and then it’ll call g for some

reason maybe g doesn’t take any arguments maybe g is just kind of doing stuff let’s just say that

g just moves a different value into rbx so the thing is when the call comes back like after we

get to this next line let’s say we’re going to do something with do something do something with

rbx by the time we get to this line dude can i get the line numbers on this oh yeah i forgot okay

so by the time we get to line seven uh the register rbx is ruined these registers are not

local variables they’re not like uh you know tied to any scope or function call these registers are

just basically global variables that are sitting on the cpu for lightning fast performance but that

means the rbx i use inside of f is the same rbx i use inside of g so that means if g messes up the

value of rbx and then if f calls g then f now has a bad value for rbx this is a broken program

broken program because we did not respect the ABI.

The ABI says that RBX is callee saved,

which means if I use RBX in the G,

then I have to preserve the value so that by the time I return,

the value is the same as it was when the call first came in.

So how do we do that?

We’ll do that with a push pop pair.

I’ll probably make more videos in the future about pushing and popping,

but I’m going to try to keep it simple for now.

We just say, let’s push RBX onto the stack.

at the beginning and then we’ll pop it off the stack at the very end.

This basically means we’re going to take the value of RBX.

We’re going to send it onto the stack.

So, so yeah, we are hitting system RAM.

It’s a little slower at that point.

The ABI will save us a little time for the other registers.

I’ll try to explain that in a second, but basically we’re preserving the value here

with push and then we’re popping it back off.

So we’re restoring it.

So that means even though we ruined the value at line 14, when F does its line

When F does its line 7, it’s going to have the correct value of RBX.

It’s going to have the value 10.

The book and I like to call this the prologue, just meaning this is a little section of code

where we’re going to set things up.

We’re going to start getting ready to do more instructions.

And then this at the bottom is going to be called the epilogue.

This is just like the finale.

We’re like, we’re kind of cleaning up.

We’re finishing up right before we return.

If you wanted to return a value from G, then you could put, you know, the move inside of

RAX somewhere else.

Like you could put it like below the epilogue or just above the epilogue.

It’s fine.

As long as you’re sure that RAX is not getting trampled upon.

So it’s important to note also that if I do a, let’s say a system call right after that,

let’s say I call G and then I do a system call with, you know, like, you know, some

you know some other number as the call code i want to open a file i want to close a file

i want to read or write a file whatever i want to ask the system to do something for me the

system is also going to respect the abi which means i’m guaranteed that rbx is not modified

when the system call comes back if if the system call you know if the syscall instruction didn’t

respect the abi then my rbx could be ruined i’d have to do a bunch of stuff to preserve it so this

some of these registers let me go down a little bit here like this R10 the

temporary register and also the RDI if you decided to use that in the body of

your program which you’re allowed to these are not designated as callee saved

which means system call could actually ruin the value of those registers so

suppose for the sake of argument I really decided that I needed to use I

10 because that’s marked as a temporary I’ll put a value in our 10 and then I’ll say you know

do something

With our 10 I’m sorry our 10

Then that means by the time I’m done with my call to G

I should assume that our 10 is ruined because even though you’re you can see right here that that G doesn’t actually do anything

To our 10 we should assume that we have to respect the ABI which means the other function could have ruined it

Ruined it. This is especially true if you call someone else’s module or system call or whatever same thing for the system call

so if I call system call

and I use

R10 at some point before and then after then I have to assume R10 is destroyed by the time I get back in system call

So that’s no good

The cure to that when we’re talking about a temporary or something that is not designated as callee saved is that the caller has to save

hit a system RAM just to make a call.

Anything that we think we need when we’re finished.

So I’m going to do a push.

This is not the only way to do it, but I’m going to do a push R10 here.

And then afterwards, I’m going to do pop R10.

So that sucks.

And then I have to do the same thing for the system call.

I can go push R10 and then pop R10.

And of course, if you were clever, you probably would, you know, put the call to G inside

of that system call push pop pair.

So you could have one less push pop pair.

push pop pair but I’m just saying there’s no guarantee r10 is going to survive so you always

have to preserve it if you ever want to use it again so this is like another way that the abi

kind of can help you save time notice how here in the uh in the g function which I probably should

have prototyped let me just say it looks like to me it’s a void and it doesn’t take any arguments

to prototype your functions in comments.

Maybe let me do the same thing to F up here.

So F looks like it’s not returning anything and it’s not taking anything.

Okay. Whoops.

Those are C++ comments that would not compile.

All right. So notice how I’m using RBX.

So I decided to preserve RBX, but there’s also other registers that are marked as

marked as Kali saved like R12 through 15 and RBP and whatever,

but I’m not preserving those.

The reason I don’t have to preserve those is because I’m not using them.

So the, uh, the, uh, the ABI can save you a little time here.

Like for example, I’m preserving R10 because I’m supposed to assume that I,

that I, that they could be destroyed by the time the function comes back.

What if instead of using R10, I used R12.

have to surround any calls with a push pop pair because I can trust that whoever is going to

modify R12 will preserve it for me. But then notice down here G is not actually using R12.

So G doesn’t even do push pop on R12. So we save hits to memory. We don’t even have to touch memory

to preserve R12 because the ABI is helping us sort of stay a little bit more efficient.

So this is great, right? F is a broken function at this point though, because I’m using

at this point though because I’m using two registers that are callee saved I

can’t assume that whoever called F is gonna know that I’m modifying RBX and

R12 so I should do a prolog and an epilog up here I’m gonna say push RBX

and then I’m gonna push R12 and then down here at the bottom I’m gonna do an

epilog epilog and I’m gonna pop RBX and I’m gonna pop R12

but I’ve done something wrong.

The thing is, I’m not going to talk about the stack too much in this video,

but the stack is a particular type of data structure

that will return to you data in a reverse order than you sent into it.

This is great for helping us keep track of function calls and return addresses,

as I’ll probably try to explain in this video.

But basically, the data comes out backwards.

The data comes out backwards. So if I do it like this

Then actually by the time the return statement instruction gets executed

RBX will have the value that was intended for R12 and R12 will have the value that was intended for RBX

It’ll be backwards. So you have to do your push pops in the reverse order to notice how

It’s kind of like a shell that goes outwards. It’s like R12 is first on the inside and then RBX is next on the outside

That’s just what you have to do to preserve everything.

So the F function works now.

The G function, I think it works now.

We have a prologue and epilogue.

Okay, so we talked about the ABI.

We talked about calls.

We talked about the registers.

Talked about callee saved.

We talked about the fact that we don’t have to save the other ones.

I think I can talk about…

um so uh one thing that i should make sure to mention is that these are general purpose registers

they’re to be used for integers integer data or like characters or just like regular data

they use certain instructions that are not to be used with floating point data so you actually

should not store floating point numbers inside of your general purpose registers you should only

store floating points in special registers which i’ll talk about at the end of this video

So keep that in mind.

Floating point numbers are stored differently in the system.

They’re stored with a scheme called IEEE 754 floating point.

So like the numbers wouldn’t make sense.

Integers and floats are stored differently.

So the hardware is wired differently to operate on two different types of data.

So anyway, I just want to say that this is only for integers and general purpose data.

So now let’s look at the other types of registers.

rc x and rd x and rsi and rdi are designated as arguments first second third and fourth

okay so let me uh let me write like a quick c plus function here and this is going to be uh let’s

say we have like a function that returns some value we’ll call it uh we’ll call it f and we’ll

say that f takes in some arguments let’s say that it takes in three arguments um again uh

integers right now because we’re only using integer registers.

We can’t use floating point arguments or return values.

Just keep that in mind.

So I’m just going to do like three arguments long A and B and C.

OK, so we can take in three arguments and maybe we’re just going to return,

you know, a plus B plus C.

OK, simple C++ function.

Let’s do this in assembly.

We’ll make a label and we’ll do a little comment that just reminds us.

of sorry of the

Function that we’re trying to implement we stick a little return instruction at the end of it so that

it will jump back to the caller and

then we’ll say

Well when the caller of this function

Called us and gave us a and B and C. How do we get a and B and C?

Well a is the first integer argument, so it’s just going to be the RDI register

So we’ll literally just use a move instruction

just use a move instruction.

Let’s say we want to, for whatever reason, use the R12 register

and we’ll do something with it later.

We’ll print it, we’ll save it, we’ll do whatever.

Let’s just grab the incoming argument.

So we’ll just grab RDI.

So I’m going to put a little comment up above here, you know, grab

a and do something

with it and I’ll just write down here more instructions just to just to denote

Just to denote that we’re doing something with the a value, but I’m not going to write it down here because I don’t want this to get huge.

So we’ll do the same thing with the b.

Maybe I should remember that programming is case sensitive.

We’ll do something with the b.

It’s not RDI.

It’s the second argument.

So that’s actually RSI.

And then we’ll do something else.

We could have used R13 or other registers if we wanted to.

I’m just showing you how to grab incoming arguments.

So then we’ll grab the c and do something with it also.

C and do something with it also it’s not going to be RDI it’s going to be RDX and you can do this

up to like I think six arguments let me just double check here yeah so like R9 ends up being

the sixth argument and if you want more than that then the caller will have to put stuff on the stack

and in fact if you if you kind of like understand what’s happening here let me just do like a main

Let’s say we do cout whatever f returns.

You know, this is like a typical function call, right?

So we’ll call f.

f will jump in there.

It’ll jump into its body.

It’ll do some sort of a manipulation with the incoming arguments.

It’ll return a final value.

Then that final value gets printed out.

So what’s 5 plus 6 plus 7?

That’s 11 plus 7.

What is that, like 18?

I’m bad at math.

So let’s just say that’s 18 gets printed.

So what happens is, um, we return, Oh, I forgot to return.

I’m going to say compute the, uh,

compute the sum of the things.

Uh, and I’ll just say like block cause I don’t want to put a bunch of addition

instructions here. Uh, and we’ll just like store in, uh,

in R13, let’s say. So then when we have finally computed our result, I’ll just move R13 into the

return value. And what I’m really trying to say here is if you imagine a function that behaves

this way in C++, then what I’ve written down below is really what’s actually happening in

assembly. Your compiler compiles the code down to assembly language first, and then it assembles it

down to machine code. So really this is what’s happening under the hood. It’s not like a special

under the hood it’s not like a special trick when you call a function in C++

literally the A B and C have been loaded up just before the the jump

instruction to go to that you know line 9 they’ve been loaded up with the

appropriate values so that’s part of like you know the magic of what higher

level languages give us it’s just makes things a little bit easier okay so I’ve

If I had only used RDI and RSI and RDX, those are not designated as callee saved.

So I wouldn’t have had to preserve those, but because I chose to use R12 and R13, I

have to preserve those for the caller, even if the caller is not going to use them.

So I’m going to do, I’m going to do push R12 and I’m going to do push R13.

And then at the bottom, let me do like a prologue here.

is kind of helpful because it kind of helps you remember like, oh, did I forget the prologue?

Did I forget the epilogue? They got a match. And then I guess the fact that you can see the words

prologue and epilogue also helps remind you that everything is supposed to be in reverse order

in the epilogue. So again, notice how R13 is on the inside and R12 is on the outside

of the push pop pair. So now my program is good. And we’ve, you know, successfully translated

We’ve, you know, successfully translated a nice function call there.

And we’ve done a bunch of nonsense in the middle that I’m not writing down at this point.

We are respecting the ABI.

So if somebody else uses our function in their module, then they can be pretty confident

that we’re not going to ruin their registers and so forth.

We talked about the return value.

We talked about that these general purpose registers are not for floats.

We talked about pushes and pops.

and pops. We’ve talked about function arguments,

which right now we can only do integer arguments and return values.

We’ve talked about, uh, well, he talked about the stack a little bit.

So let me, let me just point out that, um,

suppose you have a function. I just want to mention this briefly.

Suppose you have a function F let’s say it’s, it’s void.

So it doesn’t return anything and it has an integer a equals five.

I think the reason that I wanted to do this is to show you how dangerous it is to mess

with the wrong register like the stack register.

So suppose we have two variables and then we’ll do something with a and b.

So now suppose we have two threads.

We have an execution thread one and an execution thread two.

If you’re not familiar with threads, that just basically means your computer is literally

executing your function or sorry, it’s executing twice at the exact same time.

Maybe not the exact same time if you only have a single core on your CPU, but you could

imagine that that’s possible, especially if you have many cores, that’s an operating systems

video.

But basically pretend that we have an execution thread.

So it’s like going through your program, executing one instruction at a time.

Then you launch another execution thread that also executes your program one instruction

at a time.

at a time so at some point it’s possible that um thread one and thread two could be executing f

at the exact same time right so i’m not going to talk too much about this because this is not an

os video but basically this could create a race condition where thread one and thread two kind

of step on each other’s toes and they both try to modify the value of a uh at the wrong time and

because the other thread modified it.

So this is why local variables in a function actually live on the stack.

A and B are not global variables.

They’re actually temporary local variables that are sitting on the stack.

And the way the stack works, I’m not going to talk about it too much in this video,

is that, well, every function kind of has its own area of the stack.

So when the function comes in, on the stack sits the return address

return address so that the function knows where to jump back to when it returns and any local

variable that the function makes. So if you think about it, when thread one calls F, we actually

end up with a different version of A and a different version of B. We could imagine them

as being, you know, A sub one and B sub one. But when thread two comes in and, you know,

creates those local variables, we can imagine that we get two different versions of A and B also.

of a and b also so this is how the computer prevents multiple threads from stepping on each

other’s toes if you’re using local variables local variables are just local to the function

this also helps if a function calls itself a bunch of times maybe one call or another might want to

see a different version of a or b and it would be just incredibly difficult to keep track of that

if you were using globals but when you use locals well they’re just basically different variables

trying to lead up to is the stack is pretty important if you corrupt the

stack then you probably are going to crash the entire program you might make

it so that a function doesn’t know where to return from like when you do the

return statement it might jump to some other part of the code that doesn’t even

make sense and then everything crashes or you might mess up some data in a local

variable like if you mess up if you mess up the stack you might be messing up the

that the caller is depending on and so then the caller continues to execute and

it sees the wrong value and it just crashes or you might even mess up your

own local variables so don’t miss with the stack the reason I’m saying that now

is because this very this register right here the RBP sorry that’s not it the

RSP register that’s the stack pointer eventually you can learn how to

manipulate the stack pointer in order to create your own local variables that’s

variables that’s okay once you know what you’re doing but unless you know exactly what you’re

doing you probably shouldn’t touch the stack pointer especially you shouldn’t mess with it

right before you call a function or right before you return from your own function be very careful

with that the rbp uh register is similarly dangerous uh it won’t like automatically destroy

your program but it is uh it’s usually i mean it’s quite often used as sort of like a bookmark for

mark for where the stack pointer was pointing in other modules and other

functions.

So if you fail to preserve the base pointer,

the RBP and then you returned from your function,

then you might have actually messed up the stack pointer for the caller or some

other caller somewhere in like the ancestry of your call graph.

So be very careful. I mean,

I guess all callee preserved variables or registers you should be very careful,

careful about, but these are like kind of the two worst ones to forget about.

first ones to forget about.

There’s also another register that is not listed on this page called the

instruction pointer. It’s RIP.

It basically is a register that holds

the memory location of the next instruction to be executed.

So if you modify that, then you just told your program to go execute

in some random crazy place and probably everything is going to crash.

R10 and R11.

I can’t remember already if I explain this, but I’ll just say it again.

But I’ll just say it again, R10 and R11 are just temporary registers.

You don’t have to preserve them.

But the callee, if you call another function, they don’t have to preserve the registers either,

which means it can be really fast to use R10 and R12 if you’re kind of like already running out of registers.

If you don’t have to make a function call anywhere, so you know no one is going to ruin your R10 and R11,

then you can also use R10 and R11 to sort of like, you know,

reduce your hits to system RAM to speed up your program.

So R10 and R11, they should probably be used last.

R12, 13, 14, 15, I usually use those first.

Once I start running out of those, Kali saved.

Then I’ll start eating into the arguments.

I’ll say, you know, I’m going to start using RBX

and then I’m going to use RDI and RSI and whatever.

It’s okay if you use, you know, the argument registers.

as long as you’ve already done something with your incoming arguments or you don’t have any.

So just keep that in mind.

You’re allowed to use them.

I mean, this is all just a standard.

As long as you obey what the rule is, then you’ll be all right.

The rule is you got to callee save those.

The rule is that one’s just temporary.

The rule is this one’s an argument and so forth.

Okay.

locals and how we use these registers. Let me try to just show you one more

thing real fast. So I said before that the size of the REX register is 64 bits

because it takes up the whole available register bits in the CPU but there are

other versions of this register that we could use. What if you only wanted to use

32 bits in your register? What if you wanted to pack like two different 32

32-bit numbers in the same 64-bit register.

You could do that.

There are also older modules and instructions

that will operate only on 32-bits.

So how do you reference only 32-bits of a register?

Well, if I search for, oh shoot, what was it?

Is it EDI?

No, no.

Shoot.

It’s in here somewhere.

This is like a good lesson in actually preparing before you record a video.

So I’m going to do architecture overview, CPU registers.

Oh, it was at the beginning of this section.

I always skip down to 2.4, 12 point something, and I should have gone to 2.3.1.1.

So obviously I’m not going to remember all of this, but basically notice at the top,

we have the REX register, all 64 bits of it.

But if you wanted to access the lowest six, sorry, the lowest 32 bits, then in your code,

instead of putting REX, you put EAX.

So for example, you know, move REX, whoops, REX, let’s say the number five, but over

here we’re going to move EAX, the number five.

five uh here it’s going to set the whole 64 bits to just like a bunch of zeros and then there’s

going to be a few bits that help represent five the lowest bits so it’s going to erase like the

whole thing all 64 bits but if you use the eax instruction then only the lowest 32 bits will

actually be modified which means whatever data you had in the higher 60 the higher 32 bits of the

of the register itself they’re just going to stay there it’s going to be considered

point so sometimes if you’re going to work with something that’s going to be using only 32 bits

of your register you better make sure that the other bits are uh are cleared out if you intend

to use rax right after that and and vice versa so keep in mind that we have other forms of the same

register a designation but just to let the cpu know that we only want to touch 32 bits worth we

And this, this kind of table covers all of the registers,

REX, RBX, RCX, and so forth.

I think it doesn’t cover the instruction pointer

and something else in there, but you know, most of them.

However, you know, for my purposes,

I usually just use 64 bits

because I’m not like super advanced

unless I have to divide or do something.

Okay, so that’s the last thing I wanted to mention

about the general purpose registers.

Let’s see.

Callie saved.

So the not sure if I said this before already, but basically the.

So just to emphasize the, uh, the RBP register is the base pointer register.

You’re probably going to mess up, uh, the caller because the caller often uses RBP as

a bookmark for the stack pointer.

mark for the stack pointer you definitely don’t want to mess with a stack pointer unless you

actually know what you’re doing in order to create local variables um there’s another variable

another register in here called rip which is the instruction pointer register so if you

if you mess that one up then the program is going to start executing in some crazy place that doesn’t

even make sense okay so now that we’ve talked about general purpose registers by the way i

called special purpose registers, not general purpose.

General purpose is like RAX, RBX, all these ones that you can just randomly use as long

as you respect the ABI.

But the base pointer and the stack pointer, those are kind of special.

And the RIP, the instruction pointer, that’s a special register.

You shouldn’t mess with those unless you really know what you’re doing or you’ll get yourself

in trouble.

But now that we’ve talked about those, let’s talk about the floating point registers just

real fast.

about using floats until a lot later but basically

i at least want to mention that we do have registers that will work with floating point

operations let me see there we go okay so it’s 18.2 floating point registers um essentially

we use xmm0 through xmm13 for floating point numbers there’s not going to be any

not going to be any crazy letters like RDI, RSI that you have to memorize. You can just use zero

through 15 and it’s totally fine. When you want to return a floating point number from a function,

you will load up XMM0 as the return value. You won’t even touch RAX. The arguments are the same.

They’re just kind of ordered. It’s like the first argument is going to be XMM0. The second argument

is going to be XMM1 and so forth all the way up to XMM15. If you need more than 15 arguments,

some sorcery with the stack or with some kind of system like the global variable or something

and also for floating point registers we use different instructions so what I really want

you to know because this is mostly about the regular registers is that if you have floating

point numbers and you want to multiply them or do some other operation on them the normal

instructions for regular registers won’t actually work you’ll have to look up a different set of

and i’m going to do this in another video some other time uh if you want to move uh data with

a floating point register you can’t just use the regular move instruction you got to use either

move ss or move sd um and and both operands have to be floats or actually i think the one on the

right can be memory but um move ss basically means a single piece of data single precision

So you can move like multiple pieces of data at a time.

I’m not going to really cover that.

Um, but you can move single precision floating points, which means there are 32 bit floating

points or you can move double precision floating points, which means they’re a full 64 bit

floating point number.

There’s also bigger registers, but I’m not going to talk about that.

Yeah.

Well, yeah.

Later processors 256.

I think mine has that, but I’m not going to talk about that.

I think mine are like YMM or something.

So yeah, with that, those are the basics of registers and some stuff to keep in mind.

In future videos, I’m going to talk more in depth about making functions and calling functions

and all that stuff, respecting the ABI.

But for now, here is your primer.

I hope it was useful on CPU registers.

Thank you for watching this video.

I’ll see you in the future.

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

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

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

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 Mastering x86-64 Assembly: A Beginner’s Guide to CPU Registers appeared first on NeuralLantern.com.

Get a clear, fun breakdown of data sizes in x86-64 CPUs! This video covers bytes (8 bits), words (16 bits), D words (32 bits), and quad words (64 bits), plus how they fit into assembly and CPU registers. Perfect for programmers, students, or anyone curious about low-level computing. I’ll walk you through the basics with relatable examples, no jargon overload. Subscribe for more coding & tech videos, and scan the QR code to visit my site for extra tutorials! Leave a comment with your thoughts!

Introduction 00:00:00
Data Sizes Overview 00:00:01
Byte Definition 00:00:44
Bits to Bytes Conversion 00:01:27
Word Size Explanation 00:02:20
Double Word (D Word) 00:04:03
Quad Word Definition 00:04:44
CPU Registers and Memory 00:05:21
Conclusion and Outro 00:06:07
Call to Action 00:06:32

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hello there.

I’d like to talk to you about data sizes within the context of x86,

64 CPUs,

just like 64 bit CPUs for assembly and just whatever.

So what’s going on inside of the machine and how do we describe the sizes of

various clumps of data? So for starters, you know,

of your computer, there’s just a bunch of ones and zeros represented in all the wires,

in all the circuitry.

The human beings with feelings decide, oh, you know, I’m going to take a group of this

many bits, this many ones and zeros, and I’m going to say that it is something else.

I’m going to call it an abstract unit.

So the first thing that we do is we have something called a byte.

That just means eight bits.

So we can say one byte equals eight bits.

equals eight bits. I don’t know why I hit the shift key there. That’s probably going to mess

up my annotator. Nope. Okay. So what is eight bits? Just as a little reminder, you know, we’ll

just say one, two, three, four, five, six, seven, eight, or it could be, you know, something more

random looking one, two, three, four, five, six, seven, eight, you know, so like inside of the

machine, we have eight ones and zeros for eight bits. And when we group them together, we’ll just

Okay, no problem.

So that means by the way, if somebody says,

oh, my internet connection is this many megabits a second.

If you wanna know how many bytes a second,

try dividing by eight.

Or if somebody says I have this many megabytes a second

of transfer speed, try dividing that by eight.

You know, so multiply or divide by eight

to get the right number.

Okay, so if we had two bytes together,

that’s just gonna be 16 bits.

No problem there.

I’m just going to copy paste these bits and you don’t have to do this.

But for me personally, I like to put a little space in between bite groupings just to help

my human brain kind of see, oh, I’m looking at two bites right here when I’m referring

to different data sizes.

So then eventually we kind of need an idea of, you know, let’s come up with a different

word that means more than one bite.

ironically based on what I just said the the term we’re going to use is word a word

the size of a word just kind of depends on the system that you’re on on my system

the size of a word is two bytes so I’m going to say one word equals two bytes

and you can imagine that’s 16 bits maybe I should start doing the double equal sign here just to be

Okay, so equals two bytes.

It also equals 16 bits.

And you can imagine it’s basically the same thing

that we just wrote up above.

So I’m gonna erase this actually, 16.

Oh, I put an E there, embarrassing.

Okay, so one word is two bytes.

Again, the size of a word depends on your system.

If you’re not sure, you should probably look it up.

What’s the word size on my system?

But again, the typical system here in 2024

6664 machines running Ubuntu, um, or just like Linux is going to be like, you know,

two bytes. Okay. So now, uh, we have like words that we can do. So if I had, uh,

let’s say I had two words, uh, two words is going to be double of what we just wrote. Right. So

that means we’re going to have this many, whoops, I blew it. We’re going to have this many bits.

So two words, two words is going to be equal to, um, 32 bits.

And it’s also going to be equal to four bytes because, you know, we multiplied everything

by two.

So this is like four bytes.

So now we need another term to represent this two words, which is four bytes, which

is 32 bits.

We can also call that a D word.

Actually, I’ll say D word like that.

And what does D word mean?

is twice the size of the word length on your system.

So like if we decided our word length is two bytes,

then a D word is four bytes and that’s it.

Four bytes is 32 bits.

You might notice this is similar to like old school CPUs

that ran in 32 bits and maxed out their RAM

at about four gigabytes.

So let’s come up with one more term here.

Let’s come up with the term quad word.

Actually, we’re not coming up with the term.

We’re just using it.

What is a quad word?

A quad word is two D words.

So we’re just kind of doubling it again.

I forgot that extra equal sign there.

Quad word is two D words, which means it’s also four words.

And it also means it’s eight bytes.

64 bits.

And then I guess if I want to represent this to you,

I can just kind of like copy paste that twice.

And this is the size of the memory address space that we have on modern CPUs.

This is also the size of your general purpose registers in modern 64-bit CPUs.

So if somebody says, hey, I got a quad word.

I want you to store it somewhere.

You can instantly think to yourself, well, obviously I could put it in memory.

I could put it in memory.

You could also just put it directly into a CPU register.

And that’s it.

This also means that you could put two D words into one CPU register if you were very clever.

You could also do the same thing.

You could put like four words inside of one CPU register.

Because the CPU registers, they’re always the same size no matter how you use them.

They’re kind of hardwired.

So I hope this has been, you know, kind of helpful.

These are the basics of different data type sizes that we have in CPUs and

assembly language. I’ll see you in the next video.

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

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

If you could do me a please, a small little favor,

Follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now

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

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So, please do do me a kindness and and subscribe

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

and I get filled with joy. That’s exactly what happens every single time. So you could do it as

a nice favor to me, or you could, you could troll me if you want to just wake me up in the middle

of the night, just subscribe. And then I’ll, I’ll just wake up. I promise that’s what will happen.

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

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

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

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

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

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

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

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

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

darkness which is coming for us all

Thank you.

The post Master Data Sizes in x86-64 CPUs: Bytes, Words, D Words, and Quad Words Explained appeared first on NeuralLantern.com.