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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hello there.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

overloading functionality so we’re basically going to disable overload

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

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

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

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

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

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

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

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

I guess a non-mangled way.

Mangled meaning name mangling.

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

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

different languages.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I’m going to call it my CPP function.

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

just some nonsense arguments.

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

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

And then just return a value to the caller.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So we have to actually write that somewhere.

It’s not in the driver.

Let’s write it inside of assembly.

So my assembly function is going to start right here.

Boom, right there.

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

So for starters, hopefully you understand labels.

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

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

sort of like a variable name.

You can’t use every symbol available.

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

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

not just type something and see if it compiles.

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

So that’s a label.

You can jump into labels.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

let me just show you real fast.

I’ll say some other function.

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

And then the label.

So now it’s being treated like a function.

it’s being treated like a function.

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

that would have been executed.

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

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

push that onto the call stack.

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

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

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

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

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

to return from there.

And then now we can actually call it a function.

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

the program.

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

Oh, I think I forgot to update that.

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

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

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

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

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

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

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

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

But basically we’re going to use those registers.

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

Respect the ABI.

The ABI stands for the Application Binary Interface.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

because it happens before the function does anything.

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

because you have to be careful with the stack.

If you just start pushing values

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

by the time you return,

you’ve basically broken the program.

It’s either going to crash right away

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

So let’s do some pops.

We’re going to do three pops

and we’ll call this the epilogue,

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

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

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

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

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

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

So just keep that in mind.

OK, so now the ABI is being respected.

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

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

Yeah, I think we could probably this might compile.

OK, let me let me just check this out.

I want to say clear and make run.

Yeah, it compiles.

OK, so the driver printed its hello message.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Okay, so that’s the basic idea.

So now let’s maybe let me pin this.

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

So the first thing that we should do

is we should save our integer or pointer arguments.

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

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

And well, I guess, you know,

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

but I’ll just make another comment here.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Let me see if this works.

I’m going to go make run.

Okay.

So nothing happens, but it at least worked.

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

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

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

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

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

now.

What is print null terminated string?

It’s just another convenience function that I wrote.

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

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

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

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

output or standard error.

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

string?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So now we should see two numbers. Yeah.

Now printing all integer arguments,

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

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

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

the driver called the assembly module with these numbers.

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

it gave it the 287 giant number. So great.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So we’ve done that.

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

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

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

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

do anything.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

received as an argument.

It’s what this function expects as an argument.

This function only takes one argument.

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

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

line.

Okay.

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

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

Right?

99, that’s the first one.

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

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

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

Pretty slick, what do you think?

Anyway, so we’ve done that.

And the next thing that we should probably do is…

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

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

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

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

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

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

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

I want to put this one right here.

It’s the my CPP function function.

So if we look back at the driver

and look at the signature for my CPP function,

whoops, it has this signature.

And if you wanted to look up higher,

you totally can just look into the name mangling section.

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

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

and a character pointer.

Basically the same thing as the other one,

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

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

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

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

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

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

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

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

Okay.

So we’re going to call myCPP function,

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

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

it’ll probably do some sort of nonsense.

Let’s actually see what happens right now.

If we don’t load up the appropriate registers,

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

Let’s see what happens.

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

This would probably be something called undefined behavior,

meaning you did something wrong,

and probably sometimes your program will work,

and sometimes it won’t.

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

So I’m going to do this right now,

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

Okay.

Why did it segfault?

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

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

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

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

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

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

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

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

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

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

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

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

So E is supposed to be a character pointer.

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

And I’ll just say memory.

And then we’ll do a static cast.

Oh, I wonder if this will actually change anything.

I wonder.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

corresponds to the first float argument.

That’s why it’s XMM zero.

And then the float send D corresponds

to the second argument.

That’s why it’s XMM one.

And that’s the D right here.

And there’s no other floats.

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

the float send B and D,

I just defined those arbitrarily

to just these two random numbers.

So we should see like a two one nine

and then a nine nine eight eight seven seven six

sort of, you know, weird number.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

point number.

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

which I defined up above.

So let me scroll up real fast.

So where is that?

Where is that?

Float got return value.

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

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

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

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

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

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

return the double to us inside of XMM0.

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

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

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

Let’s get that far real fast.

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

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

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

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

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

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

move the float value back into XMM0.

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

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

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

or any of the system calls that it uses.

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

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

So that’s not good.

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

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

And it wants the float as argument zero.

So we’re just sticking into XMM zero.

And then we’re printing a new line.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So let’s do this.

Everything seems to be working.

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

the stack, the return address, prologue and epilog,

pushing and popping, respecting the ABI.

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

int or pointer return types and float return types.

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

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

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

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

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

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

appreciate it. I do hope you did learn something and have some fun. If you could do me a please,

a small little favor, could you please subscribe and follow this channel or these videos or whatever

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

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

videos, better videos, or just I’ll be able to keep making videos in general. So please do me a

kindness and subscribe. You know, sometimes I’m sleeping in the middle of the night and I just

wake up because I know somebody subscribed or followed. It just wakes me up and I get filled

with joy. That’s exactly what happens every single time. So you could do it as a nice favor to me or

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

and then I’ll just wake up. I promise that’s what will happen. Also, if you look at the middle of

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

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

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

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

and tutorials and things that I offer and all that good stuff and if you have

a suggestion for clarifications or errata or just future videos that you

comment or if you just want to say hey what’s up what’s going on you know just send me a comment

whatever i also wake up for those in the middle of the night i get i wake up in a cold sweat and i’m

like it would really it really mean the world to me i would really appreciate it so again thank you

so much for watching this video and um enjoy the cool music as as i fade into the darkness

which is coming for us all

Thank you.

The post YASM x86-64 Assembly Functions Tutorial – Integers, Floats, Pointers, ABI, C++ Interoperability appeared first on NeuralLantern.com.

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

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

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

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

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

in an x8664 assembly program written in YASM.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

We could also have a pointer, int pointer p,

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

And then, you know, later in your function,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

eventually these functions start returning right oops how come my greens

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

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

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

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

And you can imagine it as B subscript 1.

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

So we can imagine this as B subscript 2.

So these are two totally different Bs.

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

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

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

The stack allows us to do this.

So what is the stack itself?

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

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

Imagine a data structure that kind of grows upward.

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

And when you put an item onto the stack,

the items kind of stack on top of each other.

So imagine that this is the call to F.

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

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

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

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

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

We got to do B and C and the array.

I’ll put AR for array.

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

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

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

And then eventually F is called again.

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

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

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

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

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

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

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

And I just want you to know.

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

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

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

than what I drew up.

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

not necessarily deallocated, but ignored.

We’ll just say that they’re gone.

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

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

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

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

that we have available.

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

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

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

Rsp, to point to that other piece of data.

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

but we just ignore them, right?

So that’s how the stack works.

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

Something to note.

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

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

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

of memory locations.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Again, this is a hybrid program,

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

which is pretty cool.

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

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

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

which I’ve named local underscore varrs.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Clear and make run.

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

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

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

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

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

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

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

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

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

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

Let’s go right after the welcome module.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

We’ll move

The stack pointer into the base pointer

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

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

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

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

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

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

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

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

Let’s see.

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

Then we’re restoring its value at the bottom.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

It’s impossible that there is literally nothing at some memory location,

unless you’re trying to go beyond your RAM stick. But then the system will still acknowledge that,

you know, you’ve done that and it won’t just give you back nothing if you try to read

nothing if you try to read.

So there’s going to be junk data sitting on there and then we’ll loop

through all those slots on the stack and we’ll just modify the data one by one

so that we can control what it is instead of just printing whatever junk data we end

up with.

So really, we’re just moving the stack pointer, just making room and then just

remembering where our array is.

We could put, you know, another frame on top if we wanted to make just like one

integer as a local variable.

You just got to remember where it is.

You know, what is it?

What is its offset?

is it what is its offset okay so i’m going to erase this because we’re going to do a lot more than

than five uh integers on the stack but i just want you to understand what we’re doing before we do it

okay so the next thing i’m going to grab is a move instruction and i’m going to put it right here so

to move the stack pointer rsp so the first thing i’m going to do is i’m going to use a temporary

register we don’t need to preserve this in the push and pop because it’s marked as temp so we’re

not responsible for preserving it and so i’m going to say r10 is just going to be the number of

integers that we want to create if you recall at the top of our program here num integers is just

50 okay so then the next thing that i’m going to grab is well i’m not going to grab it i’m going

it I’m going to straight multiply by integer size so again if you look at integer size that’s going

to be eight because we’re using quad words for our integers so we’re really just going to take

50 times 8 whatever number that is is that 400 tell me in the comments if that’s a right or wrong

and so uh you may or may not know if you don’t see more videos see more textbooks you may or may not

instruction just multiplies two numbers.

If you use the three operand format,

then the last two operands get multiplied

and the results stored in the first operand.

But if we use the two operand format like I’ve done here,

then both of those operands get multiplied

and then the result gets stored in the first operand.

So basically at this point,

R10 should hold the number of memory locations

that we should move the stack pointer

in order to make room for all those integers

like I showed you a second ago.

showed you a second ago. So then we’re going to move the stack pointer.

And maybe I’ll leave a little comment here. Remember, the stack grows downward

in memory. And so all I’m doing is subtracting the stack pointer. Remember the stack pointer

register, it just holds a number, which is a memory location. So if you subtract some numbers

from it, you’re really having it go downward in memory. And that’s what we want to do

memory and that’s what we want to do to you know grow the stack for a local variable so I’m going

to say well I should also say that we’re using the two operand version so just like I’m all if we

had the three operand version then the last two operands would have one subtracted from the other

and the result will be stored in the first one but since I’m using the two operand version

basically it’s taking RSP minus R10 and then storing it in RSP so this this instruction just

this instruction just says let’s move the stack pointer downward in memory

enough times that we have room for all of our integers okay no problem next thing that we’re

going to do is um we’re going to move r12 we’re going to move into r12 the current value of rsp

word in memory right less okay so the first integer you know it’s up to you

how you style this because once we do the subtraction then RSP is actually

going to be pointing towards an integer you could consider that to be the first

integer or the last integer because all we have is an array of integers so you

you know rsp wherever it’s sitting when we’re finished we could say that’s pointing to the

first integer or we could say it’s pointing to the last integer but um if we decide to say that it is

pointing to the let’s see yeah if we’re deciding that it points to the first integer let me just do

a little comment here first integer it just makes it a little bit easier for me to write our loop

You could start by pointing to the one that RSP is pointing to,

or you could start by pointing to the other one that was like the first one that you added onto the stack.

You could call either one of those the first integer, as long as you remember where you started.

So you can increase or decrease the memory location to get to the next integer.

So I’m just going to do it in this style.

But keep in mind, as long as the only thing that you modify and read is within that range, it’s okay.

So let’s remember where is RSP.

So that’s like the top of the stack.

We’re going to say R12 holds the stack pointer so that we can use R12 as sort of a running

pointer.

I think that’s the way I’m going to use it.

Let me just double check my solution.

Yeah.

Okay.

a calculation where we remember where the last integer is so we know where the first integer

we’re just going to call this the first integer i’ll put it in quotes just to remind you that

this is just the style i happen to be using so here we’re going to say that the first integer

is wherever rsp is pointing and then in r13 we’re going to remember where the other side of the

array is in this case we’re calling it the last integer and pretty much it’s just r12 which is

And then we add to it a memory location.

So remember we said before that the stack grows downward in memory.

So if we consider the top of the stack to be the first integer,

then that means previous items, maybe I should draw this,

are going to be increased memory locations.

So that’s kind of like the backwards of what you imagine a stack is doing,

but it’s kind of the way that I like it sometimes.

So imagine just in a very simple stack,

let’s pretend that the stack has one byte values,

one byte of values, which it doesn’t, but let’s pretend if you, if you do it,

I got to learn how to draw. I can’t get that five right. Okay. I’m defeated. So let’s pretend

that that address on the thing sitting at the bottom of the stack is five. So then that means

the next address would be four, right? But if we decided, let’s say that the, well, let’s do like

like a few more just to make it a little bit more interesting.

Let’s do a total of five.

So we’ll say four, three, two, one.

Maybe I should just add some numbers in front of those values.

So it doesn’t feel like we’re hitting zero.

But so just pretend we have a memory location of 15.

That’s not going to be the case in real life.

Pretend that we have one byte integers on the stack, which is not going to be the case.

We’re going to have quad words.

But you can see the memory locations go downward, right?

to the stack pointer is pointing to the topmost location we have to remember that anything up here

might exist in system ram but it’s not considered valid data because we didn’t

you know make it part of the stack by by growing the stack pointer so that means uh these

these items well maybe i’ll do a check instead of an x because x looks bad i’ll do a check

check and a check and a check and a check these items are okay to use so if I have

RSP or in this case we just remembered where RSP was by storing r12 if we have

that memory location 11 and we want to get an additional integer like somewhere

else like the next integer well that would be you know this one down here we

wouldn’t go in the other direction we wouldn’t go you know up we would just go

know up we would just go down in the stack but down visually is actually growing upwards in memory

because remember when we grow upwards visually we’re growing downward in memory so and you can

see here too if we’re if we’re increasing 11 to 12 that means we’re adding memory locations to get

to the next uh integer that we have in the stack so that’s why here my green is just like frustrating

fix this yeah so that’s why here we’re adding a little formula instead of subtracting because

the rsp started there we’re saying that the top of the stack is the first integer

just so we can add in a more convenient nice way so what are we adding to it we’re just adding to it

the number of integers minus one and then so that’s that’s the number of slots that

size. So if you imagine, you know, if we had 10 integers, then, you know, 10 minus one is nine

slots. So if you imagine that zero is the first integer, let’s say the memory location again,

then that means one, two, three, four, five, six, seven, eight, nine, 10 minus one is nine. So if we

added the number of integers minus one from the start, which we’ll consider zero here, that means

directly so that’s just like a little math because sometimes when you when you

think of adding two numbers together or taking the difference or including the

first number or not including the first number it’s a little confusing right so

keep in mind for this particular calculation we are adding to it the

number of integers minus one so that will be sitting on the last integer

rather than going past it so start with the first integers memory location and

the number of integers minus one or size minus one times the integer size,

because remember, every integer is going to be eight bytes.

And that will give us the memory location of the last integer in R13.

And then I’ve said this in other videos,

but basically you’re only allowed to make these sorts of calculations in Yasm

when you have the calculation inside of brackets,

but brackets will automatically dereference the value on the inside.

It’ll consider it as a pointer that needs to be dereferenced,

but we don’t want to dereference anything.

anything we don’t want to go to a memory location and take a value the memory location is the value

so these dereferencing brackets which are required for the formula are kind of bad so that’s why we

use the lea instruction instead of the move instruction if i put move there it would

definitely dereference the memory location and give me a value in r13 so r13 wouldn’t actually

be a pointer it would just be the value of the junk data of the last integer keep that in mind

keep that in mind okay so uh where’s RSP so we got that so now let’s do a loop

I’m gonna start off with a label called demo loop init so for me personally when

I’m looping you know I like to make my labels inside of my loops start with a

prefix that matches the function so it’s like demo and then everything else is

gonna be demo underscore something so uh init loop init I’m gonna make a loop

to make a loop where i initialize the values of the array so i’m calling this loop the init loop

and then the last part is just like this is the initialization part of the loop this is where we

sort of like set up the initial values to loop so we have r12 and 13 that point to the first

and last integers now we’re going to set up r14 and 15 where r14 is the running pointer i think

before i might have accidentally said that r13 is the running pointer it just points to the last

it just points to the last integer but if you look back up at my comments r14 is the running pointer

to the current integer what is a running pointer it’s just a pointer that runs it’s just a pointer

that just keeps increasing so we can look at different data values so i’m going to start it

by looking at the first integer so now r14 is pointing to the first integer and then r15 is

going to be the value that i want to put into that position in the array so like the first integer

integer I want to put some kind of a starting value into it you can put the

number zero or whatever you want I just wanted to have a start value so that it

sort of looks more like I’m putting data and less like I have a loop counter so

remember the integer start value up here is just seven so I’m just going to start

at the number seven and now I’m done initializing my loop then the next thing

I’m going to add is the top of my loop so you can imagine this as the top of a

top of a while loop where you start comparing some sort of an expression maybe i’ll say uh

you know expr to say that we’re comparing some sort of an expression

and if that expression evaluates to true the loop continues if it evaluates to false

then the loop does not continue let’s see so i’m going to compare r14 with r13 inside of the

and 13 remember R14 is the running pointer and R13 is the last integer so basically I’m trying to

figure out am I looking at or like let’s compare the running pointer with the pointer of the last

integer then I’m going to say if the running pointer has a greater memory location than than

the last integer that means I’ve gone beyond the last integer and again the way I arranged the first

last integers just makes it easier for me to think of them as having increasing

memory locations so I’m going to jump if the running pointer has already

surpassed the last integer by saying let’s jump if it’s greater than so you

can imagine maybe in the expression here I should probably say while not

r14 is greater than r13 not a great expression but it’ll do so that’s what

up there at the top let me just put that into my notes too so that my notes match

the video okay so we are comparing and then we’re jumping to the end of the

loop if we end up you know going beyond the last integer so that labels not

created yet I’ll create that in a moment but pretty much that’s a label that’s

just going to be below the loop just to say like we’re finished with the loop

the loop body I like to put comments here to help myself remember oh this is

the part of the while loop that I’m currently inside of just makes things a

little bit easier to understand you know you put a block comment up top of every

label or every you know chunk of instructions just to let you know the

general idea and then you know sometimes you put comments also on the right side

to help you remember what each instruction is actually doing so then

what am I going to do here remember R14 is the running pointer if I D ref R14

ref r14 that means i want to move an actual value into that memory location rather than changing the

memory location that r14 points to so r15 is going to be the uh the integer that we want to

write into the array so all i’m doing here is i’m saying let’s take that value seven which is what

it starts as and just move it in to you know the ram stick at that memory location so i’m setting

seven right now then I’m going to increase our 15 so that means every time

we iterate the loop we should see that the value increases so the first integer

should be seven the second one should be eight next one should be nine and so

forth so just a simple loop where I’m just writing data into my array so now

that we’ve ended the loop body let’s write the bottom of the loop which is

just going to increase the running pointer and jump back up to the top and

And this is not necessarily the only style for translating while loops.

I’m just doing it.

And, you know, I’m going to make another video in the future where we talk about, you know, for loops and while loops and all that stuff.

But this video is just really about local variables on the stack.

So I’m not going to go over all the different ways you can do it.

Anyway, so R14 is the running pointer.

So I’m going to just make the running pointer jump to the next integer.

And we can do that by increasing its memory location by the size of one integer.

Again, this is another benefit of the first and last pointers that I chose at the beginning.

I can just increase to go to the next integer.

So we’re going to increase by 8 bytes to just go to the next integer.

If you increase by 1 byte, you’ll probably have a huge corrupted mess because you’re

messing with 8 byte integers but you’re only increasing by 1 byte.

And then after we increase, we’re just going to jump to the top of the loop.

So notice how I have a jump statement here.

It’s going to go just to loop top.

loop top. So now this part is here is basically just going to execute over and over and over again

until we finally scan through all of the integers in our array. So that’s the bottom of the loop.

And then I’ll make the label for the loop being done. It’s not really going to do anything

except just be done. And do you, you know, I don’t know, depending on your style, maybe you can let

drop through if the loop’s done rather than always jumping to the top but i’m just going to say when

we’re done we jump to the loop done label and therefore there’s no more looping of that

initialization loop okay so we got that done let me just run the program real fast to make sure

that i haven’t screwed it up we actually should not see anything right now oh what did i do

must have done something naughty maybe if i finish

uh this program then everything will be okay oh my gosh what did i even do

well i’ve got a working solution in the other window so hopefully when i paste all the extra

steps everything will be fine you never know subtract the stack pointer oh did i forget to

oh did i forget to restore something at the very end print body move the base pointer into the

RSP stack pointer oh yeah okay that’s definitely what you got that’s why I

crashed okay so um remember I said you got to be very careful about the stack

this is a great lesson so I did preserve the base pointer but I didn’t actually

preserve the stack pointer notice how right here I subtracted from the stack

pointer but I did not restore the stack pointer anywhere so that means I

corrupted the stack for anyone that called me and also for my return address

address. So I’m kind of trying to copy paste my instructions from top to bottom, but I think I’m

just going to copy paste something else to make sure that we can actually run this. So I’m going

to copy paste into the epilog a restoration of the stack pointer. And that’s why we saved the

stack pointer in the base pointer, just to remember where it was when we originally started our

function. So now on line 128, it should be restored and the program should work. Let me just double

yeah it worked okay nothing happened that we can see but it did write values

into the array now let’s do another loop where we just print the array so let’s

see loop in it done looping it bottom and looping it done okay so now there’s

like gonna be another loop here we’re gonna call this the print loop and so

the print loop is gonna be kind of the same pattern we’re just gonna loop

going to loop through all the integers in the array but instead of modifying them we’re just

going to print them so now you know the first thing we’ll do is we’ll set r12 we’ll store that

inside of r14 in order to start the loop at the first integer what was r14 again that was the

running pointer remember let’s see where is that yeah it was the running pointer so now we’re

resetting the r14 running pointer to the very beginning of the array and we know where the

thing we’ll do is we will set up the top of the loop and the body so I’m just

going to copy paste again this stuff right here

right there okay so the top of the loop we’re asking ourselves you know we’re

gonna compare I’m not gonna put all the extra while stuff that I put in the

previous loop because hopefully by now you understand loops a little bit better

and if we’re beyond the last integer because the running point of r14 is beyond the memory

location of r13 that means we’re totally done so we should jump if it’s greater than

now i feel bad let’s uh let’s put a comment in here on the top let’s go uh

basically that you know if uh keep going as long as r14 is not greater than r13 so if it is

in the body and in the body all i’m going to do is use r14 the running pointer to print uh you know

whatever value is sitting in that particular integer so how do we do that i’m just going to

use the printf statement or sorry the printf function which is provided by the c libraries

that’s why we’re doing you know a modular or a hybrid program with multiple modules and c linking

very quickly there is a function called printf which I can call it it takes multiple arguments

but the first two arguments that I can give it are the string that represents the formatting

that I want to print like I could do like a regular string message I could do tokens

to format some data inside of them and then the second argument is going to be the piece of data

that I actually want to use let me see if I can just type that up for you real fast

So, you know, the printf instruction, or sorry, this is not an instruction.

This is a function in C.

We would typically, you know, give it some kind of string.

The string should be null terminated, and it should have a new line at the very end of it

to make sure that printf actually flushes.

It won’t flush if you don’t have a new line, so the program will look really weird.

But I guess it’s more performant if you have a way to delay the flushing,

flushing and you know that you can flush it later at the very end but for now i’m just going to

flush every time and then every argument after that is some sort of you know data that we can

print so imagine we have a long and we’ll call it a and we’ll say that it has like some giant value

so that means we would give that long as the next argument the rsi argument and then for the string

what I’m using right here %lu so you can imagine instead of this string it is this

string right here whoops too many too many quotes it’s just this string right

here and then instead of a 10 13 that’s the same thing as just doing an or if

you want to be you know more of a windows windows person slash r slash n

it’s all good and the zero is not needed because the string if you put a string

literal it’s automatically going to be null terminated which means there’s just

null terminated which means there’s just a zero at the end of the string in memory so this is

basically what I’m doing I’m making a an integer in the case of the assembly program it’s going to

grab an integer from that position in the array that we’re looking at and it’s going to give it

as an argument and then the first argument is going to say let’s just print this as a unsigned

long so that’s why I have that string here let me search for it and go down a little bit again so

I’m saying first argument is this the format that I want to be printed second argument is the actual

is the actual value and then I’m gonna make a call to printf why do I have this

weird push and pop pair sitting around printf so this is not a video about

stack alignment in GCC but basically the GCC libraries expect that your stack is

aligned to I think 16 bytes but since we use 8 byte integers every single time we

address to the stack which is eight bytes and then every time we do one single push or pop

we’re modifying the alignment of the stack by eight bytes so if you think about it when we’re

programming in assembly for the most part the stack is going in and out of alignment because

every time we modify it by eight bytes it it might line up with a 16 byte alignment or it might not

it’s just kind of like oscillating right so when I first wrote this solution I wasn’t doing the

what happened oh actually maybe i guess i don’t need to jump to the top right now i don’t need

to finish the loop let’s see if this prints just one number well let me let me let me see if this

prints one number certainly and if it’s an okay assembly program just to print one number is it

going to work okay we got to do the done symbol okay so i’ll show you in a minute why we need

that for stack alignment but i guess i’ll just finish the loop so demo print loop done so we

just did print loop top and that means we need the bottom and the done so i’m just going to copy paste

into program here i’ll just say nada because we’re not really doing anything and then at the bottom

you know that’s the epilogue that’s separate from the the other label so basically now let me finish

know we already know the loops but I’ll just I’ll just say it at the bottom of

the loop we do the same thing that we did with the initialization loop we just

increase the running pointer you know we move it along to the next integer and

then we jump to the top of the loop that’s it and then the done label we

don’t really do anything we’re just letting execution drop through down to

that point so that the loop doesn’t continue so now we should be able to run

the program don’t get excited oh actually you know what get excited I

was gonna say don’t get excited because it was gonna totally work now but now

because it was going to totally work now,

but now I think we can just say that it’s going to crash.

So if I run it, notice how there’s a segpult.

So the GCC libraries, many functions expect your stack

to be aligned to 16 bytes.

So if you see mysterious crashes

and you are absolutely sure that you’re not ruining

the stack pointer or ruining something else,

you’re doing everything correctly,

but the program still crashes, it might be stack alignment.

So one way to get around stack alignment

is just to move the stack pointer.

move the stack pointer like at the top here we could have said oh we’ve got one two three four

five we’ve got five pushes and then here we’re moving the stack by I don’t know how many other

addresses the stack might be out of alignment somehow so we could add an extra push up here

and then add a corresponding pop down at the bottom like we could easily do this let me just

show you real fast we could push r15 twice for no reason I acknowledge and then at the bottom

and then at the bottom we pop R15 twice,

that would change the alignment because that’s one more 8 byte push.

But in my case, and actually that would be a little bit smarter

because if you have our loop where it’s constantly calling on printf,

this is a lot of hits to memory, right?

This is like 100 hits to memory because every single time we do a push-pop pair

around a call to printf, we’re like touching memory.

Whereas if I did it at the beginning and the end,

Maybe I should just do it this way.

I want to do it both ways so you understand, but it’s more efficient, I think, if we do

it this way.

Anyway, so we’ll do pop twice at the bottom and then push twice at the top.

And so then we don’t really need to surround it with a push-pop pair.

I think I haven’t tested this.

We’ll hope now that the stack is in alignment at all times in our functions so that it doesn’t

crash.

Yeah, so now see how the program works.

So I’m going to do it the other way now, which is the less efficient way, because here

now which is the less efficient way because here we just have one extra push

pop pair but if we do it the other way it’ll still work but we’ll be hitting

memory much more often so I’m just gonna do it this way just to show you you can

surround any call because sometimes in your programs you might have the stack

like you know modified throughout the function many different times so it

wouldn’t make too much sense for you to add an extra push pop pair in the prologue

and epilogue because that might not solve it for all of your calls to all of

to all of your seed library functions.

So in that case,

where you can’t really predict the stack well enough,

you can just surround your call with a push-pop pair.

It hits memory more, but it’ll work.

So this is basically, you can imagine,

by the time we get to line 139,

the stack is out of alignment.

So I just do a push that puts it into alignment.

And then after the call comes back,

I just pop it so it’s back out of alignment again,

but I don’t have extra erroneous data sitting on the stack.

Because if I only had push and not pop,

then it’s going to push it more and more out of alignment.

It’s going to push it in and out and in and out,

but it’s going to add a bunch of junk data to the stack

that I’ll never recover from.

Or actually, I guess I will recover at the very end

when I restore the stack pointer, but it’s pointless.

It’s going to consume too much memory.

What if I was writing like a billion

or like a million items on the stack, right?

a billion iterations of the loop would probably be a bad idea to start adding onto the stack

we’ll probably end up stack overflowing probably with far less than a billion items so anyway i’m

going to surround the call with the push pop pair and then at the bottom we just do the same thing

you know increase the integer and then go to the top and so now we you know you already can see it

it starts off printing well it starts off initializing the array but then the thing that we

can see starts off printing the first integer and then the next iteration of the loop prints the

second integer and the third and the fourth and so forth until we get all the way down just to

prove to you maybe we can increase it by two instead of one each time I’ll just modify that

Oh no, that’s the print loop. Let’s do the init loop.

Init loop bottom.

Oh, right there, when we’re in the body.

So I’m just going to increase R15 twice.

Just to show you, you know, we can kind of control what’s going inside of the local array.

So see how it goes from 7 to 9 to 11 instead of 7, 8, 9.

So I’m going to take that out and then just show you that we can control

how many integers we have in our local array with just the number of integers.

just the number of integers so I’m going to change the 50 to a 5 and run it again and you can see

what the dang did I do number of integers is 5 and then it was 50 did I put the stack out of

alignment no I I have a push put pair there number 50 is not hard-coded anywhere anywhere

there. Oh, I have a bug that I can debug. That’s nice. I guess the bug debugging is not for this

video. I wonder if some other value would work for that. There’s a number of things that could

be the problem. It could be like stack alignment somehow. It could also be, let’s see, am I making

any calls here inside of my function demo? I’m saying sub and LEA and then start and then jump

and start and then jump and increase and jump and then RDI.

Not really doing anything else.

So I don’t think it’s stack alignment.

I must have miscalculated somewhere somehow for changing that.

All right.

Well, if I figured it out, then I will release another video.

But basically, this is the idea.

100 works, 50 works.

What about 99?

Would that work?

Save faults on 99.

faults on 99 and then 98. 98 works so like every two seems to work but that is

two quad words or 16 oh right so like a hundred integers if we assume that

that’s in alignment then 99 would be eight bytes less that we’re moving the

98, notice how it is okay.

And then 97, it’s going to segfault again.

Watch.

This is a great stack alignment video, I guess.

96, it won’t segfault.

So it’s going in and out of alignment.

I think I figured it out.

So if we use the number 100, it’s in alignment.

Sorry, it’s out of alignment.

If we use the number 100, the program works because the number 100 throws it out of alignment.

number 100 throws it out of alignment but then we have this push pop pair here around the call to

printf which puts it back in alignment so if I change the number of integers I’m actually

changing the number of memory locations that I modify the stack pointer so I have to do it by

twos if I wanted to do 99 here then that means the stack is in alignment by the time I call

by the time I’m getting ready to call printf which means the push pop pair around it throws

push pop pair around it throws the stack out of alignment so just watch here I’ll

prove it okay so it’s sake false I comment that out now it won’t throw it

out of alignment okay should have known that before I recorded the video it’s

fun to guess sometimes though you know I get a little nervous oh no my program

broke on camera can I debug it live well I guess I can but kind of slowly

anyway so we I think we’ve gone over every single part that I wanted to show you

we know how to create a local array on the stack and and therefore you also know how to create like

any other data type on the stack if you want you want to create a long a 64-bit integer

just move it by eight bytes instead of moving it by eight times however many integers we were doing

in this video you want to I don’t know put a character on the stack you can do that if you

Just, you know, move it by one memory location instead of eight memory locations.

So, you know, one byte instead of eight bytes.

You want to store a short, you know, a two byte integer?

Well, just move it by two bytes instead of eight bytes, right?

So you can do this as many times as you want.

You want to have several local variables?

Just move it one time for every local variable.

Same thing for accessing.

You just have to remember where everything is.

offset of the of the first variable local variable and then the offset of the second

local variable you can store those in globals or store those in registers if you can you just

got to remember somehow where everything starts but it’s all sitting on the stack if it’s a local

variable okay I guess that’s everything that I really have to say I hope you enjoyed this video

I hope you learned a little bit of stuff and had a little bit of fun I’ll see you in the next video

have a good one

you

Hey everybody, thanks for watching this video again from the bottom of my heart. I really appreciate it

I do hope you did learn something and have some fun

If you could do me a please a small little favor

Could you please subscribe and follow this channel or these videos or whatever it is?

You do on the current social media website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe. You know, sometimes I’m sleeping in the middle of

the night and I just wake up because I know somebody subscribed or followed. It just wakes

me up and I get filled with joy. That’s exactly what happens every single time. So you could do

it as a nice favor to me or you could troll me if you want to just wake me up in the middle of

the night, just subscribe and then I’ll just wake up. I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website

which I think is also named somewhere at the bottom of this video and

It’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

If you have a suggestion for

Please leave a comment or if you just want to say hey, what’s up? What’s going on?

You know just send me a comment whatever I also wake up for those in the middle of the night

I get I wake up in a cold sweat. I’m like

It would really it really mean the world to me. I would really appreciate it. So again, thank you so much for watching this video and

Enjoy the cool music as I fade into the darkness, which is coming for us all

Thank you.

The post x86-64 Assembly: Local Variables, Stack Frames & Alignment Explained appeared first on NeuralLantern.com.

Ever wonder how your program remembers where to return after calling a function? That’s the call stack’s job.

In this clear, whiteboard-style explanation we cover:

• What the call stack actually is
• How call frames are built and what they contain
• Return addresses, function arguments, local variables
• Why recursion works (until you overflow the stack)
• Stack vs heap memory differences
• Why too much recursion = crash

Great for beginners to intermediate programmers who want to understand what’s happening under the hood. References Ed Jorgensen’s excellent (and free) x86-64 assembly book.

00:00 Introduction to the Call Stack
00:16 Prerequisites – Understanding Basic Stacks
00:41 Simple Example Program with Function Calls
01:24 Function Call Chain and Recursion Example
02:20 Visualizing the Call Sequence
03:06 Local Variables and Return Values
03:55 Quick Recap – How Generic Stacks Work
04:34 Stacks Can Hold Any Data Type
05:36 Introducing the Call Frame Concept
06:22 What Belongs Inside a Call Frame
07:00 Return Address Explained
07:44 How the CALL Instruction Works
08:32 Function Arguments on the Stack
09:57 Extra Arguments Beyond Registers
10:19 Preserving Registers (Callee-Saved)
11:12 Local Variables on the Stack
11:40 Multiple Call Frames Example
12:54 Tracing Function Calls Step by Step
13:21 Starting with Main’s Call Frame
15:00 Pushing Frames for Nested Calls
16:30 Returning – Popping Frames
18:10 Why the Stack is Perfect for Returns
19:45 Recursion and Multiple Instances
21:30 Stack Grows Downward in Memory
23:10 Stack vs Heap Memory Comparison
25:12 Local Variables vs Dynamically Allocated Memory
26:16 Pointers on Stack Pointing to Heap
27:32 Automatic Cleanup of Stack Variables
28:00 Memory Leaks with Heap Allocations
28:56 Recommended Reading – Ed Jorgensen Book
29:56 Call Frame Layout in x86-64 Assembly
31:16 Process Memory Layout Overview
32:22 Stack Grows Down, Heap Grows Up
33:52 Stack Overflow from Deep Recursion
35:09 Summary – Why the Call Stack Matters
35:28 Closing Remarks and Call to Subscribe

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there. In this video we’re going to talk about the call stack. What is the call stack?

It’s an important data structure inside of your computer that helps your computer call

functions inside of code. It’s pretty cool.

So first off, before you watch this video, you should probably already understand

how a stack works, what a stack is in terms of its interface and how to manipulate it

See my previous video if you don’t understand how to use stacks yet. In this video, I’m just going to talk about the call stack, which is just a special use of the generic stack abstract data type data structure.

Okay, so let’s see. First off, let’s suppose for the sake of argument that I have, you know, a function called main. This is not a C++ video or a coding video, but the call stack is related to coding.

mean when I write down some code. This is just a simple C++ program. You can imagine that

up above main, actually I don’t want to use prototypes, but I’m going to put the other

functions below. Please forgive me. You can imagine that main calls on the function f,

so I’m just going to do a function called f here. And so execution, when it gets to that part of

the program on line three, execution is going to jump down to line nine to just execute the f

And then maybe F calls G and then G it calls H and maybe H sometimes calls itself.

Maybe we’ll say that it’s a recursive function.

We’ll say if, you know, something happens, then we will return a call or we’ll just call H.

So it calls itself sometimes.

Otherwise, we will have it to call on the I function.

then you know execution just kind of returns to the caller which would be G in

this case and then we have the I function that just you know does whatever

right so the code here doesn’t really matter what I’m really trying to show

you is that one function calls another calls another and we can sort of allow

this to happen under the hood with a call stack so I’m just gonna draw this

and G calls on H and H we’ll say that we’ll say for the sake of argument one time H calls on H

just so it’s easier to draw later and then H eventually calls I for some other reason

maybe the deeper H calls I and then eventually this starts to return right so if you’re a

programmer you kind of take this situation for for granted you think like well I just kind of

call a function and then and then when the function’s done I just return to the place

everything is fine. If we had, let’s say, local variables in here, they would be preserved. Let’s

say, I don’t know, maybe h is like a number or something like that. Or how about let’s do g as

a number. We’ll say g returns some kind of a number. And then maybe in the f function, when

we call g, we’ll just print whatever g returned. So g calls h, and then we’ll just say like return

h and then we’ll just say like return whatever just trying to show you that we might have

a local variable so that means um in the g function maybe you’ll have a integer a is equal

to five and integer b is equal to six i’m just making up stuff here and then when we return

our data we might say you know return a plus b for whatever reason this is a nonsense program again

don’t take it too seriously but i’m just trying to show you that we have functions that can call

we have functions that can call each other sometimes call themselves and maybe they have

local variables on top of that so if you understand what is a stack then you understand that a stack

can hold many different types of data just as a quick recap here um you know a regular

generic data structure stack or an abstract data type stack we could say that the stack hold held

integers so if i wanted to put like an eight on there and then put like a five on there it would

it would just kind of stack up as we’re adding data.

And then when eventually we decided to remove data from the stack,

we’d pop it by just removing the thing from the top.

But because stacks are supposed to be abstract data types that hold any type of data,

we’re not limited to putting integers inside of the stack.

So we could invent a totally new data structure

and put instances of that data structure inside of the stack.

For example, if you had a custom class that you wrote yourself

and you just called it my class,

my class let’s see uh let me do class my class and i’ll just put braces here again this is not

a c++ video but you know you can imagine that you sort of made a blueprint for a new type of object

and you called it my class and then later on you’re like let’s make instances of my class

let’s make an instance called mc1 and mc2 and mc3 and so forth right so in the stack you could just

instances of my class i’m just going to put mc1 here if we created mc1 and then pushed it onto

the stack and then we can have mc2 and created an instance of that and just kind of pushed it

on the stack so we can do whatever we want we can put any type of data on the stack m

and this is not exactly the process stack so far i’m just telling you what a stack

in general can do so now instead of imagining that we have a custom class called my class

made a new class called call frame I’ll say we have like an instance let’s say

like a blueprint for a class we’ll call it a call frame I’m a penmanship it’s

because this thing this pen and I push it down and it always like keeps drawing

after I start lifting it up I don’t know what I’m doing wrong I’ve been trying

this for like 50 videos and it’s always bad and wrong so imagine you have a

class called call frame and inside of it you can just put some sort of data in

some sort of data inside the call frame.

You can imagine defining what an object might look like and then creating instances and

filling it up with data and then every instance just like we did with my class we could just

put that onto a stack right?

So now let’s try to understand what might be inside a data structure called a call frame

because when we have a stack under the hood in our machine that holds instances of call

frames then we actually have a process stack or a call stack which allows us to implement

which allows us to implement these function calls.

So let’s see, the first thing that we might imagine,

I’m gonna maybe just do like a little box here,

just to let you know that we’re deciding

what will go inside of a call frame.

So this is one call frame.

So you can imagine that the F function here,

in order for the F function to exist,

the particular call to exist,

what you know what it has what it is to be alive you know it needs its return

address I’m gonna put RA here for its return address what is a return address

well you know when we were inside of the main function let me draw the execution

path real fast when we were inside of the main function then execution was

going from top to bottom when we hit this F function call execution actually

jumped to the first line of the F function under the hood in assembly

there’s a jump instruction that allows you to just kind of jump to a totally

just kind of jump to a totally different memory location and start executing

instructions over there somewhere. In assembly also we have a call

instruction which means I would like to jump to another location but also I want

to remember where I just came from so that it’s easy for me to return later.

Okay so we’ll call that the return address. The return address in this case

would be let’s just call it line 4 meaning when function f returns then the

is this return zero in well I mean this is C++ we don’t it’s not really instructions it’s more

like statements but you can just imagine that F gets called and when it returns then the next

statement is return zero right so if we say that the memory location of wherever line four starts

is the return address of F then you can imagine that in order for F’s you know call instance to

exist it has to remember its return address so therefore we would put the return address inside

call frame. So the return address goes in there and function arguments sometimes go in there. If

you know assembly, and that’s kind of what we’re talking about right now in this video, then

you’ll know that function arguments, at least the integer arguments usually come in certain

registers like RDI and RSI, or if you’re, whoops, or if you’re passing float arguments,

and XMM1 and so forth right so you just kind of like load up registers with

arguments but if you have more arguments than you have registers you know

there’s only so many registers you can actually use to pass arguments into a

function that you’re calling so what if you run out of float registers you run

out of the general purpose registers but you want to have more arguments than

that for example if you look at the ABI then the integer arguments there’s only

integer arguments there’s only six registers that we can use to pass integer or pointer arguments

so if you wanted to have seven arguments or more then you know you should be able to do that but

there has to be a different way to accomplish that so the seventh and beyond arguments will

actually uh show up in the call frame oh I guess ra should probably be blue because the the call

frame I’m just you know making that green I’ll say return address so the seventh and uh the

the seventh and beyond arguments args we’ll just say so the call frame contains the return address

and any argument that’s that’s like the seventh argument and beyond and if you don’t have seven

arguments then there’s not going to be that’s not going to be in the in the call frame it’ll just be

blank at that point sometimes when people are messing around with the stack pointer they will

Basically, anytime you push a register in order to preserve it,

then it will end up on the call frame, at least at the assembly level.

So suppose you’re going to use the base pointer register.

You probably want to preserve the base pointer before you start using it.

So we would push it onto the stack and it would become part of the call frame.

Any registers that are designated as callee saved

would also be pushed into the call frame like R12.

Oh my God.

R13.

my penmanship there’s like it’s the ones the ones are always l’s okay and so forth right so

anything that’s designated as a callee saved register that you intend to use would end up

getting pushed onto the stack at the assembly level and thus it would end up in the call frame

but you know if you aren’t going to use any callee preserved registers then you don’t need to

preserve them and therefore they would not show up in the call frame and let’s see and local

local variables in assembly, you just basically end up pushing them to the stack.

So I’m going to put local variables here.

And in a second, I’ll show you how that kind of works in higher level languages like on

C++.

That’s why I wrote this down right here, line 12.

We’re making local variables.

And let’s see what else.

I should emphasize that local variables are very different from heap variables.

some point let’s say that when when g was called let’s say execution came in here

into main and then execution jumped into the f function so it jumped in there and then f wanted

to call on g in order to get some information right so we have a call frame just for g and we

have a call frame just for f and we have a call frame just for main and so we have like three

items on our stack at least just to get to that point of the program and every call frame you

you know, basically has this sort of information inside of it.

The return address, so the function knows where to jump back to

when it’s time to return from the function.

Seventh and beyond arguments, if any exist.

The base pointer, if you happen to modify that at the assembly level.

And then same thing for Kali saved registers.

And then local variables, which you could probably imagine more clearly.

So now I’m just going to erase this call frame thing here.

Oh God, this eraser needs to be improved.

god this eraser needs to be improved oh my gosh maybe i should make that bigger i need like a

little shortcut to make it bigger for a second because i don’t really want to draw that thing

on top again that’s just annoying i don’t want to do it i won’t do it i won’t do it okay so uh

imagine now that we are trying to sort of trace what’s happening in our uh call graph you know

in our in our program while we’re calling functions so first imagine we have an empty

have an empty stack and again if you don’t understand stacks you better go see my other video

imagine we have an empty stack the stack is not ever really going to be empty when you launch

your program it’s going to be uh there’s going to be stuff on it already but let’s just pretend that

we haven’t put anything on the stack at this point so there would be a you know a call frame just for

the main function i’m just going to write main here to say that this is the call frame for main

so it contains all the information that main needs and um if you have a main function in the first

first place then you’re probably linking against the GCC libraries which means

a main definitely has to return somewhere inside of the GCC library so

this kind of makes sense for our program so it’s a call frame for main

and then when main calls on F then another call frame gets created for F

and then when F calls on G another call frame gets created for G I don’t know if

I need to put these parentheses but I guess I’ve already started to do that

h and then h sometimes calls itself so I’m gonna put another call frame for h

up here oh my god h’s look like just crazy okay that’s been uh every time I

lift up the pen h calls itself sometimes we’ll just say that it calls itself

once in this case and then h calls i and then that’s let’s just say that’s the

end of our little call graph when i is finished doing whatever it’s gonna do

to do then it’ll just return to the caller right so notice how every single time we made a function

call we added a call frame for that particular instance of a call and we called it a call frame

something else that i should point out is that i have been describing to you a call frame as if it’s

a a data structure with sort of like a fixed amount of data inside of it and you would sort of

blob that whole block of data on at the same time that’s not really how it works in assembly in

you kind of just push, you know, one tiny piece of data at a time.

But in the abstract, you imagine that there’s a call frame.

Just keep that in mind.

Anyway, so in the F function, you know, we’ve been making these calls F and then G and then H and then H and then I.

Eventually, when we got to the, let’s say, what did I do wrong?

Oh, I did something wrong.

I put the local variables in the wrong function.

Hang on a second.

I want them to be, I mean, it would be okay to have them inside of the G function, but I really want them.

but I really want them, I really want them to be inside the H function for a certain reason.

So I’m just going to cut and paste here.

And I’m going to do like local variables inside of the H function and not in the G function.

And then G should maybe return an integer result.

And then this return statement shouldn’t even be in G.

It’s just going to be inside of H.

the a and the b variables at some point before returning them modify a and b somehow maybe I can

even put that comment inside of both of the blocks of the if so like so maybe if something happens

we’ll modify them in one way and if it doesn’t happen we’ll modify them in some other way

and then at the very end we return them just to kind of feel like we have more of an excuse

to have return variables in the first place and then when h returns something now we have an excuse to kind of print out whatever h is

doing okay and the reason I moved all that inside of h and not in g is because I just want you to know that

There are two instances of the h, you know call instance on the call stack which means the local variables

They’re not linked. They’re two distinct copies of each local variable inside of the stack think of it this way

When we call our h the first time,

we have an integer a and an integer b.

You could imagine that there’s an integer a

and an integer b sitting inside of the call frame somewhere,

you know, being pushed onto the call stack.

And, but the other called h also has a variable a

and a variable b,

but because those are local variables,

changing one doesn’t actually modify the other copy

that is in the other call frame.

So you could imagine this as A sub one and B sub one,

and then A sub two and B sub two.

This is kind of important later on when you realize

that your operating system is capable of launching multiple threads for your program

and local variables won’t potentially become race conditions,

which is just like for a totally different video.

But for now, just to understand these are totally separate instances.

If I change A sub two, it’s not changing A sub one and vice versa.

And same thing for B.

vice versa and same thing for B so anyway we we make all these calls and

somewhere along the way you know we’re creating a bunch of data and a bunch of

call frames eventually when we are done with the I function when I wants to

return here we don’t have an explicit return statement but if you if you know

C++ or higher level languages if there’s no return statement in most of

the language in most of these languages for a void function it just returns when

when it reaches the end of the function we don’t really need to say return because it doesn’t

return anything it just ends so when i is ready to return what happens is we look inside of its

call frame and we look for the return address which is inside of its call frame the return

address specifies exactly where we’re supposed to return for example maybe we’re supposed to return

right here maybe we’re supposed to return right here maybe to make things a little bit more

so maybe if we called h then we increased a and if not then we increased b something like that

so that means the the call frame for the first h function let’s suppose let’s see if it called

if it called itself then that means this block right here is the first part of the if block so

the return address for h return address would actually be pointing to

would actually be pointing to the next line right so when h called on h

it would look at line 21 or whatever the address was for that instruction

to begin at you know increasing a and it would just say that’s the return address so that

whenever h returns from itself it ends up executing a plus plus and then the same thing for i so

i has a return address so when we’re inside of the i function it’s got its own call frame and it

knows where it’s supposed to return which in this case would be that instruction right there or that

statement right there so whatever is the first instruction that implements that higher level

language statement that’s going to be the return address inside the the i call frame so we look

inside of the call frame for the return address we know where to return it’s going to return to h at

at this point in time.

And once we’re done with that,

then we just deallocate the call frame.

In assembly language,

all we’re really doing is moving the stack pointer

and just sort of ignoring the call frame

from that point forward and we’ll call it junk data.

So the data is kind of actually still there,

but we’re just not using it.

And then later, if we wanna start adding more stuff

on top of the stack,

then it will just override that junk data.

But for now, just imagine that it’s gone.

Anyway, so then we returned from I back to H

from I back to H and so that’s line 26 right here imagine we perform this

instruction the B++ and then execution falls through down to the very end the

return statement so then same thing happens this version or I guess this

version of H had its own no hang on a second we returned from I yeah yeah this

to h so that means execution will will basically jump from here to right here so it kind of jumps

you know back to that next line like we talked about before when it returns based off the return

address then again you can imagine that that call frame is deallocated or just ignored as junk data

and the top of the stack is kind of like moving and then when that call on h uh finishes so you

executed and then execution falls through down to the return statement then again h has its own

return address in its in its call frame or that instance of h has its own call frame then it knows

where to return and this time it knows to return to whoever called h in the very first place so

it’s going to be um i guess it’s going to be like when it returns it’s going to go back to g

h on g but I guess you could imagine under the hood you know instead of like

another statement you can imagine more stuff is happening right like when we

called h and then we returned then we had an expression that evaluated to

something because h returned to value and then we would send that to the stream

operator so in assembly there are many instructions happening after the call to

h but you could just imagine at this point you know it’s just gonna finish up

that that existing statement and then move down to finish and return so then

so then again you know we we just returned from h to g so we de-allocated that call frame the top

of the stack is now somewhere around there in that call frame when g finishes and it returns

same thing it’s got a return address so it knows where to return and then top of the stack kind of

goes down there and g knows to jump to whoever called it because of the return address so it’s

going to be at this point in time again there’s more statements that happen after the return

see out in a stream operator uh you know but uh you know basically when f is done then again it’s

going to use the return address and know where to jump back to which is just going to be this next

line right here so when f was called originally it like ended up calling h and then h uh you know

called itself and h called itself and then it called i and then we returned from i and then we

returned from h and returned from h twice and then eventually we returned to g and then we returned

and all of its calls were finished then execution returned just a line for and

that’s that’s basically saying like oh what happens when F is done let’s look

at its return address hop that off the call stack and then the top of the stack

is basically just sitting inside of the main function so yeah this is how we

implement function calls in the machine you know there’s there’s really no so if

you know, from a certain point of view, there’s no such thing as functions inside the machine.

In assembly language, we certainly see that we have a label and then we have like a return

instruction and we have a call instruction, but you know, there’s no like function. It’s all just

ones and zeros all over the place, right? So the idea of labels and functions and things,

that’s kind of an abstraction just for the human being with feelings to make it a little bit easier

stack we have a stack and we stack things on top of the stack and the things that we stack are

called call frames call frames are kind of flexible because sometimes there’s more data

sometimes there’s less data depending on what the function itself is doing but it allows us to have

a function call itself many times it allows us to have many different instances of function calls

exist at the same time even if we’re only looking at the very top of the call stack in terms of

conflict with each other.

And then, you know, like we have a trail of breadcrumbs when we start returning and

returning and returning, the stack makes it really, really easy.

And so, you know, in the abstract, we can basically say that there are functions in

our machines because this implementation helps make it happen.

One last thing that I wanted to say before I go here is just keep in mind that these

local variables, they’re on the stack, but dynamically allocated memory is not on the

stack.

stack. Let me just show you what I’m talking about right here. You probably understand the

heap already at this point. If you’re watching this video, then you know a little bit about

dynamic memory allocation. So I’m just going to do, let’s say we have like an F function void F.

And inside of the F function, we have let’s say a integer pointer P, and we will allocate P to a new

So just so you know, the variables A and B and also P, they’re considered local variables

because I just declared them.

I declared a pointer on line four.

I declared two integers on line seven.

Maybe I should put those like at the top, I guess.

Okay, so lines four and five, they declare local variables.

The pointer is a special type of variable, right?

That just points to a memory location.

So the thing that it points to might not be a local variable, but the pointer itself is

a local variable.

The pointer itself is a local variable.

So these three variables on lines four and five, A and B and P, those are on the stack.

Any local variable gets put on the stack.

And then when you allocate a new integer with dynamic memory, maybe you could imagine if

you’re a C programmer, this would be a call to malloc rather than new.

Then what’s happening under the hood is that the system goes and tries to find some free

memory in a different area of your process called the heap, not the stack.

heap not the stack it tries to find some free memory in the heap it once it finds some then it

designates that as you know being in use and then it returns to you the memory location of that new

allocation so in this case we’re allocating a new integer so that’s going to be 32 bits of data or

four bytes and uh so it just you know it just finds four bytes somewhere in the heap and it finds the

memory location of the very first byte and it returns that to the caller and so p its value is

is now going to be the memory location of the new integer that you allocated.

But P itself is on the stack.

So P is kind of weird, right?

Like P exists on the stack, but it points to something in the heap.

Keep in mind the difference.

And then if we just let this function go to the very end

without cleaning up that memory, we would have a memory leak.

I should probably just do like a dedicated video on pointers

for people who are interested in pointers in higher level languages later.

But keep in mind that when the function ends

and you pop the call frame off the call stack,

then that automatically cleans up all the local variables.

So A and B and P itself will be deallocated

and not become memory leaks.

However, the thing that P pointed to,

that will be a memory leak.

I guess that’s a topic that’s too advanced

for this stack video,

but I just want you to know the difference

between something that exists on the stack

and something that exists on the heap.

Okay, so then I think the last thing

that I need to show you here

here is uh let me uh shoot let’s see shambler okay so here’s uh uh my favorite book i love to

i love to pump up this book it’s awesome the author is like a brilliant man very kind man

he offers this book for free it’s got a copy left license you can literally just download it for

and it’s legal because this is an open book basically it’s called x86 64 assembly language

programming with ubuntu by the brilliant dr ed jorgensen phd or professor ed jorgensen

this is the latest version that i’m working with right now i think it’s the latest version i don’t

know he updates this thing all the time it’s always getting better but um if we look at this

book uh you can get a copy of it on your own or you can just watch this video i’m going to go to

12.8.3 so 12 section 12 12.8 12.8.3 called the call frame and here you can kind of see a

description of some of the stuff that I talked about in terms of what sort of data you would

expect to see in the call frame but if you just kind of look down a little bit you can see that

we are sort of pushing some preserved registers

sort of like save the stack pointer as the RBP register.

But before we do that, we wanna push the RBP register.

And then notice out here,

it shows that there’s a return address

and the RIP register.

That’s actually the instruction pointer register.

The stack pointer is RSP.

And then other arguments that go into it.

So just keep in mind that we have a little layout here

a little layout here and then somewhere else there was something I wanted to show you here

no no no no no no no no no no no no no no no no no no okay I guess I’m gonna

oh I guess I was just supposed to show you the call frame anyway okay so I guess that’s pretty

much it I just wanted to show you some extra stuff just so you understand this is the basic

Oh, okay, I found it.

I spent a second scrolling through the book to find the other diagram that I really wanted

to show you.

So same book, X-8664 Assembly with Ubuntu by Ed Jorgensen, Professor Ed Jorgensen, PhD.

And if you look at section 9.3, there’s another picture here that’s kind of useful.

And it basically shows, you know, the general idea of how information is laid out inside

information is laid out inside of your process so when you launch a process in

order to execute your program then it’s kind of laid out like this there’s like

a little reserved area and then there is the text section for assembly you know

that’s where you have all your instructions and then there’s the data

section and then there’s uninitialized data which is the BSS section if we’re

talking about Yasm assembly and then notice how in this big blob of an area

and the stack kind of sharing an area inside of available memory it’s important to understand that

the stack when you actually add things onto the process stack like call like call frame data

you’re actually decreasing memory location so the stack grows downward in memory so I think I’m going

to put this in another video but basically right now I just want to show you if we have memory

location let me let’s pretend that we have like a stack here and there’s like a couple of frames

there’s like a couple of frames you know sitting on top of it suppose you had I don’t know memory

location OX you know 99 or something suppose for the sake of argument we’re only pushing one byte

at a time so it’s easier for me to write then that means you know the next thing that shows up

you know a little higher on the stack you would intuitively think that the memory location is

I guess I increased that 9 to a but it actually goes down in memory so I mean

look at this diagram right here the stack goes down in memory so every time

you push to the stack you’re pushing to a lower and lower and lower memory

location so right here I’m just gonna write down OX 9 8 and it just keeps

going down and down and down let’s see 1 2 3 4 5 right and the heap is is

upward in memory so the heap when you call new allocations like if you say new or malloc or you

know some kind of dynamic memory then its memory locations grow up and the stack grows down and if

they ever actually meet then you’ve ran out of memory just keep that in mind but um you know

in modern systems the heap can kind of grow almost endlessly i’m sure i’m sure you’ve all

been running programs in the past and noticed that the program was consuming gigabytes of data right

gigabytes of data right but it’s not like you had gigabytes of data allocated to that process

when you first opened it up like if you have a browser with like 100 million tabs open

i know some of you people do that then when you first open your browser it doesn’t really use

that much memory but then as you start opening more tabs maybe some pages are doing some weird

stuff and you get memory leaks then the heap starts to grow and grow and grow and then you’ll

notice the process takes way more than did in the beginning so the heap can kind of grow in an

of course that is limited to your physical system ram and eventually in the far off future will be

limited by whatever 64 bits can get us i don’t think we’re ever going to reach that in my lifetime

but you know i’ve been wrong many times before however the stack it grows downward in memory

and it’s kind of limited you can actually overflow your stack pretty easily so when the stack grows

downward too much then you just you have a stack overflow and the program crashes but when the heap

But when the heap grows, then it can just be resized again and again and again.

Or that little block can kind of expand again and again and again.

If you don’t believe me, try writing a program with a recursive loop that just goes on forever.

So imagine, actually, I don’t know, don’t do this on your boss’s computer because maybe

it’ll crash things.

Do it on your own personal computer.

like a function f and uh you know you’ll probably want to call f inside of main or something so i’ll

just say like int main and we’ll just call f right away and then return zero when you’re inside of f

you just call f right so this is like a horrible program if you ran this very quickly you’d crash

the program because every single time you call f you’re adding another call frame on top of the

stack your call stack is going to just be filled with f call frames and then you know it runs out

you know, it runs out of available memory locations to use, and then you’re just done.

It just crashes the whole program.

So let’s see.

I think hopefully now you feel like you’re an expert on the process stack and call frames.

Thank you for watching this video.

And I hope you learned a little bit and had some fun.

I guess I’ll see you in the next video.

hey everybody thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could do me a please a

small little favor could you please subscribe and follow this channel or these videos or whatever it

is you do on the current social media website that you’re looking at right now it would really mean

the world to me and it’ll help make more videos and grow this community so we’ll be able to do

better videos or just I’ll be able to keep making videos in general so please

do do me a kindness and and subscribe you know sometimes I’m sleeping in the

middle of the night and I just wake up because I know somebody subscribed or

followed it just wakes me up and I get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could

you control me if you want to just wake 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

if you look at the middle of the screen right now, you should see a QR code, which you can scan

in order to go to the website, which I think is also named somewhere at the bottom of this video.

And it’ll take you to my main website where you can just kind of like see

all the videos I published and the services and tutorials and things that I offer and all that

good stuff. And if you have a suggestion for clarifications or errata or just future videos

Or if you just want to say, hey, what’s up? What’s going on? You know, just send me a comment, whatever.

I also wake up for those in the middle of the night. I get, I wake up in a cold sweat and I’m like,

it would really, it really mean the world to me. I would really appreciate it. So again,

thank you so much for watching this video and enjoy the cool music as, as I fade into the

darkness, which is coming for us all.

Thank you.

The post The Call Stack Explained: Call Frames, Return Addresses, Local Variables appeared first on NeuralLantern.com.

Quick guide to passing mixed int + float arguments in x86-64 assembly (System V ABI). See why rdi can still be the first integer after several doubles, why xmm registers count separately, and how return values switch between rax and xmm0. Perfect for YASM/NASM programmers interfacing with C/C++.

Intro to Mixed Arguments 00:00
Simple Integer-Only Functions 00:46
Adding Arguments and Return Values 01:01
Integer Arguments in RDI and RSI 01:30
Pointers Treated as Integers 02:06
Introducing Floating-Point Returns 02:31
Returning Double in XMM0 03:06
First Float Argument in XMM0 03:36
Float Registers Count Separately 04:03
Integer Register Order Explained 04:16
Separate Counting for Integers and Floats 05:21
RSI as First Integer After Float 05:38
Reference to Ed Jorgensen’s Book 07:00
Callee-Saved Registers Overview 07:56
Complex Mixed Argument Examples 09:48
Inserting Integer Among Floats 10:57
Skipping Float Registers on Integer 11:18
Calling C from Assembly Notes 11:56
Name Mangling Reminder 12:21
Closing Remarks and Thanks 12:30
Call to Subscribe and Support 13:04
Website and QR Code Mention 13:38
Final Thanks and Outro Music 14:19

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hey everybody! In this video I’m going to talk to you a little bit about using functions with

mixed arguments in a YASM x86-64 assembly language program. Although this

video will probably still be useful to you if you’re using NASM or MASM because the

mixed arguments and their order and how they work is governed by the ABI which is a system

so what the heck am i talking about okay so the first thing that i want to show you is uh

imagine we have a function here let’s say void f this function doesn’t take any arguments and it

doesn’t return anything congratulations you’re done that was the easiest thing that you’ve ever

done in your entire life but as soon as you start adding arguments to it you have to uh

start understanding how to uh how to call registers and stuff so imagine we have like a

a long a and a long b so we give it two arguments and maybe we want it to return a long

this is kind of like level one of writing functions in assembly right we just have

a bunch of integers and we realize okay um this long the return value is going to come to the

Maybe I’ll do a comment up here, we’ll do rax, we’ll say the long is actually coming

back to the user in rax and the long is coming into the function with rdi, the long a and

the long b is coming into the function with rsi.

So if you understand this then you can write a function in assembly where basically you

two incoming integer arguments and then you return to the caller a long value using rax

keep in mind also that if this second argument was a pointer long pointer then it would be the

same thing rsi because pointers are integers they’re 64-bit unsigned integers even if the

pointer was not to a long even if the pointer was to a double or a character or whatever it would

pointers are integers. It starts getting a little bit more complicated when you want to mix between

floats and numeric arguments. So what I’ve been saying so far, it’s all just integers.

Even if we’re mixing pointers with regular longs, it’s just, you know, they’re all longs basically,

right? So, but as soon as we start introducing floats, then things get a little bit more

complicated. So for starters, what if we did a function that was, that returned a double?

that returned a double. So let’s say we have a function G and it returns a double. Maybe it

still takes in a long and a double pointer. If it returns a double, let’s see, is this still

lining up? I don’t think it’s lining up anymore. There we go. If it’s returning a double, then

that means we have to return to the caller with the XMM0 register. So XMM0 is always designated as

the well the first float argument but also the float return value so keep in

mind if I’m returning a double to the caller I’m not going to use our a X at

all I’m just going to use XMM zero load it up with the return value and then

return to the caller and that’s it if I wanted to do another function let’s say

hmm how about H and then we’ll say I don’t know maybe the first argument is a

argument is a float we call it a double a that means rdi is not going to be the argument that

or the register that we look at to see our incoming double it has to be a float register

xmm0 is the float register that we look at for the first argument the float registers are really

easy you just kind of go in order like xmm0 is the first argument xmm1 is the next argument xmm2

the general purpose uh integer registers they’re a little more complicated you have to remember

their their labels uh you know like the letters have an ordering to it uh suppose for the sake

of argument that we’re going to return a double from this also uh in that case let’s see did i

just mess the formatting up again i think that’s okay um again we’re going to return xmm0

notice how we’re returning xmm0 oh that’s why i spaced it forward notice how we are

forward notice how we are returning xmm0 and we’re also taking xmm0 these float registers tend to be

reused all over the place none of them are designated as callee saved within the abi

so you always have to stash their values somewhere if you’re ever going to make a function call or

anything or a system call the other thing to keep in mind is notice how rsi i still have rsi there

for the second incoming argument you would imagine that rsi is supposed to be the second argument

supposed to be the second argument even if it uh you know comes after a double but that’s not

actually true because the the order i guess like the the ordering of the uh of the registers they

only count against their own class like the float registers the float arguments they only count

against the position of the float and the uh of the float registers and and and the general purpose

they only count against themselves.

What I’m trying to say is that RSI is the second integer argument,

but if you look at the signature, we only have one integer argument, right?

So RSI is not the second integer argument.

It’s actually the first integer argument.

So I’m going to put an RDI there.

You probably can infer that the second float argument should be XMM1 at this point, I hope.

and that’s true if we just say that there’s going to be another double

that this function takes then it’s going to be xmm1

not xmm2 because if you’re just counting the arguments

and you’re sort of grouping the integers with the floats together

you might think well first argument is xmm0 second argument would have been xmm1

third argument would have been xmm2 therefore if I see

a float coming into the third argument position it’ll be xmm2

No, the integers don’t count against the floats and the floats don’t count against the integers.

That’s why RDI is the first argument for integers, even though it’s in the second position,

it’s still the first integer that we see.

And XMM1 is the second float argument that we see.

That’s why it’s XMM1 instead of XMM2, because we’re looking at it in the third position.

So you’re not really looking at, whoops, you’re not looking at overall position.

at position only counting that type of register let me pull open my favorite book to get a little

bit more clarity on this um this book is written by a wonderful professor dr ed jorgensen phd

this book i did not write it ed jorgensen wrote this book it’s called x86 64 assembly language

programming with ubuntu this book can turn you into an expert with yasm assembly so uh

I recommend everybody grab a copy. It’s also free and it’s got a copy left license.

You can see like the license here. But anyway, I wanted to open up this book real fast

just to show you the registers. Okay. I’m going to search for Kali saved so I don’t have to fumble

around the book too long. Kali saved and that brings us to section 12.8.2 register usage.

let’s see callee saved you’ll see rbx is callee saved rbp is callee saved probably shouldn’t

mess with that one too much r12 13 14 15 all callee saved there’s a couple temporary registers

but if you look carefully rdi is designated as the first argument but it should say really

the first integer argument so rdi is the first integer argument that we see that’s why

argument that we see that’s why in all of these examples the first integer argument that we

actually see is rdi so like for function f long a that was the first integer argument

and then in the function g it’s also the first integer argument and then in function h rdi is

the double pointer b because that is the first integer argument that we actually see

so keep that in mind you would just repeat that pattern you know the second integer argument you

second integer argument you see that’s RSI. That’s why RSI is the pointer here because

pointers are integers and the pointer here and we don’t have anything else but if I guess if we

added another you know let’s say a long D then it would be RSI right there. Hopefully that makes

sense and you can you can carry this logic forward for the first argument the second argument the

and then R8 for the fifth argument R9 for the sixth argument and then you can

look for further arguments on the stack if you need more than that but basically

that’s how you count them up and then the float registers are just a lot

easier they always start at zero and they go all the way up to 15 and so I

don’t know maybe I should just copy paste well maybe I’ll start it from

scratch we’ll say dub no let’s let’s mix it up a little bit more we’ll say long

And the long is going to be returned with the RAX.

And I guess I have to space this forward a little bit.

And then if we have a bunch of floats, say double A.

Can I maybe just copy paste this a little bit so I don’t have to do so much typing?

Okay, so we’ll do double A, double B, double C, double D, double E.

and then this is going to be xmm zero why did i put the extra comment there i don’t know

and then we’re going to have xmm one and then we’re going to have xmm two xmm three and so forth

and just to make sure you’re paying attention ask yourself this real fast if i were to insert

z what register would we use for that would it be the one two three four five the fifth argument

would it be uh would it be r8 or would it be something else hopefully you understand now

let’s say we do a character pointer that it would be rdi because that’s the first integer argument

that we actually see all right and then you know to return we would return in rax and then the

return in RAX and then the floats just keep counting notice how it skipped from XMM2 or it

went from XMM2 to XMM3 even though we crossed over an integer argument in between because the

float arguments don’t count against the integers and the ints don’t count against the floats

let’s see I think

well if you want you can look at section 18.2 which just sort of talks about the floating

which just sort of talks about the floating point registers we have 0 through 15 but I don’t think

we really need to do that here I think we pretty much have everything we need to know to to call

on functions with mixed arguments and to have a function within assembly that supports mixed

arguments so again if your C or C++ modules are expecting some kind of signature like this now you

know how to calculate what registers they’re actually going to populate by the time execution

execution jumps into your assembly function.

And if you want to call a C or a C++ function from assembly,

now you know which registers to populate so that the the other function that

you’re calling can receive the right data from you.

Don’t forget about name mangling, which I talked about in another video.

Okay, I think that’s all I really have to say.

This video was pretty short.

Thank you so much for watching.

I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

make more videos and grow this community so we’ll be able to do more videos longer videos better

videos or just i’ll be able to keep making videos in general so please do do me a kindness and uh

and subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because

i know somebody subscribed or followed it just wakes me up and i get filled with joy that’s

exactly what happens every single time so you could do it as a nice favor to me or you could

you could troll me if you want to just wake me up in the middle of the night just subscribe

and then I’ll just wake up. I promise that’s what will happen. Also, if you look at the middle of

the screen right now, you should see a QR code, which you can scan in order to go to the website,

which I think is also named somewhere at the bottom of this video. And it’ll take you to my

main website where you can just kind of like see all the videos I published and the services and

tutorials and things that I offer and all that good stuff. And if you have a suggestion for

clarifications or errata or just future videos that you want to see please leave a comment or

if you just want to say hey what’s up what’s going on you know just send me a comment whatever i also

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like it would

really it really mean the world to me i would really appreciate it so again thank you so much

for watching this video and um enjoy the cool music as as i fade into the darkness which is

for us all.

Thank you.

The post Mixed Function Arguments in x86-64 Assembly – Integers & Floats Explained appeared first on NeuralLantern.com.

Learn pointers & dereferencing in x86-64 YASM assembly and how to pass them correctly between assembly and C++ in a hybrid program. We build a small working example that sends strings, longs, and doubles both directions using pointers, modifies values across module boundaries, and explains why pointer-to-double still uses general-purpose registers. Includes a quick demo of stack misalignment crash + fix.

Great for assembly beginners moving to real programs, systems programming students, or anyone curious how low-level code talks to C/C++.

00:00 Introduction to Pointers and Dereferencing in x86-64 Assembly
00:28 Pointers explained in C++
01:02 Changing values via pointers in C++
01:43 Pointers in assembly basics
02:09 Defining variables and pointers in YASM data section
03:23 Pointers are always integers even to doubles
04:20 Function arguments are pointers treated as 64-bit integers
05:00 Driver C++ code overview
05:58 Marking extern “C” functions
06:40 Local stack variables and passing pointers
07:51 Stack lifetime warning
08:34 Assembly data section strings and numbers
09:39 Print null-terminated string helper functions
10:38 External symbols and hey_driver_print_this
11:29 Point function prologue and stack alignment
13:04 Extra push for 16-byte alignment
14:20 Printing welcome message from assembly
16:00 Driver sees initial long value
16:58 Printing received string from C++
18:20 Using received char pointer without dereference
20:21 Modifying incoming long via dereference
21:46 Driver sees modified long value 101
22:43 Calling back to C++ to print assembly-owned data
23:48 Passing pointers to assembly string long and double
25:08 Driver prints assembly-owned values and addresses
26:14 Summary of pointer passing between modules
26:36 Stack alignment crash demonstration
27:39 Adding extra push/pop fixes segfault
28:00 Closing remarks and call to subscribe

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to Blog: https://www.NeuralLantern.com
• Watching the main “pinned” video of this channel for offers and extras

Hey there! In this video we’re going to talk about pointers and dereferencing in a YASM x8664

assembly program, also as a hybrid program so that assembly and C++ can talk to each other

and send each other pointers and send each other data and things like that.

for what pointers are.

I’m going to write in C++ for a second.

Suppose you have a pointer for an integer.

We’ll call it P.

Suppose you have an integer by itself.

We’ll call it A.

Let’s say that the value of A is 5.

And if you wanted to say that P points to A,

you could say P equals the address of A.

I’ll put C++ at the top here.

And so now if I set A to 6

then I print P a dereference of P this is not like a full pointers tutorial

but basically by changing a I’m changing what P thinks it sees as a value

assuming ID reference it I could also let me do a print 6 here I could also

just change the value through P I could say dereference P and I could say equals

would actually print a seven right so you know you can have regular variables global variables

whatever kind of you know memory stuff on the stack and to get a pointer to it you really just

need to get its memory location in c++ it’s kind of easy syntactically you can see what’s happening

in assembly you really just need the memory location stored somewhere you could store that

variable that just simply stored the memory location of some other variable.

You could have a 64-bit register store the value of a variable.

Let’s say we have like a, I don’t know, my whatever, my number let’s say inside of assembly.

I’ll do ASM here and we say it’s a quad word and it starts off as this number or whatever.

So if you haven’t seen my previous videos, go see them for the basics of assembly and

of assembly and linking and make files and all that stuff but you know if you

have an assembly program and you have a data section and you define a global

variable like this what you’re basically saying is I want to take this giant

number and I want to write it into eight bytes that’s the DQ it says data quad

word I want to write that giant number across eight bytes and then I want to

get a pointer to it stored in the my number symbol so my number is not

actually the value it’s a pointer to the value so you know later if you want to

you know later if you want to move you know something into a register if you did this

that would move the pointer into rax but if you did this

with deref symbols after it or around it then you would move

maybe i’ll put that into rex you’d move that actual number that we specified into rex

into Rx. It’s important to understand also that pointers are integers even when we’re pointing to

doubles. So for example sometimes people make this mistake they’ll say you know my double

and they’ll say it’s a quad word meaning this is going to be a 64-bit double precision floating

point number and they’ll do like 44.55 or whatever. So that is a double and it is in memory

you know what is the symbol of my double remember it’s supposed to be just a

pointer right it can’t be an actual double because a memory location is not

a double a memory location is an integer so that means if you wanted to move a

pointer into a register you would only be able to move the pointer into a

regular general purpose register not a floating point register and you should

use the regular movement instructions for just regular general purpose

So keep that in mind if you see a signature like this like let’s say function F and we have

You know, let’s say long a and long B and actually let’s do pointers

Let’s say long pointer a and long pointer

B and double pointer C all three of those arguments are actually 64 bit integers

Because they’re all pointers even if one of the pointers points to adult a double

double why did I say dull pointers aren’t dull they’re exciting okay so I’m gonna open up some

code here real fast so usually I don’t explain my uh my driver I’m gonna explain it to you this time

because it’s kind of doing a little bit more than my other videos um again if you don’t have uh the

knowledge of how to make a make file see my other videos because that’s explained there for now I’m

what we really need to do is write a driver and an assembly module for a

hybrid program again hybrid programs covered in other videos so the driver is

pretty easy I’m just going to copy paste it honestly here and then just kind of

explain it to you the driver is pretty easy we’re going to do I O stream so we

can print stuff we’re going to mark an external function called point as extern

C so that just disables name mangling which means the C++ module will be able

will be able to call on this function called point and it won’t expect that

the point function has its name mangled like C++ does the reason being is that

point is actually going to be in a side it’s going to be inside assembly where

its name will not be mangled this disables the ability to overload but

that’s okay we don’t care it’s going to take two pointers a pointer to a character

and a pointer to a long since both of those are pointers they’re both

64-bit integers even the character pointer and then we have a function that is internal to this

module called hey driver print this remember we’re inside of the driver program right now

so if you look at the bottom it’s just a function that takes in some pointers

and then prints some stuff so it’s going to print like it’s going to print what the string is

it’s going to print what the long is my dog’s growling at me i’m going to ignore him because

i literally just let him pee and poop at this point now he’s harassing me for treats

now he’s harassing me for treats he always does this okay so uh the string the long the double

this function expects to receive three pointers to different data types it’s just going to print

all of them and the point get it the point of this function is we’re going to go inside of

the assembly module and then have the assembly module call on this function so that we can we

can prove that we can have stuff sent from assembly to c plus plus or c using pointers

using pointers we can have data sent over so anyway that’s why both of these

are in here the point needs to be marked as no name mangling because point is

inside of assembly which will not name mangle and then hey driver print this

that needs to have name mangling disabled also so that the assembly

module can call on this other than that we’re just basically inside of a main

saying hey this is the c string we’re making a c string inside of the main function notice how

this is a local variable so that c string is going to show up on the stack it’s going to show up in

the area that is owned by main for main stack area same thing for my long that’s a local variable on

the stack um and but then we can actually send pointers to those pieces of data to another

function in another module you don’t have to only transport globals or stuff on the heap

or stuff on the heap, you can transport pointers to local variables. Just make sure that by the

time this function finishes, then nowhere else is actually using that data because,

well, being on the stack, once main function or once any function finishes, then its portion of

the stack will be cleaned up and removed and it’ll be junk data. You’ll probably get a seg fault.

But for now, we’re not going to use anything on the stack. We’re not going to use these local

just going to use them quickly on this call to point and then we’re going to return to the

operating system and finish the program. So that’s the driver. Now the hard part. Let’s do this in

assembly. So for starters, I’m going to make a data section and just explain it to you very,

very quickly. Again, if you don’t understand the basics of YASM x86-64 assembly, did I mention

that that’s what this language is at the beginning of the video? I guess I should put that in the

put that in the description or record an announcement that I can tack on at the beginning

or something. Anyway, so if you don’t understand how to do this, see my other videos, but basically

we’re going to make a data section. We’re going to define some strings. Here’s like an announcement.

Oh, we’re inside of, you know, the module now, the assembly module. And now we’re going to print

the received string. And then we’re going to make a string that is owned by assembly, which we can

into C++ when we call the function inside of the driver.

So this string is owned by the assembly module.

Notice how these are null terminated strings.

I just have like a comma zero there,

which means I have some extra functions

I’m gonna paste in that we’re not really gonna talk about

because they’ve been discussed in other videos

just so that we can print null terminated strings.

Then I’ve got a new line here,

you know, carriage return line feed.

And then I’ve just got some numbers

that are owned by the assembly module.

Then I’ve got a system write call,

call code one for the system call writes and file descriptor standard output so I

can print just to the terminal again if you don’t understand this see my other

videos so now let’s start the actual text section so this is where our

instructions start so we got the text section here and we’re going to use some

external symbols don’t worry about these I’m just using my own little library to

and input integers if you have access to this library use it if you don’t if you’re watching

at home and you don’t have this library then that’s fine you can use you know printf or

scanf or something like that to get and print floats from and to the user

but yeah I’m just using that and then I’m marking an external function here called hey driver print

this if you recall the driver module has a function called hey driver print this so

just allows my assembly code to call on that external function. Okay now next

piece of code. This is going to be… actually I’m going to paste the print

null terminated string function and related code because it’s just like a

big giant mess and we’re mostly going to ignore it. So just to show you what I’m

doing here I have a function called print null terminated string so that I

can print these strings up here and then I have it rely on a function called

string length that I have implemented up here and all it does is just

implemented up here and all it does just calculates the length of the string and

then a crlf function so I can just call that so that’s all explained in other

videos don’t worry about it for now we’re going to start the actual entry

point remember the driver was just gonna call point right so now we just have to

implement point in the assembly module so that’s gonna be like down here our

our entry point so the signature for this function is going to be character

pointer and then a long pointer and it doesn’t return anything and remember

that if we look back at the driver that should match the signature right it’s a

character pointer and a long pointer and of course this is just a comment that

reminds me of what to do in assembly you don’t really have a signature you just

sort of use registers but I’m reminding myself that RDI is going to be a

character pointer and RSI is going to be a long pointer.

Here’s a note to myself that I’m going to use R12 and R13, which means

the first thing that I should do, well actually before I even do that, I should

return from this function because it is a function. I marked it as global

so that the other module could call it, the driver module could call it. Again,

see my other videos for hybrid programs.

But so now the, you know, if the driver calls this function, then now we’re inside of

and there’s a return statement so it’s a valid function I should preserve the

registers that I’m going to use that are marked as Kali saved for the ABI so I’m

going to go prologue and then an epilogue and I’m going to say push r12 and push

r13 and then I’m going to pop r13 pop r12 they should be in reverse order if

you’ve seen my other videos you’ll know this and the the thing about this

the thing about this particular program is we’re going to run into stack alignment issues

so uh if you don’t know about stack alignment and how it can crash your program without you

realizing what’s wrong see my other videos but for now we’ll assume you know that and uh i i

already know from running this program in advance that it’s going to be out of alignment by eight

bytes so i’m just going to push an extra register onto the stack and that’s going to put it back

I know it looks weird, but this is going to work.

Let me get rid of this here.

Okay, so.

And then maybe if I can remember at the end of the video,

I can just remove that extra push-pop pair,

and you’ll see the program starts crashing.

But at home, you can do it just to double check.

So the first thing I really want to do is,

after I push and pop,

is save our incoming arguments.

Remember, the first integer argument

and the second integer argument,

argument they come in as RDI and RSI in assembly per the ABI if both of these

things are pointers it doesn’t matter what the data type is it could be

pointing to anything including a double and these would still be considered

integer arguments because well RDI and RSI are just going to be loaded up with

memory locations which which are integers so I’m going to save our

arguments to R12 and R13 now justifying our push and pop pair then I’m going to

little welcome message so print a little welcome message again you don’t need to know about this

function but it’s explained in other videos that I’ve already published we’re going to print our

hello beginning message I’m getting nervous he needs to take a second poop sometimes it’s poopoo

number two time for him and he’s not really just lying about a treat but he did go pee and poop

But he did go pee and poop already.

Okay, he just left and walked away.

Okay, if he comes back, I’m letting him out this time.

I’ll pause the video if he does it again.

Okay, I’m pausing the video.

No pee lied.

He went outside, lifted up his little leg, and a couple of drops of pee came out.

Now he’s staring at me like he deserves a treat.

Sorry, buddy.

I wish I could eat constantly all day long, too.

But life isn’t always fair.

isn’t always fair anyway let’s see I might even lined up on the camera

anymore I don’t even know so we’re looking at this code here is going to

print a welcome message let’s see if that actually works so I’m gonna do make

run again make files are whoops what did I do loader dot asm what did I do what

did I do I somehow copy pasted the wrong make file

What’s the name of my source code file?

It’s point.

I guess I’ll just change it, and then it’ll probably work.

It’s still in assembly module.

Hopefully that didn’t mess it up too bad by copy-pasting the wrong source code.

Okay.

What is going on here?

Floater.

Oh, I need to change that.

Hang on.

Let me fix this.

I don’t know if I’m going to edit this out.

out. It’s fun to watch me struggle sometimes. There we go.

Point.

Alright, let’s give it another try.

Oh no, star dot so no such file a directory. Dang it.

Okay, now this seems to work. I may or may not have edited

that out. I copy pasted the wrong source code into my make

file. So I had to manually adjust it. Then I forgot to

copy paste my library file into the build directory. So I had

The driver sees my long as whatever.

What’s going on?

Print an alternate string begin.

Oh, the driver is printing a bunch of stuff.

Okay.

I started to think, why does it look like the program has a lot of stuff going on?

Oh, that’s the driver.

Okay.

So the driver says it sees its long as 100.

And then now we’re inside of the point module.

So that’s the only thing we’ve done in assembly so far.

so far then the driver has regained control maybe I should add a couple of

new lines in there so I don’t get confused again we will do a C out and L

and we’ll do two of those run the program again and then I won’t get

confused about the messages okay so now we’re inside of the point module and

nothing is happening so points let me get rid of the make file here and

and we’re just printing a welcome message nothing else so now let’s print

the received string so what am I talking about so we’re gonna print a prefix

basically saying hey we received the following string right so if you look at

the symbol message received string it’s just gonna say we’re now printing the

received string and then it’ll print it so what are we actually printing we’re

What is R12? R12 is a character pointer to the print me string. And so basically this

function print null terminated string, it takes a character pointer. So we’re giving it a character

pointer that we received. When point was called by the driver, notice how it gave a pointer to

the C string. You know, all arrays are basically pointers. They’re just different syntactically

just different syntactically sometimes so if i declare an array of some length and i give the

symbol somewhere that symbol is really a character pointer so um by calling point with my c string

i’m calling point inside of the assembly module with this character pointer so that means even

though this c string is owned by the driver by the c plus plus module the assembly module has access

So that means we should be able to print it right now already.

So just the rest of it is just like giving a pointer.

And notice how I’m not dereferencing R12.

If I did dereferencing around R12, then we would be looking to that address and seeing what’s there,

which wouldn’t work for printing a null terminated string.

So let’s just run it again.

I don’t know if you can hear him.

This dude is growling at me still because he wants another treat.

He just got denied.

He’s trying to do it again.

do it again. I let him outside people. He’s been outside like three times already and he just went

out like two minutes ago. Okay. I love him so much. It hurts my heart and he knows eventually he’s

going to break me because it hurts my heart or I’m like too distracted. It’s like, you know,

pulling the crank on a slot machine in Vegas. You know, eventually something comes out.

That’s what he does to me. I’ve accidentally trained him. So now printing the received

Now printing the received string and notice how it prints.

Hello, this is a C string owned by me.

So our assembly module is able to print a C string that was created locally by a C++ module.

So we’re handing around pointers.

Nice.

Can you hear me?

He’s getting louder.

So now let’s modify the incoming long.

Can you shush your freaking pants, please?

Shush your pants.

shush your pants you know the sad thing also is he’s so old that he’s deaf now

so he used to know what shush your pants meant it meant I’m not listening to you

and you might as well stop because I’m not gonna do anything based on your

harassment but now he can’t hear me say shush your pants so he just harasses me

all day and all night okay um so I’m gonna copy paste a little bit more code

Modify the incoming long.

So remember again that the point function, it received a pointer to a long.

We’re calling the long change me on the inside of this, but it’s coming in as R13.

And if you notice what I’m doing here is I’m just saying let’s increase the long.

So I’m going to dereference R13 because R13 is a pointer.

So I’m saying let’s go to the memory and change the long that is inside of memory.

And we have to specify that it is a keyword.

it as a keyword so that we you know we don’t confuse the system the system might think are

you modifying a keyword or like a double word or like a word like how big is your data all we know

is it’s an integer because it’s the increase instruction so I’m saying we got a keyword you

know a 64-bit integer sitting at that memory location I want you to dereference it and increase

it and going back to the driver we’re providing a pointer to our long so the long starts off is 100

and we’re just giving a pointer to it the next thing that we can do is we can

ask the driver to print our own stuff actually you know what let’s run the program right now

just to show that the driver can see the change in the long so i’m going to run it again notice how

first when the driver says hello it sees its own long as 100 then we’re inside the assembly module

long and then we return to the caller which is the driver notice how at the

very end of the program the driver sees its long as being 101 so we were able to

modify data that was owned by a different module just by passing pointers

and de-referencing them okay cool so now the next thing that we should do is let’s

ask the driver to print our own stuff that we own because remember if you go

to the very top you know we own some stuff we own some we own a long we own

float, right? So we want to be able to do something with that. So I’m going to copy paste this,

ask the driver to print our own stuff. So I’m going to move three items inside of arguments

for a function call. And then I’m going to make a function call calling the function,

Hey driver, print this again, Hey driver, print this is actually owned by the C++ module.

a pointer to a long and a pointer to a double remember even pointers to doubles are actually

integers so they use the general purpose register so that’s the three arguments right there rdi rsi

and rdx m and then we’re giving the first pointer is going to be the c string so message string

inside asm so you can see that’s this right here and then the next pointer is the long

inside ASM and the third is the float where did I just go I’m getting confused my dog is harassing

me right now so bad notice how I’m not dereferencing so like if when we were increasing the incoming

long before R13 was a pointer so we dereferenced while we increased so that we would increase the

actual value and not the pointer and not the pointer’s memory location but here we’re not

C++ module the actual pointers to our data. We don’t want to give it the data itself. We want

to give pointers to the data so we’re not derefing with the brackets. So then we call it and when we

get back in here it should just be able to print everything. So I’m going to run it one more time.

We’re going to make it and run it and so now let’s see. So here we’re inside of our assembly module

And then here the assembly module has just called on hey driver print this.

Remember the C++ module doesn’t actually call this function.

The assembly module calls it.

So we’re like going back and forth.

We’re kind of crisscrossing.

So now the drivers print this function says we got the following string.

Notice how that’s the string that is owned by assembly.

So we define that inside of our data section in the assembly module.

And then it prints the long.

It prints it as hex.

And it just sort of prints the value.

it just sort of prints the value then it prints it as hex again and then prints at the value

i think actually not hex i think this prints the memory location let’s double check real fast

yeah so remember um in c plus plus i know this is not like a c plus plus video but um

if the long is a pointer then if we just print it without dereferencing it we should see a memory

location so it’s telling us uh that the long’s memory location is this and the doubles memory

location is that and if you stare at those two numbers long enough and you understand hex which

And do you understand hex, which you can see my other videos for?

You’ll see that those memory locations are right next to each other because that’s the way we define them inside of assembly.

So we now have the ability to have data that is owned by assembly and give it to C++ or C using pointers.

No problem at all.

And then the printing driver thing exits and then the actual driver regains control.

And it just says that it sees it’s long as 101.

it sees it’s long as 101 so uh yeah that’s that’s pretty much all i wanted to show you for this

now you hopefully are an expert at passing data back and forth between various modules using

pointers we’re not using references because references are like a little bit a little bit

less compatible pointers are just really easy they totally work in assembly no problem

one more thing i just wanted to show you real fast before we go even though there’s another

video you should check out for stack alignment I just want you to see what

happens if I remove this extra push-pop pair so now my stack is about eight

bytes off of its previous alignment because you know we’re not pushing an

extra eight byte value and somewhere inside of the let’s see print null

terminated string and then the hey driver print this oh and then we go into

like a bunch of C stuff the program should probably crash because anytime

you use a GCC function or a GCC library or something like that the stack has to

be aligned to 16 bytes so if it’s off by 8 then it’ll crash and how did I know

that I needed this well I just ran it first and it crashed and then I added

the extra push pop pair and it didn’t crash and I realized it was definitely

one more time we should get a seg fault yeah we get a seg fault stack alignment oh no with no

description of what’s going on if you were in gcc you could i mean sorry if you were in gdb you

could probably figure that out eventually but why not just give it a try add another push pop pair

run the program again with no other modifications now it totally works

okay well uh i think that’s uh that’s all i have for this video thank you so much for watching i

I hope you learned a little bit of stuff and you had a little bit of fun.

I will see you in the next video.

Hey everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me

would really mean the world to me and it’ll help make more videos and grow

this community so we’ll be able to do more videos longer videos better videos

or just I’ll be able to keep making videos in general so please do do me a

kindness and and subscribe you know sometimes I’m sleeping in the middle of

the night and I just wake up because I know somebody subscribed or followed it

just wakes me up and I get filled with joy that’s exactly what happens every

single time so you could do it as a nice favor to me or you could you control me

up in the middle of the night just subscribe and then I’ll just wake up I promise that’s what will

happen also if you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named somewhere at the bottom of

this video and it’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

for

Clarifications or errata or just future videos that you want to see please leave a comment or if you just want to say hey

What’s up? What’s going on? You know, just send me a comment, whatever

I also wake up for those in the middle of the night. I get I wake up in a cold sweat. I’m like this

It would really it really mean the world to me. I would really appreciate it. So again, thank you so much for watching this video and

darkness, which is coming for us all.

Thank you.

The post x86-64 Assembly Pointers & Dereferencing Explained – Hybrid C++/YASM Example appeared first on NeuralLantern.com.

Quick but thorough introduction to floating-point registers in x86-64 assembly using YASM.

Learn why XMM0 is special, how to use MOVSD / MULSD / CVTSI2SD, why you must save floats around function calls, and how easy (or sneaky) stack alignment bugs can crash your program.

Live coding + real examples converting integers to doubles and multiplying them.

Great next step after basic integer assembly tutorials.

00:00 Introduction to Floating Point Registers
00:28 Why Floating Point Uses Special Registers
01:35 Floating Point Return Value in XMM0
02:17 XMM Registers Overview XMM0 to XMM15
02:48 ABI Rules No Callee-Saved XMM Registers
03:16 128-bit XMM Registers Purpose and Size
04:00 Ed Jorgensen x86-64 Textbook Reference
05:03 Locating XMM Documentation in Textbook
05:20 Earthquake – I am going to die
06:24 Chapter 18 Floating Point Instructions
07:34 MOVSS vs MOVSD Single vs Double Precision
09:11 Understanding SS and SD Instruction Suffixes
10:58 MOVSD Example Register to Register
11:03 Conversion Instructions CVT Family
13:02 Floating Point Arithmetic ADDSD MULSD SUBSD
25:48 Program Demo User Input Section
26:01 Converting Integer to Double CVTSI2SD
26:29 Multiplying by Constant Float MULSD
28:56 Saving Result Printing Modified Float
31:38 Multiplying User Integer by User Float
33:54 Final Result Display Program Summary
35:19 Stack Alignment Crash Demonstration
36:24 Conclusion Key Takeaways
36:52 Outro Subscribe and Thanks

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to Blog: https://www.NeuralLantern.com
• Watching the main “pinned” video of this channel for offers and extras

Hey there! In this video we’re going to talk about pointers and dereferencing in a YASM x8664

assembly program, also as a hybrid program so that assembly and C++ can talk to each other

and send each other pointers and send each other data and things like that.

for what pointers are.

I’m going to write in C++ for a second.

Suppose you have a pointer for an integer.

We’ll call it P.

Suppose you have an integer by itself.

We’ll call it A.

Let’s say that the value of A is 5.

And if you wanted to say that P points to A,

you could say P equals the address of A.

I’ll put C++ at the top here.

And so now if I set A to 6

then I print P a dereference of P this is not like a full pointers tutorial

but basically by changing a I’m changing what P thinks it sees as a value

assuming ID reference it I could also let me do a print 6 here I could also

just change the value through P I could say dereference P and I could say equals

would actually print a seven right so you know you can have regular variables global variables

whatever kind of you know memory stuff on the stack and to get a pointer to it you really just

need to get its memory location in c++ it’s kind of easy syntactically you can see what’s happening

in assembly you really just need the memory location stored somewhere you could store that

variable that just simply stored the memory location of some other variable.

You could have a 64-bit register store the value of a variable.

Let’s say we have like a, I don’t know, my whatever, my number let’s say inside of assembly.

I’ll do ASM here and we say it’s a quad word and it starts off as this number or whatever.

So if you haven’t seen my previous videos, go see them for the basics of assembly and

of assembly and linking and make files and all that stuff but you know if you

have an assembly program and you have a data section and you define a global

variable like this what you’re basically saying is I want to take this giant

number and I want to write it into eight bytes that’s the DQ it says data quad

word I want to write that giant number across eight bytes and then I want to

get a pointer to it stored in the my number symbol so my number is not

actually the value it’s a pointer to the value so you know later if you want to

you know later if you want to move you know something into a register if you did this

that would move the pointer into rax but if you did this

with deref symbols after it or around it then you would move

maybe i’ll put that into rex you’d move that actual number that we specified into rex

into Rx. It’s important to understand also that pointers are integers even when we’re pointing to

doubles. So for example sometimes people make this mistake they’ll say you know my double

and they’ll say it’s a quad word meaning this is going to be a 64-bit double precision floating

point number and they’ll do like 44.55 or whatever. So that is a double and it is in memory

you know what is the symbol of my double remember it’s supposed to be just a

pointer right it can’t be an actual double because a memory location is not

a double a memory location is an integer so that means if you wanted to move a

pointer into a register you would only be able to move the pointer into a

regular general purpose register not a floating point register and you should

use the regular movement instructions for just regular general purpose

So keep that in mind if you see a signature like this like let’s say function F and we have

You know, let’s say long a and long B and actually let’s do pointers

Let’s say long pointer a and long pointer

B and double pointer C all three of those arguments are actually 64 bit integers

Because they’re all pointers even if one of the pointers points to adult a double

double why did I say dull pointers aren’t dull they’re exciting okay so I’m gonna open up some

code here real fast so usually I don’t explain my uh my driver I’m gonna explain it to you this time

because it’s kind of doing a little bit more than my other videos um again if you don’t have uh the

knowledge of how to make a make file see my other videos because that’s explained there for now I’m

what we really need to do is write a driver and an assembly module for a

hybrid program again hybrid programs covered in other videos so the driver is

pretty easy I’m just going to copy paste it honestly here and then just kind of

explain it to you the driver is pretty easy we’re going to do I O stream so we

can print stuff we’re going to mark an external function called point as extern

C so that just disables name mangling which means the C++ module will be able

will be able to call on this function called point and it won’t expect that

the point function has its name mangled like C++ does the reason being is that

point is actually going to be in a side it’s going to be inside assembly where

its name will not be mangled this disables the ability to overload but

that’s okay we don’t care it’s going to take two pointers a pointer to a character

and a pointer to a long since both of those are pointers they’re both

64-bit integers even the character pointer and then we have a function that is internal to this

module called hey driver print this remember we’re inside of the driver program right now

so if you look at the bottom it’s just a function that takes in some pointers

and then prints some stuff so it’s going to print like it’s going to print what the string is

it’s going to print what the long is my dog’s growling at me i’m going to ignore him because

i literally just let him pee and poop at this point now he’s harassing me for treats

now he’s harassing me for treats he always does this okay so uh the string the long the double

this function expects to receive three pointers to different data types it’s just going to print

all of them and the point get it the point of this function is we’re going to go inside of

the assembly module and then have the assembly module call on this function so that we can we

can prove that we can have stuff sent from assembly to c plus plus or c using pointers

using pointers we can have data sent over so anyway that’s why both of these

are in here the point needs to be marked as no name mangling because point is

inside of assembly which will not name mangle and then hey driver print this

that needs to have name mangling disabled also so that the assembly

module can call on this other than that we’re just basically inside of a main

saying hey this is the c string we’re making a c string inside of the main function notice how

this is a local variable so that c string is going to show up on the stack it’s going to show up in

the area that is owned by main for main stack area same thing for my long that’s a local variable on

the stack um and but then we can actually send pointers to those pieces of data to another

function in another module you don’t have to only transport globals or stuff on the heap

or stuff on the heap, you can transport pointers to local variables. Just make sure that by the

time this function finishes, then nowhere else is actually using that data because,

well, being on the stack, once main function or once any function finishes, then its portion of

the stack will be cleaned up and removed and it’ll be junk data. You’ll probably get a seg fault.

But for now, we’re not going to use anything on the stack. We’re not going to use these local

just going to use them quickly on this call to point and then we’re going to return to the

operating system and finish the program. So that’s the driver. Now the hard part. Let’s do this in

assembly. So for starters, I’m going to make a data section and just explain it to you very,

very quickly. Again, if you don’t understand the basics of YASM x86-64 assembly, did I mention

that that’s what this language is at the beginning of the video? I guess I should put that in the

put that in the description or record an announcement that I can tack on at the beginning

or something. Anyway, so if you don’t understand how to do this, see my other videos, but basically

we’re going to make a data section. We’re going to define some strings. Here’s like an announcement.

Oh, we’re inside of, you know, the module now, the assembly module. And now we’re going to print

the received string. And then we’re going to make a string that is owned by assembly, which we can

into C++ when we call the function inside of the driver.

So this string is owned by the assembly module.

Notice how these are null terminated strings.

I just have like a comma zero there,

which means I have some extra functions

I’m gonna paste in that we’re not really gonna talk about

because they’ve been discussed in other videos

just so that we can print null terminated strings.

Then I’ve got a new line here,

you know, carriage return line feed.

And then I’ve just got some numbers

that are owned by the assembly module.

Then I’ve got a system write call,

call code one for the system call writes and file descriptor standard output so I

can print just to the terminal again if you don’t understand this see my other

videos so now let’s start the actual text section so this is where our

instructions start so we got the text section here and we’re going to use some

external symbols don’t worry about these I’m just using my own little library to

and input integers if you have access to this library use it if you don’t if you’re watching

at home and you don’t have this library then that’s fine you can use you know printf or

scanf or something like that to get and print floats from and to the user

but yeah I’m just using that and then I’m marking an external function here called hey driver print

this if you recall the driver module has a function called hey driver print this so

just allows my assembly code to call on that external function. Okay now next

piece of code. This is going to be… actually I’m going to paste the print

null terminated string function and related code because it’s just like a

big giant mess and we’re mostly going to ignore it. So just to show you what I’m

doing here I have a function called print null terminated string so that I

can print these strings up here and then I have it rely on a function called

string length that I have implemented up here and all it does is just

The post x86-64 Assembly: Floating Point Registers Basics with YASM (MOVSD, MULSD, CVTSI2SD) appeared first on NeuralLantern.com.

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.

Quick practical guide showing how to implement a classic for loop (i=0; i<n; i++) in x86-64 assembly with YASM. We break the for loop into init/check/update parts, convert it to while-style logic, then build it with compares, conditional jumps, inc, and unconditional jumps back to the top. Includes real working code, user input, and printed output.

Great for students learning assembly after C/C++, OSdev hobbyists, or reverse engineering beginners.

Introduction to For Loops in Assembly 00:00:00
For Loop Structure in High-Level Languages 00:00:28
Breaking Down For Loop Parts: Init, Check, Update 00:01:04
Converting For Loop to While Loop 00:01:52
Why While Loop Style Helps in Assembly 00:03:16
Program Overview and Setup 00:04:12
Data Section – Strings and Messages 00:04:40
External Functions and Hybrid Program 00:06:11
Entry Point – Looper Function 00:07:12
For Test Function and Register Usage 00:07:42
Preserving Callee-Saved Registers 00:08:05
Printing Welcome Message 00:09:00
Prompting User for Number 00:09:48
Getting User Input 00:10:25
For Loop Structure in Assembly – Comments 00:11:12
Initialization – Setting Counter to Zero 00:12:50
Loop Top Label and Condition Check 00:14:28
Conditional Jump Setup (jl) 00:15:07
Handling Jump Distances 00:15:34
Loop Body – Printing Current Number 00:16:58
Update Part – Increment Counter 00:18:40
Unconditional Jump Back to Loop Top 00:19:14
Loop Done Label and Exit 00:19:55
Printing Goodbye Message 00:20:23
Testing the Program 00:22:08
Final Results and Demo 00:22:24
Outro and Call to Action 00:23:25
Thanks and Subscribe Request 00:23:45
Website and QR Code Mention 00:24:38
Closing Thanks 00:25:16

=-=-=-=-=-=-=-=-=

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 teach you how to implement for loops in YASM x86-64 assembly.

Although if you’re using a different type of machine or a different assembler,

this video should still be useful to you because it’s mostly about the concepts involved in implementing a for loop.

Okay, so for starters here, what am I even talking about? Let’s do…

are you even talking about dude imagine in a higher level language we have a for loop here

and so we have like four size type i equals zero i is less than 99 i plus plus right probably most

programmers looking up assembly uh on the internet probably are interested in uh or probably already

know how to implement for loops in c plus plus so let’s just pretend that you do and so inside of

your for loop we’ll do stuff and what happens here is uh well you know this for loop is going to run

Well, you know, this for loop is going to run 99 times.

It’s going to start at zero.

And, you know, so we have like an initialization part right here.

Maybe I should copy paste this and kind of break down the parts.

We have an init part here for the for loop.

We’ll say init part.

And then here we have a check part.

We’ll continue to loop as long as this expression is true.

You can make a big complicated expression if you want to,

but we’ll just keep it simple for this video.

So I’ll call this the check part.

And then we have sort of an update or a maintenance part.

an update or a maintenance part. So I’m going to call this the update part where we increment our

counter variable, move pointers, even call functions, do whatever it is you think you need

to do to update the loop so that it runs it, you know, so that the loops don’t actually have to be

integers. But in this case, I think it’s better, it’s easier to understand what the loop is doing

if we just kind of break down these parts. Anyway, so what is really a while loop? Sorry,

but a while loop that breaks and has break has like a nit logic and breaking logic and checking logic just in specific places.

Imagine this. What if I said before the loop starts, I’ll let’s let’s say we’re going to do a while loop before the loop starts.

I’m going to initialize a variable size type I equals zero, right?

That’s the initialization part that’ll only happen one time.

And then when you have a while loop and it checks to see if it should keep going, that’s

the check part of the for loop.

So I’ll just say while i is less than 99.

And then for the update part, we just have to stick that inside of the while loop somewhere.

Depending on your logic, you might want to put it at the top or the middle or the bottom.

I’m going to put it at the bottom because I’m going to expect that it happens right

before we do the next check.

So I’m going to maybe do a comment here and call it the update part and I’m just going

So maybe if I update this code to print something, it’ll seem a little bit more clear.

Value of I is, and then I’ll just say I end L, and then I’ll copy paste that to here.

And then I can also put this inside of the while loop.

And now we have transformed our for loop into a while loop.

transform your for loop into a while loop it’s pretty easy to implement in assembly if you

already know how to implement while loops so i should again say that there are lots of parts

i don’t know if i said that during this video but there are lots of things in this video that i’m

not going to that i’m not going to explain specifically because i’ve already explained

them in other videos so for example implementing a while loop is in another video so if you don’t

already know how to implement while loops if you don’t know how to use conditional branching or

If you don’t know the basics of assembly, hybrid programs, make files, all the basic stuff that I’m going to skim over in this video,

then you should probably check out my other videos first.

But for now, I’m just going to assume that you know how to implement a while loop.

And really the lesson is, hey, just take your for loop and convert it into a while loop.

And then you can implement the while loop pretty easily.

That’s the secret as far as I’m concerned.

So imagine this now. Let’s do some assembly code.

I have a source code file here called looper.asm for assembly.

And you can imagine that I have a hybrid program running under the hood.

I’m not going to show you all the code involved.

I’m not going to show you the make file or the C++ driver that calls on this module.

We’re just going to write the assembly here.

So, you know, if you’re writing pure assembly at home to practice, that’s fine.

Just keep in mind, there’s like a few things under the hood that I’m not showing in this specific video.

So first off, I’m going to copy paste my data section.

paste my data section of my assembly program. The first thing to note is we have a bunch of

C strings here. We’re basically going to be telling the user, hey, we’re going to begin

the four tests. Maybe I should have capitalized for, I’ll leave it. And then we’re going to prompt

the user for a number. We’re going to say, please enter a number. The loop will print from zero to

the number minus one, which is like the typical four loop that you usually write in the most

and then we’re going to have a little prefix we’re going to say you know like an arrow and then we’re

going to print the number back to the user that we’re looping through so if the user enters a

10 it’s going to print the arrow 0 and then arrow 1 arrow 2 all the way up to arrow 9

and then when we’re done we’re going to print an ending message so this is nothing new if you know

assembly already just c strings that will print with system calls see my other videos if you don’t

And then a CRLF string, just basically doing a new line, a carriage return new line feed

on the system.

And then we’re going to output using system call code one.

And we’re going to use file descriptor one so we can print to standard output.

Okay.

So now the real fun begins.

Let’s start our text section, which is where the instructions of our assembly program go.

So I’m going to do text section, section text right there.

And I’m going to use two external functions to just help me input and output numbers to the user.

If you wanted to, you could use a system call that just inputted a character.

And then you could just kind of like loop printing various characters.

And like, let’s say if the user typed A, maybe you could imagine doing a loop that increases the character that they typed all the way until it hits Z.

Or if they hit, you know, F, it’ll just print F all the way to Z.

to z you could do that without using an external library for printing integers this video is not

about this library right here so i’m not really going to go over it but uh you know you could

hard code the start and end points when you’re practicing um you could you could use a different

library or a different function call to get the inputs you could use a system call just to input

one character um or you could you know use a hybrid program to to utilize printf and scanf

f. Either way I’m just going to be using these two functions just to like get input and output.

It’s not really part of the idea of looping. So now let’s start our entry point.

Our function is called looper. Since this is a hybrid program you can imagine there’s a C++

module elsewhere calling on the looper function and so that’s why I mark it as global so it can

be called upon. And then I have another function called for test. I don’t really know why I chose

it this way but i wanted to make another function that was called upon by our entry point here

so the looper function really doesn’t do anything except recall the for test function

so now let’s start the for test function actually maybe this is where the fun begins

so i’m gonna put it down here and so you can see the signature it doesn’t take any arguments it

doesn’t return anything it just does stuff and then i have a note to myself this is how we’re

going to use the registers we’re going to use r12 for the user’s number and then we’re going to use

And then we’re going to use R13 to keep track of where we’re going.

So let’s see.

I’m going to start by saying let’s preserve R12 and R13

because you have to respect the application binary interface, the ABI,

and that designates R12 and R13 as Kali saved registers.

If I don’t preserve those and my program is even a little bit complicated,

I’m probably going to be debugging forever

debugging forever or I’m going to just crash my program for no reason. So I’m going to just

do a push pop pair. Notice how the pops are in reverse order. This is not a push pop video,

but just so you know, I guess while I’m here, I’m going to copy paste my crlf function,

which really does nothing. It just prints out the crlf string with a system call. That’s all

Okay, so do I even need CRLF in this program?

I think I just modified this.

Maybe I don’t even need it anymore.

No, I guess I do.

The first thing we’ll do is we’ll print an introduction message to the user.

So inside of the for test, we’ll just use a system call to print out, you know, a welcome

message to the user.

And then I’m going to call CRLF, which will just give us a new line.

And yeah, you can hard code, you know, the 13, 10 at the end of these strings, but I

don’t really like doing that.

doing that. Okay, so we should have a working program at this point. Let me see if it actually

does work. Clear and make run. Okay, so the driver prints a little welcome message. You don’t see the

driver code, but that’s what it’s doing. And then the for test prints the welcome message that we

just added. And then the driver lets us know it’s retained control. And then it’s responsible for

returning to the operating system for us. Okay, so then the next thing we’re going to do is we’re

we’re going to ask the user for a number so that we know how many times to loop.

And again, you could hard code this number if you don’t want to do IO right now.

You could even print a character a certain number of times

if you don’t want to even deal with printing an integer.

But I’m going to ask the user for a number.

That’s going to be the prompt string.

And if we run it again, now you should see it asks the user for a number.

So it’s going to say, please enter a number.

The loop will print from zero to N minus one.

print from 0 to n minus 1. It doesn’t actually ask for the number though. It doesn’t actually

I guess take the number so that’s going to be my external library that this video is not about

where I just call a function called input assigned 64 integer and I’m going to receive that back in

rax and I’m just going to save rax into r12. So r12 is now going to be the number that the user

inputted and that’s why up here I have it designated as the user’s number. So really not a big deal but

a big deal but uh you know if we run it again it’ll ask for a number and then it won’t do

anything else it’ll just kind of quit okay so now we can implement our for loop this is going to be

a little tricky so we’re going to start off with the initialization part remember we had several

parts here if i just kind of drag this off to the side maybe pin it up to the top so we can see it

aren’t we? If I move it a little bit to the side. So remember that for loop, it’s got an init part

and a check part and an update part. And I’ve kind of added that as a comment just to remind myself

of the way my mind is supposed to be wrapped around this concept. And so I made another comment

here with four and then empty parentheses just to denote that some comments that come below

I guess the top of the for loop

So now I’m going to make a label here and what I like to do with my labels is I like to

prefix them with the name of the function that I’m currently in and then an underscore and that kind of helps me keep track of

My symbols a little bit more easily, especially if I have a large module the symbols are less likely to overlap if I prefix them with the

The function names

to be Fortest underscore something and since I’m only doing one thing inside of the Fortest function

I’m just going to have a suffix only for the most part but you can imagine if you had more

parts inside of your function and it started getting a little cluttered you might want to have

you know another label you know that just sort of another I guess like part to your label that names

the part of your function you’re in although this is assembly it gets really hard really fast so

really hard really fast so if your function is even a little bit complicated you should probably

consider breaking it up into multiple functions if you can. We can’t really do that at this point

because it’s just a for loop but keep that in mind. Okay so we’re going to initialize. Remember

the first thing we had to do to initialize was you know setting i to zero or you know whatever

it is that we’re going to set up in the init part so I’m just going to do that here. I’m going to say

That’s the first part, the update part where we set size type i equals zero.

In fact, maybe I could do another copy paste of this.

Where instead of using a size type, we’ll just say that the register r13 equals zero.

I know that’s not going to make sense in a higher level language right now,

but just so that the for loop looks a little bit more like assembly.

We’ll keep going as long as r13 is less than r12.

and then we increase R13.

So I’m just going to put ink R13

so it looks more assembly-like,

even though this completely and totally

would not compile in C++.

I hope that this helps your understanding a little bit.

So yeah, we can do everything

except for just the increase part at the very top.

I’m going to choose to increase it at the bottom.

If you wanted to, I guess you could start off R13

as a negative number and then increase it at the top.

But I personally don’t feel that’s like very clean.

feel that’s like very clean it also forces you to use signed integers maybe you wanted to use an

unsigned integer so you could get like a gigantic um maximum number that you looped up to i don’t

know so we’ll just initialize here and we’ll say r13 is equal to zero the init part should not be

part of the actual like looping like every time you loop up to the top of the for loop you should

not repeat that part again it should only happen once so the next label that i have is called loop

have is called loop top and that’s just going to be the top of the loop that I

continue to go back up to every time I want to see if we’re supposed to

continue looping and then go into the loops body so maybe I should say that’s

why this is named to underscore loop top and I don’t know you don’t have to do

camel casing and your labels you know you could just do loop in it or whatever

but I’m just choosing to do it this way so at the top of our loop we’ll be

Remember that was the check part, right?

So we’re going to check to see that R13 is still less than R12.

If it is, we’ll continue with the for loop.

If it’s not, then we jump out of the for loop.

So that means probably the true case where R13 is indeed less than R12,

that’s going to be a short jump just into the loop’s body.

And the false case where R13 is not less than R12,

that should probably end up being a much longer jump.

on how big your your loop is maybe that jump is too long too far away for a conditional branching

instruction to reach if you’ve watched my previous videos you should know already that

the conditional branching instructions like jl like jump less than they can only reach about 128

bytes away if you try to go further than that the assembler will actually stop and block you from

finishing your compilation it’ll say i think it’s like jump out of range or something like that

So you want to try to keep the short jump points with your conditional branches.

And then in the false case, where the conditional branch doesn’t actually do anything,

then it falls through to the next instruction where you will have an unconditional jump.

And remember, the unconditional jumps, they don’t have a limitation of 128 bytes.

They can jump like all over the place.

Like they can jump anywhere, basically.

that means if you think about it, we come in to the loop top right here.

We immediately do a compare instruction and a conditional branch.

So if R13 is less than R12, meaning we should continue to for loop,

then we’ll just do a short jump into the loop’s body and actually execute its body.

And if not, we will end up falling through to line 92,

where there’s just an unconditional jump instruction that just says,

all right, let’s jump all the way down to being done.

Let’s jump all the way down to being done, which could be very far away for all we know.

Okay, so we’ve done that.

Now let’s implement the loops body because the first thing that we did is we wanted to

jump into the loop body to actually execute our instructions, which in this case, we’ll

just be, you know, printing a number every time we loop and then increasing that number.

So I’m going to do a little like new line there.

I’m going to paste the loop body.

little comments to help remind myself that this is actually the loop’s body. So for test loop body

that takes care of the branching instruction, hitting on that and actually going into the body.

And then later we’re going to have to implement a label for the loop being done. But for now,

we’ll just say the body. What does it do? It just prints a little message to the user.

If you look at the message for current number string, if I go up real fast,

message for current number, it’s just an arrow. So the user’s going to see an arrow and then

So the user is going to see an arrow and then their current number, I guess of the loop’s

current number.

And then every time it loops, it’s just going to continue printing that arrow with a number

on it.

So we’re doing that.

And then we’re going to say R13, which is the current counter variable, which started

at zero is going to get loaded into RDI, which if you watched my other videos, it’s just

the first integer argument for a function call.

So I’m just going to call this other function here, which is not part of the video to just

which is not part of the video to just say hey please print this number for me so the first

time this iterates it’s going to print zero because it’s going to print r13 and then it’s

going to print a new line so that the cursor goes to the next you know line of the terminal

so that’s all the body does it just kind of like prints the current number with an arrow and does

a new line and then at the very bottom of the loop body we just sort of maintain the for loop this is

for loop this is going to be the update part so like let’s see maybe scooch this up a little bit

the update part where we have let’s see on the very right side of the for loop which is like i

plus plus or in more assembly speak increasing the counter variable so i’m just going to increase r13

and then that way the loop can progress you know we’re always looking at r13

to decide if we need to stop or not you know we’re comparing r13 to r12

So we’re just increasing at the very bottom of the loop and then we unconditionally jump back up to the top.

Probably a better idea to unconditionally jump back up to the top because maybe the jump to the top is very very far and if it’s greater than 128 bytes it won’t work.

So the regular jump instruction doesn’t have that limitation. So now we’re jumping up to the loop top.

So you can imagine now that you know we’re not going to the initialization part. That would be bad.

We’re just jumping up to the top here where we immediately ask you know are we done?

If we’re not done, we jump into the loop body and print another number.

And then at the very bottom of the body, we say, all right, increase the counter and then jump back up to the top.

So this is a simple for loop, but you can see what it’s doing, right?

It’s just going to be printing a number over and over again as the number increases.

And then eventually it’ll stop when it hits the correct number.

The last thing we need is the loop done label.

If you look back up at the top here on line 92, if R13 was not less than R12,

less than r12 then execution would fall through to line 92 and there is our unconditional jump

instruction basically saying if r13 is not less than r12 then we’ll jump to the loop done label

which means we’re just totally finished with this loop so we have to make that real fast

and all it’s going to do is just basically say goodbye it’s just going to print a message to

to the restoration functions.

Oh, did I ruin my return somewhere?

Uh-oh, what did I do wrong?

I lost my return statement.

Did I accidentally delete that somehow?

That’s a bad program.

Or did I not even…

Hmm, I wonder if it like…

I wonder if I didn’t have my return statement

and it fell through into the CRLF function

and then the CRLF function returned to the caller

to the caller on behalf of the for test function I don’t even know only all only

the spirits know at this point I don’t know leave a comment or something if

you know what happened but every function has to have its own return for

sure so you know the loop done label is usually where you want to jump to when

you know the for loop is finished or the while loop is finished when it comes to

saying goodbye it probably would be a little bit more clear of me to add an

you know for test you know say goodbye just so that I that I remember that this

is this is the place where we’re done and this other place this is just

something else that’s happening maybe I’m doing more instructions or more

operations or calling a function or whatever so obviously if I did it this

way then the loop done label would just end up falling through to the goodbye

label and it would be fine but it’s just more visually clear I’m gonna take it

Anyway, so at this point we might have a program that actually works.

Let’s see if it does.

What else do I need to add?

No, I think we’re done with that.

Okay, let’s try it.

So we’ll do a make run and we’ll enter the number five and let’s see if it works or it

crashes.

It worked on the first try.

So I had a solution though.

Not fair, but I could have typoed.

Anyway, so it says we entered a five, the loop will print from zero to N minus one.

print from zero to n minus one so we should see from zero to four and so then every iteration of

the loop it’s just that little message we’re just printing a zero printing one printing a two you

know the number increases because we did did that little inc instruction the increase instruction

we unconditionally jump to the top of the loop where we decide if we’re supposed to uh finish

you know be done with the loop by jumping to the done label eventually after we uh let’s see

it prints this four here it’ll do the increase instruction at the bottom of the loop’s body

and then it’ll jump to the loop’s top then the loop’s top will see that it’s a five because we

just increased the four it will see that five is definitely not less than five so that’s a false

which means execution will you know fall through where the heck is that it’ll fall through to the

line 92 jump instruction which is just the loop being done so that’s here where it says goodbye

says goodbye and then we have successfully implemented a basic for loop

all right so thank you so much for watching this video I hope you learned

a little bit and had a little bit of fun I will see you in the next video happy

coding and happy studying hey everybody thanks for watching this video again

from the bottom of my heart I really appreciate it I do hope you did learn

hope you did learn something and have some fun. If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos or whatever it is you do on the

current social media website that you’re looking at right now. It would really mean the world to

me and it’ll help make more videos and grow this community. So we’ll be able to do more videos,

longer videos, better videos, or just I’ll be able to keep making videos in general. So please

and subscribe. You know sometimes I’m sleeping in the middle of the night and I just wake up because

I know somebody subscribed or followed. It just wakes me up and I get filled with joy. That’s

exactly what happens every single time. So you could do it as a nice favor to me or you could

you could troll me if you want to just wake me up in the middle of the night just subscribe

and then I’ll just wake up. I promise that’s what will happen. Also if you look at the middle of the

screen right now you should see a QR code which you can scan in order to go to the website which

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 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 For Loops Explained – YASM Tutorial appeared first on NeuralLantern.com.

In this detailed tutorial I walk you through exactly how to implement while loops in x86-64 assembly language using YASM. We start with the basic concept of a while loop as it exists in higher-level languages like C/C++, then break it down into labels, conditional jumps, and unconditional jumps so you can see exactly how the control flow works at the assembly level.

I explain why we usually put the condition check at the top, how to handle the jump distances (especially the ~128-byte limit of conditional branches), why unconditional jumps are preferred for the loop-back, and how to structure init / top / body / done sections clearly.

We then build a complete, runnable hybrid program (assembly + tiny C++ driver) that:

• prints an intro message
• repeatedly asks the user to enter numbers
• echoes each number back
• continues until the user enters 99
• prints a goodbye message when finished

Lots of practical tips about label naming conventions, register preservation (R12 in this case), and debugging flow are included along the way.

Assumed knowledge: basic x86-64 assembly, how to use a makefile, simple system calls, and calling external functions. If you’re new to those topics, check my earlier videos first.

Hope this helps someone finally “get” while loops in assembly!
Thanks for watching – subscribe if these kinds of low-level explanations are useful to you.

Introduction to While Loops in x86-64 YASM 00:00:00
While Loop Concept in High-Level Languages 00:00:56
Breaking Down While Loop Structure 00:02:00
Labeling Key Sections Top Body Done 00:02:40
Conditional and Unconditional Jumps Explained 00:03:26
Why Prefer Shorter Conditional Jumps 00:04:40
Diagram of While Loop Flow 00:06:52
Alternative While True with Internal Break 00:08:08
Do-While vs Regular While Difference 00:09:32
Program Setup and Data Section Overview 00:09:53
Hybrid Program Structure and External Functions 00:10:56
Main Function and While Test Call 00:12:56
While Test Function Prologue 00:13:21
CRLF Helper Function 00:14:00
Intro Message and Loop Initialization 00:14:50
While Top Comparison with 99 00:16:57
Entering the Loop Body 00:19:08
User Input and Echo Output 00:19:38
Jump Back to While Top 00:20:29
Exit to While Done Section 00:21:39
Goodbye Message and Function Epilogue 00:22:14
Live Demo Running the Program 00:22:30
Summary and Closing Remarks 00:23:12
Call to Subscribe and Website Mention 00:23:46

=-=-=-=-=-=-=-=-=

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

All right, hello there. In this video, I’m going to teach you how to implement while loops in YASM

x86-64 assembly. Although you probably don’t need to be using YASM assembly to understand

this video or to benefit from it. So what am I talking about? First off, okay, so we’re going

to do while loops. There’s a lot of assumed knowledge in this video. If you don’t know how

assembly program, if you don’t know how to make a make file, if you don’t know a lot

of the basics that I’m just skimming over in this video, you’ll need to see my other

videos because I explain all of those things at length.

For this video, I’m just going to be talking about while loops only.

So for starters, let’s see here and open up a little notepad here and just type a while

loop and try to explain a little bit about it conceptually.

And then after that, we’re going to, we’re going to write a program in Yasm to show that

we can get this to work.

So what is a while loop in a higher level language?

We’ll just suppose C or C++.

You can imagine whatever language you want, but typically in a while loop,

we’re not talking about a do while loop, although that would be really easy

to implement after watching this video.

But in a regular while loop, you have the keyword while usually,

and then you have some sort of an expression like does a equal B or whatever.

So maybe I’ll just say does a equal B?

Expression evaluates to true then the body of the while loop will execute and then when it’s done executing

Execution will go back up to look at the expression again and make sure that it’s still true

So the loop will run forever until that expression evaluates to false

Maybe that’s what you want. Maybe that’s not what you want, but that’s what it’ll do

And that means the body runs an endless number of times

Also, if the expression evaluates to false on the very first run

then the body of the while loop will just never run at all.

So that’s, you know, a basic idea of a while loop in a higher level language.

Hopefully you kind of already know that.

So let’s look at the parts right here.

If we imagine this as assembly,

then probably the first thing we should do is label the part

where we look at the expression and decide whether we’re going to continue or not, right?

So I’m going to put a little label here

and maybe we’ll call it a while top or something.

You know, whatever you want to do.

just to label the part of the code

So that we know when we write assembly

We’ll be able to put the appropriate labels on the different parts of the while loop and we’ll be able to imagine

The while loop that we’re implementing in assembly

So I’m gonna say this is the top or you can call it the eval part whatever you want

Then we’ll make another label down here. We’ll call it

You know while body something like that and so basically if we want to jump up to the top of the while loop to evaluate the

expression, we just have to basically jump to that label called while top.

And if we want to jump to the body to actually execute the code,

then we just have to jump to that other label instead. We should also have a label at the

very bottom after the whole while loop is over and we’ll call it, you know, while finished

or while, whoops, finished or while done or while over something like that. So I’m just going to

Now you can imagine that when we’re at the top of the while loop and we see that the

expression is false, then we can just jump down to the done label, thereby exiting the

entire while loop.

Then of course we probably want to have some jump statements in here.

So for example, the expression part here, it’s probably going to jump either to the

body or either to the done area based on whether or not the expression evaluated to true or

false.

label while top you know which contains a conditional branch and then like an unconditional

jump so if a condition is true maybe we can jump into the body if the condition is false we’ll fall

through to the next statement and do an unconditional jump to the done label if you don’t

know conditional branching this is another one of the topics that i’ve covered in previous videos

as we implement the while loop.

So just keep in mind, there are other videos that I have

that you should watch first

if you don’t understand conditional branching or jumps.

The reason that I’m going to kind of design

the jumps like this where I’m going to say,

let’s do a conditional branch.

And basically if the loop evaluates to true,

we’ll jump into the body of the loop.

And if it doesn’t evaluate to true,

then the conditional branch will allow execution

to fall through down to the next statement,

which will simply contain a jump to the done portion.

to the done portion so basically as soon as the while loop is ready to break it gets uh implemented

by an unconditional jump which was fallen through to by the conditional branch that would only jump

into the body if uh expression was true i’m doing it this way because it’s usually a shorter jump

uh to jump to the true area you know the the body of the while loop and remember conditional

branching instructions have a maximum you know jump reach of about 128 bytes so if you try to

128 bytes. So if you try to jump too far, like for example, if you wanted to, you could reverse

the logic to where you could say, if an expression is true, let’s jump to the done portion and say,

we’re going to break the loop. If the expression was false, we’ll jump into the body. You could

do that. But then if the body of your while loop was too long, maybe it was so long that the last

instruction was greater than 128 bytes away from the top. Then by the time you wanted to

let’s see yeah if you have if you have too long of while loops you can’t jump more than 128

instructions away so that’s a limitation of contentional branching so I just I want to put

the biggest jump on an unconditional jump instruction because it doesn’t have a limitation

like that I was having a hard time imagining what I was about to say just now for the

the reversal I guess I’m just going to ignore the reversal scenario and we’ll just do it the

and we’ll just do it the regular way.

Anyway, so we want to have a conditional jump that either jumps into the body or to the done area.

And then at the very bottom, we want to have an unconditional jump to the top,

which basically means every time we get to the bottom of the while loop body,

we’re just going to jump up to the while top.

Actually, I’ll just say to while top.

Remember again, the regular jump instructions,

maybe I’ll take out the U here.

The regular jump instructions don’t have a limitation

on how far they can jump.

So that should be fine.

And that’s the basic idea of implementing a while loop.

Maybe I should draw just a quick diagram

before we start looking at the code,

just to make sure everybody of different learning styles

understands what I’m talking about.

So we’ll, let’s see, eval.

I’m still adjusting my pen and you know what?

You know what? It looked a lot better before I hit record.

Eval the expression.

So I’m going to first evaluate the expression.

If it evaluates to true, we’ll put a green arrow here and I’ll put like a T for true.

Then this will be the body of the while loop.

I’ll say like the body.

If it evaluates to false, let’s see.

I’ll just put that in red and I’ll put an F here then this is just going to be the done area

right so you can imagine we evaluate an expression using the compare instruction in assembly and

based on the results of comparing something whatever it is that your condition is then we

you know we we either branch to the done area or we branch to the to the body area

want to have a more complicated while loop and you don’t want to put a huge

amount of expressions or if you don’t want to logically concatenate a bunch of

different components into the expression you know that’s fair I usually write my

while loops in real life as just while true and then I break when certain

conditions are met you can do that too we’re not going to talk about that in

this video but you could just have a while true so you always jump to the top

and there’s no branching that goes to while done but then throughout the loop

loop you can just sort of check to see if certain conditions are met and if they are then you’ll do

a branch to the done area and if they’re not then by the time you make it down to the bottom of the

loop then it just automatically jumps to the top although you got to make sure with the the reach

of conditional branching you probably want to test to see if your condition is true or false or

whatever if it means we’re going to continue the loop then you probably just want to do a conditional

then you probably just want to do a conditional branch that jumps down a little bit

so that it can continue the body of the loop.

And then the part that it skipped over,

just a little part should be an unconditional jump that jumps out of the loop.

That way, it doesn’t matter how big your while loop body is,

you can always jump out of the loop.

But we’re not going to talk about that in this video.

Anyway, so we evaluate the expression.

If it’s true, we go to the body.

If it’s false, we go to done.

After the body is done executing,

then we just jump back up to the top where we evaluate the expression.

where we evaluate the expression.

I’ll put while here just to make it more clear that we’re talking about the basic

idea of a while loop.

Not too hard, you know.

And then if you wanted to implement a do while loop, just make sure that you always

evaluate the body at least once.

That’s really the only difference.

But that’s up to you.

This is just a regular while loop video.

Okay.

So we’ve kind of talked about it a little bit.

We’ve sort of, you know, drawn it out in a diagram and put some regular code in.

and put some regular code in let’s set up an actual assembly program that will do this so for starters

again i’m not going to show you my make file because i’ve already made other videos where i

explained how to make a make file from scratch same thing goes for hybrid programs i’m going

to have a driver which is a c plus plus module that just sort of calls on this assembly module

if you want to know how to make hybrid programs or you know drivers or you know whatever see my

to be talking about looping only. Okay, so let me get my solution up here. My source code is called

looper. And I’m just going to copy paste the data section for my program real fast, just so you can

see it. Okay, so here’s the data section. Again, this is not a basics for assembly video. If you

don’t know how to do a data section in Yasm, see my other videos. But for now, I’m just going to say

like the actual array of bytes and then a length and all I’m doing is printing out messages you

know begin the wild test your numbers will be printed back to you until you decide to quit so

that’s going to be printed to the user right away then every time the program wants a number from

the user it’ll just ask you know please enter a number or 99 to quit and then it’ll prefix

the echo back it’ll say you entered and then it will actually print the number and then when you

we’re done and i’m going to use an external uh function that i have available to just kind of

like input and output numbers this video is not about uh input and outputting and external libraries

if you’re interested you could probably just link a hybrid program and use printf and scan

f to very easily do input and output but that’s not what this video is about see my other videos

then i have crlf which is just a carriage return in line feed uh you know select the cursor goes

You know select the cursor goes to the next line and then I have like a system call code to just print and

Then a file descriptor just to print a standard output again. That’s explained in other videos

So now I’m ready to start copy pasting the main portion of my program

So first off I’m going to start the text section, which is where the instructions go in the ASM

So there it is and then I’m going to copy paste

of external symbols. So I just have a little library that I’m using that makes it easier for

me to input and output integers. So you can do this any way you want, or you can hard code a

number in the globals area. If you don’t want to deal with input and output while you’re learning

how to do loops, that’s totally fine. But then the entry point is going to be a function called

looper. So this is my function. And again, this is a hybrid program. So the main function or the

be present in my assembly module the driver is going to be a c plus plus module that just calls

on a function named looper so that means this function is going to get called from another

module and that’s why i have to mark it as global and then it is a function so i’m going to call

return at the end of it to say we’re done and then within this function i’m just going to call two

other functions that i’m about to create one is called while test which is going to actually do

the while loop and the other is called crlf which just print which just prints a new line for me i

which just prints a new line for me.

I don’t know why I do it that way, but I want to.

Sorry, not sorry.

So this is the real meat of the function here.

Let’s start, well, the real meat of the code or the video.

Let’s start a function called while test.

You can see it’s got a void signature with no arguments,

so it doesn’t really, you know, take anything or return anything.

I’m going to use register R12 to hold the user’s input

so that I can, you know, print it out and stuff.

print it out and stuff so that means I have to do a preservation of R12 because it’s a

callee saved for the ABI which you should respect so I’m going to push it at the beginning

and then I’m going to pop it at the end and then this is a function so I have to return

at the end of the function let me just double check that there’s nothing else weird at the

bottom of that nope okay so we’ve got the prologue and epilogue the wild test function

maybe I should copy paste my crlf real fast my crlf function it’s just sad but

it’s also kind of cute right it does nothing except just print out a new line

that’s all it does this video is not about that so at this point I should

have a program that probably works let’s see if it does I’m gonna do clear and

make run again if you want to know how to use make files or compile or link or

anything like that see my other videos so I’m gonna run it and it just says

which is some code that we’re not looking at.

And then it says it’s regain control.

And this line in the middle, which is just an empty new line,

that’s definitely from the assembly program.

Because at the top here we have CRLF.

If I call it multiple times CRLF,

then you’ll see there are multiple blank lines.

All right, I’m gonna take that out.

Now let’s continue with while test.

So what should we do here?

The first thing that we should do is print an intro message

message just to let the user know that we’re about to you know begin our while

tests and if we run the program one more time we should see that message now

begin the while test your numbers will be printed back to you system calls and

simple printing is covered in other videos so now uh you know for me I kind

of like to init all of my loops even if it’s a while loop and not just a for

loop or anything so I always have an extra label that I like to call init

or before or something like that.

So I have a label now called while test underscore init,

and it’s just where I’m gonna initialize

whatever it is that I think I need to initialize

so that the loop will actually work.

If you look here, all I’m really doing is setting R12 to zero

because what I’m gonna do is stop the loop.

I’m gonna break the loop whenever the user enters a 99.

So I don’t know what’s inside of R12

when we first start this function.

And I just wanna make sure that it’s not 99,

the stopping number at the very start so I’m just going to set it to zero. So

another note about my labels you don’t have to do it this way but I love to

write labels where the first part of the label is always the function that the

label is inside of so notice how the function is named while test and so my

label is always while test underscore something and I’m putting init here

just to say we’re initializing the loop but if you had a function that had a

had a lot of stuff going on in it for starters you should probably be breaking up that function

into multiple functions but but assuming you didn’t uh you should probably do another underscore

and then like another component and then another underscore based on what giant chunk of your

function you’re inside of so if there was like an if part a while part an input part an output part

you probably want to you know stick that into your labels your labels will get huge but for me

infused in assembly and this makes it easier.

So we’re going to initialize so that we can run our while loop and then the next thing

we’re going to do is implement the top of the while loop.

So remember if we looked at this code up here, maybe if I drag this over to the side and

pin it to the top for a little while, you can see that the top of the while loop is

where we kind of evaluate the expression to see if we need to keep going or not.

jump into the ending area, the done area. So the top, whoops, the top is always for that.

We’ll say first, I’m going to ask, are we done? So, you know, how do we know if we’re done?

In this particular while loop, we want to compare the user’s input, which is R12 to the number 99.

And if it’s equal, then we will quit, which means also if it’s not equal, we will jump into the

So by the way, you’re probably wondering how did R12 get the user’s input?

Well, we’re going to do that as the next step.

And of course, your design pattern may vary a little bit.

No, that’s okay.

I just like to implement it this way.

So first thing we’re going to do is compare R12 with 99.

And that’s why I’ve written this comment here, just like the blank while comparison part.

And I guess I could have put this R12 not equal to 99 up at the top, but then it kind

of feels like I’m leaving these other two instructions.

So I moved it down one.

these other two instructions so I moved it down one so basically as long as you know we compare

R12 and 99 compare and conditional branching is covered in other videos but we compare those two

values and then we say if R12 is not equal to 99 then jump to the body and we expect that the body

will be like a short jump which will be within the range of a conditional branch

So anyway, if the not equal branch didn’t happen, that means R12 is equal to 99.

At that point, execution falls through to line 84, and we’ll just unconditionally jump out of the while loop.

So basically we’re saying, if it’s true, we continue looping.

If it’s not true, we just jump outside of the loop.

We’re just totally done with the while loop.

Okay.

So then we need a body, because obviously we’re going to jump into the body here.

that means I’m going to just copy paste another little set of code here.

Right after that unconditional jump.

So now we got the body.

Notice how I put a little comment here that has a brace just to indicate to you,

hey, this is the beginning of the actual while loop body,

just to make it a little bit more clear.

And what are we going to do inside of the body?

We’re just going to ask the user for some input.

So I’m printing a simple message here,

and then I’m calling on my helper function

to just actually input a number from the user.

I’m going to store that number into R12.

So that’s how R12 gets the numbers, gets the user’s input.

And the way I’ve written this, if the user enters a 99,

it’ll echo it back to the user and then it’ll break the loop afterwards.

So, you know, if you wanted to rearrange things like I talked about before,

where you input before you check to see if you’re going to keep going, you could do that.

But it would be a little harder to echo the user’s input back to them before you break.

I don’t know. It’s up to you.

I don’t know it’s up to you anyway so we grab input from the user and then we print another

message basically saying here’s the thing that you inputted no problem and then again we use

one of my helper functions to actually spit the number back out at them so this is not

a very complicated body it’s just asking for a number and then printing the number back to them

and then after that I’m going to do another label and I’m going to call it the body bottom

we don’t really have to do this label but for clarity I think it’s probably a good idea

I think it’s probably a good idea.

So the very bottom of the while loop’s body is usually where you don’t do any more instructions

that are part of the work of the while loop’s body,

but just sort of the place where you jump back up to the top

so you can evaluate and decide to continue or not again.

So notice how I’m using an unconditional jump here.

That’s a good idea because again, if you have like a huge while loop body,

you might end up surpassing the threshold of 128 bytes

of 128 bytes and then you’ll get a assembler error that says

I can never remember this. It’s like a

jump out of range error or something like that. Basically, if you do a conditional branch to jump up the top

because some people like to check to see

if they should continue the loop, they like to check for that at the bottom. I’ve done that before.

And then if true, then we’ll jump to the top of the loop. But if the loop is too big, that won’t work. So

I just like to take a long jump to the top of the loop and then decide if I’m going to keep going at the very top.

if I’m going to keep going at the very top. And then there’s a comment saying, hey, that’s the

end of the body. Okay, no problem. Now let’s do the done label, which is basically where we jump

if the loop is actually finished. So remember, if this expression right here evaluates to false,

then execution is going to fall through to line 84, where we jump to this while test done label.

And so I’m just going to put the while test done label right here. So we’re done. So the done is

So we’re done. So the done is not part of the loop. It comes after the loop. That’s this right

here on line nine of the little notepad. And we can just kind of do whatever we want. At that

point, we can return to a caller, we can just do other stuff, we can, you know, do a different

loop or, you know, whatever, we’re just done with the original loop. For me, I’m just going to say

goodbye with this little print to just sort of like, you know, print an exit message. And then

we’ll do the epilogue where we restore R12. And then we just return to the caller,

the driver worry about exiting the program okay so if we’ve done this correctly we should now have

a working program let’s see let’s see okay let’s enter a number let’s do 22 and it says you enter

22 and let’s do 55 and we just we can enter any numbers we want and as long as we’re not entering

99 the program will just continue forever so this is a while loop if i want to quit i do 99

breaks at the top it breaks by jumping down to the done area where we print our goodbye message

which just is end while test and then if we run this again if i do 99 from the start then it just

immediately breaks you know it prints out what you entered but then it immediately breaks

and that’s it that’s uh the basics for how to write a while loop you just use basically

layered on top of an abstract concept of what you think a while loop is,

or what I guess the world thinks a while loop is.

Okay, thank you so much for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Hey everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

if you could do me a please a small little favor could you please subscribe and follow this channel

or these videos or whatever it is you do on the current social media website that you’re looking

at right now it would really mean the world to me and it’ll help make more videos and grow this

community so we’ll be able to do more videos longer videos better videos or just i’ll be able

to keep making videos in general so please do do me a kindness and uh and subscribe you know

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 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

it would really mean the world to me. I would really appreciate it.

So again, thank you so much for watching this video and

enjoy the cool music as I fade into

the darkness which is coming for us all.

Thank you.

The post x86-64 Assembly While Loops Explained Step by Step in YASM – From Concept to Working Program appeared first on NeuralLantern.com.

In this practical x86-64 assembly language tutorial we dive deep into conditional branching using YASM (also works with NASM) on Ubuntu/Linux.

We cover:

• The CMP instruction and how it sets the RFLAGS register
• All major conditional jump instructions (JE, JNE, JL, JLE, JG, JGE, JB, JBE…)
• Important difference between signed (JL/JG) vs unsigned (JB/JA) jumps
• Real code examples showing how to implement if-style decisions
• How to handle the “jump out of range” assembler error
• Visual flow diagrams explaining control flow

Perfect for students learning low-level programming, reverse engineering, operating systems, or anyone who wants to understand how if-statements, comparisons, and decisions are actually implemented at the machine level.

Highly recommended companion resource: Professor Ed Jorgensen’s free x86-64 Assembly Language Programming book (linked in comments).

Enjoy learning assembly!

Intro to Conditional Branching in Assembly 00:00:00
Recommended Book: x86-64 Guide by Ed Jorgensen 00:00:23
Unconditional vs Conditional Jumps 00:01:39
How Conditional Branching Works 00:02:06
The CMP Instruction Explained 00:03:21
Overview of Conditional Jump Instructions 00:04:50
Signed vs Unsigned Jump Instructions 00:06:10
Jump Equal & Jump Not Equal (JE/JNE) 00:07:00
Main Conditional Jumps Summary 00:08:14
Starting the Code Example 00:09:09
Program Structure & Printing Setup 00:10:35
Function Prologue & Getting User Input 00:13:21
First Branch: Is Number Greater Than 0? 00:15:17
Live Demo: Testing Greater Than Zero 00:21:53
Second Branch: Is Number Less Than 10? 00:22:52
Live Demo: Testing Range 0-10 00:26:06
Third Branch: Is Number == 5? 00:26:52
Live Demo: Testing Equal to 5 00:28:00
Jump Out of Range Error & Workaround 00:29:00
Final Summary & Closing 00:32:17
Thanks & Call to Subscribe 00:32:57

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to Blog: https://www.NeuralLantern.com
• Watching the main “pinned” video of this channel for offers and extras

Hey there. In this video,

we’re going to talk about conditional branching in an assembly program.

We’re going to be looking at YASM x86-64 assembly or AMD 64 assembly

within Ubuntu, but this will probably be a useful video.

If you’re just thinking about how to branch in assembly in general.

So for starters, I’m going to promote one of my favorite books,

as I often do. This is a book that is free and open source. You can get a copy yourself. I did

not write this. The author of this book is a genius. His name is Professor Ed Jorgensen, PhD.

He made this whole book and released it under an open source license. So you can literally just go

to his website and get a copy of this for free. You can use this to make yourself into an assembly

expert. So I highly recommend this to everybody. Anyway, so I’m going to open up this book. I’m

up this book i’m going to assume that maybe you’ll get a copy or you’re just going to follow along

with what i’m doing on the screen but i’m going to open this book and i’m going to go to section 7

which is entitled instruction set overview i’m going to double click it so open out open the

subsections and then i’m going to click on 7.7 control control instructions and then under that

i’m going to click on 7.7.3 conditional control instructions so uh that’s a lot of subsections

So that’s a lot of subsections, isn’t it? I love a book with a ton of subsections. It makes things so much easier to find

If you or someone you know is going to write a book, especially if it’s technical, please use lots and lots of subsections

Anyway, so conditional control instructions in my last video

We talked about the jump instruction where we can just be sitting somewhere in our program and then just jump somewhere else

Anywhere we want based on the label so conditional branching or conditional control instructions

conditional control instructions are kind of the same thing except they will

decide whether or not to actually jump they might fall through to the next

instruction or they might jump away to somewhere else so conditional branching

or conditional jumping it basically kind of goes like this step one you compare

two values to each other they will probably be sitting in registers and then

conditional branching instruction or a conditional jump instruction there’s

lots of synonyms for these but basically in the regular jump instruction that I

just talked about in the last video you just jumped and it was only one thing

that you had to do but in this case we first have to compare two items and then

we’ll issue the jumping instruction because the jumping instruction will

have to decide whether to jump or not based on the result of your comparison

which makes sense right like if you’re going to implement something that’s like

if you know I’ll put like a expr for expression then well the first thing that we have to decide

before we jump either into the block of the if or if we jump into the block of the else is whether

or not that expression is true right so that’s kind of what the compare instruction is doing

sort of in higher level languages like c++ it can get a lot more complicated than that but you know

Okay, so we’re going to do conditional branching instructions.

Let me show you a few of those.

Okay, so for starters, here’s the compare instruction right here on page 126.

I think it’s actually 127 in the PDF, but basically, you know, 126.

We do CMP followed by two operands.

So if we want to compare, I don’t know, let’s say R12 with R13, that’s how you would do it.

just a two operand instruction there’s no results that are going to get stored in one of these

operands both of these operands are just for input the result actually gets stored in a special

register called r flags which we hardly ever use or look at in in the most common assembly

instructions and design patterns we just kind of like let the r flags do whatever it’s going to do

and the compare instruction will fill that up so imagine that you know depending on whether r13 is

is like greater than r12 or less than or they’re equal or something else is going on between the

two of them the compare instruction just fills up all sorts of flags defining the relationship

between those two registers or those two operands r12 and r13 and then after the r flags register

is all set up then the conditional branching instruction will sort of rely on r flags in

order to decide whether or not it’s going to jump or not okay so let’s see there are tons

there are tons of conditional well not tons i guess like half a page worth but there are lots

of conditional branching instructions we can use the first two i want to show you and after this

by the way i’m going to write a sample program just to show you how it is in practice but so the

first one is je which means let’s jump if the two operands were equal so again you know we compare

here we’ll say sets up r flags and then we’ll decide like what we’re going to do are we going

to jump if they’re equal to some label i’ll write some label here so that means uh the je instruction

will look at the r flags register and decide did compare think that r12 and r13 were equal if it

did then we’ll jump if not execution will fall down to the next line so i’ll put a nope instruction

So if they were equal, then we’ll end up jumping to some label.

And if they were not equal, we’ll end up letting execution fall through to the nope on line 10.

And same thing for jump not equal and all these other ones.

But there are actually two different versions of some of these instructions that kind of seem the same.

Like for instance, this one right here, JL, that means jump if the first operand was less than the second operand.

is a jump below that jumps also if the first operand was less than the second operand so

what’s the difference between these two let me get my pen I love excuses to do my little pen now

well I’ve got my pen it’s working oh I erased it okay okay it’s working anyway so notice how jump

less than and jump below are basically doing the same thing but there’s one difference one of them

One of them works on signed operands and one of them works on unsigned operands.

So keep this in mind.

If you’re comparing two signed integers, you want to use this group up here of instructions.

But if you’re using unsigned integers or just bits, then you want to use this group of instructions down here.

And you definitely want to know what kind of data you have that you’re comparing.

Notice though that jump equal and jump not equal, they don’t really care.

not equal they don’t really care if the operands are signed or unsigned that’s because if you want

to check to see if two things are equal you just look at all of their bits and if all of their

bits are the same then you just say they’re equal you don’t even care actually if it’s a signed or

unsigned integer if it’s a float if it’s a whatever you just you just go are all the bits equal or are

at least one of the bits unequal then we’ll say it’s equal or not equal that’s it so keep that in

mind for all of your jump instructions where you’re trying to see if things are equal or not

or not equal you’re going to definitely be using these whether you’re using signed or unsigned

integers or floats or anything else like that but when it comes to actually you know integers that

are signed or unsigned these are the instructions you use for signed and these are the instructions

whoops that you use for what have i done that you’ll use for unsigned i keep confusing the on

off button for the red button is what i’m doing oh okay whatever i guess we’re done anyway

I guess we’re done anyway.

So keep that in mind.

In this video, we’re just going to be using the signed integer instructions

because that’s the example that I have set up.

But just imagine you could very easily translate this to unsigned integers or floats.

Okay, so let’s see.

We’ve got jump less than, we’ve got jump less than or equal to,

then we’ve got jump greater than, and then we’ve got jump greater than or equal to.

And when you combine those with jump equal to or jump not equal to,

jump not equal to that’s pretty much all the comparison that you need and if you want to do

something much much more complex well then you can just you know start stacking logic on top of

logic and and branching on top of branching to do something that’s like this is what i’m talking

like if you want to do this expression and expression or expression and then maybe like a

expression, right? If you want to do something super complicated, like we can do in a higher

level language, you’re just going to have to make a bunch of mini jumps or find another

way to reduce your logic. But in this video, we’re just going to be taking a very simple

comparison. All right. So I think that’s everything that I can show you inside of this book. Let’s

go to the code now. So here’s a little empty code, source code, a page. I’m going to stick

all my code inside of it. Another reminder that if you don’t know how to write assembly

you don’t know how to write assembly at all you should see my other videos because i’m not going

to cover the basics of assembly in this video if you want to learn how to make a make file or compile

or assemble or like do all the basics that i’m not talking about in this video i’ve covered them all

in my other videos up to this point so for now we’re just going to focus only on conditional

branching conditional jumping inside of an assembly module so i’m going to start off by setting up my

and i’m gonna say paste and again you know this is covered in other videos but long story short

i’m just going to be printing out a bunch of strings while this program executes so

i’m going to announce that the branching test is going to begin and then i’m going to ask the user

for some input and then i’m going to based on whatever the user inputs i’m going to just print

out a message that sort of you know understands what the user inputted so if the user inputted

something greater than zero it’s going to output that if they entered something that was less than

10 it’s going to print that if they entered something that was equal to five it’s going to

print that and then it’s going to say we’ve ended the branching tests then i have like a crlf again

all this stuff is explained in other videos but we’re just basically printing so i’m going to

start the text section of my program which is where all the instructions are and i’m going to

a function that I can call on. Again, this video does not cover a bunch of other extra stuff. I’m

just going to show you how to branch. Just trust me when I say that this helps me easily print

numbers and things, or I guess in this particular case, it’ll help me input a number from the user.

But for you, if you’re trying to run this at home, you can just start hard coding numbers just to

make sure that you can branch correctly and then eventually work your way up to a library that can

videos in the distant future. I don’t know years from now. I don’t know.

I might release the library or some other stuff to the casual viewer.

So now here’s our entry point. Again,

I mentioned that there’s going to be other parts of this program that I’m not

showing. So this is a hybrid program where a C++ driver actually will call on

my cool function. So just imagine from somewhere else in the program,

you’re calling on the cool function. How do we know it’s a function?

a label called cool and then it has a return statement at the very end.

That’s pretty much all we need to know right now.

Let me get rid of that load.

I don’t know why I always have the word load in all of my things.

I think I put it in there on an early example

and then I just kept copy pasting to my heart’s content and never stopped.

We mark the function cool as global so that other modules can call on it

like the C++ module that I’m not showing you.

But if you’re writing a pure assembly module,

you don’t really need to mark your functions as global.

if everything’s within the same piece of source code it’s totally fine so then I’m going to make

a function call to a function called branch test so very quickly before I actually add branch test

I’m just going to add another function that we’re not covering in this video called crlf and long

story short all it does is just it prints a new line in the terminal and that’s it like it’s just

it’s a convenience function I like to be able to call crlf and have a new line okay so let’s start

our branch test function so here’s the signature it is just branch test with a

void in front of it I’m gonna put a ret to say that this is a function that we

will return from and I left myself a little note here saying that I’m gonna

use register r12 as the number that the user inputs so that means I’m gonna have

to preserve that because you have to respect the ABI and the ABI says that

The ABI says that R12 is a Kali saved register.

Again, see my other videos if you don’t know what I’m talking about.

But I’m just going to preserve it in a section that I call the prologue, or actually the

book calls the prologue.

I do that now though too.

And, you know, restore it in a section called the epilogue.

So we have prologue and epilogue.

We can have a push-pop pair.

And then in between, we can have, you know, the meat of our function.

Okay, so for the introduction, I’m just going to write a few instructions that just print

out a message.

print out a message. So we’re going to print out that intro message and then call

CRLF to print a new line and then return. So maybe actually at this point we could

probably check to see if this program works by trying to run it.

So let me say clear and make run.

Okay. So now the driver just prints hello. The driver is

elsewhere and we get that welcome message that says begin

branching test and then the driver retains control after that. So

let’s do let’s do a goodbye message real fast so we’ll do our goodbye message

it’s just another string that I’m printing it’s no big deal right now but

if I run the program again you can see that begin branching test and end

branching test okay so far we’re not really doing branching yet the next thing

we need to do is ask for a number so this is how I’m going to do it in my

this is how I’m going to do it in my program. In your program it might be different or you might

have a hard-coded number or something like that. So for now just trust me when I say that I’m going

to print a prompt basically saying could you please enter a number and then the next two lines

are going to be just calling on one of my custom functions that will input a number from the user

so the user can type at the terminal and we will receive their number through REX which is the

return value register for integer return values and we’re going to store it in R12. So that’s why

And we’re going to store it in R12.

So that’s why I had to preserve R12,

because I’m actually going to start,

you know, messing with the value of R12 now.

Okay, so we ask for a number,

and then we sort of don’t do anything after that.

If we run the program again,

it’s just asking for a number,

and I can just like type some stuff and hit enter,

and then the program ends, nothing actually happens.

We’re building, we’re building.

So now let’s ask ourselves,

is the number greater than zero?

So let me copy paste some code here.

some code here so right now we’ve just finished inputting a number from the user and we’ll ask

you know is that number that they inputted greater than zero so again the first thing we do is we use

a compare instruction cmp we give it two operands the order doesn’t necessarily matter um for

instance uh right now i’m asking is r12 greater than zero so i can do a jump less than or equal

to like a different branch or i can jump greater than equal to if i switch the operands or if i

in a different order, but I’m just choosing to say, let’s compare the two and then let’s jump

if R12 is less than or equal to, which basically means not greater than, this label right here,

which is just branch test after greater test. So I’m going to do a print statement right after that

and then I’m going to draw out what the code is kind of doing. So let me make a label here so

actually will compile. Whoops. I’m in the wrong window. Okay. There we go. So what am I saying

here? Okay. Do the comparison. And then if the condition seems to be satisfied, then we’ll jump

to this, which means we’ll just say goodbye and then exit the program because we’ll return to the

caller. But if that condition was not satisfied, then we’re going to end up executing this stuff

in the middle. So think about this. This is kind of the idea. Let’s see if I can remember how to

idea let’s see if I can remember how to draw this right now off the top of my head suppose we have

like some sort of an input I’ll call this in put and then maybe the input is going to be you know

whether r12 and r0 are equal or greater than or whatever so I’m just gonna say r12 and 0

god that’s awful I really need to practice this draw pad I spend like a whole week practicing

whole week practicing with a different draw pad and then when I come back to

this one I’m even worse than when I started so we we come in and we kind of

look at our 12 versus zero and then we will jump in one direction if that’s not

you know greater than or equal to or less than or equal to and we’ll jump in

another direction otherwise so basically here we’ll say jump less than equal to

um less than or equal to whoops maybe i’ll do r12 uh i need to somehow adjust the pressure on this

thing r12 less than or equal to and so this is sort of uh has to do with you know this branching

path that we take like if r12 was less than or equal to zero then we’ll take the right branching

to after, I’ll just put the word after,

we’ll jump to the after greater test sub label.

And otherwise, if R12 is, sorry,

I said less than or equal to, yeah,

if R12 is greater than zero,

then we jump to this other thing,

which is gonna be the fall through.

So it’s gonna be line 96, but I’ll just say,

I’ll say fall for fall through.

basically the jump won’t happen if it’s greater than or equal to so you could imagine if you

wanted to reverse the logic so you can use a jump greater than instruction you could but I’m choosing

to do it this way and then both of those will eventually reach let’s see will eventually

actually yeah the fall through instructions those will eventually reach the after instruction I’ll

here and then the after instruction will just kind of like finish the program

and exit and all that stuff. So if you think about the control path here,

we have an input we’re looking at R12 with the zero with the compare instruction

and then we use a conditional branching instruction. So maybe I should write,

what do you want to write here? Maybe I’ll just put JLE up here because usually the compare

usually the compare instruction and the conditional jump or branching instructions

kind of you know come as a pair so both of these combined mean let’s look at r12 versus zero and

if r12 is less than or equal to zero meaning if it will jump if we’re less than or equal to the

the right operand r12 less than equal to the right operand then we go down this path on the right

to the after label if that is false meaning r12 was greater than zero then we’ll fall through

this stuff right here and then whether or not we actually fall through will always end up at the

at the after area because we’re either going to jump directly to the after area or we’re going

to fall through and then the fall through falls through to the after area anyway as well let me

just show you that real fast oh man i’m having a hard time with this okay so let’s pretend that r12

less than or equal to. So that means instructions are coming, you know,

instructions are getting executed. We’re going down and down and down and down and down.

Once we see jump less than or equal to, if that’s true, then we jump to the after label,

which means we just kind of jump around this message. And so we’re not going to exit,

sorry, we’re not going to execute that code. So in the case where that is true,

where it is less than or equal to, we’re not going to execute those instructions.

So we’re not going to say their number was greater than zero. We’re just going to simply

We’re just going to simply say goodbye.

However, on the other hand, if that is not true, meaning if R12 was indeed greater than

zero, then we’re going to fall through because this jump less than or equal to instruction,

it will only jump if the R flags, if the comparison instruction thought that R12 was less than

or equal to zero.

If that’s not true, if it’s greater than, then instructions, the control path is just

the control path is just going to fall through.

So that means we will actually execute these.

And then when they’re done,

execution will continue to fall through to the rest.

So that means we’re either going to see a message saying

their number was greater than zero or not,

based on whether their number actually was greater than zero.

Okay, hopefully I explained that somewhat clearly.

Now let’s run the code and see if it works.

Hopefully I didn’t forget anything.

This is kind of a partial program at this point.

program at this point I’m gonna add a bunch more stuff to it so hopefully

this actually compiles enter an integer five notice how it says your number was

greater than zero and if I run it again and I just type zero it does not say

that it was greater than zero if I run it again I type like a negative five it

also does not say that it was greater than zero you know a huge giant number

here it’ll say your number was greater than zero you could probably type a

number that was just absolutely huge and have it overflow I actually don’t know

nines I need to type and I don’t even know what the behavior is going to be.

I don’t know if it’s just going to crash the program because this also relies on my ability

to input a number which is happening in a different library.

Let’s see if that even works greater than zero.

Okay.

It probably overflowed and went to a very, very low negative number.

So okay.

I guess at least I know my library will probably work sort of.

Okay.

So let’s go back to the code here and let’s upgrade it.

how to to check for jump less than or equal to um we’re going to say goodbye right there so now the

next thing we should do is check to see if the number was less than 10. so after the greater test

it’s going to be here so again the same thing like we can just reuse r12 because we’re not really

modifying it and we’re not calling uh well i guess even if we were calling a function r12 was supposed

supposed to be Kali preserved so we’re just comparing it and then maybe

printing a message if we want to and regardless we’re going to end up at 103

this after greater test label so then we’ll compare again r12 with the number

10 and we’ll say jump if it’s greater than or equal to branch test after less

so now at this point we’re saying compare r12 with 10 if it’s greater than or equal to 10 then

just skip over the message so if it’s greater than or equal to 10 then wait a minute wait wait

yeah yeah if it’s greater than or equal to 10 then skip the message otherwise the message

that is printed is going to say that their number is less than 10. so again you could imagine a

want me to write it out for you I don’t know I think once is probably enough but let me just do

it again we’ll do input is coming in and it’s just going to be you know comparing and then

jumping greater than or equal to the input is going to be where we’re just looking to see if

R12 how it compares to zero god the number one is awful my entire penmanship is awful okay one

we’ll do r12 and 10 and so that’s just sort of what we’re comparing with the compare instruction

and then the jump instruction and so if we go on the left i’m going to say that’s the fall through

path again and if we go to the right it’s going to be um r12 greater than or equal to 10 is going

and then here this is going to be after less I’ll say the after label the after less label

so if we fall through it’s just going to print a message maybe I should do another little bubble

here that’s just like print p for how about p for print p for print it’s going to fall through and

then it’s going to print and then it’s going to go to the after label so you can see that

the print instructions are only reached if r12 is not greater than equal to 10 which is the same

to 10 which is the same thing as saying it’s going to fall through if r12 is less than

10.

And then after we finally get to the after label, then we’re just going to do, you know,

the rest of the instructions.

We’re going to exit the program.

We’re going to say goodbye.

We’re going to do whatever.

Okay.

So say there never was less than 10.

And then regardless, here’s like the ending label that we were conditionally jumping to.

Let’s see if this works.

Make run.

So we’ll enter five.

we’ll enter five notice how it says your number was greater than zero and your

number was less than ten let’s do an 11 I guess it says your number was greater

than zero but it does not say that our number was less than ten because 11 is

not less than ten if I do a negative three here it says that our number was

less than ten but it doesn’t say that it’s greater than zero so we have like a

lot of decisions that we could make right like imagine if instead of just

based on something happening, you could call a full function or skip a bunch of extra code,

you know, whatever you want it to do.

So I’m going to go to the next condition where we’re going to compare R12 to the number five.

And we’re going to ask, you know, is R12 equal to five?

So this is going to be the jump not equal branch.

And again, you know, if you wanted to say jump, if it’s equal to the place where we

and then maybe like right after that fall through and just do an unconditional jump you can

I just think there are less jumps if I do it this way so uh here we’re just going to print you know

your number was equal to five and so basically if it was not equal we should have another label here

that allows us to skip that so all right so same thing I’m not going to draw the diagram this time

R12 with 5 and if it’s not equal to 5 then jump to this label down here which just means

let’s say goodbye and not actually say that their number was equal to 5.

But if it was equal to 5 then this JNE conditional branch won’t actually jump anywhere.

Execution will fall through to the next statements which is just printing the message that their

number is equal to 5 and then when that’s done it’ll fall through to this other label

and eventually fall through to the return statement.

the whole thing already nice that was easy um let’s do another run and um let’s enter the

integer one it says one is uh greater than zero and one is less than 10

greater than zero and less than 10 is there any way i can get nothing to print out

greater than zero and less than 10

you don’t think i can do it let me try it nine no

why did I even put 9 okay yeah it’s always gonna say 0 or 10 okay so let’s

do a 4 we’ll get both of those greater than 0 and also less than 10 let’s do a

5 now we should get all those messages your number was greater than 0 your

number was less than 10 your number was equal to 5 and if I just do a 6 in there

again it doesn’t print your number was equal to 5 and we have to enter an

actual 5 for that so that’s the that’s the basics of

conditional branching oh there’s one other thing that I wanted to make sure

in my previous video where we only talked about jumps bear in mind that

these conditional branching statements or instructions you know je j any all

these things they have a limited range of jumps of where they can jump to so if

you have a gigantic program and you’re trying to jump very very very far away

based on a condition you might have an assembler error where your program won’t

even compile won’t even assemble telling you i think the message is i wrote it

I wrote it down somewhere jump out of range coming from the assembler that basically means that these

instructions can only jump about 128 bytes away from whatever instruction they are at or whatever

memory location they are at so you know after your assembler assembles your program and after

your linker links your program and you just have like a binary you know if you were to inspect

all the instructions inside of your executable your binary you would see that they have offsets

offsets, right? You know, like one instruction is basically eight bytes away from the one that

comes right after it. But some instructions are a lot further away. So if you’re trying to jump

to an instruction that is 100 is more than 128 bytes away, it won’t work, you’ll get that error.

So how do you solve that problem? Well, maybe I’ll just write this down real fast. I’m not going to

make this part of the code example. But just imagine we have, you know, jump equal to some

and maybe I’ll do a comment very very far away and here’s the label some label right

so if your assembler says hey you can’t jump to some label because it’s too far away it’s a

jump out of range assembler error then basically you can just make some other labels here you can

say uh you can say short jump true and short jump false you know just make up some sort of a label

label and basically say if it is um well false yeah okay i guess this is the way i’ll do it this

is not super efficient but instead of jumping to the very far away label in the case of true you

can just jump to the true label so i’m going to say jump uh to the short jump true label otherwise

To the false label. So now you’re definitely jumping in either case and both of these labels are close by

So then I can pretty much just have the close by true label do an unconditional

Jump to some label and that overcomes the limitation of branching instructions

So, you know JMP the regular jump instruction

It has an unlimited jump that it can do it can go just to like very very very far away instructions

And then for the false, you know, I don’t know, do whatever you want and then jump wherever you want.

It doesn’t really matter.

I’m just trying to show you that if you make a short jump to a label that will only have an unconditional jump,

so it’s sort of like two jumps, you know, like a short jump and then a long jump,

then you can overcome that limitation.

Again, bearing in mind that some label is supposed to be very, very far away and sort of unreachable.

Okay, so let me just double check that I talked about everything that I wanted to.

We looked at the branching instructions, the sign in this, I drew a diagram for you.

We solved the jump out of range error.

Okay, so that’s, I think that’s basically it.

Hopefully you feel like an expert now at conditional branching and how to make decisions.

In future videos, I’ll talk about how to implement an if else block and how to implement loops

and all that stuff.

decisions in yasm x86-64 assembly and conceptually you can apply this to other assembly languages too

so thanks for watching my video i hope you learned a little bit of stuff and had a little bit of fun

i’ll see you in the next video

hey everybody thanks for watching this video again from the bottom of my heart i really appreciate it

i do hope you did learn something and have some fun uh if you could do me a please a small little

Could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now?

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

or followed it just wakes me up and I get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could

you control me if you want to just wake me up in the middle of the night just

subscribe and then I’ll just wake up I promise that’s what will happen also if

you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named

somewhere at the bottom of this video and it’ll take you to my main website

where you can just kind of like see all the videos I published and the

all the videos i published and the services and tutorials and things that i offer and all that

good stuff and uh if you have a suggestion for uh uh clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i

get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

appreciate it so again thank you so much for watching this video and enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Learn Conditional Branching in x86-64 Assembly (YASM/NASM) – CMP, JE, JNE, JL, JG & More appeared first on NeuralLantern.com.