Quick practical guide showing how to implement a classic for loop (i=0; i<n; i++) in x86-64 assembly with YASM. We break the for loop into init/check/update parts, convert it to while-style logic, then build it with compares, conditional jumps, inc, and unconditional jumps back to the top. Includes real working code, user input, and printed output.

Great for students learning assembly after C/C++, OSdev hobbyists, or reverse engineering beginners.

Introduction to For Loops in Assembly 00:00:00
For Loop Structure in High-Level Languages 00:00:28
Breaking Down For Loop Parts: Init, Check, Update 00:01:04
Converting For Loop to While Loop 00:01:52
Why While Loop Style Helps in Assembly 00:03:16
Program Overview and Setup 00:04:12
Data Section – Strings and Messages 00:04:40
External Functions and Hybrid Program 00:06:11
Entry Point – Looper Function 00:07:12
For Test Function and Register Usage 00:07:42
Preserving Callee-Saved Registers 00:08:05
Printing Welcome Message 00:09:00
Prompting User for Number 00:09:48
Getting User Input 00:10:25
For Loop Structure in Assembly – Comments 00:11:12
Initialization – Setting Counter to Zero 00:12:50
Loop Top Label and Condition Check 00:14:28
Conditional Jump Setup (jl) 00:15:07
Handling Jump Distances 00:15:34
Loop Body – Printing Current Number 00:16:58
Update Part – Increment Counter 00:18:40
Unconditional Jump Back to Loop Top 00:19:14
Loop Done Label and Exit 00:19:55
Printing Goodbye Message 00:20:23
Testing the Program 00:22:08
Final Results and Demo 00:22:24
Outro and Call to Action 00:23:25
Thanks and Subscribe Request 00:23:45
Website and QR Code Mention 00:24:38
Closing Thanks 00:25:16

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

Hey there! In this video I’m going to teach you how to implement for loops in YASM x86-64 assembly.

Although if you’re using a different type of machine or a different assembler,

this video should still be useful to you because it’s mostly about the concepts involved in implementing a for loop.

Okay, so for starters here, what am I even talking about? Let’s do…

are you even talking about dude imagine in a higher level language we have a for loop here

and so we have like four size type i equals zero i is less than 99 i plus plus right probably most

programmers looking up assembly uh on the internet probably are interested in uh or probably already

know how to implement for loops in c plus plus so let’s just pretend that you do and so inside of

your for loop we’ll do stuff and what happens here is uh well you know this for loop is going to run

Well, you know, this for loop is going to run 99 times.

It’s going to start at zero.

And, you know, so we have like an initialization part right here.

Maybe I should copy paste this and kind of break down the parts.

We have an init part here for the for loop.

We’ll say init part.

And then here we have a check part.

We’ll continue to loop as long as this expression is true.

You can make a big complicated expression if you want to,

but we’ll just keep it simple for this video.

So I’ll call this the check part.

And then we have sort of an update or a maintenance part.

an update or a maintenance part. So I’m going to call this the update part where we increment our

counter variable, move pointers, even call functions, do whatever it is you think you need

to do to update the loop so that it runs it, you know, so that the loops don’t actually have to be

integers. But in this case, I think it’s better, it’s easier to understand what the loop is doing

if we just kind of break down these parts. Anyway, so what is really a while loop? Sorry,

but a while loop that breaks and has break has like a nit logic and breaking logic and checking logic just in specific places.

Imagine this. What if I said before the loop starts, I’ll let’s let’s say we’re going to do a while loop before the loop starts.

I’m going to initialize a variable size type I equals zero, right?

That’s the initialization part that’ll only happen one time.

And then when you have a while loop and it checks to see if it should keep going, that’s

the check part of the for loop.

So I’ll just say while i is less than 99.

And then for the update part, we just have to stick that inside of the while loop somewhere.

Depending on your logic, you might want to put it at the top or the middle or the bottom.

I’m going to put it at the bottom because I’m going to expect that it happens right

before we do the next check.

So I’m going to maybe do a comment here and call it the update part and I’m just going

So maybe if I update this code to print something, it’ll seem a little bit more clear.

Value of I is, and then I’ll just say I end L, and then I’ll copy paste that to here.

And then I can also put this inside of the while loop.

And now we have transformed our for loop into a while loop.

transform your for loop into a while loop it’s pretty easy to implement in assembly if you

already know how to implement while loops so i should again say that there are lots of parts

i don’t know if i said that during this video but there are lots of things in this video that i’m

not going to that i’m not going to explain specifically because i’ve already explained

them in other videos so for example implementing a while loop is in another video so if you don’t

already know how to implement while loops if you don’t know how to use conditional branching or

If you don’t know the basics of assembly, hybrid programs, make files, all the basic stuff that I’m going to skim over in this video,

then you should probably check out my other videos first.

But for now, I’m just going to assume that you know how to implement a while loop.

And really the lesson is, hey, just take your for loop and convert it into a while loop.

And then you can implement the while loop pretty easily.

That’s the secret as far as I’m concerned.

So imagine this now. Let’s do some assembly code.

I have a source code file here called looper.asm for assembly.

And you can imagine that I have a hybrid program running under the hood.

I’m not going to show you all the code involved.

I’m not going to show you the make file or the C++ driver that calls on this module.

We’re just going to write the assembly here.

So, you know, if you’re writing pure assembly at home to practice, that’s fine.

Just keep in mind, there’s like a few things under the hood that I’m not showing in this specific video.

So first off, I’m going to copy paste my data section.

paste my data section of my assembly program. The first thing to note is we have a bunch of

C strings here. We’re basically going to be telling the user, hey, we’re going to begin

the four tests. Maybe I should have capitalized for, I’ll leave it. And then we’re going to prompt

the user for a number. We’re going to say, please enter a number. The loop will print from zero to

the number minus one, which is like the typical four loop that you usually write in the most

and then we’re going to have a little prefix we’re going to say you know like an arrow and then we’re

going to print the number back to the user that we’re looping through so if the user enters a

10 it’s going to print the arrow 0 and then arrow 1 arrow 2 all the way up to arrow 9

and then when we’re done we’re going to print an ending message so this is nothing new if you know

assembly already just c strings that will print with system calls see my other videos if you don’t

And then a CRLF string, just basically doing a new line, a carriage return new line feed

on the system.

And then we’re going to output using system call code one.

And we’re going to use file descriptor one so we can print to standard output.

Okay.

So now the real fun begins.

Let’s start our text section, which is where the instructions of our assembly program go.

So I’m going to do text section, section text right there.

And I’m going to use two external functions to just help me input and output numbers to the user.

If you wanted to, you could use a system call that just inputted a character.

And then you could just kind of like loop printing various characters.

And like, let’s say if the user typed A, maybe you could imagine doing a loop that increases the character that they typed all the way until it hits Z.

Or if they hit, you know, F, it’ll just print F all the way to Z.

to z you could do that without using an external library for printing integers this video is not

about this library right here so i’m not really going to go over it but uh you know you could

hard code the start and end points when you’re practicing um you could you could use a different

library or a different function call to get the inputs you could use a system call just to input

one character um or you could you know use a hybrid program to to utilize printf and scanf

f. Either way I’m just going to be using these two functions just to like get input and output.

It’s not really part of the idea of looping. So now let’s start our entry point.

Our function is called looper. Since this is a hybrid program you can imagine there’s a C++

module elsewhere calling on the looper function and so that’s why I mark it as global so it can

be called upon. And then I have another function called for test. I don’t really know why I chose

it this way but i wanted to make another function that was called upon by our entry point here

so the looper function really doesn’t do anything except recall the for test function

so now let’s start the for test function actually maybe this is where the fun begins

so i’m gonna put it down here and so you can see the signature it doesn’t take any arguments it

doesn’t return anything it just does stuff and then i have a note to myself this is how we’re

going to use the registers we’re going to use r12 for the user’s number and then we’re going to use

And then we’re going to use R13 to keep track of where we’re going.

So let’s see.

I’m going to start by saying let’s preserve R12 and R13

because you have to respect the application binary interface, the ABI,

and that designates R12 and R13 as Kali saved registers.

If I don’t preserve those and my program is even a little bit complicated,

I’m probably going to be debugging forever

debugging forever or I’m going to just crash my program for no reason. So I’m going to just

do a push pop pair. Notice how the pops are in reverse order. This is not a push pop video,

but just so you know, I guess while I’m here, I’m going to copy paste my crlf function,

which really does nothing. It just prints out the crlf string with a system call. That’s all

Okay, so do I even need CRLF in this program?

I think I just modified this.

Maybe I don’t even need it anymore.

No, I guess I do.

The first thing we’ll do is we’ll print an introduction message to the user.

So inside of the for test, we’ll just use a system call to print out, you know, a welcome

message to the user.

And then I’m going to call CRLF, which will just give us a new line.

And yeah, you can hard code, you know, the 13, 10 at the end of these strings, but I

don’t really like doing that.

doing that. Okay, so we should have a working program at this point. Let me see if it actually

does work. Clear and make run. Okay, so the driver prints a little welcome message. You don’t see the

driver code, but that’s what it’s doing. And then the for test prints the welcome message that we

just added. And then the driver lets us know it’s retained control. And then it’s responsible for

returning to the operating system for us. Okay, so then the next thing we’re going to do is we’re

we’re going to ask the user for a number so that we know how many times to loop.

And again, you could hard code this number if you don’t want to do IO right now.

You could even print a character a certain number of times

if you don’t want to even deal with printing an integer.

But I’m going to ask the user for a number.

That’s going to be the prompt string.

And if we run it again, now you should see it asks the user for a number.

So it’s going to say, please enter a number.

The loop will print from zero to N minus one.

print from 0 to n minus 1. It doesn’t actually ask for the number though. It doesn’t actually

I guess take the number so that’s going to be my external library that this video is not about

where I just call a function called input assigned 64 integer and I’m going to receive that back in

rax and I’m just going to save rax into r12. So r12 is now going to be the number that the user

inputted and that’s why up here I have it designated as the user’s number. So really not a big deal but

a big deal but uh you know if we run it again it’ll ask for a number and then it won’t do

anything else it’ll just kind of quit okay so now we can implement our for loop this is going to be

a little tricky so we’re going to start off with the initialization part remember we had several

parts here if i just kind of drag this off to the side maybe pin it up to the top so we can see it

aren’t we? If I move it a little bit to the side. So remember that for loop, it’s got an init part

and a check part and an update part. And I’ve kind of added that as a comment just to remind myself

of the way my mind is supposed to be wrapped around this concept. And so I made another comment

here with four and then empty parentheses just to denote that some comments that come below

I guess the top of the for loop

So now I’m going to make a label here and what I like to do with my labels is I like to

prefix them with the name of the function that I’m currently in and then an underscore and that kind of helps me keep track of

My symbols a little bit more easily, especially if I have a large module the symbols are less likely to overlap if I prefix them with the

The function names

to be Fortest underscore something and since I’m only doing one thing inside of the Fortest function

I’m just going to have a suffix only for the most part but you can imagine if you had more

parts inside of your function and it started getting a little cluttered you might want to have

you know another label you know that just sort of another I guess like part to your label that names

the part of your function you’re in although this is assembly it gets really hard really fast so

really hard really fast so if your function is even a little bit complicated you should probably

consider breaking it up into multiple functions if you can. We can’t really do that at this point

because it’s just a for loop but keep that in mind. Okay so we’re going to initialize. Remember

the first thing we had to do to initialize was you know setting i to zero or you know whatever

it is that we’re going to set up in the init part so I’m just going to do that here. I’m going to say

That’s the first part, the update part where we set size type i equals zero.

In fact, maybe I could do another copy paste of this.

Where instead of using a size type, we’ll just say that the register r13 equals zero.

I know that’s not going to make sense in a higher level language right now,

but just so that the for loop looks a little bit more like assembly.

We’ll keep going as long as r13 is less than r12.

and then we increase R13.

So I’m just going to put ink R13

so it looks more assembly-like,

even though this completely and totally

would not compile in C++.

I hope that this helps your understanding a little bit.

So yeah, we can do everything

except for just the increase part at the very top.

I’m going to choose to increase it at the bottom.

If you wanted to, I guess you could start off R13

as a negative number and then increase it at the top.

But I personally don’t feel that’s like very clean.

feel that’s like very clean it also forces you to use signed integers maybe you wanted to use an

unsigned integer so you could get like a gigantic um maximum number that you looped up to i don’t

know so we’ll just initialize here and we’ll say r13 is equal to zero the init part should not be

part of the actual like looping like every time you loop up to the top of the for loop you should

not repeat that part again it should only happen once so the next label that i have is called loop

have is called loop top and that’s just going to be the top of the loop that I

continue to go back up to every time I want to see if we’re supposed to

continue looping and then go into the loops body so maybe I should say that’s

why this is named to underscore loop top and I don’t know you don’t have to do

camel casing and your labels you know you could just do loop in it or whatever

but I’m just choosing to do it this way so at the top of our loop we’ll be

Remember that was the check part, right?

So we’re going to check to see that R13 is still less than R12.

If it is, we’ll continue with the for loop.

If it’s not, then we jump out of the for loop.

So that means probably the true case where R13 is indeed less than R12,

that’s going to be a short jump just into the loop’s body.

And the false case where R13 is not less than R12,

that should probably end up being a much longer jump.

on how big your your loop is maybe that jump is too long too far away for a conditional branching

instruction to reach if you’ve watched my previous videos you should know already that

the conditional branching instructions like jl like jump less than they can only reach about 128

bytes away if you try to go further than that the assembler will actually stop and block you from

finishing your compilation it’ll say i think it’s like jump out of range or something like that

So you want to try to keep the short jump points with your conditional branches.

And then in the false case, where the conditional branch doesn’t actually do anything,

then it falls through to the next instruction where you will have an unconditional jump.

And remember, the unconditional jumps, they don’t have a limitation of 128 bytes.

They can jump like all over the place.

Like they can jump anywhere, basically.

that means if you think about it, we come in to the loop top right here.

We immediately do a compare instruction and a conditional branch.

So if R13 is less than R12, meaning we should continue to for loop,

then we’ll just do a short jump into the loop’s body and actually execute its body.

And if not, we will end up falling through to line 92,

where there’s just an unconditional jump instruction that just says,

all right, let’s jump all the way down to being done.

Let’s jump all the way down to being done, which could be very far away for all we know.

Okay, so we’ve done that.

Now let’s implement the loops body because the first thing that we did is we wanted to

jump into the loop body to actually execute our instructions, which in this case, we’ll

just be, you know, printing a number every time we loop and then increasing that number.

So I’m going to do a little like new line there.

I’m going to paste the loop body.

little comments to help remind myself that this is actually the loop’s body. So for test loop body

that takes care of the branching instruction, hitting on that and actually going into the body.

And then later we’re going to have to implement a label for the loop being done. But for now,

we’ll just say the body. What does it do? It just prints a little message to the user.

If you look at the message for current number string, if I go up real fast,

message for current number, it’s just an arrow. So the user’s going to see an arrow and then

So the user is going to see an arrow and then their current number, I guess of the loop’s

current number.

And then every time it loops, it’s just going to continue printing that arrow with a number

on it.

So we’re doing that.

And then we’re going to say R13, which is the current counter variable, which started

at zero is going to get loaded into RDI, which if you watched my other videos, it’s just

the first integer argument for a function call.

So I’m just going to call this other function here, which is not part of the video to just

which is not part of the video to just say hey please print this number for me so the first

time this iterates it’s going to print zero because it’s going to print r13 and then it’s

going to print a new line so that the cursor goes to the next you know line of the terminal

so that’s all the body does it just kind of like prints the current number with an arrow and does

a new line and then at the very bottom of the loop body we just sort of maintain the for loop this is

for loop this is going to be the update part so like let’s see maybe scooch this up a little bit

the update part where we have let’s see on the very right side of the for loop which is like i

plus plus or in more assembly speak increasing the counter variable so i’m just going to increase r13

and then that way the loop can progress you know we’re always looking at r13

to decide if we need to stop or not you know we’re comparing r13 to r12

So we’re just increasing at the very bottom of the loop and then we unconditionally jump back up to the top.

Probably a better idea to unconditionally jump back up to the top because maybe the jump to the top is very very far and if it’s greater than 128 bytes it won’t work.

So the regular jump instruction doesn’t have that limitation. So now we’re jumping up to the loop top.

So you can imagine now that you know we’re not going to the initialization part. That would be bad.

We’re just jumping up to the top here where we immediately ask you know are we done?

If we’re not done, we jump into the loop body and print another number.

And then at the very bottom of the body, we say, all right, increase the counter and then jump back up to the top.

So this is a simple for loop, but you can see what it’s doing, right?

It’s just going to be printing a number over and over again as the number increases.

And then eventually it’ll stop when it hits the correct number.

The last thing we need is the loop done label.

If you look back up at the top here on line 92, if R13 was not less than R12,

less than r12 then execution would fall through to line 92 and there is our unconditional jump

instruction basically saying if r13 is not less than r12 then we’ll jump to the loop done label

which means we’re just totally finished with this loop so we have to make that real fast

and all it’s going to do is just basically say goodbye it’s just going to print a message to

to the restoration functions.

Oh, did I ruin my return somewhere?

Uh-oh, what did I do wrong?

I lost my return statement.

Did I accidentally delete that somehow?

That’s a bad program.

Or did I not even…

Hmm, I wonder if it like…

I wonder if I didn’t have my return statement

and it fell through into the CRLF function

and then the CRLF function returned to the caller

to the caller on behalf of the for test function I don’t even know only all only

the spirits know at this point I don’t know leave a comment or something if

you know what happened but every function has to have its own return for

sure so you know the loop done label is usually where you want to jump to when

you know the for loop is finished or the while loop is finished when it comes to

saying goodbye it probably would be a little bit more clear of me to add an

you know for test you know say goodbye just so that I that I remember that this

is this is the place where we’re done and this other place this is just

something else that’s happening maybe I’m doing more instructions or more

operations or calling a function or whatever so obviously if I did it this

way then the loop done label would just end up falling through to the goodbye

label and it would be fine but it’s just more visually clear I’m gonna take it

Anyway, so at this point we might have a program that actually works.

Let’s see if it does.

What else do I need to add?

No, I think we’re done with that.

Okay, let’s try it.

So we’ll do a make run and we’ll enter the number five and let’s see if it works or it

crashes.

It worked on the first try.

So I had a solution though.

Not fair, but I could have typoed.

Anyway, so it says we entered a five, the loop will print from zero to N minus one.

print from zero to n minus one so we should see from zero to four and so then every iteration of

the loop it’s just that little message we’re just printing a zero printing one printing a two you

know the number increases because we did did that little inc instruction the increase instruction

we unconditionally jump to the top of the loop where we decide if we’re supposed to uh finish

you know be done with the loop by jumping to the done label eventually after we uh let’s see

it prints this four here it’ll do the increase instruction at the bottom of the loop’s body

and then it’ll jump to the loop’s top then the loop’s top will see that it’s a five because we

just increased the four it will see that five is definitely not less than five so that’s a false

which means execution will you know fall through where the heck is that it’ll fall through to the

line 92 jump instruction which is just the loop being done so that’s here where it says goodbye

says goodbye and then we have successfully implemented a basic for loop

all right so thank you so much for watching this video I hope you learned

a little bit and had a little bit of fun I will see you in the next video happy

coding and happy studying hey everybody thanks for watching this video again

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

hope you did learn something and have some fun. If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos or whatever it is you do on the

current social media website that you’re looking at right now. It would really mean the world to

me and it’ll help make more videos and grow this community. So we’ll be able to do more videos,

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

and subscribe. You know sometimes I’m sleeping in the middle of the night and I just wake up because

I know somebody subscribed or followed. It just wakes me up and I get filled with joy. That’s

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

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

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

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

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

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

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

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

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

I wake up in a cold sweat and I’m like,

it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music as I fade into the darkness,

which is coming for us all.

Thank you.

The post x86-64 Assembly For Loops Explained – YASM Tutorial appeared first on NeuralLantern.com.

Want to actually understand how signed integer multiplication works at the CPU level? In this straight-to-the-point x86-64 assembly tutorial we dive into the IMUL instruction – the proper way to multiply signed integers in YASM/NASM on Linux.

We cover:

• The difference between unsigned (MUL) and signed (IMUL) multiplication
• Two-operand vs three-operand IMUL forms
• Multiplying immediate values vs global variables
• Loading values into registers (mov) and performing fast multiplication
• Basic addition with ADD and INC
• Full working example that prints results so you can see it in action
• Why you should respect the ABI and save callee-saved registers (R12-R15)

Everything is built with YASM on Ubuntu, linked with a tiny C driver, and run instantly. No fluff, just real assembly code you can copy and run right now.

Code on screen, calculator verification, and clear explanation of every line. Perfect if you’re learning low-level programming, reverse engineering, or just want to know what really happens when you write a = b * c; in C.

Introduction to Integer Arithmetic 00:00:00
Recommended Book and Resources 00:00:39
Instruction Set Overview 00:01:17
Addition Instruction (ADD) 00:01:43
Unsigned vs Signed Multiplication 00:02:20
Signed Multiplication with IMUL 00:03:05
IMUL Three-Operand Form 00:03:40
IMUL Two-Operand Form 00:04:12
Squaring with IMUL 00:04:50
Setting Up the Sample Program 00:05:08
Data Section and Strings 00:06:13
Text Section and External Functions 00:06:58
Math Function Entry Point 00:08:01
Multiply Test Function Setup 00:08:42
Multiplying Immediate Values 00:09:48
Printing the Immediate Result 00:10:21
Running and Verifying Immediates 00:12:53
Multiplying Global Variables 00:13:49
Loading Globals into Registers 00:14:07
IMUL with Globals Demo 00:14:37
Addition with INC and ADD 00:15:36
Final Results and Verification 00:17:09
Wrap-Up and Closing 00:17:22
Outro and Subscribe Request 00:17:44

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

okay

hey everybody in this video i’d like to talk to you a little bit about

integer arithmetic in yasm assembly on an x86-64 system

so what am i talking about well integer arithmetic i want to take integers and i want to add them

together multiply them together whatever this video is mostly going to focus on signed integer

but I’m going to briefly skim through unsigned integer multiplication and also

addition and anyway so for starters let me go up to this the top of this book

here that I’ve got I’m going to show you pages from a book that I really really

love I mentioned it in a lot of my other videos it’s called x86 64 assembly

language programming with Ubuntu and it is written by a brilliant doctor

professor who is just interested in everyone learning this is an open source

you can get yourself a copy for free just look that title and name up you can find his website

you can grab a copy and you too can become an assembly expert just by reading this book

honestly this book has everything that you really need to to really level yourself off

level yourself up well beyond i think the master’s level of college probably

not as much as the person who wrote the book but you never know anyway let me uh

I want to go down to section 7 here and it’s called instruction set overview.

So here you can have like an overview of like all different types of instructions, but I’m

going to focus on the integer arithmetic instructions.

So I’m going to go to 7.5.

Notice how the first section in here is addition.

I’m not going to give you an addition example because it’s just too easy.

You pretty much use just use the add instruction and then you have a source and destination

comma source in x86 yasm assembly it’s pretty much the destination is the first operand so uh

that’s kind of implied usually when you have just like a two operand instruction now we could add

using three operands and the the first one would be the destination and then the other two would

be the sources but i’m going to scroll down past that to the integer multiplication section 7.5.3

unsigned multiplication is a little tricky and

You kind of have to decide what data size you’re going to go with and then you use the instruction

uh, and then you end up with some some uh, some answers that are spread across multiple registers

I’m going to eventually make other videos where I can talk to you about how to manipulate multiple registers or at least know that they’re there like

not 64-bit registers so if we were clever we could just sort of manipulate those so that

the whole answer showed up on one single 64-bit register if we wanted to but just know you can

multiply unsigned integers it’s a little bit more complicated than signed integers so in this video

i’m just going to talk about signed integers let’s see so signed integer multiplication

so in order that’s a section 7.5.3.2 if you want to multiply two integers and they’re signed

and they’re signed meaning they have a plus or a minus sign meaning they’re designated as either

positive or negative rather than not designated at all which would usually just mean positive

you can use imall as an instruction and well you can just provide you know one operand two operands

or three operands let’s do the three operand version first because that’s probably the easiest

So we would take a number that’s sitting in a register and then we would multiply it by some immediate.

Notice how IMM is sitting here.

The result of multiplying a register by some number would just go into the destination operand.

So that means you’d put a register here.

You’d put a register here.

You’d put an immediate here in one instruction.

Then you’d have some sort of an answer on what these two numbers were multiplied against each other.

then you’re allowed to specify a register for the destination and a register for the source.

But notice how the destination gets overwritten here.

So, you know, it’s going to multiply this number by this number

and then just store the result in the first register.

So you will kind of overwrite something.

It’s maybe more convenient for you to use the three operand version

if you only want to multiply by an immediate.

But, you know, anyway, and then for the, let’s see, let’s see, I think you can square a number

just by specifying its source here.

It’ll multiply a number by itself.

And then let me just go down a little bit.

I’m starting to get lost in this book.

Let me go down a little bit.

Well, I guess that’s all we really had to say.

Okay, so let me show you a sample program that I’ve prepared.

that I’ve prepared so that we can multiply. Okay, sample program. I think I need to rehearse myself

a little bit more before I record videos. Anyway, I’ve got this empty source code file here. Keep in

mind that I don’t need that. Keep in mind that I have a sample program here already. I’m not going

to really focus on the contents of it because this is not what did I do wrong here? Main and math.

main empty no no where’s my make file oh I forgot to open it this is not a video

about make files or hybrid programs or anything like that that’s covered in my

other videos so I’m just gonna say hey I’ve got a make file that compiles my

assembly source code and then I’ve got a driver C source code file which its

entire job is just to have the main entry point because I’m linking against

the GCC libraries and then its job is just a call on a math function which

So now my assembly module is blank.

What should we do?

First I’m going to copy paste from my solution here, just a bunch of strings.

So I’ve got a data section that I’m going to get set up.

This is not a video about the basics of assembly programming.

See my other videos, but for now I’m just going to say, well, I’ve got a bunch of strings.

I’m going to say the result of multiplying immediates is this, the result of multiplying

globals is that.

multiplications and then see the results. Okay, so then a couple more variables

before we’re finished is I’m gonna now say that we have a system call for

system right which is not what this video is about. See my other videos for

system calls. Same thing for file descriptors it’s there I’m not gonna

explain it too much I’m just gonna print a standard output and then from this

program we’re gonna I’m gonna return just an integer for whatever reason I’m

for whatever reason. I’m just saving it as a variable. And then we want to multiply some

integers. So I’m storing two integers in the global section, you know, still inside of the

dot data section. So that’s, these are going to be global variables. They’re going to be both

be quad words. So I can load up into a quad registers or quad word registers. And now I’m

ready to start my text section. So the first thing that I’m going to do is just, you know,

that’s where all of our instructions go and then I’m going to name two external

symbols don’t worry about these symbols they are not the point of this video but

you know I have a little library that I wrote that helps me print and and take

input from the user I’m gonna print an integer I’m gonna take an input from the

from the user so don’t worry about that that’s not the point of this video

really I just want to make it so that when I demo I can just easily type in an

and then just print it to the user.

So let’s look at our main entry point here.

Remember the driver calls on a function called math.

So I’m just gonna make an entry point called math,

mark it as global so the driver can call on it.

And then I’m gonna, whoops, why did I put load here?

Do, I’m gonna put, I’m gonna say do it right there.

Let’s do it.

I’m just gonna call on a function I wrote

called multiply test, kind of pointless

if you think about the fact that there’s like no code

in the main function here.

like no code in the main function here but that’s the way i like to do it when we’re done we’re just

going to return our return value that’s already been defined and so now i’m ready to start setting

up our multiply test maybe i’ll just copy paste the header here and i’ll say this is going to be

a label called multiply test because i’m going to call on it and try to use it like a function

i’m going to put a return instruction at the very end so now it really is a function

I’m going to use these registers.

So I’m going to use R12, R13, R14, and R15 to hold temporary immediates and globals

just for multiplication.

So I’m basically going to be using the registers to hold my data.

And because I’m going to use all of those registers, remember you have to respect the

ABI.

So that means we have to have a push pop pair on all of those registers because they’re

designated as callee saved.

saved if anyone calls on your functions and you’re not respecting the abi then you’re probably about

to crash the program in some way or even if you are the only person who writes any code that your

code calls on or gets called from you’re probably still going to regret not respecting the abi

eventually when you forget what’s going on anyway so let’s multiply some immediates first thing i’m

and move it into R12 because that’s where we’re going to hold some temporary

immediates and then the number 256 put that into R13 and then I’m going to use

the I’m all instruction to just multiply those two values together because this

is the two operand version of that instruction the result will also be

stored in R12 so that means 233 will be erased from R12 and the answer that will

the results for the immediate because I like my programs to be pretty. I’m not just going to print

the numbers and then hope I can remember which number comes first. That’s usually a huge mistake

if you’re trying to debug something even a little bit complicated. So I’m going to print my string,

which I’m calling the immediate prefix. And if you look back up at the top right here,

it’s just going to say the result of multiplying immediates is, and then it’s going to put three

asterisks. And then I’m going to print the actual result. And then the suffix is just going to be

And then the suffix is just going to be three more asterisks.

So we should basically see the results surrounded by asterisks.

So I’m doing that.

And then I’m going to use my library

to call a special printing function

so that I can just print to the result.

So R12 is where the result of the multiplication is.

I’m going to give that as the first argument,

which is the RDI register, if we’re talking about integers.

And then I’m just going to call my function

that’ll print for me.

for me and then I’m going to print the suffix so the suffix is just that other

string we talked about just it trails with asterisks I’m then going to call

on a custom function called crlf all that’s going to do is just print a new

line I don’t know why I do that I could easily put that into the string but it’s

more fun to call functions although to be fair every time you call a function

you are jumping to an instruction elsewhere and so the CPU does pay a

trying to write programs for high performance you might not want to do that anyway so this is pretty

fast because i’m really just using an immediate and then i’m loading it into a register i’m not

actually touching global memory so this should be a lightning fast multiplication operation

let’s see if this actually works if i didn’t screw this up whoops what did i what did i do there oh no

i have too many videos now

gosh okay clear and make run oh what have I done undefined symbols CRLF did I

forget oh I forgot to copy paste my CRLF function yeah so again don’t worry

about CRLF all I’m doing is just printing a new line carriage return it’s

just you know this is from another example where I was trying to prove to

somebody you need to preserve registers and respect the ABI so don’t even worry

you know what I’m going to leave it as is because if I take that out then I have to take the time

to remove the push pop pair because there’s no point at that I’m doing that if I’m not

messing with those registers forget about that it’s not part of this video

anyway I’m going to run the program again and you can see that the result of multiplying

immediates is and so this whole string right here was my prefix so again not really the point of

the point of this video and then this is the result of multiplying those two different numbers

and then the suffix with the stars after so let me just prove this to you where’s the dang calculator

oh man i need to work on my icons like i just did something screwy and i have like no good icons

anymore on this virtual machine so we were going to multiply 233 by whoops by what was it 256.

five nine six four eight and you can see that’s on the screen five nine six four eight so we have

successfully multiplied signed integers and since they’re signed we could multiply negative numbers

if we wanted to i’m not going to here but you can now the next thing let’s try is let’s multiply

stuff sitting in global memory okay so i’m just going to copy this um where the heck is it

at the top we made two global integers we said integer a is equal to 233 and then 256

those were the same numbers that we just multiplied so we should probably get the same result

if we’re lucky so i’m saying i’m going to move both of these into registers so i’m going to move

a into r14 and i’m going to move b into r15 just to prove to you that we can and then

instruction we did before the result is going to go into r14 so let’s see i’m gonna print the

prefix real fast here same kind of concept that we talked about before there’s just going to be

a prefix before the result and then i’m actually going to print the result with this line right

here or these lines i’m just going to print r14 which is holding the result at this point

and hey we can trust that R14 wasn’t killed by the system call because the

system call respects the ABI and then I’m gonna print my suffix right here and

then a CRLF and that’s basically the idea let’s just double check here that

we get the same result twice make run notice how it prints the same result

twice once with globals once with immediates so if you were wondering

before this video how to multiply immediates or how to multiply globals

well there you go just put them into registers first and then call I’m all

pretty fast let’s just do one other thing for fun I’m going to let’s see add

one number to our 14 so to the result of the multiplication and then I’m going to

add five to it just to prove to you that we can increase an integer by one and we

we print it before we do the prefix extra stuff just for fun so here I’m gonna increase r14 and

I’m gonna say that it is a q word I guess that’s implied already because r14 is considered a 64-bit

register but if we wanted to increase I don’t know just for the sake of argument if we wanted

to like increase this right here let me just show you real fast how we do it we would say increase

would say increase q word and then name the integer in global memory so in global memory

the system doesn’t really know by default if it’s a one byte integer a two byte integer or four or

eight so you just have to specify the data size so it knows which integers to look at when it’s

considering what the original value is and how to overflow and when to overflow but you know just

for fun I’m putting that in here so it’s going to increase the result by one and then it’s going to

and it’s going to do that using the addition instruction.

So we’re going to add R14 with 5.

We can put an immediate there,

and the result is going to be stored in R14.

So basically R14 is equal to R14 plus 5.

And so overall, when we add those two things in there,

the second result should now be about 6 higher than the first result.

So if you kind of look at this right here,

we have 648, and then we have 644,

which is 6 numbers higher than the original result.

than the original result. So these are the basics of integer arithmetic with

signed multiplication and addition. I think that’s all I really wanted to show

you. Yeah, okay. So I hope you learned a little bit of stuff from this video. I

hope you had a little bit of fun. Come back, I’ll see you in the next video and

happy coding! Hey everybody! Thanks for watching this video again from the

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

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 i’ll just wake up i promise that’s what will happen also uh if you look at the middle

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

which I think is also named somewhere at the bottom of this video.

And it’ll take you to my main website where you can just kind of like see

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

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.

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

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

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

Thank you.

The post x86-64 Assembly: Signed Integer Multiplication and Addition with IMUL & ADD (YASM on Ubuntu Linux) appeared first on NeuralLantern.com.