Quick guide to passing mixed int + float arguments in x86-64 assembly (System V ABI). See why rdi can still be the first integer after several doubles, why xmm registers count separately, and how return values switch between rax and xmm0. Perfect for YASM/NASM programmers interfacing with C/C++.

Intro to Mixed Arguments 00:00
Simple Integer-Only Functions 00:46
Adding Arguments and Return Values 01:01
Integer Arguments in RDI and RSI 01:30
Pointers Treated as Integers 02:06
Introducing Floating-Point Returns 02:31
Returning Double in XMM0 03:06
First Float Argument in XMM0 03:36
Float Registers Count Separately 04:03
Integer Register Order Explained 04:16
Separate Counting for Integers and Floats 05:21
RSI as First Integer After Float 05:38
Reference to Ed Jorgensen’s Book 07:00
Callee-Saved Registers Overview 07:56
Complex Mixed Argument Examples 09:48
Inserting Integer Among Floats 10:57
Skipping Float Registers on Integer 11:18
Calling C from Assembly Notes 11:56
Name Mangling Reminder 12:21
Closing Remarks and Thanks 12:30
Call to Subscribe and Support 13:04
Website and QR Code Mention 13:38
Final Thanks and Outro Music 14:19

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey everybody! In this video I’m going to talk to you a little bit about using functions with

mixed arguments in a YASM x86-64 assembly language program. Although this

video will probably still be useful to you if you’re using NASM or MASM because the

mixed arguments and their order and how they work is governed by the ABI which is a system

so what the heck am i talking about okay so the first thing that i want to show you is uh

imagine we have a function here let’s say void f this function doesn’t take any arguments and it

doesn’t return anything congratulations you’re done that was the easiest thing that you’ve ever

done in your entire life but as soon as you start adding arguments to it you have to uh

start understanding how to uh how to call registers and stuff so imagine we have like a

a long a and a long b so we give it two arguments and maybe we want it to return a long

this is kind of like level one of writing functions in assembly right we just have

a bunch of integers and we realize okay um this long the return value is going to come to the

Maybe I’ll do a comment up here, we’ll do rax, we’ll say the long is actually coming

back to the user in rax and the long is coming into the function with rdi, the long a and

the long b is coming into the function with rsi.

So if you understand this then you can write a function in assembly where basically you

two incoming integer arguments and then you return to the caller a long value using rax

keep in mind also that if this second argument was a pointer long pointer then it would be the

same thing rsi because pointers are integers they’re 64-bit unsigned integers even if the

pointer was not to a long even if the pointer was to a double or a character or whatever it would

pointers are integers. It starts getting a little bit more complicated when you want to mix between

floats and numeric arguments. So what I’ve been saying so far, it’s all just integers.

Even if we’re mixing pointers with regular longs, it’s just, you know, they’re all longs basically,

right? So, but as soon as we start introducing floats, then things get a little bit more

complicated. So for starters, what if we did a function that was, that returned a double?

that returned a double. So let’s say we have a function G and it returns a double. Maybe it

still takes in a long and a double pointer. If it returns a double, let’s see, is this still

lining up? I don’t think it’s lining up anymore. There we go. If it’s returning a double, then

that means we have to return to the caller with the XMM0 register. So XMM0 is always designated as

the well the first float argument but also the float return value so keep in

mind if I’m returning a double to the caller I’m not going to use our a X at

all I’m just going to use XMM zero load it up with the return value and then

return to the caller and that’s it if I wanted to do another function let’s say

hmm how about H and then we’ll say I don’t know maybe the first argument is a

argument is a float we call it a double a that means rdi is not going to be the argument that

or the register that we look at to see our incoming double it has to be a float register

xmm0 is the float register that we look at for the first argument the float registers are really

easy you just kind of go in order like xmm0 is the first argument xmm1 is the next argument xmm2

the general purpose uh integer registers they’re a little more complicated you have to remember

their their labels uh you know like the letters have an ordering to it uh suppose for the sake

of argument that we’re going to return a double from this also uh in that case let’s see did i

just mess the formatting up again i think that’s okay um again we’re going to return xmm0

notice how we’re returning xmm0 oh that’s why i spaced it forward notice how we are

forward notice how we are returning xmm0 and we’re also taking xmm0 these float registers tend to be

reused all over the place none of them are designated as callee saved within the abi

so you always have to stash their values somewhere if you’re ever going to make a function call or

anything or a system call the other thing to keep in mind is notice how rsi i still have rsi there

for the second incoming argument you would imagine that rsi is supposed to be the second argument

supposed to be the second argument even if it uh you know comes after a double but that’s not

actually true because the the order i guess like the the ordering of the uh of the registers they

only count against their own class like the float registers the float arguments they only count

against the position of the float and the uh of the float registers and and and the general purpose

they only count against themselves.

What I’m trying to say is that RSI is the second integer argument,

but if you look at the signature, we only have one integer argument, right?

So RSI is not the second integer argument.

It’s actually the first integer argument.

So I’m going to put an RDI there.

You probably can infer that the second float argument should be XMM1 at this point, I hope.

and that’s true if we just say that there’s going to be another double

that this function takes then it’s going to be xmm1

not xmm2 because if you’re just counting the arguments

and you’re sort of grouping the integers with the floats together

you might think well first argument is xmm0 second argument would have been xmm1

third argument would have been xmm2 therefore if I see

a float coming into the third argument position it’ll be xmm2

No, the integers don’t count against the floats and the floats don’t count against the integers.

That’s why RDI is the first argument for integers, even though it’s in the second position,

it’s still the first integer that we see.

And XMM1 is the second float argument that we see.

That’s why it’s XMM1 instead of XMM2, because we’re looking at it in the third position.

So you’re not really looking at, whoops, you’re not looking at overall position.

at position only counting that type of register let me pull open my favorite book to get a little

bit more clarity on this um this book is written by a wonderful professor dr ed jorgensen phd

this book i did not write it ed jorgensen wrote this book it’s called x86 64 assembly language

programming with ubuntu this book can turn you into an expert with yasm assembly so uh

I recommend everybody grab a copy. It’s also free and it’s got a copy left license.

You can see like the license here. But anyway, I wanted to open up this book real fast

just to show you the registers. Okay. I’m going to search for Kali saved so I don’t have to fumble

around the book too long. Kali saved and that brings us to section 12.8.2 register usage.

let’s see callee saved you’ll see rbx is callee saved rbp is callee saved probably shouldn’t

mess with that one too much r12 13 14 15 all callee saved there’s a couple temporary registers

but if you look carefully rdi is designated as the first argument but it should say really

the first integer argument so rdi is the first integer argument that we see that’s why

argument that we see that’s why in all of these examples the first integer argument that we

actually see is rdi so like for function f long a that was the first integer argument

and then in the function g it’s also the first integer argument and then in function h rdi is

the double pointer b because that is the first integer argument that we actually see

so keep that in mind you would just repeat that pattern you know the second integer argument you

second integer argument you see that’s RSI. That’s why RSI is the pointer here because

pointers are integers and the pointer here and we don’t have anything else but if I guess if we

added another you know let’s say a long D then it would be RSI right there. Hopefully that makes

sense and you can you can carry this logic forward for the first argument the second argument the

and then R8 for the fifth argument R9 for the sixth argument and then you can

look for further arguments on the stack if you need more than that but basically

that’s how you count them up and then the float registers are just a lot

easier they always start at zero and they go all the way up to 15 and so I

don’t know maybe I should just copy paste well maybe I’ll start it from

scratch we’ll say dub no let’s let’s mix it up a little bit more we’ll say long

And the long is going to be returned with the RAX.

And I guess I have to space this forward a little bit.

And then if we have a bunch of floats, say double A.

Can I maybe just copy paste this a little bit so I don’t have to do so much typing?

Okay, so we’ll do double A, double B, double C, double D, double E.

and then this is going to be xmm zero why did i put the extra comment there i don’t know

and then we’re going to have xmm one and then we’re going to have xmm two xmm three and so forth

and just to make sure you’re paying attention ask yourself this real fast if i were to insert

z what register would we use for that would it be the one two three four five the fifth argument

would it be uh would it be r8 or would it be something else hopefully you understand now

let’s say we do a character pointer that it would be rdi because that’s the first integer argument

that we actually see all right and then you know to return we would return in rax and then the

return in RAX and then the floats just keep counting notice how it skipped from XMM2 or it

went from XMM2 to XMM3 even though we crossed over an integer argument in between because the

float arguments don’t count against the integers and the ints don’t count against the floats

let’s see I think

well if you want you can look at section 18.2 which just sort of talks about the floating

which just sort of talks about the floating point registers we have 0 through 15 but I don’t think

we really need to do that here I think we pretty much have everything we need to know to to call

on functions with mixed arguments and to have a function within assembly that supports mixed

arguments so again if your C or C++ modules are expecting some kind of signature like this now you

know how to calculate what registers they’re actually going to populate by the time execution

execution jumps into your assembly function.

And if you want to call a C or a C++ function from assembly,

now you know which registers to populate so that the the other function that

you’re calling can receive the right data from you.

Don’t forget about name mangling, which I talked about in another video.

Okay, I think that’s all I really have to say.

This video was pretty short.

Thank you so much for watching.

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

I’ll see you in the next video.

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

videos or just i’ll be able to keep making videos in general so please do do me a kindness and uh

and subscribe you know sometimes i’m sleeping in the middle of the night and i just wake up because

i know somebody subscribed or followed it just wakes me up and i get filled with joy that’s

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

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

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

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

which I think is also named somewhere at the bottom of this video. And it’ll take you to my

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

tutorials and things that I offer and all that good stuff. And if you have a suggestion for

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

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

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like it would

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

for watching this video and um enjoy the cool music as as i fade into the darkness which is

for us all.

Thank you.

The post Mixed Function Arguments in x86-64 Assembly – Integers & Floats Explained appeared first on NeuralLantern.com.

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

We cover:

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

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

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

Enjoy learning assembly!

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

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there. In this video,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Anyway, so conditional control instructions in my last video

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

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

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

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

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

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

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

conditional branching instruction or a conditional jump instruction there’s

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

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

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

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

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

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

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

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

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

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

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

Let me show you a few of those.

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

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

We do CMP followed by two operands.

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

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

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

register called r flags which we hardly ever use or look at in in the most common assembly

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So keep this in mind.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I guess we’re done anyway.

So keep that in mind.

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

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

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

Okay, so let’s see.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So now here’s our entry point. Again,

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

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

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

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

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

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

Let me get rid of that load.

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

I think I put it in there on an early example

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

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

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

But if you’re writing a pure assembly module,

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

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

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

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

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

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

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

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

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

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

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

The ABI says that R12 is a Kali saved register.

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

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

book calls the prologue.

I do that now though too.

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

So we have prologue and epilogue.

We can have a push-pop pair.

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

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

out a message.

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

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

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

So let me say clear and make run.

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

elsewhere and we get that welcome message that says begin

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

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

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

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

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

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

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

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

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

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

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

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

And we’re going to store it in R12.

So that’s why I had to preserve R12,

because I’m actually going to start,

you know, messing with the value of R12 now.

Okay, so we ask for a number,

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

If we run the program again,

it’s just asking for a number,

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

and then the program ends, nothing actually happens.

We’re building, we’re building.

So now let’s ask ourselves,

is the number greater than zero?

So let me copy paste some code here.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

And otherwise, if R12 is, sorry,

I said less than or equal to, yeah,

if R12 is greater than zero,

then we jump to this other thing,

which is gonna be the fall through.

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

I’ll say fall for fall through.

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

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

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

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

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

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

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

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

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

usually the compare instruction and the conditional jump or branching instructions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

We’re just going to simply say goodbye.

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

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

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

or equal to zero.

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

the control path is just going to fall through.

So that means we will actually execute these.

And then when they’re done,

execution will continue to fall through to the rest.

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

their number was greater than zero or not,

based on whether their number actually was greater than zero.

Okay, hopefully I explained that somewhat clearly.

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

Hopefully I didn’t forget anything.

This is kind of a partial program at this point.

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

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

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

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

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

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

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

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

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

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

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

Okay.

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

So okay.

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

Okay.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

10.

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

the rest of the instructions.

We’re going to exit the program.

We’re going to say goodbye.

We’re going to do whatever.

Okay.

So say there never was less than 10.

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

Let’s see if this works.

Make run.

So we’ll enter five.

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

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

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

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

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

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

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

you know, whatever you want it to do.

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

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

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

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

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

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

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

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

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

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

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

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

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

and eventually fall through to the return statement.

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

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

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

greater than zero and less than 10

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So, you know JMP the regular jump instruction

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

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

It doesn’t really matter.

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

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

then you can overcome that limitation.

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

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

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

We solved the jump out of range error.

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

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

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

and all that stuff.

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

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

i’ll see you in the next video

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

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

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

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

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

So please do me a kindness and subscribe.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Thank you.

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

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 master command line arguments in Yasm assembly? This video breaks down how to access and process args in x86-64 hybrid programs linked with GCC. From understanding argv and argc to looping through arguments, we cover it all with practical examples. Perfect for programmers diving into assembly or looking to level up their low-level coding skills. Check out my other videos for more on Yasm and pure assembly! Subscribe for more coding tutorials. #AssemblyProgramming #YasmAssembly #GCC #x86_64

Introduction 00:00:00
Command Line Arguments Overview 00:00:03
Yasm Assembly and GCC Linking 00:00:07
Hybrid Program Explanation 00:01:27
Makefile Overview 00:02:16
Assembly Program Structure 00:03:16
Main Entry Point and Registers 00:03:51
Accessing Command Line Arguments 00:04:26
Argument Count and Pointers 00:05:03
Loop Initialization for Arguments 00:08:57
Loop Logic and Dereferencing 00:10:52
Printing Arguments 00:13:02
Incrementing Pointers in Loop 00:14:08
Running the Program 00:15:35
Practical Application of Arguments 00:17:24
Conclusion and Next Steps 00:17:51
Call to Subscribe and Outro 00:18:22

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’m going to talk to you about how to accept incoming command line arguments to

an x86-64 Yasm assembly program that is probably linking to

GCC and is thus probably a hybrid program under the hood.

If you don’t know how to program in Yasm assembly yet,

check out my other videos. If you don’t understand command line arguments yet,

yet check my other videos I’m going to assume a lot of knowledge here I’m

really just going to show you how to pull the arguments inside of assembly

using using the GCC setup that they’ve given you so just a quick just a very

quick recap this is not a command line arguments video if we have the program

echo and we give it like one argument of just the word hello then it’s it’s

going to receive one command line argument in addition to its program

echo as argument zero and hello as argument index one.

And it’s just going to be able to look at them and say,

oh, the user wants me to print this hello string.

So it just prints it.

And so that’s kind of how you can tell a program what to do,

either when you’re running them directly

or having one program automate another program.

Anyway, so in our Yasm assembly programs,

how do we actually get that out?

Well, for starters, we are dynamically linking.

Sorry, not dynamically linking.

We are linking a hybrid program.

So I just want to make sure that you understand this is the right video for you.

If you’re trying to do this in pure assembly, or if you need to know that for some reason,

then you’ll probably want to watch the next video that I publish.

But for now, this is a hybrid program.

Hybrid programs, for those of you who don’t know, it just means you have modules that

are written in different source code and they’re compiled differently, different source code

languages.

So you might have a source code file that’s written in C++ another one that’s written in C another one that’s written in assembly

And you compile them all down to their own object files and then you link them together into an executable

If GCC is part of the linking process

Then it’s going to end up giving you a main function as your entry point and it’s going to make things a little bit easier

Here’s my make file. I’m just going to skim through it real fast. This is not a make file video

So if you don’t understand it go look at my other videos

But basically I’m just going to assemble with Yasm and I’m going to use G++ as the linker

and I’m going to gobble up all of the object files. Here’s like a little menu.

I have a target for running and building only. And here’s the main thing that I’m doing. This

is not really a hybrid program. This is just kind of a pure assembly program that is linked with GCC,

but you can imagine you could add other source files in C and C++ and still totally get away

GCC. But anyway, I’m just compiling one source code of assembly and,

and compiling it down to an object file right here.

And then when it comes time to linking, uh, you can kind of tell here, uh,

especially if you’re familiar with make files that I’m just gobbling up all the

object files and linking them together into the executable.

So that’s as far as I’ll go there again,

I’ve got another video that totally explains a lot more in my assembly program.

video just for pure assembly so if you don’t understand assembly see my other videos but for

now we’re just going to say i’ve got a data section it’s got a couple of null terminated strings we’ve

got a hello message a begin message a goodbye message carriage return line feed string i’ve

got the system call codes for you know printing to standard output and to exit the program and then

i’ve got the standard output file handle and then my exit code zero for success again this is all

other videos. So because I’m linking with GCC, my text section here, the actual place where the

instructions are, not the data, is going to have a main entry point. So of course, if you had a

hybrid program, you could have main somewhere else in a different module and then just call on a

function that was inside of assembly. You could totally do that. But for now, I’m just going to

say this is the only source code file. So I mark main as global and I put main right here. And then

I preserve all of the Kali saved registers that I’m supposed to by pushing them at the beginning and popping them in reverse order at the end.

And then I return a return value.

Standard assembly stuff covered in other videos.

But here’s the key for getting command line arguments in assembly.

If you recall, the ABI specifies that in x86-64 programs, the first argument is always supposed to come into a function as RDI in the RDI register.

register or rather I should say the first integer argument I haven’t talked

about to float arguments in any of my videos yet in the future you should

probably search for other videos that that explain how to do float arguments

but for now all of the arguments I’m talking about in this video are just

integer arguments and pointer arguments which is kind of the same thing a

pointer is an integer it’s a 64-bit integer but we’ll just use it as a

using it as an integer so anyway first argument comes in on RDI second argument

comes in on RSI and you can imagine that basically this is the thing you’re

probably used to seeing in your C++ programs if we do this int main and then

integer arg C and then a character pointer arg V and then an array those are

those two registers right there I probably want to change this into long

because you know rdi is in 64-bit form but an integer is an unsigned 32-bit int.

I don’t like that so I’m just going to put long. I probably should put unsigned but I don’t really

care. Anyway so we’re just going to grab those two things so obviously rdi is probably pretty

easy for you to guess how to use it’s just the number of arguments. In this program we’re going

to use it to control a loop counter that’s going to loop through all incoming arguments.

which is going to be the name of the program in this case it’ll be I think

just main is what I called it which is confusing against the entry point I

admit it but imagine that my main program that sits in the file system is

actually called program or hello or whatever so that’s the number of

arguments in RDI and then RSI notice how it’s a character pointer to an array of

characters that means it’s actually a pointer to a pointer and the reason for

every argument on the command line like for instance if i went back here and i said echo

hello let’s just do without quotes hello you i’ve given it two arguments and so when the program

launches it’s going to receive three total it’s going to receive its own program name at index zero

echo it’s going to receive at index one the first argument hello and it’s going to receive at index

two the second argument as you it prints them both so how does echo know how many arguments i have

strings. Remember argc is the number of arguments so that’s kind of easy but how does it dereference

all of the strings if there could be any number of strings? Well that’s this right here.

This whole symbol argv is a pointer and it points to an array of pointers, of character

pointers. That’s why it’s written like this like an array. So it’s a pointer that points

points to an array.

So like if you go to that location in memory,

then what you will see there for the first eight bytes

is just the address of some other memory location where a string has been stored.

Then if you advance that pointer another eight bytes for it,

you know, in memory, because all pointers are eight bytes or 64 bits,

then again, you’ll see that that value of that next eight bytes

is actually a memory location that points to another string somewhere else.

So these strings could be all over the place,

But the pointers to those strings are contiguous in memory starting with what you were given in RSI.

So it’s a character pointer pointer or an array of character pointers, however you want to imagine that.

Anyway, so we’ll grab those and then I’ll just show you how to use them down further in the code.

For starters, I’m calling on an intro function which just basically prints some stuff.

I have a custom function that I wrote called print null terminated string.

That’s not the point of this video.

I have that explained in other videos a little bit.

So it’s up to you if you want to even care.

Right now I just want to be able to print something.

And then let’s see.

So after we print our welcome message in the intro, then we print another message basically

saying okay now we’re about to start printing all the arguments.

Okay cool.

Nothing complicated at this point.

Then I have another label here with my preferred style of adding a suffix after the function

after the function that I’m currently inside of.

And I’m going to say, all right, this is where I initialize my loop.

This is not a looping video, so I’m going to skim through it kind of.

But I’m basically going to say, let’s start the loop as basically saying

the index of the argument that we’re currently looking at is zero

because we’ll start with zero.

So that means we’ll print like if we were going to, if our program was named Echo,

we would also print Echo itself and not just all the incoming arguments

that the user might have typed.

index zero and then we’re going to use r15 as the current character pointer so r15 its current

character pointer is going to be coming from r13 which was the argv argument so that means

r15 is now going to hold a pointer uh let’s see it’s going to hold

when you have an array and the array is contiguous in memory then the pointer itself that points to

the array is also a pointer to the first item that’s just kind of the way it works like if we

have 10 items and it’s an array then your pointer to that array is also a pointer to the first item

in the array if that makes sense so if r13 was a pointer to an array it’s also a pointer to the

go off to a null terminated string i know that sounds weird you got to get used to double dereferencing

here so all we really need to do to access uh the first pointer to the actual string is take the

array pointer that we have and dereference it one time so remember we’re receiving an argv

a pointer to a pointer or like a you know a double pointer if we dereference it once then we should

terminated string. Anyway, so that’s the initialization part. I’m going to start looking

at the first string here and I’m going to say we’re at index zero. And then here’s the top of

my loop. You can imagine this is a while loop. This is not a while video, but you know, there it is.

And we’re just going to ask first, are we actually done? Do we need to break the loop? I like to do

that at the top of my while loop. And how we’ll do that is we’ll say, all right, R14 is the index

the number of arguments so notice how like right here we grabbed RDI right

into R12 right away so basically I’m saying if the index we’re currently

looking at is greater than or equal to the number of arguments then we’re

actually already done remember if we’re using zero based indexing and you

suppose that you have three items in your array their indexes would be zero

So that means if the size of your array is three, like the count, like the RFC, that

means the last valid index is two.

It’s one less than the size.

You know, it’s one less than the count.

So I’m saying at this point that if we ever reach an index number that is equal to the

size, then we’ve already finished.

We do not need to look at the current item.

So I’m comparing those two registers.

You know, where are we looking at versus what is the count?

You know, what is the index we’re looking at versus the count?

If the index we’re looking at is greater than or equal to the count, then that means we’re done.

I’m going to jump out of the loop to a label called main loop done.

So then, you know, that’s down here.

Basically, we just say goodbye and then we jump to our exit function.

And all that does is it just returns from main with some kind of a success code.

You know, so just you can imagine in C++, it’s just return zero.

So, you know, breaking the loop doesn’t really do anything except end the program and say goodbye.

However, if we did not jump, then the, let’s see if we did not jump, let’s, let’s see if

we did jump, we compared it, we realized that we’re done.

Then it’s going to jump down to the, to the done.

But if we’re not done, execution is going to fall through to the next statement.

So that means we’re going to end up doing something with the current item inside of

our loop.

So what are we going to do?

We’re going to dereference R15.

was your pointer to a pointer it was your double pointer there if we dereference it once then

instead of being a pointer to an array of pointers it’s going to be a pointer to one string one one

character that starts one string so dereferencing it once means you know i put brackets around the

double pointer it’s now dereferenced once that means rdi is going to receive a pointer to one

into my function my function takes two arguments it wants a pointer to a string and it wants

the file descriptor to print to again other videos explain you know printing to standard

output but i’m just going to print the string so this part right here should actually print

the argument and then after we’re done with that uh well maybe i should change this

so that it’s a little bit more clear i’m going to maybe push this down and say

these lines up here actually do something they do the printing by

dereferencing and then here we just sort of increment along the array of pointers

and jump back to the top of the loop so what are we doing here with r14

remember r14 was the index that we’re currently looking at so we we start

looking at index 0 line 83 is going to say let’s next look at index 1 and then

this part right here add 8 to r15 that just basically means remember r15 was

remember r15 was the double pointer the double pointer like i said before it’s looking at an

array of pointers so it’s actually a pointer to a pointer if i increase the memory location that

r15 holds then it’s now looking at the next pointer it’s moving through the array r15 at

that point would no longer be a valid pointer to the original array it’s sort of like a running

pointer it’s kind of like scanning all of the pointers but a pointer is eight bytes so if we’re

a pointer is eight bytes so if we’re just looking at the first pointer and we increase the memory

location that we’re looking at by eight bytes now we’re looking at the second pointer so then on the

next iteration of the loop if we dereference then we’re going to end up dereferencing to the second

string then i just print a little new line here honestly probably should have put that up top

sloppy code i was doing this quickly and then we jump to the top of the loop so then we just

going up to the top of the loop and printing arguments and advancing to the

next pointer. And we just keep going at it.

Let me see if this works. Hopefully I didn’t mess this up while I was screwing

around. All right. So I’m going to do this make run. Okay.

So under the hood inside of my make file,

maybe let’s open the make file real fast just so you can see.

I’m just going to nano it real fast here under the hood.

So when I call the program to run, notice how I’m giving it arguments.

You can see right here on this line, or actually let me get the line numbers up.

You can see on line 48, I am calling my executable, which is named main.

In the make file, I’m using a variable, so don’t worry about that.

But I’m giving it four arguments.

And I’m just saying first arg, second arg, third arg, fourth arg.

So that’s why you see that printed in the previous screen.

screen it’s just going through all the arguments that I gave it it’s saying

first arg second arg third arg fourth arg notice how it knows when to stop

because of the argc that came in on RDI now that the program is built you know

I’ve got my main executable which I named main which I said before was kind

of confusing now that I’ve got it I can just execute it again and give it like

one argument of like hello notice how it prints hello on a line by itself you do

do it again dudes and notice how every argument I give it it just prints it no

matter how many I do I can go a b c d e f g I could probably do this so many

times that I exhaust you know a long integer which is would be a horrible

endeavor but yeah everything that I put on there it just loops through it and

prints it so when you are linking with GCC because you’re probably using a

if you’re just linking with GCC.

GCC makes it really, really easy

to access the command line arguments.

Imagine now instead of just printing these things,

you used them to somehow decide

what your program was gonna do.

Maybe the user will give you a sub command.

Like if you’re a Git user, we say Git status, right?

So the Git says like, oh, you Git launches

and it goes, you want the status of something?

Yeah, sure.

So in your program now,

you could read what the user typed,

figure out a way to parse it and interpret it

have your program’s behavior adjust to whatever the user typed in okay that’s it for this video

the next video I’m going to post is how to do basically exactly the same thing but using pure

assembly without linking against GCC so like LD is going to be the linker just like pure assembly

no extra libraries okay thank you so much for watching this video I hope you learned a little

tell your friends 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 uh 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

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.

just wake up I promise that’s what will happen also if you look at the middle of

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

to the website which I think is also named somewhere at the bottom of this

video and it’ll take you to my main website where you can just kind of like

see all the videos I published and the services and tutorials and things that I

offer and all that good stuff and if you have a suggestion for clarifications or

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

Thank you.

The post Command Line Arguments in Yasm Assembly with GCC: A Practical Guide appeared first on NeuralLantern.com.