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.