Learn pointers & dereferencing in x86-64 YASM assembly and how to pass them correctly between assembly and C++ in a hybrid program. We build a small working example that sends strings, longs, and doubles both directions using pointers, modifies values across module boundaries, and explains why pointer-to-double still uses general-purpose registers. Includes a quick demo of stack misalignment crash + fix.

Great for assembly beginners moving to real programs, systems programming students, or anyone curious how low-level code talks to C/C++.

00:00 Introduction to Pointers and Dereferencing in x86-64 Assembly
00:28 Pointers explained in C++
01:02 Changing values via pointers in C++
01:43 Pointers in assembly basics
02:09 Defining variables and pointers in YASM data section
03:23 Pointers are always integers even to doubles
04:20 Function arguments are pointers treated as 64-bit integers
05:00 Driver C++ code overview
05:58 Marking extern “C” functions
06:40 Local stack variables and passing pointers
07:51 Stack lifetime warning
08:34 Assembly data section strings and numbers
09:39 Print null-terminated string helper functions
10:38 External symbols and hey_driver_print_this
11:29 Point function prologue and stack alignment
13:04 Extra push for 16-byte alignment
14:20 Printing welcome message from assembly
16:00 Driver sees initial long value
16:58 Printing received string from C++
18:20 Using received char pointer without dereference
20:21 Modifying incoming long via dereference
21:46 Driver sees modified long value 101
22:43 Calling back to C++ to print assembly-owned data
23:48 Passing pointers to assembly string long and double
25:08 Driver prints assembly-owned values and addresses
26:14 Summary of pointer passing between modules
26:36 Stack alignment crash demonstration
27:39 Adding extra push/pop fixes segfault
28:00 Closing remarks and call to subscribe

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to 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 pointers and dereferencing in a YASM x8664

assembly program, also as a hybrid program so that assembly and C++ can talk to each other

and send each other pointers and send each other data and things like that.

for what pointers are.

I’m going to write in C++ for a second.

Suppose you have a pointer for an integer.

We’ll call it P.

Suppose you have an integer by itself.

We’ll call it A.

Let’s say that the value of A is 5.

And if you wanted to say that P points to A,

you could say P equals the address of A.

I’ll put C++ at the top here.

And so now if I set A to 6

then I print P a dereference of P this is not like a full pointers tutorial

but basically by changing a I’m changing what P thinks it sees as a value

assuming ID reference it I could also let me do a print 6 here I could also

just change the value through P I could say dereference P and I could say equals

would actually print a seven right so you know you can have regular variables global variables

whatever kind of you know memory stuff on the stack and to get a pointer to it you really just

need to get its memory location in c++ it’s kind of easy syntactically you can see what’s happening

in assembly you really just need the memory location stored somewhere you could store that

variable that just simply stored the memory location of some other variable.

You could have a 64-bit register store the value of a variable.

Let’s say we have like a, I don’t know, my whatever, my number let’s say inside of assembly.

I’ll do ASM here and we say it’s a quad word and it starts off as this number or whatever.

So if you haven’t seen my previous videos, go see them for the basics of assembly and

of assembly and linking and make files and all that stuff but you know if you

have an assembly program and you have a data section and you define a global

variable like this what you’re basically saying is I want to take this giant

number and I want to write it into eight bytes that’s the DQ it says data quad

word I want to write that giant number across eight bytes and then I want to

get a pointer to it stored in the my number symbol so my number is not

actually the value it’s a pointer to the value so you know later if you want to

you know later if you want to move you know something into a register if you did this

that would move the pointer into rax but if you did this

with deref symbols after it or around it then you would move

maybe i’ll put that into rex you’d move that actual number that we specified into rex

into Rx. It’s important to understand also that pointers are integers even when we’re pointing to

doubles. So for example sometimes people make this mistake they’ll say you know my double

and they’ll say it’s a quad word meaning this is going to be a 64-bit double precision floating

point number and they’ll do like 44.55 or whatever. So that is a double and it is in memory

you know what is the symbol of my double remember it’s supposed to be just a

pointer right it can’t be an actual double because a memory location is not

a double a memory location is an integer so that means if you wanted to move a

pointer into a register you would only be able to move the pointer into a

regular general purpose register not a floating point register and you should

use the regular movement instructions for just regular general purpose

So keep that in mind if you see a signature like this like let’s say function F and we have

You know, let’s say long a and long B and actually let’s do pointers

Let’s say long pointer a and long pointer

B and double pointer C all three of those arguments are actually 64 bit integers

Because they’re all pointers even if one of the pointers points to adult a double

double why did I say dull pointers aren’t dull they’re exciting okay so I’m gonna open up some

code here real fast so usually I don’t explain my uh my driver I’m gonna explain it to you this time

because it’s kind of doing a little bit more than my other videos um again if you don’t have uh the

knowledge of how to make a make file see my other videos because that’s explained there for now I’m

what we really need to do is write a driver and an assembly module for a

hybrid program again hybrid programs covered in other videos so the driver is

pretty easy I’m just going to copy paste it honestly here and then just kind of

explain it to you the driver is pretty easy we’re going to do I O stream so we

can print stuff we’re going to mark an external function called point as extern

C so that just disables name mangling which means the C++ module will be able

will be able to call on this function called point and it won’t expect that

the point function has its name mangled like C++ does the reason being is that

point is actually going to be in a side it’s going to be inside assembly where

its name will not be mangled this disables the ability to overload but

that’s okay we don’t care it’s going to take two pointers a pointer to a character

and a pointer to a long since both of those are pointers they’re both

64-bit integers even the character pointer and then we have a function that is internal to this

module called hey driver print this remember we’re inside of the driver program right now

so if you look at the bottom it’s just a function that takes in some pointers

and then prints some stuff so it’s going to print like it’s going to print what the string is

it’s going to print what the long is my dog’s growling at me i’m going to ignore him because

i literally just let him pee and poop at this point now he’s harassing me for treats

now he’s harassing me for treats he always does this okay so uh the string the long the double

this function expects to receive three pointers to different data types it’s just going to print

all of them and the point get it the point of this function is we’re going to go inside of

the assembly module and then have the assembly module call on this function so that we can we

can prove that we can have stuff sent from assembly to c plus plus or c using pointers

using pointers we can have data sent over so anyway that’s why both of these

are in here the point needs to be marked as no name mangling because point is

inside of assembly which will not name mangle and then hey driver print this

that needs to have name mangling disabled also so that the assembly

module can call on this other than that we’re just basically inside of a main

saying hey this is the c string we’re making a c string inside of the main function notice how

this is a local variable so that c string is going to show up on the stack it’s going to show up in

the area that is owned by main for main stack area same thing for my long that’s a local variable on

the stack um and but then we can actually send pointers to those pieces of data to another

function in another module you don’t have to only transport globals or stuff on the heap

or stuff on the heap, you can transport pointers to local variables. Just make sure that by the

time this function finishes, then nowhere else is actually using that data because,

well, being on the stack, once main function or once any function finishes, then its portion of

the stack will be cleaned up and removed and it’ll be junk data. You’ll probably get a seg fault.

But for now, we’re not going to use anything on the stack. We’re not going to use these local

just going to use them quickly on this call to point and then we’re going to return to the

operating system and finish the program. So that’s the driver. Now the hard part. Let’s do this in

assembly. So for starters, I’m going to make a data section and just explain it to you very,

very quickly. Again, if you don’t understand the basics of YASM x86-64 assembly, did I mention

that that’s what this language is at the beginning of the video? I guess I should put that in the

put that in the description or record an announcement that I can tack on at the beginning

or something. Anyway, so if you don’t understand how to do this, see my other videos, but basically

we’re going to make a data section. We’re going to define some strings. Here’s like an announcement.

Oh, we’re inside of, you know, the module now, the assembly module. And now we’re going to print

the received string. And then we’re going to make a string that is owned by assembly, which we can

into C++ when we call the function inside of the driver.

So this string is owned by the assembly module.

Notice how these are null terminated strings.

I just have like a comma zero there,

which means I have some extra functions

I’m gonna paste in that we’re not really gonna talk about

because they’ve been discussed in other videos

just so that we can print null terminated strings.

Then I’ve got a new line here,

you know, carriage return line feed.

And then I’ve just got some numbers

that are owned by the assembly module.

Then I’ve got a system write call,

call code one for the system call writes and file descriptor standard output so I

can print just to the terminal again if you don’t understand this see my other

videos so now let’s start the actual text section so this is where our

instructions start so we got the text section here and we’re going to use some

external symbols don’t worry about these I’m just using my own little library to

and input integers if you have access to this library use it if you don’t if you’re watching

at home and you don’t have this library then that’s fine you can use you know printf or

scanf or something like that to get and print floats from and to the user

but yeah I’m just using that and then I’m marking an external function here called hey driver print

this if you recall the driver module has a function called hey driver print this so

just allows my assembly code to call on that external function. Okay now next

piece of code. This is going to be… actually I’m going to paste the print

null terminated string function and related code because it’s just like a

big giant mess and we’re mostly going to ignore it. So just to show you what I’m

doing here I have a function called print null terminated string so that I

can print these strings up here and then I have it rely on a function called

string length that I have implemented up here and all it does is just

implemented up here and all it does just calculates the length of the string and

then a crlf function so I can just call that so that’s all explained in other

videos don’t worry about it for now we’re going to start the actual entry

point remember the driver was just gonna call point right so now we just have to

implement point in the assembly module so that’s gonna be like down here our

our entry point so the signature for this function is going to be character

pointer and then a long pointer and it doesn’t return anything and remember

that if we look back at the driver that should match the signature right it’s a

character pointer and a long pointer and of course this is just a comment that

reminds me of what to do in assembly you don’t really have a signature you just

sort of use registers but I’m reminding myself that RDI is going to be a

character pointer and RSI is going to be a long pointer.

Here’s a note to myself that I’m going to use R12 and R13, which means

the first thing that I should do, well actually before I even do that, I should

return from this function because it is a function. I marked it as global

so that the other module could call it, the driver module could call it. Again,

see my other videos for hybrid programs.

But so now the, you know, if the driver calls this function, then now we’re inside of

and there’s a return statement so it’s a valid function I should preserve the

registers that I’m going to use that are marked as Kali saved for the ABI so I’m

going to go prologue and then an epilogue and I’m going to say push r12 and push

r13 and then I’m going to pop r13 pop r12 they should be in reverse order if

you’ve seen my other videos you’ll know this and the the thing about this

the thing about this particular program is we’re going to run into stack alignment issues

so uh if you don’t know about stack alignment and how it can crash your program without you

realizing what’s wrong see my other videos but for now we’ll assume you know that and uh i i

already know from running this program in advance that it’s going to be out of alignment by eight

bytes so i’m just going to push an extra register onto the stack and that’s going to put it back

I know it looks weird, but this is going to work.

Let me get rid of this here.

Okay, so.

And then maybe if I can remember at the end of the video,

I can just remove that extra push-pop pair,

and you’ll see the program starts crashing.

But at home, you can do it just to double check.

So the first thing I really want to do is,

after I push and pop,

is save our incoming arguments.

Remember, the first integer argument

and the second integer argument,

argument they come in as RDI and RSI in assembly per the ABI if both of these

things are pointers it doesn’t matter what the data type is it could be

pointing to anything including a double and these would still be considered

integer arguments because well RDI and RSI are just going to be loaded up with

memory locations which which are integers so I’m going to save our

arguments to R12 and R13 now justifying our push and pop pair then I’m going to

little welcome message so print a little welcome message again you don’t need to know about this

function but it’s explained in other videos that I’ve already published we’re going to print our

hello beginning message I’m getting nervous he needs to take a second poop sometimes it’s poopoo

number two time for him and he’s not really just lying about a treat but he did go pee and poop

But he did go pee and poop already.

Okay, he just left and walked away.

Okay, if he comes back, I’m letting him out this time.

I’ll pause the video if he does it again.

Okay, I’m pausing the video.

No pee lied.

He went outside, lifted up his little leg, and a couple of drops of pee came out.

Now he’s staring at me like he deserves a treat.

Sorry, buddy.

I wish I could eat constantly all day long, too.

But life isn’t always fair.

isn’t always fair anyway let’s see I might even lined up on the camera

anymore I don’t even know so we’re looking at this code here is going to

print a welcome message let’s see if that actually works so I’m gonna do make

run again make files are whoops what did I do loader dot asm what did I do what

did I do I somehow copy pasted the wrong make file

What’s the name of my source code file?

It’s point.

I guess I’ll just change it, and then it’ll probably work.

It’s still in assembly module.

Hopefully that didn’t mess it up too bad by copy-pasting the wrong source code.

Okay.

What is going on here?

Floater.

Oh, I need to change that.

Hang on.

Let me fix this.

I don’t know if I’m going to edit this out.

out. It’s fun to watch me struggle sometimes. There we go.

Point.

Alright, let’s give it another try.

Oh no, star dot so no such file a directory. Dang it.

Okay, now this seems to work. I may or may not have edited

that out. I copy pasted the wrong source code into my make

file. So I had to manually adjust it. Then I forgot to

copy paste my library file into the build directory. So I had

The driver sees my long as whatever.

What’s going on?

Print an alternate string begin.

Oh, the driver is printing a bunch of stuff.

Okay.

I started to think, why does it look like the program has a lot of stuff going on?

Oh, that’s the driver.

Okay.

So the driver says it sees its long as 100.

And then now we’re inside of the point module.

So that’s the only thing we’ve done in assembly so far.

so far then the driver has regained control maybe I should add a couple of

new lines in there so I don’t get confused again we will do a C out and L

and we’ll do two of those run the program again and then I won’t get

confused about the messages okay so now we’re inside of the point module and

nothing is happening so points let me get rid of the make file here and

and we’re just printing a welcome message nothing else so now let’s print

the received string so what am I talking about so we’re gonna print a prefix

basically saying hey we received the following string right so if you look at

the symbol message received string it’s just gonna say we’re now printing the

received string and then it’ll print it so what are we actually printing we’re

What is R12? R12 is a character pointer to the print me string. And so basically this

function print null terminated string, it takes a character pointer. So we’re giving it a character

pointer that we received. When point was called by the driver, notice how it gave a pointer to

the C string. You know, all arrays are basically pointers. They’re just different syntactically

just different syntactically sometimes so if i declare an array of some length and i give the

symbol somewhere that symbol is really a character pointer so um by calling point with my c string

i’m calling point inside of the assembly module with this character pointer so that means even

though this c string is owned by the driver by the c plus plus module the assembly module has access

So that means we should be able to print it right now already.

So just the rest of it is just like giving a pointer.

And notice how I’m not dereferencing R12.

If I did dereferencing around R12, then we would be looking to that address and seeing what’s there,

which wouldn’t work for printing a null terminated string.

So let’s just run it again.

I don’t know if you can hear him.

This dude is growling at me still because he wants another treat.

He just got denied.

He’s trying to do it again.

do it again. I let him outside people. He’s been outside like three times already and he just went

out like two minutes ago. Okay. I love him so much. It hurts my heart and he knows eventually he’s

going to break me because it hurts my heart or I’m like too distracted. It’s like, you know,

pulling the crank on a slot machine in Vegas. You know, eventually something comes out.

That’s what he does to me. I’ve accidentally trained him. So now printing the received

Now printing the received string and notice how it prints.

Hello, this is a C string owned by me.

So our assembly module is able to print a C string that was created locally by a C++ module.

So we’re handing around pointers.

Nice.

Can you hear me?

He’s getting louder.

So now let’s modify the incoming long.

Can you shush your freaking pants, please?

Shush your pants.

shush your pants you know the sad thing also is he’s so old that he’s deaf now

so he used to know what shush your pants meant it meant I’m not listening to you

and you might as well stop because I’m not gonna do anything based on your

harassment but now he can’t hear me say shush your pants so he just harasses me

all day and all night okay um so I’m gonna copy paste a little bit more code

Modify the incoming long.

So remember again that the point function, it received a pointer to a long.

We’re calling the long change me on the inside of this, but it’s coming in as R13.

And if you notice what I’m doing here is I’m just saying let’s increase the long.

So I’m going to dereference R13 because R13 is a pointer.

So I’m saying let’s go to the memory and change the long that is inside of memory.

And we have to specify that it is a keyword.

it as a keyword so that we you know we don’t confuse the system the system might think are

you modifying a keyword or like a double word or like a word like how big is your data all we know

is it’s an integer because it’s the increase instruction so I’m saying we got a keyword you

know a 64-bit integer sitting at that memory location I want you to dereference it and increase

it and going back to the driver we’re providing a pointer to our long so the long starts off is 100

and we’re just giving a pointer to it the next thing that we can do is we can

ask the driver to print our own stuff actually you know what let’s run the program right now

just to show that the driver can see the change in the long so i’m going to run it again notice how

first when the driver says hello it sees its own long as 100 then we’re inside the assembly module

long and then we return to the caller which is the driver notice how at the

very end of the program the driver sees its long as being 101 so we were able to

modify data that was owned by a different module just by passing pointers

and de-referencing them okay cool so now the next thing that we should do is let’s

ask the driver to print our own stuff that we own because remember if you go

to the very top you know we own some stuff we own some we own a long we own

float, right? So we want to be able to do something with that. So I’m going to copy paste this,

ask the driver to print our own stuff. So I’m going to move three items inside of arguments

for a function call. And then I’m going to make a function call calling the function,

Hey driver, print this again, Hey driver, print this is actually owned by the C++ module.

a pointer to a long and a pointer to a double remember even pointers to doubles are actually

integers so they use the general purpose register so that’s the three arguments right there rdi rsi

and rdx m and then we’re giving the first pointer is going to be the c string so message string

inside asm so you can see that’s this right here and then the next pointer is the long

inside ASM and the third is the float where did I just go I’m getting confused my dog is harassing

me right now so bad notice how I’m not dereferencing so like if when we were increasing the incoming

long before R13 was a pointer so we dereferenced while we increased so that we would increase the

actual value and not the pointer and not the pointer’s memory location but here we’re not

C++ module the actual pointers to our data. We don’t want to give it the data itself. We want

to give pointers to the data so we’re not derefing with the brackets. So then we call it and when we

get back in here it should just be able to print everything. So I’m going to run it one more time.

We’re going to make it and run it and so now let’s see. So here we’re inside of our assembly module

And then here the assembly module has just called on hey driver print this.

Remember the C++ module doesn’t actually call this function.

The assembly module calls it.

So we’re like going back and forth.

We’re kind of crisscrossing.

So now the drivers print this function says we got the following string.

Notice how that’s the string that is owned by assembly.

So we define that inside of our data section in the assembly module.

And then it prints the long.

It prints it as hex.

And it just sort of prints the value.

it just sort of prints the value then it prints it as hex again and then prints at the value

i think actually not hex i think this prints the memory location let’s double check real fast

yeah so remember um in c plus plus i know this is not like a c plus plus video but um

if the long is a pointer then if we just print it without dereferencing it we should see a memory

location so it’s telling us uh that the long’s memory location is this and the doubles memory

location is that and if you stare at those two numbers long enough and you understand hex which

And do you understand hex, which you can see my other videos for?

You’ll see that those memory locations are right next to each other because that’s the way we define them inside of assembly.

So we now have the ability to have data that is owned by assembly and give it to C++ or C using pointers.

No problem at all.

And then the printing driver thing exits and then the actual driver regains control.

And it just says that it sees it’s long as 101.

it sees it’s long as 101 so uh yeah that’s that’s pretty much all i wanted to show you for this

now you hopefully are an expert at passing data back and forth between various modules using

pointers we’re not using references because references are like a little bit a little bit

less compatible pointers are just really easy they totally work in assembly no problem

one more thing i just wanted to show you real fast before we go even though there’s another

video you should check out for stack alignment I just want you to see what

happens if I remove this extra push-pop pair so now my stack is about eight

bytes off of its previous alignment because you know we’re not pushing an

extra eight byte value and somewhere inside of the let’s see print null

terminated string and then the hey driver print this oh and then we go into

like a bunch of C stuff the program should probably crash because anytime

you use a GCC function or a GCC library or something like that the stack has to

be aligned to 16 bytes so if it’s off by 8 then it’ll crash and how did I know

that I needed this well I just ran it first and it crashed and then I added

the extra push pop pair and it didn’t crash and I realized it was definitely

one more time we should get a seg fault yeah we get a seg fault stack alignment oh no with no

description of what’s going on if you were in gcc you could i mean sorry if you were in gdb you

could probably figure that out eventually but why not just give it a try add another push pop pair

run the program again with no other modifications now it totally works

okay well uh i think that’s uh that’s all i have for this video thank you so much for watching i

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

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

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 to me or you could you control 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

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 this

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

darkness, which is coming for us all.

Thank you.

The post x86-64 Assembly Pointers & Dereferencing Explained – Hybrid C++/YASM Example appeared first on NeuralLantern.com.

In this beginner-to-intermediate assembly language tutorial, we dive deep into unconditional jump instructions (JMP) in x86-64 assembly using Yasm syntax.

We cover:

• What unconditional jumps really are (basically a “go to” for assembly)
• How labels work and how to create them
• Why JMP has unlimited range (unlike conditional jumps)
• Practical demo showing how to skip code sections using jumps
• Comparison between jumping over code vs letting it execute
• Quick look at why this matters before learning conditional branching

We also reference the excellent free open-source textbook by Professor Ed Jorgensen (May 2024 version) which is highly recommended for anyone serious about learning x86-64 assembly.

Whether you’re preparing for university courses, reverse engineering, operating systems development, or just love low-level programming, this video will give you a clear understanding of how unconditional control flow works in modern x86-64 assembly.

Next video will cover conditional jumps (je, jne, jg, jl, etc.) and their limitations.

Enjoy the video and happy coding at the machine level!

Introduction to Jump Instructions 00:00:00
Recommended Free Assembly Textbook 00:00:23
What Unconditional Jumps Actually Do 00:01:27
Labels Explained with Examples 00:02:40
Unlimited Jump Range Advantage 00:04:43
Overview of the Demonstration Program 00:06:56
Building and Running the Jump Test 00:09:21
Live Jump Test Demonstration 00:10:53
Effect of Removing the Jump Instruction 00:13:50
Jumping in Different Directions Example 00:14:58
Summary and Next Video Teaser 00:17:28
Closing Remarks and Call to Action 00:17:44

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 be talking about jump instructions in assembly.

This video is going to be about x86-64 Yasm assembly,

but I think probably anyone who’s interested in jump instructions

will benefit from this video because the concept is usually the same

throughout any system that you might use.

So for starters, I want to direct your attention to a textbook

that I think is wonderful.

This is an open source free textbook that will help you become an expert in assembly.

It’s not mine, I didn’t write it.

The author is Professor Ed Jorgensen, PhD.

He releases this textbook for free.

It’s under a copyleft license so you can literally just go to his website and download it and

send it to your friends and everything and it’s wonderful.

This book will take you from zero to hero when it comes to Yasm Assembly.

It’s wonderful and amazing.

This is the book and I just want to show you the section on jump instructions real fast

and then I’ll talk about them a little bit and then I’ll show you a sample program that

uses jump instructions.

So this version of the book that I’m working with right now is May 2024 version 1.1.56.

I’m going to go down to let’s see section 7 instruction set overview.

Inside of there there’s another subsection called where the heck is it control instructions

instructions 7.7 within that there’s a another subsection called 7.7.2 that’s

why I look this other not one of the many reasons that I love this book it

has so many subsections there’s just so many yummy subsections to organize

everything in a way that you can find it all so fast and okay so we’re looking

at unconditional control instructions in other words a jump instruction if

you’re an old-school programmer especially if you use some sort of like

if you use some sort of like a basic language or a language with go-to’s you might recognize jumps

as just being a go-to meaning we’re not actually going to call a function and then return from it

which is what the modern programs tend to do we’re just going to say let’s write a jump instruction

and we will literally just change execution to to jump to some other location just kind of go there

forever maybe we come back but if we do it’s going to be because there was a different jump instruction

instruction that told us to jump back.

So we’re not calling and returning.

We’re just going somewhere and that’s it.

Obviously it’s a little bit more convenient to be able to call functions,

but that’s sort of like an abstraction that has to be implemented after we

understand how to jump. So anyway, the jump instruction is pretty simple.

You just put JMP in Yasm anyway, and then follow it with a label.

So, you know, just as a quick little recap here, what’s a label?

imagine we have an assembly program here and maybe here’s our text section and we put some

instructions maybe there’s like an entry point right here I’ll say a global entry point and

literally just taking the word entry point and putting a colon after it now makes that a label

so if there are any instructions underneath I’m gonna put a bunch of nopes then if someone somewhere

to say jump entry point they should be able to go right here to instruction 8 and then start

executing downward. I guess maybe I didn’t need to put the global keyword global just means let’s

make this label available to other modules within the same program so if you have a multi-source

program or a hybrid program with multiple different languages then you know you should do this but if

it’s just a pure assembly program and there’s only one source code filed you don’t need to mark a

Just as a quick example here, entry points, I’ll just put hello as a label and I’ll say like do exit stuff.

So imagine on line 16, you add some instructions just to kind of exit.

If I wanted to skip all these nope instructions for some reason, I could just do this.

I could say jump hello.

And what would happen is execution.

Oh, I can use my pen.

Execution would just sort of, you know, it would come into the text section.

you know, it’d come into the text section.

It would go down through the label and it would execute this first jump

instruction and then execution would jump over the nopes into the hello label.

And then, you know, if there was other stuff here, then it would get executed.

So by jumping over the nopes,

I’m essentially saying that the nopes should not actually end up being

executed. They’ll be there in the program, but they won’t actually execute.

So that’s the basics of a jump instruction. Okay.

So what else do I need to tell you real fast?

What else do I need to tell you real fast?

Oh, one thing that’s really good about jump instructions is they have unlimited jump range.

So you can jump from a place at the very, very beginning of your assembly program and

jump to a place that is at the very, very, very end of your assembly program.

There’s not going to be a limitation on how far you can jump.

I mean, in theory, there’s a limit, but practically speaking, there’s not a limit.

Why would you care that there’s not a limit?

not a limit well because in a future video that i’m going to release we’re going to talk about

conditional branching which is sort of a jump that only jumps if a certain condition is true

and those have limited ranges where they can jump so there’s going to be a bunch of different

instructions but one of the conditional branching instructions is jne and another one is jge and

there’s another one that’s je basically you know jump if something is equal jump if something is

can only jump about 128 bytes away.

So after your assembler assembles and compiles

down to object code,

and then after your linker links your final executable,

wherever it is that the instructions happen to end up

inside of your program,

the conditional jumps,

the conditional branching instructions,

they can’t jump more than 128 bytes away

to some other instruction.

So keep that in mind.

Even if later on you graduate

to making decisions in your program,

like I’m going to do in the next video,

in your program like i’m going to do in the next video you can only jump so far and if you have to

jump too far you actually might not be able to jump at all unless you jump a very short jump

to a regular jump instruction and then that jump instruction jumps very very far away that’s kind

of the workaround for it i’m not going to talk about that in this video though this is not a

video for uh conditional branching i just wanted you to be aware of one of the benefits of regular

Okay, so we’re looking at the book here.

There’s not really a whole lot to the jump instruction, just jump and then a label.

We talked about its benefit over conditional branch instructions,

but we also talked about its, I guess, its shortcoming,

meaning it can’t actually make a decision.

It will always jump to a label no matter what.

There’s no condition.

So there’s the book there, and now I’m going to make a sample program

and show you how to run it.

I’m just going to run it.

I’m just gonna run it I’m show you what it does in order to implement conditional branches so for

starters I want you to know that there’s a make file that I’ve generated under the hood and we’re

not going to be talking about that in this video this is also a hybrid program so there’s a C++

entry point a driver module under the hood of this we’re not going to talk about that if you

want to know how to make hybrid programs you want to generate make files you want to learn the basics

videos for now we’re only going to be talking about jump instructions so I’m

going to skip a lot of information okay so for starters I’m going to make a

little data section here and again this is explained in other videos but for now

we’ll just trust that we can make a data section that contains strings C strings

and other values so pretty much I’m just going to make a string called begin jump

test just to announce to the user that we’re we’re going to start doing this

We’re going to start doing this and then I’m going to make a string called this message

should not appear.

So in the code, I’m going to try to print that message, but then I’m going to jump over

the call to print it just to prove to you that there are instructions that would print

that message, but we’re jumping over them with the jump instruction.

And then there’s like an exit message.

And then there’s a CRLF, which is just a carriage return line feed.

Again, all of this stuff is in other videos already.

So we’re going to use system call one to print.

We’re going to print a file descriptor one, which is just standard output for your program.

Then we’re going to start the text section where the actual code lives.

So this text section is here and it’s supposed to be at line 37 already.

I think I missed a bunch of lines.

Oh no, I think I missed some comments.

Anyway, so we have a text section here and an entry point and I’m calling it cool.

calling it cool and I am marking it as global because in this particular program that I’m

building it’s a hybrid program there’s going to be a C++ module that will call on our cool

function so cool has to be global and then I’m just going to call on a method called jump test

I don’t know I have the words load there I’m just going to get rid of that real fast locally and in

my solution up above and so we’re going to call a function called jump test and then when we’re

finished we’re going to return to the caller which is going to be the driver and that’ll

pretty much be it.

So if I comment this out real fast, let’s see,

this might actually work.

Let’s see if I can get it to run in the terminal.

But there’s a bunch more code that we have to add, so I’m not really sure.

So let’s do clear and make run.

And it seems to not have a shared object directory.

Let me pause the video while I copy paste one of my stupid libraries into the

program. You don’t need this library.

It just helps me print things.

okay so now I have copy pasted my shared object which allows me to do extra printing stuffs

just for just to make this demo easier for me but you don’t need to know it or you don’t need to have

it to to learn jump instructions anyway so I’m going to do that again and now it actually prints

something okay so hello from the main CPP driver and then it says the driver has regained control

make a call to jump test here and then let’s start the actual jump test function. So I’m going to do

well I guess this thing is kind of short I could copy paste the whole thing all at once.

So let’s do yeah let’s just jump let’s just call the whole thing. Okay I’m going to copy paste the

whole thing then I’ll explain it a little bit to you. So there is a function that I have in here

It’s just a convenience function that I made so I can print a carriage return line feed.

The real interesting thing here is the jump test function.

So we were just making a call to jump test.

Now we’re making the actual jump test function.

It’s got a signature of just void with no arguments.

So it’s not super interesting from the caller’s perspective, but it does some stuff.

So for starters, it has an intro message.

So this will print, you know, hello, welcome to the jump test.

jump test. In fact, if I do a return call here,

it should actually just print that and do nothing else. Right. Okay.

Notice how it printed, begin the jump test.

And then right after that,

there’s a jump instruction just proving to you that we can jump over other

instructions. So look at this,

this piece of code should never actually be called because we’re going to jump

over it. What it is, is it’s printing that jump shouldn’t happen message.

at the top here jumps shouldn’t happen so it’s trying to print out this message should not appear

but we’re going to jump over that by using this jump instruction here on line 66.

Again note that the jump instruction is just jmp followed by a label the label specified has to be

where you want to jump it’s never going to return from that place unless you specifically jump back

somehow later on like i guess if we wanted to we could put a label on line 67 call it the return

call it the return point and then jump back from it after the jump point in fact maybe that would

be kind of interesting to do at the end of this video but otherwise we’re gonna you know just

let’s see we’re gonna end up jumping over so let me reduce the front size just for a second here

so imagine execution uh comes into this program you know we’re executing uh instructions we’re

calling crlf we’re just executing executing as soon as we hit this jump instruction then execution

then execution jumps over into the label that I specified.

So this whole code section here just never even gets called.

So that’s why we will not see that message.

And then at the very end, all I’m doing is I’m just properly,

you know, I’m printing the exit message.

So I’m just printing another string saying the exit or the jump test is done.

I return to the caller execution goes all the way back up to just you know right here right after

call jump test was executed and then the cool function will return to the caller and that’s

just a c++ main function that does nothing so at this point we should see the whole entire point of

the program and then I’ll start tweaking it so you can kind of see the difference with the jump

instruction uh there and not there so let’s run one more time and notice how it says begin the

says begin the jump test and then end jump test and then it goes back to the driver that is

regain control it never says this message should not be printed so this whole section was just

skipped let’s comment out line 66 so that we don’t actually jump over that code and then now you’ll

see that that message does get printed so notice how it says this message should not appear okay

and then run the program one more time.

Now that message does not appear.

Pretty cool.

Now let’s do that double jumping thing just to show you.

I mean, this is not something that you actually want to do.

You probably want to write functions and function calls,

but if you wanted to, you could do something like this.

Here’s the exiting.

And maybe right after this, let’s make another label.

Let’s do, oh gosh, what am I going to do?

what am I going to do? Because if I jump after the exiting label and I jump back up to some label

up here, it’s just going to be an infinite loop. So maybe, um, I don’t know, let’s make a, I mean,

if I make another label down at the bottom, you’ll kind of think it’s a function just without

a return statement. So let’s actually jump within the same function. Let’s do, um,

over the never area.

So I’m going to say jump test and I’m going to write never.

So now we have a label that tells us where the never printed message actually starts.

So if we jump over it to the exiting, then we’re good.

But then if I up here, if I say jump instruction that subverts

never message so I’m just I’m just leaving a comment not code I could then

say let’s jump to jump test never and what will happen now is we’ll still see

the never message because what will happen is execution comes down you know

through here all these instructions are executing and then we see a jump that

tells us to go to the the never label so we actually jump over this exiting jump

over this exiting jump or this like the skipping jump,

the jump that skips the message.

And then we actually do print the never message

and we just keep going down and down and down

until we’re finished with that.

And we end up just sort of exiting normally.

So that means the only code that doesn’t get executed

in this case is the one right here

that skips over the never message.

Hopefully that makes sense.

Let’s run the program just to prove it real fast.

So I’m going to do this again.

And now you see the message should not appear.

This message should not appear.

You see that message.

So again, if we comment out that jump that subverts the skip, then execution will fall

through and we’ll end up executing line 69, the skipping instruction.

again now that message does not appear.

We could jump back and forth if we wanted to.

I don’t know.

Should I do a back and forth?

I don’t really want to.

I think at this point you understand we can jump anywhere we want, right?

I could take a bunch of time in this video to rewrite this program and have it say,

let’s jump downward and then let’s jump upward again and let’s let it fall through

and then let’s jump over something and whatever.

let’s jump over something and whatever. I mean, just wherever you want to jump,

just make a label and then jump to it. Then you have to figure out what your execution path is

actually going to be. And maybe that’ll be complicated, but I hope I’ve made my point by

now. Anyway, so that’s the basics of just jumping around. It’s not super useful. Conditional

branching is a lot better. So see my next video. And I thank you for watching this and I hope you

learned a little bit and had a little fun. See you soon.

See you soon.

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

So please do me a kindness and subscribe. You know sometimes I’m sleeping in the

middle of the night and I just wake up because I know somebody subscribed or

followed. It just wakes me up and I get filled with joy. That’s exactly what

happens every single time. So you could do it as a nice favor to me or you could

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

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

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

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

It’ll take you to my main website where you can just kind of like see all the videos

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

If you have a suggestion for

Clarifications or errata or just future videos that you want to see

please leave a comment or if you just want to say, Hey, what’s up, what’s going on?

You know, just send me a comment, whatever. I also wake up for those in the middle of the night.

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

I would really appreciate it. So again, thank you so much for watching this video and, um,

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

Thank you.

The post x86-64 Assembly Jump Instructions Explained: Unconditional JMP with Full Example in Yasm 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.

In this video, I walk through how to perform signed integer division in x86-64 assembly language using Yasm on Ubuntu/Linux.

We focus on 64-bit signed integers and the IDIV instruction. I explain the setup: loading the dividend into RAX, using CQO for proper sign extension into RDX, loading the divisor, and executing IDIV. After division, the quotient ends up in RAX and the remainder in RDX.

I reference the excellent free book “x86-64 Assembly Language Programming with Ubuntu” and show practical code examples, including a complete working program that prints both the quotient and remainder.

We test with small numbers (256 / 233) and larger ones to see it in action. I also touch on the difference between signed (IDIV) and unsigned (DIV) division, and why CQO is needed for correct sign handling.

Perfect for anyone learning low-level programming, assembly language, or wanting to understand how integer division really works under the hood.

Introduction to Signed Division 00:00:00
Referencing the Assembly Book 00:00:28
IDIV Instruction Overview 00:01:16
Dividend and Divisor Setup 00:01:24
Sign Extension and CQO 00:04:18
Quotient and Remainder Results 00:04:40
Setting Up the Program 00:05:13
Data Section and Strings 00:06:22
Function Prologue and Preservation 00:09:20
Loading the Dividend into RAX 00:10:00
Sign Extension with CQO 00:11:24
Loading the Divisor 00:12:36
Performing IDIV 00:14:19
Saving Quotient and Remainder 00:16:48
Printing the Results 00:17:20
Running and Testing the Program 00:18:51
Testing Larger Numbers 00:19:48
Returning the Remainder 00:21:42
Signed vs Unsigned Division 00:23:48
Conclusion and Thanks 00:25:02

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’d like to talk to you about dividing signed integers in an x86-64 Yasm

assembly program.

I’m going to be focusing on 64-bit integers and I’m going to use an instruction called

iDiv.

Okay, so for starters, I just want to give you an overview of the process.

I’m going to use an awesome book that I love to reference.

awesome book that i love to reference i did not write this book the book is titled x86 64 assembly

language programming with ubuntu i mention it in a lot of other videos the author here

is a genius and this book is open source and freely available so go look it up get yourself a

copy and become an assembly expert too anyway so what i’m going to do is go into this book

instruction set overview and then inside of that i’m going to click on 7.5 integer arithmetic

instructions or arithmetic i don’t know whatever you prefer to say it as but and then i’m going to

go inside of there and i’m going to click on 754 integer division so you know the basic idea for

dividing integers in a yasm assembly program on x86 64 is just to load up your dividend you know

top portion I guess that is the numerator and then the divisor which

would be the denominator with separate registers so load up the dividend with a

register or put the dividend into a register and then put the divisor into

another register they’re going to be special registers we’re going to be

using the A and D registers you can kind of see that at the bottom already and

then once that’s set up properly you just sort of use the IDIV function or

instruction and there’s another instruction we can use to make things a

little bit more simple because if you kind of notice what what this is saying

here it’s saying that the the dividend usually needs to be stacked between two

other registers at the same time and that’s a little bit confusing

especially if these registers right here notice how a DX colon ax that means it

16-bit versions of two different registers just sort of like pushed up against each other so

Obviously if you know how to manipulate bits which I’m gonna do other videos for in the future

Then you could do that with any size, but just I’m gonna make the easiest example that I can here. I

Love this line. I just found it today

As always division by zero will crash the program and damage the space-time continuum. So try not to divide by zero. I love it

nifty little table inside of the book that sort of shows you how you’re supposed to set up the

numerator and denominator or the divisor what was the other word that they used dividend and divisor

i usually say numerator and denominator anyway so remember in in if you watched my previous videos

then you’ll know that we have smaller versions of our registers like for example uh this eax right

here that’s actually the rax register but it’s only about half of it uh half of those bytes are

half of those bytes are being ignored so all of these different versions that you’re seeing are

just different sizes of the a and d registers so i’m going to go to the simplest example here and

just kind of show you that basically what they’re trying to do is force you to have a numerator that

is bigger than the denominator that way it’s guaranteed you’ll have some kind of a quotient

or you know more likely that you’ll have some kind of a quotient and and a remainder that kind of

that kind of makes sense because if you divide a number that’s much smaller than

the denominator then you’ll just end up with zero remainder the original number

pretty much in integer division this video is not about float division float

division is more precise so in other words if I want to divide something by a

64-bit integer then I need to first set up a 128-bit integer and that means I

and that means I have to take two 64-bit integers, the D register and the A register.

I have to load both of those registers up with 64 bits each so that when you imagine them being combined,

it’s a 128-bit register or 128-bit value.

Once I have something that is sufficiently large, then I can divide it by something else.

Then the result will show up in the A and D registers.

the actual quotient, you know, the actual result of dividing without a fractional part at the end,

just, you know, truncated data. Then the remainder will be in the D register, the RDX register. So at

least for this form, I just want you to know you can do it with all these other forms if you want

to. But in this example, I’m just going to take 128 bits, divide it by 64 bits, and then I’ll get

So that’s the basic idea. Here’s some sample code in the book. I love it. It’s wonderful.

But I’m going to go ahead and start writing my own program now.

Okay, so I got a solution up here. I’m going to just copy paste my data section and explain it briefly.

Okay, so here is, oh, maybe I should first say, here’s a sample program that I’m using.

You don’t have to worry too much about what’s actually inside of it.

The C module and the make file, they’re standard stuff that I usually use in all of my videos.

all of my videos this is not a make file video see my other videos if you want to learn how to

make your own make files but long story short i’m just going to type you know make run in order to

just get this program to run and then for the c program i’m compiling a hybrid program so i mean

it’s just easier for me to just kind of get started this way so i have my main entry point sitting

inside of a c source code file that gets compiled and linked into my main program and it just calls

a function called math right here which is just going to be you know this source code right here

so if you want to make hybrid programs you want to learn the basics of assembly you want to learn

anything that i’m not really talking about in this video see my other videos

for today or for this video it’s just going to be integer division anyway i’m going to paste in

some starter code here for my math module i’ve got a data section and i’ve got some strings

strings or anything but just keep in mind I’m going to eventually print the division result

quotient is and then I’m going to actually print it and then I’m going to print the division

remainder is and then actually print it so I’m just I’m just setting up strings to make my

results look a little bit prettier that’s all I’m really doing crlf that’s just new line stuff

system calls here’s the system service code for writing to something writing to a file or standard

standard output again that’s in another video file descriptor one another video and then return

value I’m just choosing to return the number seven from this module I don’t know why I just

I like to reuse code and I’m not going to change it and then we’re going to take two different

integers here and uh 56 and oh I think in my starter code I actually hard-coded those numbers

after everything is working so um i’m going to start my text section here by just copy pasting

a little thing that says okay here’s where my code is going to go now all my instructions

and then uh here’s my entry point which is just my function called math you want to write functions

see my other videos but this is basically it you just kind of have something enter and then return

from it when you’re done and if you mess up any registers you have to preserve them with push and

you have to preserve them with push and pop pairs.

Another thing that I’m going to add that I’m not going to explain in this video

is I’m going to do calls to one of my own personal libraries.

And basically I’m just going to mark two functions as external.

They’re sitting in a shared object that I made.

Don’t worry about that. This video is not about printing.

It’s just about dividing. But I want to be able to easily print.

So I’m just going to use that library.

So don’t worry about that.

for this video is my function called divide test because notice how in the entry point of math

remember the c module the driver it calls on this math function the math function eventually or

immediately calls on divide test and so here’s the prototype basically for my divide test function

I’m just going to say it’s void takes no arguments that way it can just do everything by itself

as a little demo and it’s a little bit easier so that means I don’t really need to preserve any

I am using them and if you see here well I guess if it was going to take arguments you don’t need

to preserve the argument register so I should have just said yeah we are going to use some

registers and therefore we’re going to preserve them so our 12 14 and 15 oh why am I not using

13 I must have erased that at an earlier date whatever we’re going to use these three registers

make this an official function and because I know I’m going to use r12 14 and 15 I’m just going to

preserve them with a push pop pair so I’m going to say this is the prologue whoops and I’m going to

push r12 push r14 push r15 respect the abi if you don’t other pro other parts of the program

will probably crash epilogue is just popping all those in reverse order so that I can basically

basically preserve them for the caller.

Okay, so now we’re good with all our registers.

Next thing I want to do is I want to load up, let’s see,

I want to load up RAX with a number.

Now maybe I’ll fix this right now.

What was 256?

It was the my integer B.

So I’m going to hit main memory,

which is a little slower than using an immediate,

but hey, it’s more flexible.

but hey it’s more flexible and so basically i’m going to set up rax which is the numerator if we

go back to the book real fast if our intention is to divide a 128 bit uh uh like combined register

by a 64 bit something then uh well rax is the lower 64 bit so that’s why i’m loading that up

first i’m just saying well i’ve got 64 bits worth of stuff a quad word worth of stuff sitting in

so i’m just going to load that into rax then i just have to somehow take care of rdx so obviously

if you wanted to you could just you know take rdx and just set a bunch of zeros to it but that

would probably only work if you were guaranteed that rax was a positive number so that its sign

bit was zero at the very left if it was a negative number its sign bit would be a one at the very

And that wouldn’t be very good if RDX plus RAX, you know, lined up are supposed to be a negative number because you would want ones all the way through to RDX.

So there’s a special instruction we can use called CQO.

I’m just going to paste that in here just to make things a little bit easier because I’m really trying to divide a 64-bit integer by something.

The system wants a 128-bit integer.

basically this instruction right here CQO whoops what happened how come it’s not lined up

CQO basically just takes RAX whatever is in there and stretches it onto the 128 bit combination of

RDX colon RAX so remember when you see this kind of thing remember when you see RDX colon RAX or

just like a register colon another register that’s usually telling you that the system will think of

in a combined way as one longer register so that’s really what it is cqo is going to say

let’s look at rex and let’s uh you know fix it up and then also fix up uh rdx so that when they’re

combined they make sense as just one number um and you know that that would work pretty easily

like i said before if it was a positive number but not necessarily in all cases so we’ll just use

is, let’s see, set up the denominator. So let’s see, here, I’m going to say set up denominator.

And you know, we can hard code the 233 there, but I think I’ve already decided,

let’s just use variables. So the A, I think has 233. Where the heck’s my A? There we go.

So I’m going to say my integer A. And here I’m going to put the pointer to the A variable,

to the a variable and then i’m going to dereference it and um oh one thing that we have to remember is

when the system is using your registers like rax here it knows rax is the 64-bit form of the a

register so if you use different forms of your register then it knows how many bits you want

like for example here we just kind of go back up uh this eax that’s still the a register but the e

that it’s a you know 32 bits instead of 64 bits but there’s no there’s no way for

the system to really know that that memory location is 64 bits how does it

how does it know if I’m if I’m trying to load from memory a one byte integer or

two byte integer or four bytes or eight bytes it doesn’t really know so I kind

of have to specify what the data size is of the integer at that place in memory

this probably wouldn’t even compile. But if it did compile, you probably should be nervous that

it would compile and do something wrong. So I’m just going to specify exactly what the data size

is for that. So now we’ve set up our numerator and also set up our denominator. And the next step is

to just actually divide. Let me copy paste that real fast. So now we actually divide. Why is my

Oh, I know what’s going on.

I have the tab size set up differently between my two editors.

I got to fix that.

Or how about never fix it so I can always complain and you can laugh at me.

That’s okay.

So on line 85, we’re going to divide the numerator by the denominator.

And we’ll say the numerator is, you know, RAX with RDX in front of it.

the denominator is just one register which is uh what have I done wrong here oh no no I’m okay I’m

okay r12 so if you look back at the I got a little confused here because uh the book you know it

wants uh the d and the a registers as the numerator but then it says op64 as the denominator you can

just kind of use a bunch of different stuff for that but I’m choosing to divide by another register

So basically I’m taking the denominator and loading it up into R12.

And then when I call my idiv instruction, I’m just saying integer division.

And I want you to divide whatever’s in the RDX, RAX set as I want you to divide it by R12.

At that point, RAX and RDX will be overwritten.

So that data is now destroyed, but they contain the answer.

So RAX now contains the answer.

I’m just gonna say quotient and the RAX register contains the remainder so for

example if you are familiar with the let me pull this up real fast is that the

calculator no there is if you’re familiar with the modulo instruction like if we

said let’s see what was it again 233 okay so let’s do 256 divided by 233 this

this gives us the number one and then some sort of like a fractional remainder

with integer division we’re not going to get the fractional remainder it’s just literally going to

be the number one sitting in rax and then in rdx it’s going to give us the result of using the

modulo operator which is going to be 23 so it’s going to be one remainder 23

is what we should see unless i’m totally wrong so then right away

of our division which is a good practice you know like the rex and rdx those are registers that

could be quickly destroyed especially if you called another function or a system call or

something so i’m just going to save them right away so that’s why we saved 14 and 15

in addition to r12 so r12 we were using for the denominator and then we’re using 14 and 15 to

save them real fast and now I’m just going to do easy stuff that I’ve talked about in other videos

just to sort of print out an answer so I’m just going to I’m just going to write this up real

fast copy paste this and then just kind of briefly talk about oh look I’m using a system call

explained in another video to print out that little prefix message you know the result of your

division here’s the quotient and then a colon and then I can actually print the number

personal library to print a 64-bit integer and so that way it’s easy for me and notice how I’m

printing r14 I’m giving it to the call to the function as the first argument which is rdi

what is r14 again that’s just the quotient so here I’m printing the quotient and then I do the

same thing for the remainder and then we’re going to do a paste here and I’m just going to print my

prefix of the remainder you know here’s your remainder and then I’m going to actually print

And then I’m going to actually print it.

And the remainder was in R15.

So 14 and 15 had the answer.

And then the other register just kind of had, or the R12 just kind of had the denominator.

So I think that’s pretty much all I need.

Oh, there’s one more function that I forgot to put in there.

I’m fond of writing a little CRLF function.

This is not part of the video, really.

But it’s just a special function that I can call on to do a carriage return line feed.

And I’m just, I just can never stop using this.

stop using this. I know I could just prefix or suffix my strings, you know, with like a CRLF,

but I like to be able to call every time I want to see our lab. Okay. So we have the program now.

Let’s see if it actually works. Is that my terminal? Yeah. Okay. I’m going to go clear

and make, hopefully it actually works. So, oh yeah, there we are. Okay. So everything seemed

It printed hello from the driver.

And then when we went inside of the assembly module,

this is really what we’re interested in.

It said the division result, the quotient is the number one

and the division remainder is the number 23.

That’s what we said before, right?

So it’s going to be 23 is the remainder.

If you just do the modular operator or if you’re dividing,

whoops, if you’re dividing, then you’ll just get a one.

Remember like the quotient is just going to, you know,

truncate or remove or throw away all the extra data.

all the extra data it’s not going to round up or down or anything it’s just going to say

anything past the decimal point is gone and that’s why the uh the remainder is pretty important

then of course you know just for fun we could i don’t know put like some other numbers in here

if we wanted to maybe i’ll copy paste this just put some other numbers let’s put like a giant

number and see what happens because these are 64-bit numbers we can do it um i probably should

have switched a and b right because doesn’t it kind of feel like a’s on top so it should be the

top so it should be the numerator or whatever so I’m just gonna hit a bunch of stuff here and then

divide that by some other stuff see if this comes up with a more fun answer so one more time clear

and make and it’s telling me that uh whoa that’s the result I guess probably should have printed

out the original numbers but let me just put that into the calculator just for fun we’ll say this

just sort of go back to the calculator it enters so uh oh the squiggly lines

that means that’s not exactly the result i got to figure out how to change the mode on

this calculator so i can get precise let’s see can i do that right here

exact no can i try it again with exact all right this is not a tutorial on the

it as is maybe i’ll do can i do a slightly smaller number yeah there we go okay i’ll take

off three digits so that the calculator will at least show me something okay run it one more time

and then so now we have smaller stuff the answer should have been 38677662 38677662 yeah that looks

the decimal point so the point six is not on there and then we run the modulo

to see what the remainder is and it should say one two eight six three yeah

okay and then the seven is getting returned I don’t know do you want to

return the remainder for some reason we could do it let’s just return the

remainder might as well make this video a little bit more fun so recall that in

order to return something if the return value is an integer and not a float or

float or if it’s a pointer then you’ll just use RAX as the return register so I’m just going to do

move return the remainder to the color okay I’m going to move something into RAX it’s going to be

R15 nice now this is a function with a return type I’m going to say along here and then

up here, I guess, RAX is already going to be pre-filled now after that call.

But you could imagine if you were doing more stuff between the call and the return,

you would probably want to save the return value from RAX in some other register like R12.

And then that means you got to add a push pop pair to preserve it.

And then we’ll definitely just, well, maybe I’ll say move RAX into RAX

totally useless. That’s why I’m commenting it out. So we’ll do one less instruction.

So basically after we get back from divide test, RAX is going to have the

return value and math, this function would also use RAX for its return value. So if we just sort

of don’t do anything, we should now see that the driver receives the remainder as its return value.

Let me open that up again real fast just to make sure we understand what’s going on with

the driver.

Even though this is not a driver video, it says external long math.

It names that as a long function.

And then when we call the function, we just kind of grab a long result, 64 bit int, and

then we print it with printf because this is a C program, not C++.

integers, assigned integers. Let’s see in assembly. Let’s see. Where’s that? Yeah, there we go.

So just keep in mind what I’ve been showing you is idiv, which is a signed integer, which is what

you probably want, which means the integer can be positive or negative. And, you know, if you know

for sure that you’re going to be dividing two positive numbers, and there’s no chance that

that the numerator or denominator or the quotient or you know any of those things are going to be

negative then you could you could divide unsigned integers and then you can use larger values

because remember when we have signed values we basically lose half of the I guess maximum

possible value that we can represent because we lose one bit to the fact that the integer is signed

is for signed sorry i div is for signed and regular div is for unsigned and then

yeah i guess that’s basically all i really needed to show you there’s a bunch of nice code in this

book i’m not gonna i’m not gonna look at it right now so 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’ll see you in the next

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

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.

I promise that’s what will happen.

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

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

what’s going on you know just send me a comment whatever I also wake up for those in the middle

of the night I get I wake up in a cold sweat and I’m like it would really it really mean the world

to me I would really appreciate it so again thank you so much for watching this video and

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

Thank you.

you

The post Signed Integer Division in x86-64 Assembly with IDIV and CQO appeared first on NeuralLantern.com.

Ever stared at “mov rdi, rsi” and wondered WHO goes WHERE?
This 18-minute crash course turns confusion into confidence.

We start with the world’s simplest instruction (inc rax) and level-up to:

• Zero, one, two, and three-operand formats
• Why “mov rdi, 89” and “mov rdi, [someVar]” are NOT the same
• Brackets = dereference, no brackets = pointer
• When ADD destroys your register (and how to stop it)
• The memory-size trap that crashes 90% of beginners
• Byte / word / dword / qword prefixes that save your life
• Pro tip: keep everything in registers until the last microsecond

Code is shown live in Yasm, every line explained like you’re sitting next to me.
No fluff, no 2-hour theory—just the exact mental model you need to read and write assembly tomorrow.

Grab the free PDF cheat-sheet (link in first comment) and code along.
Hit Subscribe—next video we build a complete program from scratch.

Assembly #x86_64 #Yasm #LowLevel

Introduction to Instruction Formats 00:00:00
Simple INC Example 00:00:28
Instruction and Operand Basics 00:00:47
Zero to Three Operands 00:01:14
MOV Instruction Explained 00:02:02
Immediates and Registers 00:02:44
Memory Variables and Pointers 00:03:16
Dereferencing with Brackets 00:05:08
ADD with Two Operands 00:05:32
ADD with Three Operands 00:06:55
Consulting the Ubuntu Book 00:07:45
MOV Source vs Destination 00:08:52
Memory Size Matters 00:09:07
Specifying Data Size 00:11:40
INC on Memory Locations 00:13:19
Why Size Prefixes Prevent Bugs 00:14:08
Performance Tip – Use Registers 00:15:12
Book Recommendation Wrap-up 00:16:04

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 instruction formats in Yasm Assembly.

So what am I talking about? Well, if we’re in Yasm Assembly and we’re going to learn how to

use lots and lots of instructions, it’s probably a pretty good idea to understand the general idea

of an instruction and its operands and the things that you can do to it. So the first thing I want

show you is a really simple instruction called inc and we’ll put it we’ll put a

register there we’ll say RAX we want to take whatever value is inside of the RAX

register and just increase it by one simple enough but it’s important to

understand that this is this follows a specific format the first thing that we

put is the name of the instruction that we want to execute second thing we put

is an operand you know what thing do we want to increase we could actually put

We could actually put other types of operands there.

We couldn’t put an immediate number, like just a hard-coded number,

but we could put a memory location if we wanted to, and we were careful about it.

So think about instructions as following this sort of format.

Let’s see, INST, and then a space, and then, you know,

sometimes instructions have zero operands, like there’s an instruction called CQO, I think,

and it just takes two registers and sort of like lays them out against each other.

against each other but for now we’ll just assume we’re going to write instructions that

actually do something to named registers or memory locations or whatever.

So the name of the instruction comes first and then we have an operand.

One or more operands up to three actually.

So basically the operands are separated by commas so we’ll say operand one, operand two,

operand three and most instructions will follow this format.

do what the operands are for it’s easy to tell that the first operand is the

thing that will be increased in the increase operand but what about the move

instruction what if we wanted to move you know one register to another let’s

say RDI to RSI or sorry RDI from RSI or vice versa I mean how would you know

remember this is the instruction and this is the first operand and then this

And then this is the second operand.

There’s not three operands in this instruction.

Other instructions have three operands.

The way it works with the move instruction,

I hope you understand already at this point,

is that operand two gets placed into operand one.

So when this instruction is finished,

then whatever value was inside of RSI is going to be inside of RDI.

So they’re actually going to end up being copies of each other.

Some instructions allow you to put immediates,

like I could just put the number 89 right here and the number 89 will get loaded into RDI so I

don’t really even need to use a register. Some instructions this one in particular also will

allow you to place the name of some variable in brackets as the second operand and then what’ll

happen is if you if you recall hopefully let me let me let me improve this a little bit.

you have a data section and you have a text section.

The text section is for your instructions.

In the data section, we could say some variable

and we could define this as data quad word, I guess,

and put like a big giant number inside of there.

And so now we have a variable, a global variable to that module

that is sitting in memory somewhere and it’s got this value.

So then what we can do is basically say,

take the name of that variable, stick it inside of brackets,

and then the move instruction will go grab that number, grab the value associated with that

variable and then load that into RDI. What if we didn’t put brackets? What if we just said load and

then some variable? This is how you place a pointer inside of a register. Remember all these registers,

at least the general purpose registers with this R format, are 64-bit registers and in the 64-bit

use that means you could hold a memory location in the register so it’s pretty convenient when

when you define a variable up top here what you’re really doing is you’re saying i would like to

allocate eight bytes for a quad word and i would like to fill it up with this data

you know like let’s take eight bytes reserve it for us then we’ll convert all the ones and zeros

appropriately so that it ends up equaling that value then when we’re done it’ll give us a pointer

a normal variable that you usually would think of in C++ where it’s just like the variable is the

variable and not a pointer to something. All these are actually just pointers. So if I load some

variable into RDI I’m actually loading a pointer to RDI which by the way would make it pretty easy

for you to pass a pointer into another function just by loading up RDI with some pointer to you

know some of your data somewhere. But the moment I put the brackets around it it will dereference

it will dereference the pointer for me

and take the value and then send the value into that.

Hopefully that makes sense.

Okay, so we got pointers, dereference pointers,

immediates and registers.

That actually went by pretty fast.

I thought this was gonna be a long video.

Well, let’s look at my favorite book here,

the Ubuntu coding book.

Let’s see.

Oh, maybe first let’s look at the add instruction

because I wanted to get something with three operands.

So let’s do an instruction with three operands.

I’ll say INST and we’ll do operand one, operand two, operand three.

So we have this add instruction here where we can just add two integers together.

I could say let’s load the value of, you know what, let’s do this first with only two.

Yeah, because that’ll be more fun.

Let’s do RDI and RSI.

Okay, so this is legal.

You can have an instruction named add that uses either two or three operands.

A lot of instructions do that.

Usually in the two operand format, what they’re saying is,

let’s do something with both of these values and then store the result

of doing something in the first register.

So for example, it’s going to take RDI and add it with RSI,

assuming two’s complement integers.

store the result of that addition inside of RDI. So if you think about it, it’s faster to type,

but sometimes it might destroy data if you didn’t actually expect to modify RDI.

If you wanted to store the result somewhere else, but still add RDI and RSI somewhere,

then that wouldn’t work. So let’s do the three operand format, operand two, operand three.

So now let’s say that we wanted to store in some other register without destroying

RDI after we do the addition. So we can use the three operand format. Maybe I’ll

hit space here a couple times just to make it a little more interesting. I

guess I probably should have formatted the comment. Let me try to… No I guess I

can’t. I don’t need to space it out. Well I could. I could anyway. So we’ll use the

add instruction which is totally valid to use for three operands in addition to

two operands. And what will happen now is it’ll take RDI and add it to RSI

and add it to RSI and store the result in R11 in case you wanted to preserve the value of RDI and

RSI. Lots and lots of different instructions with lots and lots of different things that you can do.

Of course, we could put a memory location there. We could put like an immediate somewhere.

But let me go to my favorite book here. Whoops, I already have it highlighted on the right section.

x86 64 assembly language programming with Ubuntu by a brilliant doctor and I

use his book all the time I’m not gonna say his name because I don’t want to

accidentally mispronounce it I’m pretty sure I know how but I don’t even want to

try because I suck at pronouncing things I’ve pronounced my own name wrong on

many occasion so let’s see I’m gonna click on section 7 the instruction set

the instruction set overview and basically you know it kind of goes over the fact that oh you

know we can put registers as operands and we can do some certain things like if you see this

notation it means you can put a register as an operand if you see this notation it means that’s

going to be the source operand if you put if you see this notation it means you can put an immediate

at that spot so the book just kind of tells you what to expect in terms of notation then if you

go down it starts explaining a bunch of different instructions for example the move instruction

instructions. For example, the move instruction that we’ve just been working with. Notice how it

tells you the source is on the right, the destination is on the left. And if we are taking

from a memory location, which I probably should have mentioned, let me see, did I mention that?

No, I don’t think I did. If we’re taking from a memory location, it’s important to understand that

the data size of the memory locations data and the register might actually be different. See,

different. See here we kind of made a bad assumption. We made the assumption that RDI

was a 64-bit register. That’s a good assumption. But then we also made the assumption that sitting

at that pointer is eight bytes of memory. That’s a bad assumption. Up at the top, we know that

when we put DQ for data quad word, then eight bytes are going to get allocated. But by the time we

But by the time we get down to this instruction, you know assembly is not very smart.

By the time we get down to this instruction, we can’t be sure if that pointer refers to

something that is 8 bytes or 4 bytes or 2 bytes.

We should be able to support loading a number.

Like just as an example, I could lower this number, like let’s say with the number 25,

but you know that the number 25 will fit into just a single byte.

It’ll also fit into a word, 2 bytes.

32 bit number, a D word, you know, four bytes.

It’ll also fit into a quad word, 64 bits, eight bytes.

So it’ll fit in different sizes of data.

So what if you have a memory allocation,

like instead of putting DQ,

what if we put DB for just data byte?

So just like one byte of memory to put that 25 in,

that should work.

But the point is this part of the code

doesn’t actually know how big the memory location is.

So it doesn’t know how many bytes to grab.

many bytes to grab like what if we what if it just assumed that because we used a 64-bit register

actually let’s go back up here let’s change this to a byte data byte so we know that the 25 occupies

only one byte but here if we were unlucky then the assembler might assume oh they want to load

eight bytes of memory interpreted as a number and then put that into a 64-bit register an eight

But that probably wouldn’t work because we only actually modified one byte to make that 25.

So there’s going to be seven other bytes of junk data.

So now we just loaded RDI with some sort of a nonsense value.

And even if it does work, it might not work on every run of the program.

So then you have something which is probably undefined behavior,

where it’s just like you made a bad mistake and your program’s going to work sometimes

and maybe some other times not work.

So how do we fix this?

So how do we fix this? We just specify the size of the memory location or of

the bytes that we’re going to grab at that memory location. So if I just put

the word byte in front, now the assembler knows that I only want to grab

one byte and interpret that as a number and then put that into RDI rather than

all the extra junk data. So if I want to make sure that it understands that I want

eight bytes and also to prevent it from refusing to compile, which it’s probably

going to do if i don’t specify the size i’ll put q word to say yeah this 25 it’s uh it’s actually

a q word it occupies eight bytes so i want you to load up eight bytes in ram and interpret all

those bytes as just you know whatever numbers inside of them pretty sweet i love going to this

book because i was going to forget to say that anyway just so you know there’s a bunch of

instructions that you can look up i’m not going to go through all of them but um you know typically

Leftmost operand in some sort of a modifying instruction is going to be the destination

register or memory location.

And if you have a two operand instruction, it’s probably going to take both operands

and do something with them and then stick the result in the first operand.

And then if you have a three operand instruction, it’s probably going to take the rightmost

two operands, do something with them, store the result in the leftmost operand.

wonderful, wonderful book will tell you exactly what to expect for every type of instruction.

So there’s like move here, integer arithmetic. Oh yeah, there’s the add function or sorry,

the add instruction. And then here’s like a bunch of sample code, which is awesome.

And notice how here, if we want to increase something that is located at a memory location,

we got to specify the size of the memory. Again, same problem that we just talked about up above.

Did we do that at the beginning?

I don’t remember if we did that.

You know, if we have something where it’s like,

if we said increase the RAX register,

the computer knows that RAX is a 64-bit register

because the way we typed it, RAX, that implies 64 bits.

If we meant to only use 32 bits of the register,

we would type a different, you know,

set of letters to represent that register.

But if we say, I would like you to increase

the value sitting in memory at some variable,

sitting in memory at some variable dereferenced, well then whoops,

it doesn’t actually know how many bytes.

If you increase a small

value, like if it’s if you have one byte and you try to increase it,

what if it overflows?

Like, for example, if we had a one byte, if we had one byte of data here

and we had the number, let’s say 255 already, that’s the highest value that a

So if we then say let’s increase that,

the computer is going to, you know, like overflow back down to just zero or not.

What if it actually was a quad word?

The computer didn’t understand whether it’s supposed to overflow or not overflow.

Do you see what I’m saying?

There’s lots of problems that can happen if you don’t know the size.

So that just means we have to specify the size.

Anytime we’re dealing with memory, we’ll say we’ll increase a keyword sitting at some

variable. And of course, if you’re going to

and of course if you’re gonna i don’t know why you’d want to do this but if you wanted to well

i guess if you’re running through a string if you wanted to increase a pointer value uh then i think

you don’t have to specify the data size although i’m not actually sure if you can change the value

of that pointer i don’t know if it’s hard coded usually what i do is i would just move you know

some kind of a i would move the pointer if we’re if we’re using a running pointer to run through

I would load the pointers value into a register and then I would just start increasing the

register just to make things a little bit easier because as I usually try to say it’s

way slower to constantly be hitting memory.

Anytime you can possibly keep all of your calculations and algorithms and stuff inside

of only registers as long as possible, then your program will be way, way faster.

So if you’re going to run through a bunch of data with a pointer, probably want to load

it up into a register first and then keep increasing the register.

When you finally figure out, you know, everything that’s calculated and finished,

then go ahead and save it back to memory at the very end.

But just to let you know, we’ve got lots of stuff.

Okay, so there’s the add function.

This is the two op version.

You can see at the top there.

Let’s see, where’s the three op version?

Here’s somebody honking the horn outside.

Someone’s upset with someone else.

Someone’s upset.

Someone’s upset. Do you ever honk the horn not angry, but just so that the other driver will think you’re angry and

Then possibly be a good driver or a better driver later on in their life. I don’t know if that actually works. I have tried it

And you do your eyebrows like this

Even though you’re not upset

I wonder if they just go home laughing and they’re like, yeah, you’re right. I was ridiculous

Okay, so I guess I’m gonna stop scrolling

a

A good coder always reads the documentation and studies ahead and things like that

I know you were hoping for me to tell you everything in this video, but there’s just not enough time or energy to do that

I just wanted you to understand

How how to how to interpret instruction formats?

I wanted to make that part easy for you

but all the different instructions that are available to you to multiply to add to increase values to do all this stuff

It’s all in this nice wonderful book

okay anyway I think I’m gonna cut the video I hope you enjoyed what you have

learned I hope you have learned a lot of stuff and had a little bit of fun there

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

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.

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

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

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

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

Thank you.

The post Yasm x86-64 Assembly: Instruction Formats, Operands, MOV, ADD, Memory & Registers Explained 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.