In this practical x86-64 assembly language tutorial we dive deep into conditional branching using YASM (also works with NASM) on Ubuntu/Linux.

We cover:

• The CMP instruction and how it sets the RFLAGS register
• All major conditional jump instructions (JE, JNE, JL, JLE, JG, JGE, JB, JBE…)
• Important difference between signed (JL/JG) vs unsigned (JB/JA) jumps
• Real code examples showing how to implement if-style decisions
• How to handle the “jump out of range” assembler error
• Visual flow diagrams explaining control flow

Perfect for students learning low-level programming, reverse engineering, operating systems, or anyone who wants to understand how if-statements, comparisons, and decisions are actually implemented at the machine level.

Highly recommended companion resource: Professor Ed Jorgensen’s free x86-64 Assembly Language Programming book (linked in comments).

Enjoy learning assembly!

Intro to Conditional Branching in Assembly 00:00:00
Recommended Book: x86-64 Guide by Ed Jorgensen 00:00:23
Unconditional vs Conditional Jumps 00:01:39
How Conditional Branching Works 00:02:06
The CMP Instruction Explained 00:03:21
Overview of Conditional Jump Instructions 00:04:50
Signed vs Unsigned Jump Instructions 00:06:10
Jump Equal & Jump Not Equal (JE/JNE) 00:07:00
Main Conditional Jumps Summary 00:08:14
Starting the Code Example 00:09:09
Program Structure & Printing Setup 00:10:35
Function Prologue & Getting User Input 00:13:21
First Branch: Is Number Greater Than 0? 00:15:17
Live Demo: Testing Greater Than Zero 00:21:53
Second Branch: Is Number Less Than 10? 00:22:52
Live Demo: Testing Range 0-10 00:26:06
Third Branch: Is Number == 5? 00:26:52
Live Demo: Testing Equal to 5 00:28:00
Jump Out of Range Error & Workaround 00:29:00
Final Summary & Closing 00:32:17
Thanks & Call to Subscribe 00:32:57

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there. In this video,

we’re going to talk about conditional branching in an assembly program.

We’re going to be looking at YASM x86-64 assembly or AMD 64 assembly

within Ubuntu, but this will probably be a useful video.

If you’re just thinking about how to branch in assembly in general.

So for starters, I’m going to promote one of my favorite books,

as I often do. This is a book that is free and open source. You can get a copy yourself. I did

not write this. The author of this book is a genius. His name is Professor Ed Jorgensen, PhD.

He made this whole book and released it under an open source license. So you can literally just go

to his website and get a copy of this for free. You can use this to make yourself into an assembly

expert. So I highly recommend this to everybody. Anyway, so I’m going to open up this book. I’m

up this book i’m going to assume that maybe you’ll get a copy or you’re just going to follow along

with what i’m doing on the screen but i’m going to open this book and i’m going to go to section 7

which is entitled instruction set overview i’m going to double click it so open out open the

subsections and then i’m going to click on 7.7 control control instructions and then under that

i’m going to click on 7.7.3 conditional control instructions so uh that’s a lot of subsections

So that’s a lot of subsections, isn’t it? I love a book with a ton of subsections. It makes things so much easier to find

If you or someone you know is going to write a book, especially if it’s technical, please use lots and lots of subsections

Anyway, so conditional control instructions in my last video

We talked about the jump instruction where we can just be sitting somewhere in our program and then just jump somewhere else

Anywhere we want based on the label so conditional branching or conditional control instructions

conditional control instructions are kind of the same thing except they will

decide whether or not to actually jump they might fall through to the next

instruction or they might jump away to somewhere else so conditional branching

or conditional jumping it basically kind of goes like this step one you compare

two values to each other they will probably be sitting in registers and then

conditional branching instruction or a conditional jump instruction there’s

lots of synonyms for these but basically in the regular jump instruction that I

just talked about in the last video you just jumped and it was only one thing

that you had to do but in this case we first have to compare two items and then

we’ll issue the jumping instruction because the jumping instruction will

have to decide whether to jump or not based on the result of your comparison

which makes sense right like if you’re going to implement something that’s like

if you know I’ll put like a expr for expression then well the first thing that we have to decide

before we jump either into the block of the if or if we jump into the block of the else is whether

or not that expression is true right so that’s kind of what the compare instruction is doing

sort of in higher level languages like c++ it can get a lot more complicated than that but you know

Okay, so we’re going to do conditional branching instructions.

Let me show you a few of those.

Okay, so for starters, here’s the compare instruction right here on page 126.

I think it’s actually 127 in the PDF, but basically, you know, 126.

We do CMP followed by two operands.

So if we want to compare, I don’t know, let’s say R12 with R13, that’s how you would do it.

just a two operand instruction there’s no results that are going to get stored in one of these

operands both of these operands are just for input the result actually gets stored in a special

register called r flags which we hardly ever use or look at in in the most common assembly

instructions and design patterns we just kind of like let the r flags do whatever it’s going to do

and the compare instruction will fill that up so imagine that you know depending on whether r13 is

is like greater than r12 or less than or they’re equal or something else is going on between the

two of them the compare instruction just fills up all sorts of flags defining the relationship

between those two registers or those two operands r12 and r13 and then after the r flags register

is all set up then the conditional branching instruction will sort of rely on r flags in

order to decide whether or not it’s going to jump or not okay so let’s see there are tons

there are tons of conditional well not tons i guess like half a page worth but there are lots

of conditional branching instructions we can use the first two i want to show you and after this

by the way i’m going to write a sample program just to show you how it is in practice but so the

first one is je which means let’s jump if the two operands were equal so again you know we compare

here we’ll say sets up r flags and then we’ll decide like what we’re going to do are we going

to jump if they’re equal to some label i’ll write some label here so that means uh the je instruction

will look at the r flags register and decide did compare think that r12 and r13 were equal if it

did then we’ll jump if not execution will fall down to the next line so i’ll put a nope instruction

So if they were equal, then we’ll end up jumping to some label.

And if they were not equal, we’ll end up letting execution fall through to the nope on line 10.

And same thing for jump not equal and all these other ones.

But there are actually two different versions of some of these instructions that kind of seem the same.

Like for instance, this one right here, JL, that means jump if the first operand was less than the second operand.

is a jump below that jumps also if the first operand was less than the second operand so

what’s the difference between these two let me get my pen I love excuses to do my little pen now

well I’ve got my pen it’s working oh I erased it okay okay it’s working anyway so notice how jump

less than and jump below are basically doing the same thing but there’s one difference one of them

One of them works on signed operands and one of them works on unsigned operands.

So keep this in mind.

If you’re comparing two signed integers, you want to use this group up here of instructions.

But if you’re using unsigned integers or just bits, then you want to use this group of instructions down here.

And you definitely want to know what kind of data you have that you’re comparing.

Notice though that jump equal and jump not equal, they don’t really care.

not equal they don’t really care if the operands are signed or unsigned that’s because if you want

to check to see if two things are equal you just look at all of their bits and if all of their

bits are the same then you just say they’re equal you don’t even care actually if it’s a signed or

unsigned integer if it’s a float if it’s a whatever you just you just go are all the bits equal or are

at least one of the bits unequal then we’ll say it’s equal or not equal that’s it so keep that in

mind for all of your jump instructions where you’re trying to see if things are equal or not

or not equal you’re going to definitely be using these whether you’re using signed or unsigned

integers or floats or anything else like that but when it comes to actually you know integers that

are signed or unsigned these are the instructions you use for signed and these are the instructions

whoops that you use for what have i done that you’ll use for unsigned i keep confusing the on

off button for the red button is what i’m doing oh okay whatever i guess we’re done anyway

I guess we’re done anyway.

So keep that in mind.

In this video, we’re just going to be using the signed integer instructions

because that’s the example that I have set up.

But just imagine you could very easily translate this to unsigned integers or floats.

Okay, so let’s see.

We’ve got jump less than, we’ve got jump less than or equal to,

then we’ve got jump greater than, and then we’ve got jump greater than or equal to.

And when you combine those with jump equal to or jump not equal to,

jump not equal to that’s pretty much all the comparison that you need and if you want to do

something much much more complex well then you can just you know start stacking logic on top of

logic and and branching on top of branching to do something that’s like this is what i’m talking

like if you want to do this expression and expression or expression and then maybe like a

expression, right? If you want to do something super complicated, like we can do in a higher

level language, you’re just going to have to make a bunch of mini jumps or find another

way to reduce your logic. But in this video, we’re just going to be taking a very simple

comparison. All right. So I think that’s everything that I can show you inside of this book. Let’s

go to the code now. So here’s a little empty code, source code, a page. I’m going to stick

all my code inside of it. Another reminder that if you don’t know how to write assembly

you don’t know how to write assembly at all you should see my other videos because i’m not going

to cover the basics of assembly in this video if you want to learn how to make a make file or compile

or assemble or like do all the basics that i’m not talking about in this video i’ve covered them all

in my other videos up to this point so for now we’re just going to focus only on conditional

branching conditional jumping inside of an assembly module so i’m going to start off by setting up my

and i’m gonna say paste and again you know this is covered in other videos but long story short

i’m just going to be printing out a bunch of strings while this program executes so

i’m going to announce that the branching test is going to begin and then i’m going to ask the user

for some input and then i’m going to based on whatever the user inputs i’m going to just print

out a message that sort of you know understands what the user inputted so if the user inputted

something greater than zero it’s going to output that if they entered something that was less than

10 it’s going to print that if they entered something that was equal to five it’s going to

print that and then it’s going to say we’ve ended the branching tests then i have like a crlf again

all this stuff is explained in other videos but we’re just basically printing so i’m going to

start the text section of my program which is where all the instructions are and i’m going to

a function that I can call on. Again, this video does not cover a bunch of other extra stuff. I’m

just going to show you how to branch. Just trust me when I say that this helps me easily print

numbers and things, or I guess in this particular case, it’ll help me input a number from the user.

But for you, if you’re trying to run this at home, you can just start hard coding numbers just to

make sure that you can branch correctly and then eventually work your way up to a library that can

videos in the distant future. I don’t know years from now. I don’t know.

I might release the library or some other stuff to the casual viewer.

So now here’s our entry point. Again,

I mentioned that there’s going to be other parts of this program that I’m not

showing. So this is a hybrid program where a C++ driver actually will call on

my cool function. So just imagine from somewhere else in the program,

you’re calling on the cool function. How do we know it’s a function?

a label called cool and then it has a return statement at the very end.

That’s pretty much all we need to know right now.

Let me get rid of that load.

I don’t know why I always have the word load in all of my things.

I think I put it in there on an early example

and then I just kept copy pasting to my heart’s content and never stopped.

We mark the function cool as global so that other modules can call on it

like the C++ module that I’m not showing you.

But if you’re writing a pure assembly module,

you don’t really need to mark your functions as global.

if everything’s within the same piece of source code it’s totally fine so then I’m going to make

a function call to a function called branch test so very quickly before I actually add branch test

I’m just going to add another function that we’re not covering in this video called crlf and long

story short all it does is just it prints a new line in the terminal and that’s it like it’s just

it’s a convenience function I like to be able to call crlf and have a new line okay so let’s start

our branch test function so here’s the signature it is just branch test with a

void in front of it I’m gonna put a ret to say that this is a function that we

will return from and I left myself a little note here saying that I’m gonna

use register r12 as the number that the user inputs so that means I’m gonna have

to preserve that because you have to respect the ABI and the ABI says that

The ABI says that R12 is a Kali saved register.

Again, see my other videos if you don’t know what I’m talking about.

But I’m just going to preserve it in a section that I call the prologue, or actually the

book calls the prologue.

I do that now though too.

And, you know, restore it in a section called the epilogue.

So we have prologue and epilogue.

We can have a push-pop pair.

And then in between, we can have, you know, the meat of our function.

Okay, so for the introduction, I’m just going to write a few instructions that just print

out a message.

print out a message. So we’re going to print out that intro message and then call

CRLF to print a new line and then return. So maybe actually at this point we could

probably check to see if this program works by trying to run it.

So let me say clear and make run.

Okay. So now the driver just prints hello. The driver is

elsewhere and we get that welcome message that says begin

branching test and then the driver retains control after that. So

let’s do let’s do a goodbye message real fast so we’ll do our goodbye message

it’s just another string that I’m printing it’s no big deal right now but

if I run the program again you can see that begin branching test and end

branching test okay so far we’re not really doing branching yet the next thing

we need to do is ask for a number so this is how I’m going to do it in my

this is how I’m going to do it in my program. In your program it might be different or you might

have a hard-coded number or something like that. So for now just trust me when I say that I’m going

to print a prompt basically saying could you please enter a number and then the next two lines

are going to be just calling on one of my custom functions that will input a number from the user

so the user can type at the terminal and we will receive their number through REX which is the

return value register for integer return values and we’re going to store it in R12. So that’s why

And we’re going to store it in R12.

So that’s why I had to preserve R12,

because I’m actually going to start,

you know, messing with the value of R12 now.

Okay, so we ask for a number,

and then we sort of don’t do anything after that.

If we run the program again,

it’s just asking for a number,

and I can just like type some stuff and hit enter,

and then the program ends, nothing actually happens.

We’re building, we’re building.

So now let’s ask ourselves,

is the number greater than zero?

So let me copy paste some code here.

some code here so right now we’ve just finished inputting a number from the user and we’ll ask

you know is that number that they inputted greater than zero so again the first thing we do is we use

a compare instruction cmp we give it two operands the order doesn’t necessarily matter um for

instance uh right now i’m asking is r12 greater than zero so i can do a jump less than or equal

to like a different branch or i can jump greater than equal to if i switch the operands or if i

in a different order, but I’m just choosing to say, let’s compare the two and then let’s jump

if R12 is less than or equal to, which basically means not greater than, this label right here,

which is just branch test after greater test. So I’m going to do a print statement right after that

and then I’m going to draw out what the code is kind of doing. So let me make a label here so

actually will compile. Whoops. I’m in the wrong window. Okay. There we go. So what am I saying

here? Okay. Do the comparison. And then if the condition seems to be satisfied, then we’ll jump

to this, which means we’ll just say goodbye and then exit the program because we’ll return to the

caller. But if that condition was not satisfied, then we’re going to end up executing this stuff

in the middle. So think about this. This is kind of the idea. Let’s see if I can remember how to

idea let’s see if I can remember how to draw this right now off the top of my head suppose we have

like some sort of an input I’ll call this in put and then maybe the input is going to be you know

whether r12 and r0 are equal or greater than or whatever so I’m just gonna say r12 and 0

god that’s awful I really need to practice this draw pad I spend like a whole week practicing

whole week practicing with a different draw pad and then when I come back to

this one I’m even worse than when I started so we we come in and we kind of

look at our 12 versus zero and then we will jump in one direction if that’s not

you know greater than or equal to or less than or equal to and we’ll jump in

another direction otherwise so basically here we’ll say jump less than equal to

um less than or equal to whoops maybe i’ll do r12 uh i need to somehow adjust the pressure on this

thing r12 less than or equal to and so this is sort of uh has to do with you know this branching

path that we take like if r12 was less than or equal to zero then we’ll take the right branching

to after, I’ll just put the word after,

we’ll jump to the after greater test sub label.

And otherwise, if R12 is, sorry,

I said less than or equal to, yeah,

if R12 is greater than zero,

then we jump to this other thing,

which is gonna be the fall through.

So it’s gonna be line 96, but I’ll just say,

I’ll say fall for fall through.

basically the jump won’t happen if it’s greater than or equal to so you could imagine if you

wanted to reverse the logic so you can use a jump greater than instruction you could but I’m choosing

to do it this way and then both of those will eventually reach let’s see will eventually

actually yeah the fall through instructions those will eventually reach the after instruction I’ll

here and then the after instruction will just kind of like finish the program

and exit and all that stuff. So if you think about the control path here,

we have an input we’re looking at R12 with the zero with the compare instruction

and then we use a conditional branching instruction. So maybe I should write,

what do you want to write here? Maybe I’ll just put JLE up here because usually the compare

usually the compare instruction and the conditional jump or branching instructions

kind of you know come as a pair so both of these combined mean let’s look at r12 versus zero and

if r12 is less than or equal to zero meaning if it will jump if we’re less than or equal to the

the right operand r12 less than equal to the right operand then we go down this path on the right

to the after label if that is false meaning r12 was greater than zero then we’ll fall through

this stuff right here and then whether or not we actually fall through will always end up at the

at the after area because we’re either going to jump directly to the after area or we’re going

to fall through and then the fall through falls through to the after area anyway as well let me

just show you that real fast oh man i’m having a hard time with this okay so let’s pretend that r12

less than or equal to. So that means instructions are coming, you know,

instructions are getting executed. We’re going down and down and down and down and down.

Once we see jump less than or equal to, if that’s true, then we jump to the after label,

which means we just kind of jump around this message. And so we’re not going to exit,

sorry, we’re not going to execute that code. So in the case where that is true,

where it is less than or equal to, we’re not going to execute those instructions.

So we’re not going to say their number was greater than zero. We’re just going to simply

We’re just going to simply say goodbye.

However, on the other hand, if that is not true, meaning if R12 was indeed greater than

zero, then we’re going to fall through because this jump less than or equal to instruction,

it will only jump if the R flags, if the comparison instruction thought that R12 was less than

or equal to zero.

If that’s not true, if it’s greater than, then instructions, the control path is just

the control path is just going to fall through.

So that means we will actually execute these.

And then when they’re done,

execution will continue to fall through to the rest.

So that means we’re either going to see a message saying

their number was greater than zero or not,

based on whether their number actually was greater than zero.

Okay, hopefully I explained that somewhat clearly.

Now let’s run the code and see if it works.

Hopefully I didn’t forget anything.

This is kind of a partial program at this point.

program at this point I’m gonna add a bunch more stuff to it so hopefully

this actually compiles enter an integer five notice how it says your number was

greater than zero and if I run it again and I just type zero it does not say

that it was greater than zero if I run it again I type like a negative five it

also does not say that it was greater than zero you know a huge giant number

here it’ll say your number was greater than zero you could probably type a

number that was just absolutely huge and have it overflow I actually don’t know

nines I need to type and I don’t even know what the behavior is going to be.

I don’t know if it’s just going to crash the program because this also relies on my ability

to input a number which is happening in a different library.

Let’s see if that even works greater than zero.

Okay.

It probably overflowed and went to a very, very low negative number.

So okay.

I guess at least I know my library will probably work sort of.

Okay.

So let’s go back to the code here and let’s upgrade it.

how to to check for jump less than or equal to um we’re going to say goodbye right there so now the

next thing we should do is check to see if the number was less than 10. so after the greater test

it’s going to be here so again the same thing like we can just reuse r12 because we’re not really

modifying it and we’re not calling uh well i guess even if we were calling a function r12 was supposed

supposed to be Kali preserved so we’re just comparing it and then maybe

printing a message if we want to and regardless we’re going to end up at 103

this after greater test label so then we’ll compare again r12 with the number

10 and we’ll say jump if it’s greater than or equal to branch test after less

so now at this point we’re saying compare r12 with 10 if it’s greater than or equal to 10 then

just skip over the message so if it’s greater than or equal to 10 then wait a minute wait wait

yeah yeah if it’s greater than or equal to 10 then skip the message otherwise the message

that is printed is going to say that their number is less than 10. so again you could imagine a

want me to write it out for you I don’t know I think once is probably enough but let me just do

it again we’ll do input is coming in and it’s just going to be you know comparing and then

jumping greater than or equal to the input is going to be where we’re just looking to see if

R12 how it compares to zero god the number one is awful my entire penmanship is awful okay one

we’ll do r12 and 10 and so that’s just sort of what we’re comparing with the compare instruction

and then the jump instruction and so if we go on the left i’m going to say that’s the fall through

path again and if we go to the right it’s going to be um r12 greater than or equal to 10 is going

and then here this is going to be after less I’ll say the after label the after less label

so if we fall through it’s just going to print a message maybe I should do another little bubble

here that’s just like print p for how about p for print p for print it’s going to fall through and

then it’s going to print and then it’s going to go to the after label so you can see that

the print instructions are only reached if r12 is not greater than equal to 10 which is the same

to 10 which is the same thing as saying it’s going to fall through if r12 is less than

10.

And then after we finally get to the after label, then we’re just going to do, you know,

the rest of the instructions.

We’re going to exit the program.

We’re going to say goodbye.

We’re going to do whatever.

Okay.

So say there never was less than 10.

And then regardless, here’s like the ending label that we were conditionally jumping to.

Let’s see if this works.

Make run.

So we’ll enter five.

we’ll enter five notice how it says your number was greater than zero and your

number was less than ten let’s do an 11 I guess it says your number was greater

than zero but it does not say that our number was less than ten because 11 is

not less than ten if I do a negative three here it says that our number was

less than ten but it doesn’t say that it’s greater than zero so we have like a

lot of decisions that we could make right like imagine if instead of just

based on something happening, you could call a full function or skip a bunch of extra code,

you know, whatever you want it to do.

So I’m going to go to the next condition where we’re going to compare R12 to the number five.

And we’re going to ask, you know, is R12 equal to five?

So this is going to be the jump not equal branch.

And again, you know, if you wanted to say jump, if it’s equal to the place where we

and then maybe like right after that fall through and just do an unconditional jump you can

I just think there are less jumps if I do it this way so uh here we’re just going to print you know

your number was equal to five and so basically if it was not equal we should have another label here

that allows us to skip that so all right so same thing I’m not going to draw the diagram this time

R12 with 5 and if it’s not equal to 5 then jump to this label down here which just means

let’s say goodbye and not actually say that their number was equal to 5.

But if it was equal to 5 then this JNE conditional branch won’t actually jump anywhere.

Execution will fall through to the next statements which is just printing the message that their

number is equal to 5 and then when that’s done it’ll fall through to this other label

and eventually fall through to the return statement.

the whole thing already nice that was easy um let’s do another run and um let’s enter the

integer one it says one is uh greater than zero and one is less than 10

greater than zero and less than 10 is there any way i can get nothing to print out

greater than zero and less than 10

you don’t think i can do it let me try it nine no

why did I even put 9 okay yeah it’s always gonna say 0 or 10 okay so let’s

do a 4 we’ll get both of those greater than 0 and also less than 10 let’s do a

5 now we should get all those messages your number was greater than 0 your

number was less than 10 your number was equal to 5 and if I just do a 6 in there

again it doesn’t print your number was equal to 5 and we have to enter an

actual 5 for that so that’s the that’s the basics of

conditional branching oh there’s one other thing that I wanted to make sure

in my previous video where we only talked about jumps bear in mind that

these conditional branching statements or instructions you know je j any all

these things they have a limited range of jumps of where they can jump to so if

you have a gigantic program and you’re trying to jump very very very far away

based on a condition you might have an assembler error where your program won’t

even compile won’t even assemble telling you i think the message is i wrote it

I wrote it down somewhere jump out of range coming from the assembler that basically means that these

instructions can only jump about 128 bytes away from whatever instruction they are at or whatever

memory location they are at so you know after your assembler assembles your program and after

your linker links your program and you just have like a binary you know if you were to inspect

all the instructions inside of your executable your binary you would see that they have offsets

offsets, right? You know, like one instruction is basically eight bytes away from the one that

comes right after it. But some instructions are a lot further away. So if you’re trying to jump

to an instruction that is 100 is more than 128 bytes away, it won’t work, you’ll get that error.

So how do you solve that problem? Well, maybe I’ll just write this down real fast. I’m not going to

make this part of the code example. But just imagine we have, you know, jump equal to some

and maybe I’ll do a comment very very far away and here’s the label some label right

so if your assembler says hey you can’t jump to some label because it’s too far away it’s a

jump out of range assembler error then basically you can just make some other labels here you can

say uh you can say short jump true and short jump false you know just make up some sort of a label

label and basically say if it is um well false yeah okay i guess this is the way i’ll do it this

is not super efficient but instead of jumping to the very far away label in the case of true you

can just jump to the true label so i’m going to say jump uh to the short jump true label otherwise

To the false label. So now you’re definitely jumping in either case and both of these labels are close by

So then I can pretty much just have the close by true label do an unconditional

Jump to some label and that overcomes the limitation of branching instructions

So, you know JMP the regular jump instruction

It has an unlimited jump that it can do it can go just to like very very very far away instructions

And then for the false, you know, I don’t know, do whatever you want and then jump wherever you want.

It doesn’t really matter.

I’m just trying to show you that if you make a short jump to a label that will only have an unconditional jump,

so it’s sort of like two jumps, you know, like a short jump and then a long jump,

then you can overcome that limitation.

Again, bearing in mind that some label is supposed to be very, very far away and sort of unreachable.

Okay, so let me just double check that I talked about everything that I wanted to.

We looked at the branching instructions, the sign in this, I drew a diagram for you.

We solved the jump out of range error.

Okay, so that’s, I think that’s basically it.

Hopefully you feel like an expert now at conditional branching and how to make decisions.

In future videos, I’ll talk about how to implement an if else block and how to implement loops

and all that stuff.

decisions in yasm x86-64 assembly and conceptually you can apply this to other assembly languages too

so thanks for watching my video i hope you learned a little bit of stuff and had a little bit of fun

i’ll see you in the next video

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

Could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now?

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

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

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

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

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

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

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

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

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

appreciate it so again thank you so much for watching this video and enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Learn Conditional Branching in x86-64 Assembly (YASM/NASM) – CMP, JE, JNE, JL, JG & More appeared first on NeuralLantern.com.

In this in-depth x86-64 assembly tutorial using YASM, we dive deep into implementing complex if-else and if-elseif-else control structures from scratch. Starting with the fundamentals of conditional branching, we build up to full chained if-elseif-else blocks with multiple conditions – exactly how high-level languages handle them under the hood.

You’ll see real working code that:

• Takes user integer input
• Tests against specific values (5, 6, etc.)
• Handles greater-than/less-than comparisons
• Properly branches so only one block executes
• Uses labels, cmp, conditional jumps (je, jl), and unconditional jumps (jmp) correctly

We cover the classic pattern: compare to conditional jump to true block to execute true code to jmp to end to false block falls through or jumps in. Everything is shown step-by-step with live compilation and runtime demos.

Perfect for anyone learning low-level programming, reverse engineering, or wanting to understand how compilers translate if-else chains into machine code. Prerequisites: basic conditional jumps (see my earlier videos).

Code shown works on Linux x86-64 with YASM/NASM syntax. Grab the concepts and apply them anywhere.

Introduction to If-Else in Assembly 00:00:00
Explaining the If-Else Design Pattern 00:00:56
Drawing the Basic If-Else Flow 00:01:01
Comparison and Conditional Jumps 00:02:30
Labels for True and False Blocks 00:03:07
Unconditional Jump to End 00:04:50
Diagram of Execution Flow 00:05:51
Alternative Pattern with Inverted Jump 00:07:00
Recapping the If-Else Pattern 00:08:45
Starting the Code Example 00:09:16
Setting Up Input and Strings 00:09:40
Calling External Functions 00:10:57
Entry Point and Prologue 00:11:40
Asking User for Integer Input 00:13:09
Creating the if_test Function 00:14:56
Preserving Callee-Saved Registers 00:15:51
Printing Begin Message 00:17:03
Implementing Simple If Block 00:18:29
Comparison and je Jump 00:19:18
True Block: Equality Message 00:21:08
Testing Simple If Examples 00:23:48
Transition to If-Else Blocks 00:24:21
Creating if_else_test Function 00:24:47
Setting Up Complex If-Else 00:26:25
First If: Equal to 5 00:27:22
True Block for Equal 5 00:28:33
Else If: Equal to 6 00:30:29
Else If: Less Than 10 00:34:17
Final Else Block 00:37:33
Done Label and Goodbye 00:38:23
Recap of Full Flow 00:39:06
Live Demo of All Branches 00:40:54
Signed vs Unsigned Jumps Note 00:43:38
Recommended Assembly Book 00:44:12
Conditional Jump Families 00:45:05
Closing and Practice Advice 00:46: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

Hello there.

In this video we’re going to talk about implementing simple if-else blocks in YASM x86-64 assembly.

Although if you’re writing in a different assembly language, this video will probably

still be useful to you because I’m going to explain the design pattern or how we can achieve

that at the assembly level.

So x86-64 YASM assembly, also known as AMD64 YASM assembly.

So if you have not seen my other videos about how to do conditional branching in the first

place, you probably want to go check that first because that knowledge is required for

this video.

There’s also a lot of other stuff that I’m just not going to explain in this video, such

as creating a make file, you know, compiling and linking your executable and so forth.

So see my other videos where all those concepts are explained already.

how to implement a simple if-else block.

So for starters, maybe let me draw a little bit.

Suppose we had, let me get rid of this thing

and then I’ll just do a regular notepad.

Suppose we had a higher level language,

just so you know what I’m talking about.

Suppose we had a higher level language

and we wanted to say if, you know, some expression is true.

We wanted to say if expression is true,

then print, you know, it was true.

Anybody remember that old movie, Little Nicky?

Somebody got exploded and then the guy next to him goes it’s not true

Okay, it was not true

So this is the basic idea of what we’re going to implement in assembly

I’m going to write a full program for assembly to show you this but um

You know you’re in C++ you’re in C you’re in I don’t know whatever language you’re in and

You obviously know how to use if-else blocks at this point hopefully

And now we’re going to just try to figure out how to implement them in assembly

So it’s important to understand that really under the hood

really under the hood there’s a bunch of stuff happening surprise right okay so

first off we look at this expression which could be I don’t know let’s say

five is greater than ten or a is equal to B or whatever it is that you put in

there you could make a very complicated expression we’re going to use simple

expressions for this video so if we’re comparing a to B we’ll end up using the

compare instruction remember there are two steps to conditional branching and

in YASM we first use the compare instruction against two operands and then that will end up

filling up the rflags register so that we can later conditionally jump based on the results

of the comparison. So we do a comparison and then you can imagine that the beginning of this

you know the the true body notice how it has a scope I’m going to just put this brace on another

line here to indicate that there is a scope from line four to six indicating all this code in here

in here is executed only if the if statement was true and then all of this other stuff is executed

only if the original comparison was false right so you can imagine now label is something like

my if was true so we can make a label for where that body starts and another label for where the

label is something like if was false and then what will happen is we can use a

conditional jump instruction after we do our comparison maybe I should put to

compare right here oh I’m using I’m using assembly style comments I should

be using a C style comments if I’m actually writing C++ here let me just do

that okay so this is the comparison instruction here and then here’s the

here and then here’s the beginning of the body of stuff to execute if it was true you can imagine

that there could be many statements here um if it was true or if it was false

just to prove to you that we can execute like a full body of stuff so we have a label that

designates when that body starts and then we have another label designating when the else body

starts and then we should have a label that uh that designates when the whole thing is over

label is something like if and or if is done or something like that so basically what we want to

do is to implement an if else a simple if else in assembly we’re going to say let’s do a comparison

and then we’ll do a conditional jump where are we going to conditionally jump well if the comparison

was true label. And then what will happen is execution will fall through.

When it reaches the end, we want to have another jump statement that unconditionally jumps

to the end of the if statement. If we didn’t, then whenever the expression was true,

we would end up executing all of the true statements and then it would fall through

to all of the false statements or the not true statements. So we have to have many jumps in here

let’s get into the body and then let’s finish and jump out of the body on the other hand if the

expression was false then our jump instruction is going to jump you know over the true body so

it’s not even going to do that at all it’s going to execute all of the else stuff and then it’s

you know sometimes a good idea if you have another jump here that just jumps to the end but you can

kind of see by the way i’ve written this out that there’s not going to be anything between the end

you know place where we’re finished with everything which means we don’t really

need an unconditional jump at the end of the else body we can just let the

execution fall through so maybe if I can draw a little diagram here I’ll say I

don’t know I’ll do like if put it in a little bubble and we’ll say that if it

was false we jump to one place and if it was true we jump to another place

we jump to another place.

I hope you’ve already started to understand this by now.

So we’ll say if the expression is true, we jump here.

If the expression is false, we jump over here.

And so true would be saying, let’s jump to the if was true.

So we’re going to jump to if was,

I’ll put a T there because I’m running out of space.

If was true.

was I’ll put an F false and then at the end of the true we jump to the done

label so I’m just gonna put done maybe down here

so at the end of the true we just unconditionally jump to the done area

and then at the end of the false we jump unconditionally to the done area as well

here’s something interesting though when we have a comparison instruction and

conditional branch instruction let’s say uh let’s say a equals b we did that comparison and then we

wanted to jump into the true area if a equals b was true so that means we’ll say jump

equal so if a is equal to b after we compare well let’s say a comma b we’re going to use registers

when we come to the code we’ll say compare a and b and then jump if they’re equal to some label

but the conditional branching instructions they only jump to one

potential place or fall through so if the comparison was false meaning if those

two things were not equal then we’re not going to actually be able to jump to a

different label we’re going to simply fall through to the next instruction so

in that case the very next instruction would get executed let’s just put a jump

was

false.

Meaning

we compare A and B

and if the two things are equal

we’ll jump into the true block.

Otherwise we fall through to the next instruction

which

that’s a very poorly written J

but we’re going to unconditionally jump to false.

So if we did not

jump to the true area we fall through to the next

instruction where we will always

jump to false and that implements the diagram

that implements the diagram that you see up above.

I mean, you know, if we have if statement, we compare,

maybe I’ll do, you know, A equals B.

We jumped to true, if was true.

And otherwise we end up falling through

and then jumping to if was false.

And then at the end of both of those,

we have an unconditional jump instruction

that jumps to the done.

So I’ll put JMP down here just to let you know,

you know, at the end of each of these blocks,

that they are jumping out of themselves at the very end to the done area maybe

I’ll put an arrow here so that we know both of these jumps end up jumping to

the done area that’s the basic idea for how to implement an if-else block a very

basic one we’re gonna do more complicated ones later but for now we

kind of have the idea down I think let’s look at some code dang I blew 10 minutes

already on that okay so I’m gonna copy paste some code from my solution here

code for my solution here this again this is not like a beginner’s assembly

video if you need to learn how to write assembly in the first place how to

compile you know link create a make file and so forth you need to see my other

videos first but for now we’re just going to assume that you know how to

make a data section in Yasm and we’re gonna say let’s make a bunch of strings

so first I’m gonna ask the user for an integer and then I’m gonna make a bunch

of decisions like I’m gonna do you know an if-else block to test what kind of

what kind of number they put you know did they make a number that uh

equal one if it was equal to something oh did I ask twice I can’t remember what I’m doing

but basically we’re going to print something if their number was equal to something else

we’re going to print uh something if their number that they inputted was equal to five we’re going

to print something else if their number was equal to six we’re going to print again something else

a bunch of stuff and then wait isn’t this the complicated example oh no i think i am using code

for my more complicated example else less than 10 i don’t know maybe this is the simple one

let’s double check i guess if i put more complicated code in here you’ll probably be happy

but whatever i thought this was going to be a simple example so i’m just defining strings at

codes stuff that is covered in other videos now i’m going to start my text section so my text

section begins with a declaration that i’m going to use two external functions so this video is

not about this library that takes input and sends output i have other videos for that but basically

i’m just using a library that lets you type an integer into the terminal and then it will print

a different number to the terminal for you so you can imagine if you wanted to follow along

imagine if you wanted to follow along with this code at home and you don’t

have this library you can just hard code your numbers just to prove to yourself

that you can get it to work or you can use a different library if you have a

hybrid program and you’re linking against GCC you can just use scanf and

printf pretty much those take a little bit more work to do but you can do it

anyway so our entry point is going to be called if tester it’s a function called

Again, this is a hybrid program and hybrid programs are not covered in this video, but you can imagine that there is a C++ module elsewhere in my source that is just going to call on a function called if tester.

And so that’s why I’m marking this as global so that other modules in my program can call on if tester.

So it’s just a little label that we can jump into or in this case call into.

Let me go down to the bottom of that.

We’ll put a return statement at the very end.

very end so now this is officially a function and notice how i made a note here that says r12 is

the user’s inputted integer so that means i’m going to be using r12 and since r12 is designated

in the abi the application binary interface as callee saved or callee preserved that means i

have to do a push pop pair to preserve it or i’ll get in lots and lots of trouble my program will

prologue which my favorite book also calls the prologue and then I’m going to

say epilogue and so now we have a function that basically doesn’t do

anything but we can at least jump into it let’s see if this compiles as is I

think it probably will yeah so the driver just says hello that’s the C++

program with the actual main function and it calls my if tester function but

nothing happens the if tester function returns control to the driver and then

the driver just says okay i got control back so nothing really happened so now let’s ask the user

for some input so again this is not a video about this library or how to print with this with system

calls see my other videos if you need help on that but basically we’re going to print a message to

the user hey please input an integer and then we’re going to call on a library function that

lets them type in a number and then returns it to us in rax we’re then going to store it

well just basic stuff right so if I run this again it’s going to ask for an

integer please enter an integer if I can type that and then nothing else happens

okay now we can kind of start making more decisions so I’m going to let’s see

if test if test if test okay so what I need to do now is run another function

called if tests several times and I’m going to compare the number that the

times and I’m going to compare the number that the user inputted so remember r12 is the user’s

input so I’m going to load that as the first argument of a function call and then I’m going

to load the number five as the second argument of a function call probably not a great idea to hard

code numbers in your assembly you should probably define them up in the globals or the the data

section at least as just regular defines and not numbers in memory but I’m going to just keep these

So three times we’re gonna call if test and then also another function called CRLF. So first I’m gonna paste in

CRLF

Where the heck is that? Oh, dude?

Again, this is not a video about the basics

So you’re just gonna have to trust me or go watch my other videos if you don’t understand what I’m doing here

But I have a function called

CRLF and its whole job in life is just to print a new line for me just because I like to do it that way

handles the CRLF call. Now let’s make another function called if test.

So I’m going to start that by designating its label right after this block of

code here, maybe before CRLF.

So we have like a basic if test function and here’s my prototype just to remind

myself what I’m going to be doing.

It’s going to take an input and it’s going to take another input for a test

against me. So the first one is like the user’s input.

The second one is the number that I want to test it against.

number that I want to test it against they’re both longs which means they are both integers

which means the incoming arguments are going to be rdi and rsi if you’re respecting the abi

and then some notes to remind myself I’m going to be using r12 and r13 inside of this function so

I’m going to start by putting a return statement there since that is what it takes to make a label

into a return into into a function then I’m going to preserve the callee saved registers again if

don’t know what i’m talking about see my other videos we’re going to push r12 and push r13 so

that they are not ruined for the caller we call this the prolog then at the very bottom of the

function we have the epilog which just restores uh the registers in reverse order you’ve got to

do it in reverse order see my other videos if you don’t understand why okay so that’s basically a

function that can get called it doesn’t do anything let me double check that the program still actually

works. 66 and nothing happens. We just printed CRLF a bunch of times. Okay, so now we’re ready

to continue. So let’s grab the function arguments. Remember we were going to use R12 and R13 for the

user’s input and the number we will test against. Those came into our function with RDI and RSI.

So I’m just going to copy those two incoming arguments into R12 and R13. And you’re supposed

keep the user’s input in RDI then the moment I call any other function or system call I’m just

going to lose that data so I’m going to keep it inside of R12 and R13 so I grab the function

arguments and then I print a begin message just to let the user know that we’re going to start

you know making tests against our number so this is just basically a message saying hey begin the

if test and then print what we’re going to check against so the next thing is

I’m going to let the user know what the second incoming argument was.

If you look at R13 here, that was RSI, which was the second argument.

So the test against me number.

So we’re going to check the user’s input against whatever we called for the second argument.

So I just wanted to print it out.

You know, like we’re testing your number against whatever.

So that means I need to make another call to my little printing library here.

To RDI which is the first argument notice how we already we already destroyed RDI. That’s why I’m keeping the input in our 12 and our 13

And then we’re gonna make that call and we can just assume everything will go according to plan at that point and then

Then we’re gonna print a special message only if something actually happens

So we’re gonna implement the if else block in a moment. Let me just run this real fast

and then it says we’re calling the function three times and we’re saying the basic test has begun

we’ll test against this number five so we’re testing your input against five and then six and

then seven and then we didn’t actually do anything we’re about to okay so then the next thing is we’re

going to print a special message only if the user entered the right number so first off remember we

see if else block and converting it into assembly so i’m sort of placing that in comments for you

so the comparison instruction i i didn’t want to put the r12 equals r13 inside of the same comment

that lines up with the the compare instruction because the compare instruction as i’ve said in

other videos already it doesn’t actually check to see if something’s equal it just makes a bunch of

called r flags with information that we can later use to decide if the two things were equal or not

equal or greater than or less than or whatever so that’s why i chose to put that on on the next line

so at this point we’re saying if those two things were equal and that’s how i implement the expression

in the middle then let’s jump to a special label called if test if was equal so you can come up

with any scheme you want for your labels but for me when i have when i have sub labels inside of a

when i have sub labels inside of a function i like to just suffix the function’s name with an

underscore and then start thinking of sub labels after that so everything’s like kind of clean

there’s less chance of overlap in labels if you have like a giant module with tons of functions

so i’m going to say this is like my main if that i’m checking and uh i’m going to jump to a label

called was equal meaning you know this evaluated to true that means that should be the true part

block let’s see do i still have that code here yeah right so here i’m going to jump to

the true block so you know if was true in the first example that we talked about so i’m going

to say if it’s if those things were equal jump to the code for the true block okay that means i

actually need the true block uh but i guess we’re going to set that up in a second otherwise if that

did not jump away it means that those two things are not equal so i said i should jump to the

I should jump to the else block or the false block.

Wait, do I have else in this example?

Oh, okay, okay.

This first thing that we’re looking at is only if.

So we don’t even have an else block yet.

We’re going to do that as the second example.

So we’re basically going to jump to the done area

if we didn’t jump into the true area.

And then at the end of the true area,

we can either jump to the done area

or we can let the execution fall through.

fall through okay so now that means i need if was equal and if i just copy paste a big giant

block of code and try to explain it to you real fast let’s do this

okay so we were going to jump to if was equal if r12 was equal to r13 and then um

we uh have this you know label here and notice how i’ve kind of like put a brace here indicating

like put a brace here indicating hey this is the beginning of the true block body you should

consider doing this too when you’re first learning and even after you’ve learned because let’s face

it assembly is tough and so in the true area i’m just going to print the equality message i’m going

to say hey your number was equal to you know whatever and then uh i’m going to actually print

the let’s see r13 number so that was uh i think the number to compare against the test against

against me number so that means here in this message we’re going to say hey your number was

equal to the number that we tested against so then otherwise let’s see or sorry after that

we’ll print the suffix of the message um and so you know i just i just like to make pretty

pretty uh printed messages so let’s see where’s the suffix here i can’t even find it um how about

oh i should have put suffix instead of the number two that would have been better so what i wanted

to do is say your input was equal to and then print the number and then after that print an

exclamation just to prove to you how easy it is to to make a pretty message that’s formatted nicely

for the user um or your professor or whoever so uh you know you basically just print a number and

then you or sorry you print the prefix and then you print the number and then you print the suffix

suffix and then that’s the end of the true body and then since we’re done with the true body we

can basically just say all right now we’re done with the if so the next instruction that follows

is the done area again looking back at the example here that would be sort of like here after the

whole entire block was finished we’re ignoring the else in this code but you can imagine we’ll do

that soon so if the user’s number matched something we execute a true body if not we jump to the done

to the done area and if the user’s uh number did not match then we just immediately jump to the

done area so that we don’t do the true area and then we write comments to ourselves to help us

remember oh look here’s like the comparison and then here’s the body of true and then uh the done

area is like we could put another comment if we want we could say like this is done but i kind of

think like i kind of think the label is self-explanatory so let’s see if this worked it’s

was talking too fast we’ll run it and we’ll say 44. okay so nothing matched any of the numbers so

let’s type the number six so that we get a little message on the second one so i’m going to type the

number six and you can see it did not match the number five and it did match the number six so

we got that true block executing when we called on that function where the number to compare to

nothing there. So now we know simple if blocks.

The next thing we’re going to do is if else blocks.

All right.

So let’s see.

Not sure if I’m going to cut the video and split this up into multiple parts.

Probably would have been a smart idea.

Let me know if I ended up doing it.

We’re at about 25 minutes now.

But anyway,

so now we’re going to look at if else blocks.

if else blocks.

So I’m going to start off with another function.

I’m going to call it if else test.

So here’s the tester.

It called on if test.

And then I’m going to, you know, I had the if test function that I did previously.

And so now we’re just going to make an if else test function.

The if else test, it just has one input, one argument for input.

And we’re going to just sort of compare it against different values.

of compare it against different values we’re not going to call this multiple times with different

values to compare against so that means let’s see we only need to use one register so

i’ve designated r12 as the user’s input so that’s where we’re going to store it which means we

should preserve it in the prologue so i’m going to push r12 and then again if you don’t understand

some of the basic stuff that i’m that i’m skipping over see my other videos where i explained

to know to actually have this kind of a program. So I’m going to have a function that enters and

it returns at the end. It uses R12 so we will preserve it with a push pop pair.

And then the first thing that I should do is grab the user’s input from the first argument.

And if you’re respecting the ABI that means it should come from RDI. So I’m going to move RDI

somebody remind me that the first part of the program has to actually call this function or

nothing will happen. So we’re going to say hello. That’s just a simple message that we talked about

before. And then now we’re going to actually implement the if else block. So it’s like a

little bit more complicated than just the simple if block. It’s going to be this whole example that

we talked about before. Let me see. Maybe I should add the calls to this block real fast. So we have

to this block real fast so we have the if tester and then run the complex if else tests

right before r12 okay let me just double check that i’m making a call at the right spot here

so we have r12 and 7 and then epilog okay so now finally in our program we’re going to have a call

to um the if else test function that we’re just making right now

Okay, so we have that.

And let me find that source again real fast.

If else test, we got the prologue.

We take their input and then we say hello.

Okay, so now we need another label that begins the if block.

So what we’re doing is we’re checking to see if the user’s input was equal to five.

And then we’re going to say something if it was.

And otherwise, we’re going to do an else block on that.

block on that so again i like to write my comparison instructions with a blank expression

in terms of the c equivalent comment so notice how the we’re checking to see if r12 is equal to

five i put that on the next block because we’re going to jump to the to the true part of the if

block if it equals five so that’s why i put that there the comparison instruction pretty much just

compares r12 with five sets a bunch of values into the r flags registers so that we can later

so that we can later conditionally jump if we want to.

So basically we’ll jump to the true place if that was true.

And then if not, execution falls through to the next statement,

which will just jump to the else place.

So we need more labels is what I’m saying.

So now we need a body for if the statement was true

or the expression was true,

we want to be able to execute the true portion of the if block.

the if block so that’s this right here so we’re going to jump to if it did equal to five you

could imagine you know making a better label instead of equal five you could say first if

first else if complicated block true scope or true block or something but i just put equal to five

basically saying we’ll execute this code if it was equal to five so again we’re just kind of like

into this label equal five if r12 was indeed equal to five so that means if it was we execute

all this code right here we know we’re finished when we have the very last line saying let’s jump

to finish the the if else block again just just to clarify

we do the comparison first and if the comparison was true then we’ll jump into the true area so

you know we’ll jump into the true area and then all of these uh instructions get executed

instructions get executed but if we don’t have a way to jump out of that block then whoops

all of the else statements are going to get executed too right so we don’t want that

we don’t want to execute both the true and the false statements we want to have a jump instruction

at the very end i’ll put jmp just so that we jump to the to the end of the if else block

you know jump to the place where it’s just all over and finished

Okay, so now I’m going to look at, whoops, turn that off.

So we have equal five.

So we’re going to jump to if else test if done.

Let me just double check to make sure I’m not forgetting anything.

Oh, we need to jump here.

Basically meaning we’re going to jump into the else portion.

So here we covered jumping into the true portion, you know, the regular top block.

Now here we’re going to jump into the else portion.

We need a label and some code for that.

code for that so this is the else six begin i copy that oh man it’s starting to get kind of

hectic in my brain here the copy pasting is worse than actually writing the program

so uh if the comparison was not equal like if r12 was not equal then execution falls through

to line 216 and then we unconditionally jump to the l6 begin area which is like down here

like down here and then we’ll print something else.

We’ll, oh, we’ll, we’ll check again.

So we’re doing like, um, if else, if else.

Okay. So originally when I was talking about the, uh,

if else block, I didn’t do a,

I didn’t do like a very complex if else statement.

We’ll say a is greater than B something like that.

So I’ll just put a more code here just so you know that we can do if else,

if else blocks but just you know again keep in mind that every scope here that you’re going to

try to run based on some condition you just make it its own label and make sure that at the very

end of the scope you jump away so that you reach the very end of all this stuff because just as a

quick review if we are just writing in c or c plus plus only one of these blocks is going to execute

right like if a is equal to b then only that first block will execute the second and third blocks

will not execute it’ll jump after that all the way down to line 21 only if a does not equal b

do we even have the chance of checking to see if a is more than b if it’s false then we’ll have the

chance to check the else and if it’s true we will only execute the code in the line 12 block you

know imagine there are more statements there and when that block is done then we will jump to line

to b and a is not greater than b so just a quick uh you know c plus plus uh you know design pattern

review if else block review so we have like an else if here we’re going to say check if the input

was equal to six so we just do the same thing that we did before we compare r12 the user’s input with

six we jump if they were equal to the else if equals true block and if not execution falls

Less than 10 begin block. So this is going to be like really complicated

How many lines did I actually I think I got excited when I wrote this

Okay, else if equal six true

My challenge to you is to come up with labels that are like way easier than the labels that I came up with

All right, so we’re gonna do this I

Can almost guarantee that when I’m done copy pasting everything something is not going to compile because I forgot a label somewhere

Else if equals six true, okay

equals six true okay so what’s happening here again um uh so at this point you know the first

if uh expression was not true r12 was definitely not equal to five so we jumped down to else if

equal six begin which was here and so then we just make another comparison to see well okay it was

those two things weren’t equal it wasn’t equal to five so let’s check to see if it was equal to six

to yet another scope.

If it was false, we go down to line 237

and jump to yet another scope.

So here is what will get executed

if R12 was indeed equal to six,

and then we’re just basically gonna say it to the user

and then jump to the done label,

meaning like we’re totally done with our if else block.

Notice how the first if here,

when it was totally finished, it jumped to the done area.

this else if block is also jumping down to the if done area.

So eventually we’re going to need that label.

Okay.

So then next we’re going to check to see if the user’s input was equal to a 10.

So like kind of the same thing here.

We’re going to do another copy paste and we’re going to say, all right.

So if the user’s input was not equal to, let’s see,

if it was not equal to five, then we jump down here for our next comparison.

comparison we check to see if it’s equal to six if it was not equal to six then we jump down to

the less 10 begin line which is like all the way down here we do another comparison to see all right

well is it less than 10 you know if it was not equal to five or not equal to six then we check

is it less than 10 if it uh if it is then we uh jump to the else if equal less 10 true block which

I made this way too complicated. I realize that now, but it’s too late. I’m going for it, man.

Anyway, so if that statement is true, if R12 was indeed less than 10, then we jump to this block

and we basically just say that to the user and then we jump to the done. So finally, notice how

this part right here on line 259, it’s basically saying if R12 was not less than 10, then we’ll

then we’ll jump somewhere else notice how it’s just else right so this is like the very the very

bottom so i think the way that i wrote this uh code is uh we have two else ifs right we have like

an if five else if six else if less than 10 so maybe i could do something like this um if r12

r12 I think I said six just now right hopefully I actually did say six

otherwise if r12 is less than 10 then do some stuff otherwise if nothing else

matched then we’ll execute you know this block right here so again remember

every single scope has to have its own label so that you know where to jump and

it’s also a really really smart idea for every single scope to have you know

to have a little jump instruction that jumps past all of the if else if else if else stuff

so we’ll say like you know label you know done so that we can make sure that only one of these

blocks actually executes which is how you’re supposed to imagine c and c plus plus work

um and so it’s just complicated because there’s a lot of stuff to copy paste but you can just

still see you know only one of these blocks ever is supposed to execute so we give the first one

we jump into it if it’s true if it’s not true then we give the second one a chance

we jump into it if it’s true if not we jump to compare the third one if it’s true then we jump

to its scope if not we jump to the else and the else always executes if nothing else above

was true so that’s the basic idea here oh dear i’ve probably lost my place

looks like i just copy pasted less 10 true which was this right here so

so um less than true or less than 10 true okay so we told the user your stuff is less than 10

and then we jumped to the done area so that means we are probably working on the else area okay let

me grab that so now finally we’re going to have the else area which is going to you know finish

this all up that’s going to be after the if done so if nothing else matched then we will end up

nothing else matched then we will end up jumping to the else area and then we’ll basically

just tell the user none of the conditions seemed to have applied and then even at the

end of the else block even though you could probably get away with just letting execution

fall through just to save yourself one instruction you know you could comment that out assuming

you were sure that the very next instruction was the beginning of the done area but otherwise

I’m just going to play it safe and jump directly there then we have to make the actual done

So, just so you know, a label doesn’t have to have any instructions.

We could have something like this, if else test say goodbye.

We could have two labels right next to each other and one doesn’t actually have instructions.

That’s totally fine.

If you jumped to the done area, then execution would just fall through to the next valid

instruction which could go through another label.

So you know, we could have a say goodbye label and an if done label.

if done label, I’m just going to have the goodbye stuff happening inside of the done.

But for clarity’s sake, you might want to keep that label in there that I just deleted.

And all that we need to do at the very end when we’re done with everything is just say goodbye.

So I’m just printing a message.

So just to do a quick recap here, let’s see.

We come in with the user’s input as R12.

We ask, does R12 equal five?

If that’s true, we’ll say that it was equal to 5, and then we’ll go to the done area,

meaning we’ll skip past all the other blocks for the if-else block, or all the other scopes.

But if that did not equal 5, then we’ll fall through to that jump instruction,

which takes us to the next test, which is going to be our else-if equals 6.

So we are checking now to see if R12 is equal to 6.

If that’s true, we jump to this next block.

Why do we need to jump to a block that’s so close?

Well, if we don’t, then we’re going to end up definitely jumping to the next comparison

and you know, that wouldn’t work.

So we’re just kind of jumping over this unconditional jump statement and we’re saying, all right,

your input was definitely equal to six.

And then we’re jumping to the done area just past everything.

But if that wasn’t true, then we hit this unconditional jump that takes us to the next

comparison to see if the user’s input was less than 10.

You know, if that’s true, then we go to the true area to print another message and then

go to the done area.

If it was false, we fall through to the else jump, which will take us to here.

And notice how the else scope doesn’t actually make any comparisons because, you know, when

you have like an if else, sorry, when you have an if else if else if else if, you know,

any number of else if blocks, the else will always be executed if nothing above it actually

did execute.

execute so if you have an else block that means something will execute so we’re not doing any

comparisons we’re just saying you know when that scope is done we’re just going to jump to the done

area so all of these different scopes they’re jumping to the done area when they finish and

the done area is just this label right here where we say goodbye and that’s it let’s see did i copy

paste everything that i was supposed to i think so probably so let’s run the program and see if it

All right, it at least compiled.

So the basic if test, that was the first part of either this video or the previous video,

depending on whether I chose to split this up.

So let me comment out those calls real fast.

So I’m going to just comment out these calls real quick so we can only deal with the complicated

if else block.

So I’m going to enter like a three.

Whoops, let me do it again.

Three.

And so begin the if else test.

test your input was definitely less than 10 and then we end the if-else test so notice how only

one scope executed three was definitely less than 10 what other numbers did we have let me write

them down somewhere so I don’t forget oh they’re written down right here so we entered a three

which was definitely not a five and not a six so that’s why the less than 10 block executed maybe

only the first scope should execute so it says your input was equal to five notice how it didn’t

mention that it was a six or less than ten and then if we do a six it should just tell us that

we have a six it will not mention the five it will not mention the ten so we did we did five

already and then we did six and we did like a two which was less than ten we could also do a one

which was less than ten we can do anything that was less than ten and then the else would be if

And then the else would be if our input is probably like 11 or greater,

meaning it’s not less than 10 and it’s also not five or six.

Just we can see the else block.

So I’m going to do 11, which is the first number that should trigger the else block.

And it says no conditions were satisfied,

which was the message inside of our else block.

Let me just show you that again real fast.

This was the else block.

So message if else else or labeling on my port, I realize that.

But it basically says no conditions were satisfied.

The if else else.

I think that’s basically everything that I wanted to show you.

At this point, you should feel like you’re starting to become an expert at complicated

if else if else blocks, converting those from a higher level language into assembly.

assembly and I honestly recommend that you practice this like crazy while you’re trying

to get more used to it but you know hopefully you have everything you need at this point

keep in mind I’ve said this at the beginning I’ve actually I think I said this in a different video

when we use these branching instructions notice how I have jump equal to where’s that less than

yeah notice how I have a instruction jump less than the the family of conditional branching

conditional branching instructions that compares less than greater than less than or equal to

greater than or equal to the ones that I’m using here apply to signed integers and they won’t

necessarily work with unsigned integers and they won’t work with floats if you compare floats later

so just keep that in mind let me pull up my favorite book again real fast

where what the heck is that book oh dude where’s my document viewer document viewer can I get

document viewer can I get there there we go so I guess I didn’t introduce this

book at the beginning of this video but I probably should have this is my

favorite assembly book you can turn yourself into an expert with this book

by just on its own it’s open source and free the author gives this away he’s a

genius the person who wrote this book is a dr. Ed Jorgensen he’s a professor he

wrote this for his own classes and again it’s like a free open source book you

download a copy from his website if you look this up and and convert yourself

into an expert so let me collapse everything here and then I’ll go to

instruction set overview control instructions conditional control

instructions and I just want you to see real fast just as a recap I talked about

this in a previous video but when it comes to comparing things and checking

operands because if you want to see if two operands are equal you just check to see if

all of their bits are equal you don’t even really care whether they’re both integers or not

on the other hand notice how there is like a family here jump less than jump less than equal

to jump greater than jump greater than equal to that those instructions apply only if your

if they are unsigned or if you’re using floats for your comparisons you have to use this other family

of jump conditional branching instructions called jump below jump below equal jump above jump above

equal and i’m sure you can infer that jump below is the same thing as jump less than right jump

less than or equal to is the same thing as jump below or equal to it’s just that you need to use

a different instruction uh if you’re using signed integers or floats versus sorry sorry

a versus sorry sorry you need to use different instructions if you’re using signed integers

versus unsigned integers or floats so keep that in mind the code demo that i just showed you it’s

for signed integers if you were going to use unsigned integers or floats you would this

program wouldn’t work for you you’d need to replace my my branching instructions with the

the unsigned versions which i mean they work the same thing you’re still going to do a comparison

it still works. Anyway, so after having shown you that and making sure that everything actually

did work, I think we’ve talked about everything that we need to for this video. So yeah, I hope

you feel like an expert practice this on your own, you know, write your own programs just to make

sure you know how to convert a higher level language block into an assembly block. And you

should be on your way. Thank you for watching this video. I hope you learned a little bit of

bit of stuff and had a little bit of fun 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 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 want to just wake me up in the middle of the night.

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 uh if you look at the middle of the screen right now you should see a

QR code which you can scan in order to go to the website which I think is also named somewhere at

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

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

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

the darkness which is coming for us all.

Thank you.

The post Complex If-ElseIf-Else in x86-64 YASM Assembly – Full Guide with Code Examples appeared first on NeuralLantern.com.

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.

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.

Get a clear, hands-on look at Linux’s standard input (STDIN), output (STDOUT), and error (STDERR) pipes! In this video, we explore how programs communicate using these essential streams, with practical examples in Yasm Assembly (no assembly knowledge needed!). Learn to redirect outputs, handle errors, and read inputs like a pro. Whether you’re a beginner or seasoned coder, this fun demo breaks down the basics of Linux pipes. Subscribe for more coding insights and check out the full tutorial on our site!

Introduction to STDIN, STDOUT, STDERR 00:00:00
Overview of Pipes in Linux 00:00:07
Explanation of File Descriptors 00:01:12
Demonstrating Echo Command 00:01:24
Redirecting Standard Output 00:02:02
C++ Example with cout and cerr 00:02:48
Purpose of Separate Error Pipe 00:03:28
Assembly Program Introduction 00:04:55
Creating Data Section in Yasm 00:05:22
Writing Helper Functions 00:07:37
Printing to Standard Output and Error 00:11:29
Testing Output Redirection 00:12:43
Standard Input Explanation 00:14:54
Creating Stack Buffer for Input 00:16:03
Reading from Standard Input 00:17:28
Piping Input to Program 00:20:54
Handling Null Terminators 00:22:02
Conclusion and Call to Subscribe 00:23:53

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey everybody.

In this video I’m going to talk to you a little bit about standard input, standard output,

and standard error.

Three pipes that every program has in Linux that allow it to just communicate in a very

standard way.

I’m going to show you some example code written in Yasm Assembly, but assembly knowledge is

not necessarily required for this video.

You can just sort of follow along.

Anyway, what is standard input, standard output, and standard error?

Well for starters, every program that gets launched, under the hood, the operating system

will typically attach three pipes to it.

Basically one for standard input, one for standard output, and one for standard error.

the program pretty easily. So let’s see. Oh, I know what to do. There’s an echo command, right?

So here’s the program called echo. When the program launches, it’s going to have three pipes

attached to it, just like I told you before. These pipes also behave as file descriptors,

as if you had opened a file, but their file descriptor numbers are always zero and one and two.

Zero for standard input, one for standard output, and two for standard error. So if I launch the

program it’s going to get those three pipes those three file descriptors and

right away the standard output is going to get attached to the program running

our terminal here well not necessarily the actual terminal but bash under the

hood which is the program that we’re using to interact with the operating

system so basically the program launches and based on this incoming argument that

I give it hello then it’s going to print the string hello right but what it’s

its standard output pipe its standard output file descriptor I can test this

for sure by just sort of doing the command again and then muting its

standard output pipe with this little shell trick I’ll do a arrow or a greater

than angle bracket and I’ll just send the first pipe I’ll do one I’ll send it

to dev null and on Linux dev null is just if you send anything there it just

it’s just totally ignored so if i send uh the pipe labeled number one to just nowhere then notice how

it doesn’t show on the terminal for me right it’s pretty cool let’s go a little bit deeper into this

i just want you to see real fast before i write an example program in assembly what you would

probably end up doing in c plus plus so we usually do something like iostream in germane you know

We’ll say using std cout std c error std and l and so forth.

And then if you actually want to print a message to the user, we’ll say cout this message prints

to std out because that’s what cout does by default.

And then if we do c error, a lot of people haven’t actually seen this and I personally

always forget that it’s even there if you print to see error it prints a message to standard error

why would you want two different pipes that printed messages and one is called output and

one is called error well like i’ve said before in other videos it’s really convenient to be able to

have programs automate other programs for example if you have a program that is launching you know

a second program maybe the second program fails in some way or wants to complain to you in some way

or wants to complain to you in some way, it would usually, if it’s smart,

print the complaint to standard error.

It may not actually use C error because maybe it’s not a C++ program,

but it would print to pipe number two, file descriptor number two, standard error.

And then that way, the program that’s launching it can just sort of ignore messages

that happen on standard output because we can assume all of those messages

are just normal info messages that a human might want to see.

Or maybe you want to record to a log or something somewhere

log or something somewhere and just kind of save it away.

But the error messages are a little bit more important than the regular,

you know, normal messages.

So if you’re automating another program,

then your program probably wants to take standard output and either ignore it or

just kind of send it to a different file.

And then it wants to take standard error and pay more attention to it.

Write it to a log file, save it, maybe check that it’s actually blank.

And if it’s not empty, then maybe alarm bells go off.

Something went wrong.

We have to alert someone or, you know, make a database entry, send an email, whatever.

And yeah, just pipe one and pipe two is how you accomplish that.

So this is what’s happening in C++ when you do that sort of thing.

Okay, so now I would like to write a sample program that just kind of demonstrates this

real fast.

So please bear with me.

I’m going to go really fast for the assembly portion because this is not an assembly video.

to learn more about how to write assembly in the first place than see my other videos.

For now, I’m just going to create a little blank file here.

Let’s see where the heck is my window.

I’m on a multi-window system here.

Okay, so I’m just going to paste a little data section.

This is Yasm assembly.

A little data section.

I’m just going to fill it up with strings.

I’m going to make a string for the introduction.

Hello, the module has started.

A string announcing everything that we’re going to do.

We’re going to begin printing to standard output and standard error,

and then some messages that will go to each.

And then some messages that will go to each and then a standard input string, which we’ll

talk about after the standard output and standard error.

So just a bunch of strings.

I’m going to make a buffer size.

I’m going to make system call codes for reading, writing and exiting.

If you want to know more about system call codes, see my other videos and some file descriptors.

This is exactly what I just talked about.

The file descriptor for standard input is zero for standard output is one for standard

for standard error is two.

And then I’m going to do a system exit code of zero,

which actually doesn’t matter that much,

but I’m going to do it.

So now I’m going to make a, let’s see,

a global,

hmm, make a global.

Oh, did I already make the text section?

Here we go.

So there’s the text section.

So the data section is over now.

So data section is over now.

I’m going to make the tech section.

I’m going to make a global entry point called start.

Again, if you want to know more about assembly programming in general,

see my other videos.

But so this is the entry point of our program.

At the very end, we should probably just program that it exits with success

and test it out real fast.

So basically right now this program does nothing.

Let me just double check.

Clear and make run.

I have a make file under the hood, but this is not a make file video.

If you want to know more about make files, see my other videos.

know more about make files see my other videos but basically it just starts running and then

it just dies right away okay no problem let me actually can i i want to fix that make file

because it’s it’s labeled after like a different project that i was doing let’s do

there’s no need for me to even do this i’m just uh i just can’t help myself okay so there we go

going back to the editor.

We have a program that does nothing.

I’m going to copy paste in a couple of useful functions that I use elsewhere.

Again, this is not an assembly video.

So, so you can look at my code if you want to, if you just kind of want to know how this

works, but not the point of this video.

So I’m not going to spend too much time.

Maybe I’ll just briefly talk about what it does, but not the point of this video.

So the first thing I’m doing is I’m adding a function called print null terminated string

function called print null terminated string just you know it sweeps through a

string or actually it asks another function I made to find out how long the

string is and then it’ll print the string to some file handle that I gave

it like standard output or standard error and you know it calls on this other

function called string length which I just wrote in pure assembly for fun even

though I didn’t need to and it just kind of sweeps through the string until it

finds a zero and then it knows how long the string is and then CRLF just prints

is and then crlf just prints a carriage return new line uh carriage return new line just um

with the same idea with the print null terminated string function and you can see all my strings have

null terminators that’s the dot zero at the very end of it okay so we got those helper functions

uh the next thing that i need to add in here is

do an intro like my growling i used to have a professor who would go

and he would go oh god when something went wrong and i do that all the time even when things are

going right okay so i’m going to paste a little function here called intro and this is not going

to be anything important it’s just going to print a little hello message you know it just uses my

intro string and then just prints it with those other functions i made so that means now my my

I can call intro real fast and then it’ll return when it’s done.

If I just sort of run the program again, you can see after all the build messages,

it’s just printing that the module has started.

Okay, so nothing super important yet.

Now, what I’d like to do is capture some incoming arguments real quick because…

Let’s see standard input.

Well, that’s actually not going to work.

Let’s see what I want to do here.

No, I think that’s part of a different program.

OK, I’m going to call a demo.

I don’t think I need to add that one thing that I was just looking at.

So I’m going to call a function that’s going to be our main demo.

So it’s going to jump down somewhere.

I’ll just create the function down later.

So let’s see.

Where is it?

Standard input.

I’m going to start off by saying this is my standard input function which is this and

is this pop p and then pop r12 and then it returns if you don’t know what a prologue

and epilogue are or why I’m doing pushes and pops just see my other videos but basically

I’m responsible for preserving it.

And I’m going to use the base pointer to help me remember where the stack started.

I’m just going to choose to…

What did I do?

I started the wrong function.

I’m going to do that one later.

Okay, for now, let me go find where that other one is.

Oh, there it is.

Should have double checked.

I’m going way too fast.

I’ll just copy paste this whole thing from my solution.

So I’m going to do standard.

This video is a mess.

Honestly, it’s a mess, but that’s okay.

I’m going to try my best to explain it.

So I have this function standard output standard error and I’m calling it here.

So it should jump right down there as soon as the program starts.

The standard input one is not getting called yet, but we’ll call it at the end of this

video.

print null terminated string function to print a message to standard output.

Remember standard output was just you know pipe one. Standard error is going to

be pipe two. So if I go back here and I say I want to print this matches to that

pipe then it’ll go to standard output just like the echo program was doing

when we looked at it a moment ago. And then next we’re going to print to

Oh, that was just an announcement that we’re going to begin.

So this is the real message that will say this is definitely going to standard output.

And then this other message is going to go to standard error, which is when we when we

looked at C error or pipe number two a moment ago.

So basically, I’m just printing an announcement and then two important messages.

One is going to pipe one and one is going to pipe two for standard output and standard

error.

OK, like really not very complicated at all.

Right.

So if I run this program now, hopefully I didn’t crash it by copy pasting out of order here.

Yeah, there we go.

Clear and make run.

So notice how it says that the messages are going to be printed.

And then notice that both of my messages actually show up on the terminal.

The one that says this message will print to standard output, number one, pipe one.

This message will print to standard error, pipe two.

They both get printed to the terminal because by default, the terminal will just take both of those pipes.

both of those pipes it’ll take one and two standard output and error but I can

use those little redirection tricks to mute one or more of those pipes so I’m

gonna say pipe one which is standard output I’m just gonna redirect that to

dev null to say I don’t want to see standard output if I run it again

notice how the only thing you can see on the string or on the screen is standard

error pipe to file descriptor 2 on the other hand if I redirect file descriptor

descriptor to pipe two to nothing then I should see all the normal messages and not see the error

message notice right here it’s it prints all the regular you know make file stuff and then the

welcome message and then here’s our message that says this is going to be printed to standard output

so notice how the error message is missing so cool if I mute both of those I can do that I can

then nothing gets printed at all because that’s all we really have is standard output and standard

error all right not too bad right that’s the basic idea between redirecting and things you

could also do things like this if I okay this is not part of my plan but suppose I wanted to take

any error message and redirect it to instead of dev null I wanted to redirect it to some kind of

standard error.txt.

Notice how nothing seems to have shown up on the screen, but if I list the directory,

now there’s a text file called standard error that contains the error message.

So you can redirect pipes, you can reattach them if you’re like an elite hacker.

You can do lots of things with them, but that’s as far as I’m going to take it right now.

I’m going to remove that.

Now let’s look at standard input.

How do you send input to the program?

Remember when programs call other programs, they can send each other standard input too.

It’s just that when I launch something on the terminal, I’m just, you know, I’m the

human and so whatever I type or, you know, what command I type is going to go into standard

input if I do it the right way.

So let’s go back to the program here.

Okay, so let’s finish up standard input.

And let’s see the pre-made code that I had here.

I had the prolog and the epilog, right?

Move the base pointer

RBP and R12. Oh, I got to put the

Base pointer back into the stack pointer. Let’s see move

Again, this is not an assembly video. So just try to hang on here. So what I’m gonna do in this video

I thought I was cute when I was making this plan. I know I’m not like that clever, but um, I

Thought hey wouldn’t it be fun instead of having a global

or the BSS section. What if I just made the stack a buffer? This is kind of what you do when you make

a local array in C++. You’re making a buffer on the stack. So this is not a stack pointer video.

So long story short, I’m just going to keep track of where the stack pointer started with this base

pointer. That’s why I have to preserve it there. And then I’m just going to subtract my buffer size

from the stack pointer. And what is the buffer size? I’ve chosen to do a buffer size of about

So that means the user or me, I could send about eight kilobytes, maybe eight kilobytes

or less into standard input and be sure that it’s all actually going to be received by

the program.

And then I’m just going to use R12 to remember where the start of the buffer is, which is

just wherever the stack pointer started.

Because if we subtract and then the data that increases is actually increasing in memory,

but making room on the stack decreased, it’s just the way it works.

There’s going to be another stack video out there.

stack video out there anyway for now I just create a buffer on the stack and

then I’m gonna print a little hello message so I’m gonna print this so just

my message saying hey we’re about to do something from standard input and then

I’m gonna send that to a standard output so the message is gonna go to standard

output but I’m announcing that we’re about to read from standard input

assuming I actually cleaned up correctly let me double check this this should

It should just simply say that it’s going to without crashing.

Okay, looks good.

So then now I’m ready to actually read from standard input.

We’re going to use a system call from this.

If you want more information on system calls, see my other videos.

But basically you just go to the system call codes table,

look up appendix area of whatever textbook you’re using.

And you say, what’s the code to read?

I want the system to read.

what you know i want the system to read so i define that as system read and if you look up

here in my program it’s just call code zero so sys call code zero is to read from somewhere

and then uh where do i want to read from that’s the second argument for the standard

or for the system call i want to read from standard input that’s going to be the number zero

if you recall and then here is a pointer to the first character of wherever i want it to

read into. So it’s going to read from that pipe, but it has to, it has to write the data that it

read somewhere so that I can save it and access it. So R12 is basically going to be a bunch of

free bytes that I created on the stack. So I like, you know, I’m, I like made the stack bigger,

but it’s mostly empty or with junk data. And R12 is just pointing to the first byte that I have

reserved. So, you know, you could imagine maybe you make a global variable in the BSS section up

up at the top, you know, like an eight kilobyte array of bytes, and then just sort of point

it to that. But in my case, I’m just using the stack because I think it’s cooler. So

I tell it, Hey, that’s the first bite on the stack that you want that I want you to start

reading from. And then I give it the buffer size, which we just looked at. And then I

do a system call and then the system now should do all the hard work for me. It’ll look at

the pipe for standard input. It’ll grab all of it. And then it will only grab, you know,

it’ll stop if the input ends before that and then when I’m done I should be able

to actually read from the buffer which is sitting at R12 and print it to the

screen so the next thing I’m gonna copy paste in there is I’m gonna print what

I just read from standard input so this is another call to my function my little

doggy wants to go pee even though he’s completely lying he just went pee so at

wants to go outside and lift his leg and do nothing and then come back in and demand a treat.

I’ll let him do it in a few minutes just in case but trust me he’s lying he’s laid like five times

today. Anyway I sometimes I regret teaching him to growl at me. It’s so cute but like it’s not

cute right now. I don’t know maybe it is. Let me know in the comments. So basically I’m going to

take that R12 buffer that I just wrote to and I’m going to print that directly to standard output

output and this is not really the important part of the video.

So I’m going to do that and then I’m going to kind of clean up here at the end of the

function.

And then maybe I’ll say goodbye.

I think I just added a string for that.

So maybe I’ll say goodbye.

I’ll say goodbye before we end the function and then I’ll actually return.

So let me go here and run the program.

Let’s see, begin.

printed because we didn’t send anything and we also didn’t call that let me call

standard input call stdin and so now it’s actually gonna print basically

nothing oh I didn’t send it anything so it’s just kind of hanging you probably

want to check this sort of situation but that’s that’s not the point of this

video let me show you how to pipe some some stuff into standard input real fast

hello and then just put a little or bar in the shell this will take the output

of echo and instead of printing it to the terminal it’ll attach its standard

output into the standard input of make run pretty cool shell trick so now we

should see the word hello the word hello printed and that’s what it does we have

detected the following stdin and it says like here’s begin that’s just a string

that I had that I print every time and then here’s the string that it actually

And then it ends.

Pretty nice.

I think maybe we could probably do the empty thing if I just started typing here.

And then maybe I hit control D to detach the buffer.

And yeah, that’s what it does.

It sort of prints here and then it ends there.

Didn’t do a new line.

I think it probably doubled it for some reason because I…

Let’s see.

I didn’t plan for this.

Let me see.

plan for this let me see it printed oh because I did I did not null terminate the string so

actually what it did is it uh let’s see if we can do that real fast one more time I’m going to go

one two three four five then I’m going to just disconnect the standard input buffer because the

printing function needs a null terminator to know when to stop there’s not going to be a null

terminator because I just typed and disconnected the uh the input so it’s actually going to just

until it randomly finds a zero and then it’ll stop so if I disconnect it it

that explanation was bunk let me try that one more time I’m gonna go a bunch

of H’s I guess there is a null terminator I disconnect it no no see how

yeah these little symbols there so it does kind of print until it finds a

null terminator but I guess I was confused because it seemed like it

like it printed it twice what’s actually happening is when i type then it’s getting sent to the

terminal which and that’s not part of the program that we just wrote then when i disconnect standard

input then the program finally prints everything that i actually typed until it hits a null

terminator in this case it looks like it seems to have worked but uh if i just do like a couple

sevens and then disconnect probably have to do this a bunch of times before we’ll see those weird

What did I do? Hit enter. That seems to have worked. My dog is stressing me out

but I love him. Alright anyway just trust me on this sometimes it’s hitting the

null terminator in time sometimes it’s not. But I hope by now you understand the

difference between standard input standard output and standard error. Thank

you so much for watching this video that I’m recording and I hope you learned a

little bit of stuff and had a little bit of fun. I’m gonna let my dog lie to me

I’m gonna let my dog lie to me for a second 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.

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

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.

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 Mastering Standard Input, Output, and Error (STDIN, STDOUT, STDERR) in Linux with Yasm Assembly Examples 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.