reverse engineering Archives - NeuralLantern.com

x86-64 Assembly: Local Variables, Stack Frames & Alignment Explained

mike — Mon, 16 Mar 2026 06:39:32 +0000

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

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

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

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

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.

Implement strlen for Null-Terminated Strings in x86-64 Assembly (YASM)

mike — Sun, 08 Feb 2026 01:59:27 +0000

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.

Learn Conditional Branching in x86-64 Assembly (YASM/NASM) – CMP, JE, JNE, JL, JG & More

mike — Sun, 18 Jan 2026 00:49:38 +0000

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

We cover:

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

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

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

Enjoy learning assembly!

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there. In this video,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Anyway, so conditional control instructions in my last video

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

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

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

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

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

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

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

conditional branching instruction or a conditional jump instruction there’s

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

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

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

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

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

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

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

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

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

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

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

Let me show you a few of those.

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

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

We do CMP followed by two operands.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So keep this in mind.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I guess we’re done anyway.

So keep that in mind.

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

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

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

Okay, so let’s see.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So now here’s our entry point. Again,

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

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

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

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

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

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

Let me get rid of that load.

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

I think I put it in there on an early example

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

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

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

But if you’re writing a pure assembly module,

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

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

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

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

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

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

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

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

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

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

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

The ABI says that R12 is a Kali saved register.

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

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

book calls the prologue.

I do that now though too.

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

So we have prologue and epilogue.

We can have a push-pop pair.

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

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

out a message.

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

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

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

So let me say clear and make run.

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

elsewhere and we get that welcome message that says begin

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

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

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

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

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

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

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

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

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

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

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

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

And we’re going to store it in R12.

So that’s why I had to preserve R12,

because I’m actually going to start,

you know, messing with the value of R12 now.

Okay, so we ask for a number,

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

If we run the program again,

it’s just asking for a number,

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

and then the program ends, nothing actually happens.

We’re building, we’re building.

So now let’s ask ourselves,

is the number greater than zero?

So let me copy paste some code here.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

And otherwise, if R12 is, sorry,

I said less than or equal to, yeah,

if R12 is greater than zero,

then we jump to this other thing,

which is gonna be the fall through.

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

I’ll say fall for fall through.

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

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

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

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

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

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

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

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

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

usually the compare instruction and the conditional jump or branching instructions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

We’re just going to simply say goodbye.

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

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

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

or equal to zero.

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

the control path is just going to fall through.

So that means we will actually execute these.

And then when they’re done,

execution will continue to fall through to the rest.

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

their number was greater than zero or not,

based on whether their number actually was greater than zero.

Okay, hopefully I explained that somewhat clearly.

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

Hopefully I didn’t forget anything.

This is kind of a partial program at this point.

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

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

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

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

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

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

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

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

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

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

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

Okay.

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

So okay.

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

Okay.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

10.

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

the rest of the instructions.

We’re going to exit the program.

We’re going to say goodbye.

We’re going to do whatever.

Okay.

So say there never was less than 10.

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

Let’s see if this works.

Make run.

So we’ll enter five.

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

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

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

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

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

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

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

you know, whatever you want it to do.

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

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

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

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

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

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

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

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

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

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

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

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

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

and eventually fall through to the return statement.

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

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

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

greater than zero and less than 10

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So, you know JMP the regular jump instruction

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

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

It doesn’t really matter.

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

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

then you can overcome that limitation.

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

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

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

We solved the jump out of range error.

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

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

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

and all that stuff.

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

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

i’ll see you in the next video

hey everybody thanks for watching this video again from the bottom of my heart i really appreciate it

i do hope you did learn something and have some fun uh if you could do me a please a small little

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

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

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

So please do me a kindness and subscribe.

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

or followed it just wakes me up and I get filled with joy that’s exactly what

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

you control me if you want to just wake me up in the middle of the night just

subscribe and then I’ll just wake up I promise that’s what will happen also if

you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named

somewhere at the bottom of this video and it’ll take you to my main website

where you can just kind of like see all the videos I published and the

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

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

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

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

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

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

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

Thank you.

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

Yasm x86-64 Assembly: Instruction Formats, Operands, MOV, ADD, Memory & Registers Explained

mike — Sun, 02 Nov 2025 12:20:23 +0000

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

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

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

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

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

Assembly #x86_64 #Yasm #LowLevel

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

Thanks for watching!

Find us on other social media here:

https://www.NeuralLantern.com/social

Please help support us!

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

Hey there! Let’s talk about instruction formats in Yasm Assembly.

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

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

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

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

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

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

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

We could actually put other types of operands there.

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

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

So think about instructions as following this sort of format.

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

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

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

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

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

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

One or more operands up to three actually.

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

operand three and most instructions will follow this format.

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

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

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

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

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

And then this is the second operand.

There’s not three operands in this instruction.

Other instructions have three operands.

The way it works with the move instruction,

I hope you understand already at this point,

is that operand two gets placed into operand one.

So when this instruction is finished,

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

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

Some instructions allow you to put immediates,

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

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

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

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

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

The text section is for your instructions.

In the data section, we could say some variable

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

and put like a big giant number inside of there.

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

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

So then what we can do is basically say,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

it will dereference the pointer for me

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

Hopefully that makes sense.

Okay, so we got pointers, dereference pointers,

immediates and registers.

That actually went by pretty fast.

I thought this was gonna be a long video.

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

the Ubuntu coding book.

Let’s see.

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

because I wanted to get something with three operands.

So let’s do an instruction with three operands.

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

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

I could say let’s load the value of, you know what, let’s do this first with only two.

Yeah, because that’ll be more fun.

Let’s do RDI and RSI.

Okay, so this is legal.

You can have an instruction named add that uses either two or three operands.

A lot of instructions do that.

Usually in the two operand format, what they’re saying is,

let’s do something with both of these values and then store the result

of doing something in the first register.

So for example, it’s going to take RDI and add it with RSI,

assuming two’s complement integers.

store the result of that addition inside of RDI. So if you think about it, it’s faster to type,

but sometimes it might destroy data if you didn’t actually expect to modify RDI.

If you wanted to store the result somewhere else, but still add RDI and RSI somewhere,

then that wouldn’t work. So let’s do the three operand format, operand two, operand three.

So now let’s say that we wanted to store in some other register without destroying

RDI after we do the addition. So we can use the three operand format. Maybe I’ll

hit space here a couple times just to make it a little more interesting. I

guess I probably should have formatted the comment. Let me try to… No I guess I

can’t. I don’t need to space it out. Well I could. I could anyway. So we’ll use the

add instruction which is totally valid to use for three operands in addition to

two operands. And what will happen now is it’ll take RDI and add it to RSI

and add it to RSI and store the result in R11 in case you wanted to preserve the value of RDI and

RSI. Lots and lots of different instructions with lots and lots of different things that you can do.

Of course, we could put a memory location there. We could put like an immediate somewhere.

But let me go to my favorite book here. Whoops, I already have it highlighted on the right section.

x86 64 assembly language programming with Ubuntu by a brilliant doctor and I

use his book all the time I’m not gonna say his name because I don’t want to

accidentally mispronounce it I’m pretty sure I know how but I don’t even want to

try because I suck at pronouncing things I’ve pronounced my own name wrong on

many occasion so let’s see I’m gonna click on section 7 the instruction set

the instruction set overview and basically you know it kind of goes over the fact that oh you

know we can put registers as operands and we can do some certain things like if you see this

notation it means you can put a register as an operand if you see this notation it means that’s

going to be the source operand if you put if you see this notation it means you can put an immediate

at that spot so the book just kind of tells you what to expect in terms of notation then if you

go down it starts explaining a bunch of different instructions for example the move instruction

instructions. For example, the move instruction that we’ve just been working with. Notice how it

tells you the source is on the right, the destination is on the left. And if we are taking

from a memory location, which I probably should have mentioned, let me see, did I mention that?

No, I don’t think I did. If we’re taking from a memory location, it’s important to understand that

the data size of the memory locations data and the register might actually be different. See,

different. See here we kind of made a bad assumption. We made the assumption that RDI

was a 64-bit register. That’s a good assumption. But then we also made the assumption that sitting

at that pointer is eight bytes of memory. That’s a bad assumption. Up at the top, we know that

when we put DQ for data quad word, then eight bytes are going to get allocated. But by the time we

But by the time we get down to this instruction, you know assembly is not very smart.

By the time we get down to this instruction, we can’t be sure if that pointer refers to

something that is 8 bytes or 4 bytes or 2 bytes.

We should be able to support loading a number.

Like just as an example, I could lower this number, like let’s say with the number 25,

but you know that the number 25 will fit into just a single byte.

It’ll also fit into a word, 2 bytes.

32 bit number, a D word, you know, four bytes.

It’ll also fit into a quad word, 64 bits, eight bytes.

So it’ll fit in different sizes of data.

So what if you have a memory allocation,

like instead of putting DQ,

what if we put DB for just data byte?

So just like one byte of memory to put that 25 in,

that should work.

But the point is this part of the code

doesn’t actually know how big the memory location is.

So it doesn’t know how many bytes to grab.

many bytes to grab like what if we what if it just assumed that because we used a 64-bit register

actually let’s go back up here let’s change this to a byte data byte so we know that the 25 occupies

only one byte but here if we were unlucky then the assembler might assume oh they want to load

eight bytes of memory interpreted as a number and then put that into a 64-bit register an eight

But that probably wouldn’t work because we only actually modified one byte to make that 25.

So there’s going to be seven other bytes of junk data.

So now we just loaded RDI with some sort of a nonsense value.

And even if it does work, it might not work on every run of the program.

So then you have something which is probably undefined behavior,

where it’s just like you made a bad mistake and your program’s going to work sometimes

and maybe some other times not work.

So how do we fix this?

So how do we fix this? We just specify the size of the memory location or of

the bytes that we’re going to grab at that memory location. So if I just put

the word byte in front, now the assembler knows that I only want to grab

one byte and interpret that as a number and then put that into RDI rather than

all the extra junk data. So if I want to make sure that it understands that I want

eight bytes and also to prevent it from refusing to compile, which it’s probably

going to do if i don’t specify the size i’ll put q word to say yeah this 25 it’s uh it’s actually

a q word it occupies eight bytes so i want you to load up eight bytes in ram and interpret all

those bytes as just you know whatever numbers inside of them pretty sweet i love going to this

book because i was going to forget to say that anyway just so you know there’s a bunch of

instructions that you can look up i’m not going to go through all of them but um you know typically

Leftmost operand in some sort of a modifying instruction is going to be the destination

And if you have a two operand instruction, it’s probably going to take both operands

and do something with them and then stick the result in the first operand.

And then if you have a three operand instruction, it’s probably going to take the rightmost

two operands, do something with them, store the result in the leftmost operand.

wonderful, wonderful book will tell you exactly what to expect for every type of instruction.

So there’s like move here, integer arithmetic. Oh yeah, there’s the add function or sorry,

the add instruction. And then here’s like a bunch of sample code, which is awesome.

And notice how here, if we want to increase something that is located at a memory location,

we got to specify the size of the memory. Again, same problem that we just talked about up above.

Did we do that at the beginning?

I don’t remember if we did that.

You know, if we have something where it’s like,

if we said increase the RAX register,

the computer knows that RAX is a 64-bit register

because the way we typed it, RAX, that implies 64 bits.

If we meant to only use 32 bits of the register,

we would type a different, you know,

set of letters to represent that register.

But if we say, I would like you to increase

the value sitting in memory at some variable,

sitting in memory at some variable dereferenced, well then whoops,

it doesn’t actually know how many bytes.

If you increase a small

value, like if it’s if you have one byte and you try to increase it,

what if it overflows?

Like, for example, if we had a one byte, if we had one byte of data here

and we had the number, let’s say 255 already, that’s the highest value that a

So if we then say let’s increase that,

the computer is going to, you know, like overflow back down to just zero or not.

What if it actually was a quad word?

The computer didn’t understand whether it’s supposed to overflow or not overflow.

Do you see what I’m saying?

There’s lots of problems that can happen if you don’t know the size.

So that just means we have to specify the size.

Anytime we’re dealing with memory, we’ll say we’ll increase a keyword sitting at some

variable. And of course, if you’re going to

and of course if you’re gonna i don’t know why you’d want to do this but if you wanted to well

i guess if you’re running through a string if you wanted to increase a pointer value uh then i think

you don’t have to specify the data size although i’m not actually sure if you can change the value

of that pointer i don’t know if it’s hard coded usually what i do is i would just move you know

some kind of a i would move the pointer if we’re if we’re using a running pointer to run through

I would load the pointers value into a register and then I would just start increasing the

way slower to constantly be hitting memory.

Anytime you can possibly keep all of your calculations and algorithms and stuff inside

of only registers as long as possible, then your program will be way, way faster.

So if you’re going to run through a bunch of data with a pointer, probably want to load

it up into a register first and then keep increasing the register.

When you finally figure out, you know, everything that’s calculated and finished,

then go ahead and save it back to memory at the very end.

But just to let you know, we’ve got lots of stuff.

Okay, so there’s the add function.

This is the two op version.

You can see at the top there.

Let’s see, where’s the three op version?

Here’s somebody honking the horn outside.

Someone’s upset with someone else.

Someone’s upset.

Someone’s upset. Do you ever honk the horn not angry, but just so that the other driver will think you’re angry and

Then possibly be a good driver or a better driver later on in their life. I don’t know if that actually works. I have tried it

And you do your eyebrows like this

Even though you’re not upset

I wonder if they just go home laughing and they’re like, yeah, you’re right. I was ridiculous

Okay, so I guess I’m gonna stop scrolling

A good coder always reads the documentation and studies ahead and things like that

I know you were hoping for me to tell you everything in this video, but there’s just not enough time or energy to do that

I just wanted you to understand

How how to how to interpret instruction formats?

I wanted to make that part easy for you

but all the different instructions that are available to you to multiply to add to increase values to do all this stuff

It’s all in this nice wonderful book

okay anyway I think I’m gonna cut the video I hope you enjoyed what you have

learned I hope you have learned a lot of stuff and had a little bit of fun there

and I’ll see you in the next video hey everybody thanks for watching this video

again from the bottom of my heart I really appreciate it I do hope you did

learn something and have some fun if you could do me a please a small little

favor could you please subscribe and follow this channel or these videos or

or whatever it is you do on the current social media website that you’re looking at right now.

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

So we’ll be able to do more videos, longer videos, better videos,

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

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night

and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

every single time so you could do it as a nice favor to me or you could you control me if you

want to just wake me up in the middle of the night just subscribe and then i’ll i’ll just wake up i

promise that’s what will happen also uh if you look at the middle of the screen right now you

should see a qr code which you can scan in order to go to the website which i think is also named

somewhere at the bottom of this video and it’ll take you to my main website where you can just

kind of like see all the videos i published and the services and tutorials and things that i offer

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

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

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

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

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

Thank you.

The post Yasm x86-64 Assembly: Instruction Formats, Operands, MOV, ADD, Memory & Registers Explained appeared first on NeuralLantern.com.