Learn how to write your own strlen function in x86-64 assembly (YASM) that finds the length of a null-terminated string using a simple while loop.

We preserve the proper registers, follow the ABI, compute the length safely, and then use that length to print the full string efficiently with a single sys_write call.

Great for anyone studying low-level programming, operating systems, or wanting to understand C strings at the assembly level.

00:00:00 Introduction to implementing string length in assembly
00:00:25 What are null-terminated strings and why they exist
00:01:59 Pre-computing length vs using null terminators
00:02:53 How the null byte (0) actually works in memory
00:04:14 Naive approach: printing one character at a time
00:05:20 Goal: efficient printing using computed length
00:06:00 Program structure overview – two main functions
00:06:32 Data section: defining null-terminated strings
00:08:19 Additional strings for output (prefix, CRLF)
00:09:15 Text section start and global looper function
00:10:44 Preserving callee-saved registers (ABI prologue)
00:11:28 Calling print_null_terminated_string
00:12:43 Simple crlf printing helper function
00:13:10 print_null_terminated_string function signature
00:14:31 Prologue for print_null_terminated_string
00:15:44 Saving arguments and calling strlen
00:17:12 Using sys_write with computed length
00:18:19 string_length (strlen) function begins
00:19:20 Prologue and fake return value testing
00:20:44 Planning the while loop in C-like pseudocode
00:21:33 While loop initialization (pointer and counter)
00:24:23 Loop top: check for null terminator
00:26:23 Loop body: increment pointer and counter
00:27:37 Done label and return length in RAX
00:28:29 First successful run – full string printed
00:29:30 Adding direct strlen call and length printing
00:31:02 Final run showing both string and its length (54)
00:31:53 Summary – benefits of computed length printing
00:32:59 Improving loop structure (better jump pattern)
00:34:07 Final improved loop verification
00:35:03 Closing thoughts and thanks
00:35:27 Outro, call to subscribe, website mention

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there, in this video, I’m going to show you how to implement the function string length.

So you can find the length of a null terminated string in a Yasm x86-64 assembly program.

Although if you’re using a different assembly language or different architecture, this video

will probably still be useful to you because the concepts are going to be the same.

So what am I talking about?

I’m not going to be around here with this.

So in a previous video, I discussed null terminated strings.

I should also point out that a lot of basic knowledge is going to be skipped in this video

because I’ve explained it in other videos.

For example, if you don’t know how to compile, link, assemble, write a basic assembly program,

write a make file and so forth, then you should see my other videos first.

I’ve also already published a video about null terminated strings, but I’ll just do

it again here since that’s in the title of the video.

of the video so imagine you have a string and it’s hello right so under the hood uh the string is

probably a collection of characters on some level so we’ll just say this is h e uh l

l o right um when you’re printing

it’s unlikely that your entire memory stick is just done like it just you’re at the very end of your memory by the time that O hits

So that means you need some way of understanding when the string ends because if the memory is not over at that point

There could probably be some junk data at the end of it

You know like a bunch of other random letters or you can even imagine these as just you know

One byte that’s not one byte one byte numbers that just go on and on and on forever for the entirety of your RAM stick

of your RAM stick and you have to know how do we actually stop at the O. One thing that you can do

is just pre-compute the length of the string so we do that in assembly a lot before we know how

to scan for null terminators. We’ll say all right well that string is just five long so I’ll tell

the system I want you to print five characters starting at that memory location wherever the H is

and then the system knows okay I’ll just you know print the H-E-L-L-O and just stop after that.

null terminated strings are a lot more convenient because you don’t have to pre-compute the strings.

I mean, maybe your user entered a string.

Maybe you have a lot of strings or they change quite often.

Maybe you have like a multinational program that has tons of translations,

or I think multilingual is probably the better word for that.

But it can be a pain in the butt to constantly compute the length of strings in advance.

So with a null terminated string, you basically just say,

that I want to print and I’m just going to stick actually the number zero at the end of the string.

I’ll leave the junk data there just to let you know that there is some stuff happening in memory.

Notice how this zero, it is not actually the character that looks like a zero to a human.

That’s actually a totally different code than just zero. So you can imagine just an actual zero here.

You know, each of these characters that a human would look at has a number underneath it.

You know, this H is not really an H.

It’s just some number between 0 and 255 if we’re talking about ASCII.

The E is a different number and so forth.

So if we just put the literal number 0 in our data,

or if you want to quote this inside of a single quote,

you can do, I think, slash 0 just to let the compiler know

that you intend to have the number 0 there

instead of something that looks like the number 0, you know, the character.

you know the character but anyways the point is we just have to stick a zero at the end

of the string we call it a null terminator because zero is also you know an alias for null

whenever you have a null pointer or you assign null to a memory location or a pointer or something

you know it’s zero basically under the hood so a zero will terminate it’ll be like a token to let

us know that the string is finished and so since zero is also considered null we’ll say it’s a

we’ll say it’s a null terminator.

It’s a basic idea for null terminators.

Now the question is, how do we actually know when to stop?

Well, the first thing that you could do if you’re trying to write a program that is highly inefficient,

which I’ve definitely done before, is you could just print one character at a time.

You use a for loop.

You start at the very beginning of your string, you know, a pointer,

whatever the user gave you as like this is the first character.

We’ll just print that letter, and then we’ll go on to the next letter.

the next letter and before we print it actually before we print the first letter even before we

print this letter we’ll uh we’ll say is this like a regular character or is this a null terminator

is this a zero if it’s not a zero we print that character if it is a zero we terminate the loop

and then we go through every character one by one just you know checking and printing checking and

printing checking and printing unfortunately that’s kind of inefficient because every time

you call a print you know you’re you’re calling on a function you’re asking the system to do some

for you and it would be a lot better if we could just flush the whole string at

the same time but but know how long the string was that would increase our

efficiency so the program that we’re going to write together is basically

going to use our knowledge of a while loop which I’ve explained in other

videos already so see those other videos if you don’t know how to do while loops

in Yasm we’re going to use our knowledge of a while loop to sort of scan the

string real fast just you know kind of scan it and figure out how far into the

far into the string until we see a null terminator and use that to determine what is the length of

the string. At that point, we can use a system call in YASM, in assembly, to just say, I want you to

print this sequence of characters and here’s the length and then let the system worry about

efficiency. So with that said, let’s look at some code. Okay, it’s just going to be a simple while

loop. What we’re going to need to do is break this up into two parts. The first part is going to be

the first part is going to be a function called string length which you’ve probably already seen

in c if you program in c or c plus plus the second function is going to be called print null terminated

string which will just ask string length what the length of the string is first and then actually

print it with the system call so let me uh i guess let me start off with my data section here

to print I’m gonna copy paste that for my solution again this is not a not an

assembly basics video so if you don’t understand what I’m doing you should

watch my other videos first I’m assuming you know how to make a data section by

now we’ll put some C strings I’m just gonna make one null terminated string

actually I guess I’m making two but the focus of this program is just the first

one I’m calling it null terminated string and in assembly it’s pretty easy

you just make it a you know a character array just like a sequence of bytes with

a sequence of bytes with this DB meaning data bytes.

And I can just put a quoted string like this.

No problem.

As many characters as I want.

I can start injecting specific ASCII values if I wanted to

or byte values if I wanted to just by putting a comma

and then a number.

So I could do something like this.

I could do like, you know, 47, you know, 49, you know, 50, whatever.

If I knew the ASCII codes for the characters,

fortunately, I don’t need to.

normally into the double quoted area but then i need to be able to put a null terminator at the

end of my string because it’s not going to happen automatically so then i am going to do comma zero

and you’ll end up with something like this like if i guess if we look at the previous example real

fast i’ll call this a hello string just so that you see some similarity from what we just looked

a notepad thing would just be typing the word hello and then putting comma zero.

So it is now a null terminated string and it looks just like this inside of system memory.

Well, not just like that.

There would be numbers where the letters are, but you know, that’s basically what we have created.

And then of course there’s junk data afterwards, but we don’t really care about that.

You know, we’re just going to ignore it with the null terminator.

So I’m going to erase that since we’re not just going to print the word hello.

We have a null terminated string here and then after we print the null terminated string

I’m just going to print out what was the length of the string.

So this is a prefix string where it’s just, you know, it’s a prettier program.

The program is going to say the null terminated string’s length was something.

And then we’re going to use the null terminated string printer to print that also.

Convenient, right?

And then I’m going to actually print the number.

Then we have this down here, crlf, which is just printing a new line in the terminal.

That’s character code 13 and then 10 and then a null terminator so that we can use the null terminated string printer again.

And then we’re going to use system call code 1 to print a standard output right here.

If you don’t understand that, then see my other videos.

But let’s move on to the text section where all our instructions will go.

Okay, so now the instructions begin in our text section right here.

section.text and I’m using an external symbol this video is not about this

library here but basically I have a library that will help me print integers

you don’t need to worry about that you could imagine well I guess in your

example when you’re practicing if you don’t have this library you could just

not print the length of the string and just use it only and it all should still

work or you could hard code the thing that you’re printing if you really

wanted to. Okay, so I’m just going to continue on here. Now let’s do our entry point. So again,

this is not a video about hybrid programs. Just assume that there is another module in my program.

It’s a C++ module. It’s got the main function, you know, for the entry point for a hybrid program,

and it’ll just call on my looper function. So that’s why I’m marking a looper as global.

So my other module can call it. And well, it is a function that needs to return. So I’m going to

to return so i’m going to put ret at the end of it and you can see here i left myself a note saying

i’m going to use r12 to remember the length of the string so that i can print it back to the user

so that means i have to preserve r12 for the caller because the abi or the application binary

interface says that r12 is a callie saved register and if you don’t respect the abi

the abi is not going to respect you your program is going to end up crashing eventually

So I’m just going to do a push pop pair to preserve R12.

Oops, prologue and call that epilogue.

Okay. So we got a push pop pair. We got a return statement.

This program should probably do nothing so far. So let’s run it and see,

just make sure that it at least compiles.

So I’m going to say clear and make run running the program.

Hello from the driver. You don’t know that the driver has that.

that the driver has that. This is not a driver video. And then the driver regains control because

nothing happened inside of the assembly module. We just basically looper got called and then we

preserved R12 and then restored it and then we did nothing. Okay, so now let’s make a call to

print null terminated string. We have to make another function for this, but right now this is

just the call. So the name of the function that we’re going to write is called print null terminated

it it will call on the string length function to figure out how long the string is then it will use

a simple system call to print the whole string giving the length to the system call it also takes

two arguments the first argument is a pointer to the null terminated string so that’s just that

symbol we defined up above remember when you define variables up in the data section then

these symbols tend to be pointers so that symbol is a pointer to the h basically or just the memory

that h is sitting in ram then the second argument that it wants is uh is where we’re going to print

it so we’re just going to print it to standard output um which is just file descriptor number one

so again if you don’t understand arguments or you know file descriptors or function calls

see my other videos because i’ve explained those already anyway so we’re going to call

print null terminated string then we’re going to call on crlf which will just print a new line

So now maybe we should implement, well, let’s copy paste crlf so that I can implement the

other function a little bit more slowly.

What does crlf do?

It literally just asks the print null terminated string function to just print a crlf for us.

So it’s very, very simple.

Here’s the signature.

Nothing much to it.

Okay.

Now, a little bit more complicated is the print null terminated string function.

So in our looper, we’re going to print the null terminated string.

We have to have a function that actually does that.

So that’s going to be this one right here.

Here’s the signature that I’ve chosen for my print null terminated string function.

Basically, I want to receive a character pointer to the first character in the string that we’re going to print.

And then a file handle designating where we’re going to print it.

The reason I want to receive the file handle is so I could print a standard output or standard error.

or standard error, or I could print to a file,

like whatever I want to do.

You don’t have to have that in there, but it’s nice.

Anyway, so we have this function set up.

Notice how my notes that I left for myself

is that I’m gonna use R12

to remember the incoming C string pointer argument,

and I’m gonna use R13 to remember the file handle.

Remember, it’s probably not a good idea

to just let the incoming arguments

stay in their original registers,

original registers because those registers tend to get overwritten as you do system calls or

calls to any other function. So I’m just going to grab them real fast into R12 and R13. And then R14

is the string’s length, which I’m going to compute with a call to the function called string length.

So just three things to remember. And that’s it. So that means I’m going to have to preserve those

Okay, so we’re going to do a prologue to preserve those registers.

And then at the very end, we’re going to do an epilogue where we restore those registers.

Oh, I think I already overwrote my return statement from the previous function.

I think I did that in the last video and I was a little confused as to what was wrong.

So make sure you don’t accidentally overwrite or push down your return instructions.

Let me just double check here.

Looper’s got return.

Print and alternated string has got a return.

string has got a return.

CRLF has a return.

What the heck did I do?

Oh, I think I copy pasted in a bizarre place.

That’s probably what happened because the epilog for for print null terminated

string is like down in CRLF already.

That’s not good.

Okay, that would have been a crashing program.

Although sometimes if you omit the return statements, execution will just fall

through down to the next label and maybe your program will survive accidentally.

accidentally but for now it’s just crlf is supposed to be very simple it doesn’t preserve

any registers so we’ve got a prologue and an epilogue here notice how the push and pops are

in reverse order you want to know more about that see my other videos but now that we are preserving

the appropriate registers we can actually grab our incoming arguments so first thing i’m going to do

is i’m going to say r12 is going to be the first argument that i received and then r13 is going to

okay no problem then let’s rely on the string length function to compute the actual length of

the string i didn’t feel like having print null terminated string compute the length of the

string it’s a good idea especially in assembly or any language when you have multiple distinct

jobs happening within the same function you probably want to break that function up into

multiple functions just to reduce you know strain on your brain right cognitive load

So I’m going to use this function strlen string length to compute the length of the string.

It’s only going to take one argument and it’s going to take the pointer to the null terminated

string which is now in R12. It’s going to take that as its first argument so that’s why I’m loading

that up into RDI. When string length returns it’s going to give me the length of the string in the

RAX register which is the usual return register for integer or pointer return types. So I’m just

So I’m just going to save that in R14.

And that’s the usage of all those registers R12, 13, and 14.

We still have to implement string length.

Don’t worry.

Although if you were linking a hybrid program, you could probably just call

STRLEN in the C libraries and be fine.

But this is an assembly video.

We want to do everything in assembly if we can, or at least more of it.

So then finally, when we know what the strings length is, we can just use a

system call to actually print the string we’re going to say load up call code one to say you

know mr. system I want you to print a string and then r13 is going to be the file handle so we’re

going to basically say wherever the caller of print null terminated string said to print which

is probably going to be standard output we’ll just tell the system we want to print to the same place

and then r12 is a pointer to the c string so we just give that to the system call as well

system call wants to know how long the string is that’s r14 now now that we have used strlen

to determine the length of the string so not really that complicated of a function we just

kind of like grab some arguments preserve those registers and we ask another function to compute

the length of the string and then we actually just print it once we have the length this is still not

getting to the point where we’re going to use our while loop knowledge to compute the length so i

That’s probably all I need right now.

And I think we’re ready to use or to start the string length function.

Okay, so now let’s make another function called string length.

Hopefully I’ll paste in the right spot this time.

You’re cringing at home.

That just tells me that you care.

So the string length function, at least the version that I’m making right now,

just is going to take one argument.

It’s going to be a character pointer to the string that you want to compute.

It will expect that the string has a null terminator at the end.

the end if you accidentally didn’t put a null terminator at the end of the string then this

function definitely won’t work it’ll probably give you some huge number because it’ll go through ram

until it accidentally finds a zero um and then it’s going to return to you as its return value

and uh assigned a 64-bit integer actually this should be unsigned but i’m just putting long for

now um to indicate the length of the string okay inside the notes we’re going to use r12 and r13

So that means I should probably preserve those registers first before I do anything else.

So in the prolog, we’re going to push R12 and R13 so that we don’t break this program

for others.

And then we’re going to do an epilog.

Whoops.

Then we’re going to do an epilog to restore the registers.

And this is a function.

So it’s got to return to the caller.

If I didn’t put a return statement here, then execution is going to just go all the way

down to CRLF.

And this will be an infinite loop.

and this will be an infinite loop because crlf will end up calling null terminated string,

which we’ll then call string length, which will then fall through to crlf,

so the whole program won’t even work if we don’t have return.

And, you know, you don’t want to omit return statements anyways,

because that’s always a bad idea.

So now string length will just not do anything right now.

Maybe we could return a fake value for a second before we start implementing the loop.

the number five into RAX so that string length will always trick the caller into thinking that

the length of the string is five let’s see if that actually works we should get a portion

of the null terminated string unless I screwed something up

hello from the main driver notice how it just says hello here that’s kind of confusing let’s

let’s hard code the five to like a nine we should see more of that null terminated string

I sound when I wake up sometimes hello okay so let’s finish the str len function so again you

should know how while loops work if you don’t see my other videos but we’re going to use a while

loop to count the length of the string so we’re going to start with a little portion up here

think the string is and a running pointer so rdi is already supposed to come in as a pointer to the

string that we’re measuring so i’m going to save um the pointer into r12 so that we can have a

pointer that points to a character we’re going to use this as a running pointer so it’s going to like

sweep through the whole entire string until it hits a null terminator and then r13 is going to

keep track of uh how big we think the string is so when we first start we’re just looking at the

first start we’re just looking at the first letter and then we think the string has zero length.

So that’s the initialization part which will not be repeated as we continue looping. Now we’re

going to implement the top of the loop. I don’t know should I should I write this out as c code

for you? I don’t know if I should maybe let me do it. I didn’t prepare this so if it’s slow sorry

Maybe this is like a long strln, something like that.

And then we’ll do if my code is wrong or doesn’t compile, I’m so sorry.

I did not, I did not prepare this.

We’ll say character pointer s and then we’ll say, uh, maybe we can actually just leave

s alone because it’s coming in as an argument and in C plus plus you can just continue to

use that symbol.

It’s not going to get destroyed.

So imagine we’ve saved it already into R 12 and then we just keep using it.

using it so we’ll say while a let’s say a dereferencing of s is not equal to zero meaning

if we look at the value that the pointer is currently pointing to if we assume it’s just

pointing to one byte is we’ll keep going as long as that value is not a zero so that means

if the user called this function and gave us a pointer that was already looking at a zero

we would just return whoops we would just return that the length was zero so

that means I should probably keep track of the length here size type actually

long just to just to match the return signature long we’ll put size equals zero

and then at the very end we’ll just return the size and so again if the user

gave us a pointer that pointed to a zero already nothing would happen inside the

while loop we’d break through it right away and we would just return the number

the number zero that makes sense so then as long as it is not pointing at a zero

we’ll just increase what we think the size is and then we will increase the

pointer we can use s plus plus in C++ that’s just pointer arithmetic that’s

just going to tell the pointer to advance you know one memory location

further or whatever the data type is but in this case the data type is a

character so it really is going to be one memory location one byte so we’re

going to sweep through the string until we see a zero and then we stop and every time we see a

character that’s not a zero we increase our our measured length of the string by one and then

advance the pointer. So I haven’t tested this I don’t know if there’s an error in it but I hope

you get the basic idea of what we’re going to do. So that means up here you know this is the

initialization part that we were just talking about so we just set the running pointer to look

okay so then after we do that we are going to make the top of the while loop

so at the top of the while loop where we evaluate you know like right here this

is the top of the while loop it has to have its own label just like we explained

in the other videos and it is basically where we decide if we’re going to keep

looping or not are we going to jump into the body the loop or are we going to do

a long jump after the body to say that we’re done so the top of the loop is a

label. We compare the value that R12 is currently pointing at. We say that we only want to look at

one byte. We dereference R12 because remember R12 is supposed to be a pointer. You put the

brackets around it, it’s going to go to the memory location and then check what the value is that

the pointer is pointing to. That’s what dereferencing is, right? So we’re just going to

compare the byte that we’re looking at with a zero and we’ll say if it is equal to a zero,

jump to the done this is actually kind of a poor design pattern on my part usually we should jump

if it’s not equal into the body meaning we’ll always take a short jump into the body and then

execution will fall through on the next line to a long jump which has the ability to jump further

out of the body i’ve said in other videos that the conditional branch instructions they can only jump

about 128 bytes so if your if your loop body is too big then they won’t work but it’ll work for

But it’ll work for this example.

I don’t know, maybe if I have the gumption, I will fix up the loop for you if you want

me to after I copy paste my existing solution.

So for now we’re going to say, all right, I’m not going to do it.

I’m not going to do that.

Maybe in another video, if somebody requested, I might post another video in like five years.

Anyway, so we’re going to jump if it is a null terminator to the done label.

Otherwise we will fall through to the loop’s body where we’re just literally going to increase the pointer and also increase our idea of how big the string is.

So remember R12 is the pointer.

Integer arithmetic doesn’t, sorry, pointer arithmetic doesn’t really work here, but it accidentally works here because we’re looking at a byte array.

So if we just increase by one memory location, it will literally just increase by one memory location and we’ll be fine.

Just keep in mind that if you were sweeping through an array of, you know, quad words or some larger data type,

then just a simple ink wouldn’t actually work.

You’d have to increase by the appropriate number of bytes.

But hey, the number of bytes in one item is just one byte, so it’s easy.

So we’re making the pointer go forward by one on line 134 and then in line 135.

line 135 we’re increasing our idea of how big the string is and then we will unconditionally jump

to the top of our loop and so if you just kind of look at this what did i do i pasted that twice

oh god okay sorry guess i lost track of what i was doing so then we will unconditionally jump

to the top of the loop so basically you can imagine this loop is gonna it’s just gonna

continue forever just moving the pointer and increasing the counter and moving the pointer

finally when it sees a zero a null terminator then it actually breaks to

the done label and the done label is just doesn’t really do much it’s just a

label to get us out of the loop so the top of the loop says if we are done then

just jump to the done area notice how that skips over the the top jump and then

of course under that is going to be the epilog and then we can we can take the

we can take the return value and set that up now because at this point R13 should contain

the actual length of the string. So if we move that into RAX respecting the ABI for return values,

then the caller should be able to get the string length just at that point by itself.

So let’s see, that might actually be the whole entire program already. Let me

double check here. All right, let’s run it and see if it actually works.

and then do a make run.

What’s up with those asterisks?

Did I put that in there?

Oh, I wonder.

Okay.

So the driver comes in,

it calls on our function,

and the whole null terminated string gets printed out.

It says, hello, this is an example

of our null terminated string.

Notice how it printed the full length of the string,

not any less,

and it also didn’t print more than the length of the string,

i.e. junk data,

because it knew exactly how long the string was.

was and this is way better than printing one character at a time in terms of efficiency we

just pre-compute the length and then print exactly that length and then we’re done i think there is

one more thing i wanted to do here let me see up at the top yeah okay let me go back up to the top

of the program here so in the looper function we called on print null terminated string and we

didn’t do anything else so what i would like to do is just make an explicit call to string length

explicit call to string length inside of the lubr function just to get the length of the

null terminated string so we can just print it to the caller or print it to the user

and then I’m going to use my special library function here actually just just for your

information notice how I’m calling string length just like the the print null terminated string

function did and I’m just giving it as an argument a pointer to that null terminated string so then

So now I can just print r12

Well not yet, I’m gonna print a prefix if you look at the prefix here, it’s just

The null terminated strings length was and then I’ll print a number after that

You do it this way, you know your program is more pretty it’s more

It’s more nice to the user and so forth so I’m going to do this

we’re printing a nice prefix, a hard-coded string to the user to let them know that I’m about to

show them the length of the string. And then I use my external function that just prints a number to

the user. Again, this video is not about this library. You can use some other library if you

want to print something, or you can omit that part if you don’t have one set up yet. But

so I’m going to tell, I’m going to do first argument is R12, which was the length of the

I’m going to call this function and say I would like you to print r12 which is the length of the string so

After that we’ll print a new line to make things a little bit tidier and then I think this program is actually finished

Run it again now it says here’s the null terminated string and then on the next line it just says

The null terminated strings length was that was the prefix and then when I called my library

the number it says 54. so i don’t know was it 54? let’s just double check to make sure that it

actually was 54. 54 should not include the null terminator so i’m going to go 1 2 3 4 5 6 7 8 9 10

1 2 3 4 5 6 7 9 20 1 2 3 5 6 7 9 30 1 2 3 5 6 7 9 9 30 1 2 3 5 6 7 9 9 50 51 52 53 54 was it 54? i can’t even remember anymore.

So we have basically proved that this works.

We have leveraged our knowledge of while loops to implement a string length function, which

will let us have a printing function that is very smart.

So we don’t have to hard code string lengths up at the top anymore.

As long as we’re working with null terminated strings, everything will just work out now

with less variables or less defines.

Okay.

Let’s see.

I think that’s pretty much everything that I wanted to talk to you about.

I don’t know. Could I do,

could I do this easy, easily?

Loop top.

Okay. Yeah. I think I could probably do this reasonably.

So at this point,

you are satisfied that you understand how to implement this and you’re happy just cut the

video the rest of this video is going to be me sort of like improvising trying to figure out if

i can rearrange the logic in a fast enough time for a video uh just to show you that you know you

should you should probably write your loops a little bit better than i did so here we go but

this is this is just redundant stuff so we have our loop here and we have our initialization

The loop top, it should compare R12 to 0 and it should break the loop if it is a 0.

So that means I’m going to comment out this.

And I’m going to do jump not equal to 0 to the body.

And I just need to make a label for the body here.

So I’m going to say str lane loop bottom.

So there’s a label, which is the body.

Maybe I’ll do a comment here just to remind us that this is actually the body.

I guess I’ll do another comment right here.

So that’s the loop’s body.

So I’m going to say if R12 is not a null terminator, jump into the loop’s body.

Otherwise, we fall through to the next instruction,

and that will just be an unconditional jump to the done area.

Okay, and then when we’re inside the loop’s body, we’ll jump back up to the top.

I don’t know why I thought this was going to be hard.

Let me run this to make sure I didn’t break the program.

Yeah, it still works.

Okay.

I guess I overestimated the difficulty there.

The point being, the body is a lot closer to the top of the loop.

So that should be the thing that does a conditional branch.

You should conditionally branch to the body because it’s a shorter jump and therefore

much less likely to be out of bounds of that 128 conditional jump bite restriction.

And then when we fall through to the next line, because we did not do that jump,

because we did not do that jump then we’ll do an unconditional jump to the done area and you know

our loop is small so it didn’t really matter the first time we did this but um again imagine your

loop is huge that you definitely want an unconditional jump that goes to the done area

at that point and that’s also what we’re doing an unconditional jump to the top here when we get to

the end of the body so when you’re jumping large uh you know spans you want to use unconditional

Alright, so I guess that’s it.

I’m going to erase maybe this comment.

Well, I’ll leave that in there just for posterity.

And now I will officially say that I hope you had a good time watching this video.

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

I will see you in the next video.

I’m going to go play some video games.

Maybe I’m going to eat some soup first.

Hey everybody.

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

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,

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 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, as I fade into the darkness, which is coming for us all.

Thank you.

The post Implement strlen for Null-Terminated Strings in x86-64 Assembly (YASM) 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.