Learn pointers & dereferencing in x86-64 YASM assembly and how to pass them correctly between assembly and C++ in a hybrid program. We build a small working example that sends strings, longs, and doubles both directions using pointers, modifies values across module boundaries, and explains why pointer-to-double still uses general-purpose registers. Includes a quick demo of stack misalignment crash + fix.

Great for assembly beginners moving to real programs, systems programming students, or anyone curious how low-level code talks to C/C++.

00:00 Introduction to Pointers and Dereferencing in x86-64 Assembly
00:28 Pointers explained in C++
01:02 Changing values via pointers in C++
01:43 Pointers in assembly basics
02:09 Defining variables and pointers in YASM data section
03:23 Pointers are always integers even to doubles
04:20 Function arguments are pointers treated as 64-bit integers
05:00 Driver C++ code overview
05:58 Marking extern “C” functions
06:40 Local stack variables and passing pointers
07:51 Stack lifetime warning
08:34 Assembly data section strings and numbers
09:39 Print null-terminated string helper functions
10:38 External symbols and hey_driver_print_this
11:29 Point function prologue and stack alignment
13:04 Extra push for 16-byte alignment
14:20 Printing welcome message from assembly
16:00 Driver sees initial long value
16:58 Printing received string from C++
18:20 Using received char pointer without dereference
20:21 Modifying incoming long via dereference
21:46 Driver sees modified long value 101
22:43 Calling back to C++ to print assembly-owned data
23:48 Passing pointers to assembly string long and double
25:08 Driver prints assembly-owned values and addresses
26:14 Summary of pointer passing between modules
26:36 Stack alignment crash demonstration
27:39 Adding extra push/pop fixes segfault
28:00 Closing remarks and call to subscribe

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there! In this video we’re going to talk about pointers and dereferencing in a YASM x8664

assembly program, also as a hybrid program so that assembly and C++ can talk to each other

and send each other pointers and send each other data and things like that.

for what pointers are.

I’m going to write in C++ for a second.

Suppose you have a pointer for an integer.

We’ll call it P.

Suppose you have an integer by itself.

We’ll call it A.

Let’s say that the value of A is 5.

And if you wanted to say that P points to A,

you could say P equals the address of A.

I’ll put C++ at the top here.

And so now if I set A to 6

then I print P a dereference of P this is not like a full pointers tutorial

but basically by changing a I’m changing what P thinks it sees as a value

assuming ID reference it I could also let me do a print 6 here I could also

just change the value through P I could say dereference P and I could say equals

would actually print a seven right so you know you can have regular variables global variables

whatever kind of you know memory stuff on the stack and to get a pointer to it you really just

need to get its memory location in c++ it’s kind of easy syntactically you can see what’s happening

in assembly you really just need the memory location stored somewhere you could store that

variable that just simply stored the memory location of some other variable.

You could have a 64-bit register store the value of a variable.

Let’s say we have like a, I don’t know, my whatever, my number let’s say inside of assembly.

I’ll do ASM here and we say it’s a quad word and it starts off as this number or whatever.

So if you haven’t seen my previous videos, go see them for the basics of assembly and

of assembly and linking and make files and all that stuff but you know if you

have an assembly program and you have a data section and you define a global

variable like this what you’re basically saying is I want to take this giant

number and I want to write it into eight bytes that’s the DQ it says data quad

word I want to write that giant number across eight bytes and then I want to

get a pointer to it stored in the my number symbol so my number is not

actually the value it’s a pointer to the value so you know later if you want to

you know later if you want to move you know something into a register if you did this

that would move the pointer into rax but if you did this

with deref symbols after it or around it then you would move

maybe i’ll put that into rex you’d move that actual number that we specified into rex

into Rx. It’s important to understand also that pointers are integers even when we’re pointing to

doubles. So for example sometimes people make this mistake they’ll say you know my double

and they’ll say it’s a quad word meaning this is going to be a 64-bit double precision floating

point number and they’ll do like 44.55 or whatever. So that is a double and it is in memory

you know what is the symbol of my double remember it’s supposed to be just a

pointer right it can’t be an actual double because a memory location is not

a double a memory location is an integer so that means if you wanted to move a

pointer into a register you would only be able to move the pointer into a

regular general purpose register not a floating point register and you should

use the regular movement instructions for just regular general purpose

So keep that in mind if you see a signature like this like let’s say function F and we have

You know, let’s say long a and long B and actually let’s do pointers

Let’s say long pointer a and long pointer

B and double pointer C all three of those arguments are actually 64 bit integers

Because they’re all pointers even if one of the pointers points to adult a double

double why did I say dull pointers aren’t dull they’re exciting okay so I’m gonna open up some

code here real fast so usually I don’t explain my uh my driver I’m gonna explain it to you this time

because it’s kind of doing a little bit more than my other videos um again if you don’t have uh the

knowledge of how to make a make file see my other videos because that’s explained there for now I’m

what we really need to do is write a driver and an assembly module for a

hybrid program again hybrid programs covered in other videos so the driver is

pretty easy I’m just going to copy paste it honestly here and then just kind of

explain it to you the driver is pretty easy we’re going to do I O stream so we

can print stuff we’re going to mark an external function called point as extern

C so that just disables name mangling which means the C++ module will be able

will be able to call on this function called point and it won’t expect that

the point function has its name mangled like C++ does the reason being is that

point is actually going to be in a side it’s going to be inside assembly where

its name will not be mangled this disables the ability to overload but

that’s okay we don’t care it’s going to take two pointers a pointer to a character

and a pointer to a long since both of those are pointers they’re both

64-bit integers even the character pointer and then we have a function that is internal to this

module called hey driver print this remember we’re inside of the driver program right now

so if you look at the bottom it’s just a function that takes in some pointers

and then prints some stuff so it’s going to print like it’s going to print what the string is

it’s going to print what the long is my dog’s growling at me i’m going to ignore him because

i literally just let him pee and poop at this point now he’s harassing me for treats

now he’s harassing me for treats he always does this okay so uh the string the long the double

this function expects to receive three pointers to different data types it’s just going to print

all of them and the point get it the point of this function is we’re going to go inside of

the assembly module and then have the assembly module call on this function so that we can we

can prove that we can have stuff sent from assembly to c plus plus or c using pointers

using pointers we can have data sent over so anyway that’s why both of these

are in here the point needs to be marked as no name mangling because point is

inside of assembly which will not name mangle and then hey driver print this

that needs to have name mangling disabled also so that the assembly

module can call on this other than that we’re just basically inside of a main

saying hey this is the c string we’re making a c string inside of the main function notice how

this is a local variable so that c string is going to show up on the stack it’s going to show up in

the area that is owned by main for main stack area same thing for my long that’s a local variable on

the stack um and but then we can actually send pointers to those pieces of data to another

function in another module you don’t have to only transport globals or stuff on the heap

or stuff on the heap, you can transport pointers to local variables. Just make sure that by the

time this function finishes, then nowhere else is actually using that data because,

well, being on the stack, once main function or once any function finishes, then its portion of

the stack will be cleaned up and removed and it’ll be junk data. You’ll probably get a seg fault.

But for now, we’re not going to use anything on the stack. We’re not going to use these local

just going to use them quickly on this call to point and then we’re going to return to the

operating system and finish the program. So that’s the driver. Now the hard part. Let’s do this in

assembly. So for starters, I’m going to make a data section and just explain it to you very,

very quickly. Again, if you don’t understand the basics of YASM x86-64 assembly, did I mention

that that’s what this language is at the beginning of the video? I guess I should put that in the

put that in the description or record an announcement that I can tack on at the beginning

or something. Anyway, so if you don’t understand how to do this, see my other videos, but basically

we’re going to make a data section. We’re going to define some strings. Here’s like an announcement.

Oh, we’re inside of, you know, the module now, the assembly module. And now we’re going to print

the received string. And then we’re going to make a string that is owned by assembly, which we can

into C++ when we call the function inside of the driver.

So this string is owned by the assembly module.

Notice how these are null terminated strings.

I just have like a comma zero there,

which means I have some extra functions

I’m gonna paste in that we’re not really gonna talk about

because they’ve been discussed in other videos

just so that we can print null terminated strings.

Then I’ve got a new line here,

you know, carriage return line feed.

And then I’ve just got some numbers

that are owned by the assembly module.

Then I’ve got a system write call,

call code one for the system call writes and file descriptor standard output so I

can print just to the terminal again if you don’t understand this see my other

videos so now let’s start the actual text section so this is where our

instructions start so we got the text section here and we’re going to use some

external symbols don’t worry about these I’m just using my own little library to

and input integers if you have access to this library use it if you don’t if you’re watching

at home and you don’t have this library then that’s fine you can use you know printf or

scanf or something like that to get and print floats from and to the user

but yeah I’m just using that and then I’m marking an external function here called hey driver print

this if you recall the driver module has a function called hey driver print this so

just allows my assembly code to call on that external function. Okay now next

piece of code. This is going to be… actually I’m going to paste the print

null terminated string function and related code because it’s just like a

big giant mess and we’re mostly going to ignore it. So just to show you what I’m

doing here I have a function called print null terminated string so that I

can print these strings up here and then I have it rely on a function called

string length that I have implemented up here and all it does is just

implemented up here and all it does just calculates the length of the string and

then a crlf function so I can just call that so that’s all explained in other

videos don’t worry about it for now we’re going to start the actual entry

point remember the driver was just gonna call point right so now we just have to

implement point in the assembly module so that’s gonna be like down here our

our entry point so the signature for this function is going to be character

pointer and then a long pointer and it doesn’t return anything and remember

that if we look back at the driver that should match the signature right it’s a

character pointer and a long pointer and of course this is just a comment that

reminds me of what to do in assembly you don’t really have a signature you just

sort of use registers but I’m reminding myself that RDI is going to be a

character pointer and RSI is going to be a long pointer.

Here’s a note to myself that I’m going to use R12 and R13, which means

the first thing that I should do, well actually before I even do that, I should

return from this function because it is a function. I marked it as global

so that the other module could call it, the driver module could call it. Again,

see my other videos for hybrid programs.

But so now the, you know, if the driver calls this function, then now we’re inside of

and there’s a return statement so it’s a valid function I should preserve the

registers that I’m going to use that are marked as Kali saved for the ABI so I’m

going to go prologue and then an epilogue and I’m going to say push r12 and push

r13 and then I’m going to pop r13 pop r12 they should be in reverse order if

you’ve seen my other videos you’ll know this and the the thing about this

the thing about this particular program is we’re going to run into stack alignment issues

so uh if you don’t know about stack alignment and how it can crash your program without you

realizing what’s wrong see my other videos but for now we’ll assume you know that and uh i i

already know from running this program in advance that it’s going to be out of alignment by eight

bytes so i’m just going to push an extra register onto the stack and that’s going to put it back

I know it looks weird, but this is going to work.

Let me get rid of this here.

Okay, so.

And then maybe if I can remember at the end of the video,

I can just remove that extra push-pop pair,

and you’ll see the program starts crashing.

But at home, you can do it just to double check.

So the first thing I really want to do is,

after I push and pop,

is save our incoming arguments.

Remember, the first integer argument

and the second integer argument,

argument they come in as RDI and RSI in assembly per the ABI if both of these

things are pointers it doesn’t matter what the data type is it could be

pointing to anything including a double and these would still be considered

integer arguments because well RDI and RSI are just going to be loaded up with

memory locations which which are integers so I’m going to save our

arguments to R12 and R13 now justifying our push and pop pair then I’m going to

little welcome message so print a little welcome message again you don’t need to know about this

function but it’s explained in other videos that I’ve already published we’re going to print our

hello beginning message I’m getting nervous he needs to take a second poop sometimes it’s poopoo

number two time for him and he’s not really just lying about a treat but he did go pee and poop

But he did go pee and poop already.

Okay, he just left and walked away.

Okay, if he comes back, I’m letting him out this time.

I’ll pause the video if he does it again.

Okay, I’m pausing the video.

No pee lied.

He went outside, lifted up his little leg, and a couple of drops of pee came out.

Now he’s staring at me like he deserves a treat.

Sorry, buddy.

I wish I could eat constantly all day long, too.

But life isn’t always fair.

isn’t always fair anyway let’s see I might even lined up on the camera

anymore I don’t even know so we’re looking at this code here is going to

print a welcome message let’s see if that actually works so I’m gonna do make

run again make files are whoops what did I do loader dot asm what did I do what

did I do I somehow copy pasted the wrong make file

What’s the name of my source code file?

It’s point.

I guess I’ll just change it, and then it’ll probably work.

It’s still in assembly module.

Hopefully that didn’t mess it up too bad by copy-pasting the wrong source code.

Okay.

What is going on here?

Floater.

Oh, I need to change that.

Hang on.

Let me fix this.

I don’t know if I’m going to edit this out.

out. It’s fun to watch me struggle sometimes. There we go.

Point.

Alright, let’s give it another try.

Oh no, star dot so no such file a directory. Dang it.

Okay, now this seems to work. I may or may not have edited

that out. I copy pasted the wrong source code into my make

file. So I had to manually adjust it. Then I forgot to

copy paste my library file into the build directory. So I had

The driver sees my long as whatever.

What’s going on?

Print an alternate string begin.

Oh, the driver is printing a bunch of stuff.

Okay.

I started to think, why does it look like the program has a lot of stuff going on?

Oh, that’s the driver.

Okay.

So the driver says it sees its long as 100.

And then now we’re inside of the point module.

So that’s the only thing we’ve done in assembly so far.

so far then the driver has regained control maybe I should add a couple of

new lines in there so I don’t get confused again we will do a C out and L

and we’ll do two of those run the program again and then I won’t get

confused about the messages okay so now we’re inside of the point module and

nothing is happening so points let me get rid of the make file here and

and we’re just printing a welcome message nothing else so now let’s print

the received string so what am I talking about so we’re gonna print a prefix

basically saying hey we received the following string right so if you look at

the symbol message received string it’s just gonna say we’re now printing the

received string and then it’ll print it so what are we actually printing we’re

What is R12? R12 is a character pointer to the print me string. And so basically this

function print null terminated string, it takes a character pointer. So we’re giving it a character

pointer that we received. When point was called by the driver, notice how it gave a pointer to

the C string. You know, all arrays are basically pointers. They’re just different syntactically

just different syntactically sometimes so if i declare an array of some length and i give the

symbol somewhere that symbol is really a character pointer so um by calling point with my c string

i’m calling point inside of the assembly module with this character pointer so that means even

though this c string is owned by the driver by the c plus plus module the assembly module has access

So that means we should be able to print it right now already.

So just the rest of it is just like giving a pointer.

And notice how I’m not dereferencing R12.

If I did dereferencing around R12, then we would be looking to that address and seeing what’s there,

which wouldn’t work for printing a null terminated string.

So let’s just run it again.

I don’t know if you can hear him.

This dude is growling at me still because he wants another treat.

He just got denied.

He’s trying to do it again.

do it again. I let him outside people. He’s been outside like three times already and he just went

out like two minutes ago. Okay. I love him so much. It hurts my heart and he knows eventually he’s

going to break me because it hurts my heart or I’m like too distracted. It’s like, you know,

pulling the crank on a slot machine in Vegas. You know, eventually something comes out.

That’s what he does to me. I’ve accidentally trained him. So now printing the received

Now printing the received string and notice how it prints.

Hello, this is a C string owned by me.

So our assembly module is able to print a C string that was created locally by a C++ module.

So we’re handing around pointers.

Nice.

Can you hear me?

He’s getting louder.

So now let’s modify the incoming long.

Can you shush your freaking pants, please?

Shush your pants.

shush your pants you know the sad thing also is he’s so old that he’s deaf now

so he used to know what shush your pants meant it meant I’m not listening to you

and you might as well stop because I’m not gonna do anything based on your

harassment but now he can’t hear me say shush your pants so he just harasses me

all day and all night okay um so I’m gonna copy paste a little bit more code

Modify the incoming long.

So remember again that the point function, it received a pointer to a long.

We’re calling the long change me on the inside of this, but it’s coming in as R13.

And if you notice what I’m doing here is I’m just saying let’s increase the long.

So I’m going to dereference R13 because R13 is a pointer.

So I’m saying let’s go to the memory and change the long that is inside of memory.

And we have to specify that it is a keyword.

it as a keyword so that we you know we don’t confuse the system the system might think are

you modifying a keyword or like a double word or like a word like how big is your data all we know

is it’s an integer because it’s the increase instruction so I’m saying we got a keyword you

know a 64-bit integer sitting at that memory location I want you to dereference it and increase

it and going back to the driver we’re providing a pointer to our long so the long starts off is 100

and we’re just giving a pointer to it the next thing that we can do is we can

ask the driver to print our own stuff actually you know what let’s run the program right now

just to show that the driver can see the change in the long so i’m going to run it again notice how

first when the driver says hello it sees its own long as 100 then we’re inside the assembly module

long and then we return to the caller which is the driver notice how at the

very end of the program the driver sees its long as being 101 so we were able to

modify data that was owned by a different module just by passing pointers

and de-referencing them okay cool so now the next thing that we should do is let’s

ask the driver to print our own stuff that we own because remember if you go

to the very top you know we own some stuff we own some we own a long we own

float, right? So we want to be able to do something with that. So I’m going to copy paste this,

ask the driver to print our own stuff. So I’m going to move three items inside of arguments

for a function call. And then I’m going to make a function call calling the function,

Hey driver, print this again, Hey driver, print this is actually owned by the C++ module.

a pointer to a long and a pointer to a double remember even pointers to doubles are actually

integers so they use the general purpose register so that’s the three arguments right there rdi rsi

and rdx m and then we’re giving the first pointer is going to be the c string so message string

inside asm so you can see that’s this right here and then the next pointer is the long

inside ASM and the third is the float where did I just go I’m getting confused my dog is harassing

me right now so bad notice how I’m not dereferencing so like if when we were increasing the incoming

long before R13 was a pointer so we dereferenced while we increased so that we would increase the

actual value and not the pointer and not the pointer’s memory location but here we’re not

C++ module the actual pointers to our data. We don’t want to give it the data itself. We want

to give pointers to the data so we’re not derefing with the brackets. So then we call it and when we

get back in here it should just be able to print everything. So I’m going to run it one more time.

We’re going to make it and run it and so now let’s see. So here we’re inside of our assembly module

And then here the assembly module has just called on hey driver print this.

Remember the C++ module doesn’t actually call this function.

The assembly module calls it.

So we’re like going back and forth.

We’re kind of crisscrossing.

So now the drivers print this function says we got the following string.

Notice how that’s the string that is owned by assembly.

So we define that inside of our data section in the assembly module.

And then it prints the long.

It prints it as hex.

And it just sort of prints the value.

it just sort of prints the value then it prints it as hex again and then prints at the value

i think actually not hex i think this prints the memory location let’s double check real fast

yeah so remember um in c plus plus i know this is not like a c plus plus video but um

if the long is a pointer then if we just print it without dereferencing it we should see a memory

location so it’s telling us uh that the long’s memory location is this and the doubles memory

location is that and if you stare at those two numbers long enough and you understand hex which

And do you understand hex, which you can see my other videos for?

You’ll see that those memory locations are right next to each other because that’s the way we define them inside of assembly.

So we now have the ability to have data that is owned by assembly and give it to C++ or C using pointers.

No problem at all.

And then the printing driver thing exits and then the actual driver regains control.

And it just says that it sees it’s long as 101.

it sees it’s long as 101 so uh yeah that’s that’s pretty much all i wanted to show you for this

now you hopefully are an expert at passing data back and forth between various modules using

pointers we’re not using references because references are like a little bit a little bit

less compatible pointers are just really easy they totally work in assembly no problem

one more thing i just wanted to show you real fast before we go even though there’s another

video you should check out for stack alignment I just want you to see what

happens if I remove this extra push-pop pair so now my stack is about eight

bytes off of its previous alignment because you know we’re not pushing an

extra eight byte value and somewhere inside of the let’s see print null

terminated string and then the hey driver print this oh and then we go into

like a bunch of C stuff the program should probably crash because anytime

you use a GCC function or a GCC library or something like that the stack has to

be aligned to 16 bytes so if it’s off by 8 then it’ll crash and how did I know

that I needed this well I just ran it first and it crashed and then I added

the extra push pop pair and it didn’t crash and I realized it was definitely

one more time we should get a seg fault yeah we get a seg fault stack alignment oh no with no

description of what’s going on if you were in gcc you could i mean sorry if you were in gdb you

could probably figure that out eventually but why not just give it a try add another push pop pair

run the program again with no other modifications now it totally works

okay well uh i think that’s uh that’s all i have for this video thank you so much for watching i

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

I will see you in the next video.

Hey everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me

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

this community so we’ll be able to do more videos longer videos better videos

or just I’ll be able to keep making videos in general so please do do me a

kindness and and subscribe you know sometimes I’m sleeping in the middle of

the night and I just wake up because I know somebody subscribed or followed it

just wakes me up and I get filled with joy that’s exactly what happens every

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

up in the middle of the night just subscribe and then I’ll just wake up I promise that’s what will

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

you can scan in order to go to the website which I think is also named somewhere at the bottom of

this video and it’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

for

Clarifications or errata or just future videos that you want to see please leave a comment or if you just want to say hey

What’s up? What’s going on? You know, just send me a comment, whatever

I also wake up for those in the middle of the night. I get I wake up in a cold sweat. I’m like this

It would really it really mean the world to me. I would really appreciate it. So again, thank you so much for watching this video and

darkness, which is coming for us all.

Thank you.

The post x86-64 Assembly Pointers & Dereferencing Explained – Hybrid C++/YASM Example appeared first on NeuralLantern.com.

In this video, I walk through how to perform signed integer division in x86-64 assembly language using Yasm on Ubuntu/Linux.

We focus on 64-bit signed integers and the IDIV instruction. I explain the setup: loading the dividend into RAX, using CQO for proper sign extension into RDX, loading the divisor, and executing IDIV. After division, the quotient ends up in RAX and the remainder in RDX.

I reference the excellent free book “x86-64 Assembly Language Programming with Ubuntu” and show practical code examples, including a complete working program that prints both the quotient and remainder.

We test with small numbers (256 / 233) and larger ones to see it in action. I also touch on the difference between signed (IDIV) and unsigned (DIV) division, and why CQO is needed for correct sign handling.

Perfect for anyone learning low-level programming, assembly language, or wanting to understand how integer division really works under the hood.

Introduction to Signed Division 00:00:00
Referencing the Assembly Book 00:00:28
IDIV Instruction Overview 00:01:16
Dividend and Divisor Setup 00:01:24
Sign Extension and CQO 00:04:18
Quotient and Remainder Results 00:04:40
Setting Up the Program 00:05:13
Data Section and Strings 00:06:22
Function Prologue and Preservation 00:09:20
Loading the Dividend into RAX 00:10:00
Sign Extension with CQO 00:11:24
Loading the Divisor 00:12:36
Performing IDIV 00:14:19
Saving Quotient and Remainder 00:16:48
Printing the Results 00:17:20
Running and Testing the Program 00:18:51
Testing Larger Numbers 00:19:48
Returning the Remainder 00:21:42
Signed vs Unsigned Division 00:23:48
Conclusion and Thanks 00:25:02

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

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

Hello there.

In this video, I’d like to talk to you about dividing signed integers in an x86-64 Yasm

assembly program.

I’m going to be focusing on 64-bit integers and I’m going to use an instruction called

iDiv.

Okay, so for starters, I just want to give you an overview of the process.

I’m going to use an awesome book that I love to reference.

awesome book that i love to reference i did not write this book the book is titled x86 64 assembly

language programming with ubuntu i mention it in a lot of other videos the author here

is a genius and this book is open source and freely available so go look it up get yourself a

copy and become an assembly expert too anyway so what i’m going to do is go into this book

instruction set overview and then inside of that i’m going to click on 7.5 integer arithmetic

instructions or arithmetic i don’t know whatever you prefer to say it as but and then i’m going to

go inside of there and i’m going to click on 754 integer division so you know the basic idea for

dividing integers in a yasm assembly program on x86 64 is just to load up your dividend you know

top portion I guess that is the numerator and then the divisor which

would be the denominator with separate registers so load up the dividend with a

register or put the dividend into a register and then put the divisor into

another register they’re going to be special registers we’re going to be

using the A and D registers you can kind of see that at the bottom already and

then once that’s set up properly you just sort of use the IDIV function or

instruction and there’s another instruction we can use to make things a

little bit more simple because if you kind of notice what what this is saying

here it’s saying that the the dividend usually needs to be stacked between two

other registers at the same time and that’s a little bit confusing

especially if these registers right here notice how a DX colon ax that means it

16-bit versions of two different registers just sort of like pushed up against each other so

Obviously if you know how to manipulate bits which I’m gonna do other videos for in the future

Then you could do that with any size, but just I’m gonna make the easiest example that I can here. I

Love this line. I just found it today

As always division by zero will crash the program and damage the space-time continuum. So try not to divide by zero. I love it

nifty little table inside of the book that sort of shows you how you’re supposed to set up the

numerator and denominator or the divisor what was the other word that they used dividend and divisor

i usually say numerator and denominator anyway so remember in in if you watched my previous videos

then you’ll know that we have smaller versions of our registers like for example uh this eax right

here that’s actually the rax register but it’s only about half of it uh half of those bytes are

half of those bytes are being ignored so all of these different versions that you’re seeing are

just different sizes of the a and d registers so i’m going to go to the simplest example here and

just kind of show you that basically what they’re trying to do is force you to have a numerator that

is bigger than the denominator that way it’s guaranteed you’ll have some kind of a quotient

or you know more likely that you’ll have some kind of a quotient and and a remainder that kind of

that kind of makes sense because if you divide a number that’s much smaller than

the denominator then you’ll just end up with zero remainder the original number

pretty much in integer division this video is not about float division float

division is more precise so in other words if I want to divide something by a

64-bit integer then I need to first set up a 128-bit integer and that means I

and that means I have to take two 64-bit integers, the D register and the A register.

I have to load both of those registers up with 64 bits each so that when you imagine them being combined,

it’s a 128-bit register or 128-bit value.

Once I have something that is sufficiently large, then I can divide it by something else.

Then the result will show up in the A and D registers.

the actual quotient, you know, the actual result of dividing without a fractional part at the end,

just, you know, truncated data. Then the remainder will be in the D register, the RDX register. So at

least for this form, I just want you to know you can do it with all these other forms if you want

to. But in this example, I’m just going to take 128 bits, divide it by 64 bits, and then I’ll get

So that’s the basic idea. Here’s some sample code in the book. I love it. It’s wonderful.

But I’m going to go ahead and start writing my own program now.

Okay, so I got a solution up here. I’m going to just copy paste my data section and explain it briefly.

Okay, so here is, oh, maybe I should first say, here’s a sample program that I’m using.

You don’t have to worry too much about what’s actually inside of it.

The C module and the make file, they’re standard stuff that I usually use in all of my videos.

all of my videos this is not a make file video see my other videos if you want to learn how to

make your own make files but long story short i’m just going to type you know make run in order to

just get this program to run and then for the c program i’m compiling a hybrid program so i mean

it’s just easier for me to just kind of get started this way so i have my main entry point sitting

inside of a c source code file that gets compiled and linked into my main program and it just calls

a function called math right here which is just going to be you know this source code right here

so if you want to make hybrid programs you want to learn the basics of assembly you want to learn

anything that i’m not really talking about in this video see my other videos

for today or for this video it’s just going to be integer division anyway i’m going to paste in

some starter code here for my math module i’ve got a data section and i’ve got some strings

strings or anything but just keep in mind I’m going to eventually print the division result

quotient is and then I’m going to actually print it and then I’m going to print the division

remainder is and then actually print it so I’m just I’m just setting up strings to make my

results look a little bit prettier that’s all I’m really doing crlf that’s just new line stuff

system calls here’s the system service code for writing to something writing to a file or standard

standard output again that’s in another video file descriptor one another video and then return

value I’m just choosing to return the number seven from this module I don’t know why I just

I like to reuse code and I’m not going to change it and then we’re going to take two different

integers here and uh 56 and oh I think in my starter code I actually hard-coded those numbers

after everything is working so um i’m going to start my text section here by just copy pasting

a little thing that says okay here’s where my code is going to go now all my instructions

and then uh here’s my entry point which is just my function called math you want to write functions

see my other videos but this is basically it you just kind of have something enter and then return

from it when you’re done and if you mess up any registers you have to preserve them with push and

you have to preserve them with push and pop pairs.

Another thing that I’m going to add that I’m not going to explain in this video

is I’m going to do calls to one of my own personal libraries.

And basically I’m just going to mark two functions as external.

They’re sitting in a shared object that I made.

Don’t worry about that. This video is not about printing.

It’s just about dividing. But I want to be able to easily print.

So I’m just going to use that library.

So don’t worry about that.

for this video is my function called divide test because notice how in the entry point of math

remember the c module the driver it calls on this math function the math function eventually or

immediately calls on divide test and so here’s the prototype basically for my divide test function

I’m just going to say it’s void takes no arguments that way it can just do everything by itself

as a little demo and it’s a little bit easier so that means I don’t really need to preserve any

I am using them and if you see here well I guess if it was going to take arguments you don’t need

to preserve the argument register so I should have just said yeah we are going to use some

registers and therefore we’re going to preserve them so our 12 14 and 15 oh why am I not using

13 I must have erased that at an earlier date whatever we’re going to use these three registers

make this an official function and because I know I’m going to use r12 14 and 15 I’m just going to

preserve them with a push pop pair so I’m going to say this is the prologue whoops and I’m going to

push r12 push r14 push r15 respect the abi if you don’t other pro other parts of the program

will probably crash epilogue is just popping all those in reverse order so that I can basically

basically preserve them for the caller.

Okay, so now we’re good with all our registers.

Next thing I want to do is I want to load up, let’s see,

I want to load up RAX with a number.

Now maybe I’ll fix this right now.

What was 256?

It was the my integer B.

So I’m going to hit main memory,

which is a little slower than using an immediate,

but hey, it’s more flexible.

but hey it’s more flexible and so basically i’m going to set up rax which is the numerator if we

go back to the book real fast if our intention is to divide a 128 bit uh uh like combined register

by a 64 bit something then uh well rax is the lower 64 bit so that’s why i’m loading that up

first i’m just saying well i’ve got 64 bits worth of stuff a quad word worth of stuff sitting in

so i’m just going to load that into rax then i just have to somehow take care of rdx so obviously

if you wanted to you could just you know take rdx and just set a bunch of zeros to it but that

would probably only work if you were guaranteed that rax was a positive number so that its sign

bit was zero at the very left if it was a negative number its sign bit would be a one at the very

And that wouldn’t be very good if RDX plus RAX, you know, lined up are supposed to be a negative number because you would want ones all the way through to RDX.

So there’s a special instruction we can use called CQO.

I’m just going to paste that in here just to make things a little bit easier because I’m really trying to divide a 64-bit integer by something.

The system wants a 128-bit integer.

basically this instruction right here CQO whoops what happened how come it’s not lined up

CQO basically just takes RAX whatever is in there and stretches it onto the 128 bit combination of

RDX colon RAX so remember when you see this kind of thing remember when you see RDX colon RAX or

just like a register colon another register that’s usually telling you that the system will think of

in a combined way as one longer register so that’s really what it is cqo is going to say

let’s look at rex and let’s uh you know fix it up and then also fix up uh rdx so that when they’re

combined they make sense as just one number um and you know that that would work pretty easily

like i said before if it was a positive number but not necessarily in all cases so we’ll just use

is, let’s see, set up the denominator. So let’s see, here, I’m going to say set up denominator.

And you know, we can hard code the 233 there, but I think I’ve already decided,

let’s just use variables. So the A, I think has 233. Where the heck’s my A? There we go.

So I’m going to say my integer A. And here I’m going to put the pointer to the A variable,

to the a variable and then i’m going to dereference it and um oh one thing that we have to remember is

when the system is using your registers like rax here it knows rax is the 64-bit form of the a

register so if you use different forms of your register then it knows how many bits you want

like for example here we just kind of go back up uh this eax that’s still the a register but the e

that it’s a you know 32 bits instead of 64 bits but there’s no there’s no way for

the system to really know that that memory location is 64 bits how does it

how does it know if I’m if I’m trying to load from memory a one byte integer or

two byte integer or four bytes or eight bytes it doesn’t really know so I kind

of have to specify what the data size is of the integer at that place in memory

this probably wouldn’t even compile. But if it did compile, you probably should be nervous that

it would compile and do something wrong. So I’m just going to specify exactly what the data size

is for that. So now we’ve set up our numerator and also set up our denominator. And the next step is

to just actually divide. Let me copy paste that real fast. So now we actually divide. Why is my

Oh, I know what’s going on.

I have the tab size set up differently between my two editors.

I got to fix that.

Or how about never fix it so I can always complain and you can laugh at me.

That’s okay.

So on line 85, we’re going to divide the numerator by the denominator.

And we’ll say the numerator is, you know, RAX with RDX in front of it.

the denominator is just one register which is uh what have I done wrong here oh no no I’m okay I’m

okay r12 so if you look back at the I got a little confused here because uh the book you know it

wants uh the d and the a registers as the numerator but then it says op64 as the denominator you can

just kind of use a bunch of different stuff for that but I’m choosing to divide by another register

So basically I’m taking the denominator and loading it up into R12.

And then when I call my idiv instruction, I’m just saying integer division.

And I want you to divide whatever’s in the RDX, RAX set as I want you to divide it by R12.

At that point, RAX and RDX will be overwritten.

So that data is now destroyed, but they contain the answer.

So RAX now contains the answer.

I’m just gonna say quotient and the RAX register contains the remainder so for

example if you are familiar with the let me pull this up real fast is that the

calculator no there is if you’re familiar with the modulo instruction like if we

said let’s see what was it again 233 okay so let’s do 256 divided by 233 this

this gives us the number one and then some sort of like a fractional remainder

with integer division we’re not going to get the fractional remainder it’s just literally going to

be the number one sitting in rax and then in rdx it’s going to give us the result of using the

modulo operator which is going to be 23 so it’s going to be one remainder 23

is what we should see unless i’m totally wrong so then right away

of our division which is a good practice you know like the rex and rdx those are registers that

could be quickly destroyed especially if you called another function or a system call or

something so i’m just going to save them right away so that’s why we saved 14 and 15

in addition to r12 so r12 we were using for the denominator and then we’re using 14 and 15 to

save them real fast and now I’m just going to do easy stuff that I’ve talked about in other videos

just to sort of print out an answer so I’m just going to I’m just going to write this up real

fast copy paste this and then just kind of briefly talk about oh look I’m using a system call

explained in another video to print out that little prefix message you know the result of your

division here’s the quotient and then a colon and then I can actually print the number

personal library to print a 64-bit integer and so that way it’s easy for me and notice how I’m

printing r14 I’m giving it to the call to the function as the first argument which is rdi

what is r14 again that’s just the quotient so here I’m printing the quotient and then I do the

same thing for the remainder and then we’re going to do a paste here and I’m just going to print my

prefix of the remainder you know here’s your remainder and then I’m going to actually print

And then I’m going to actually print it.

And the remainder was in R15.

So 14 and 15 had the answer.

And then the other register just kind of had, or the R12 just kind of had the denominator.

So I think that’s pretty much all I need.

Oh, there’s one more function that I forgot to put in there.

I’m fond of writing a little CRLF function.

This is not part of the video, really.

But it’s just a special function that I can call on to do a carriage return line feed.

And I’m just, I just can never stop using this.

stop using this. I know I could just prefix or suffix my strings, you know, with like a CRLF,

but I like to be able to call every time I want to see our lab. Okay. So we have the program now.

Let’s see if it actually works. Is that my terminal? Yeah. Okay. I’m going to go clear

and make, hopefully it actually works. So, oh yeah, there we are. Okay. So everything seemed

It printed hello from the driver.

And then when we went inside of the assembly module,

this is really what we’re interested in.

It said the division result, the quotient is the number one

and the division remainder is the number 23.

That’s what we said before, right?

So it’s going to be 23 is the remainder.

If you just do the modular operator or if you’re dividing,

whoops, if you’re dividing, then you’ll just get a one.

Remember like the quotient is just going to, you know,

truncate or remove or throw away all the extra data.

all the extra data it’s not going to round up or down or anything it’s just going to say

anything past the decimal point is gone and that’s why the uh the remainder is pretty important

then of course you know just for fun we could i don’t know put like some other numbers in here

if we wanted to maybe i’ll copy paste this just put some other numbers let’s put like a giant

number and see what happens because these are 64-bit numbers we can do it um i probably should

have switched a and b right because doesn’t it kind of feel like a’s on top so it should be the

top so it should be the numerator or whatever so I’m just gonna hit a bunch of stuff here and then

divide that by some other stuff see if this comes up with a more fun answer so one more time clear

and make and it’s telling me that uh whoa that’s the result I guess probably should have printed

out the original numbers but let me just put that into the calculator just for fun we’ll say this

just sort of go back to the calculator it enters so uh oh the squiggly lines

that means that’s not exactly the result i got to figure out how to change the mode on

this calculator so i can get precise let’s see can i do that right here

exact no can i try it again with exact all right this is not a tutorial on the

it as is maybe i’ll do can i do a slightly smaller number yeah there we go okay i’ll take

off three digits so that the calculator will at least show me something okay run it one more time

and then so now we have smaller stuff the answer should have been 38677662 38677662 yeah that looks

the decimal point so the point six is not on there and then we run the modulo

to see what the remainder is and it should say one two eight six three yeah

okay and then the seven is getting returned I don’t know do you want to

return the remainder for some reason we could do it let’s just return the

remainder might as well make this video a little bit more fun so recall that in

order to return something if the return value is an integer and not a float or

float or if it’s a pointer then you’ll just use RAX as the return register so I’m just going to do

move return the remainder to the color okay I’m going to move something into RAX it’s going to be

R15 nice now this is a function with a return type I’m going to say along here and then

up here, I guess, RAX is already going to be pre-filled now after that call.

But you could imagine if you were doing more stuff between the call and the return,

you would probably want to save the return value from RAX in some other register like R12.

And then that means you got to add a push pop pair to preserve it.

And then we’ll definitely just, well, maybe I’ll say move RAX into RAX

totally useless. That’s why I’m commenting it out. So we’ll do one less instruction.

So basically after we get back from divide test, RAX is going to have the

return value and math, this function would also use RAX for its return value. So if we just sort

of don’t do anything, we should now see that the driver receives the remainder as its return value.

Let me open that up again real fast just to make sure we understand what’s going on with

the driver.

Even though this is not a driver video, it says external long math.

It names that as a long function.

And then when we call the function, we just kind of grab a long result, 64 bit int, and

then we print it with printf because this is a C program, not C++.

integers, assigned integers. Let’s see in assembly. Let’s see. Where’s that? Yeah, there we go.

So just keep in mind what I’ve been showing you is idiv, which is a signed integer, which is what

you probably want, which means the integer can be positive or negative. And, you know, if you know

for sure that you’re going to be dividing two positive numbers, and there’s no chance that

that the numerator or denominator or the quotient or you know any of those things are going to be

negative then you could you could divide unsigned integers and then you can use larger values

because remember when we have signed values we basically lose half of the I guess maximum

possible value that we can represent because we lose one bit to the fact that the integer is signed

is for signed sorry i div is for signed and regular div is for unsigned and then

yeah i guess that’s basically all i really needed to show you there’s a bunch of nice code in this

book i’m not gonna i’m not gonna look at it right now so okay thank you so much for watching this

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

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

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

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

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

really mean the world to me and it’ll help make more videos and grow this community. So we’ll be

able to do more videos, longer videos, better videos, or just I’ll be able to keep making

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

So please do me a kindness and subscribe.

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

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

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

That’s exactly what happens every single time.

So you could do it as a nice favor to me

or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now,

the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for uh

clarifications or errata or just future videos that you want to see please leave a comment or

what’s going on you know just send me a comment whatever I also wake up for those in the middle

of the night I get I wake up in a cold sweat and I’m like it would really it really mean the world

to me I would really appreciate it so again thank you so much for watching this video and

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

Thank you.

you

The post Signed Integer Division in x86-64 Assembly with IDIV and CQO appeared first on NeuralLantern.com.

Want to write a single program that uses C++ for high-level logic, C for portability, and assembly for speed? This video shows exactly how to do it.

We build a complete hybrid program from scratch:

• driver.cpp – contains main(), prints intro, calls assembly
• c.c – simple printf() function
• cpp.cpp – C++ function (with extern “C” to disable name mangling)
• hello.asm – assembly module that prints messages, calls C and C++ functions

You’ll see:

• Why hybrid programs matter
• How source files → object files → final executable
• The role of the driver and why main() lives once
• Name mangling in C++ and how extern “C” fixes interop
• Global / extern in assembly to expose and call functions
• A clean Makefile that compiles each module separately
• Live build and execution with output explained line-by-line

By the end you’ll know how to call across languages safely, pass basic args via registers, and structure projects for fast incremental builds.

No prior assembly required – just basic C/C++ familiarity. Code is copy-paste ready.

Timestamps in comments. Source files linked below.

Like & subscribe for more systems programming!

What is a Hybrid Program 00:00:00
Why Use Hybrid Programs 00:00:21
Program Modules Overview 00:01:10
Compilation to Object Files 00:02:23
Makefile Introduction 00:04:26
Driver Module Setup 00:06:43
Name Mangling Explained 00:07:18
C++ Module with extern C 00:07:43
Driver Main Function 00:10:12
C Module Implementation 00:11:52
Assembly Module Setup 00:12:41
Assembly Data Section 00:13:03
Assembly Text Section 00:14:18
Global and External Functions 00:14:35
Assembly System Calls 00:16:20
Calling C from Assembly 00:18:58
Calling C++ from Assembly 00:20:32
Program Execution Flow 00:21:05
Running the Program 00:23:59
Passing Arguments Between Modules 00:26:23
Hybrid Program Summary 00:29:11

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

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

Hello there. Let’s talk about hybrid programs.

What’s a hybrid program?

A hybrid program is basically a program where you have multiple modules,

many written in different languages, all compiled into one executable program.

Why would you want to make a hybrid program? Well, you know,

maybe you have C++ as one of the modules that you’re creating and C++ is a high

And C++ is a high level language, so it makes it easier to write big, robust programs with GUIs and like big design, big fancy design patterns and things.

But maybe at some point you want to interface with the C program.

So it might make sense to, you know, kind of jump into some C code.

Maybe also you want to write a little module in assembly because maybe one part of your code needs to be really, really fast and efficient in some way.

the code compiles down to machine code.

Assembly is just, you know, a level up from machine code.

So let’s see, I’m just gonna write a quick program

to demonstrate that you can do this

and you can have these modules call each other.

First off, I should probably draw a little bit

about what I’m even talking about with multiple modules.

So I’m gonna do my little annotator here

and yeah, there we go.

Basically imagine that you have a C++ module

and we’ll call it the driver.

and we’ll call it the driver and I’ll say like driver.cpp. Okay I think I’m

drawing this backwards. I’m gonna draw this down here. Driver.cpp.

Excuse my penmanship I don’t have a smoother setup on this thing. So we have

driver.cpp that’s one source code. Maybe you have like another module, another

just some C code. The driver, usually the way I like to refer to it, and one of my favorite,

you know, assembly books refers to it is the driver is where the main function is so that

it’s sort of like the entry point of your program. But then maybe we’ll have another module that has

some other kind of CPP code in there. I’m just going to call this file cpp.cpp. And maybe we

have another module that’s written in assembly. I’m going to call this hello.asm. Okay, so just

Okay, so just several source code files.

We will compile them each to an object file.

Sometimes, I think, with new programmers,

they think that you just compile a source code directly to the executable.

We’re not going to do that in this case.

We’re going to get a little bit fancier.

Doing it this way, by the way, will increase your compiling efficiency

when you start getting used to make files.

I don’t know if you’re already using those, but it’s a good idea.

So we’ll write a script to compile or make file to compile

or some kind of a build system to compile.

We’ll compile the CPP driver to just a file called

driver.o, O for object file.

So O for object file depends on driver.cpp.

We’ll have another file called c.o,

so the object file c.o depends on c.c and so forth.

So I’m just gonna go cpp.o, circle it,

and then down here we’ll do hello.o.

Notice how all of these modules, regardless of the language they are written in, compile

down to an object file.

That’s really what it is.

The higher level languages are just an illusion for us humans.

So then at the very top, we want our actual executable file.

We’ll call it main because that’s kind of a standard thing sometimes.

So it’s like our main, we’ll have a file named main that we can execute.

is going to be the main function.

Spoiler, it’s going to be inside the driver.

Remember, the main function, if you’re using GCC libraries,

has to appear in exactly one place, one module in your program.

It should appear one time and one time alone, not zero or more than one.

So the main executable depends on the driver object file,

the C object file, and the C++ object file,

and the assembly hello object file.

Looks complicated at first until you stare at it a while,

complicated at first until you stare at it a while and then you just realize,

oh, every source code is going to compile to its own object file.

And then after we have all the object files,

we’re going to have our executable just sort of linked together at the final

linking stage. So with that in mind,

I’m just going to copy paste a make file that I already wrote.

It’s like my pre solution because this is not a make file video.

And I just want you to know just real fast what it looks like.

All I’m doing is I’m going to make some variables, uh,

for my C++ compiler flags and my C compiler flags and my Yasm assembler flags.

I’m really not doing anything fancy.

I’m just sort of setting up some variables so I don’t have to type.

The newer Ubuntu stuffs need a no executable stack flag and a no pi flag.

So here we’re just like making variables for linking.

My executable’s name is going to be main over here.

I personally like to make make files that default to a cute help menu.

help menu. I know most people just default to building, but, uh, you know, for educational

purposes, I think this is a little more fun, a little easier. So this way later I can just type

make menu or make build or make run or make clean or whatever I want to do. And, um,

I’m going to make a target called run, which is what we’re going to be using. And then a target

called build, which just only builds everything. The run target obviously depends on build so that

to run it and and if you don’t know make files at this point it’s okay this is not a make file video

i’m going to make some make file videos in the future

then my binary the main program is just going to depend on all these object files notice how it

depends on the driver the hello the c plus plus and the c object files so really uh at the linking

stage we’re just going to use g plus plus to just sort of link all the object files together

Then we have a little section to compile each source code file.

So in order to make driver.o, I’m going to compile,

I’m going to depend on the driver.cpp.

And then when it comes to actually compiling, compiling it,

I’m just going to type the commands to compile it here.

Don’t worry about these crazy variables.

I’m going to make more videos in the future.

And then each module gets compiled in its own way.

Then I just have a little target at the bottom called clean because I like to be

able to just clean my build area of object files.

I don’t know about you, but I like a clean build area.

I’m a clean build area guy.

I don’t like a dirty build area.

So that was the make file.

Again, this is not a make file video,

so don’t worry too much about it right now.

The next thing we should do is make a driver.

Again, I’m gonna copy paste from my solution here

because the driver should be easy.

This is really, this video is mostly gonna be

for people who have never done assembly before.

So I’m just gonna assume you know a little bit

about C++ and C already.

So I’m going to say touch, let’s see, driver.cpp so that I can get the driver file in there.

And I’m going to go nano driver, probably put it down in the first place.

Then I’m just going to paste my solution.

Oops, you can tell I copy pasted this from my IDE because I have the extra tabs in there, which I love.

One thing to keep in mind is that, I guess like one of the first rules that I want to tell you for hybrid programs

is that assembly doesn’t understand something called name mangling.

mangling. So what is name mangling? Name mangling is basically when you have a,

oh, this is not going to get called. So this is maybe not a great idea to show you name

mangling. Let me, let me start on one of the other ones real fast too. Let’s do

the C++ module. Okay. So I’m going to go nano CPP dot CPP. I know it’s a silly name. I know it.

So CPP dot CPP, this is just a simple C++ program, which is meant to be called by

by the assembly module just to show you that we can.

And so we just have a little function here,

void, you know, the CPP function.

So it’s just a function that doesn’t really return anything.

Inside of it, I’m just going to print,

hello, this is the C++ function, no problem.

Notice at the top,

this is the first important thing that you should understand.

In C++, we have overloads, right?

You can have the same function name,

but with different argument lists.

And so that gets resolved under the hood

by the name actually kind of changing

based on what the argument signature is,

what the prototype signature is.

So that’s great and all,

but in assembly, at least at this level,

there’s no way to really differentiate between overloads.

In assembly, we’ll just call a name of some function.

But if we try to call a name,

let’s say of just the CPP function,

if we say call the CPP function in assembly,

it’s not going to work

because the actual function has not been compiled to have that name.

It’s been compiled to have the CPP function

and a bunch of extra symbols indicating what the argument list is.

This is great for C++ programs, but it’s poor.

It’s bad for other modules to be able to call the C++ function

because they won’t really know what the actual name is

after the mangling has been done.

So what you want to do is make a little block called Xtern C,

just like this.

You say extern and then C in quotes and then do a scope with braces.

And inside of that, just put the prototypes of any function that you want to be available to other modules.

So, for example, we want the CPP function to be available to assembly modules and C modules, not just other C++ modules.

So, I’m just going to put the prototype of it right there.

You can put as many prototypes as you want.

I think they should come from the same source file.

different source file where you want something to be available elsewhere,

you would put an extern C block for its prototype.

This disables name mangling,

which means the compiled name of the CPP function will actually be the CPP

function. So it’s pretty good. This will make it available to assembly.

So now that I’ve kind of explained that I can maybe close this and go back to

what I was doing before. So this is the main driver program.

We don’t need to engage in a dis,

we don’t need to disable name mangling for the main function because no one is going to call main

except the GCC libraries or like the OS. But when the C++ module calls other modules, it needs to

be able to call the right name. And remember in C++, there’s name mangling enabled by default.

So if I tell it, let’s say on this line right here, or you can do alt N to get line numbers on nano.

we want to call on the hello module will C++ by default will assume that hello has name

mangling applied to it, which means it will actually try to call some name that is totally

different based on the prototype signature, the incoming arguments and things like that.

But so we want to disable that because we wanted to just call the actual name because

hello is going to be a function that we make inside of assembly.

So it’s not going to be name mangled.

So that’s why up here on line seven, we enter its signature.

Enter its signature. Oh, actually this is from a different version of something that I was doing. I’m not going to return anything from hello

We’ll do name a demangling with our extern C block just void hello

And now when we call hello, it’s actually going to call a function called hello without any other

mangling same thing for the C S E A

Oh

That was from a different version. I wrote we’re not going to be calling C in this module. Don’t worry

We’re going to keep it simple

So pretty much we’re going to print hello and then we’re going to print,

then we’re going to call the hello and then we’re going to say goodbye.

And then that’s going to be the end of the program.

So let me close out of that and just double check what I have written right now.

So we’ve got CPP and okay, we need to do C, nano C dot C.

Okay, so let me get my solution real fast here.

It’s a simple program.

Literally, it’s just a C program that prints something.

Remember in C++, we’ve got the IO stream, but we don’t have that in C.

that in C. So I’m just going to use printf. Oh, by the way, this is a C function. Hi.

So done with that. Pretty easy. Shoot. You know what? I need to start learning how to do

clear and LSA. So I can just go up, up, up. So C++, C and the driver

and the make file, which is huge. I just realized that. And now I guess we can start

or hello function.

Okay.

So maybe I want to write this in the Genie program.

So I’m going to, well, maybe I’ll first, I’ll say touch,

and I’ll say hello.assembly.

And then now that it’s there, I can try to open it up.

Let’s see.

Hello.assembly.

Okay, so now let’s write an assembly program.

I’m not going to spend too much time talking about this,

but I’ll say like data section here,

and we’ll say section.data.

We’ll say section.data and then we’ll say system calls.

This is not a system calls video.

I’m just gonna do this very quickly without explaining.

System write is gonna be code one, I guess.

And then we’re gonna do file descriptors, one for stdout.

Whoops, stdout, it’s gonna be equal to one.

This is not a file descriptors video.

I’ll put FDs, I guess.

And then we’ll make some C strings.

C strings, you know, just character arrays, basically.

I’ll say, well, you know what?

I don’t want to type this all out

because this is not a lesson on variables.

I’m just going to copy paste my existing solution here.

And, you know, long story short,

I’m going to try to make this a pretty program

that prints hello and goodbye and things.

And so we just have like some variables

that sort of just you know old strings and hold the strings length and we’re

gonna do one that calls a new line and so forth actually that’ll be a different

video but I’ll leave it in there for now so now let’s make the text section

remember the text section in Yasm is just for the actual code of your program

and then we need to set up some external symbols. So right now, at least for the purposes of this

source code, this source code is inside of the hello module. So you can imagine we’re inside of

hello.o. All the o’s get linked together in the executable, but between themselves, there’s kind

of a little bit of like a border situation happening. There’s like some separation. So

are going to be available to the other modules,

even if they’re part of the same executable.

It’s kind of convenient because you would like sometimes

to be able to write tons and tons of functions

that are only available inside of your assembly module,

and they might not be available to other modules,

and therefore you don’t want to pollute the namespace,

I guess, of the global namespace of the executable.

So by default, if I make a function called hello,

how you make a function, just a quick recap here.

This is not a functions video.

make a symbol with the name of the function you want and then you just put a ret after it and then

you hope that whoever got you there is going to use the call instruction but anyway for now

we’re just going to say this is our hello function okay i cannot call the hello function now from

another module i have to make it visible to the other modules with a special keyword called global

our program the hello function will be available to the other modules but not anything else that

I type without marking it as global so let’s go ahead and do let’s do a welcome message and this

is not a system call a video maybe I should just copy paste this so just looking at it this is a

going to quickly you know breeze through what we’re doing in case you’re interested but you

don’t have to care too much about this right now we’re going to tell rax what system call we want

to make the code for that is what i put up in system right which is just code one means let’s

write to a file we’ll give it the file handle uh that’s going to be the variable we made called fd

std out which means we’re going to be giving it the file handle of one which means we’re telling

to print to standard output because file handle one is always standard output.

And then we just give it the a pointer to the first character of the message

string that we made and then tell it how long that message is. Then we do system call this should

actually um this this should actually print a string. Okay so then uh let’s see down here I’m

going to make a function called crlf because I’m lazy and I don’t like constantly adding extra stuff

constantly adding extra stuff to the string so that there will be like a new line line feed

situation so i usually like to make a little function somewhere called crlf carriage return

line feed is what it stands for and it’s the same thing it’s just like load up the system call

registers so that it knows i want to print the string which is just a line feed

carriage return line feed and then actually call system call and then return to the caller so this

back up here let’s see crlf i guess i am going to be doing it it’s just a string with the the

slash r slash n or the carriage return line feed characters in ascii those are 13 comma 10 so i can

put that there instead of a literal quoted string okay so we got that and then that means after the

welcome message i can just like call crlf in order to have uh the cursor jump down to the next uh

after that string is notice how I don’t have any line feeds after my strings that’s kind of why I

like to do crlf and it lets me just call crlf a bunch of times if I want to just like space things

out temporarily okay so we’ve got the hello function and now we’re going to print another

message here I’ll just explain this real fast so I’m going to print a message about calling a c

So same thing, we’re just going to tell the system call service that we want to print a string and it’s going to be our string here that says, you know, we’re about to print this.

We’re about to, what do we say?

We’re about to call the C function and then later we’re going to call the C++ function.

So we’re just going to print a message announcing and do CRLF.

So that’s really nothing new at all.

And then down here we actually call the C function, which is not going to be in this module.

It’s going to be in the C module, the other source code.

Somewhere in this program, we need to let our assembly module know

that the C function is available because it kind of goes both ways.

In assembly, I have to mark a function as global if I want other modules to be able

to call that function, but I also have to mark a function as external

if I want to be able to call some other modules function.

So we have to go back up to the top.

I mean, somewhere in the text section, I think would be fine.

But for me, I just like to put it at the top.

put it at the top at the top so I’ll say externals and then I’ll go extern

keyword and then just name the function that I intend to call this way when the

linker is trying to link all the objects together it doesn’t get upset because

you tried to call a C function which is not in the current module it’ll

understand that it’s gonna happen you know like it’s gonna call other modules

for that it usually gets upset right away and then while we’re at it let’s do

Let’s turn the CPP function because that’s going to come from the C++ module.

So now we have both of our external functions set up.

We’ve marked our global hello function so other modules can call us.

And then let’s see, oh, what did I do wrong?

I put the C message in the wrong spot.

I was inside of the CRLF function.

So I’m just going to copy paste that back up here.

Okay.

Then we’ll do the same thing for the C++ message,

or for the C++ stuff.

I will first print a C++ message

with these lines up here.

That’s just like a regular system call,

and then I’ll do a CRLF, so nothing new,

just printing something.

And then I will actually call the C++ function

called the CPP function.

Then I’ll say goodbye with another block of text.

Again, not super important or complicated,

so I’m just gonna paste it.

Just another string.

string. And then when we’re done, I’ll just say, you know, return, we’re done. So that means if

you notice how we don’t have like any symbols in here called underscore start, that means this is

not a pure assembly program. And we don’t even have a symbol inside of here that is called main.

So that means this hello ASM module is not going to be the entry point of our program. It’s just

going to expose a function called hello, which does some stuff. The entry point of our program

really, let’s see, where is it? Oh, gosh, I think I already closed it for some reason. It’s the

driver program, which we talked about. So remember the driver program, it’s got a main here. So that

means this is going to be what the GCC libraries or the operating system calls, however you want

to think of it. So this is the entry point of our program, it’ll just print something quickly,

then it’ll call the hello function, which means execution will jump in to the hello module. So

module and and also it would be really easy to apply this logic to have a c module call on an

assembly module and in fact you can use this logic to have every type of module call on any other i

mean just if you have a c++ function either being defined in the current module or being referenced

in another module just make sure that you have an extern c block and then if you’re inside of a c

and you’re going to call a non-name mingled module like C or assembly,

then just do this block here.

No problem.

What else can I really tell you?

The C module, we looked at that.

The C++, we looked at that.

Pretty easy.

Hello module.

I mean, I guess we’re kind of done already.

So what we should see now is a little intro here.

Hello, my name is whatever.

And then when we jump into the hello module,

we should see a little welcome message about being in the assembly module.

And then we should see a message about calling the C function.

And then the C function should print.

Let me open that up for you.

Let’s see.

The C function should print.

Just, oh, by the way, this is the C function.

And then when it returns at the very end, remember, even in a void function, there is

a return statement implicit at the end of scope.

So when it returns, it’ll come back down here.

And then the C++ message will get printed.

printed and then the C++ function will get called which is going to end up being

just it just prints you know another message this is the C++ function

then when it returns implicitly at the end of the function

then we get down to here where we just basically say goodbye and then return to the caller

the caller in this case is going to be the driver program because this whole time we were just inside

called. So then the driver will say goodbye and then it will return control to the GCC libraries

or the operating system ending the program. Let’s see if that works. Okay, clear. And so,

you know, the way I wreck my make files, I’d like to do a little menu. I type make and it’s like,

oh, the menu, make menu, make build, just in case, just to see what’s up. Okay, clear.

say, let’s do clear and make run because that’s really what we’re after.

Again, run will implicitly call build.

So do that.

And it seems to have succeeded.

It wasn’t actually very exciting.

Let me do a make clean so you can see it compile real fast.

We run it.

It’s compiling.

That was still kind of fast.

So up here is basically the make file, all these lines.

They’re just calling your normal compiler and assembler tools and linker tools.

linker tools and then here’s the driver like we said it prints the hello message

you know my name is whatever I love that name I have a strange name generator

that I found online that’s not my name you can call me that if you want to and

then we have the message that we’re going to call the hello module so now

we’ve called into the hello function inside of the assembly module assembly

module prints hello you know I’m inside of here now and then the assembly module

Now we’re going to call the C function and then the C function actually

executes and it is now printing with its print F function call that it did,

you know, by the way, this is a C function. Hi.

And then it returns to the caller.

Maybe I could have added another print statement if I felt like I wanted to

spend more time, but it returns to the caller, which is the hello function.

Then we get to the next part of the hello function where it’s like now calling

the C function as a print statement.

Then it actually does call the C function. The C function prints itself out.

prints itself out hello this is the C function and then the assembly module

says goodbye it says it’s finished and then it returns to the caller so finally

at the end of this print statement the there’s like that little return statement

at the bottom of the hello module that returns to the caller which was the

driver dot CPP program so then the driver prints the driver is now back in

the driver is now back in control. You can see that message behind the terminal here.

The driver is now back in control. Then it says goodbye. Then it returns zero to the operating

system and the whole program is done. So it’s important to understand that if you want to

pass arguments, right now I’m just going to say, you know, I’m going to make another video that

is more robust in the future about passing arguments back and forth between these. It’s

important to understand for now that you can pass arguments between all these different

between all these different module functions if you want.

Like if I wanted to give the.

If I wanted to give the hello function.

An incoming argument, let’s say like an integer or a character value or a pointer

or something like that, I could just load up appropriate registers.

Remember, we have argument registers in assembly.

I think I can never remember if RSI or RDI are the first one.

I’m going to say RDI is the first argument just off the top of my head.

I always look that up.

So if I wanted to call, let’s say give an integer argument to hello when I originally

called it, then from the driver, I literally would just have to type an integer argument

in there and then under the hood, the RDI register, assuming that I’m right about RDI

being the first argument, the RDI register would get loaded up with that value.

your assembly program all you’d have to do is do something with the RDI register

you know load it up save it do whatever it is that you think you’re gonna do so

that’s how you pass an integer or like a character or a pointer from C++ to

assembly it works the same exact way if you want to pass arguments when calling

from C to assembly and when if you want to pass integers from assembly to C or

or C++, it’s the same thing just backwards.

First, you load up RDI as the first argument register with whatever value you want to pass

to C or C++.

And then in the signature of the C++ function, you just expect, you know, a long or, you

know, whatever you were going to get and the register will already be loaded up.

Remember, the C++ is not really happening on the machine.

It gets compiled down to assembly.

So this source code that we’re looking at, it’s another illusion for our benefit.

benefit. It’s not happening. It’s getting assembled and then compiled down to machine code. And then

that is what’s actually happening on the machine. So when you write that you have an argument in a

C++ function signature prototype, you’re not really writing that at all. You’re just saying

that the A variable should get loaded from whatever the RDI register had.

Or if you previously loaded the RDI register and you want to call a C++ function, that’s

a C++ function that’s what it would expect the RDI register so it can work pretty seamlessly

just calling things back and forth um so yeah I guess that’s all I really had to say

this is the basics of writing a hybrid program thank you for watching I hope you learned a

little bit of stuff and had a little bit of fun see you in the next video

thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could

do me a please a small little favor could you please subscribe and follow

this channel or these videos or whatever it is you do on the current social media

website that you’re looking at right now it would really mean the world to me and

it’ll help make more videos and grow this community so we’ll be able to do

more videos longer videos better videos or just I’ll be able to keep making

videos in general. So please do 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’ll happen.

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

QR code which you can scan in order to go to the website which I think is also named somewhere at

the bottom of this video and it’ll take you to my main website where you can just kind of like see

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

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

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

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

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

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

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

Thank you.

The post Mix C++, C, and Assembly into One Program – Hybrid Program Full Build Tutorial appeared first on NeuralLantern.com.

Want to master command line arguments in pure x86-64 YASM assembly on Linux? This video breaks down how to access argc and argv directly from the stack, without GCC libraries. Follow along as we write a program to loop through and print user-provided arguments, complete with a visual stack explanation. Whether you’re new to assembly or leveling up, this tutorial offers clear, practical insights for coding low-level programs. Check out my other videos for more assembly tips, and subscribe for more coding goodness!

Introduction to Command Line Arguments 00:00:00
Target Architecture and Assumptions 00:00:04
Recap of Command Line Arguments 00:00:56
Accessing Arguments in Pure Assembly 00:01:47
Program Structure and Data Section 00:02:19
Stack Pointer and Argument Count 00:04:16
Accessing Argument Vector (argv) 00:07:14
Looping Through Arguments 00:12:16
Incrementing to Next Argument 00:16:45
Visualizing the Stack 00:19:24
Running the Program with Arguments 00:21:56
Conclusion and Call to Subscribe 00:23:48

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

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

hey there let’s talk about accepting command line arguments in a pure assembly program

written for x86-64 aka amd yasm assembly

on linux anyway so uh there are going to be a lot of topics that i that i sort of mention in this

video that are not actually covered in this video so if you feel yourself getting lost like for

program in assembly in the first place.

If you don’t know what command line arguments are,

if you don’t know the terminal, things like that,

you probably want to check out my previous videos

because they will be explained in detail.

For now, I’m just going to assume you know how to do all this basic stuff.

And the only thing that I need to show you

is how to write a program in Yasm assembly that can

grab your command line arguments.

So, you know, just to do a quick recap of what I’m even talking about.

echo we can launch it with no arguments it doesn’t do anything but we can give

it some arguments we can say hello and then we can say goodbye and that’s two

arguments that I’m giving to echo echo will grab on to the arguments it was

given it’s actually going to receive three arguments the index zero argument

being the name of itself its own program and then the next two arguments being

the stuff that I typed after the program but you can see that it somehow figured

two arguments as strings and print them right so imagine you have an assembly

program and you want the user to be able to launch your program and add

arguments at the end of the command line and have your program behave in some

certain way according to what the user wants the question then becomes how do

you access those arguments it’s a little bit easier in GCC look at my other video

that I posted about the topic for GCC linked assembly programs it’s a little

You pretty much just look at RDI and RSI to get your argc and your character pointer array.

When you’re dealing with pure assembly though, the GCC libraries don’t bundle up the command

line arguments in a really convenient way for you.

You’ve got to look for them elsewhere.

It’s honestly not that much harder.

It’s just a little, feels a little weird.

I think at least for me, I was hoping to see the arguments in a register and I did not.

But anyway, so here’s my program.

Again, this is not an assembly programming video.

an assembly programming video if you need to know how to program assembly see my other videos for

now i’m just going to quickly go over it i’ve got my data section in yasm i am printing out a couple

of strings or i i have a couple of strings defined i’m saying like the module has started i’m going

to begin printing arguments i have some system call codes so that i can write just to standard

output and so that i can exit the program this is pure assembly so we don’t actually return from

we just get jumped into and then we call exit normally and then here’s the standard output pipe

again another video covers that and then i’ve got the exit success code again another video covers

that but basically you know exiting zero is usually what you do for success then i’ve got the

text section which holds all my assembly instructions and this is my entry point we don’t

really need to uh push and pop these registers because we’re just going to exit the program when

it’s totally fine we would need to preserve Kali saved registers if we were

jumping into a main function or if this was a different function that was being

jumped into but we’re not so we don’t have to anyway here’s my entry point the

underscore start for a pure assembly program and then I’m going to grab the

incoming arguments when you’re linking with GCC which we’re not doing here in

this video then the arguments come in very easily they just come in argc

up in RDI and arg sorry argc comes into RDI and the character pointer array comes in as RSI so you

can imagine in GCC this would be integer main and then integer argc character pointer array argv

right hopefully you’ve done this in a higher level language so you have a better idea of what I’m

talking about if not I guess that’s okay it will still allow you to grab even if you don’t

it will still allow you to grab,

even if you don’t understand this in C++.

So argc is actually the stack pointer.

The stack pointer register, RSP,

always tells you where the top of the stack is,

like what’s the last piece of data

that we actually have sitting on the stack.

So that’s gonna be the count of arguments.

argc is always gonna be the stack pointer.

So if you dereference the stack pointer register,

pointer register then what you’re doing is you know the stack pointer register

actually points to memory locations within the stack so if the memory

location that it’s looking at is where argc is stored then you dereference it

with the brackets and you’ll actually get argc so right away I’m just gonna

steal argc off the top of the stack and this is a good idea to do right away

because if you start doing other stuff you might end up modifying the stack

especially if you start calling functions and things like that and and

and and these these pieces of information will be lost or they’ll be a lot harder to find so right

away i’m just going to say argc goes directly into r12 and i have a little comment reminder

for myself at the top saying r12 is now argc same thing for uh r13 i’m going to say that’s a pointer

to my character pointer array i talked about this in depth on my other video where we talked about

an assembly program but basically if you look at uh if you look at argv right here it’s not just a

pointer and it’s not just an array it’s a pointer to an array and if you recall in higher level

languages or just i guess anything an array itself is a pointer because argv the symbol let’s say we

were in a higher level language argv can only point to one thing so it’s going to point to the very

but the beginning of your array is not going to be one string like one argument that the user gave

you because the user could give you many arguments instead it’s an array of pointers

so it’s a character pointer array meaning argv is a pointer to a pointer

the first item in any array is what is pointed to by the symbol so like imagine if we had just

had just for the sake of argument imagine if we had an integer array let’s say we had like 500

integers in like a c++ program so the symbol a is what i’m trying to say the symbol a

is really a pointer that points to the first integer in that array and then later of course

you can dereference that pointer with some sort of an index to get the index 5 integer or the

the array and a pointer to the first item.

Or I guess you could say it’s both a pointer to the array

and a pointer to the first item,

because it’s kind of the same thing.

So that means if we grab argv,

then we’ll be grabbing a pointer.

If we then dereference that pointer,

it would tell us where another pointer is.

And then that other pointer would point to a string

representing the first argument.

first argument so we’ll explain that more as i do this loop i’m going to i’m going to show you

some code that actually loops through all the arguments anyway the thing about where to find

that argv is it’s just the next pointer or i guess it’s the it’s the next item that the stack holds

so remember i told you that rsp when this when this function comes in rsp is a pointer to wherever

we’re we’re looking what memory location the top of the stack is so if we dereference that we get

So if we dereference that, we get argc.

Well, we just need to go find the next previous item in the stack

and then dereference that so that we can get the first pointer or argv,

you know, the first pointer to a pointer,

or the first double pointer in your array of pointer to pointers.

Why am I doing plus eight?

This might actually make sense as is,

sense as is but it’s important to understand that when you add stuff to the stack you’re actually

decreasing the memory locations uh that you are pointing to so like if i if i increase a stack

this is not a stack video there’s other videos that i have for that um if we add something to

the top of a stack you imagine the stack growing visually in a in a vertical direction like it’s

growing up right but inside of the computer the memory locations are actually going down

If we’re looking at the stack pointer and we’re adding eight, what it’s saying is that

we’re looking back into memory that was already added for the stack.

So that’s like if we grew the stack, that would be subtracting from the memory location.

So like looking further up in the stack would be subtracting from the memory location because

the stack grows upward in the abstract, but downward in memory locations.

So that means if we add eight, that means we’re going in the other direction.

that means we’re going in the other direction.

We’re looking downward into the stack.

So what that means is that the top two items on the stack

are first argc and then second, that first pointer,

you know, the argv argument.

And that’s how we access it with plus eight.

Why is it a plus eight instead of plus something else?

Because all pointers on 64-bit systems are 64-bit integers

and 64-bit integers are eight bytes.

If we’re talking about eight bytes, sorry,

if we’re talking about eight bits per byte.

So this is just how you access it.

What about this other thing going on here?

What’s this LEA instruction?

Usually you see a move instruction, right?

So we basically want to look at the stack pointer,

but look one level lower.

And each item on the stack is also going to be eight bytes.

We want to look one item lower on the stack,

and then we want to dereference it.

but we don’t want to dereference and store the dereferenced value we still want to grab the

actual pointer the thing is I shouldn’t have said dereference in the first place these are dereferencing

brackets right so like up here on line 46 when you put brackets around rsp it dereferences whatever

value rsp holds so therefore when you put brackets around this you kind of expect that you’re going

to be dereferencing right but we don’t want to dereference we just want the original address that

showing us. So the problem with this is that when we say RSP plus eight,

we can’t actually do a mathematical formula unless we’re inside of brackets, which means we

can’t do them in a move instruction without accidentally dereferencing and losing a pointer

to the actual array of pointers. If we dereferenced like this, we would just end up with,

you know, a pointer to one string. So the way around this is instead of using the move instruction,

instead of using the move instruction we use the lea instruction the lea instruction allows us to

put a formula inside of brackets so that the assembler won’t get confused but then it won’t

put the dereferenced value into r13 it’ll just put the actual value of whatever we see

with that formula meaning it’ll give us the memory location of the item sitting one under the top of

this at this point r13 is now the memory location of the of the item sitting one underneath the top

of the stack and then we can de-reference that later in order to look at all of our arguments

so the next part of our code is just going to print an intro message so there’s like this intro

string up here hello and um i’m basically going to call a custom function that i made to just sort of

Printing. Don’t worry about this code right here.

This is not the point of the video.

I just made a custom function that just kind of helped me print.

Don’t worry about that.

The real meat of this video is that we’re going to loop through all arguments

and just print every single argument that the user provided.

So you can imagine this is maybe the top of a while loop here.

Notice how, oh, I forgot to replace main with start with start.

I had another version of this program that used main.

pretend we have this is called the main loop instead of the the main functions

loop anyway so main loop initialize first thing I’m going to do is I’m going

to initialize the loop by saying we’re looking at index 0 okay no problem so

we’re looking at index 0 we want to do that we want to look at all the

arguments you know we want to look at index 0 and index 1 and index 2 and we

just want to keep going until we’re out of arguments remember that we also have

the number of arguments coming from argc now sitting in r12. So that means if we have a

counter that starts at zero with r14 and then we know how many arguments there are in r12,

we should be able to know when the loop stops. So just a reminder that, you know, the loops here,

the arrays here are zero-based indexed or zero-index based, which means, for example,

that’s three arguments but the array of arguments is going to have indexes zero and one and two

which means the last valid index is going to be two or the size minus one think about that if you

have five arguments the last index that is valid is going to be four size minus one because it’s

zero based so we can use that logic to figure out if we’re done so we start off with an index of zero

here and then at the top of the loop i’m just going to quickly ask are we done how do we know

are we done how do we know if we’re done we compare the current index we’re

looking at with the count and we say if the current index we’re looking at is

greater than or equal to the count then we know we’re already done we don’t need

to look at any more indexes why am I saying is is the index greater than or

equal to the count because remember if we have five arguments then the last

valid index is four therefore if we find ourselves looking at index five we know

already done five is equal to or greater than five, but four is not equal to or greater

than five.

So that’s why I’m using this logic here.

I’m saying if we’re done, then jump to the done label.

Basically what’s the done label?

It’s main loop done.

All it really does is it says goodbye and then it just exits the program with a system

call.

Again, I have other videos that explain system calls and all that stuff.

So if we’re done, we, uh, we jumped down to the done area, but if not, then execute

to the done area but if not then execution will fall through to this next loop or sorry this next

label which is not necessarily we don’t really need a label there but i i like to put i like to

put it there just to help myself remember this is what it looks like in terms of a while loop you

know i have like here’s the top of the while loop here’s the little comparison part of the while loop

here’s the body like the opening braces of the while loop and then here’s sort of like the

closing braces i just like to do that but anyway after we decided that we are not done and we drop

done and we drop through to the next actual instruction we’re just going to

print the next argument so what’s the next argument we will dereference r13

remember up here we took the second item sitting like you know one under the top

of the stack and we just stuck it into r13 so this is r13 is now the address of

the second item on the stack if we de-reference it then that’s going to give

then that’s going to give us a pointer to our um sorry it’s going to give us a pointer to the first

item to the first string i should say to the first string uh the f this the string of the first

argument so if we dereference you know let me say this one more time just to make sure that i’m

item, you know, the item right under the top of the stack, that’s going to be a pointer

to the first argument string.

So if we just simply dereference R13, then we’re basically telling RDI, here’s a pointer

to the string that we want to print.

Okay, so then I just call my helper function to print that string to standard output, no

problem.

And then we have to figure out like, how do we increment to go to the next string?

might have been unclear earlier because gcc does it in a different way but on the stack

every item underneath the the top of the stack is a is another pointer it’s part of the original argv

array it’s another pointer to a different string so basically if i increase r14 here then i’m

increasing the index counter that’ll help us eventually terminate but notice how here i’m

Remember R13 is the second item, you know, the item right under the top of the stack.

And if I dereference that, then I now have a pointer to the first argument string.

If I want to go one lower into the stack, then I just add eight to that register’s value.

Because again, remember, the stack grows downward in memory.

So if I increase the value, then I’m sort of like going through previous items that were put into the stack.

So imagine the stack here, it’s got like,

you know, argc sitting on top

and then underneath argc,

it’s got a pointer to the first argument.

And then under that in the stack,

it’s got a pointer to the second argument.

And then under that in the stack,

it’s got a pointer to the third argument.

Then under that, it’s got a pointer

to the next argument and so forth.

So every time we wanna go to the next arguments pointer,

the next arguments string pointer,

we just add eight to that R13 register,

which was originally just pointing at the first string.

so again why eight because pointers are 64-bit integers therefore they are eight bytes so I’m

just literally increasing the index by one and then I’m moving that register r13 to point to

the next pointer that way next time I dereference it up here on line 70 I’ll be dereferencing the

next string and these strings don’t need to be contiguous they could be located anywhere it’s

that is contiguous but it’s just full of pointers to other strings or sorry it’s full of if we de

reference the stack pointer at any point then we will get the address of a string so then we will

get a pointer to a string this double pointer stuff sometimes i get tongue tongue tired okay so uh

when we’re done printing and incrementing then we just jump to the top of the loop

And then finally, when we’re done, well, we’re done.

Let me draw this out for you, because I think the way I’m explaining it might be

a little bit unclear, so I just want to make sure that I’m being totally clear on

this, okay, so I’ve got my little annotator here and you can imagine here’s a stack

and it visually grows up.

We can imagine that every time we add an item to the stack, it grows up.

Like if you wanted to take a five, stick it on top of the stack.

Well, then it would end up on the top of the stack, right?

No problem.

Right? No problem.

Oh, maybe this needs to be bigger because of my pen size.

So let’s do it like that.

What the heck happened?

I lost the whole desktop.

There we go.

So we have this and this and this and this.

And so there’s probably some kind of a value sitting on top of the stack.

When we started the program,

RSP is a register that just has the memory location of the top of the stack,

you know, the most recently added item.

you know the most recently added item we know that this was actually arg c so if we dereferenced rsp

that’ll go to wherever rx is and get it so we can basically say that rx is sitting on the top of

the stack so you know we dereference our rsp which holds a memory location to this place in memory

we just had an integer stored an eight byte integer okay cool so then the next lowest i guess

the next highest item or the next lower item is arg v at index zero which is the same thing as

just saying arg v remember a pointer to the array is really a pointer to the first item

the next lower item is arg v at index one and so forth so we can just keep doing this we can keep

keep doing this we can keep going lower and lower and lower on the stack by adding eight to r13

because remember r13 originally pointed uh you know to this item right here i don’t know i’ll

say like r13 maybe starts off pointing uh to the first argument because that’s the way we have it

set up so every time the loop iterates if we dereference r13 then we’re getting a pointer to

when we add eight bytes to r13 we’re really just moving it down to the next pointer that we can

dereference hopefully that was a little bit more clear than what i said before or maybe you’re just

a visual learner um you know it’s a good idea to try to explain things in many different ways

but long story short we’re going down down down further in the stack to get more arguments and

we’re just printing them and so now that we’ve explained it all we should be able to just run

clear and make run and under the hood let me just show you real fast what I’ve got inside of my make

file under the hood when we do make run you don’t need to know about make files I have a video that

explains all of this don’t worry but well I mean you don’t need to know it to understand this video

but you probably do need to know it notice how when I call the executable which in this case is

I give it some arguments.

I give it just some strings.

First arg, second arg, third arg, fourth arg.

So that’s the same thing as if I typed echo first arg,

second arg, third arg, fourth arg, right?

That’s what echo is doing.

So in the make file, I’m just giving it those arguments.

And then our program now is looping

through all of the arguments.

It knows when to stop because we grabbed argc

and it knows where those strings are located

are located because the pointers to those strings are just sitting on the stack so if we deref twice

we’re derefing we’re doing a double dereference a pointer to a pointer

at least we could say r13 is a pointer to a pointer but the actual values sitting inside

the stack are just pointers to strings um so let’s just do this in a slightly different way

clear and then I’ll say main because that’s the name of the program that I

compiled you can imagine this is could be named something else and I’ll just put

hello you are super cool now so I’m giving it one two three four five

arguments in addition to main so it should print six things main hello you

are super cool now so notice how it prints main hello you are super cool now

Alright, that’s pretty much everything that I wanted to show you for the pure assembly

version of Grappin Command Line Arguments.

Thank you so much for listening.

It’s a little late for me.

The sun’s starting to come up.

I’ve got to go and eat a bunch of cookies.

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

Thank you so much for watching this video.

I will see you in the next one.

Happy studying and coding and all that stuff.

Hey everybody!

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website

that you’re looking at right now.

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

and grow this community.

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

or just i’ll be able to keep making videos in general so please do do me a kindness and uh and

subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because i

know somebody subscribed or followed it just wakes me up and i get filled with joy that’s exactly what

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

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

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

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 uh if you have a suggestion for uh

clarifications or errata or just future videos that you want to see please leave a comment or

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 Master Command Line Arguments in x86-64 Assembly with YASM appeared first on NeuralLantern.com.

Get hands-on with x86-64 YASM assembly in this in-depth tutorial on writing functions! Perfect for beginners and seasoned coders, we cover the basics of function creation, calling conventions, argument handling, and return values. Learn to avoid crashes, respect the ABI, and use prologue/epilogue for clean code. From printing messages to returning integers, see practical examples and tips to simplify your assembly programs. Subscribe for more low-level programming tutorials and take your skills to the next level!

Introduction to Functions 00:00:00
Makefile Overview 00:00:19
Assembly Program Setup 00:02:01
Data Section Definitions 00:02:08
Text Section and Entry Point 00:03:02
Basic Assembly Program Demo 00:03:38
Return Codes Explained 00:04:30
Function Concepts Introduced 00:06:10
Creating a Simple Function 00:07:04
Function Call vs Jump 00:08:00
Adding Return Statement 00:09:06
Moving Print Logic to Function 00:09:48
Benefits of Functions 00:10:01
Calling Function Multiple Times 00:11:58
Creating Print Function with Arguments 00:14:00
Handling Function Arguments 00:15:45
Respecting the ABI 00:17:16
Prologue and Epilogue 00:23:15
Stack Operations 00:24:34
Calling Print Function 00:25:25
Avoiding Recursive Loop 00:34:17
Modifying Print Function to Print Line 00:35:21
Adding CRLF Function 00:30:13
Printing Multiple Messages 00:37:00
Returning Integer Values 00:37:48
Preserving Registers in Entry Point 00:41:50
Final Program Demo 00:43:24
Conclusion and Call to Subscribe 00:45:16

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

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

Hey there! Let’s talk about functions in x8664 Yasm Assembly.

I’m just going to give you the basics of how to write a function.

So let’s get started here. First thing I want to show you is just a makefile.

This is not a makefile video, so you don’t have to worry about it too much.

I just have it up because I need it for this demo.

If you’re interested in makefiles, that would be a really, really good thing.

thing i’ll probably make videos in the future about them but for now we’ll just say you hopefully have

a script or method already set up that allows you to compile or assemble assembly programs

so i’m just going to skim through it real fast if you’re interested you can kind of study it

but basically i have like a little define here that allows me to print out a message that looks

nice and then i define the repo path as the current path and i take the absolute path of that

This is where the real work happens.

I have Yasm flags because I’m using the Yasm assembler.

I’m going to be assembling to x86 64.

I like to out.

I like to convert all of my warnings to errors to make sure that I don’t write sloppy code

export debug symbols and export debug symbols for the linking stage to the name of my executable

is going to be called a main.

have set up and well I can just do make run or make debug as a little shortcut

to run it in GDB if you don’t know GDB don’t worry that’s going to happen in a

future video and make clean which just cleans the build area I like a clean

build area and then this is the main command here we’re going to be using LD

to do our linking because this is going to be a pure assembly program instead of

a hybrid program which would require GCC or something else and then here’s my

And then here’s my program main ASM is going to get compiled down to main.o and

That’s it for the make pile

Okay, so for the main assembly program I have some stuff written up already here, but I think I’m going to modify it for this video

For starters, we have our data section which hopefully you understand already

I’m just going to define a bunch of stuff in the data section like I’m going to define

The system call code to write a string so I can print a message pretty easily

so I can print a message pretty easily the system call code to actually exit the program

remember when you’re writing a pure assembly program that has start as an entry point

you need to be you know you’re responsible for exiting the program so the system call code is

60 there and then I’m going to say exiting for success is a zero that’s kind of a standard thing

and then I’m going to make two file descriptors for the standard input it’s going to be zero and

the standard output it’s going to be one actually I don’t think we need that for this video we just

We just need standard output, but not standard input.

And then I’m just going to make two strings.

That’s not my name, but I like those names.

And then the BSS section.

Actually, I’m going to get rid of that

because we don’t really need that for this video.

And then I have a text section, which is where all the code is.

We’re going to begin our entry point.

If you are writing a pure assembly program

and this is your entry point module,

make a function called underscore start.

It’s not actually technically going to be a function because it won’t return anywhere.

It’ll actually just call the system exit service.

And then I mark start as global so that the operating system can go into it,

can call it from the outside.

And then all I’m doing right now is I’m printing a hello.

So far, this is not really a demo of functions.

This is just like a very basic pure assembly program.

All it’s going to do is it’s going to enter.

going to print the hello message and then down here it’s going to do a system call to exit the

program with zero for success so let’s just see what that looks like real fast I’m going to do

make run and then make run you can see the first line it just kind of prints and then the second

line that’s make sort of echoing the command that I’m issuing it’s just going to assemble the main

dot asm into a main dot o and then it’s letting me know that if there are any warnings it will

It will refuse to compile.

And then I use the LD linker to link the main executable.

And then I actually run the executable.

So only below this line that I have highlighted right now

is gonna be the actual program.

So you can see all it really did was just,

you know, print the message and then exit.

Just, you know, a little note here.

I’ve probably said this in other videos,

but the return code zero is kind of a standard

to indicate success for programs,

which is very useful if you want programs to automate other programs.

If I change the system, let’s see what is it, exit success.

If I just change that variable to a 3 so that I will exit with a return code of 3 instead of 0,

then the operating system, or actually bash, since we’re in a terminal emulator,

should consider the program to have exited in error.

So you can see now it’s like, hey, hey, hey, the makefile system,

oh not bash, the makefile system is like that program exited with code 3,

three something went wrong and normally if you don’t add any extra stuff into your make file it’ll

just refuse to continue at that point well so i’m just going to change it back to a zero and make

sure that it still works and then we’ll get on to actually writing functions so i’m going to go clear

and make run so it’s a little bit faster for me to run this repeatedly you can see actually the

first time that i did that um the make file recompiled notice how it recompiled um and

and relinked because I changed that source code.

This is not a make file video, but I just want you to be aware.

One of the great reasons to use make or a build system in general

is because it makes it really easy to compile your code faster.

Notice how if I didn’t actually change, let’s see.

So I recompiled it because I just changed it again,

but now I haven’t changed it since I’m going to recompile or rerun.

Make just kind of like skips reassembling that file because it hasn’t changed.

it can make your compilations and assemblies much, much faster.

So anyway, functions. Functions in assembly are kind of simple and you’ll realize that

some of the stuff that we take for granted in higher level languages is being done for us

automatically by the compiler. But in assembly, we have labels. So for example, this start entry

some valid symbols like characters underscore numbers I don’t think you can start a label with

a number correct me if I’m wrong but I don’t think you can so we have like a label which is just like

this collection of characters and then we have a colon after it and so you can jump into a label

which I’ll talk about in a different video but you can jump into a label you can call a label as a

function and so a label isn’t actually a function by itself you have to treat it in a certain way

the abstract so notice how there’s no return statement at the bottom here let me write a

function real fast and maybe i will have it so that i have a function that just says hello for

me so i’ll make a label down here function that says hello and i’ll give it a label and i’ll say

maybe like say hello and i’ll do a little label there first thing that you should do when you are

trying to create a function is just put a return statement at the very end of it.

That way it will return to the caller because if you don’t then it’s just going to continue

to execute downward until it reaches no code and then the program will probably crash. In fact

maybe I should do that. I’m going to do say hello as a label with no return so it’s not really a

function now. It’s more of just like a label that you can jump to but there’s no code under it so

I’m not even sure this will assemble, but it’ll definitely crash if we can call into this.

So let me do, at the very start of our program, I’m going to type call say hello.

Or actually, you know what, maybe first I’ll jump to hello.

Jumping is going to be for a different video, but jumping just means go to that place.

It’s a go-to statement, essentially.

You’re not supposed to be able to return from a jump.

but it doesn’t really follow the same design pattern logic as a function.

So I’m going to immediately jump to the say hello logic and see what happens.

I think that it’ll crash.

Here we go.

SegFault, core dumped, oh no.

So, hey, it crashed.

So instead of jumping there, let’s do a call.

Now we’re treating it a little bit more like a function.

We still don’t have the return statement down here.

So it should still crash, I think.

Let’s try that again.

Yep, it crashed again.

Because you’re supposed to exit from the operator, or you’re supposed to exit from the program

properly to the operating system.

So now I’m going to do a return statement here.

There’s never an argument for the return statement.

You just simply return to the caller.

This uses the stack.

If you don’t know what the stack is, I’ll probably make another video about that in

the future.

But the stack, you know, it helps your program understand where it just called to and how

to get back from it.

to get back from it it also stores local variables and things but so if i have a call it should jump

down to the hello function and then return meaning it’ll just return to the caller immediately without

actually doing anything but the program should be able to continue without crashing notice how

there’s no crash here all it does is print out the welcome message and then no problem all right

printing stuff and I’m just going to cut it and stick it inside of the say hello

function that way when I call that function it should still print hello but

now notice how we have less code to deal with in this primary function you know

one of the first things that that programmers learn is that you know we’re

human beings we’re not computers it’s really hard for us to write complex

logic in a program without tools to help us and design patterns to help us to

help us stay on track to help us you know make sure that we’re not going to

we’re not going to be forgetting anything or screwing something up or you know to debug so

you know one awesome design pattern is to write functions because you you you realize in your

program you might be calling the same logic several times so you’re sort of like repeating a bunch of

code that already is bad it’s really hard to debug repeating code and it’s really hard to make updates

to it and it becomes unwieldy right so as soon as you realize you’re repeating the same logic

places you should think about taking it and putting that logic into a function

and then just simply calling that function many times it makes your coding

a lot easier and then once you put all the work into getting a function to

work you’re just you can just be done with it as soon as you’re sure that

this function actually works you can just put it to the side and just forget

about it you can stick it at the bottom of the source or just ignore it put it

into a different module whatever you want to do and then the other parts of

of the program that you’re still working on they become a lot more simple and so you know because

we’re human beings we need all the advantages we can get to write powerful code so i am now just

i’m not i don’t have to think anymore about all the system call things that’s happening

to print the hello message all i have to do is think about calling the say hello function

and of course this is simple but you can imagine using this for more complicated

concepts in the future so let’s see if this still works if i didn’t screw this up

It printed the same exact message.

And if I keep running it, you know, the make file doesn’t compile as much, but it still

runs the program.

If you don’t believe me that this is inside of a function now, let’s actually just call

that same function many times.

We’ll call say hello.

Let’s say we call it five times.

This should work.

I’m going to run the program again.

Notice how it printed that message five times.

Just to reemphasize my earlier point, wouldn’t it be a huge pain in the butt if you wrote

all the code for the system call and the message printing five duplicate times?

Wouldn’t that be hard to update? What if you had a hundred of those in there?

What if you had something that was really complicated and you called on it like

50 times,

wouldn’t that be so much better than maintaining 50 different versions of the

exact same idea of code and, and, you know,

making sure that if you needed to upgrade it or change it in some way,

you actually got it right for all 50 copies. So this is way better.

All right. So that’s the basic idea for a function.

for a function let’s see what else can i do um let’s let’s make a function that just prints

anything because that would be kind of a good little practice in the uh in the arguments that

we can use remember in c plus plus and other languages you have function signatures that

you can use so for example say hello we know for sure that say hello is not actually doing anything

it’s not receiving any arguments and it’s also not returning anything so if we know it’s not

returning anything. So if we know it’s not returning anything, we can say that it’s a

void function if we’re talking C++. We’ll do the name here. We’ll say say hello. And in the

argument list, we know that it doesn’t take any arguments. So it’s just say hello with nothing,

right? Okay. So let’s make another function that just prints something. And this function will

kind of be a little redundant because if you just sort of look at the system call here,

we have to load up the system call with the standard output and the system write code.

So that’s going to be repeated.

So we could move that into the print something function, but then, you know, giving an argument

of like, here’s the string I want to print.

And here’s the length of the string that I want to print that, that is something that

we can pass as arguments every time.

So we’ll be saving like a little bit of work, but it’s still, I think, I hope illustrates

the idea.

Maybe we will, oh, print something.

Okay.

So print something.

Maybe we’ll do the signature here.

Print something will not return any value.

So we’ll just give it a void return type.

And I’ll do a description up here.

Print a message given by a character pointer.

A pointer to a string.

character is also a pointer to a C string, not a regular string class, but a C string.

So I don’t know how to describe it. I think I’ll just say a pointer to a C string

and length and integer length maybe. So that means the print something function should take

two arguments. We want to be able to call that function and tell it, here’s a pointer to the

string I want you to print. And here’s how long the string is. So still talking about C++, I’m

character pointer p and maybe i’ll put like string just to remind myself when i look at this later

it’s a pointer to the string or like p char for the pointer to like the first character in the

string something like that and then length so the length is going to be a long because we’re using

64-bit integers in this video long and i’ll just say maybe size or length or something so now we

I want to use the same symbol that I’m describing in this little prototype here.

So I’m just going to copy paste it and use a colon.

And then because it’s a function, I immediately want to put a return statement at the very end.

Okay.

So then what I need to do is grab the incoming arguments.

Okay.

So, well, the first thing that every system call that prints a string should do,

at least if it’s going to print it to standard output,

to print it to standard output is it should start setting up the system call code registers or the

system call registers to say all right the system call wants rax to describe what the system call

is going to do we already have system write set up so that just means we’re telling syscall that

we want to print something where do we want to print it we want to print to the standard output

which if you look at earlier in the video that was just a file descriptor of one so that’s fine

up the system call and then the next two things can be kind of variable uh you know we can we

can grab that from incoming arguments so rsi wants a pointer to the string we’re not going to load

hello string but we’re going to load whatever character pointer we were given in the incoming

RDI is the first incoming integer argument.

We’re not going to talk about mixed arguments with floats.

If we just assume that we’re only going to use integer arguments or pointer arguments,

then the first one is going to be RDI.

So that means by the time print something gets called,

by the time we come into this code right here,

RDI should be loaded with the pointer to the character to the C string that we want to print.

Again, this follows something called the ABI, which you should absolutely respect,

which you should absolutely respect even if you’re the only one writing any of the code that you

interact with your code will be bad and considered not good if you don’t respect the abi on this type

of architecture so we definitely still need to load rsi with the string pointer but art whoops

but rdi is what’s going to have the string pointer so we actually already just ruined rdi when we

probably either load it up backwards or i think probably a better way to explain functions is

let’s just use another register so i’m going to use another register to sort of store our incoming

arguments i personally like to do this i admit that this will cost you cpu cycles to sort of

like move things around in registers but it’s still way faster than sticking something into

a global variable because then you’ll be hitting memory so first i’m going to say let’s move

to r12 and I want to store the incoming argument so I’m just going to write here save the

the p care you know c string character pointer or something like that so we’re going to save it

and then the next thing we need to do is save the size because as soon as we load up rsi we’re also

going to be destroying the second integer argument which should come to us in rsi

Okay, so I’m going to save that too, I guess, with R13.

So I’m going to move something into R13, RSI, and then save the size of the C string.

Okay, so we saved both of those.

Now, when we load RSI, we can just sort of say, RDI is saved.

And then when we load RSI…

Oh, that’ll be when we hit RDX.

Oh, that’ll be when we hit RDX. Okay, I got confused. So we stored R12 was the character

pointer. And then for the length of the string, we stored that as R13. Also for me personally,

I feel like it’s a pretty good idea to kind of make a comment at the very top, because this is

assembly. It’s really, really hard, right? Make a little comment at the top, just kind of reminding

yourselves what you use all of the registers for. I know sometimes you’ll use the same register for

sometimes you’ll use the same register for multiple purposes.

You could either write that down

or you could consider breaking up your function

into multiple functions.

That’s totally valid

and it probably will make your life a lot easier.

Anyway, so I’m gonna say register usage

and then I’m gonna say R12 pointer to string, C string.

And then I’m gonna say R13 is gonna be

size of the string. And that seems simple but remember assembly especially when you’re new

it’s really confusing and for me when I was first learning and even sometimes now I’ll be staring

at a big blob of assembly code and I’ll just be like what register was I using you know or I’ll

look at a register and I’ll be like what was that thing even for? So just make yourself a little

comment up here to help you understand and then you’ll thank yourself later when you get a little

a little bit too overloaded or maybe even if you come back to your code a month from

now probably having totally forgotten what you even wrote then you’ll just have a nice

little reminder here.

It’s good to document and this is one of the ways that I recommend.

Okay, so we’re saying that R12 and R13 are going to be used.

We’re loading them up here from the incoming arguments.

Now RDI and RSI are free to be destroyed if we want and of course we have to destroy them

because RDI and RSI were incoming arguments when this function first came in but now that

first came in but now that we’re going to be doing a system call we have to use

them for incoming arguments to the sys call so they’re just they’re just meant

to be constantly destroyed so we’re gonna do call code there and then the

standard output is gonna be the first argument and then the string that we did

which is an r12 is going to be the second argument and then rdx is going to

be the next argument which is r13 which came into us through the second argument

wait wait wait the string to write came into us through the first argument the

came into us through the second argument but if you just kind of look at what we’re doing to the

system call it’s actually the second and the third so I mean just forget about it okay so we set all

that up let me make sure I’m not forgetting something by scrolling up real fast yeah so now

we can do a system call one other thing that’s very very important about functions is you have

to respect the ABI and that doesn’t just include using the right registers for incoming arguments

out a call but you also have to keep in mind which registers are denoted as callee saved

if something is callee saved then that means you know if i’m inside of print something

i’m being called that means i’m the callee so that means if i’m going to use r12 and r13 which

are designated as callee saved maybe i’ll pull up that my favorite assembly book after this

but if i’m using registers which are designated as callee saved then i have to preserve those

then I have to preserve those registers, meaning those registers,

they should have their same values from when they first came in on the call

when I exit the function. So when I exit the function, those registers,

register values should appear to be untouched to the caller.

Remember these registers are not local variables.

They’re global to the entire system. There’s only one R12 on the whole CPU.

So every program that runs every function that gets called,

see the same exact R12 register. So if we’re not careful about preserving when we have to,

we could end up crashing other programs or our own program. So anyway, let’s do something that

I like to call the prologue and the epilogue. That’s another nod to my favorite assembly book,

which I’ll probably show at the end of this video. So prologue is just, hey, let’s preserve

the stuff that we need to preserve. We will preserve the R12 with a push and we will preserve

and we will preserve the R13 with another push.

We then have to restore them.

So right now when we do this push,

that just means that whatever value R12 and R13 had

is going to go to the stack.

So we’re going to hit memory.

That’s not great, but like we have to in this case.

We’re going to push it onto memory

in order to preserve the value.

And now we’re free to destroy the value if we want.

And then right before we return,

we’ll just pop those values.

So that means we’re going to go to memory.

We’re going to go to the stack.

to go to the stack we’re going to grab the values that we just pushed and put them back onto the

registers oops forgot to do 13 and 12 and I’ll call this the epilogue just meaning like we’re

done we’re cleaning up and of course look very carefully at the fact that the push and the pop

sequence are in reverse order notice how we push 12 first and we push our 13 second then at the end

Then at the end, we pop R13 first, so it’s backwards.

It’s like a little shell, you know, the R13s are on the inside

and the R12s are on the outside.

That logic would persist if we pushed,

or if we had to preserve more Kali saved registers,

if we were using more stuff.

The reason we do that is because the stack as a data structure

will return data to you backwards in the reverse order

that you returned it or that you sent it into the stack.

it into the stack so if i send a 12 and a 13 let’s just say the number 12 and the number 13

into the stack then if i start popping stuff out of the stack it’s first going to give me the most

recent item which is going to be the 13 so it’s going to give me backwards data and then it’ll

give me the art the 12 seconds so um the type of data structure a stack is is first in last out

last out no that’s a that’s a queue anyway so we’re preserving the registers we’re doing the

system call we’re probably okay to call this function now so let me see if i can do this

i’m going to comment out all of these things that the the say hello function does and i’m just going

to call on print something in order to call that function but i have to load up my arguments i have

pass arguments remember in the print something function it’s got a signature

it wants a character pointer and a size we can’t just call it without giving it

those things or it’s going to look at the registers anyway and just grab

whatever junk data happened to be in there so that would be bad so first we

have to load up the registers load up argument registers and call print

load up the argument registers and call print something.

So the first thing is going to be RDI, so we have to move something into RDI

and then the second register for the second integer argument is going to be RSI.

As far as I recall, if I’m wrong this is going to go horribly wrong.

I’ll double check the book after this.

And what do we want to do?

We want to basically, inside of say hello,

we could assume for now that say hello hardcodes the pointer and the length.

So we’ll just say it’s going to grab the string from global and it’s going to grab the string

length from the global variables.

So it’s going to load up those two arguments and then call on print something.

This still ends up being three lines.

That’s why I was saying before, we’re not going to save too much, but we did save, you

know, these two lines right here, you know, and the system call line.

So it’s like slightly faster to do.

You just load up two pointers and then you make a call.

in this video so I can’t really make the function better but in the future when

you learn how to loop and and learn about null terminated strings you could

basically just pass a pointer to just the string only and then call on a

function if the function was smart enough to scan through the string and

figure out how long it was based on where the null terminator was but that’s

gonna happen in another video anyway so if we call print something it should

Notice also that we’re having a function call another function, which is pretty cool.

So we have our entry point, it’s going to call on say hello, and then once we’re inside

of say hello, we’re just going to load up some arguments and then call on the print

something function.

The print something function then does most of the work for the printing, and I think

we’re ready to go.

Let’s see if this works.

All right, so we’re going to clear and then just run the program.

Oh, that was so fast.

That was so fast I don’t even feel like I’ve proved anything.

Let’s comment out the system call so that all we really do is just load up some registers

and then don’t do anything.

And then you should see here that the print something function no longer actually does

anything because it was too fast.

Now if I uncomment the system call, you know that the print something function is actually

doing something and it’s printing the message five times.

We can also make some more messages if we wanted to,

just as a way to make this video slightly more interesting.

I’ll say msg1 is going to be a string of bytes,

and I’m going to say this is message number one.

Boring, sorry.

And we’ll do a crlf there.

Actually you know what, let’s make a function that does a crlf.

Okay, let me just finish message one length,

and we’ll do it equals that special string that you can do in yasm am i doing this right yeah okay

so this is message number one so now we’ll call again with message we’ll call say hello just once

and then we’ll call on print something loading it up first move something with rdi and then move

message one is that what I had message underscore one and then RSI is going to

get message underscore one length so basically we’re just you know print the

first message it’s always a good idea to put comments on each line when you’re

learning so that you don’t forget what’s happening in addition to like a comment

for the whole block but I’m not going to do that here let’s just make sure that

make sure that this actually works so it should print two different messages now

one okay nice let’s enhance this a little bit more later i think i’m going to have us print like a i

don’t know a character or maybe we’ll do a return value from something so we can just show you how

to do the return values but i’m just going to enhance this a little bit more we’re going to say

let’s make another function we’ll call it crlf the crlf function i don’t want it to do all the

system call stuff because print something already does that for us i’m instead just going to make

message so now that means i’m going to go crlf and that’s just going to be a 13 and a 10. remember

you can define a c string with quotes but you can also separate quoted strings by commas and also

integers just to sort of tack it on so you know this variable right here it’s going to be a

sequence of characters representing the string that you see and then at the very end of the

string it’s going to have a crlf carriage return line feed so that the cursor goes to the next line

goes to the next line so I’m actually gonna take that off of message one

because it’s gonna be here just on CRLF and then I’ll say CRLF length is gonna

be two I could also do that special thing probably a little smarter CRLF

yeah I mean it’s it’s better to avoid hard coding things if you can avoid

hard coding the number two or any number just do it I guess I have to hard code

So, so CRLF and then length.

And so that means in my CRLF function, let’s see, let’s do CRLF, CRLF immediately return

because it’s going to be a function.

I’ll just say void CRLF with no arguments and prints a carriage return new line, also

known as CRLF.

and so that just kind of describes it and I don’t need to preserve RSI and RDI

because those are not callie saved registers so respecting the ABI kind of

helps you in this case I’m just gonna copy paste here and maybe I’ll copy

paste that comment real fast too so I don’t have to like type that whole thing

out and instead of doing hello string we’ll just say CRLF and then for here

And now when I call CRLF, it should just make the cursor go down a little bit.

So let’s test that out.

I took the CRLF off of message one.

So if we actually run this right now on modified, it should have the cursor.

Now, what did I just do wrong?

On number 28 and 29, instructions expected after label.

I guess I forgot to complete something.

Oh, I forgot to put, it’s a byte sequence right there.

there and I forgot to put that this is basically a defined sequence you know

that EQU okay my bad okay so now it prints notice how the message line it no

longer does a new line and no longer jumps to the next line CRLF so that

means when the program exits the terminal prompt is on the same line as

the program just printed that’s ugly and awful so let’s call

We could either say, let’s call CRLF after printing the first message,

or we could just assume that print something is like print a line.

I don’t know how you feel,

but I think if we always called CRLF after every time we printed a message,

I would probably be a little irritated.

So maybe let’s change this to print line and then make it call CRLF.

You can just keep adding this like 1013 at the end of every string, but I think I want

to try to make this as compact as possible.

So let’s add the CRLF for now and then we’ll change print something later.

So we print the message.

Now the prompt should be, you know, a line further down.

So great works.

I am now going to take the CRLF off and I’m going to put it inside of print something

so that right after we do the system call to print the string in question, we’ll print

we’ll print a new line this should now accomplish the same thing that we just saw

oh no what did i do i think i did uh i think i have a infinite loop of recursive calls in there

somewhere i had a stack overflow probably so let’s see what did i just do say hello is call

print something and then crlf is call print something oh whoops print something calls crlf

at the end so i should do one or the other and not have them call both so maybe just because crlf is

special maybe i’ll just use a direct system call inside of crlf i thought i was so clever

but i was wrong so we’re going to repeat a little code for the crlf and we’re going to load it up

with um crlf dang how embarrassing i like to say this is the most public of my many humiliations

of my many humiliations. But anyway, so now we don’t need to rely on print something. So this

won’t be an infinite loop and it should work if print something calls on crlf now. Do it again.

Okay, it works. So now let’s modify print something so that it is just print

a line. Print a line. And then that, in my eyes, you don’t have to do it this way. It sort of

to do it this way it sort of justifies printing a crlf at the end every single time so this is

just my personal thinking and then maybe i’ll add a comment after prints a crlf

so now when we call print line we no longer have to call crlf

and then when we print that message should be pretty good oh we got to update that to print line

Then for say hello, let’s just double check.

We can get rid of this system call code here.

Probably a good idea at this point.

And then we just say print hello string.

And then from the hello string, we can get rid of this CRLF at the end of it.

So I’m just going to get rid of that.

Actually, let’s do it first without getting rid of it.

Just so you see, oh, what did I do wrong?

Lion 61, forgot to update the symbol name.

Oh, there we go.

call print line because we don’t have print something anymore and try it again notice how

the first message hello my name is it has two line feeds after it because it is calling print line

which will do a crlf but then also in the string itself there’s a crlf so again the point is i’m

to my advantage.

Okay, so we got that working now.

I’m just going to print like five different kinds of messages.

How about three?

So we don’t have to sit here and watch me typing for too long.

So I’m going to say message two and then I’m going to do message three.

Message three.

This is message three unless I got that wrong.

One, two, three, one, two, three, one, two, three.

Now we can just call a print string on three different messages.

And I’ll just change this to say, you know, print the second message, print the third

message.

And then I’m going to change that to message two and then message three.

All right.

So then I’m going to do that again.

And then all three messages get printed.

Nice.

So now one more thing.

I just want to show you how to return an integer to the caller in a basic YASM x86 assembly function.

Again, this will not cover floats.

This does not show you how to return floats.

With floats, you have to use a different register called xmm0.

That’s going to be a different video.

But for now, I’m going to say all integer or pointer return values, like longs is going to be what we’re using,

that is the register that is designated for return values.

So what about this?

Instead of just returning the exit success code

that I’ve defined up above,

we’ll return whatever some function call gives us.

Maybe I’ll make another function down here

and then I’ll say a function

that just returns a simple long value.

And we’ll call this function gimme long.

We’ll call this function gimme long.

It’ll take no arguments because we’re just keeping this simple for now.

And instead of having a void return type, it’ll have a long return type because we expect

RAX to be loaded up.

So then I’m going to say gimme long and immediately do a return because it is a function.

And then I’m just going to load up a value from somewhere.

Obviously, it’s better if you’re doing something complicated to stick with registers as much

or defines and hit memory only if you need to.

And try not to hard code immediate into your code

if you can possibly avoid it.

It’s probably a lot better to define a value up at the top

in the data area than to just hard code it here.

But I’m gonna just hard code something here.

No, I always second guess myself.

I’m gonna say exit gimme.

I’m gonna define something up here.

So it’s easy to find what value I’m gonna return

for the gimme.

I’m just going to say 88, 89, 90, I don’t even know.

About 33, I don’t even know.

So we’re defining exitGimme as a symbol

to just be a replacement of just the number 33.

So down here, I’m going to say,

let’s have gimme long simply return exitGimme into RAX.

Nice, okay.

And so that means it’s the official return value

once you call gimme long.

call gimme long so that means up here get our whoops get out it’s coming from inside the house

get our return value from gimme long and again imagine gimme long might be a big complicated

function that decides what a return value is going to be or does something so i’ll start with saying

call gimme long because gimme long does not take any arguments i don’t have to load up any registers

load up any registers nor do i have to worry about preserving them or setting them up or doing

anything i just call but then let’s see inside of this function we’ll use rax in order to you know

load up the system call to let it know what function or sorry what function we want from

the system call so we got to give rax system exit so that means down here we can’t actually use rax

those other registers again I’m going to use I’m going to use the r12 register

I’m going to do like a little comment here that says register usage and I’ll say r12

maybe I’ll do a tab r12 is going to be old return value

or the syscall to exit you know whatever and that’s all we’re going to do so in the prologue

I’m going to push R12.

You should probably even preserve registers in the start function

because something might, or in your entry point,

because something that called you might be counting on those registers.

This is going to be probably especially true if you’re using GCC

to have a main entry point within a hybrid program.

So I’m just going to go prolog, push R12,

and then pop R12 at the very end.

Pop R12.

That’s not going to work because by the time we get there,

because by the time we get there,

it’s gonna exit the program.

I’ll do this here.

I’ll just try to be a good citizen.

I’m not actually sure if we need this

for a pure assembly function,

but it’s just a really good habit to get into.

And what is it gonna cost you?

Just a touch memory,

just one time right before the program exits.

It’s not gonna be a giant for loop or anything.

Okay, so epilog,

probably I might be showing you bad practice

by preserving things in the underscore start function.

But again, you will definitely wanna do this

Again, you will definitely want to do this for the main when you return from main.

So we do prolog R12, epilog R12.

I made a comment there.

And then we’re going to store the return value in R12.

So that means here we’re going to move something into R12.

It’s getting precarious because we restored it right before the system call,

but I think it’ll be okay.

system call but i think it’ll be okay we’re going to grab rax because rax is supposed to be the

return value register so when we called gimme long it loaded up rax with our return value

we then send rax into r12 so we can use r12 uh even though our rax has been you know destroyed

we’ll still have the return value that we wanted to use so i’m just going to load r12 up into the

first argument of the sys exit call let’s see if i if i got this to work or if i totally ruin this

work or if i totally ruin this okay all right so let’s see here what was

why is it not erroring gimme 33 exit gimme should i did i load the wrong value exit gimme what is

it doing exit gimme it’s moving rex into exit gimme so you call gimme long and then you move

r a x into r 12 and r 12 i wonder if that destroyed it

hmm let me get rid of this push pop pair because it’s supposed to be giving me

an ever message that the function or that the program did not exit maybe this is proof that

you don’t need to preserve inside of the underscore start function let’s see here

yeah okay i guess that proves it hey don’t take my word for it i’m wrong all the time

For yourself, be a scientist, be a computer scientist.

Try it out.

Try to do something different.

Okay, so I guess this is proof we don’t really need a prolog and epilog in just a pure assembly,

at least the entry point for start.

But if you were calling any other functions, then they definitely need to preserve.

And again, if you’re using GCC, so you can have a main for your entry point, then you

still have to preserve.

you know print the message and then print our other three messages and then the return code

is going to be 33 that was the gimme code that we did so now we know how to return a value from a

function and um let me set this back to just zero so the make system thinks that we succeeded

run it again succeeded all right i guess this concludes the video i hope you had a little bit

and I hope you learn a little bit of stuff and I’ll see you in the next video.

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

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow

this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now.

world to me and it’ll help make more videos and grow this community so we’ll

be able to do more videos longer videos better videos or just I’ll be able to

keep making videos in general so please do do me a kindness and and subscribe

you know sometimes I’m sleeping in the middle of the night and I just wake up

because I know somebody subscribed or followed it just wakes me up and I get

filled with joy that’s exactly what happens every single time so you could

do it as a nice favor to me or you could you control me if you want to just wake

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

clarifications or errata or just future videos that you want to see please leave a comment or

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

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

it would really it really mean the world to me i would really appreciate it so

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

which is coming for us all.

Thank you.

The post Mastering x86-64 YASM Assembly: Functions Made Simple appeared first on NeuralLantern.com.