Quick but complete guide to writing proper functions in YASM x86-64 assembly on Linux. See how to pass integers, pointers & floats, return values, follow the ABI, disable C++ name mangling with extern “C”, and call back and forth between C++ and assembly in a real working example.

Great for people moving from NASM/GAS or trying to mix assembly with higher-level code.

00:00 Introduction and Video Overview
00:28 What Are Functions in Programming
00:56 Why Functions Are Harder in Assembly
01:24 Topics Covered in This Video
01:59 About the Makefile and Prerequisites
02:28 Hybrid C++ and Assembly Program Plan
03:01 Using extern “C” to Disable Name Mangling
04:03 Main Driver Function in C++
05:00 Adding a Callable C++ Function for Assembly
05:42 Explaining extern “C” Placement
06:16 Assembly File Skeleton and Data Section
06:41 Creating Null-Terminated Strings
07:49 Section .text and External Symbols
08:52 Declaring my_cpp_function as extern
09:20 Defining my_assembly_function
09:40 Labels vs Real Functions
10:31 The call Instruction and Return Address
11:16 Why Jumping Instead of Calling Crashes
11:47 Global Directive for Exporting Functions
12:32 Basic Function Structure
13:20 Implementing my_assembly_function Prologue
14:50 Receiving Arguments in ABI Registers
16:30 Printing Received Integer Arguments
18:10 Handling Pointer Arguments (C Strings)
19:40 Passing Floating-Point Arguments in XMM
21:15 Printing Floats from Assembly
23:00 Calling Back to C++ Function
25:40 Preparing Arguments for my_cpp_function
27:20 Loading XMM0 and XMM1 for Floats
29:10 Making the Call to C++ Function
30:50 Receiving Double Return Value in XMM0
32:30 Saving Returned Float to Memory
34:10 Printing the Returned Value
36:00 Final Messages and Program Flow
38:20 Fixing String Pointer Crash Issue
40:00 Correcting Argument Loading
42:10 Passing String Owned by Assembly
44:00 Observing Successful Output
45:47 Saving and Restoring XMM0 Safely
47:14 Printing Final Returned Float
48:32 Importance of Following the ABI
50:29 Summary of Covered Topics
51:03 Closing Remarks and Call to Subscribe

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hello there.

In this video I’m going to teach you how to write functions in YASM x86-64 assembly inside

of Ubuntu, although probably any YASM assembler will be fine.

I’ve covered these topics before in other videos, but I thought it would be nice to

put them all here in one single video to make it a little bit easier to understand.

Okay, so first off, what the heck am I talking about?

Well, you know, when you have a program, let’s say we have a higher level language program

and we have like, you know, void or actually probably not void main, let’s say int main

and we’ll forget about the arguments and inside of main, it just sort of calls f and then

we have an f function over here and it, you know, does stuff, right?

So that’s the basic idea of having a function that you can call and calling it.

We sort of take the whole process for granted in higher level languages, but in assembly,

in assembly we have to do a lot more from scratch so I’m going to show you about how to pass

arguments how to pass integer arguments pointer arguments floating point arguments return types

you know double like floating return types integer return types pointer return types

how to use special registers to actually pass the arguments into the functions how to write a

so that’s basically what we’re going to do before before i get any further here i just want to point

out that um this video is not about the basics of assembly nor is it about the basics of um

make files or some of the other related technologies that i’m going to show

i’ve covered everything in this video in a previous video um so if you if you find yourself

getting lost and you don’t understand what i’m saying or what i’m doing you probably want to

look at my previous videos because this is sort of a summary video to kind of help you

of help you help you really lock down on the concepts of writing functions okay so for starters

this right here that you’re looking at is a make file this is not a make file video if you want to

learn how to make make files or why they’re awesome see my other videos but i’m just going to assume

at this point you’re either willing to research my other video or you already know or you don’t care

how to make a make file so you know we’re just going to skip this i’m going to close it

function or sorry a driver module and what I’m going to do is I’m going to write this program

that I’m showing you now as a as a hybrid program a program with modules of different languages so

this module right here is going to be c++ and then we’re going to have an assembly module and

then they’re going to be able to call each other so the first thing that I’m going to do is I’m

going to name some functions that are going to be inside of my assembly module and also name some

module and also name some functions that are going to well name a function that’s

going to be just inside of the C++ module but it should be callable by the

assembly module so for that we use a little block called extern C and long

story short that disables name mangling which C++ does in order to provide

overloading functionality so we’re basically going to disable overload

functionality in order to have simple function names that way assembly can

and also when we attempt to call a function inside of assembly we’ll just call it by its

simple name rather than try to mangle the name based on the the arguments and return type and

such so that that’s something we have to do for compatibility at least for this video and I’m just

going to move on so basically you just take you just take the keyword extern and you put a c in

a quote and then you make a block right a little braces scope and then you just list prototypes of

types of either the functions inside of the current module which you would like to demangle

or other modules functions that you would like to be able to call in a demangled or

I guess a non-mangled way.

Mangled meaning name mangling.

Okay, so then I’m going to copy paste the main function that I’m going to do.

So this is a hybrid program, which means you know there are several different modules of

different languages.

driver which just launches the program and it contains like the entry point

like see how there’s like the the main entry point which if you know how to do

other languages this is usually where you start in C++ or like the GCC

libraries so this is the entry point for our whole program and then once we’re

inside of here we’re just kind of print out a message to the user we’re gonna

make a C string and then we’re gonna call on the assembly function we’re

gonna give it you know some numbers some integers and some floats and we’re

gonna give it our C string and then when we’re inside of the assembly

and then when we’re inside of the assembly function we’re just going to print those things to prove

that we know how to call and we know how to receive data from c or c plus plus into assembly

and then we’re just going to print you know goodbye basically okay so uh i’m going to make

another uh let’s see another function in the driver so that assembly has something to call

because i don’t just want to be able to call assembly from c i also want to be able to call

put in something that we can call on from assembly here.

I’m going to call it my CPP function.

And it’s just going to have like some arguments,

just some nonsense arguments.

And all it’s going to do is just print out that it’s entering,

print out the arguments and then just sort of say goodbye.

And then just return a value to the caller.

We’re going to return a floating point value to the call.

And we’re going to return a floating point value to the caller.

floating point value to the color okay so notice how at the top here i have uh in the extern c my

cpp function it’s the same thing that we see at the top is now at the bottom and that just means

uh this normally would be compiled and linked with name mangling and so because it’s in the

extern c block there’s no name mangling and the reason that works with an extern c block is

because there’s no name mangling in c that’s sort of like a c plus plus thing with overloads and like

whatever okay so we have like the basics for our driver it’s a simple module the hard work is going

to be inside of assembly so uh maybe before we write assembly oh you know what let’s write the

skeleton of the assembly and then i’ll start explaining uh what it means to call back and

forth and to make functions and things like that okay so for starters i’m just going to make a data

section with a bunch of stuff inside of it and i’ll explain it just very briefly again this video is

basics of assembly in Yasm. If you want to learn the basics, go see my other videos.

But for now, I’ll just assume that you understand why we’re making variables in the data section

and kind of how to do it. So I’m just, you can see here, I’m making a bunch of null terminated

strings. They’re null because they have a zero at the end. And I’m just saying, well, here’s a

message when we begin the program. Here’s a message to announce we’re about to print some integers,

to print a C string, to print some floats. Here’s another message for this, another message for

messages right then a crlf that’s just you know taking the cursor down to the

next line and then back to the very beginning so it’s like a basically a new

line and then I’m gonna have some floating point numbers and I’m gonna

have an a and a B number and then I’m gonna have a B and a D that I’ll send

somewhere else and so I’m gonna populate them with numbers from the start the B

and the D that just are not being sent they start at zero because we’re gonna

we’re going to receive those numbers from C and then we’re going to get a return value as a

floating point from the C function that we call so we’re just going to store it there so I’m just

like making a bunch of room to store some from some variables and then here we’re just going

to do system right and we’re going to send to standard output that’s covered in other videos

but basically we’re just going to be printing stuff okay so section text now this is where

actually starts. Well, sort of. This is where the program contains instructions to execute.

So section text. And the first thing I’m going to do is I’m going to name some external symbols

that I have for myself just to help me print integers and floats. So, you know, if you’ve

seen my other videos, you know that you can do a wide variety of things to sort of print characters

and numbers if you were clever. And you can also call on C library functions like printf.

functions like printf if you really wanted to print floating point numbers

and signed integers and stuff so you don’t have access to this library so

don’t worry about putting this part in your code if you’re working at this from

home unless you’re someone that has taken a class that I’ve taught somewhere

and for now just just assume that this just lets me print very easily no

problem you don’t really need that if you’re just kind of experimenting with

function this is the name of the function that we made in the driver my cpp function notice how it’s

over here my cpp function we’re just letting our assembly module know that there’s a function in

another module that we should be able to call on even though all these modules are going to be

linked into the same program we still have to do this just to let the assembly module know

okay so now we need to make a function called my assembly function if you look at the top right here

We had this other D name mingled prototype, my assembly function.

So we have to actually write that somewhere.

It’s not in the driver.

Let’s write it inside of assembly.

So my assembly function is going to start right here.

Boom, right there.

So this is when we kind of start on the basics of writing a function.

So for starters, hopefully you understand labels.

If you don’t understand labels by now, you might want to see my other videos.

just some sort of an alphanumeric symbol that you just kind of write as sort of

sort of like a variable name.

You can’t use every symbol available.

I would just start with using letters and numbers in the underscore.

Of course, you can always experiment if you want to see what’s allowed and what’s

not just type something and see if it compiles.

So the label starts with just, you know, this name and then a colon, right?

So that’s a label.

You can jump into labels.

Like if we were somewhere else in the program right now, we could like, if we

we could like if we wanted to do an infinite loop we could say jump and then the name of the label

and what would happen is execution would go back up to this label and then it would jump again

it would go back up it would be an infinite loop but we wouldn’t technically be calling a function

we’re just sort of jumping so labels are sort of the first step we have to do a little bit more to

actually make a function so we have an assembly function which right now is just a label and in

side we have to mark it as global so remember when we marked my CPP function

as extern that means we can call a function that lives somewhere else now

we’re marking this function as global which means it lives here but we want

other modules to be able to call on our function or our label okay so how do we

actually make a function let’s see the first thing that you should do is try to

understand that if that all functions return even if they don’t return any any

Under the hood, what this is actually going to do is crash the program if you just jumped

into this label and didn’t call it like a function, because the return instruction will

look onto the call stack and try to find a return address for wherever this function

was called from and then go jump, do a jump instruction to return there.

And so if you just jumped into this label and then there’s a return, it’s going to pop

something up the stack that’s not actually a return address and probably crash the program.

So that means now that we have a return statement, we definitely have to call this like a function.

And I guess that’s pretty easy because, well, if we were inside of assembly and we wanted to call another function,

let me just show you real fast.

I’ll say some other function.

If we were inside of this label, for some reason, we could call the above function by just saying call.

And then the label.

So now it’s being treated like a function.

it’s being treated like a function.

What the call instruction really does is it just looks at the address of the next instruction

that would have been executed.

So, you know, whatever, let’s say we have like a nope on the next line, whatever the

memory location or the relative memory location is of that nope instruction, it’s going to

push that onto the call stack.

And then it’s going to just do a jump instruction to this label.

So then later when we hit this return statement, then it’s going to look onto the call stack

and it’s going to find that return address, which is going to correspond with the nope

instruction and the return instruction is going to do a jump back to that address.

So basically you have to use the call instruction to get there and then use a return instruction

to return from there.

And then now we can actually call it a function.

But then there’s other things that functions have to do to behave themselves without crashing

the program.

So for example, notice up here that I have copy pasted the let’s see call on assembly.

Oh, I think I forgot to update that.

I forgot to update that. Let’s see. Call on this. Yeah. It’s supposed to be called my assembly

function now. Hold on. Let me update my, uh, my solution. Whoops. Hold on. Call on.

There we go. My assembly. Okay. So I’ve got my solution up above on another monitor.

So I have the prototype of the function here. Uh, it’s just going to return nothing. And it’s

going to like take in a long and a double and a long and a double and a character pointer.

And then my intention here is to save these arguments with some registers.

So notice how I’m saying we’re going to use R12, 13, and 14 to save the arguments A, C, and E.

And we’ll talk about why we’re not saving the other ones with those registers in a second.

But basically we’re going to use those registers.

So the thing about the registers is we have to do something called respecting the ABI.

Respect the ABI.

The ABI stands for the Application Binary Interface.

interface and it’s just sort of like a standard that governs all of the things that you can do

and you’re supposed to do when you’re working with x86 64 assembly so the abi is pretty cool

hang on a second the abi is pretty cool because it actually standardizes things

for instance if we didn’t have the abi and we didn’t respect it then we couldn’t actually call

plus or vice versa because c plus plus the higher level languages they’re going to use the abi so if

you try to do things your own way then all you’re going to end up doing is wasting time and energy

coming up with two different ways of doing things when you could have just done it the abi way

right so and one of those and one of those ways your way wouldn’t even work uh for cross you know

module calling it would only work internally to your own program so we’re going to respect the abi

does the abi say about these registers and again i’ve talked about this extensively in other videos

but let me pull up a fun book that i love to uh to talk about uh so this book right here i did not

write it uh the book here is written by a really wonderful uh professor dr ed jorgensen phd and um

this book is totally free it’s not i’m not selling you anything uh this is literally you can just go

to this this professor’s website and download his book for free and he’s already given me permission

and he’s already given me permission to just tell everybody to just share it with everybody if you

if you look in the license area it’s a copyleft license so it’s sort of like the spirit of open

source just sort of like sharing knowledge and stuff so it’s awesome so I suggest everybody you

know follow the link that I hopefully put in the video and and grab a copy of this book but

basically what I’m going to do is I’m going to go to a special area and I’m going to search for

here and so that would be I guess section 12.8.2 and it’s called register usage subsection 12.8.2

notice how it lists all of the registers and kind of how they are typically used

this falls under the scope of the abi so this is not all the abi is but this is one of the

things you’re supposed to do when you’re respecting the abi is you’re supposed to sort of like

are supposed to be used. Notice R12, which is one of the registers that we’re going to use,

is designated as callee saved. So that means whoever is being called has to preserve that

register if they intend to mess it up. So for example, if I just had this function here,

move some value into, you know, R12, I have now basically broken the program. If any, you know,

C function or other library that you didn’t write, just any anywhere else calls on this function,

anywhere else calls on this function then their version of r12 is going to get destroyed by what

i just did and so i’m not respecting the abi when this function returns to the caller they’re going

to expect that their original data was intact and if it’s not program is not going to work it’s going

to screw up so respecting the ai means you have to preserve any registered mark as callee saved or

that’s one of the things that it means so notice how r12 through r15 are callee saved so we have

the abi now and sort of preserve 12 13 and 14. we can do that pretty easily with some push and pop

statements so i’m going to do push r12 push r13 push r14 and now what happens is those values

are actually on the stack now and i can retrieve them later at the end of the function even if i

destroy them while i’m inside of the function i’ll just restore them right before i return so

because it happens before the function does anything.

And then we have to make sure that we pop those values

because you have to be careful with the stack.

If you just start pushing values

and you don’t restore the stack to its original state

by the time you return,

you’ve basically broken the program.

It’s either going to crash right away

or whoever called it is not going to function correctly anymore.

So let’s do some pops.

We’re going to do three pops

and we’ll call this the epilogue,

which means uh you know something we do right before we exit the function and keep in mind

that the order of the pops should be reverse of the order of the pushes notice how we’re popping

in reverse order from what i did before so we’re going to pop uh 14 13 and 12 where as we pushed

12 13 and 14 before if you pop in the wrong order like if you try to do it in in the same order as

the pushes then uh you’re still going to end up destroying data for the caller because you’re

because you’re going to be restoring data to the wrong registers.

So just keep that in mind.

OK, so now the ABI is being respected.

Let me see, by the way, do we have enough to actually even run the driver right now?

We’re just calling it and then it didn’t really do anything.

Yeah, I think we could probably this might compile.

OK, let me let me just check this out.

I want to say clear and make run.

Yeah, it compiles.

OK, so the driver printed its hello message.

again it’s just sort of saying like hello from the driver and then when the driver comes

back it says the driver regained control and nothing really happened because well we didn’t

do anything in our assembly function yet but at least we’re calling multiple modules and again

if you want to know how to do hybrid programs and linking and compiling and all that stuff

see my other videos for now I’m just going to move on so the next thing we have to do is we have to

have to try to understand like how are we going to receive these arguments so this is one of the

other you know building blocks to making functions notice how the assembly function i’m sending in an

integer and then a float and then another integer and then another floats i’m kind of mixing the

arguments then at the very end i’m sending in a pointer if i look back up at the prototype here

which matches what i’ve what how i’ve used it it’s a long a double a long a double and a character

longs and doubles, they actually, they’re called mixed arguments and they don’t actually count

against each other when you’re looking at the order of the registers to stuff them into.

So for example, let me show you here. We have, what did I just do? I clicked on the wrong

computer. Okay. I’m on the wrong computer. Okay. Let me close this real fast. So

When you think about registers for incoming arguments, you basically start to think about this.

RDI and RSI, those registers represent the first and the second integer arguments.

If we look back to the book real fast, we can see in that same section, RDI is the first argument,

and then RSI is the second argument, and then RDX is the third, and then the fourth.

We can do up to six arguments with R9, and then after that, we have to start pushing arguments to the stack.

stack i’m not going to go that far in this video i’ve actually done that already in a previous video

but basically we for for now we can just use six registers to push arguments but if you think

about it these registers these are not floating point registers these are general purpose registers

they’re meant for integers and pointers the reason they’re used for in it for pointers also is because

a pointer is just an integer a pointer is just a 64-bit integer unsigned which represents a memory

can use these registers only for integers and pointers but we can’t use them for floats so that

means the first integer argument is going to be RDI and the second integer argument is going to be

RSI but if there was a float argument in between then RSI would still be the second integer argument

the floats don’t count against the integers and vice versa so for example if we’re talking about

float registers you know the first one available is XMM0 and then we have XMM1 and then we have

we have XMM1 and we have XMM2 and it goes all the way up to I think XMM15 so we have 16 floating

point registers. So we could pass in 16 floating point arguments just using these registers if we

wanted to and then if we want to do even more than that we probably have to get you know funky with

the stack or something or maybe hopefully you just have an array somewhere and you’re just going to

pass in a pointer. But the way you have to think of these arguments is that even though they might

they might be mixed in the prototype of the function that you’re calling from a higher level

language you shouldn’t think of them as being mixed when you’re actually loading up registers so

again if we just kind of like go back here to this prototype

notice how that a variable we’re going to say that the a is rdi because a is along it’s an integer

but then right after that there’s a double b we would not skip rsi or assign b to rsi

b would just be the first float argument and then when we go back to long c long c is actually the

second integer argument because that double doesn’t count against the integer so it’s going to be c

is going to be rsi and then uh for double d uh same thing uh we’re not going to skip xmm1 just

because there was a an integer we’re going to go straight to saying that xmm1 is the second float

so it’s the d then for the last argument that we have i’m just going to erase this stuff down here

it was going to be e and remember pointers are integers they’re just unsigned uh 64-bit integers

we have to go on to the next one which i think i recall is like rdx let me just double check

i don’t want to say this wrong rdx yeah the third argument so i’m going to do rdx and now

that we’ve kind of like mapped this out we we know now what what registers we should be looking for

we should be looking for when the function comes in in order to receive

our data we should look at those registers for those variables another

thing to keep in mind by the way is that usually when we return something in

assembly we will move a value into RAX right like some value if you’ve been

following my assembly videos so far but that only counts if you want to return

an integer or a pointer if you instead wanted to return a floating point number

use XMM zero and I’ll just you’re not allowed to you’re not allowed to hard code a floating

point number in assembly like this or at least in the ASM so we’ll just pretend that there’s

like a float somewhere and I’ll just load it from memory and I’ll say like the float

something like that so notice how we’re using a different instruction we’re not using the regular

move instruction that works with integers we’re instead using the floating point version we’re

saying let’s move a single piece of data and let’s move a double precision floating point number

xmm zero and then we’ll just grab from memory whatever whatever that variable has we’ll just

take that floating point number and stick it into xmm zero so uh if you want to return an integer

or float you use rax if you want to re sorry if you want to return an integer or a pointer

you use rax if you want to return a float you use xmm zero you shouldn’t do that at the same time

if you have like two assembly functions calling each other you might be tempted to do that and i

you know very standard and it wouldn’t work very well with other people’s code or library code or

higher level language code so only one or the other and it just has to match your prototype

so notice how here inside of my cpp function notice how it’s going to return a double

right so when the assembly module is done calling on this function it should expect xmm0 to be

loaded up with that double precision loading point number okay so that’s the basic idea

Okay, so that’s the basic idea.

So now let’s maybe let me pin this.

Let’s kind of fill this out a little bit more.

So the first thing that we should do

is we should save our integer or pointer arguments.

So I’m gonna leave the respect ABI thing there.

And notice how I’m just looking at RDI and RSI and RDX.

And well, I guess, you know,

we have it in a comment up here, A, C and E,

but I’ll just make another comment here.

here I’ll say like a and a or sorry a C and E and maybe we’ll specify the data types for fun

it’s going to be long a and then long C and then the character pointer C even if this was a float

pointer it would still be an integer because all pointers are integers no matter what they’re

pointing to so just keep that in mind anyway so we’re going to save r12 r13 and 14 with the

14 with the incoming arguments and the reason we want to save those right away is because rdi rsi

and rdx those are not callee saved which means the moment we call in another function they’ll

possibly be destroyed because we don’t really know what’s going on in other functions that we might

call so it’s a good idea to just kind of save right away either to a global or the stack or

in this case just registers being faster okay so we have that now we have to save our float arguments

b and d were xmm0 and xmm1 so I’m just going to save both of those

and if you’re wondering what this float b and float d are that’s just

you know up here I just have a global variable so I can save them to memory

easily and not worry about the stack this is not a stack video so much

but yeah okay so I’m just saving all of the incoming arguments that’s all I’ve

done so far and let’s see it should probably still

Let me see if this works.

I’m going to go make run.

Okay.

So nothing happens, but it at least worked.

So I’m going to same as other windows for that so that we don’t have to look at it anymore.

And now that we’re done saving our float arguments, let’s, let’s print a welcome message.

So I’m going to do, you know, welcome.

And I’m going to use a special function that I’ve made in previous videos called print

null terminated string, which means I should probably copy paste that into this program

now.

What is print null terminated string?

It’s just another convenience function that I wrote.

I’m not going to explain it too much because it’s in other videos and

I’m already here trying to explain functions to you in general.

So long story short, it takes in a C string and a file handle, you know, to like where

you want to write, like if you want to write to a file or you want to write to standard

output or standard error.

And it just takes those arguments and then it sort of says, all right, how long is the

string?

And it uses another function called string length to figure out how long the string is.

how long the string is and then it just uses a system call to actually print the

string and again system calls are covered in other videos this one looks

really convoluted because it’s like you know customized for this function but

just trust me on this this prints a string next function I got a paste in

real fast again explained in other videos is the string length function so

all this does is it just takes a pointer to a string and it sort of scans the

string is and as soon as it sees a zero like a null terminator then it just says all right that’s

that’s the end of the string and it’ll just return the length to the caller so that’s all you need to

know about this covered in other videos then i’m going to make a convenience function here called

crlf and all that’s going to do is just print the new line that we talked about earlier so just

just a bunch of convenience functions on top of the real part of the program so now that we have

the convenience functions in there we should be able to see the welcome message let me just double

yeah now inside assembly entry point oh what did I do wrong now inside I keep forgetting to change

the strings on this now inside where’s that now inside my assembly function okay let me change

that in my solution to you know I’m just kind of like writing these things and I’m having fun and

I keep changing my mind about what they should be named and then I I get some inconsistencies okay

all right so then uh we printed the welcome message and now let’s print the integer arguments

but first let’s print a little introduction uh to the integers let’s just say hey we’re about

to print the integer so that’s just this other string a message saying we’re about to print the

integers nothing really that complicated so far it says now we’re printing all the integer arguments

so now we can actually print the integer arguments so we have two integer arguments

if you recall let’s see yeah we had like a and c those were integers I’m not going to talk about

e right now because that was a pointer but you know right now we’re just saying a and c so that

was r12 and r13 so I’m just going to paste some code here to actually print those and

talk about this library in other videos but basically I’m moving r12 which is the first

integer argument that functions typically receive and once that’s loaded up i’m just going to call

on my special function to just print the integer and again you could use printf from the c libraries

if you actually wanted to print it and not just experiment and stuff like that so i’m going to use

r12 and r13 and i’m just going to print both of those integer arguments and then after each one

is printed notice i’m calling the crlf function which is just the convenience function of just

which is just the convenience function of just like doing a new line.

So now we should see two numbers. Yeah.

Now printing all integer arguments,

we’ve got an 88 there and then that other giant number there.

Let’s just double check that that’s actually what we’re supposed to be seeing.

So I’m going to do this and I’m going to say,

the driver called the assembly module with these numbers.

It gave it an 88 and then for the next integer,

it gave it the 287 giant number. So great.

so great we’re printing the integers now let’s print the floats so we should see

like a 99 point something in a 32 point something next okay so let’s continue

with printing oh sorry actually let’s print the the C string because that’s a

pointer that’s still more closely related than the floats so the first

thing I’m going to do is I’m going to

print the received c string how about like announce that we will print the c string because

that’s what we’re doing right here let me change my solution to match and then we’ll uh we’ll

actually print the received c string next so same stuff as before first we call print null terminated

string to print out a little welcome message or just like an intro message like we are going to

print the c string and then we’ll use that print function again but we’ll give it the c string so

it the c string so it just prints the whole c string out and this should prove to you that we

are indeed receiving a pointer to some data owned by the c plus plus module so if we run this real

fast it should just tell us two more things it’ll give us the announcement now printing the received

c string and then on that same line it says hello this is the c string owned by main and if we just

that’s exactly what string is inside of that variable so hello this is a c string owned by

main and we gave it to the function by just kind of passing it in and we know that character arrays

are basically character pointers or any array is just a pointer to the first item in the array so

my c string is really a pointer to that h character so if we pass that in then a pointer

based print function should be able to work and that’s what happened okay so we’ve done that

So we’ve done that.

And then the next thing we should do is let’s print the floats.

So first let’s announce that we’re going to print the floats.

Same thing we’d before we’re just printing like an announcement message.

If we run the program again, it’s just like now printing the floats, but it doesn’t actually

do anything.

So then the next step is let’s, let’s grab the first float into XMM zero.

And then let’s call a function to print it.

so right here we have like that 99 number that we expected from before by

the way so why am I doing it this way why am I not just keeping XMM zero

because you remember before we had XMM zero had that had the float that we

received and then we’re using it again down here but remember XMM zero and all

the other float registers they’re not designated as callee saved which means

the moment we call any other function we should expect that that data has been

so I can’t actually count on XMM 0 surviving just this little simple function instead I have to save

it somewhere to the stack to memory you know whatever so I’m just that’s why I put that into

a global variable so it’s sitting in float underscore B right now and then we saved it at

the beginning to float underscore B and if you just kind of look up to the data area well it was

just float underscore B was just a little quad word you know eight bytes of memory that can hold

hold our float. So we have like float allocations for B and D, the first and second float arguments.

So we’re saving it there. And then we’re recalling it here. And remember, the first function argument

is going to be XMM0, regardless of where that data originally came from. So if we look at the next

one here, if we kind of like, let’s see, copy paste this, and we want to grab like the D float,

still going to load it into XMM zero because right now it’s not about what we originally

received as an argument.

It’s what this function expects as an argument.

This function only takes one argument.

It just wants a float so that it can print it and that’s it.

So both times we’re going to load it up into XMM zero and then we’re going to print a new

line.

Okay.

So let me just run the program one more time and we should now see we’ve got two floats

and they should match what the driver tried to send in.

Right?

99, that’s the first one.

And then 32 point something, that’s the second one.

So cool, we have received integers and pointers and floats.

We’ve recalled them and then we’ve printed them.

Pretty slick, what do you think?

Anyway, so we’ve done that.

And the next thing that we should probably do is…

Well, at this point, we just maybe have to mess with return types.

Even though I’ve told you about it, we’ll just mess with it a little bit.

mess with it a little bit. But let’s call the C++ module. So what I’d like to do first is just sort

of announce that we’re going to call on the C++ module. Again, typical design pattern, let’s just

print a message saying what we’re about to do. And if we run this now, it’s going to say assembly

module will now call on the C++ module. So nothing really too complicated. So now we’re going to call

on that function. Let me let me paste the name of it here. Actually, I’m going to put this one right

I want to put this one right here.

It’s the my CPP function function.

So if we look back at the driver

and look at the signature for my CPP function,

whoops, it has this signature.

And if you wanted to look up higher,

you totally can just look into the name mangling section.

Whoops, the my CPP function, it returns a double.

It takes in a long, a double, a long, a double,

and a character pointer.

Basically the same thing as the other one,

as the other one except it returns a double so what’s going to happen is when it takes all of

these in it’s just going to print all of them and then i’m just going to have it return just kind of

like some random double that i decided to type because this is not an arithmetic video okay so

cpp function and then um now how do we interpret that so if we uh let’s see let me maybe just for

help this usually helps me when i’m trying to do this i’m going to take the prototype and just sort

and just sort of like paste it right where I’m about to call the function.

So I’m going to do this just to remind myself of what I’m actually calling.

Let me add that to my solution, by the way.

Okay.

So we’re going to call myCPP function,

which means it’s expecting some registers to be loaded up with arguments.

If we don’t actually load up anything right now,

it’ll probably do some sort of nonsense.

Let’s actually see what happens right now.

If we don’t load up the appropriate registers,

then C++ will still look at those registers expecting to see valid data.

Let’s see what happens.

I don’t know if it’s going to be good or bad.

This would probably be something called undefined behavior,

meaning you did something wrong,

and probably sometimes your program will work,

and sometimes it won’t.

Sometimes you won’t understand what’s going on.

So I’m going to do this right now,

and it’s saying, oh, it’s segfaulted.

Okay.

Why did it segfault?

all right well I guess maybe because I did something naughty I don’t know

if this say faults by the end we’re going to be in trouble I’ll have to debug on camera

so uh we’re going to enter into my cpp function and then it says we got a variable a

which was a long we didn’t give it a one a one was just probably sitting in there

before we even called that function so like one is definitely not it and then b was like some

floating point number and then C was just like another seemingly random value

that kind of looks a little bit more like a pointer I’m not really sure it’s

probably not but it’s just some junk data coming from somewhere and then D

which I think D was supposed to be a character pointer it says not a number

so we just got like a a really bad value for D let me upgrade this real fast

because maybe we should be printing what printing it as a memory location so E is

So E is, let me bring this down real fast.

So E is supposed to be a character pointer.

Let me, instead of printing the C string as just like itself, let’s first print the memory location.

And I’ll just say memory.

And then we’ll do a static cast.

Oh, I wonder if this will actually change anything.

I wonder.

Let’s static cast both of them just to see what happens.

print e and uh c string here and then it’s going to be um

hmm no i don’t think that’s actually going to change anything

because if i cast it as a point as a character that’s definitely wrong

and if i don’t cast it then it’s going to show up as its original data type how do i get the memory

location hmm oh i know what to do i can static cast it maybe as a as an unsigned long okay

and unsigned long. Okay, so a character pointer, we’ll leave that for the C string. Unsigned long,

long, just in case. And I think I should see the memory location first and then the actual C

string later. If not, then whatever. Let’s try one more time. Oh dear. Invalid static cast from

a character pointer to a type long, long unsigned integer. What have I done? How about unsigned long?

long see if that works character pointer long int i guess i forgot how to cast pointers to longs

i’ll look that up and post another video in the future but i guess for now we’ll just

we’ll deal with this humiliation and i’ll just print e by itself

all right so i’m just going to run it one more time it should say fault again

is wrong let’s uh let’s just fix the arguments so before we make that call we should load up some

stuff right so i’m going to do maybe like a semicolon comment here and then i’m going to do

what else do i have i’ve got three move instructions so the first argument is going to get

77118 the second argument is going to get 1111 and the third argument looks like it’s going to

get a pointer that i’ve defined inside of the assembly module so if you look back up at the

look back up at the top let’s see message string inside asm message string inside asm so basically

i’m going to be sending a character pointer to this t right here which is just this string says

this string is owned by the assembly module and it’s a null terminated string which uh c definitely

needs in order to print correctly if we took that zero off we’d probably get a bunch of junk data

we might crash the program i don’t know so anyway basically we’re just going to be saying you know

we’re just going to be saying, you know, here you go. Here’s a pointer. Where the heck am I?

Okay. Here’s a pointer to a C string. And so we’re giving it one, two, three arguments. We’re giving

it the A and the C and the E. Now we just have to load it up with the other two floats. So

I’m going to do this real fast. Remember the first float argument is going to be XMM zero.

And the second one is going to be XMM one. And you can see that send B corresponds to the first

corresponds to the first float argument.

That’s why it’s XMM zero.

And then the float send D corresponds

to the second argument.

That’s why it’s XMM one.

And that’s the D right here.

And there’s no other floats.

And if we just kind of look back up real fast,

the float send B and D,

I just defined those arbitrarily

to just these two random numbers.

So we should see like a two one nine

and then a nine nine eight eight seven seven six

sort of, you know, weird number.

number then when we’re done loading all those things you know all of these registers up now

the function should be able to receive something i bet you the reason it crashes because we

we had like a bad address for the the string previously because we didn’t load it

so let me go up here and now it doesn’t crash so if you just kind of like look we have hard-coded a

and b sorry not not a and b a and also c so that’s the seven seven one and then the bunch of ones

of ones and then the string which was rdx which was the e so this string is owned by the assembly

module nice we’re now able to print a string that’s owned by assembly in another module in

the c plus plus module and then xmm0 and xmm1 those are the two floats so if we look back up

again that’s uh we should expect to see these two numbers right here whoops um bloat send b and d

and then D. So the printing kind of turned it into scientific notation. That’s okay. You know,

there’s other stuff you can do in C++ to just not print in scientific notation, but for now,

I don’t really care. It’s basically the same value. So it’s fine. I just want to show you

how to transport data. This is not a C++ video. Anyway, if we go back down to the end of that,

so we called the function, but then this function, if you notice, it returns a double,

we should expect to see something loaded into the XMM zero register.

So I’m going to move a single piece of data and it’s going to be a double precision floating

point number.

And I’m just going to store it into my float got return value global variable,

which I defined up above.

So let me scroll up real fast.

So where is that?

Where is that?

Float got return value.

I initialized it with a zero just because we’re going to receive something in there.

I could have used the BSS section if I wanted to, probably would have been a little bit

bit smarter and more performant but i don’t know i personally don’t like using the bss section in

yasm unless uh i want to allocate an array if i’m just doing one variable here and there then i’m

just going to put it in the globals or or the data section so float got return value i’m saving it in

there and then uh i want to grab it from xmm zero so that’s where it comes from when uh my cpp

return the double to us inside of XMM0.

So I’m just moving that into my data section into the global variable.

And then now that we have finally returned from the C++ module,

I’m just going to announce that we have indeed returned from the C++ module.

Let’s get that far real fast.

So this string is owned and then my CPP function exiting.

exiting and then now it says the assembly module received this return value from the

C++ module and then it says the driver has regained control because we were supposed

to print the float and do a line feed after that and we didn’t so basically assembly just

printed this string that was the last part we just added and then it returned right away

to the driver so let’s finish this up so next thing we’re going to do is we’re going to

move the float value back into XMM0.

Remember, anytime you call a function, all your float registers could be destroyed.

So it makes sense that we saved XMM0 and then we loaded it only several instructions later

because you don’t know what’s happening under the hood inside of print null terminated string

or any of the system calls that it uses.

Your XMM0 is likely destroyed, but you don’t know for sure, right?

If you count on it not being destroyed, you might be introducing undefined behavior to your program.

So that’s not good.

Anyway, so we’re just loading back up from that global into XMM zero.

And then we’re calling that function again to just sort of print the float.

And it wants the float as argument zero.

So we’re just sticking into XMM zero.

And then we’re printing a new line.

So then when we’re done here, run it.

and now it says the assembly module received this value from the C++ module and notice how it’s that

special value that I hard-coded 112222 whatever so that’s this value right here

and again if we had this cpp function returning along then all we would have to do is look at

the RAX register and if we had let’s let’s say for some reason that this assembly function we

function we wanted to get something from it we could say you know double temp

equals that then all we’d have to do is make sure that we returned sorry we

loaded XMM zero with our return value in the assembly module because XMM zero is

the return register for floats or if we wanted to do like a long then just load

RAX with something at the end of my assembly function and that’s how C would

C and C++ they’re following the ABI so if you personally don’t follow the ABI

you’re just going to end up memorizing two different ways of doing things and

your way is not going to be compatible with all the other modules written in

higher level languages so it’s kind of a waste of time and your modules won’t be

compatible with other people’s libraries and functions it’s just a huge waste of

time so just follow the ABI in the first place I’ve literally known people who

said you know what I don’t want to learn the ABI that’s dumb then as they wrote

they wrote a bunch of assembly they just started thinking like oh this is too confusing because i

keep forgetting what registers i was going to pass back and forth between my functions

and like a month goes by i come back to an old program i can’t remember i have to like look

through all my code again so then they started accidentally inventing their own little scheme

like oh i know what to do i’ll put the first argument in this register and i’ll put the

second argument in this all they were doing is just reinventing the abi from scratch and then

got to that point and then later wasting more time when they realized they just needed to learn the

ABI and forget about their way so don’t let that happen to you and you should probably just try to

do it the right way the first time right um a lot of things in coding and computer science in general

are just time savers that feel like wastes of time at first okay what else we have anything

that I wanted to show you that was actually I think the entirety of that program let’s run it

while I check to see if there’s any other stuff that I was supposed to show you.

So let’s do this.

Everything seems to be working.

Let’s see, I wanted to tell you about labels, return, call,

the stack, the return address, prologue and epilog,

pushing and popping, respecting the ABI.

I wanted to show you that textbook function arguments, mixed arguments,

int or pointer return types and float return types.

I guess I got through everything without forgetting something huge, which, hey,

that’s probably a first not that i recall at the moment but it probably is

anyway so uh i guess that’s it i hope you feel like function experts now in yasm x86-64 assembly

also known as a amd64 assembly in ubuntu okay thank you so much for watching this video i

hope you learned a little bit and had a little bit of fun i’ll see you in the next video

Hey everybody, thanks for watching this video again from the bottom of my heart. I really

appreciate it. I do hope you did learn something and have some fun. 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.

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. I promise that’s what will happen. Also, if you look at the middle of

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

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 YASM x86-64 Assembly Functions Tutorial – Integers, Floats, Pointers, ABI, C++ Interoperability appeared first on NeuralLantern.com.

Quick but deep look at local variables on the stack in x86-64 assembly (YASM). We cover allocation with sub rsp, accessing via offsets, why the stack must be 16-byte aligned when calling libc functions like printf, and two practical ways to fix alignment crashes. Includes live segfault debugging and a full working example with a local array.

Great for anyone studying systems programming, computer architecture, or just trying to figure out why their assembly program randomly crashes on a library call.

Like + subscribe if you want more clear, practical assembly tutorials!

00:00 Introduction to Local Variables on the Stack
00:28 C++ Example of Function and Local Variables
01:06 Incoming Arguments in RDI vs Stack Variables
03:24 Pointers as Local Variables on Stack
04:34 Why the Stack – Recursion and Multiple Calls
05:18 Visualizing Multiple Stack Frames
09:24 How Function Returns Adjust RSP
10:35 Stack Grows Downward in Memory
11:33 Program Setup – Hybrid C++/Assembly
12:46 Assembly Module Overview
14:00 Function Prologue – Register Push & Alignment
15:30 Allocating Stack Space for Local Array
17:45 Initializing Array in Loop
20:10 Printing Loop with printf
49:48 First Run – Segfault Observed
51:00 16-Byte Stack Alignment Requirement
51:55 Fix 1 – Extra Push/Pop in Prologue/Epilogue
53:15 Fix 2 – Push/Pop Around Each printf Call
55:04 Testing Different Array Sizes
56:52 Debugging Alignment Behavior
58:54 Summary – Creating Any Local Data on Stack
59:59 Closing Remarks & Subscribe Call

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hi there! Today I’d like to talk to you about local variables on the stack

in an x8664 assembly program written in YASM.

If you don’t understand assembly or local variables or other things like that you might

want to see my other videos but I’m just going to give you a quick example. So what am I talking

about with local variables on the stack? For starters forget what you’re seeing here for a

blank code page and pretend that we’re coding in c plus plus just for a moment this is an assembly

video but pretend this is c plus plus so suppose you have c plus plus you have a main function here

and at the end of it you know this is your entry point for your program we return zero and maybe

above it there’s a function called f i’m putting it above because i don’t want to use prototypes

in this video but you should probably use prototypes um maybe main calls on f and so then

what happens? I don’t know. Maybe we have some arguments. We’ll call this integer argument A

that comes in. If you’ve watched my other videos, hopefully you have by now,

you’ll know that A comes into the function as RDI because that’s the first integer argument

register. But then when we start creating local variables, we’ll say integer B equals, let’s say,

a five and then integer C is equal to an eight for whatever reason. Maybe there will be an array.

So I’ll call this a int array, I guess.

We’ll say that we have 100 integers in our array.

We could also have a pointer, int pointer p,

and then allocate it to some kind of new memory just to prove a point.

And then, you know, later in your function,

you’re probably going to want to do something with your data.

So I don’t know, maybe a, how about like b is plus equal to a,

of C++ and then oh C++ C is plus equal to B for some reason I’m just making random nonsense up

honestly I’m just showing you that we use our variables and then maybe you want to build an

array so we just declared the array up here on line six but maybe you want to actually do something

with it you want to fill it with data maybe so I’ll do size type I is zero keep going until I

is less than as long as I is less than 100 I plus plus and now I’m going through every single index

array maybe I’ll say the array at index i is equal to c and then we’ll just say c is plus equal to b

and then we’ll do b plus plus just to have something in there okay so let me explain the

parts of your program real fast if you haven’t watched my other videos please do because this

should help a little bit anyway so a is an incoming argument like I said before that’s

usually coming to you in the RDI register because it’s the first integer argument so we don’t need

to worry too much about that we know that a is actually just a register in your CPU and b that’s

created on the stack and c is created on the stack also and the array is created on the stack by the

way I could name the array anything if I wanted to like just v I’m using the name array because

Notice also that we have a pointer here. I just wanted to make a point that the pointers we make in our function are considered local variables.

And that means they do sit on the stack because what I’m trying to say is that local variables that are not arguments, they sit on the stack.

But the memory we allocated and then gave to the pointer, that’s sitting in the heap somewhere.

So when you use the new operator or the malloc operator, or you’re just like making dynamic memory,

that dynamic memory sits in the heap, but the pointer itself, since we just declared it here,

that sits on the stack. That means later on when your function ends, the p pointer itself will get

cleaned up automatically and itself won’t be leaked memory. But if you forget to clean up your memory

here, like I did, you’ll have a memory leak. But I’m going to talk about memory leaks probably in

some other videos somewhere else at another time. Anyway, so then we have our local variables here.

remember B and C and array are all on the stack and well we just have our

for loop here where we just kind of start modifying data so why would we use

the stack let me just do a quick tutorial this is not a stack video I’m

gonna make a stack video in the future but I’ll just do like a quick little

rundown of what is the stack and why is it really good for function calls

consider that sometimes F might want to call itself maybe it’s a recursive

be like a long chain of function calls like f calls g and g calls h and h calls you know whatever

and it just goes on and on and on as long as it’s not infinite recursion like all the functions are

calling themselves in one circle that never ends you should be allowed to do that we should be

allowed to have a function f that sometimes calls itself or other functions or maybe it’s called

multiple times within our giant call stack our call graph and this will work because these

you know a b and c and array are sitting on the stack and the stack allows you to have sort of

different instances of variables so for example and this is just a quick thing i’m not this is

not supposed to be a full stack tutorial here but um you know if we have like the function f

and let’s say we call it at some point maybe uh maybe main calls f uh and then let’s let’s pretend

f and then f calls h and then maybe h calls f and um did i write an h there no i think that’s

supposed to be a parenthesis i’m sorry i have bad penmanship oh god it’s even worse hang on let me

let me do another h here i’ll just do it i’ll just do a g about that f g and then uh

F again. Let’s just pretend that we can have a call graph where F is sometimes called by something

and sometimes called something else or maybe sometimes F is called by a different thing. So

like I guess this was supposed to be the G function. So maybe that’s why down here was the H.

Should I delete this video? I don’t know. You know what? I’m going to start. I’m going to delete this

and then G calls H and then H calls F and then F calls I I guess and then

eventually these functions start returning right oops how come my greens

not working green there we go too late now so we can have like a really

complicated call graph and F might appear in there multiple times and the

Each call to F along the call graph should have its own copy, unique copy of local variables.

So the B for this first F call, let me just do an arrow here, will have a B.

And you can imagine it as B subscript 1.

And down here when F executes, you can imagine that it’s got its own copy of B.

So we can imagine this as B subscript 2.

So these are two totally different Bs.

If you tried to use global variables for this, it would be really, really, really hard to get the code to work.

get the code to work and it would be really, really hard to debug.

So that’s kind of why we have local variables.

The stack allows us to do this.

So what is the stack itself?

Again, this is not a full tutorial on the stack,

but I just want you to kind of see what’s happening.

Imagine a data structure that kind of grows upward.

I’ll say that here’s the floor at the bottom.

And when you put an item onto the stack,

the items kind of stack on top of each other.

So imagine that this is the call to F.

is the call to f and embedded within this little stack frame area we’ll call it a stack frame but

actually the stack continues to grow as you create and destroy local variables within a function call

we’ll just imagine that there’s i don’t know a mini stack sitting inside of the stack that

contains all the local variables i’ll just put i’m not going to put a because a is an argument so

it’s sitting in a register but we could do dude i got to learn how to how to draw with this tablet

We got to do B and C and the array.

I’ll put AR for array.

Sitting in, you know, their own little spots on the stack within the major portion of the stack that is designated for that first F call.

And then, you know, maybe F calls G and some other stuff happens.

I’ll just pretend that a bunch of other stuff happened.

And then eventually F is called again.

But there’s a different, this is a different instance of the call to F.

it’s got its own little area that is separate from the the previous call to f and again we’ll

also have variables that we can create locally that are supposed to be separate from the original

variables oh god that’s awful and ugly i need to maybe decrease the size of my eraser or something

but imagine this is uh you know these are two separate copies so that’s like what i said before

when we have like a b1 and a b2 basically they’re not going to be called b1 and b2 but they’re just

They’re not going to be called B1 and B2, but they’re just two separate instances.

And I just want you to know.

So then when we start returning from functions, like when this F eventually returns, and by

the way, I know that what I’m drawing on the right doesn’t match the code because this

is not a function that calls itself, but just suppose that your code is a lot more complicated

than what I drew up.

When it eventually returns, all that happens is those items on the stack just sort of get

not necessarily deallocated, but ignored.

We’ll just say that they’re gone.

They’re still sitting as junk data in system RAM somewhere.

And in assembly talk, we know that we have a stack pointer called RSP.

We have a register called RSP that just sort of points to the location in the

stack that is considered the top of the stack, like the most recent piece of data

that we have available.

So all the other data is actually still kind of above, but we’re not pointing to it

anymore, so we consider that it doesn’t exist.

So then when G eventually returns, you know, we just change the stack pointer,

Rsp, to point to that other piece of data.

The G data frame and the other F data frame are still sitting above somewhere in memory,

but we just ignore them, right?

So that’s how the stack works.

And that’s how we have local function call copies of all of our local variables.

Something to note.

Something to note, this is not a stack video, but you know, just something to note that

even though I draw the stack visually as growing vertically up, when you actually manipulate

the stack in assembly or just like in any language, the stack grows downward in terms

of memory locations.

So you can imagine, I’m trying so hard not to make this like a huge stack video.

Imagine this is a memory location 80, we’ll say.

You would think that memory location 81 would be the next item of the stack, or I guess

the stack or i guess if you if you’re considering the fact that the items on the stack are quad words

we would say it goes up to 88 but that’s not true it goes down to 72 so the memory location goes down

even though we imagine the stack growing uh upward vertically just so you know that’s the kind of

thing we’re going to do so what i’m going to do is just show you an assembly program where we can

create local variables and i’m just going to show you how to create an array because this array is

just like a bunch of integers and you can imagine it would be really easy to create only one integer

by just imagining an example where the array is a size of one so keep that in mind and i’m not going

to show you malloc or anything like that we’re just going to look at the local variables okay

so for starters i have a make file here that’s just going to compile a hybrid program if you don’t

know make files or you don’t know hybrid programs that’s okay just see my other videos i’ve explained

The first source code file here is just driver.cpp.

Again, this is a hybrid program,

so I’m going to mix my C++ modules with my assembly modules,

which is pretty cool.

The whole point of the driver is just to contain the entry point, you know, main.

And I’m just going to print a hello message.

And then I’m going to call the real function that I’m interested in,

which I’ve named local underscore varrs.

And that’s going to be all the assembly stuff that we talked about.

block so that C++ can call an assembly module that’s explained in other videos. And then

here’s the real heart of what we got to do. Let’s write up an assembly module

that can do local variables. Okay. So again, if you don’t know assembly, that’s okay,

but you need to watch my other videos before you can understand this one. So I’m going to just

copy paste some starter code here. This is Yasm assembly in x86-64. So I’ve got a data section up

So I’ve got a data section up top and I’m just going to define some messages.

So, you know, I’ve got like an intro message that just says, hello, I’m so and so.

And that’s not my name, but I like those kinds of names.

And then over here, I’m going to do some printf formatted strings.

That’s why I’m using a hybrid program for this video.

I don’t want to import my own personal library.

I want you to be able to do this at home with just the GCC libraries.

link a hybrid library you know linking against gcc instead of linking against ld again if you don’t

know that stuff check my other videos then we’re allowed to call c functions in this case we’re

going to call printf and we’re just going to give it the string percent lu meaning i would like you

to print just you know an unsigned long integer so i’m going to give it a value at some point on the

stack representing a local variable and then i want it to print as just like a long like a string

along like a string that a human can read then after that this is the carriage return line feed

the crlf printf won’t flush its output unless that is sitting at the very end of the string so

i’m just going to use printf to also print my new lines and then i’m going to null terminate the

string so that printf doesn’t freak out and try to print a bunch of stuff after the crlf and uh

oh i this was from another video let me get rid of that we don’t really need crlf in this video

CRLF in this video because we’re just putting it directly inside of the printf string we’re not

making our own function to do that so then I’m going to make some defines I’m going to define

that we’re going to have 50 integers so I’m calling this define 50 I’m calling it num integers

and I’m saying that it has a value of 50 so I want to make an array that has 50 integers I don’t

know maybe if you want to imagine 100 you know like the example that I just showed I’m going to

going to define what is the integer size so i’m going to use quad words which are 64 bit integers

so i’m just going to say that there are eight bytes per integer that will help me multiply later

and then i’m going to decide to fill up the array on the stack with just some numbers just to prove

that i can just to prove that we can like uh you know manipulate and and fetch the values

of all this stuff going on in the stack and i’m going to say that the starting value is seven so

with this we should expect to see like an array of numbers that starts with seven and it just

kind of increases somehow then i’m going to do some system call codes we talked about that in

a different video and then some file descriptors i don’t think we actually need anything but standard

output but i put it in there anyway then the next thing we’re going to add is the text section

let me just do copy paste on my solution here so here’s the text section section text

section text in Yasm and I’m going to let my module know that I want to be able to call printf

which is a function sitting in the GCC libraries when I link against a GCC I have the ability to

do that that way I don’t have to come up with like a complicated printing method or use one

of my own shared libraries or something so we can just ask printf to do everything so now here’s the

entry point for the module it’s just a function called local VAERS I mark it as global so it’s

it’s accessible to outside modules ie or eg driver dot cpp and then so here’s the label saying the

function starts and here’s the return statement saying that we’re done with the function i’m not

going to manipulate any registers inside of the function so i don’t really need to do any push pop

to preserve them first thing i’m going to do is call a welcome let me comment this part out by

the way i’m going to call a welcome a function and the whole job of the welcome function is just to

is just to, you know, print a welcome message to the user.

So nothing that I haven’t talked about before in other videos.

So it’s just we’re using a system call to print a string.

Okay, so with that in mind, let me open this up here and see if this is going to work.

I just want to basically print the welcome message at this point.

Clear and make run.

And again, if you don’t know make files or anything like that, see my other videos.

So this is the driver, I think, that prints.

think that Prince maybe I should change the driver’s message to make it more

clear hello about this is the driver and my name is whatever I’m gonna do it again

and now it says hello this is the driver okay so that’s the CPP module and then

here is the assembly module and then finally the driver gets control back and

then the program exits so nothing really happened so now let’s upgrade the

So now let’s upgrade the assembly module a little bit.

Next thing I want to add is the actual demo function, which is going to be absolutely huge.

So first I’m going to start off with, how about just the signature here?

Let’s go right after the welcome module.

And I’m just going to copy paste the signature, put a return at the end of it.

So we’ll consider this a function that can be called.

instruction on line 47 of the entry point and then now we have a demo

function that is being called but it does nothing for starters you know I in

my comments I like to put the signature of the function and I like to remind

myself of how I’m using my registers hopefully I’m not using the same

register in two different ways but you know sometimes it happens if it does and

I’m able to break my function up into multiple parts I’ll probably do it

you know with modular thinking modular programming but in this case I’m just

using these registers it’s fine to use them they are all designated per the ABI

as callee saved so that means the callee which is the demo function is

responsible for preserving them so if you don’t remember that or if you don’t

know about that see my other videos this is not an ABI video so I’m just going to

push all of them to make sure that they’re preserved I’m gonna call this

call this the prolog then at the end of my function i’m going to call this the epilog where

i just restore them in reverse order because that’s the way the stack returns data to you

the stack returns data to you in reverse order so i have to pop in the reverse register order to

un-reverse the reversal if that makes sense pop r13 pop r12 okay so i think 15 14 13 okay

so i got that next thing we’ll do is um let’s remember where the stack pointer started because

started because we have our register here that we’re going to mess with let me just type rsp

real fast so this is the stack pointer register rsp this helps all programs know where where

they’re looking at in the stack all of your functions have to be really really careful about

messing with the stack pointer if you do it wrong you will crash the entire program because not only

will your local function not really know where its local variables end and begin it probably also

It’s return address when you try to return from the function because that is also sitting on the stack

And even if you were lucky enough to be able to jump back correctly to whoever called you

If you messed up the stack pointer then you’ve also messed it up for any caller of you and any of their callers

So the whole program is ruined. So we’ll start off by trying to remember where the stack pointer was

We’ll move

The stack pointer into the base pointer

didn’t do here that I that I want to do we should since we’re messing with the

base pointer and other programs sorry other functions or modules might also

rely on the base pointer and it’s considered callie saved we probably also

want to preserve that too so I’m going to do push RBP to basically say I would

like to restore I would like to preserve the base pointer so I don’t mess it up

for my callers so that means I have to restore it with the pop so RBP the base

The base pointer isn’t necessarily a pointer to the stack, but it’s often used as kind of like a bookmark.

So we have RBP at the front and the back there.

Let’s see.

Next thing I want to add is, so now that we’ve restored it, we’re allowed to just overwrite it because, you know, we’re kind of like keeping its value at the top.

Then we’re restoring its value at the bottom.

And that means we can actually mess it up in the middle if we want to, and it’ll be fine.

let me show you real fast what happens what happens is nothing the program is

still okay because we we restored it so now we’re using the base pointer to

remember where the stack was now we’ve got to sort of calculate how much room

we want to make on the stack let me show you what I’m talking about here

remember all of our local variables are going to be on the stack and before we

drew this thing where it was like well we’ve got like a stack sitting here and

let’s just pretend that there’s some kind of data sitting on the stack data

data data right if the stack pointer dude green green there we go oh I erased my

green RSP if the stack pointer is currently pointing to this frame then

in order for us to make room on the stack to hold our array well if the

whole array is going to be sitting on the stack that just basically means

have five integers suppose five suppose that we want to make five integers on the stack that just

means we need to do five extra slots let me draw it in red here well let’s see can we get a green

no how about a yellow my green is just having a hard time we can do it in red even though this is

not a bad thing to do so i’ll just draw like five extra frames on top of on top of the stack here

imagine these are all 64-bit integers and so they take eight bytes on the stack even though in our

previous example we were using just regular ints which are 32 we’ll just say we’re going to make

five 64-bit integers because that’s easier so they’re quad words so every frame is actually

eight bytes and not just four bytes and it’s definitely not one byte so we make five of those

how do we make five slots it’s pretty easy we we literally just move the stack pointer let’s see

we just move the stack pointer to or the you know the rsp register to just say let’s let’s point you

know further out and how do we get that number we’re just going to multiply the size of one

integer so you know the size of one integer here we know it’s going to be eight bytes we just

multiply that by the number of integers that we want you know that’s going to be 40 so we’ll just

increase uh sorry decrease the stack pointers value by 40 because remember again when the

vertically, it’s actually growing downward in memory. So we’re going to decrease by 40 there,

at least in this drawing example. And that gives us a bunch of junk data, you know, because there

is always going to be some kind of a value sitting at every memory location in your computer.

It’s impossible that there is literally nothing at some memory location,

unless you’re trying to go beyond your RAM stick. But then the system will still acknowledge that,

you know, you’ve done that and it won’t just give you back nothing if you try to read

nothing if you try to read.

So there’s going to be junk data sitting on there and then we’ll loop

through all those slots on the stack and we’ll just modify the data one by one

so that we can control what it is instead of just printing whatever junk data we end

up with.

So really, we’re just moving the stack pointer, just making room and then just

remembering where our array is.

We could put, you know, another frame on top if we wanted to make just like one

integer as a local variable.

You just got to remember where it is.

You know, what is it?

What is its offset?

is it what is its offset okay so i’m going to erase this because we’re going to do a lot more than

than five uh integers on the stack but i just want you to understand what we’re doing before we do it

okay so the next thing i’m going to grab is a move instruction and i’m going to put it right here so

to move the stack pointer rsp so the first thing i’m going to do is i’m going to use a temporary

register we don’t need to preserve this in the push and pop because it’s marked as temp so we’re

not responsible for preserving it and so i’m going to say r10 is just going to be the number of

integers that we want to create if you recall at the top of our program here num integers is just

50 okay so then the next thing that i’m going to grab is well i’m not going to grab it i’m going

it I’m going to straight multiply by integer size so again if you look at integer size that’s going

to be eight because we’re using quad words for our integers so we’re really just going to take

50 times 8 whatever number that is is that 400 tell me in the comments if that’s a right or wrong

and so uh you may or may not know if you don’t see more videos see more textbooks you may or may not

instruction just multiplies two numbers.

If you use the three operand format,

then the last two operands get multiplied

and the results stored in the first operand.

But if we use the two operand format like I’ve done here,

then both of those operands get multiplied

and then the result gets stored in the first operand.

So basically at this point,

R10 should hold the number of memory locations

that we should move the stack pointer

in order to make room for all those integers

like I showed you a second ago.

showed you a second ago. So then we’re going to move the stack pointer.

And maybe I’ll leave a little comment here. Remember, the stack grows downward

in memory. And so all I’m doing is subtracting the stack pointer. Remember the stack pointer

register, it just holds a number, which is a memory location. So if you subtract some numbers

from it, you’re really having it go downward in memory. And that’s what we want to do

memory and that’s what we want to do to you know grow the stack for a local variable so I’m going

to say well I should also say that we’re using the two operand version so just like I’m all if we

had the three operand version then the last two operands would have one subtracted from the other

and the result will be stored in the first one but since I’m using the two operand version

basically it’s taking RSP minus R10 and then storing it in RSP so this this instruction just

this instruction just says let’s move the stack pointer downward in memory

enough times that we have room for all of our integers okay no problem next thing that we’re

going to do is um we’re going to move r12 we’re going to move into r12 the current value of rsp

word in memory right less okay so the first integer you know it’s up to you

how you style this because once we do the subtraction then RSP is actually

going to be pointing towards an integer you could consider that to be the first

integer or the last integer because all we have is an array of integers so you

you know rsp wherever it’s sitting when we’re finished we could say that’s pointing to the

first integer or we could say it’s pointing to the last integer but um if we decide to say that it is

pointing to the let’s see yeah if we’re deciding that it points to the first integer let me just do

a little comment here first integer it just makes it a little bit easier for me to write our loop

You could start by pointing to the one that RSP is pointing to,

or you could start by pointing to the other one that was like the first one that you added onto the stack.

You could call either one of those the first integer, as long as you remember where you started.

So you can increase or decrease the memory location to get to the next integer.

So I’m just going to do it in this style.

But keep in mind, as long as the only thing that you modify and read is within that range, it’s okay.

So let’s remember where is RSP.

So that’s like the top of the stack.

We’re going to say R12 holds the stack pointer so that we can use R12 as sort of a running

pointer.

I think that’s the way I’m going to use it.

Let me just double check my solution.

Yeah.

Okay.

a calculation where we remember where the last integer is so we know where the first integer

we’re just going to call this the first integer i’ll put it in quotes just to remind you that

this is just the style i happen to be using so here we’re going to say that the first integer

is wherever rsp is pointing and then in r13 we’re going to remember where the other side of the

array is in this case we’re calling it the last integer and pretty much it’s just r12 which is

And then we add to it a memory location.

So remember we said before that the stack grows downward in memory.

So if we consider the top of the stack to be the first integer,

then that means previous items, maybe I should draw this,

are going to be increased memory locations.

So that’s kind of like the backwards of what you imagine a stack is doing,

but it’s kind of the way that I like it sometimes.

So imagine just in a very simple stack,

let’s pretend that the stack has one byte values,

one byte of values, which it doesn’t, but let’s pretend if you, if you do it,

I got to learn how to draw. I can’t get that five right. Okay. I’m defeated. So let’s pretend

that that address on the thing sitting at the bottom of the stack is five. So then that means

the next address would be four, right? But if we decided, let’s say that the, well, let’s do like

like a few more just to make it a little bit more interesting.

Let’s do a total of five.

So we’ll say four, three, two, one.

Maybe I should just add some numbers in front of those values.

So it doesn’t feel like we’re hitting zero.

But so just pretend we have a memory location of 15.

That’s not going to be the case in real life.

Pretend that we have one byte integers on the stack, which is not going to be the case.

We’re going to have quad words.

But you can see the memory locations go downward, right?

to the stack pointer is pointing to the topmost location we have to remember that anything up here

might exist in system ram but it’s not considered valid data because we didn’t

you know make it part of the stack by by growing the stack pointer so that means uh these

these items well maybe i’ll do a check instead of an x because x looks bad i’ll do a check

check and a check and a check and a check these items are okay to use so if I have

RSP or in this case we just remembered where RSP was by storing r12 if we have

that memory location 11 and we want to get an additional integer like somewhere

else like the next integer well that would be you know this one down here we

wouldn’t go in the other direction we wouldn’t go you know up we would just go

know up we would just go down in the stack but down visually is actually growing upwards in memory

because remember when we grow upwards visually we’re growing downward in memory so and you can

see here too if we’re if we’re increasing 11 to 12 that means we’re adding memory locations to get

to the next uh integer that we have in the stack so that’s why here my green is just like frustrating

fix this yeah so that’s why here we’re adding a little formula instead of subtracting because

the rsp started there we’re saying that the top of the stack is the first integer

just so we can add in a more convenient nice way so what are we adding to it we’re just adding to it

the number of integers minus one and then so that’s that’s the number of slots that

size. So if you imagine, you know, if we had 10 integers, then, you know, 10 minus one is nine

slots. So if you imagine that zero is the first integer, let’s say the memory location again,

then that means one, two, three, four, five, six, seven, eight, nine, 10 minus one is nine. So if we

added the number of integers minus one from the start, which we’ll consider zero here, that means

directly so that’s just like a little math because sometimes when you when you

think of adding two numbers together or taking the difference or including the

first number or not including the first number it’s a little confusing right so

keep in mind for this particular calculation we are adding to it the

number of integers minus one so that will be sitting on the last integer

rather than going past it so start with the first integers memory location and

the number of integers minus one or size minus one times the integer size,

because remember, every integer is going to be eight bytes.

And that will give us the memory location of the last integer in R13.

And then I’ve said this in other videos,

but basically you’re only allowed to make these sorts of calculations in Yasm

when you have the calculation inside of brackets,

but brackets will automatically dereference the value on the inside.

It’ll consider it as a pointer that needs to be dereferenced,

but we don’t want to dereference anything.

anything we don’t want to go to a memory location and take a value the memory location is the value

so these dereferencing brackets which are required for the formula are kind of bad so that’s why we

use the lea instruction instead of the move instruction if i put move there it would

definitely dereference the memory location and give me a value in r13 so r13 wouldn’t actually

be a pointer it would just be the value of the junk data of the last integer keep that in mind

keep that in mind okay so uh where’s RSP so we got that so now let’s do a loop

I’m gonna start off with a label called demo loop init so for me personally when

I’m looping you know I like to make my labels inside of my loops start with a

prefix that matches the function so it’s like demo and then everything else is

gonna be demo underscore something so uh init loop init I’m gonna make a loop

to make a loop where i initialize the values of the array so i’m calling this loop the init loop

and then the last part is just like this is the initialization part of the loop this is where we

sort of like set up the initial values to loop so we have r12 and 13 that point to the first

and last integers now we’re going to set up r14 and 15 where r14 is the running pointer i think

before i might have accidentally said that r13 is the running pointer it just points to the last

it just points to the last integer but if you look back up at my comments r14 is the running pointer

to the current integer what is a running pointer it’s just a pointer that runs it’s just a pointer

that just keeps increasing so we can look at different data values so i’m going to start it

by looking at the first integer so now r14 is pointing to the first integer and then r15 is

going to be the value that i want to put into that position in the array so like the first integer

integer I want to put some kind of a starting value into it you can put the

number zero or whatever you want I just wanted to have a start value so that it

sort of looks more like I’m putting data and less like I have a loop counter so

remember the integer start value up here is just seven so I’m just going to start

at the number seven and now I’m done initializing my loop then the next thing

I’m going to add is the top of my loop so you can imagine this as the top of a

top of a while loop where you start comparing some sort of an expression maybe i’ll say uh

you know expr to say that we’re comparing some sort of an expression

and if that expression evaluates to true the loop continues if it evaluates to false

then the loop does not continue let’s see so i’m going to compare r14 with r13 inside of the

and 13 remember R14 is the running pointer and R13 is the last integer so basically I’m trying to

figure out am I looking at or like let’s compare the running pointer with the pointer of the last

integer then I’m going to say if the running pointer has a greater memory location than than

the last integer that means I’ve gone beyond the last integer and again the way I arranged the first

last integers just makes it easier for me to think of them as having increasing

memory locations so I’m going to jump if the running pointer has already

surpassed the last integer by saying let’s jump if it’s greater than so you

can imagine maybe in the expression here I should probably say while not

r14 is greater than r13 not a great expression but it’ll do so that’s what

up there at the top let me just put that into my notes too so that my notes match

the video okay so we are comparing and then we’re jumping to the end of the

loop if we end up you know going beyond the last integer so that labels not

created yet I’ll create that in a moment but pretty much that’s a label that’s

just going to be below the loop just to say like we’re finished with the loop

the loop body I like to put comments here to help myself remember oh this is

the part of the while loop that I’m currently inside of just makes things a

little bit easier to understand you know you put a block comment up top of every

label or every you know chunk of instructions just to let you know the

general idea and then you know sometimes you put comments also on the right side

to help you remember what each instruction is actually doing so then

what am I going to do here remember R14 is the running pointer if I D ref R14

ref r14 that means i want to move an actual value into that memory location rather than changing the

memory location that r14 points to so r15 is going to be the uh the integer that we want to

write into the array so all i’m doing here is i’m saying let’s take that value seven which is what

it starts as and just move it in to you know the ram stick at that memory location so i’m setting

seven right now then I’m going to increase our 15 so that means every time

we iterate the loop we should see that the value increases so the first integer

should be seven the second one should be eight next one should be nine and so

forth so just a simple loop where I’m just writing data into my array so now

that we’ve ended the loop body let’s write the bottom of the loop which is

just going to increase the running pointer and jump back up to the top and

And this is not necessarily the only style for translating while loops.

I’m just doing it.

And, you know, I’m going to make another video in the future where we talk about, you know, for loops and while loops and all that stuff.

But this video is just really about local variables on the stack.

So I’m not going to go over all the different ways you can do it.

Anyway, so R14 is the running pointer.

So I’m going to just make the running pointer jump to the next integer.

And we can do that by increasing its memory location by the size of one integer.

Again, this is another benefit of the first and last pointers that I chose at the beginning.

I can just increase to go to the next integer.

So we’re going to increase by 8 bytes to just go to the next integer.

If you increase by 1 byte, you’ll probably have a huge corrupted mess because you’re

messing with 8 byte integers but you’re only increasing by 1 byte.

And then after we increase, we’re just going to jump to the top of the loop.

So notice how I have a jump statement here.

It’s going to go just to loop top.

loop top. So now this part is here is basically just going to execute over and over and over again

until we finally scan through all of the integers in our array. So that’s the bottom of the loop.

And then I’ll make the label for the loop being done. It’s not really going to do anything

except just be done. And do you, you know, I don’t know, depending on your style, maybe you can let

drop through if the loop’s done rather than always jumping to the top but i’m just going to say when

we’re done we jump to the loop done label and therefore there’s no more looping of that

initialization loop okay so we got that done let me just run the program real fast to make sure

that i haven’t screwed it up we actually should not see anything right now oh what did i do

must have done something naughty maybe if i finish

uh this program then everything will be okay oh my gosh what did i even do

well i’ve got a working solution in the other window so hopefully when i paste all the extra

steps everything will be fine you never know subtract the stack pointer oh did i forget to

oh did i forget to restore something at the very end print body move the base pointer into the

RSP stack pointer oh yeah okay that’s definitely what you got that’s why I

crashed okay so um remember I said you got to be very careful about the stack

this is a great lesson so I did preserve the base pointer but I didn’t actually

preserve the stack pointer notice how right here I subtracted from the stack

pointer but I did not restore the stack pointer anywhere so that means I

corrupted the stack for anyone that called me and also for my return address

address. So I’m kind of trying to copy paste my instructions from top to bottom, but I think I’m

just going to copy paste something else to make sure that we can actually run this. So I’m going

to copy paste into the epilog a restoration of the stack pointer. And that’s why we saved the

stack pointer in the base pointer, just to remember where it was when we originally started our

function. So now on line 128, it should be restored and the program should work. Let me just double

yeah it worked okay nothing happened that we can see but it did write values

into the array now let’s do another loop where we just print the array so let’s

see loop in it done looping it bottom and looping it done okay so now there’s

like gonna be another loop here we’re gonna call this the print loop and so

the print loop is gonna be kind of the same pattern we’re just gonna loop

going to loop through all the integers in the array but instead of modifying them we’re just

going to print them so now you know the first thing we’ll do is we’ll set r12 we’ll store that

inside of r14 in order to start the loop at the first integer what was r14 again that was the

running pointer remember let’s see where is that yeah it was the running pointer so now we’re

resetting the r14 running pointer to the very beginning of the array and we know where the

thing we’ll do is we will set up the top of the loop and the body so I’m just

going to copy paste again this stuff right here

right there okay so the top of the loop we’re asking ourselves you know we’re

gonna compare I’m not gonna put all the extra while stuff that I put in the

previous loop because hopefully by now you understand loops a little bit better

and if we’re beyond the last integer because the running point of r14 is beyond the memory

location of r13 that means we’re totally done so we should jump if it’s greater than

now i feel bad let’s uh let’s put a comment in here on the top let’s go uh

basically that you know if uh keep going as long as r14 is not greater than r13 so if it is

in the body and in the body all i’m going to do is use r14 the running pointer to print uh you know

whatever value is sitting in that particular integer so how do we do that i’m just going to

use the printf statement or sorry the printf function which is provided by the c libraries

that’s why we’re doing you know a modular or a hybrid program with multiple modules and c linking

very quickly there is a function called printf which I can call it it takes multiple arguments

but the first two arguments that I can give it are the string that represents the formatting

that I want to print like I could do like a regular string message I could do tokens

to format some data inside of them and then the second argument is going to be the piece of data

that I actually want to use let me see if I can just type that up for you real fast

So, you know, the printf instruction, or sorry, this is not an instruction.

This is a function in C.

We would typically, you know, give it some kind of string.

The string should be null terminated, and it should have a new line at the very end of it

to make sure that printf actually flushes.

It won’t flush if you don’t have a new line, so the program will look really weird.

But I guess it’s more performant if you have a way to delay the flushing,

flushing and you know that you can flush it later at the very end but for now i’m just going to

flush every time and then every argument after that is some sort of you know data that we can

print so imagine we have a long and we’ll call it a and we’ll say that it has like some giant value

so that means we would give that long as the next argument the rsi argument and then for the string

what I’m using right here %lu so you can imagine instead of this string it is this

string right here whoops too many too many quotes it’s just this string right

here and then instead of a 10 13 that’s the same thing as just doing an or if

you want to be you know more of a windows windows person slash r slash n

it’s all good and the zero is not needed because the string if you put a string

literal it’s automatically going to be null terminated which means there’s just

null terminated which means there’s just a zero at the end of the string in memory so this is

basically what I’m doing I’m making a an integer in the case of the assembly program it’s going to

grab an integer from that position in the array that we’re looking at and it’s going to give it

as an argument and then the first argument is going to say let’s just print this as a unsigned

long so that’s why I have that string here let me search for it and go down a little bit again so

I’m saying first argument is this the format that I want to be printed second argument is the actual

is the actual value and then I’m gonna make a call to printf why do I have this

weird push and pop pair sitting around printf so this is not a video about

stack alignment in GCC but basically the GCC libraries expect that your stack is

aligned to I think 16 bytes but since we use 8 byte integers every single time we

address to the stack which is eight bytes and then every time we do one single push or pop

we’re modifying the alignment of the stack by eight bytes so if you think about it when we’re

programming in assembly for the most part the stack is going in and out of alignment because

every time we modify it by eight bytes it it might line up with a 16 byte alignment or it might not

it’s just kind of like oscillating right so when I first wrote this solution I wasn’t doing the

what happened oh actually maybe i guess i don’t need to jump to the top right now i don’t need

to finish the loop let’s see if this prints just one number well let me let me let me see if this

prints one number certainly and if it’s an okay assembly program just to print one number is it

going to work okay we got to do the done symbol okay so i’ll show you in a minute why we need

that for stack alignment but i guess i’ll just finish the loop so demo print loop done so we

just did print loop top and that means we need the bottom and the done so i’m just going to copy paste

into program here i’ll just say nada because we’re not really doing anything and then at the bottom

you know that’s the epilogue that’s separate from the the other label so basically now let me finish

know we already know the loops but I’ll just I’ll just say it at the bottom of

the loop we do the same thing that we did with the initialization loop we just

increase the running pointer you know we move it along to the next integer and

then we jump to the top of the loop that’s it and then the done label we

don’t really do anything we’re just letting execution drop through down to

that point so that the loop doesn’t continue so now we should be able to run

the program don’t get excited oh actually you know what get excited I

was gonna say don’t get excited because it was gonna totally work now but now

because it was going to totally work now,

but now I think we can just say that it’s going to crash.

So if I run it, notice how there’s a segpult.

So the GCC libraries, many functions expect your stack

to be aligned to 16 bytes.

So if you see mysterious crashes

and you are absolutely sure that you’re not ruining

the stack pointer or ruining something else,

you’re doing everything correctly,

but the program still crashes, it might be stack alignment.

So one way to get around stack alignment

is just to move the stack pointer.

move the stack pointer like at the top here we could have said oh we’ve got one two three four

five we’ve got five pushes and then here we’re moving the stack by I don’t know how many other

addresses the stack might be out of alignment somehow so we could add an extra push up here

and then add a corresponding pop down at the bottom like we could easily do this let me just

show you real fast we could push r15 twice for no reason I acknowledge and then at the bottom

and then at the bottom we pop R15 twice,

that would change the alignment because that’s one more 8 byte push.

But in my case, and actually that would be a little bit smarter

because if you have our loop where it’s constantly calling on printf,

this is a lot of hits to memory, right?

This is like 100 hits to memory because every single time we do a push-pop pair

around a call to printf, we’re like touching memory.

Whereas if I did it at the beginning and the end,

Maybe I should just do it this way.

I want to do it both ways so you understand, but it’s more efficient, I think, if we do

it this way.

Anyway, so we’ll do pop twice at the bottom and then push twice at the top.

And so then we don’t really need to surround it with a push-pop pair.

I think I haven’t tested this.

We’ll hope now that the stack is in alignment at all times in our functions so that it doesn’t

crash.

Yeah, so now see how the program works.

So I’m going to do it the other way now, which is the less efficient way, because here

now which is the less efficient way because here we just have one extra push

pop pair but if we do it the other way it’ll still work but we’ll be hitting

memory much more often so I’m just gonna do it this way just to show you you can

surround any call because sometimes in your programs you might have the stack

like you know modified throughout the function many different times so it

wouldn’t make too much sense for you to add an extra push pop pair in the prologue

and epilogue because that might not solve it for all of your calls to all of

to all of your seed library functions.

So in that case,

where you can’t really predict the stack well enough,

you can just surround your call with a push-pop pair.

It hits memory more, but it’ll work.

So this is basically, you can imagine,

by the time we get to line 139,

the stack is out of alignment.

So I just do a push that puts it into alignment.

And then after the call comes back,

I just pop it so it’s back out of alignment again,

but I don’t have extra erroneous data sitting on the stack.

Because if I only had push and not pop,

then it’s going to push it more and more out of alignment.

It’s going to push it in and out and in and out,

but it’s going to add a bunch of junk data to the stack

that I’ll never recover from.

Or actually, I guess I will recover at the very end

when I restore the stack pointer, but it’s pointless.

It’s going to consume too much memory.

What if I was writing like a billion

or like a million items on the stack, right?

a billion iterations of the loop would probably be a bad idea to start adding onto the stack

we’ll probably end up stack overflowing probably with far less than a billion items so anyway i’m

going to surround the call with the push pop pair and then at the bottom we just do the same thing

you know increase the integer and then go to the top and so now we you know you already can see it

it starts off printing well it starts off initializing the array but then the thing that we

can see starts off printing the first integer and then the next iteration of the loop prints the

second integer and the third and the fourth and so forth until we get all the way down just to

prove to you maybe we can increase it by two instead of one each time I’ll just modify that

Oh no, that’s the print loop. Let’s do the init loop.

Init loop bottom.

Oh, right there, when we’re in the body.

So I’m just going to increase R15 twice.

Just to show you, you know, we can kind of control what’s going inside of the local array.

So see how it goes from 7 to 9 to 11 instead of 7, 8, 9.

So I’m going to take that out and then just show you that we can control

how many integers we have in our local array with just the number of integers.

just the number of integers so I’m going to change the 50 to a 5 and run it again and you can see

what the dang did I do number of integers is 5 and then it was 50 did I put the stack out of

alignment no I I have a push put pair there number 50 is not hard-coded anywhere anywhere

there. Oh, I have a bug that I can debug. That’s nice. I guess the bug debugging is not for this

video. I wonder if some other value would work for that. There’s a number of things that could

be the problem. It could be like stack alignment somehow. It could also be, let’s see, am I making

any calls here inside of my function demo? I’m saying sub and LEA and then start and then jump

and start and then jump and increase and jump and then RDI.

Not really doing anything else.

So I don’t think it’s stack alignment.

I must have miscalculated somewhere somehow for changing that.

All right.

Well, if I figured it out, then I will release another video.

But basically, this is the idea.

100 works, 50 works.

What about 99?

Would that work?

Save faults on 99.

faults on 99 and then 98. 98 works so like every two seems to work but that is

two quad words or 16 oh right so like a hundred integers if we assume that

that’s in alignment then 99 would be eight bytes less that we’re moving the

98, notice how it is okay.

And then 97, it’s going to segfault again.

Watch.

This is a great stack alignment video, I guess.

96, it won’t segfault.

So it’s going in and out of alignment.

I think I figured it out.

So if we use the number 100, it’s in alignment.

Sorry, it’s out of alignment.

If we use the number 100, the program works because the number 100 throws it out of alignment.

number 100 throws it out of alignment but then we have this push pop pair here around the call to

printf which puts it back in alignment so if I change the number of integers I’m actually

changing the number of memory locations that I modify the stack pointer so I have to do it by

twos if I wanted to do 99 here then that means the stack is in alignment by the time I call

by the time I’m getting ready to call printf which means the push pop pair around it throws

push pop pair around it throws the stack out of alignment so just watch here I’ll

prove it okay so it’s sake false I comment that out now it won’t throw it

out of alignment okay should have known that before I recorded the video it’s

fun to guess sometimes though you know I get a little nervous oh no my program

broke on camera can I debug it live well I guess I can but kind of slowly

anyway so we I think we’ve gone over every single part that I wanted to show you

we know how to create a local array on the stack and and therefore you also know how to create like

any other data type on the stack if you want you want to create a long a 64-bit integer

just move it by eight bytes instead of moving it by eight times however many integers we were doing

in this video you want to I don’t know put a character on the stack you can do that if you

Just, you know, move it by one memory location instead of eight memory locations.

So, you know, one byte instead of eight bytes.

You want to store a short, you know, a two byte integer?

Well, just move it by two bytes instead of eight bytes, right?

So you can do this as many times as you want.

You want to have several local variables?

Just move it one time for every local variable.

Same thing for accessing.

You just have to remember where everything is.

offset of the of the first variable local variable and then the offset of the second

local variable you can store those in globals or store those in registers if you can you just

got to remember somehow where everything starts but it’s all sitting on the stack if it’s a local

variable okay I guess that’s everything that I really have to say I hope you enjoyed 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 video

have a good one

you

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

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

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: Local Variables, Stack Frames & Alignment Explained appeared first on NeuralLantern.com.

Quick guide to passing mixed int + float arguments in x86-64 assembly (System V ABI). See why rdi can still be the first integer after several doubles, why xmm registers count separately, and how return values switch between rax and xmm0. Perfect for YASM/NASM programmers interfacing with C/C++.

Intro to Mixed Arguments 00:00
Simple Integer-Only Functions 00:46
Adding Arguments and Return Values 01:01
Integer Arguments in RDI and RSI 01:30
Pointers Treated as Integers 02:06
Introducing Floating-Point Returns 02:31
Returning Double in XMM0 03:06
First Float Argument in XMM0 03:36
Float Registers Count Separately 04:03
Integer Register Order Explained 04:16
Separate Counting for Integers and Floats 05:21
RSI as First Integer After Float 05:38
Reference to Ed Jorgensen’s Book 07:00
Callee-Saved Registers Overview 07:56
Complex Mixed Argument Examples 09:48
Inserting Integer Among Floats 10:57
Skipping Float Registers on Integer 11:18
Calling C from Assembly Notes 11:56
Name Mangling Reminder 12:21
Closing Remarks and Thanks 12:30
Call to Subscribe and Support 13:04
Website and QR Code Mention 13:38
Final Thanks and Outro Music 14:19

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey everybody! In this video I’m going to talk to you a little bit about using functions with

mixed arguments in a YASM x86-64 assembly language program. Although this

video will probably still be useful to you if you’re using NASM or MASM because the

mixed arguments and their order and how they work is governed by the ABI which is a system

so what the heck am i talking about okay so the first thing that i want to show you is uh

imagine we have a function here let’s say void f this function doesn’t take any arguments and it

doesn’t return anything congratulations you’re done that was the easiest thing that you’ve ever

done in your entire life but as soon as you start adding arguments to it you have to uh

start understanding how to uh how to call registers and stuff so imagine we have like a

a long a and a long b so we give it two arguments and maybe we want it to return a long

this is kind of like level one of writing functions in assembly right we just have

a bunch of integers and we realize okay um this long the return value is going to come to the

Maybe I’ll do a comment up here, we’ll do rax, we’ll say the long is actually coming

back to the user in rax and the long is coming into the function with rdi, the long a and

the long b is coming into the function with rsi.

So if you understand this then you can write a function in assembly where basically you

two incoming integer arguments and then you return to the caller a long value using rax

keep in mind also that if this second argument was a pointer long pointer then it would be the

same thing rsi because pointers are integers they’re 64-bit unsigned integers even if the

pointer was not to a long even if the pointer was to a double or a character or whatever it would

pointers are integers. It starts getting a little bit more complicated when you want to mix between

floats and numeric arguments. So what I’ve been saying so far, it’s all just integers.

Even if we’re mixing pointers with regular longs, it’s just, you know, they’re all longs basically,

right? So, but as soon as we start introducing floats, then things get a little bit more

complicated. So for starters, what if we did a function that was, that returned a double?

that returned a double. So let’s say we have a function G and it returns a double. Maybe it

still takes in a long and a double pointer. If it returns a double, let’s see, is this still

lining up? I don’t think it’s lining up anymore. There we go. If it’s returning a double, then

that means we have to return to the caller with the XMM0 register. So XMM0 is always designated as

the well the first float argument but also the float return value so keep in

mind if I’m returning a double to the caller I’m not going to use our a X at

all I’m just going to use XMM zero load it up with the return value and then

return to the caller and that’s it if I wanted to do another function let’s say

hmm how about H and then we’ll say I don’t know maybe the first argument is a

argument is a float we call it a double a that means rdi is not going to be the argument that

or the register that we look at to see our incoming double it has to be a float register

xmm0 is the float register that we look at for the first argument the float registers are really

easy you just kind of go in order like xmm0 is the first argument xmm1 is the next argument xmm2

the general purpose uh integer registers they’re a little more complicated you have to remember

their their labels uh you know like the letters have an ordering to it uh suppose for the sake

of argument that we’re going to return a double from this also uh in that case let’s see did i

just mess the formatting up again i think that’s okay um again we’re going to return xmm0

notice how we’re returning xmm0 oh that’s why i spaced it forward notice how we are

forward notice how we are returning xmm0 and we’re also taking xmm0 these float registers tend to be

reused all over the place none of them are designated as callee saved within the abi

so you always have to stash their values somewhere if you’re ever going to make a function call or

anything or a system call the other thing to keep in mind is notice how rsi i still have rsi there

for the second incoming argument you would imagine that rsi is supposed to be the second argument

supposed to be the second argument even if it uh you know comes after a double but that’s not

actually true because the the order i guess like the the ordering of the uh of the registers they

only count against their own class like the float registers the float arguments they only count

against the position of the float and the uh of the float registers and and and the general purpose

they only count against themselves.

What I’m trying to say is that RSI is the second integer argument,

but if you look at the signature, we only have one integer argument, right?

So RSI is not the second integer argument.

It’s actually the first integer argument.

So I’m going to put an RDI there.

You probably can infer that the second float argument should be XMM1 at this point, I hope.

and that’s true if we just say that there’s going to be another double

that this function takes then it’s going to be xmm1

not xmm2 because if you’re just counting the arguments

and you’re sort of grouping the integers with the floats together

you might think well first argument is xmm0 second argument would have been xmm1

third argument would have been xmm2 therefore if I see

a float coming into the third argument position it’ll be xmm2

No, the integers don’t count against the floats and the floats don’t count against the integers.

That’s why RDI is the first argument for integers, even though it’s in the second position,

it’s still the first integer that we see.

And XMM1 is the second float argument that we see.

That’s why it’s XMM1 instead of XMM2, because we’re looking at it in the third position.

So you’re not really looking at, whoops, you’re not looking at overall position.

at position only counting that type of register let me pull open my favorite book to get a little

bit more clarity on this um this book is written by a wonderful professor dr ed jorgensen phd

this book i did not write it ed jorgensen wrote this book it’s called x86 64 assembly language

programming with ubuntu this book can turn you into an expert with yasm assembly so uh

I recommend everybody grab a copy. It’s also free and it’s got a copy left license.

You can see like the license here. But anyway, I wanted to open up this book real fast

just to show you the registers. Okay. I’m going to search for Kali saved so I don’t have to fumble

around the book too long. Kali saved and that brings us to section 12.8.2 register usage.

let’s see callee saved you’ll see rbx is callee saved rbp is callee saved probably shouldn’t

mess with that one too much r12 13 14 15 all callee saved there’s a couple temporary registers

but if you look carefully rdi is designated as the first argument but it should say really

the first integer argument so rdi is the first integer argument that we see that’s why

argument that we see that’s why in all of these examples the first integer argument that we

actually see is rdi so like for function f long a that was the first integer argument

and then in the function g it’s also the first integer argument and then in function h rdi is

the double pointer b because that is the first integer argument that we actually see

so keep that in mind you would just repeat that pattern you know the second integer argument you

second integer argument you see that’s RSI. That’s why RSI is the pointer here because

pointers are integers and the pointer here and we don’t have anything else but if I guess if we

added another you know let’s say a long D then it would be RSI right there. Hopefully that makes

sense and you can you can carry this logic forward for the first argument the second argument the

and then R8 for the fifth argument R9 for the sixth argument and then you can

look for further arguments on the stack if you need more than that but basically

that’s how you count them up and then the float registers are just a lot

easier they always start at zero and they go all the way up to 15 and so I

don’t know maybe I should just copy paste well maybe I’ll start it from

scratch we’ll say dub no let’s let’s mix it up a little bit more we’ll say long

And the long is going to be returned with the RAX.

And I guess I have to space this forward a little bit.

And then if we have a bunch of floats, say double A.

Can I maybe just copy paste this a little bit so I don’t have to do so much typing?

Okay, so we’ll do double A, double B, double C, double D, double E.

and then this is going to be xmm zero why did i put the extra comment there i don’t know

and then we’re going to have xmm one and then we’re going to have xmm two xmm three and so forth

and just to make sure you’re paying attention ask yourself this real fast if i were to insert

z what register would we use for that would it be the one two three four five the fifth argument

would it be uh would it be r8 or would it be something else hopefully you understand now

let’s say we do a character pointer that it would be rdi because that’s the first integer argument

that we actually see all right and then you know to return we would return in rax and then the

return in RAX and then the floats just keep counting notice how it skipped from XMM2 or it

went from XMM2 to XMM3 even though we crossed over an integer argument in between because the

float arguments don’t count against the integers and the ints don’t count against the floats

let’s see I think

well if you want you can look at section 18.2 which just sort of talks about the floating

which just sort of talks about the floating point registers we have 0 through 15 but I don’t think

we really need to do that here I think we pretty much have everything we need to know to to call

on functions with mixed arguments and to have a function within assembly that supports mixed

arguments so again if your C or C++ modules are expecting some kind of signature like this now you

know how to calculate what registers they’re actually going to populate by the time execution

execution jumps into your assembly function.

And if you want to call a C or a C++ function from assembly,

now you know which registers to populate so that the the other function that

you’re calling can receive the right data from you.

Don’t forget about name mangling, which I talked about in another video.

Okay, I think that’s all I really have to say.

This video was pretty short.

Thank you so much for watching.

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

I’ll see you in the next video.

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

for us all.

Thank you.

The post Mixed Function Arguments in x86-64 Assembly – Integers & Floats Explained appeared first on NeuralLantern.com.

In this hands-on x86-64 assembly tutorial, we dive deep into moving integer data between registers and memory, working with pointers, dereferencing, and pointer arithmetic using YASM on Ubuntu.

You’ll see practical examples of:

• Moving immediates and data between general-purpose registers
• Loading different sized integers (byte, word, dword, qword) from memory
• Why data size specifiers matter and what happens with overflow/underflow
• The difference between moving a pointer vs dereferencing it
• Pointer arithmetic to access array elements
• Using LEA for address calculation without dereferencing
• Debugging with GDB to inspect registers step-by-step

Perfect for anyone learning low-level programming, systems programming, or wanting to truly understand how pointers work at the assembly level. No prior expert knowledge required – we build it up with clear examples.

Code and examples are shown live, compiled with YASM, linked with LD, and debugged with GDB.

If you’re into assembly, reverse engineering, operating systems, or just love understanding how computers really work, this one is for you.

Introduction to Integer Data Movement and Pointers 00:00:00
Program Setup and Makefile 00:01:16
Data Section Definitions 00:01:38
System Calls for Output and Exit 00:01:52
Text Section and Entry Point 00:04:21
Printing Hello String 00:05:05
Moving Immediates to Registers 00:06:04
Copying Between Registers 00:06:27
Dereferencing Pointers from Memory 00:07:16
Specifying Data Sizes 00:08:01
Register Size Variants 00:09:45
Reference Book Explanation 00:10:50
Loading Words and Bytes 00:13:25
Debugger Breakpoint and Registers 00:14:28
Overflow Demonstration 00:16:25
Makefile Adjustments for Warnings 00:17:44
Proving Data Size Importance 00:20:32
Underflow and Overflow Examples 00:21:34
Symbols as Pointers 00:24:16
Array Definitions and Access 00:25:20
Pointer to Array Items 00:26:08
LEA Instruction for Addresses 00:27:32
Dereferencing Manipulated Pointers 00:29:01
Final Register Inspection 00:29:50
Conclusion and Subscribe Request 00:33:26

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 about integer data movement and pointers

in an x86-64 YASM assembly program within Ubuntu but this should work for all of you x86 YASM people.

Okay so what am I talking about for starters? I’m just talking about moving data pretty much. If you

from one integer register to another or from one general purpose register to another.

And if you know how to manipulate pointers in assembly and all that stuff,

you probably don’t need this video.

But if you are not an expert, then this will probably help you.

Let me start off by saying, of course, that there are going to be lots of concepts in this video

that I don’t actually explain because I’ve explained them in other videos.

For example, this is not a Hello World tutorial where I show you how to actually,

you know, build a basic Yasm assembly program.

a basic yasm assembly program you can probably infer that just from this video but i’m not going

to explain it also this is not a debugging video so i’m not really going to explain too much about

gdb which is something i’m going to use to look at the registers but it might be nice for you to

get a little preview i will record a full gdb tutorial in another video anyway so let’s see

here uh for starters i’ve just kind of like created a little sample program here um well

a make file which will just compile and execute my program again this is not a

make file video tutorial check my other videos for that I’ve already made one

for now I’m just gonna start making a program and I’m gonna give it a data

section so first thing I’m gonna give it is like well let’s say I’ll give it a

bunch of data then I’ll kind of explain what I gave it again this is not a

basics Yasum tutorial so see my other videos but you know just simply put I’m

You know just simply put I’m gonna write to standard output so I do I remember the system call code for for writing

And then I’m gonna exit because this is a pure assembly program that I’m compiling. There’s this is not a hybrid program

We’re not doing GCC. We’re just doing LD

So I’m just gonna say a call code 60 to exit a file descriptor for stdin actually I don’t really need that

Let me just double check that I don’t need that in my solution

Yeah, I like to reuse these things so we don’t really need standard input

standard input. We’re just going to do standard output, you know, printing to the terminal.

We’re going to exit with a success code of zero. And then I made a couple of, well, just one C

string where I’m just basically saying, hello, my name is so-and-so. So you can know that the

program actually started in case it crashes later. That’s not my name. I just love those kinds of

names. And then I’m just going to make a bunch of integers of different data sizes. So this is kind

sizes but just real fast because these are going to be directly used in our video we uh we have a

quad word here so i’m defining an integer called my long int and i’m saying that it’s a quad word

with dq q for quad word and then i’m just giving a pretty big integer same thing for a regular d

word which is just a double word so that’s half of a quad word and then another thing with a whoops

w not a q let me just fix that in my solution oh dear then i’m going to do a word which is a six two

one one one a word is two bytes of data we’re starting to get dangerously into overflow territory

when i was originally writing this solution i had like a bunch of nines up here and the number that

i ended up seeing on the screen was totally different and i forgot oh a word is just two bytes

so even if it’s unsigned the highest thing that it can actually represent is um

65535. So that’s not good. Then I’m going to just store a byte here with DB and put some twos there.

And then I’m going to make an array of integers. Putting an array, making an array in the regular

data section, that’s not as good as putting it in the BSS section if you want a lot of integers.

But I’m just going to specify a small number of integers so I can just put it directly into the

BSS is for like giant arrays of uninitialized data and the data section is for whatever you can handle typing pretty much of initialized data.

So now I’m going to start my text section and my program’s entry point.

Again, this is not a Yasm basics tutorial. See my other videos.

And so we’re going to start by just saying here’s my entry point where the operating system can sort of jump into my program.

to just you know exit the program let’s actually see if that works so far it

should do nothing but but at least exit with success I’m gonna go clear and make

run and notice how it just kind of like ran it and then nothing happened okay so

that’s great how come it didn’t print though what did I do wrong oh I forgot

to copy paste the code that prints something okay let me get my solution up

here so the first thing we’re really going to do is just use a system call to

call to print the word hello again this is not a system call video see my other videos

and um so now we’re just we’re just going to print our hello string

with a system call let me run it one more time we should see like a quick hello

yeah okay my name is uh chaplain mondover it’s not maybe i should change that to it’s not my name is

not no i don’t want to do that sometimes i like to pretend that my name is chaplain mondover

name is check lane Mondover you should too it’s fun anyway so the first thing that I’m going to

do here is I’m going to move an immediate well let me copy paste a whole chunk of code and then

I’ll explain it one by one I’m basically going to use data movement instructions to move a bunch of

data into a bunch of registers and then I’m going to hit a break point or I’m going to I’m going to

sort of do like a non-operation piece of code so that I can easily break on it in my debugger so

the results. Okay so first off I’m going to move an immediate into R12. The

instruction for moving data into general purpose registers or the integer

registers is just MOV so that’s fine probably you should know that by now but

I’m going to move an immediate into R10 and I’m going to move 12876 into R10.

So that’s how you move an immediate no problem. Then I’m going to first clear

out R11 and then I’m going to move R10 into it. The reason I’m clearing out R11

reason i’m clearing out r11 first is just to prove to you that we are actually moving data from one

register into another because if i just i don’t know if i didn’t do that you might be tempted to

to think well um maybe r11 already had that data in it so first it’s going to be just a zero and

then it’s going to actually be whatever r10 had so we should see r10 and 11 both have one two eight

register or a pointer register from one to another. And by the way, integers, those are

pointers, or rather, should I say, pointers are integers. So if you’re moving an integer or you’re

moving a pointer, the system just kind of sees that as a number either way. So you can use the

move instruction for it. So now let’s use the pointer that was assigned to our long integer

to move that number into R12. So let me just go up real fast. My long int up here,

my long int up here it’s like a gigantic number and remember I said before that my long int is

actually just a pointer to the memory location that begins to hold the quad word so my long

int is really a pointer to one byte and there’s an eight byte allocation because it’s a quad word

so when you sort of put this into your code and you let the system know that you want to move a

then the system will scan eight bytes and interpret that as an integer so

putting the the keyword quad word here I don’t think that’s necessary I usually

do it anyway but you’ll see in the next few instructions that it’s a really

really good idea to specify the data size because if you don’t you’re gonna

actually get something wrong in other words if for some reason I moved I don’t

into R12 I could do it if I if I wrote it correctly but then I would be taking

part of a quad word and trying to interpret that as the entire number and

it’s probably going to be totally wrong we’ll have an example for that in a

moment but anyway so that’s how we move a quad word we just specify keyword right

before the memory location and we use the brackets to dereference if we

didn’t dereference then we would actually be moving a pointer to the long

integer into R12 we’ll do that soon too I’m going to try to do everything in this

to do everything in this video then we’ll move a d word from uh from memory into r13 this is a

little bit different notice how uh here on line 60 i kind of have to specify d word because that’s

the data size that i’m trying to move into the r13 register so this is telling the system that

there’s about four bytes that i need to scan not eight bytes and interpret those four bytes as an

Moving it into R13, you know, I could have sworn a long time ago, you could just move that sort of thing directly into R13.

But when I tried my solution before recording this video, I kept getting assembler errors until I added the D at the end.

And so I just want you to know, oh, you know what, let’s look at a book real fast.

Let’s look at my favorite book.

I just want you to know that there are other forms of every register that can specify the register’s data size.

What do I mean by that?

itself then the system thinks you’re talking about all 64 bits of the 13 register the r13 register

but if you type whoops if you type r13d then the system thinks you’re only talking about the lowest

32 bits of that register so you’re also able to specify the data size of a register again i thought

you should should a long time ago i thought i remembered moving a d word directly into r13 and

it would just clear out the extra bits but i got warnings this time maybe that’s for the best

that’s for the best forcing us to be more precise, but this will solve it. R13 just says,

let’s only talk about a D word. So let me go, let me go to my favorite book here.

Where the heck is my favorite book? Okay. I guess I have to like, there we go.

Okay. There’s my favorite book. So, um, I’m going to go to, uh, let’s, let me just search for,

just search for I can’t remember where it is our 13 D yeah there it is okay so

what we’re looking for is 2.3.1.1 let me show you real fast the top of the book

just to give a shout out to the person who wrote this book I did not write this

book this is a free and open source book that you can download for free

everybody should get a copy to turn yourselves into an expert it’s called

x86 64 assembly language programming with Ubuntu it’s written by a brilliant

professor. This is like a semi recent version. There’s probably a newer one now, but yeah,

it’s a great book. I love it. So I’m going to go back to what the heck was I just doing?

Was it 2.3.1.1? Yeah. Okay. So in this book section 2.3.1.1, the section entitled general

purpose registers, notice how there are a bunch of different versions of each register. So if you

So if you look in this column right here, we have, oh, I get to use my annotator.

We have a, what were we just looking at?

R12.

Notice how R12 here is a designated as a 64 bit register.

But if you wanted to use the R12 register and only use 32 bits of it, the lowest 32

bits, then this is the form you would use for the R12 register.

So 32 bits.

And if you wanted to use only a word’s worth, you know, 16 bits.

Well there you go.

two bytes on these systems or 16 bits and then if you just wanted to use one

byte of the register well you can you just put a B at the end of it it’s

pretty sweet and convenient it’s not too hard to remember that D is for D word and

W is for word and B is for bytes it just gets a little confusing when you’re

using the other registers like the the RAX register it’s got EAX as its 32-bit

version and then AX as its 16-bit version and AL as its 8-bit version if

it’s a 8-bit version if you can remember that there’s an L I guess that’s not too bad but you

know remembering the X and then it changes to an I over here and a P over here I’m personally not

a fan so I always come back to this book to try and remember what I’m supposed to be putting for

these registers because I can’t remember all the time or rather I can almost never remember but we

So, I want to take a D word from memory and load it up into the R13 register.

So I got to specify the R13D.

And, you know, maybe I’ll take that out and show you that it doesn’t compile later, if I can remember.

But I’m going to now take a D word, do the same thing into R13.

Oh, sorry, no.

I’m going to take a regular word and do the same thing basically into R14.

But it’s just going to be a word instead of a D word.

And then I’m going to take a single byte and load it up into R15.

single byte and load it up into R15. Then I’m going to call Nope, which is an instruction that

just does nothing. And it’s useful sometimes if you want to have a place where you can stop your

program and sort of inspect the results of your program in your debugger. So there’s a lot more

to this program. I’m going to go ahead and just run it right now, just to make sure that it compiles.

And then maybe I’ll add a breakpoint here. Let’s go clear and make run. Okay, so it ran,

Okay, so it ran, it compiled, it was fine.

And now I’m going to open up a new little window and I’m going to launch the program.

Notice how the program that has been compiled is called main.

So I’m going to launch the program into the GDB debugger.

This is not a GDB video.

So I’m going to be skimming over this, check future videos for a full GDB tutorial.

So I’m going to do a break point right there at line 72.

So that I can just kind of inspect the state of the register.

break at main.asm line 72 and then just to be sure I did that correctly I’m going to say info

breakpoints or just a b is fine and it’s like looks like I set it up correctly then I can type

run to see what’s up notice how it starts to run and immediately stops at that breakpoint

you can tell it stops there because it’s at line 72 then I’m just going to do info registers or

info r just to print out all my registers and we should see a confirmation of what we were hoping

so if I kind of like maybe I’ll pin this to the top for a second always on top how about that

so first we moved an immediate into r10 so notice how 12876 is in r10 right there and then on line

53 we basically copied r10 into r11 so that means in r11 we see the same value

and then we’ll move a quad word from the long integer we’ll dereference that pointer

at R12 it’s like this gigantic number if I scroll all the way up it’s the same number here as in our

source code so that seemed to work and then we’re going to move the D word next I guess into R13

so that’s this number right here so that seemed to have worked it’s this number right here the

D word and I’m going to get lost so fast scrolling up and down like this now we’re going to move a

one one and there it is right there and then r15 is just gonna take a bite and

it’s gonna take a bite oh now I’m hungry now I’m hungry that activated it it’s

only been like think four or five hours since I ate I guess that is usually when

I need to eat again even though I gorge and fall asleep on the floor because I

home r15 anyway holds the correct value it’s 222 i just want to show you overflow real fast

we look at r14 uh we’re using the word version so it’s only going to read you know uh two bytes

from that memory location and it’s only going to consider uh you know 16 bits as being valid in uh

in that register so if i use a number that’s too big it’ll overflow two bytes the maximum number

three, five or from zero to that number or six, five, five, three, six combinations.

So if I just stick a nine in front of that right now, that should overflow the system.

So let me try it one more time.

I want to do Q because that was the last thing we needed to look at.

And then I’m going to do make.

Oh gosh, what’s happening here?

Okay.

How about I do clear and make build, which is in my make file and GDB main.

So I don’t have to type all this stuff out again every single time.

have to type all this stuff out again every single time what did i just do oh nice okay you know what

i swear it didn’t used to do this before it’s giving me a nice warning saying that value does

not fit in a 16-bit field i guess if i turned warnings off which i don’t want to do then the

program would run and it would overflow eh do you want to turn it off let’s turn off warnings okay

much attention to it. Um, where the heck are the warnings? Where’s the assembler running? There it

is. Yasum flags. And that’s, so that’s my variable up there. There we go. Okay. So I’m just going to

make a copy of this line, comment out the original, and then I’m going to take out, uh, the command

that says, or the flag that says convert warnings into errors. Your compiler is your friend. It was

So I am now going to do a breakpoint at 72.

So break at main.asm972 and then run and then it breaks.

And then I go input registers.

Then if I look at, what was I just talking about?

R14, was that it?

Notice how 44607 for the word, that’s a totally different value, right?

So this is what happens when you overflow or underflow.

You got to be careful about your data sizes.

I’m just going to do this again one more time just to make sure.

one more time just to make sure that it’s fixed now that I moved it and I’m

gonna I’m gonna read that part about warnings because I love converting

warnings to errors as just a way to help myself write better code okay so let’s

do that and you know what I’m gonna do too I added another target here again

this is not a Yasm or sorry this is not this is kind of a Yasm video this is not

extra file called gdb.txt where I can stick gdb commands and so I don’t want

to continue to type my breakpoints over and over over again every single time so

I know for sure I’m not going to change the program anymore at least I’m not

going to shift the lines up and down before 72 so I’m going to do breakpoint

you can type like break or I think you can type either break or the full word

breakpoint but I just type B name of the source code file a.asm at line 72 and so

And so this file right here, again, this is not a GDB tutorial, but in my make file, I have it set up so that GDB will execute whatever commands I put into this text file.

So it just kind of saves me typing.

So let’s put a breakpoint there and then we’ll say info breakpoints and then we’ll just run the program in that way.

I can have a little bit more information.

So I’m going to do make build instead of make build and then running GDB.

I’m going to say make debug.

That’s another target in my make file.

make file so then you can see it added the breakpoint for me and then it

immediately broke on that and you know what yeah I guess I’ll just leave it in

where I have to type info registers okay so we’re just making sure I think that

R14 is still a valid value and that it was fixed okay so we’ve gotten this far

the next thing we need to do is prove that data size matters by specifying a

specifying a bad data size for our long and then for our byte. So I’m going to copy paste a little

proof here that is followed by another non-operation. So I’m going to do this. And so

I’m going to try to prove to you that the data size matters by specifying a bad data size. I

just proved to you that it kind of mattered or it definitely mattered in terms of overflow and

underflow, but I’m trying to prove to you now that it matters when you’re reading. So I’m going to

I’m going to clear out r12 and then I’m going to move a byte from the long integer into r12b

and you know this would be a warning or I think it this wouldn’t compile or wouldn’t assemble if

I didn’t have the b there so I’m basically telling the computer all right I want you to use only a

byte of r12 and I want you to take one byte from memory and just put it in there but I’m taking it

awful. And then right after that, I’m going to do another naughty thing. I’m going to move

something into R15 and I’m going to word, I’m going to move a keyword of memory into R15,

but I’m going to be taking it from the bytes memory. So remember a byte is just one byte.

And so the next seven bytes that come after it definitely have nothing to do with that byte,

but I’m going to interpret them all as a quad word. So we should get nonsense data

also R15. I don’t really need to zero out R15 because the fact that I’m specifying R15 means

I want to use all 64 bits. So it is going to definitely zero it out. And whatever we see in

R15 is going to be the real thing. But in terms of R12B, we’re only going to be loading up one

byte’s worth of that register. So that’s why I’m zeroing out the rest of it just to prove to you

that we are truly getting nonsense. So now there’s going to be another break point at 82.

I’m not going to break anymore at 72. I’m going to break at 82. So let’s do that.

What’s going on here? We got that.

Oh gosh. Okay. Quit. I guess that means I need to comment this out. Let me do that.

We’ll do break at main.asm at 82. And you could, you could do both of these two. Actually,

let me do it first. We could, we could do multiple break points. Yeah, I’ll just do it first,

So notice how it first breaks at the 72 and then I do C to continue and then suddenly

it breaks at the 82.

But I don’t want to have to hit continue a bunch of times so I’m going to comment that

out for the future.

Let me quit real fast to make sure I remember what GDB expects as a comment.

Yeah, okay.

82.

Okay, so then I’m going to print the registers info registers.

And we’re looking at R12 and R15.

You can see R12 has the number 144, which definitely doesn’t make sense because there’s

no 144 anywhere in our original data.

in our original data so hopefully that’s proof to you that we’ve grabbed some junk

sometimes maybe when you’re doing this at home if you’re just going to grab one bite

maybe accidentally um no no that would definitely still look bad but for the r15

if you’re going to grab a q words worth of data i don’t know maybe the junk data is like

accidentally correct in a way where it would it would still make it look like the intended value

the intended value no it wouldn’t there’s no way that would even happen no i guess the junk data

could could work that way anyway so we’ll look at r15 two eight and a bunch of fours and then a two

three eight um that value does not exist up here so again junk data mixed in with real data is is

bad news okay so now let’s do another proof i want to prove to you that symbols are pointers

you know like I’ve been saying and they need to be dereferenced so let’s first start off by

moving the raw pointer for my long int into r10 and then into r11 we will dereference that

pointer so in r10 we should see something that looks like a memory location or at least a relative

memory location and then in r11 we should see the actual long integer like we saw before

And then I’m going to mess around with some arrays.

So remember up here we made an array.

Let me minimize that real fast.

We made an array, a very small array.

I just specified a bunch of ones and then specified a bunch of twos.

So it should be contiguous memory since it’s been allocated as an array with that comma

there.

We should see if we looked inside of the system inside of memory, we should see eight bytes

representing the ones.

And then right next to that, we should see eight bytes representing the twos.

easy for us to sort of move our pointer around a little bit. So what else do I need to copy paste

here? We got that long int. Okay. So I’m going to grab the first item and the second item in those

arrays just using some pointer manipulation. So you know how to do this already. You just take

like the pointer to some number and you just dereference it and you end up getting a number.

I understand your feeling because you might be thinking, wait a minute, wait a minute.

I understood it when it was dereferencing just one number, but didn’t you say this is an array?

Why is it we can dereference the array and just get one number still?

Well, remember, a pointer to an array is really a pointer to the first item in the array.

That’s kind of how it works.

So either way, whether you consider that to be a pointer to one number or a pointer to array,

when we dereference it, we’ll get one number.

If you want to get the other numbers, then you have to start manipulating the pointer

or derefing in different ways.

So here’s how we can get the second item.

We deref the original pointer plus 8.

8 because it’s a quad word.

So, you know, it probably would be a little smarter to put that 8 up into a define somewhere

so you’re not hard coding numbers, but I’m not going to do it.

So basically in R12, we should see the 1s.

In R13, we should see the 2s.

And then a couple more things.

Next, we will grab a pointer to the first item in the small array.

And we’ll just stick that into R14.

So, you know, we kind of did that with R10 already.

But now I just want a pointer to the small array.

And I’m going to keep it in R14 just so you can see the memory location.

And then after that, we’re going to grab an actual pointer to the second item.

hey how do you get a pointer to the second item well it’s that but then what

if you didn’t want to dereference the pointer like what if R13 you know here

clearly because we have these brackets for dereferencing you’re allowed to put

the formulas inside of the brackets what if I wanted to get the address to the

second item and not actually the second item we would not be allowed to remove

the brackets the assembler wouldn’t like that so without another instruction

way to actually get a pointer with a complicated mathematical formula. You know, you can do like

multiplication inside of here and other things in parentheses. So we wouldn’t be able to do that

without the other instruction that I’m introducing now called LEA. LEA just means, yeah, sure, we’re

still going to use the brackets to figure out where the pointer is, like figure out what memory

location we want with some sort of a formula. But then what will be stored in the first operand is

This LEA won’t dereference just because there are brackets.

LEA will keep the pointer.

And then finally, once we actually have a pointer to the second item in R15,

then we can move the second item into another register.

And this is like an LOL because I ran out of registers already.

So I’m just going to use RDI, which is usually the first argument.

It doesn’t matter. It’s fine.

So if we dereference R15, it’s the same thing as dereferencing this.

We could have also just dereferenced R14,

and it would have been the same thing as just getting the value of the first item.

But I hope you can see now that, you know,

that expression is going to be a pointer to the second item in the array,

and that’s going to be stuck into R15.

So if we dereference that, we can treat R15 like a pointer.

It’s just, you know, it’s a general purpose register.

it doesn’t only need to hold integer values it can also hold pointers because pointers are integers

they’re just unsigned so we deref the pointer that is stored inside of r15 now put it inside

of rdi and then we should see that rdi actually holds the second item which should be a bunch of

twos so the last thing that i’m going to copy paste in here is another nope so i’m going to

break at 108 just so we can see the rest of it so i’m going to open up this right here and i’m

open up this right here and I’m going to comment that out and I’m gonna say break at 108.

Whoops.

Okay.

There we go.

But, but, but quitsies.

Now I’m just going to run make debug again so that I can enter GDB.

And we’ve, we’ve, we’ve hit our break points.

And now I’m going to go info registers and just talk about the stuff that we’re seeing.

Okay.

So the first thing I think this is all on one page, right?

I don’t need to scroll.

Yeah.

one page right I don’t need to scroll yeah okay this is all on one page first thing we see is r10

holds this value right here that’s a pointer to the my long int that kind of looks like a pointer

if you consider that it could be relative and then r11 holds the actual integer and if you recall

that is the gigantic long that we put in there great so now that’s the difference between a

pointer and its value or in its dereference value so then we’re going to grab the first item in the

So then we’re going to grab the first item in the small array.

So R12 should have the ones.

If we look at R12 here, it’s got the ones.

Again, just trying to prove to you that if you dereference a pointer to an array,

you’re actually dereferencing a pointer to the first item.

And then on R13, we’re going to make a pointer to the second item.

Then with the brackets and the move instruction, we dereference that and it should become the twos.

So if we look at R13, notice how it’s the twos.

Then we’re going to grab a pointer to the first item in the small array.

Hang on a second.

What did I want to say about that?

In the small array to R14.

Okay.

So again, we’re just going to grab an actual pointer to the small array.

And so the difference between R12 and R14 is the dereft value or the pointer.

So if we look at R12, that’s the actual value that we’re pointing at.

And then R14 is the memory location that we have in there.

And then notice how it’s kind of similar.

Notice how it’s kind of similar.

Maybe this proves a little bit more that these are pointers that we’re looking at.

R10 was supposed to be a pointer and now R14 is also a pointer.

Notice how those numbers are pretty close together.

I’m sure if we looked back up in the data section and we calculated an offset based

on how big each data item was, we could probably predict what the memory location of R14 should

have been based on R10 because you can see it’s like only increased by a little bit,

by a little bit right it was like 534 to 49 what is that 10 plus 5 so that’s like 15 is that correct

oh I guess I had a byte in there so maybe it’s that’s why it’s kind of odd but yeah we can we

can just compute the offset and then we’ll grab a pointer to the second item using the LEA

instruction remember we have to use brackets if we’re going to do an expression but then the

dereferencing in the move instruction so we just use LEA to not dereference.

So we should see that R15 is about 8 bytes further along in RAM than R14 because both of those items

are contiguous in memory and they should only be about you know a quad word apart 8 bytes.

So if we look at R14 it’s got this number so it’s a pointer and then if we look at R15

you know what’s 49 plus 8 it’s 57 so you can see that the pointer to the second item is only

pointer to the second item is only eight bytes further in memory yay contiguousness and then

sorry i can’t resist so then finally we will uh we’ll look at the dereference to r15 because it’s

now a pointer what was it it was the it was a pointer to the second item that should be a bunch

of twos right because remember in our array we had a bunch of twos here as our second item

have a bunch of twos inside of it so if i look at rdi where the heck is that right there has a

bunch of twos inside of it rdi baby oh my gosh why did i say that anyway so that’s our non-operation

instruction and i think that’s everything that i wanted to talk to you about in this video so now

i hope you feel like you’re an expert in moving integers and moving pointers and

dereferencing pointers and manipulating pointers so you can get a pointer to something else and

pointer to something else and de-referencing those pointers or not whenever you choose.

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. Limit out. I’ll never say that

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

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

you know sometimes I’m sleeping in the middle of the night and I just wake up

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

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 those in the middle of the night I get 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 x86-64 Assembly: Integer Data Movement, Pointers, and Dereferencing Explained (YASM on Ubuntu) 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.

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.

Ready to master x86-64 assembly? This video breaks down system services, showing you how to use syscalls to print messages, handle file descriptors, and exit programs cleanly. We’ll walk through a real assembly program, explain key concepts like standard output and file handles, and share tips from a top book on the subject. Whether you’re new to assembly or sharpening your skills, this tutorial is packed with clear examples and practical advice. Subscribe for more coding deep dives, and check out our upcoming file I/O video! #AssemblyProgramming #SystemCalls #x86_64 #CodingTutorials

Introduction to System Services 00:00:00
System Services in x86-64 Assembly 00:00:04
Recommended Book on Assembly 00:00:35
What is a System Service? 00:01:01
Example Assembly Program 00:01:21
Syscall Instruction Explanation 00:02:52
Standard Output and File Descriptors 00:04:01
Printing a String with Syscall 00:05:16
Exiting a Program with Syscall 00:07:21
Exit Codes and Program Success 00:08:02
Book Reference for System Services 00:09:51
Detailed System Write Service 00:11:01
Checking System Call Return Values 00:12:08
File Operations with System Calls 00:14:35
Closing Files and Best Practices 00:15:50
Other System Call Codes 00:16:43
File Permissions and Modes 00:17:20
Handling System Call Results 00:19:03
Future Video Plans and Wrap-Up 00:20:40
Call to Subscribe and Outro 00:21:28

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey everybody in this video we’re going to talk a little bit about system services

in an x86-64 machine while programming in assembly

this video is going to focus on yasm assembly but this should also work for any other assembly

language that you program as long as you have the right kind of cpu x86-64 is also known as

that in mind okay so for starters let’s see here’s a wonderful book i love pushing this book i did

not write it the person who wrote it is a genius it’s called x86 64 assembly language programming

with the boot to it’s a free and open source book so anybody can go get it find his website

and here’s the version i’m using and honestly a really old version of this book is still really

good he just keeps you know making little improvements but it was it was good even a

even a long time ago. Anyway, so what is a system service? For starters, before I go into this book

a little bit more, what is the system service? Suppose for the sake of argument that I’ve

already written an assembly program, a pure assembly program, not a hybrid module program

or anything. If you want to learn assembly, see my other videos, but for now I’m just going to

assume you kind of already know how, so I’m just going to open up a pre-made program here.

I’m going to do nano so I can edit the assembly file just so you can see what’s inside of here.

just so you can see what’s inside of here.

Okay, so I hope the red is not too hard to see.

Oh, the tabs got ruined on Nano.

Hang on, let me see if I can just open this up in Genie.

Should have done that to begin with, okay.

Yeah, okay, I wrote it in Genie

and I guess I don’t have the tabs set up in Nano very well.

Okay, so here’s like my assembly program.

You know, I just have a little string here

string length and CRLF for like a line feed and some file descriptors and stuff

that I talk about in other videos here’s the entry point of the program just like

a little start entry point because it’s pure assembly and all I’m gonna do is

I’m gonna print a message right I’m just gonna print a little hello message and

then call on CRLF all CRLF does is just it just prints a new line so the program

if i run it right now you’ll just see what happens if i say let’s see clear and make run

then you can see there’s some stuff happening up here in the make file which i forgot to update

the title ignore that basically the real action is this line right here hello i’m printing using

a system service if you already know assembly then you have probably already seen this before

and it seems a little boring that’s good but i just want you to know that we’re using a system

system service to actually do the printing.

Kind of take it for granted here.

This little instruction called syscall.

What is a syscall?

Well, it’s just basically you set up some variables, some,

some codes, some data, whatever in, in some special registers.

One of the registers lets the system know what you want it to do.

One of the registers is like, or I guess all the following registers

if they’re needed, are just input to the system call that you’re trying to do.

do so in this case rax is letting the system know i want you to do this this code i want you to do

this certain thing i have a defined set up here called system right but if you look up in my

little defines area it’s just a number one so that means if i set the number one in rax i’m letting

the system know that i want it to write to some pipe to some file then you know depending on what

code you’re using rdi rsi rdx and other things may be needed or maybe not be needed at all

in this case when i’m writing somewhere it wants three arguments so i have to use rdi rsi and rdx

because those are the three arguments the first argument that it wants is where to print

see my other videos for a more in-depth explanation of file descriptors and pipes but just long story

pipes standard input standard output and standard error standard out is a pipe

number one let’s see where’s that yeah it’s just assigned a number one so

every program has its own number one pipe which is just standard output and I

guess I should say that it gets piped to file descriptor one it’s kind of like an

ambiguous term sort of but the system right call will write data to a file

file and if i give it a file handle of just one that lets the system know oh actually i want to

write to this standard output for the one particular process that we’re inside of but

you could open any file that you want and get like a file handle to it and the operating system will

realize oh you know i i associate that file handle i gave you with this certain open file that you

created or opened for reading or whatever um and so when you give the handle back it knows where

knows where to write. So in this case,

it’s treating the standard output just like a file,

just a file with a special handle of just one.

I’ll talk about that more in another video.

Then the next two arguments it wants is just the,

a pointer to the first character of the message that you want to print.

And then just an integer representing the length of the message that you want

to print. And if we just look up here again at my little hello,

my hello symbol points to an array of bytes, just characters.

bytes just characters there is no null terminator on there it’s just bytes only

and so when I give it you know message hello by itself what I’m really giving

it is a pointer to that H letter just a pointer to the memory look you know I’m

pointing to the memory location of the very first character in that string and

then for the length I’m just using a special token little shortcut thing

where you just put a dollar sign minus and then the name of another string and

and then the name of another string,

and then the assembler will compute the length of that string.

So this right here is the same thing as me

just typing the exact length of the string.

I don’t even know what it is.

I don’t feel like counting it.

You can at home if you want.

One, two, three, four, I’m not gonna do it.

Anyway, so we basically just say,

you know, I would like to write somewhere.

I would like to write to the standard output file,

file handle, I would like to, you know, to that pipe.

I would like to write, you know, this string,

you know this string and then i would like to tell you that this is how long that string is

and then after you set all that stuff up you just say system call and the system will go ahead and

do all of the hard work for you it’ll go figure out how to actually write data to the file and

you know figure out how to do everything that it’s supposed to do and all you have to do is

a little system call here right after this you can see that i have a call crlf that’s just a function

call i talked about functions in other videos but basically you know i’m just calling a function here

you know i’m just calling a function here and it does the same thing it makes a system call but

instead of printing the hello string it’s printing my crlf string and if you just kind of look at what

my crlf is it’s just these two characters 13 and 10 so like you know slash r slash n for carriage

return line feed that’s why i call it crlf so all this program does just print a message and then a

new line and then at the very end it does another system call to properly exit the program if this

hybrid program and I had like the entry point of main, you know, that the GCC libraries give you,

then I would probably just want to return at the end of this function. But since this is pure

assembly, I can actually just exit the program and be fine. So exit with success is a different

system call code. Notice how I have the symbol system exit loaded into RAX. And if you look up

here, system exit is just the code 60. So if I send a code of one into RAX, that means I want to write

a code of 60 somewhere that means i want to exit the program the only argument that takes is rdi

which is just what is the exit code that you want to return to the operating system so um

if you recall from some of my other videos let’s see if we do echo hello echo always succeeds at

least as far as i know there’s like it’s like really hard to make it fail if i echo hello then

the program echo launches and it will succeed by just printing the word hello like see how it just

like see how it just does that so that means after that command i could echo the special

variable dollar sign question mark just to see what the echo command exited with right it should

be a zero because it succeeded so you can see now a zero under the hello on the other hand

if i concatenate um let’s say a file that exists i should also get you know an error code that is a

So it’s a zero at the very end.

But if I try to concatenate a file that doesn’t actually exist,

I’ll put a OS release two because that doesn’t exist.

Notice how the cat command fails because it couldn’t find the file and the exit

code is a one.

So all you’re doing when setting RDI here is just controlling what exit code you

want your program to exit with.

This isn’t very convenient for a human running a program.

Maybe if you want to look at the exit code for some reason, but this is really,

really convenient for programs that want to automate other programs.

programs just keep in mind if you have a program that is executing another

program and it wants to see if that program succeeded the exit code is one

of the easiest ways to find out if the program succeeded so this is the whole

idea of this entire program we’re just using two system calls to print

something and then to exit the program hopefully this makes sense and now I

want to go show you this wonderful wonderful book if I didn’t already say

If I didn’t already say this before, sorry if I already did.

This book is written by a genius.

It’s called this.

Here’s the guy who wrote the book.

And here’s the version that I’m using, but old versions are good.

You can get this book for free on his website if you go find it.

So I’m just going to go to this assembly book, which deals with a lot of Yasm assembly tips

and tricks and tutorials and explanations and things.

And I’m going to go to the section labeled after system services.

So for me, this is a chapter 13 system services, just to give you a little explanation of what

this is.

You know, this is basically what I said.

It gives you, you know, a chance for your application to ask the operating system to

do something for you that you don’t want to program from scratch in assembly or that you

can’t program.

But here’s the real juicy details here.

If we go to, yeah, yeah.

Okay.

C, which is section 23.0 system services.

There’s a whole bunch of system services in here that you can, uh, that you can read about.

So for starters, if we go down a little bit, notice how it says basic system services.

If we go down a little bit, you can see right here, the system write service that we’ve

been using in the sample assembly program.

You know, when we’re just printing, we say code one is to write something.

And so this is what the table says.

you place inside of RAX before syscall.

Call code 1 is going to be to write characters and then it tells you what arguments it needs.

So like RDI is the file descriptor where do you want to write to.

Just like I said before you could give it a file handle that you already received from

opening a file or creating a file.

Or you could give it 0 or 1 or 2 if you want to try to write to one of the pipes although

actually file descriptor 0 is standard input I don’t think that would actually work.

zero to reading if you wanted to read the user’s input or or you know any input that that program

was given through its standard input rsi is just the address of the characters to write like we

talked about before and then rdx is the count of the characters to write notice how there are no

more arguments and that’s why i only gave it three arguments besides rex notice how it says here if

unsuccessful it returns a negative value if successful it returns the count of characters

count of characters actually written this is a really really good idea if you think about it

um a lot of new programmers they don’t really look at return codes when they call system services

or built-in c functions or built-in c++ functions they just kind of call it and hope for the best

but imagine if you uh if you try to write a huge long string in uh using system write call code one

and maybe some of the characters did write but the system decided to only write i don’t know half for

reason maybe it ran out of buffer maybe you know it interrupted you know your right or something

like that so it could happen what that would mean is that the return value it would be greater than

zero indicating that some characters were written but it’ll tell you exactly how many characters

were written so you’ll know that you got to keep calling the sys call until all the characters were

successfully written why would you do this i don’t know maybe you have a gigantic string like maybe

like a several gigabyte file and you wanted to copy it to another file so you’ll be calling

system write over and over again and system write it’s only going to write so many bytes at the same

time so you use the return value to figure out how far forward in the read buffer you need to advance

or you know whatever so that you can well write the entire complete file or the entire complete

string or whatever it is without any gaps without it being truncated and so forth and then of course

And then of course, if it returns a negative value, then it totally failed.

Like you tried to write to a bad file handle, like standard input or a file handle that

was closed or a file handle that was open for reading only, something like that.

And then you can use some if else, you know, branching logic.

I mean, not if else in assembly, it’s just going to be comparison and conditional jumping

or branching.

But you can have more control over your program, right?

Because you want your program to be able to respond to errors.

Let me just quickly cruise through all of the other options and let you know that

and let you know that in another video I’m gonna do a full tutorial for how to

copy one file to another by opening one file for reading and then like using

system calls to read from it and then open another file for writing and then

you know use system calls to write to it and I’m gonna do that looping buffer

stuff that I talked about before anyway so but for now I’m just gonna go through

the rest of these system call codes let’s see so first off we got open well

Well, if you want to open a file, then you just give it call code 2 and you pass in the

address here, you know, RDI, you say, here’s the address of a null terminated file name.

So that means somewhere in memory, you have to have the file name that you want to open

with a null terminator, like a zero at the end of the string, either the full path or

relative path to wherever the program is currently running.

And then RSI is going to be file status flags.

And what does that mean?

And what does that mean? We can actually just search for that.

I’m going to say control C to copy,

and then I’m going to do control F to search for that.

And let’s see what page of mine right now, 340.

If I go down to the search results for that,

it just explains what the file modes are. So if you put value zero,

that means read only you’re opening the file and read only mode value one.

That means a write only a value to allows reading and writing to the file.

So if you don’t know what that means, well, there it was.

What was I just on before?

40?

Oh, gosh.

Completely lost my…

Oh, yeah, 40.

Okay, so opening pretty easy, right?

Like if you didn’t know this before, you didn’t necessarily read me.

You could just look at this table and go, what do I want to do?

I want to open.

So here’s the code.

Here’s the address that it needs.

When you’re done opening a file, when you’re done working with a file,

you want to close that file unless the whole program is going to terminate.

unless the whole program is going to terminate at that point you i mean maybe you have a function

that gets called somewhat often and you kind of always have to open a file and sort of look at

something or write something and maybe you want to close it when the function is over right you

don’t want to have a file handle just open forever that’s a waste of memory and it might introduce

bad behavior to your program if you just have a bunch of file handles floating around that you

forgot about so it’s proper to close a file when you’re finished with it that’s just going to be

and it only wants one argument.

It just wants the file descriptor of the file that you wanted to close.

So if you open a file for a reading or to create it,

you get a file descriptor back.

You should probably hang on to it somewhere on the stack

or like in a global variable or like, you know, in a register or whatever.

Then when you’re done doing something to that file

and you’re sure that it’s time to close it,

just give that handle right back when you call code three to close it.

Then you can sort of like seek, you know,

forward and backwards to the file if you want to.

You can fork the current process.

You can fork the current process that’s kind of advanced for this video.

You can exit.

Remember before we exited from that program with code 60.

So that’s it. Call code 60.

If you didn’t watch this video, you could have gone through this table and just said,

Oh, you know, I want to terminate the executing process.

I do a system call with code 60 and I’ll give the exit status to RDI,

which is typically zero for success.

Bunch of other stuffs create, get the time of day,

and then the file modes that we talked about before.

we talked about before and then file permissions. Let’s see, where’s the permission. I think it’s

when you want to create a file. Yeah, right here. If we wanted to create a file, that’s code 85.

RDI is the name of the file, you know, like a pointer to the string. RSI is the file mode flags.

And then you’re thinking like, what are the file mode flags? Just go down here and then here you

go. All the file modes that you could ever want. You just look at it and go, well, I guess I can

I guess I can just copy paste this number right here and it’ll end up being, you know,

whatever is described on the left and the right.

Like the group has read, write and execute permissions and so forth.

I mean, really, if you look at this long enough, you’ll kind of realize that this is a quad

word because it has a Q on the end of it.

And the rest is just an octal file permissions notation where this first number here, notice

how the first two are zeros, but this first actual number here is something that applies

to the user and then the next one applies to the group the next one applies to others who are not

part of the user or group and this video is not about file permissions I’ll probably make one

later if I think people will actually watch it but yeah you can just kind of like look it up here if

you want to and just copy paste that into a define somewhere let’s see what else I just want to show

you a little code snip just to illustrate a little bit more what I was talking about before

for. People usually make this mistake, they’ll do see this is what people will usually do like new

programmers. Suppose this is a function pretend we’re in C or C++. For the time being, you call

some sort of a system function or an API of some other library. And you just you just hope that it

works, you just call it and then your program continues underneath, right? It’s a bad idea,

because maybe that failed, maybe there’s some action you need to take. So instead, it’s a really

really good idea to check the return result or i should say an even better idea is check the

documentation usually these types of you know c system calls or function calls or api calls or

whatever they’ll return something indicating success or failure sometimes the documentation

will tell you oh you’ve got to put like a pointer to some other data structure in the arguments

and then the result comes there of course just read the documentation but usually it’s just

So you want to grab the result and then check the result.

In this case I’m assuming this is sort of a standard function that will return zero

or greater on success like the system write call or the system read call and return less

than zero if it fails.

So here I’m just responding, you know, if it’s like if the result was greater than zero

then it’s like, yay we can proceed.

Maybe I’ll continue with my program in some way and if it’s not then I’ll print a complaint

then I’ll print a complaint to the user and then I’ll take some sort of an action

like I’ll write to a log file, send an email somewhere, you know,

do something to try and recover from the error and alert admins to the error.

And in this case, I’m just throwing an exception.

This video is not about exceptions, but so I just want you to know,

this is a good design pattern to not just discard the result of a call to

something. You should check the result and see what you’re supposed to do.

Let’s see, what else did I want to tip?

system services, file handles.

Yeah, okay, I think that’s everything that I wanted to tell you.

In future videos, I’m going to talk about, you know, some of this stuff much more in-depth,

like with my file.io video that I’m going to publish pretty soon, which is, you know,

it lets you read and write to files, and it uses a loop to read a little bit at a time.

Okay, thank you so much for watching this video.

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

I’m outie.

Or something.

Goodbye.

you’re looking at right now it would really mean the world to me and it’ll

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

videos longer videos better videos or just I’ll be able to keep making videos

in general so please do do me a kindness and and subscribe you know sometimes

I’m sleeping in the middle of the night and I just wake up because I know

somebody subscribed or followed it just wakes me up and I get filled with joy

that’s exactly what happens every single time so you could do it as a nice favor

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

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

also if you look at the middle of the screen right now you should see a QR

code which you can scan in order to go to the website which I think is also

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

website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and if

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

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

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

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

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

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

Thank you.

The post Mastering System Services in x86-64 Assembly Programming appeared first on NeuralLantern.com.

Get a clear, beginner-friendly dive into how your CPU works! This video explains the fetch-decode-execute cycle, the role of the clock, instruction pointer (RIP), and units like the ALU and cache. Learn why timing matters and how your CPU handles instructions step-by-step. Perfect for gamers, coders, or anyone curious about what makes computers tick. Inspired by Kip Irvine’s Assembly Language for x86 Processors, this is your gateway to understanding computer architecture. Subscribe for more tech insights and hit that QR code to explore more tutorials! #CPU #ComputerScience #TechTutorials

Introduction to CPU Operations 00:00:00
CPU Clock Explanation 00:00:17
Clock Cycle and Stability 00:01:07
Instruction Fetch from RAM 00:03:24
Instruction Pointer (RIP) Role 00:03:48
Sequential and Conditional Execution 00:04:49
Code Cache Functionality 00:06:24
Instruction Decoding Process 00:07:51
Control Unit Operations 00:08:33
Arithmetic Logic Unit (ALU) 00:08:52
Floating Point Unit 00:11:03
Data Cache Usage 00:12:08
Summary of CPU Process 00:14:36
Closing and Subscription Call 00:15:07

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

CPU #ComputerScience #TechTutorials #ComputerArchitecture #AssemblyLanguage #TechExplained #CPUBasics #LearnTech #x86Processors #Coding

Hello there. Let’s talk about how your CPU fetches, decodes and executes instructions.

We’re going to just do a quick surface level overview, but I hope you like it.

Okay. So for starters, your CPU has something called the clock.

keep my pen onto one monitor here let me just double check that real fast

okay is it working yeah okay so

okay so notice how we have this line that goes up and down and up and down it kind of looks like a

little binary line uh it actually is uh sometimes your cpu is outputting a zero to this special

and it just oscillates between zero and one constantly it goes zero one zero one zero one

it does so very very very very fast and the reason it does that is because something needs to control

the timing of your cpu imagine this we kind of take this for granted but when you apply electricity

somewhere as a human you kind of feel like the electricity goes to the other place like on the

other side of your house or your room or whatever you kind of feel like it goes there instantaneously

really fast but in reality electricity doesn’t go faster than the speed of light so there is a limit

which means if you have a cpu that is executing instructions really really really really fast

you know fetching instructions from your system ram really really fast

there’s there’s there’s the problem of trying to um to know for sure that the electricity actually

made it uh to the other place in time uh so like what if we said let’s load some instructions from

load some instructions from memory, they come down the wire to your CPU.

How do we know when it actually finished coming down the wire to the CPU?

We just take it for granted.

But in reality, physics has a limit.

And so the electricity needs time to get there and it needs time to stabilize.

So the clock cycle helps us with that timing.

So, you know, if we make the clock go too fast, your CPU becomes unstable.

Your gamers, you gamers probably know that.

If we make it too slow, then it’ll work.

it’ll work, but, um, you know, we’re not getting the fastest, you know, CPU, uh, that, that

we, that we can, we’re not getting all the performance out of it that we can.

So we make it, we make the clock cycle go as fast as we can, uh, without making the

CPU, uh, instable.

And so just keep that in mind.

That’s one component of the CPU.

Okay.

So then the next thing I wanted to show you, oh, and by the way, let me give credit to

the authors of this book.

I’m just looking at a diagram, but, um, this book is written by someone named Kip

This book is written by someone named Kip Irvine

and it’s titled Assembly Language for X86 Processors.

It’s written by Pearson or it’s published by Pearson

and the year is 2014.

So get a copy of this book.

Anyway, so this is a simplified CPU block diagram.

Let me get my notes here real fast

so I don’t forget what I was supposed to say.

Clock ticks and alu.

Okay, so I guess that’s pretty much it.

Imagine now that we have a little RAM stick or some place where we can get instructions for the CPU.

So this is like system RAM, we’ll say.

And we’ll just pretend for the sake of argument that we already have existing circuitry

that will easily transfer data back and forth from the RAM stick to the CPU.

So anytime the CPU wants to grab some kind of data or like an instruction or something off the RAM stick,

it can just do it. And that’s the arrow right there.

keep in mind after that is that there is a special register in the CPU called the instruction pointer

RIP in x86-64 assembly the RIP register and the RIP register it basically just holds a memory

location telling the CPU where is the next where’s the address of the next instruction that we want

to execute so you know imagine you have like some kind of memory address 0x I don’t know 55 and then

an instruction on the very next actually let’s do five zero so I can increase this by eight without

doing hex in my head we’ll say this is like the address five zero in hexadecimal so that means

that the next time the CPU wants to execute an instruction it’s just going to ask system ram

for that address system ram is going to give it whatever ones and zeros it has and then it can be

decoded and executed after that and then of course we have to execute a program you know step by step

you know step by step we have to execute more instructions and we can’t just do one instruction

so typically in a program you execute instructions one by one by one by one by one

and then every once in a while there might be some decision logic like you have an if else

branch like let’s say uh you know for the for the high level people i’ll put a question mark here

you have like an if statement and you say like if that’s true then execute this i’ll put maybe i’ll

then we’ll just execute this other logic down here. So you know very often we execute instructions

sequentially but every once in a while we have to jump right because if if you executed this

if statement and you realized that this condition was not true then you could not execute the body

that came right after the comparison instructions you would have to jump down to wherever the else

block is so there is circuitry inside of the CPU that allows you to either increase the instruction

instruction pointer by 8 bytes, 8 bytes because 64 bits per instruction because that’s your CPU.

So you just kind of go sequentially or to jump somewhere because you made a decision or you’re

like making a function call or whatever. So just keep in mind that under the hood, under this

diagram, there is a lot more logic even than the more detailed diagrams that you can find elsewhere.

There’s just like a lot more detail. So anyway, the RIP register just kind of increases by 8

every time we execute an instruction,

sometimes it’ll drastically change its address

so we can jump execution somewhere else

in order to make a decision.

So just keep that in mind.

So suppose that we just fetched an instruction from memory.

You know, it comes in here

and we kind of send it down the line.

We first give it to the code cache unit.

Your CPU is just not a solid block of stuff.

It’s got subunits inside of it.

And one of these units is the code cache unit.

it’s a lot more complicated than what you’re seeing here but basically

system ram is very slow dealing with the cpu internally is very very very fast in comparison

so if we have like a register or some unit that we’re accessing that’s inside of the cpu it’s

lightning fast compared to accessing the memory so that means cpus have caches which just i’m not

going to go too much into caches for this video but basically every time we get a new instruction

we might put it into the cache, which is like incredibly fast because it’s hardware that’s part

of the CPU. Then maybe sometime in the future, we might want to execute the same exact instruction

at the same exact address. Again, that’s possible. Remember we have loops. We can execute the same

instructions a bunch of times in a row. So if we come across an instruction that we have executed

in the past and it’s already in the code cache, then we don’t actually need to wait for memory

to fetch the instruction for us, we can just go directly to the code cache and it’s a dramatic

speed up.

Remember, when you access memory, execution has to stall for quite a long time usually

or sometimes.

Okay, so that’s what the code cache does.

Once the memory and the code cache have figured out, okay, we got the instruction and everything’s

good, then we just sort of decode the instruction.

We decide, you know, what is in the instruction?

it all like data or is it all like like is it half and half and part instruction

part data part whatever there’s lots of different formats for instructions so

the instruction decoder just sort of like you know decides how to separate

it and it sends data into the control unit notice how there’s a little arrow

pointing from the instruction decoder to the instruction pointer so we could use

that information to decide how to modify the RIP register like if we’re gonna go

or if we’re going to jump somewhere.

And then the, let’s see,

when we send the instruction to the control unit,

the control unit is not necessarily the brain

because the whole CPU is the brain of the computer,

but the control unit is kind of like the decider of the CPU.

At least that’s the way I see it.

It decides what to do.

There’s a lot of other subunits in the CPU.

Notice how down here we have, you know, CPU registers

and we also have the all you.

the all you the all you is basically the arithmetic logical unit so it’s it’s a little subunit that

will execute mathematical instructions or logical instructions like it’ll take some bits and it’ll

it’ll move them to the left or the right or it’ll flip the bits or whatever or it’ll add two numbers

together the registers you know they’re very very very fast they’re like you know the variables of

the cpu um so the control unit will examine uh whatever it’s getting and it’ll decide all right

want us to do it wants us to add two integers together or it wants us to

write something to memory or it wants us to do whatever right so when

the control unit receives input remember this is all just like ones and zeros

right so imagine if we had like a bunch of ones and zeros coming in and they’re

just wired directly into the control unit right so then the control unit has

its own internal circuitry that that makes it so well if I receive this

going to tell everybody else to add numbers together and if I see some other number I’m

going to tell everybody else to multiply numbers together so the control unit is really responsible

for deciding what the other units need to do in order to accomplish the current instruction

so gosh I really need to fix this I just reconfigured this thing and now it’s just like

drawing even when I don’t want it to draw so the control unit let’s say that we do that we have

that we have like an addition instruction we want to add two registers together the control unit will

send this down the wire to let the all you unit know that it needs to perform addition the all

you unit also has inputs and based on what it receives it will decide to do something it’ll

decide to add or subtract or multiply or just whatever so the control unit sends the right

input into the all you unit so that it knows to add or do whatever we wanted it to do

operands like it might receive data that just came from memory it might receive registers it might

receive just like a raw immediate number that’s embedded into the instruction on the other hand

we might also send something into the floating point unit so the control unit it’s always sending

all of these signals to all of its you know connected units these wires it’s not like we

can remove these wires so there’s always something even if it’s a zero going down the line

so the control unit will basically send the right signals down to the all you to tell it you’re

going to add and it’ll send the right signals down to the floating point unit to say you’re

not going to do anything or just we’re not we’re going to ignore the result there’s like all these

logical gates that we’re not showing on this diagram where we can just like ignore the output

result of some unit that we’re not going to use so it’s sending all these signals to these units

Just like a quick note here, the all you only deals with integer math and, you know, bitwise

logical operations.

Floating point numbers in the machine are stored totally differently than integers.

So we need a totally different unit in order to process them.

So that’s why there are two units there.

Well, I mean, I guess depending on, you know, what CPU we’re talking about, but like as

far as the ones that I’m aware of and that I use.

So then, you know, the data cache, kind of the same thing.

kind of the same thing um you know there’s like a code cache up here and a data cache down there

so sometimes we might want to fetch data that we’ve already fetched before and we don’t want

to hit system ram so you know we don’t want that slow down so we’ll just take it from the cache

and um we will also populate the cache when we have a result so when this like all you is done

adding whatever it’s going to add it’ll send its result data to the data cache and then um

two or three or whatever then we can reuse the result in another instruction or send it back to

memory or do whatever we want to so this is like a basic idea right like you you start off by you

know grabbing something from memory possibly if it’s already in the cache then you wouldn’t

actually grab it and then the instruction decoder decides you know are we gonna we’re gonna jump

are we gonna go to the next instruction after this is over so it’ll have the next address

notice how there’s kind of like a little cycle that goes here between code cache instruction

decoder and instruction pointer and so you know we’re always kind of deciding what’s the next

instruction that we’re going to execute and then we like you know send the decoded instruction to

the control unit the control unit decides you know are you going to do some addition are we

going to use registers or not and then you know like are you not going to do anything or are maybe

you are going to do something in this case I’m just saying the floating point won’t do anything

integers. And then once that is all processed, you know, it comes to the data cache and, um,

well, we can, we can basically just, uh, you know, write it back to memory. I think this

diagram is not showing an arrow that will write it, write it back to memory. Um,

yeah, the code cache is definitely not going to feed directly into memory. That’s just a cache,

but you know, so, so imagine like there’s a, there’s like another wire here that goes

so when we have a result we can just write it into system ram

let me see if i forgot to say anything rip

yeah that’s basically all i wanted to say okay so now you have a fairly good idea of at least

one level deeper of what’s going on inside of your computer how the cpu in a general way loads

and all these little subunits getting told what to do

and the results getting piped back to the instruction pointer

and also to system RAM and so forth.

And it just keeps going like this again and again and again.

And also just remember that at certain points

during even one cycle, we wait for a clock tick.

I’m not gonna say exactly when we wait

because it’s kind of specific to what’s going on

to be on the scope of this video.

But yeah, the clock speed controls

how fast these cycles go.

And there’s much more advanced stuff

And there’s much more advanced stuff that you could learn later,

like pipelining and such to increase efficiency.

But this is a basic idea of how your computer works.

I hope you enjoyed 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 video.

Hey, everybody.

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

I really appreciate it.

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

If you could do me a please, a small little favor,

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

Website that you’re looking at right now

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

So we’ll be able to do 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

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 video and it’ll take you to my main

website where you can just kind of like see all the videos I published and the

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

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

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

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

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

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

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

Thank you.

The post How Your CPU Works: Fetch, Decode, Execute Explained appeared first on NeuralLantern.com.

Ready to dive into x86-64 assembly? This beginner-friendly video breaks down CPU registers like RAX, RBX, and more in Yasm assembly. Learn how to use general-purpose registers, respect the ABI to avoid debugging nightmares, and optimize code by minimizing RAM hits. We’ll cover callee-saved registers, function arguments, and why you shouldn’t mess with the stack pointer. Perfect for coders looking to master low-level programming. Grab the free book mentioned and subscribe for more assembly tips! #AssemblyProgramming #x86

Introduction to Registers 00:00:00
x86-64 Yasm Assembly 00:00:04
Recommended Book 00:00:09
Move Instruction Example 00:01:04
64-bit Registers Overview 00:01:52
General Purpose Registers 00:02:24
Two’s Complement for Integers 00:03:37
Floating Point Registers Introduction 00:03:54
ABI Importance 00:04:55
Function Return Values 00:08:01
C++ to Assembly Translation 00:08:43
Avoiding System RAM 00:11:45
Optimizing with Registers 00:13:04
Callee Saved Registers 00:14:16
Preserving Registers with Push/Pop 00:16:40
Stack and Local Variables 00:22:00
Function Arguments in Registers 00:25:12
Stack Pointer and Base Pointer 00:31:29
Instruction Pointer (RIP) 00:36:30
Temporary Registers (R10, R11) 00:36:49
Accessing 32-bit Register Portions 00:38:29
Floating Point Registers Details 00:42:53
Conclusion and Call to Subscribe 00:45:35

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hello there.

Let’s talk about registers in assembly.

More specifically, x8664 Yasm assembly.

Okay, so first off, check out this book.

It’s a wonderful book.

The author is a genius.

It’s called x8664 assembly language programming with Ubuntu.

It’s free.

website and you know grab your copy it’s wonderful it’s released under a copy left license

author’s a genius whenever i’m trying to remember things about cpu registers for assembly

i always go to this section i say callie saved i search for callie saved i already had it there

callie saved and it ends up being section 12.8.2 register usage so before we do that let me just

that let me just give you a little quick example so you kind of know what I’m

talking about here hopefully everybody’s seen this instruction by now this is a

move instruction in Yasm x86 64 assembly it just moves data from one place to

another it takes two operands so you know we have like operand one and

operand two basically operand one is the destination operand so we could put

destination there if we wanted to operand two is the source we could put

that actually won’t, you know, compile or assemble,

but I’m just saying that’s what those positions are for.

So here’s an example of a register receiving the value 10.

We use the move instruction and we say,

we would like to move something into the REX register.

We would like to move the value 10 into the REX register.

And there you have it. There’s a move instruction. Okay.

So REX is a register.

that it is a 64-bit register in our 64-bit CPUs every single register or

sorry every single general purpose register and the plot registers they

have 64 bits available for us to use 64 bits like you know ones and zeros it’s

like a very very very big number a long time ago we had 32 bit registers and so

these are like you know twice as mathematically robust or whatever you

allows the registers to address, you know, the 64 bit memory addressing space,

which helps us go beyond four gigabytes of RAM in our modern computers,

helps us go far beyond what we can even achieve right now.

So we have a register called RAX and there’s a list of other registers on this

page here. So basically, you know,

we have the RAX register and the RBX register and the RCX register and so

forth. I have a hard time remembering all these names,

remembering all these names so I go to this book when I forget but otherwise

you know you can kind of think of like ABCD and then just surround them with

RNX you know our kind of for register and X for extra big maybe so we’ve got

the RAX RBX RCX and RDX registers and then we have a bunch of other ones

through R15 but first before we do that let me just emphasize that these are

general purpose registers to be used for integers or data you can put

characters in there for strings you can put just like you know whatever data you

want inside the machine we use twos complement to represent integers so it’s

it’s fine the instructions that you will do for addition and other mathematical

but don’t put floating point numbers in these registers because the computer the

system the machine won’t know how to operate on that data the thing is

integers are stored as twos complement I’m going to talk about that more in

another video and floats are stored in something called I triple E seven five

four standard which is just like a crazy different way of storing floating point

numbers that makes more sense for floating point numbers but because the

differently in the machine you can’t really use normal instructions like you

can’t add two floats together the same with the same instruction that you would

add two integers together you would have to use special floating point registers

and special floating point instructions I’ll talk about floats at the end of

this video I hope but basically just keep in mind these are general purpose

registers to be used for integers in data only okay so what am I talking

Okay, so what am I talking about?

What are we seeing here on the side here?

Why does it say return value?

What is going on with Kali saved and fourth argument and third argument and so forth?

So there’s a standard that you’re supposed to use when you program.

You can get yourself into a lot of hot water or you can dramatically increase your debugging

time if you don’t do this.

standard called the ABI which I think is short for application binary interface but basically I just

like to say the ABI respect the ABI there’s a plan that people came up with that says this is how you

should use these registers don’t use them in a different way and that way if everybody is writing

you know modules and they’re all going to interact together like I write a module you write a module

the abi then it’s it’s pretty much guaranteed that we can we can expect certain things like

our registers won’t become corrupted after a function call or that we’re not going to corrupt

someone else’s uh function or you know whatever right so you can also use this to benefit yourself

even if you’re the only person who is writing your code and you’re not calling on anyone else’s

function um then you know like how are you going to remember like what was i using this register

Was I supposed to save that one?

Was I supposed to preserve it?

How was I going to return data from that function?

Was I going to use this register or the other register?

It’s hard to remember what you,

what you yourself even did like a month ago.

So if you respect this plan,

then your functions will work not only

with other people’s functions,

but with your own functions from a month ago.

The other thing too, is we have system calls, right?

So you have like a system call.

Let’s say we want to move something into REX.

something into REX, maybe I want to exit the system or something.

Just forget about this.

This is not a system call video.

Suppose I want to do a system call, right?

The system call itself is also going to respect the ABI.

So if you start calling other

services in the system call instruction, like if you want to open a file,

close a file, read a file, write a file, whatever.

If you don’t respect the ABI and the system call is respecting the ABI,

might have some of your data corrupted so it’s a really really good idea to respect the abi

in fact think about it this way what if uh what if you wrote a bunch of functions for a long long

time and then like a year later you couldn’t you couldn’t remember what you were doing you know

last year oh what was the return register uh and it costs you a bunch of extra time debugging

eventually you’ll probably decide to write your write your own standard okay from now on i’m always

going to use this register for return values and i’m going to use this register for the first

and i’m going to use this register for the first argument and i’m going to write you probably

come up with a plan right that’s basically the abi the abi covers more than just how to use

registers but um register usage is covered in the abi so why would you put yourself through

a bunch of heartache and then eventually come up with your own plan when you could have just

been following the correct plan in the first place right so everybody should respect the abi

I wanted to talk next about the return value.

Okay, so let me write up a little function here.

Let me just say that we have a C++ function.

And we’ll just say it’s like void f.

And we’ll say it calls on g.

And then we’ll have another function called g.

And actually, maybe it’s not void.

Maybe it actually does return a long.

returns the number five or something. Okay.

Hopefully you’ve seen some kind of a higher level language before like C++

so that you can understand what’s going on here.

We’re just making two functions and one is calling the other.

And the second one is just returning a value to the first one.

So in assembly, the equivalent of this would be,

let’s make a label with the name of the function and then a little colon,

and then just put a return instruction at the end of it. Wham,

it, wham, you’ve got a function. It’s not going to work very well, but you do have a function at

this point. So F, uh, I’m going to try to copy the C++, uh, function. So it’s a really good idea.

Whenever you’re writing a function in assembly, try to imagine what the prototype would be for

C++ and just put it as a comment at the top. So I know how the F function is going to behave in

my assembly module because I put a comment up there just kind of reminding me what the prototype

for C++. It doesn’t really do anything. It just sort of runs. So that’s okay. And then I’ll make

another function down here. I’ll do the long G again in a comment, and then I’ll do the actual

assembly version. I’ll say G colon, and then I’ll return. So just by putting that comment up,

I kind of can remind myself now that the G function is supposed to return some kind of a value.

up here, you know, do how about let’s say, I don’t want to start adding a bunch of local

variables right now.

Pretend that we’re going to print the return value of the call to G somehow we’re going

to use C out or whatever.

We’re going to send it to a variable, whatever.

I’m just going to try to keep the assembly as simple as possible.

But anyway, the point is G returns something.

you know, a value in your assembly function.

Well, remember that higher level languages,

part of why they’re so awesome

is they do a lot of extra work for us under the hood

and they actually provide illusions to us

that make programming easier.

For example, there are no functions

going on inside the actual machine.

I mean, I guess from a certain point of view there are,

but basically the machine is just sort of like moving data

and jumping to instructions

and jumping back from somewhere.

And, you know, it’s just sort of like jumping around

and executing instructions.

and executing instructions there’s no actual function it’s so it’s like if you want to pretend

that you have a function in assembly well there is a return instruction that will help you jump

back to wherever you came from most recently but we have to we have to implement more is what i’m

saying so how do we return a value in an assembly function we just have to load up the return value

it as return value that just means we have to load rax up with something so for example we wanted to

return the number five so i’m just going to load it up with the number five and then return

now we’ve pretty much translated a c plus plus function into uh an assembly function i mean

that’s really what’s happening under the hood when you compile your c plus plus program

it’s um it’s just you know translating all the c plus plus into assembly

Another thing that I should probably point out is that you should use registers as often as possible

and you should try your best not to touch memory.

Of course at some point you have to touch memory when you want to save your final result or send

it off somewhere or whatever but you know imagine that you have an assembly function and you’re

doing lots and lots of calculations you’re performing an algorithm or something your

program will be so much more efficient by like a factor of a hundred or probably more if you don’t

if you don’t hit system ram because every time you hit system ram like a global variable or the

stack or something then um your cpu you know typically in the uncashed uh scenario your cpu

has to go talk to the system bus on your motherboard and then you know send a message

to system ram and then wait for the system ram to figure out what it’s doing and then get a response

back so when your program is executing on the cpu you can encounter a stall which is like your

like a hundred clock cycles or more like it’s a long time at least in the most basic case

and how do you avoid that just use registers only when you’re doing lots of calculations the

registers are built into the cpu they’re part of the cpu’s hardware so they are lightning fast

compared to system ram or your disk or whatever

i probably say this a lot but you know part of the reason you would even want to code an assembly

Maybe you have a big program that does a lot of stuff and eventually you profile the program

and you realize, Hey, this one part of the program is really slow because it gets called

constantly and it’s not super efficient.

That might be a good use case for writing a hybrid program where you have multiple modules.

Some of your modules are in a higher level language and some of your modules are in assembly.

So you take your most important function that slows down your program that gets called all

like a big loop or something and you rewrite it to assembly so that you can

have more control over how often you touch system RAM to try to make the

whole thing more efficient and you know reduce the number of instructions and

just like whatever and you can improve the product of the efficiency of your

program so anyway you want to try to avoid hitting system RAM your registers

are built in the CPU there’s 64 bits that gives us 64 bits of address space

can reach you know back in the day we had 32 bit systems that means you could only have a memory

stick that was about four gigabytes so now we can go much further so um yeah that’s what’s going on

with our registers on the cpu back to the return value okay so we have return value here goes into

the rax register and then the next thing here is it’s saying that the rbx register is something

remember we said that uh we have to respect the abi right like you have to respect this convention

uh because if you don’t you’re going to cost yourself debug time and your

functions probably won’t be interoperable interoperable with other people’s functions

or the system call uh instruction well so one of the things about the abi is some of the registers

are designated as the function that is being called has to be the thing that saves the register’s

registers value so that it doesn’t corrupt for the caller. Imagine this if I had a function

called f I’m going to do like f and g here suppose the function f is going to move something into

let’s say r12 or actually let’s do rbx move the value 10 into rbx and then it’ll call g for some

reason maybe g doesn’t take any arguments maybe g is just kind of doing stuff let’s just say that

g just moves a different value into rbx so the thing is when the call comes back like after we

get to this next line let’s say we’re going to do something with do something do something with

rbx by the time we get to this line dude can i get the line numbers on this oh yeah i forgot okay

so by the time we get to line seven uh the register rbx is ruined these registers are not

local variables they’re not like uh you know tied to any scope or function call these registers are

just basically global variables that are sitting on the cpu for lightning fast performance but that

means the rbx i use inside of f is the same rbx i use inside of g so that means if g messes up the

value of rbx and then if f calls g then f now has a bad value for rbx this is a broken program

broken program because we did not respect the ABI.

The ABI says that RBX is callee saved,

which means if I use RBX in the G,

then I have to preserve the value so that by the time I return,

the value is the same as it was when the call first came in.

So how do we do that?

We’ll do that with a push pop pair.

I’ll probably make more videos in the future about pushing and popping,

but I’m going to try to keep it simple for now.

We just say, let’s push RBX onto the stack.

at the beginning and then we’ll pop it off the stack at the very end.

This basically means we’re going to take the value of RBX.

We’re going to send it onto the stack.

So, so yeah, we are hitting system RAM.

It’s a little slower at that point.

The ABI will save us a little time for the other registers.

I’ll try to explain that in a second, but basically we’re preserving the value here

with push and then we’re popping it back off.

So we’re restoring it.

So that means even though we ruined the value at line 14, when F does its line

When F does its line 7, it’s going to have the correct value of RBX.

It’s going to have the value 10.

The book and I like to call this the prologue, just meaning this is a little section of code

where we’re going to set things up.

We’re going to start getting ready to do more instructions.

And then this at the bottom is going to be called the epilogue.

This is just like the finale.

We’re like, we’re kind of cleaning up.

We’re finishing up right before we return.

If you wanted to return a value from G, then you could put, you know, the move inside of

RAX somewhere else.

Like you could put it like below the epilogue or just above the epilogue.

It’s fine.

As long as you’re sure that RAX is not getting trampled upon.

So it’s important to note also that if I do a, let’s say a system call right after that,

let’s say I call G and then I do a system call with, you know, like, you know, some

you know some other number as the call code i want to open a file i want to close a file

i want to read or write a file whatever i want to ask the system to do something for me the

system is also going to respect the abi which means i’m guaranteed that rbx is not modified

when the system call comes back if if the system call you know if the syscall instruction didn’t

respect the abi then my rbx could be ruined i’d have to do a bunch of stuff to preserve it so this

some of these registers let me go down a little bit here like this R10 the

temporary register and also the RDI if you decided to use that in the body of

your program which you’re allowed to these are not designated as callee saved

which means system call could actually ruin the value of those registers so

suppose for the sake of argument I really decided that I needed to use I

10 because that’s marked as a temporary I’ll put a value in our 10 and then I’ll say you know

do something

With our 10 I’m sorry our 10

Then that means by the time I’m done with my call to G

I should assume that our 10 is ruined because even though you’re you can see right here that that G doesn’t actually do anything

To our 10 we should assume that we have to respect the ABI which means the other function could have ruined it

Ruined it. This is especially true if you call someone else’s module or system call or whatever same thing for the system call

so if I call system call

and I use

R10 at some point before and then after then I have to assume R10 is destroyed by the time I get back in system call

So that’s no good

The cure to that when we’re talking about a temporary or something that is not designated as callee saved is that the caller has to save

hit a system RAM just to make a call.

Anything that we think we need when we’re finished.

So I’m going to do a push.

This is not the only way to do it, but I’m going to do a push R10 here.

And then afterwards, I’m going to do pop R10.

So that sucks.

And then I have to do the same thing for the system call.

I can go push R10 and then pop R10.

And of course, if you were clever, you probably would, you know, put the call to G inside

of that system call push pop pair.

So you could have one less push pop pair.

push pop pair but I’m just saying there’s no guarantee r10 is going to survive so you always

have to preserve it if you ever want to use it again so this is like another way that the abi

kind of can help you save time notice how here in the uh in the g function which I probably should

have prototyped let me just say it looks like to me it’s a void and it doesn’t take any arguments

to prototype your functions in comments.

Maybe let me do the same thing to F up here.

So F looks like it’s not returning anything and it’s not taking anything.

Okay. Whoops.

Those are C++ comments that would not compile.

All right. So notice how I’m using RBX.

So I decided to preserve RBX, but there’s also other registers that are marked as

marked as Kali saved like R12 through 15 and RBP and whatever,

but I’m not preserving those.

The reason I don’t have to preserve those is because I’m not using them.

So the, uh, the, uh, the ABI can save you a little time here.

Like for example, I’m preserving R10 because I’m supposed to assume that I,

that I, that they could be destroyed by the time the function comes back.

What if instead of using R10, I used R12.

have to surround any calls with a push pop pair because I can trust that whoever is going to

modify R12 will preserve it for me. But then notice down here G is not actually using R12.

So G doesn’t even do push pop on R12. So we save hits to memory. We don’t even have to touch memory

to preserve R12 because the ABI is helping us sort of stay a little bit more efficient.

So this is great, right? F is a broken function at this point though, because I’m using

at this point though because I’m using two registers that are callee saved I

can’t assume that whoever called F is gonna know that I’m modifying RBX and

R12 so I should do a prolog and an epilog up here I’m gonna say push RBX

and then I’m gonna push R12 and then down here at the bottom I’m gonna do an

epilog epilog and I’m gonna pop RBX and I’m gonna pop R12

but I’ve done something wrong.

The thing is, I’m not going to talk about the stack too much in this video,

but the stack is a particular type of data structure

that will return to you data in a reverse order than you sent into it.

This is great for helping us keep track of function calls and return addresses,

as I’ll probably try to explain in this video.

But basically, the data comes out backwards.

The data comes out backwards. So if I do it like this

Then actually by the time the return statement instruction gets executed

RBX will have the value that was intended for R12 and R12 will have the value that was intended for RBX

It’ll be backwards. So you have to do your push pops in the reverse order to notice how

It’s kind of like a shell that goes outwards. It’s like R12 is first on the inside and then RBX is next on the outside

That’s just what you have to do to preserve everything.

So the F function works now.

The G function, I think it works now.

We have a prologue and epilogue.

Okay, so we talked about the ABI.

We talked about calls.

We talked about the registers.

Talked about callee saved.

We talked about the fact that we don’t have to save the other ones.

I think I can talk about…

um so uh one thing that i should make sure to mention is that these are general purpose registers

they’re to be used for integers integer data or like characters or just like regular data

they use certain instructions that are not to be used with floating point data so you actually

should not store floating point numbers inside of your general purpose registers you should only

store floating points in special registers which i’ll talk about at the end of this video

So keep that in mind.

Floating point numbers are stored differently in the system.

They’re stored with a scheme called IEEE 754 floating point.

So like the numbers wouldn’t make sense.

Integers and floats are stored differently.

So the hardware is wired differently to operate on two different types of data.

So anyway, I just want to say that this is only for integers and general purpose data.

So now let’s look at the other types of registers.

rc x and rd x and rsi and rdi are designated as arguments first second third and fourth

okay so let me uh let me write like a quick c plus function here and this is going to be uh let’s

say we have like a function that returns some value we’ll call it uh we’ll call it f and we’ll

say that f takes in some arguments let’s say that it takes in three arguments um again uh

integers right now because we’re only using integer registers.

We can’t use floating point arguments or return values.

Just keep that in mind.

So I’m just going to do like three arguments long A and B and C.

OK, so we can take in three arguments and maybe we’re just going to return,

you know, a plus B plus C.

OK, simple C++ function.

Let’s do this in assembly.

We’ll make a label and we’ll do a little comment that just reminds us.

of sorry of the

Function that we’re trying to implement we stick a little return instruction at the end of it so that

it will jump back to the caller and

then we’ll say

Well when the caller of this function

Called us and gave us a and B and C. How do we get a and B and C?

Well a is the first integer argument, so it’s just going to be the RDI register

So we’ll literally just use a move instruction

just use a move instruction.

Let’s say we want to, for whatever reason, use the R12 register

and we’ll do something with it later.

We’ll print it, we’ll save it, we’ll do whatever.

Let’s just grab the incoming argument.

So we’ll just grab RDI.

So I’m going to put a little comment up above here, you know, grab

a and do something

with it and I’ll just write down here more instructions just to just to denote

Just to denote that we’re doing something with the a value, but I’m not going to write it down here because I don’t want this to get huge.

So we’ll do the same thing with the b.

Maybe I should remember that programming is case sensitive.

We’ll do something with the b.

It’s not RDI.

It’s the second argument.

So that’s actually RSI.

And then we’ll do something else.

We could have used R13 or other registers if we wanted to.

I’m just showing you how to grab incoming arguments.

So then we’ll grab the c and do something with it also.

C and do something with it also it’s not going to be RDI it’s going to be RDX and you can do this

up to like I think six arguments let me just double check here yeah so like R9 ends up being

the sixth argument and if you want more than that then the caller will have to put stuff on the stack

and in fact if you if you kind of like understand what’s happening here let me just do like a main

Let’s say we do cout whatever f returns.

You know, this is like a typical function call, right?

So we’ll call f.

f will jump in there.

It’ll jump into its body.

It’ll do some sort of a manipulation with the incoming arguments.

It’ll return a final value.

Then that final value gets printed out.

So what’s 5 plus 6 plus 7?

That’s 11 plus 7.

What is that, like 18?

I’m bad at math.

So let’s just say that’s 18 gets printed.

So what happens is, um, we return, Oh, I forgot to return.

I’m going to say compute the, uh,

compute the sum of the things.

Uh, and I’ll just say like block cause I don’t want to put a bunch of addition

instructions here. Uh, and we’ll just like store in, uh,

in R13, let’s say. So then when we have finally computed our result, I’ll just move R13 into the

return value. And what I’m really trying to say here is if you imagine a function that behaves

this way in C++, then what I’ve written down below is really what’s actually happening in

assembly. Your compiler compiles the code down to assembly language first, and then it assembles it

down to machine code. So really this is what’s happening under the hood. It’s not like a special

under the hood it’s not like a special trick when you call a function in C++

literally the A B and C have been loaded up just before the the jump

instruction to go to that you know line 9 they’ve been loaded up with the

appropriate values so that’s part of like you know the magic of what higher

level languages give us it’s just makes things a little bit easier okay so I’ve

If I had only used RDI and RSI and RDX, those are not designated as callee saved.

So I wouldn’t have had to preserve those, but because I chose to use R12 and R13, I

have to preserve those for the caller, even if the caller is not going to use them.

So I’m going to do, I’m going to do push R12 and I’m going to do push R13.

And then at the bottom, let me do like a prologue here.

is kind of helpful because it kind of helps you remember like, oh, did I forget the prologue?

Did I forget the epilogue? They got a match. And then I guess the fact that you can see the words

prologue and epilogue also helps remind you that everything is supposed to be in reverse order

in the epilogue. So again, notice how R13 is on the inside and R12 is on the outside

of the push pop pair. So now my program is good. And we’ve, you know, successfully translated

We’ve, you know, successfully translated a nice function call there.

And we’ve done a bunch of nonsense in the middle that I’m not writing down at this point.

We are respecting the ABI.

So if somebody else uses our function in their module, then they can be pretty confident

that we’re not going to ruin their registers and so forth.

We talked about the return value.

We talked about that these general purpose registers are not for floats.

We talked about pushes and pops.

and pops. We’ve talked about function arguments,

which right now we can only do integer arguments and return values.

We’ve talked about, uh, well, he talked about the stack a little bit.

So let me, let me just point out that, um,

suppose you have a function. I just want to mention this briefly.

Suppose you have a function F let’s say it’s, it’s void.

So it doesn’t return anything and it has an integer a equals five.

I think the reason that I wanted to do this is to show you how dangerous it is to mess

with the wrong register like the stack register.

So suppose we have two variables and then we’ll do something with a and b.

So now suppose we have two threads.

We have an execution thread one and an execution thread two.

If you’re not familiar with threads, that just basically means your computer is literally

executing your function or sorry, it’s executing twice at the exact same time.

Maybe not the exact same time if you only have a single core on your CPU, but you could

imagine that that’s possible, especially if you have many cores, that’s an operating systems

video.

But basically pretend that we have an execution thread.

So it’s like going through your program, executing one instruction at a time.

Then you launch another execution thread that also executes your program one instruction

at a time.

at a time so at some point it’s possible that um thread one and thread two could be executing f

at the exact same time right so i’m not going to talk too much about this because this is not an

os video but basically this could create a race condition where thread one and thread two kind

of step on each other’s toes and they both try to modify the value of a uh at the wrong time and

because the other thread modified it.

So this is why local variables in a function actually live on the stack.

A and B are not global variables.

They’re actually temporary local variables that are sitting on the stack.

And the way the stack works, I’m not going to talk about it too much in this video,

is that, well, every function kind of has its own area of the stack.

So when the function comes in, on the stack sits the return address

return address so that the function knows where to jump back to when it returns and any local

variable that the function makes. So if you think about it, when thread one calls F, we actually

end up with a different version of A and a different version of B. We could imagine them

as being, you know, A sub one and B sub one. But when thread two comes in and, you know,

creates those local variables, we can imagine that we get two different versions of A and B also.

of a and b also so this is how the computer prevents multiple threads from stepping on each

other’s toes if you’re using local variables local variables are just local to the function

this also helps if a function calls itself a bunch of times maybe one call or another might want to

see a different version of a or b and it would be just incredibly difficult to keep track of that

if you were using globals but when you use locals well they’re just basically different variables

trying to lead up to is the stack is pretty important if you corrupt the

stack then you probably are going to crash the entire program you might make

it so that a function doesn’t know where to return from like when you do the

return statement it might jump to some other part of the code that doesn’t even

make sense and then everything crashes or you might mess up some data in a local

variable like if you mess up if you mess up the stack you might be messing up the

that the caller is depending on and so then the caller continues to execute and

it sees the wrong value and it just crashes or you might even mess up your

own local variables so don’t miss with the stack the reason I’m saying that now

is because this very this register right here the RBP sorry that’s not it the

RSP register that’s the stack pointer eventually you can learn how to

manipulate the stack pointer in order to create your own local variables that’s

variables that’s okay once you know what you’re doing but unless you know exactly what you’re

doing you probably shouldn’t touch the stack pointer especially you shouldn’t mess with it

right before you call a function or right before you return from your own function be very careful

with that the rbp uh register is similarly dangerous uh it won’t like automatically destroy

your program but it is uh it’s usually i mean it’s quite often used as sort of like a bookmark for

mark for where the stack pointer was pointing in other modules and other

functions.

So if you fail to preserve the base pointer,

the RBP and then you returned from your function,

then you might have actually messed up the stack pointer for the caller or some

other caller somewhere in like the ancestry of your call graph.

So be very careful. I mean,

I guess all callee preserved variables or registers you should be very careful,

careful about, but these are like kind of the two worst ones to forget about.

first ones to forget about.

There’s also another register that is not listed on this page called the

instruction pointer. It’s RIP.

It basically is a register that holds

the memory location of the next instruction to be executed.

So if you modify that, then you just told your program to go execute

in some random crazy place and probably everything is going to crash.

R10 and R11.

I can’t remember already if I explain this, but I’ll just say it again.

But I’ll just say it again, R10 and R11 are just temporary registers.

You don’t have to preserve them.

But the callee, if you call another function, they don’t have to preserve the registers either,

which means it can be really fast to use R10 and R12 if you’re kind of like already running out of registers.

If you don’t have to make a function call anywhere, so you know no one is going to ruin your R10 and R11,

then you can also use R10 and R11 to sort of like, you know,

reduce your hits to system RAM to speed up your program.

So R10 and R11, they should probably be used last.

R12, 13, 14, 15, I usually use those first.

Once I start running out of those, Kali saved.

Then I’ll start eating into the arguments.

I’ll say, you know, I’m going to start using RBX

and then I’m going to use RDI and RSI and whatever.

It’s okay if you use, you know, the argument registers.

as long as you’ve already done something with your incoming arguments or you don’t have any.

So just keep that in mind.

You’re allowed to use them.

I mean, this is all just a standard.

As long as you obey what the rule is, then you’ll be all right.

The rule is you got to callee save those.

The rule is that one’s just temporary.

The rule is this one’s an argument and so forth.

Okay.

locals and how we use these registers. Let me try to just show you one more

thing real fast. So I said before that the size of the REX register is 64 bits

because it takes up the whole available register bits in the CPU but there are

other versions of this register that we could use. What if you only wanted to use

32 bits in your register? What if you wanted to pack like two different 32

32-bit numbers in the same 64-bit register.

You could do that.

There are also older modules and instructions

that will operate only on 32-bits.

So how do you reference only 32-bits of a register?

Well, if I search for, oh shoot, what was it?

Is it EDI?

No, no.

Shoot.

It’s in here somewhere.

This is like a good lesson in actually preparing before you record a video.

So I’m going to do architecture overview, CPU registers.

Oh, it was at the beginning of this section.

I always skip down to 2.4, 12 point something, and I should have gone to 2.3.1.1.

So obviously I’m not going to remember all of this, but basically notice at the top,

we have the REX register, all 64 bits of it.

But if you wanted to access the lowest six, sorry, the lowest 32 bits, then in your code,

instead of putting REX, you put EAX.

So for example, you know, move REX, whoops, REX, let’s say the number five, but over

here we’re going to move EAX, the number five.

five uh here it’s going to set the whole 64 bits to just like a bunch of zeros and then there’s

going to be a few bits that help represent five the lowest bits so it’s going to erase like the

whole thing all 64 bits but if you use the eax instruction then only the lowest 32 bits will

actually be modified which means whatever data you had in the higher 60 the higher 32 bits of the

of the register itself they’re just going to stay there it’s going to be considered

point so sometimes if you’re going to work with something that’s going to be using only 32 bits

of your register you better make sure that the other bits are uh are cleared out if you intend

to use rax right after that and and vice versa so keep in mind that we have other forms of the same

register a designation but just to let the cpu know that we only want to touch 32 bits worth we

And this, this kind of table covers all of the registers,

REX, RBX, RCX, and so forth.

I think it doesn’t cover the instruction pointer

and something else in there, but you know, most of them.

However, you know, for my purposes,

I usually just use 64 bits

because I’m not like super advanced

unless I have to divide or do something.

Okay, so that’s the last thing I wanted to mention

about the general purpose registers.

Let’s see.

Callie saved.

So the not sure if I said this before already, but basically the.

So just to emphasize the, uh, the RBP register is the base pointer register.

You’re probably going to mess up, uh, the caller because the caller often uses RBP as

a bookmark for the stack pointer.

mark for the stack pointer you definitely don’t want to mess with a stack pointer unless you

actually know what you’re doing in order to create local variables um there’s another variable

another register in here called rip which is the instruction pointer register so if you

if you mess that one up then the program is going to start executing in some crazy place that doesn’t

even make sense okay so now that we’ve talked about general purpose registers by the way i

called special purpose registers, not general purpose.

General purpose is like RAX, RBX, all these ones that you can just randomly use as long

as you respect the ABI.

But the base pointer and the stack pointer, those are kind of special.

And the RIP, the instruction pointer, that’s a special register.

You shouldn’t mess with those unless you really know what you’re doing or you’ll get yourself

in trouble.

But now that we’ve talked about those, let’s talk about the floating point registers just

real fast.

about using floats until a lot later but basically

i at least want to mention that we do have registers that will work with floating point

operations let me see there we go okay so it’s 18.2 floating point registers um essentially

we use xmm0 through xmm13 for floating point numbers there’s not going to be any

not going to be any crazy letters like RDI, RSI that you have to memorize. You can just use zero

through 15 and it’s totally fine. When you want to return a floating point number from a function,

you will load up XMM0 as the return value. You won’t even touch RAX. The arguments are the same.

They’re just kind of ordered. It’s like the first argument is going to be XMM0. The second argument

is going to be XMM1 and so forth all the way up to XMM15. If you need more than 15 arguments,

some sorcery with the stack or with some kind of system like the global variable or something

and also for floating point registers we use different instructions so what I really want

you to know because this is mostly about the regular registers is that if you have floating

point numbers and you want to multiply them or do some other operation on them the normal

instructions for regular registers won’t actually work you’ll have to look up a different set of

and i’m going to do this in another video some other time uh if you want to move uh data with

a floating point register you can’t just use the regular move instruction you got to use either

move ss or move sd um and and both operands have to be floats or actually i think the one on the

right can be memory but um move ss basically means a single piece of data single precision

So you can move like multiple pieces of data at a time.

I’m not going to really cover that.

Um, but you can move single precision floating points, which means there are 32 bit floating

points or you can move double precision floating points, which means they’re a full 64 bit

floating point number.

There’s also bigger registers, but I’m not going to talk about that.

Yeah.

Well, yeah.

Later processors 256.

I think mine has that, but I’m not going to talk about that.

I think mine are like YMM or something.

So yeah, with that, those are the basics of registers and some stuff to keep in mind.

In future videos, I’m going to talk more in depth about making functions and calling functions

and all that stuff, respecting the ABI.

But for now, here is your primer.

I hope it was useful on CPU registers.

Thank you for watching this video.

I’ll see you in the future.

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

hey everybody thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could do me a please a

small little favor could you please subscribe and follow this channel or these videos or whatever

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

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

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

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

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

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

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

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

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

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

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

and it’ll take you to my main website where you can just kind of like see all the videos I published and

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

If you have a suggestion for

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

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

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

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

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

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

Thank you.

The post Mastering x86-64 Assembly: A Beginner’s Guide to CPU Registers appeared first on NeuralLantern.com.

Get a clear, fun breakdown of data sizes in x86-64 CPUs! This video covers bytes (8 bits), words (16 bits), D words (32 bits), and quad words (64 bits), plus how they fit into assembly and CPU registers. Perfect for programmers, students, or anyone curious about low-level computing. I’ll walk you through the basics with relatable examples, no jargon overload. Subscribe for more coding & tech videos, and scan the QR code to visit my site for extra tutorials! Leave a comment with your thoughts!

Introduction 00:00:00
Data Sizes Overview 00:00:01
Byte Definition 00:00:44
Bits to Bytes Conversion 00:01:27
Word Size Explanation 00:02:20
Double Word (D Word) 00:04:03
Quad Word Definition 00:04:44
CPU Registers and Memory 00:05:21
Conclusion and Outro 00:06:07
Call to Action 00:06:32

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hello there.

I’d like to talk to you about data sizes within the context of x86,

64 CPUs,

just like 64 bit CPUs for assembly and just whatever.

So what’s going on inside of the machine and how do we describe the sizes of

various clumps of data? So for starters, you know,

of your computer, there’s just a bunch of ones and zeros represented in all the wires,

in all the circuitry.

The human beings with feelings decide, oh, you know, I’m going to take a group of this

many bits, this many ones and zeros, and I’m going to say that it is something else.

I’m going to call it an abstract unit.

So the first thing that we do is we have something called a byte.

That just means eight bits.

So we can say one byte equals eight bits.

equals eight bits. I don’t know why I hit the shift key there. That’s probably going to mess

up my annotator. Nope. Okay. So what is eight bits? Just as a little reminder, you know, we’ll

just say one, two, three, four, five, six, seven, eight, or it could be, you know, something more

random looking one, two, three, four, five, six, seven, eight, you know, so like inside of the

machine, we have eight ones and zeros for eight bits. And when we group them together, we’ll just

Okay, no problem.

So that means by the way, if somebody says,

oh, my internet connection is this many megabits a second.

If you wanna know how many bytes a second,

try dividing by eight.

Or if somebody says I have this many megabytes a second

of transfer speed, try dividing that by eight.

You know, so multiply or divide by eight

to get the right number.

Okay, so if we had two bytes together,

that’s just gonna be 16 bits.

No problem there.

I’m just going to copy paste these bits and you don’t have to do this.

But for me personally, I like to put a little space in between bite groupings just to help

my human brain kind of see, oh, I’m looking at two bites right here when I’m referring

to different data sizes.

So then eventually we kind of need an idea of, you know, let’s come up with a different

word that means more than one bite.

ironically based on what I just said the the term we’re going to use is word a word

the size of a word just kind of depends on the system that you’re on on my system

the size of a word is two bytes so I’m going to say one word equals two bytes

and you can imagine that’s 16 bits maybe I should start doing the double equal sign here just to be

Okay, so equals two bytes.

It also equals 16 bits.

And you can imagine it’s basically the same thing

that we just wrote up above.

So I’m gonna erase this actually, 16.

Oh, I put an E there, embarrassing.

Okay, so one word is two bytes.

Again, the size of a word depends on your system.

If you’re not sure, you should probably look it up.

What’s the word size on my system?

But again, the typical system here in 2024

6664 machines running Ubuntu, um, or just like Linux is going to be like, you know,

two bytes. Okay. So now, uh, we have like words that we can do. So if I had, uh,

let’s say I had two words, uh, two words is going to be double of what we just wrote. Right. So

that means we’re going to have this many, whoops, I blew it. We’re going to have this many bits.

So two words, two words is going to be equal to, um, 32 bits.

And it’s also going to be equal to four bytes because, you know, we multiplied everything

by two.

So this is like four bytes.

So now we need another term to represent this two words, which is four bytes, which

is 32 bits.

We can also call that a D word.

Actually, I’ll say D word like that.

And what does D word mean?

is twice the size of the word length on your system.

So like if we decided our word length is two bytes,

then a D word is four bytes and that’s it.

Four bytes is 32 bits.

You might notice this is similar to like old school CPUs

that ran in 32 bits and maxed out their RAM

at about four gigabytes.

So let’s come up with one more term here.

Let’s come up with the term quad word.

Actually, we’re not coming up with the term.

We’re just using it.

What is a quad word?

A quad word is two D words.

So we’re just kind of doubling it again.

I forgot that extra equal sign there.

Quad word is two D words, which means it’s also four words.

And it also means it’s eight bytes.

64 bits.

And then I guess if I want to represent this to you,

I can just kind of like copy paste that twice.

And this is the size of the memory address space that we have on modern CPUs.

This is also the size of your general purpose registers in modern 64-bit CPUs.

So if somebody says, hey, I got a quad word.

I want you to store it somewhere.

You can instantly think to yourself, well, obviously I could put it in memory.

I could put it in memory.

You could also just put it directly into a CPU register.

And that’s it.

This also means that you could put two D words into one CPU register if you were very clever.

You could also do the same thing.

You could put like four words inside of one CPU register.

Because the CPU registers, they’re always the same size no matter how you use them.

They’re kind of hardwired.

So I hope this has been, you know, kind of helpful.

These are the basics of different data type sizes that we have in CPUs and

assembly language. I’ll see you in the next video.

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

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

If you could do me a please, a small little favor,

Follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now

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

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

So, please do do me a kindness and and subscribe

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

and I get filled with joy. That’s exactly what happens every single time. So you could do it as

a nice favor to me, or you could, you could troll me if you want to just wake me up in the middle

of the night, just subscribe. And then I’ll, I’ll just wake up. I promise that’s what will happen.

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

which you can scan in order to go to the website, which I think is also named somewhere at the

bottom of this video. And it’ll take you to my main website where you can just kind of like see

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

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

if you just want to say hey what’s up what’s going on you know just send me a comment whatever I also

wake up for those in the middle of the night I get I wake up in a cold sweat and I’m like this

it would really it really mean the world to me I would really appreciate it so again thank you so

thank you so much for watching this video and enjoy the cool music as as i fade into the

darkness which is coming for us all

Thank you.

The post Master Data Sizes in x86-64 CPUs: Bytes, Words, D Words, and Quad Words Explained appeared first on NeuralLantern.com.