In this detailed tutorial I walk you through exactly how to implement while loops in x86-64 assembly language using YASM. We start with the basic concept of a while loop as it exists in higher-level languages like C/C++, then break it down into labels, conditional jumps, and unconditional jumps so you can see exactly how the control flow works at the assembly level.

I explain why we usually put the condition check at the top, how to handle the jump distances (especially the ~128-byte limit of conditional branches), why unconditional jumps are preferred for the loop-back, and how to structure init / top / body / done sections clearly.

We then build a complete, runnable hybrid program (assembly + tiny C++ driver) that:

• prints an intro message
• repeatedly asks the user to enter numbers
• echoes each number back
• continues until the user enters 99
• prints a goodbye message when finished

Lots of practical tips about label naming conventions, register preservation (R12 in this case), and debugging flow are included along the way.

Assumed knowledge: basic x86-64 assembly, how to use a makefile, simple system calls, and calling external functions. If you’re new to those topics, check my earlier videos first.

Hope this helps someone finally “get” while loops in assembly!
Thanks for watching – subscribe if these kinds of low-level explanations are useful to you.

Introduction to While Loops in x86-64 YASM 00:00:00
While Loop Concept in High-Level Languages 00:00:56
Breaking Down While Loop Structure 00:02:00
Labeling Key Sections Top Body Done 00:02:40
Conditional and Unconditional Jumps Explained 00:03:26
Why Prefer Shorter Conditional Jumps 00:04:40
Diagram of While Loop Flow 00:06:52
Alternative While True with Internal Break 00:08:08
Do-While vs Regular While Difference 00:09:32
Program Setup and Data Section Overview 00:09:53
Hybrid Program Structure and External Functions 00:10:56
Main Function and While Test Call 00:12:56
While Test Function Prologue 00:13:21
CRLF Helper Function 00:14:00
Intro Message and Loop Initialization 00:14:50
While Top Comparison with 99 00:16:57
Entering the Loop Body 00:19:08
User Input and Echo Output 00:19:38
Jump Back to While Top 00:20:29
Exit to While Done Section 00:21:39
Goodbye Message and Function Epilogue 00:22:14
Live Demo Running the Program 00:22:30
Summary and Closing Remarks 00:23:12
Call to Subscribe and Website Mention 00:23:46

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

Thanks for watching!

Find us on other social media here:

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

Please show your support!

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

All right, hello there. In this video, I’m going to teach you how to implement while loops in YASM

x86-64 assembly. Although you probably don’t need to be using YASM assembly to understand

this video or to benefit from it. So what am I talking about? First off, okay, so we’re going

to do while loops. There’s a lot of assumed knowledge in this video. If you don’t know how

assembly program, if you don’t know how to make a make file, if you don’t know a lot

of the basics that I’m just skimming over in this video, you’ll need to see my other

videos because I explain all of those things at length.

For this video, I’m just going to be talking about while loops only.

So for starters, let’s see here and open up a little notepad here and just type a while

loop and try to explain a little bit about it conceptually.

And then after that, we’re going to, we’re going to write a program in Yasm to show that

we can get this to work.

So what is a while loop in a higher level language?

We’ll just suppose C or C++.

You can imagine whatever language you want, but typically in a while loop,

we’re not talking about a do while loop, although that would be really easy

to implement after watching this video.

But in a regular while loop, you have the keyword while usually,

and then you have some sort of an expression like does a equal B or whatever.

So maybe I’ll just say does a equal B?

Expression evaluates to true then the body of the while loop will execute and then when it’s done executing

Execution will go back up to look at the expression again and make sure that it’s still true

So the loop will run forever until that expression evaluates to false

Maybe that’s what you want. Maybe that’s not what you want, but that’s what it’ll do

And that means the body runs an endless number of times

Also, if the expression evaluates to false on the very first run

then the body of the while loop will just never run at all.

So that’s, you know, a basic idea of a while loop in a higher level language.

Hopefully you kind of already know that.

So let’s look at the parts right here.

If we imagine this as assembly,

then probably the first thing we should do is label the part

where we look at the expression and decide whether we’re going to continue or not, right?

So I’m going to put a little label here

and maybe we’ll call it a while top or something.

You know, whatever you want to do.

just to label the part of the code

So that we know when we write assembly

We’ll be able to put the appropriate labels on the different parts of the while loop and we’ll be able to imagine

The while loop that we’re implementing in assembly

So I’m gonna say this is the top or you can call it the eval part whatever you want

Then we’ll make another label down here. We’ll call it

You know while body something like that and so basically if we want to jump up to the top of the while loop to evaluate the

expression, we just have to basically jump to that label called while top.

And if we want to jump to the body to actually execute the code,

then we just have to jump to that other label instead. We should also have a label at the

very bottom after the whole while loop is over and we’ll call it, you know, while finished

or while, whoops, finished or while done or while over something like that. So I’m just going to

Now you can imagine that when we’re at the top of the while loop and we see that the

expression is false, then we can just jump down to the done label, thereby exiting the

entire while loop.

Then of course we probably want to have some jump statements in here.

So for example, the expression part here, it’s probably going to jump either to the

body or either to the done area based on whether or not the expression evaluated to true or

false.

label while top you know which contains a conditional branch and then like an unconditional

jump so if a condition is true maybe we can jump into the body if the condition is false we’ll fall

through to the next statement and do an unconditional jump to the done label if you don’t

know conditional branching this is another one of the topics that i’ve covered in previous videos

as we implement the while loop.

So just keep in mind, there are other videos that I have

that you should watch first

if you don’t understand conditional branching or jumps.

The reason that I’m going to kind of design

the jumps like this where I’m going to say,

let’s do a conditional branch.

And basically if the loop evaluates to true,

we’ll jump into the body of the loop.

And if it doesn’t evaluate to true,

then the conditional branch will allow execution

to fall through down to the next statement,

which will simply contain a jump to the done portion.

to the done portion so basically as soon as the while loop is ready to break it gets uh implemented

by an unconditional jump which was fallen through to by the conditional branch that would only jump

into the body if uh expression was true i’m doing it this way because it’s usually a shorter jump

uh to jump to the true area you know the the body of the while loop and remember conditional

branching instructions have a maximum you know jump reach of about 128 bytes so if you try to

128 bytes. So if you try to jump too far, like for example, if you wanted to, you could reverse

the logic to where you could say, if an expression is true, let’s jump to the done portion and say,

we’re going to break the loop. If the expression was false, we’ll jump into the body. You could

do that. But then if the body of your while loop was too long, maybe it was so long that the last

instruction was greater than 128 bytes away from the top. Then by the time you wanted to

let’s see yeah if you have if you have too long of while loops you can’t jump more than 128

instructions away so that’s a limitation of contentional branching so I just I want to put

the biggest jump on an unconditional jump instruction because it doesn’t have a limitation

like that I was having a hard time imagining what I was about to say just now for the

the reversal I guess I’m just going to ignore the reversal scenario and we’ll just do it the

and we’ll just do it the regular way.

Anyway, so we want to have a conditional jump that either jumps into the body or to the done area.

And then at the very bottom, we want to have an unconditional jump to the top,

which basically means every time we get to the bottom of the while loop body,

we’re just going to jump up to the while top.

Actually, I’ll just say to while top.

Remember again, the regular jump instructions,

maybe I’ll take out the U here.

The regular jump instructions don’t have a limitation

on how far they can jump.

So that should be fine.

And that’s the basic idea of implementing a while loop.

Maybe I should draw just a quick diagram

before we start looking at the code,

just to make sure everybody of different learning styles

understands what I’m talking about.

So we’ll, let’s see, eval.

I’m still adjusting my pen and you know what?

You know what? It looked a lot better before I hit record.

Eval the expression.

So I’m going to first evaluate the expression.

If it evaluates to true, we’ll put a green arrow here and I’ll put like a T for true.

Then this will be the body of the while loop.

I’ll say like the body.

If it evaluates to false, let’s see.

I’ll just put that in red and I’ll put an F here then this is just going to be the done area

right so you can imagine we evaluate an expression using the compare instruction in assembly and

based on the results of comparing something whatever it is that your condition is then we

you know we we either branch to the done area or we branch to the to the body area

want to have a more complicated while loop and you don’t want to put a huge

amount of expressions or if you don’t want to logically concatenate a bunch of

different components into the expression you know that’s fair I usually write my

while loops in real life as just while true and then I break when certain

conditions are met you can do that too we’re not going to talk about that in

this video but you could just have a while true so you always jump to the top

and there’s no branching that goes to while done but then throughout the loop

loop you can just sort of check to see if certain conditions are met and if they are then you’ll do

a branch to the done area and if they’re not then by the time you make it down to the bottom of the

loop then it just automatically jumps to the top although you got to make sure with the the reach

of conditional branching you probably want to test to see if your condition is true or false or

whatever if it means we’re going to continue the loop then you probably just want to do a conditional

then you probably just want to do a conditional branch that jumps down a little bit

so that it can continue the body of the loop.

And then the part that it skipped over,

just a little part should be an unconditional jump that jumps out of the loop.

That way, it doesn’t matter how big your while loop body is,

you can always jump out of the loop.

But we’re not going to talk about that in this video.

Anyway, so we evaluate the expression.

If it’s true, we go to the body.

If it’s false, we go to done.

After the body is done executing,

then we just jump back up to the top where we evaluate the expression.

where we evaluate the expression.

I’ll put while here just to make it more clear that we’re talking about the basic

idea of a while loop.

Not too hard, you know.

And then if you wanted to implement a do while loop, just make sure that you always

evaluate the body at least once.

That’s really the only difference.

But that’s up to you.

This is just a regular while loop video.

Okay.

So we’ve kind of talked about it a little bit.

We’ve sort of, you know, drawn it out in a diagram and put some regular code in.

and put some regular code in let’s set up an actual assembly program that will do this so for starters

again i’m not going to show you my make file because i’ve already made other videos where i

explained how to make a make file from scratch same thing goes for hybrid programs i’m going

to have a driver which is a c plus plus module that just sort of calls on this assembly module

if you want to know how to make hybrid programs or you know drivers or you know whatever see my

to be talking about looping only. Okay, so let me get my solution up here. My source code is called

looper. And I’m just going to copy paste the data section for my program real fast, just so you can

see it. Okay, so here’s the data section. Again, this is not a basics for assembly video. If you

don’t know how to do a data section in Yasm, see my other videos. But for now, I’m just going to say

like the actual array of bytes and then a length and all I’m doing is printing out messages you

know begin the wild test your numbers will be printed back to you until you decide to quit so

that’s going to be printed to the user right away then every time the program wants a number from

the user it’ll just ask you know please enter a number or 99 to quit and then it’ll prefix

the echo back it’ll say you entered and then it will actually print the number and then when you

we’re done and i’m going to use an external uh function that i have available to just kind of

like input and output numbers this video is not about uh input and outputting and external libraries

if you’re interested you could probably just link a hybrid program and use printf and scan

f to very easily do input and output but that’s not what this video is about see my other videos

then i have crlf which is just a carriage return in line feed uh you know select the cursor goes

You know select the cursor goes to the next line and then I have like a system call code to just print and

Then a file descriptor just to print a standard output again. That’s explained in other videos

So now I’m ready to start copy pasting the main portion of my program

So first off I’m going to start the text section, which is where the instructions go in the ASM

So there it is and then I’m going to copy paste

of external symbols. So I just have a little library that I’m using that makes it easier for

me to input and output integers. So you can do this any way you want, or you can hard code a

number in the globals area. If you don’t want to deal with input and output while you’re learning

how to do loops, that’s totally fine. But then the entry point is going to be a function called

looper. So this is my function. And again, this is a hybrid program. So the main function or the

be present in my assembly module the driver is going to be a c plus plus module that just calls

on a function named looper so that means this function is going to get called from another

module and that’s why i have to mark it as global and then it is a function so i’m going to call

return at the end of it to say we’re done and then within this function i’m just going to call two

other functions that i’m about to create one is called while test which is going to actually do

the while loop and the other is called crlf which just print which just prints a new line for me i

which just prints a new line for me.

I don’t know why I do it that way, but I want to.

Sorry, not sorry.

So this is the real meat of the function here.

Let’s start, well, the real meat of the code or the video.

Let’s start a function called while test.

You can see it’s got a void signature with no arguments,

so it doesn’t really, you know, take anything or return anything.

I’m going to use register R12 to hold the user’s input

so that I can, you know, print it out and stuff.

print it out and stuff so that means I have to do a preservation of R12 because it’s a

callee saved for the ABI which you should respect so I’m going to push it at the beginning

and then I’m going to pop it at the end and then this is a function so I have to return

at the end of the function let me just double check that there’s nothing else weird at the

bottom of that nope okay so we’ve got the prologue and epilogue the wild test function

maybe I should copy paste my crlf real fast my crlf function it’s just sad but

it’s also kind of cute right it does nothing except just print out a new line

that’s all it does this video is not about that so at this point I should

have a program that probably works let’s see if it does I’m gonna do clear and

make run again if you want to know how to use make files or compile or link or

anything like that see my other videos so I’m gonna run it and it just says

which is some code that we’re not looking at.

And then it says it’s regain control.

And this line in the middle, which is just an empty new line,

that’s definitely from the assembly program.

Because at the top here we have CRLF.

If I call it multiple times CRLF,

then you’ll see there are multiple blank lines.

All right, I’m gonna take that out.

Now let’s continue with while test.

So what should we do here?

The first thing that we should do is print an intro message

message just to let the user know that we’re about to you know begin our while

tests and if we run the program one more time we should see that message now

begin the while test your numbers will be printed back to you system calls and

simple printing is covered in other videos so now uh you know for me I kind

of like to init all of my loops even if it’s a while loop and not just a for

loop or anything so I always have an extra label that I like to call init

or before or something like that.

So I have a label now called while test underscore init,

and it’s just where I’m gonna initialize

whatever it is that I think I need to initialize

so that the loop will actually work.

If you look here, all I’m really doing is setting R12 to zero

because what I’m gonna do is stop the loop.

I’m gonna break the loop whenever the user enters a 99.

So I don’t know what’s inside of R12

when we first start this function.

And I just wanna make sure that it’s not 99,

the stopping number at the very start so I’m just going to set it to zero. So

another note about my labels you don’t have to do it this way but I love to

write labels where the first part of the label is always the function that the

label is inside of so notice how the function is named while test and so my

label is always while test underscore something and I’m putting init here

just to say we’re initializing the loop but if you had a function that had a

had a lot of stuff going on in it for starters you should probably be breaking up that function

into multiple functions but but assuming you didn’t uh you should probably do another underscore

and then like another component and then another underscore based on what giant chunk of your

function you’re inside of so if there was like an if part a while part an input part an output part

you probably want to you know stick that into your labels your labels will get huge but for me

infused in assembly and this makes it easier.

So we’re going to initialize so that we can run our while loop and then the next thing

we’re going to do is implement the top of the while loop.

So remember if we looked at this code up here, maybe if I drag this over to the side and

pin it to the top for a little while, you can see that the top of the while loop is

where we kind of evaluate the expression to see if we need to keep going or not.

jump into the ending area, the done area. So the top, whoops, the top is always for that.

We’ll say first, I’m going to ask, are we done? So, you know, how do we know if we’re done?

In this particular while loop, we want to compare the user’s input, which is R12 to the number 99.

And if it’s equal, then we will quit, which means also if it’s not equal, we will jump into the

So by the way, you’re probably wondering how did R12 get the user’s input?

Well, we’re going to do that as the next step.

And of course, your design pattern may vary a little bit.

No, that’s okay.

I just like to implement it this way.

So first thing we’re going to do is compare R12 with 99.

And that’s why I’ve written this comment here, just like the blank while comparison part.

And I guess I could have put this R12 not equal to 99 up at the top, but then it kind

of feels like I’m leaving these other two instructions.

So I moved it down one.

these other two instructions so I moved it down one so basically as long as you know we compare

R12 and 99 compare and conditional branching is covered in other videos but we compare those two

values and then we say if R12 is not equal to 99 then jump to the body and we expect that the body

will be like a short jump which will be within the range of a conditional branch

So anyway, if the not equal branch didn’t happen, that means R12 is equal to 99.

At that point, execution falls through to line 84, and we’ll just unconditionally jump out of the while loop.

So basically we’re saying, if it’s true, we continue looping.

If it’s not true, we just jump outside of the loop.

We’re just totally done with the while loop.

Okay.

So then we need a body, because obviously we’re going to jump into the body here.

that means I’m going to just copy paste another little set of code here.

Right after that unconditional jump.

So now we got the body.

Notice how I put a little comment here that has a brace just to indicate to you,

hey, this is the beginning of the actual while loop body,

just to make it a little bit more clear.

And what are we going to do inside of the body?

We’re just going to ask the user for some input.

So I’m printing a simple message here,

and then I’m calling on my helper function

to just actually input a number from the user.

I’m going to store that number into R12.

So that’s how R12 gets the numbers, gets the user’s input.

And the way I’ve written this, if the user enters a 99,

it’ll echo it back to the user and then it’ll break the loop afterwards.

So, you know, if you wanted to rearrange things like I talked about before,

where you input before you check to see if you’re going to keep going, you could do that.

But it would be a little harder to echo the user’s input back to them before you break.

I don’t know. It’s up to you.

I don’t know it’s up to you anyway so we grab input from the user and then we print another

message basically saying here’s the thing that you inputted no problem and then again we use

one of my helper functions to actually spit the number back out at them so this is not

a very complicated body it’s just asking for a number and then printing the number back to them

and then after that I’m going to do another label and I’m going to call it the body bottom

we don’t really have to do this label but for clarity I think it’s probably a good idea

I think it’s probably a good idea.

So the very bottom of the while loop’s body is usually where you don’t do any more instructions

that are part of the work of the while loop’s body,

but just sort of the place where you jump back up to the top

so you can evaluate and decide to continue or not again.

So notice how I’m using an unconditional jump here.

That’s a good idea because again, if you have like a huge while loop body,

you might end up surpassing the threshold of 128 bytes

of 128 bytes and then you’ll get a assembler error that says

I can never remember this. It’s like a

jump out of range error or something like that. Basically, if you do a conditional branch to jump up the top

because some people like to check to see

if they should continue the loop, they like to check for that at the bottom. I’ve done that before.

And then if true, then we’ll jump to the top of the loop. But if the loop is too big, that won’t work. So

I just like to take a long jump to the top of the loop and then decide if I’m going to keep going at the very top.

if I’m going to keep going at the very top. And then there’s a comment saying, hey, that’s the

end of the body. Okay, no problem. Now let’s do the done label, which is basically where we jump

if the loop is actually finished. So remember, if this expression right here evaluates to false,

then execution is going to fall through to line 84, where we jump to this while test done label.

And so I’m just going to put the while test done label right here. So we’re done. So the done is

So we’re done. So the done is not part of the loop. It comes after the loop. That’s this right

here on line nine of the little notepad. And we can just kind of do whatever we want. At that

point, we can return to a caller, we can just do other stuff, we can, you know, do a different

loop or, you know, whatever, we’re just done with the original loop. For me, I’m just going to say

goodbye with this little print to just sort of like, you know, print an exit message. And then

we’ll do the epilogue where we restore R12. And then we just return to the caller,

the driver worry about exiting the program okay so if we’ve done this correctly we should now have

a working program let’s see let’s see okay let’s enter a number let’s do 22 and it says you enter

22 and let’s do 55 and we just we can enter any numbers we want and as long as we’re not entering

99 the program will just continue forever so this is a while loop if i want to quit i do 99

breaks at the top it breaks by jumping down to the done area where we print our goodbye message

which just is end while test and then if we run this again if i do 99 from the start then it just

immediately breaks you know it prints out what you entered but then it immediately breaks

and that’s it that’s uh the basics for how to write a while loop you just use basically

layered on top of an abstract concept of what you think a while loop is,

or what I guess the world thinks a while loop is.

Okay, thank you so much for watching this video.

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

I’ll see you in the next video.

Hey everybody.

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

I really appreciate it.

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

if you could do me a please a small little favor could you please subscribe and follow this channel

or these videos or whatever it is you do on the current social media website that you’re looking

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

community so we’ll be able to do more videos longer videos better videos or just i’ll be able

to keep making videos in general so please do do me a kindness and uh and subscribe you know

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

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

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website,

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

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

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

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

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

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

it would really mean the world to me. I would really appreciate it.

So again, thank you so much for watching this video and

enjoy the cool music as I fade into

the darkness which is coming for us all.

Thank you.

The post x86-64 Assembly While Loops Explained Step by Step in YASM – From Concept to Working Program appeared first on NeuralLantern.com.

In this beginner-to-intermediate assembly language tutorial, we dive deep into unconditional jump instructions (JMP) in x86-64 assembly using Yasm syntax.

We cover:

• What unconditional jumps really are (basically a “go to” for assembly)
• How labels work and how to create them
• Why JMP has unlimited range (unlike conditional jumps)
• Practical demo showing how to skip code sections using jumps
• Comparison between jumping over code vs letting it execute
• Quick look at why this matters before learning conditional branching

We also reference the excellent free open-source textbook by Professor Ed Jorgensen (May 2024 version) which is highly recommended for anyone serious about learning x86-64 assembly.

Whether you’re preparing for university courses, reverse engineering, operating systems development, or just love low-level programming, this video will give you a clear understanding of how unconditional control flow works in modern x86-64 assembly.

Next video will cover conditional jumps (je, jne, jg, jl, etc.) and their limitations.

Enjoy the video and happy coding at the machine level!

Introduction to Jump Instructions 00:00:00
Recommended Free Assembly Textbook 00:00:23
What Unconditional Jumps Actually Do 00:01:27
Labels Explained with Examples 00:02:40
Unlimited Jump Range Advantage 00:04:43
Overview of the Demonstration Program 00:06:56
Building and Running the Jump Test 00:09:21
Live Jump Test Demonstration 00:10:53
Effect of Removing the Jump Instruction 00:13:50
Jumping in Different Directions Example 00:14:58
Summary and Next Video Teaser 00:17:28
Closing Remarks and Call to Action 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

Hello there.

In this video, we’re going to be talking about jump instructions in assembly.

This video is going to be about x86-64 Yasm assembly,

but I think probably anyone who’s interested in jump instructions

will benefit from this video because the concept is usually the same

throughout any system that you might use.

So for starters, I want to direct your attention to a textbook

that I think is wonderful.

This is an open source free textbook that will help you become an expert in assembly.

It’s not mine, I didn’t write it.

The author is Professor Ed Jorgensen, PhD.

He releases this textbook for free.

It’s under a copyleft license so you can literally just go to his website and download it and

send it to your friends and everything and it’s wonderful.

This book will take you from zero to hero when it comes to Yasm Assembly.

It’s wonderful and amazing.

This is the book and I just want to show you the section on jump instructions real fast

and then I’ll talk about them a little bit and then I’ll show you a sample program that

uses jump instructions.

So this version of the book that I’m working with right now is May 2024 version 1.1.56.

I’m going to go down to let’s see section 7 instruction set overview.

Inside of there there’s another subsection called where the heck is it control instructions

instructions 7.7 within that there’s a another subsection called 7.7.2 that’s

why I look this other not one of the many reasons that I love this book it

has so many subsections there’s just so many yummy subsections to organize

everything in a way that you can find it all so fast and okay so we’re looking

at unconditional control instructions in other words a jump instruction if

you’re an old-school programmer especially if you use some sort of like

if you use some sort of like a basic language or a language with go-to’s you might recognize jumps

as just being a go-to meaning we’re not actually going to call a function and then return from it

which is what the modern programs tend to do we’re just going to say let’s write a jump instruction

and we will literally just change execution to to jump to some other location just kind of go there

forever maybe we come back but if we do it’s going to be because there was a different jump instruction

instruction that told us to jump back.

So we’re not calling and returning.

We’re just going somewhere and that’s it.

Obviously it’s a little bit more convenient to be able to call functions,

but that’s sort of like an abstraction that has to be implemented after we

understand how to jump. So anyway, the jump instruction is pretty simple.

You just put JMP in Yasm anyway, and then follow it with a label.

So, you know, just as a quick little recap here, what’s a label?

imagine we have an assembly program here and maybe here’s our text section and we put some

instructions maybe there’s like an entry point right here I’ll say a global entry point and

literally just taking the word entry point and putting a colon after it now makes that a label

so if there are any instructions underneath I’m gonna put a bunch of nopes then if someone somewhere

to say jump entry point they should be able to go right here to instruction 8 and then start

executing downward. I guess maybe I didn’t need to put the global keyword global just means let’s

make this label available to other modules within the same program so if you have a multi-source

program or a hybrid program with multiple different languages then you know you should do this but if

it’s just a pure assembly program and there’s only one source code filed you don’t need to mark a

Just as a quick example here, entry points, I’ll just put hello as a label and I’ll say like do exit stuff.

So imagine on line 16, you add some instructions just to kind of exit.

If I wanted to skip all these nope instructions for some reason, I could just do this.

I could say jump hello.

And what would happen is execution.

Oh, I can use my pen.

Execution would just sort of, you know, it would come into the text section.

you know, it’d come into the text section.

It would go down through the label and it would execute this first jump

instruction and then execution would jump over the nopes into the hello label.

And then, you know, if there was other stuff here, then it would get executed.

So by jumping over the nopes,

I’m essentially saying that the nopes should not actually end up being

executed. They’ll be there in the program, but they won’t actually execute.

So that’s the basics of a jump instruction. Okay.

So what else do I need to tell you real fast?

What else do I need to tell you real fast?

Oh, one thing that’s really good about jump instructions is they have unlimited jump range.

So you can jump from a place at the very, very beginning of your assembly program and

jump to a place that is at the very, very, very end of your assembly program.

There’s not going to be a limitation on how far you can jump.

I mean, in theory, there’s a limit, but practically speaking, there’s not a limit.

Why would you care that there’s not a limit?

not a limit well because in a future video that i’m going to release we’re going to talk about

conditional branching which is sort of a jump that only jumps if a certain condition is true

and those have limited ranges where they can jump so there’s going to be a bunch of different

instructions but one of the conditional branching instructions is jne and another one is jge and

there’s another one that’s je basically you know jump if something is equal jump if something is

can only jump about 128 bytes away.

So after your assembler assembles and compiles

down to object code,

and then after your linker links your final executable,

wherever it is that the instructions happen to end up

inside of your program,

the conditional jumps,

the conditional branching instructions,

they can’t jump more than 128 bytes away

to some other instruction.

So keep that in mind.

Even if later on you graduate

to making decisions in your program,

like I’m going to do in the next video,

in your program like i’m going to do in the next video you can only jump so far and if you have to

jump too far you actually might not be able to jump at all unless you jump a very short jump

to a regular jump instruction and then that jump instruction jumps very very far away that’s kind

of the workaround for it i’m not going to talk about that in this video though this is not a

video for uh conditional branching i just wanted you to be aware of one of the benefits of regular

Okay, so we’re looking at the book here.

There’s not really a whole lot to the jump instruction, just jump and then a label.

We talked about its benefit over conditional branch instructions,

but we also talked about its, I guess, its shortcoming,

meaning it can’t actually make a decision.

It will always jump to a label no matter what.

There’s no condition.

So there’s the book there, and now I’m going to make a sample program

and show you how to run it.

I’m just going to run it.

I’m just gonna run it I’m show you what it does in order to implement conditional branches so for

starters I want you to know that there’s a make file that I’ve generated under the hood and we’re

not going to be talking about that in this video this is also a hybrid program so there’s a C++

entry point a driver module under the hood of this we’re not going to talk about that if you

want to know how to make hybrid programs you want to generate make files you want to learn the basics

videos for now we’re only going to be talking about jump instructions so I’m

going to skip a lot of information okay so for starters I’m going to make a

little data section here and again this is explained in other videos but for now

we’ll just trust that we can make a data section that contains strings C strings

and other values so pretty much I’m just going to make a string called begin jump

test just to announce to the user that we’re we’re going to start doing this

We’re going to start doing this and then I’m going to make a string called this message

should not appear.

So in the code, I’m going to try to print that message, but then I’m going to jump over

the call to print it just to prove to you that there are instructions that would print

that message, but we’re jumping over them with the jump instruction.

And then there’s like an exit message.

And then there’s a CRLF, which is just a carriage return line feed.

Again, all of this stuff is in other videos already.

So we’re going to use system call one to print.

We’re going to print a file descriptor one, which is just standard output for your program.

Then we’re going to start the text section where the actual code lives.

So this text section is here and it’s supposed to be at line 37 already.

I think I missed a bunch of lines.

Oh no, I think I missed some comments.

Anyway, so we have a text section here and an entry point and I’m calling it cool.

calling it cool and I am marking it as global because in this particular program that I’m

building it’s a hybrid program there’s going to be a C++ module that will call on our cool

function so cool has to be global and then I’m just going to call on a method called jump test

I don’t know I have the words load there I’m just going to get rid of that real fast locally and in

my solution up above and so we’re going to call a function called jump test and then when we’re

finished we’re going to return to the caller which is going to be the driver and that’ll

pretty much be it.

So if I comment this out real fast, let’s see,

this might actually work.

Let’s see if I can get it to run in the terminal.

But there’s a bunch more code that we have to add, so I’m not really sure.

So let’s do clear and make run.

And it seems to not have a shared object directory.

Let me pause the video while I copy paste one of my stupid libraries into the

program. You don’t need this library.

It just helps me print things.

okay so now I have copy pasted my shared object which allows me to do extra printing stuffs

just for just to make this demo easier for me but you don’t need to know it or you don’t need to have

it to to learn jump instructions anyway so I’m going to do that again and now it actually prints

something okay so hello from the main CPP driver and then it says the driver has regained control

make a call to jump test here and then let’s start the actual jump test function. So I’m going to do

well I guess this thing is kind of short I could copy paste the whole thing all at once.

So let’s do yeah let’s just jump let’s just call the whole thing. Okay I’m going to copy paste the

whole thing then I’ll explain it a little bit to you. So there is a function that I have in here

It’s just a convenience function that I made so I can print a carriage return line feed.

The real interesting thing here is the jump test function.

So we were just making a call to jump test.

Now we’re making the actual jump test function.

It’s got a signature of just void with no arguments.

So it’s not super interesting from the caller’s perspective, but it does some stuff.

So for starters, it has an intro message.

So this will print, you know, hello, welcome to the jump test.

jump test. In fact, if I do a return call here,

it should actually just print that and do nothing else. Right. Okay.

Notice how it printed, begin the jump test.

And then right after that,

there’s a jump instruction just proving to you that we can jump over other

instructions. So look at this,

this piece of code should never actually be called because we’re going to jump

over it. What it is, is it’s printing that jump shouldn’t happen message.

at the top here jumps shouldn’t happen so it’s trying to print out this message should not appear

but we’re going to jump over that by using this jump instruction here on line 66.

Again note that the jump instruction is just jmp followed by a label the label specified has to be

where you want to jump it’s never going to return from that place unless you specifically jump back

somehow later on like i guess if we wanted to we could put a label on line 67 call it the return

call it the return point and then jump back from it after the jump point in fact maybe that would

be kind of interesting to do at the end of this video but otherwise we’re gonna you know just

let’s see we’re gonna end up jumping over so let me reduce the front size just for a second here

so imagine execution uh comes into this program you know we’re executing uh instructions we’re

calling crlf we’re just executing executing as soon as we hit this jump instruction then execution

then execution jumps over into the label that I specified.

So this whole code section here just never even gets called.

So that’s why we will not see that message.

And then at the very end, all I’m doing is I’m just properly,

you know, I’m printing the exit message.

So I’m just printing another string saying the exit or the jump test is done.

I return to the caller execution goes all the way back up to just you know right here right after

call jump test was executed and then the cool function will return to the caller and that’s

just a c++ main function that does nothing so at this point we should see the whole entire point of

the program and then I’ll start tweaking it so you can kind of see the difference with the jump

instruction uh there and not there so let’s run one more time and notice how it says begin the

says begin the jump test and then end jump test and then it goes back to the driver that is

regain control it never says this message should not be printed so this whole section was just

skipped let’s comment out line 66 so that we don’t actually jump over that code and then now you’ll

see that that message does get printed so notice how it says this message should not appear okay

and then run the program one more time.

Now that message does not appear.

Pretty cool.

Now let’s do that double jumping thing just to show you.

I mean, this is not something that you actually want to do.

You probably want to write functions and function calls,

but if you wanted to, you could do something like this.

Here’s the exiting.

And maybe right after this, let’s make another label.

Let’s do, oh gosh, what am I going to do?

what am I going to do? Because if I jump after the exiting label and I jump back up to some label

up here, it’s just going to be an infinite loop. So maybe, um, I don’t know, let’s make a, I mean,

if I make another label down at the bottom, you’ll kind of think it’s a function just without

a return statement. So let’s actually jump within the same function. Let’s do, um,

over the never area.

So I’m going to say jump test and I’m going to write never.

So now we have a label that tells us where the never printed message actually starts.

So if we jump over it to the exiting, then we’re good.

But then if I up here, if I say jump instruction that subverts

never message so I’m just I’m just leaving a comment not code I could then

say let’s jump to jump test never and what will happen now is we’ll still see

the never message because what will happen is execution comes down you know

through here all these instructions are executing and then we see a jump that

tells us to go to the the never label so we actually jump over this exiting jump

over this exiting jump or this like the skipping jump,

the jump that skips the message.

And then we actually do print the never message

and we just keep going down and down and down

until we’re finished with that.

And we end up just sort of exiting normally.

So that means the only code that doesn’t get executed

in this case is the one right here

that skips over the never message.

Hopefully that makes sense.

Let’s run the program just to prove it real fast.

So I’m going to do this again.

And now you see the message should not appear.

This message should not appear.

You see that message.

So again, if we comment out that jump that subverts the skip, then execution will fall

through and we’ll end up executing line 69, the skipping instruction.

again now that message does not appear.

We could jump back and forth if we wanted to.

I don’t know.

Should I do a back and forth?

I don’t really want to.

I think at this point you understand we can jump anywhere we want, right?

I could take a bunch of time in this video to rewrite this program and have it say,

let’s jump downward and then let’s jump upward again and let’s let it fall through

and then let’s jump over something and whatever.

let’s jump over something and whatever. I mean, just wherever you want to jump,

just make a label and then jump to it. Then you have to figure out what your execution path is

actually going to be. And maybe that’ll be complicated, but I hope I’ve made my point by

now. Anyway, so that’s the basics of just jumping around. It’s not super useful. Conditional

branching is a lot better. So see my next video. And I thank you for watching this and I hope you

learned a little bit and had a little fun. See you soon.

See you soon.

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

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 coming for us all.

Thank you.

The post x86-64 Assembly Jump Instructions Explained: Unconditional JMP with Full Example in Yasm 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.