In this in-depth x86-64 assembly tutorial using YASM, we dive deep into implementing complex if-else and if-elseif-else control structures from scratch. Starting with the fundamentals of conditional branching, we build up to full chained if-elseif-else blocks with multiple conditions – exactly how high-level languages handle them under the hood.
You’ll see real working code that:
- Takes user integer input
- Tests against specific values (5, 6, etc.)
- Handles greater-than/less-than comparisons
- Properly branches so only one block executes
- Uses labels, cmp, conditional jumps (je, jl), and unconditional jumps (jmp) correctly
We cover the classic pattern: compare to conditional jump to true block to execute true code to jmp to end to false block falls through or jumps in. Everything is shown step-by-step with live compilation and runtime demos.
Perfect for anyone learning low-level programming, reverse engineering, or wanting to understand how compilers translate if-else chains into machine code. Prerequisites: basic conditional jumps (see my earlier videos).
Code shown works on Linux x86-64 with YASM/NASM syntax. Grab the concepts and apply them anywhere.
Introduction to If-Else in Assembly 00:00:00
Explaining the If-Else Design Pattern 00:00:56
Drawing the Basic If-Else Flow 00:01:01
Comparison and Conditional Jumps 00:02:30
Labels for True and False Blocks 00:03:07
Unconditional Jump to End 00:04:50
Diagram of Execution Flow 00:05:51
Alternative Pattern with Inverted Jump 00:07:00
Recapping the If-Else Pattern 00:08:45
Starting the Code Example 00:09:16
Setting Up Input and Strings 00:09:40
Calling External Functions 00:10:57
Entry Point and Prologue 00:11:40
Asking User for Integer Input 00:13:09
Creating the if_test Function 00:14:56
Preserving Callee-Saved Registers 00:15:51
Printing Begin Message 00:17:03
Implementing Simple If Block 00:18:29
Comparison and je Jump 00:19:18
True Block: Equality Message 00:21:08
Testing Simple If Examples 00:23:48
Transition to If-Else Blocks 00:24:21
Creating if_else_test Function 00:24:47
Setting Up Complex If-Else 00:26:25
First If: Equal to 5 00:27:22
True Block for Equal 5 00:28:33
Else If: Equal to 6 00:30:29
Else If: Less Than 10 00:34:17
Final Else Block 00:37:33
Done Label and Goodbye 00:38:23
Recap of Full Flow 00:39:06
Live Demo of All Branches 00:40:54
Signed vs Unsigned Jumps Note 00:43:38
Recommended Assembly Book 00:44:12
Conditional Jump Families 00:45:05
Closing and Practice Advice 00:46:48
Thanks for watching!
Find us on other social media here:
- https://www.NeuralLantern.com/social
Please help support us!
- Subscribing + Sharing on Social Media
- Leaving a comment or suggestion
- Subscribing to our Blog
- Watching the main “pinned” video of this channel for offers and extras
Hello there.
In this video we’re going to talk about implementing simple if-else blocks in YASM x86-64 assembly.
Although if you’re writing in a different assembly language, this video will probably
still be useful to you because I’m going to explain the design pattern or how we can achieve
that at the assembly level.
So x86-64 YASM assembly, also known as AMD64 YASM assembly.
So if you have not seen my other videos about how to do conditional branching in the first
place, you probably want to go check that first because that knowledge is required for
this video.
There’s also a lot of other stuff that I’m just not going to explain in this video, such
as creating a make file, you know, compiling and linking your executable and so forth.
So see my other videos where all those concepts are explained already.
how to implement a simple if-else block.
So for starters, maybe let me draw a little bit.
Suppose we had, let me get rid of this thing
and then I’ll just do a regular notepad.
Suppose we had a higher level language,
just so you know what I’m talking about.
Suppose we had a higher level language
and we wanted to say if, you know, some expression is true.
We wanted to say if expression is true,
then print, you know, it was true.
Anybody remember that old movie, Little Nicky?
Somebody got exploded and then the guy next to him goes it’s not true
Okay, it was not true
So this is the basic idea of what we’re going to implement in assembly
I’m going to write a full program for assembly to show you this but um
You know you’re in C++ you’re in C you’re in I don’t know whatever language you’re in and
You obviously know how to use if-else blocks at this point hopefully
And now we’re going to just try to figure out how to implement them in assembly
So it’s important to understand that really under the hood
really under the hood there’s a bunch of stuff happening surprise right okay so
first off we look at this expression which could be I don’t know let’s say
five is greater than ten or a is equal to B or whatever it is that you put in
there you could make a very complicated expression we’re going to use simple
expressions for this video so if we’re comparing a to B we’ll end up using the
compare instruction remember there are two steps to conditional branching and
in YASM we first use the compare instruction against two operands and then that will end up
filling up the rflags register so that we can later conditionally jump based on the results
of the comparison. So we do a comparison and then you can imagine that the beginning of this
you know the the true body notice how it has a scope I’m going to just put this brace on another
line here to indicate that there is a scope from line four to six indicating all this code in here
in here is executed only if the if statement was true and then all of this other stuff is executed
only if the original comparison was false right so you can imagine now label is something like
my if was true so we can make a label for where that body starts and another label for where the
label is something like if was false and then what will happen is we can use a
conditional jump instruction after we do our comparison maybe I should put to
compare right here oh I’m using I’m using assembly style comments I should
be using a C style comments if I’m actually writing C++ here let me just do
that okay so this is the comparison instruction here and then here’s the
here and then here’s the beginning of the body of stuff to execute if it was true you can imagine
that there could be many statements here um if it was true or if it was false
just to prove to you that we can execute like a full body of stuff so we have a label that
designates when that body starts and then we have another label designating when the else body
starts and then we should have a label that uh that designates when the whole thing is over
label is something like if and or if is done or something like that so basically what we want to
do is to implement an if else a simple if else in assembly we’re going to say let’s do a comparison
and then we’ll do a conditional jump where are we going to conditionally jump well if the comparison
was true label. And then what will happen is execution will fall through.
When it reaches the end, we want to have another jump statement that unconditionally jumps
to the end of the if statement. If we didn’t, then whenever the expression was true,
we would end up executing all of the true statements and then it would fall through
to all of the false statements or the not true statements. So we have to have many jumps in here
let’s get into the body and then let’s finish and jump out of the body on the other hand if the
expression was false then our jump instruction is going to jump you know over the true body so
it’s not even going to do that at all it’s going to execute all of the else stuff and then it’s
you know sometimes a good idea if you have another jump here that just jumps to the end but you can
kind of see by the way i’ve written this out that there’s not going to be anything between the end
you know place where we’re finished with everything which means we don’t really
need an unconditional jump at the end of the else body we can just let the
execution fall through so maybe if I can draw a little diagram here I’ll say I
don’t know I’ll do like if put it in a little bubble and we’ll say that if it
was false we jump to one place and if it was true we jump to another place
we jump to another place.
I hope you’ve already started to understand this by now.
So we’ll say if the expression is true, we jump here.
If the expression is false, we jump over here.
And so true would be saying, let’s jump to the if was true.
So we’re going to jump to if was,
I’ll put a T there because I’m running out of space.
If was true.
was I’ll put an F false and then at the end of the true we jump to the done
label so I’m just gonna put done maybe down here
so at the end of the true we just unconditionally jump to the done area
and then at the end of the false we jump unconditionally to the done area as well
here’s something interesting though when we have a comparison instruction and
conditional branch instruction let’s say uh let’s say a equals b we did that comparison and then we
wanted to jump into the true area if a equals b was true so that means we’ll say jump
equal so if a is equal to b after we compare well let’s say a comma b we’re going to use registers
when we come to the code we’ll say compare a and b and then jump if they’re equal to some label
but the conditional branching instructions they only jump to one
potential place or fall through so if the comparison was false meaning if those
two things were not equal then we’re not going to actually be able to jump to a
different label we’re going to simply fall through to the next instruction so
in that case the very next instruction would get executed let’s just put a jump
was
false.
Meaning
we compare A and B
and if the two things are equal
we’ll jump into the true block.
Otherwise we fall through to the next instruction
which
that’s a very poorly written J
but we’re going to unconditionally jump to false.
So if we did not
jump to the true area we fall through to the next
instruction where we will always
jump to false and that implements the diagram
that implements the diagram that you see up above.
I mean, you know, if we have if statement, we compare,
maybe I’ll do, you know, A equals B.
We jumped to true, if was true.
And otherwise we end up falling through
and then jumping to if was false.
And then at the end of both of those,
we have an unconditional jump instruction
that jumps to the done.
So I’ll put JMP down here just to let you know,
you know, at the end of each of these blocks,
that they are jumping out of themselves at the very end to the done area maybe
I’ll put an arrow here so that we know both of these jumps end up jumping to
the done area that’s the basic idea for how to implement an if-else block a very
basic one we’re gonna do more complicated ones later but for now we
kind of have the idea down I think let’s look at some code dang I blew 10 minutes
already on that okay so I’m gonna copy paste some code from my solution here
code for my solution here this again this is not like a beginner’s assembly
video if you need to learn how to write assembly in the first place how to
compile you know link create a make file and so forth you need to see my other
videos first but for now we’re just going to assume that you know how to
make a data section in Yasm and we’re gonna say let’s make a bunch of strings
so first I’m gonna ask the user for an integer and then I’m gonna make a bunch
of decisions like I’m gonna do you know an if-else block to test what kind of
what kind of number they put you know did they make a number that uh
equal one if it was equal to something oh did I ask twice I can’t remember what I’m doing
but basically we’re going to print something if their number was equal to something else
we’re going to print uh something if their number that they inputted was equal to five we’re going
to print something else if their number was equal to six we’re going to print again something else
a bunch of stuff and then wait isn’t this the complicated example oh no i think i am using code
for my more complicated example else less than 10 i don’t know maybe this is the simple one
let’s double check i guess if i put more complicated code in here you’ll probably be happy
but whatever i thought this was going to be a simple example so i’m just defining strings at
codes stuff that is covered in other videos now i’m going to start my text section so my text
section begins with a declaration that i’m going to use two external functions so this video is
not about this library that takes input and sends output i have other videos for that but basically
i’m just using a library that lets you type an integer into the terminal and then it will print
a different number to the terminal for you so you can imagine if you wanted to follow along
imagine if you wanted to follow along with this code at home and you don’t
have this library you can just hard code your numbers just to prove to yourself
that you can get it to work or you can use a different library if you have a
hybrid program and you’re linking against GCC you can just use scanf and
printf pretty much those take a little bit more work to do but you can do it
anyway so our entry point is going to be called if tester it’s a function called
Again, this is a hybrid program and hybrid programs are not covered in this video, but you can imagine that there is a C++ module elsewhere in my source that is just going to call on a function called if tester.
And so that’s why I’m marking this as global so that other modules in my program can call on if tester.
So it’s just a little label that we can jump into or in this case call into.
Let me go down to the bottom of that.
We’ll put a return statement at the very end.
very end so now this is officially a function and notice how i made a note here that says r12 is
the user’s inputted integer so that means i’m going to be using r12 and since r12 is designated
in the abi the application binary interface as callee saved or callee preserved that means i
have to do a push pop pair to preserve it or i’ll get in lots and lots of trouble my program will
prologue which my favorite book also calls the prologue and then I’m going to
say epilogue and so now we have a function that basically doesn’t do
anything but we can at least jump into it let’s see if this compiles as is I
think it probably will yeah so the driver just says hello that’s the C++
program with the actual main function and it calls my if tester function but
nothing happens the if tester function returns control to the driver and then
the driver just says okay i got control back so nothing really happened so now let’s ask the user
for some input so again this is not a video about this library or how to print with this with system
calls see my other videos if you need help on that but basically we’re going to print a message to
the user hey please input an integer and then we’re going to call on a library function that
lets them type in a number and then returns it to us in rax we’re then going to store it
well just basic stuff right so if I run this again it’s going to ask for an
integer please enter an integer if I can type that and then nothing else happens
okay now we can kind of start making more decisions so I’m going to let’s see
if test if test if test okay so what I need to do now is run another function
called if tests several times and I’m going to compare the number that the
times and I’m going to compare the number that the user inputted so remember r12 is the user’s
input so I’m going to load that as the first argument of a function call and then I’m going
to load the number five as the second argument of a function call probably not a great idea to hard
code numbers in your assembly you should probably define them up in the globals or the the data
section at least as just regular defines and not numbers in memory but I’m going to just keep these
So three times we’re gonna call if test and then also another function called CRLF. So first I’m gonna paste in
CRLF
Where the heck is that? Oh, dude?
Again, this is not a video about the basics
So you’re just gonna have to trust me or go watch my other videos if you don’t understand what I’m doing here
But I have a function called
CRLF and its whole job in life is just to print a new line for me just because I like to do it that way
handles the CRLF call. Now let’s make another function called if test.
So I’m going to start that by designating its label right after this block of
code here, maybe before CRLF.
So we have like a basic if test function and here’s my prototype just to remind
myself what I’m going to be doing.
It’s going to take an input and it’s going to take another input for a test
against me. So the first one is like the user’s input.
The second one is the number that I want to test it against.
number that I want to test it against they’re both longs which means they are both integers
which means the incoming arguments are going to be rdi and rsi if you’re respecting the abi
and then some notes to remind myself I’m going to be using r12 and r13 inside of this function so
I’m going to start by putting a return statement there since that is what it takes to make a label
into a return into into a function then I’m going to preserve the callee saved registers again if
don’t know what i’m talking about see my other videos we’re going to push r12 and push r13 so
that they are not ruined for the caller we call this the prolog then at the very bottom of the
function we have the epilog which just restores uh the registers in reverse order you’ve got to
do it in reverse order see my other videos if you don’t understand why okay so that’s basically a
function that can get called it doesn’t do anything let me double check that the program still actually
works. 66 and nothing happens. We just printed CRLF a bunch of times. Okay, so now we’re ready
to continue. So let’s grab the function arguments. Remember we were going to use R12 and R13 for the
user’s input and the number we will test against. Those came into our function with RDI and RSI.
So I’m just going to copy those two incoming arguments into R12 and R13. And you’re supposed
keep the user’s input in RDI then the moment I call any other function or system call I’m just
going to lose that data so I’m going to keep it inside of R12 and R13 so I grab the function
arguments and then I print a begin message just to let the user know that we’re going to start
you know making tests against our number so this is just basically a message saying hey begin the
if test and then print what we’re going to check against so the next thing is
I’m going to let the user know what the second incoming argument was.
If you look at R13 here, that was RSI, which was the second argument.
So the test against me number.
So we’re going to check the user’s input against whatever we called for the second argument.
So I just wanted to print it out.
You know, like we’re testing your number against whatever.
So that means I need to make another call to my little printing library here.
To RDI which is the first argument notice how we already we already destroyed RDI. That’s why I’m keeping the input in our 12 and our 13
And then we’re gonna make that call and we can just assume everything will go according to plan at that point and then
Then we’re gonna print a special message only if something actually happens
So we’re gonna implement the if else block in a moment. Let me just run this real fast
and then it says we’re calling the function three times and we’re saying the basic test has begun
we’ll test against this number five so we’re testing your input against five and then six and
then seven and then we didn’t actually do anything we’re about to okay so then the next thing is we’re
going to print a special message only if the user entered the right number so first off remember we
see if else block and converting it into assembly so i’m sort of placing that in comments for you
so the comparison instruction i i didn’t want to put the r12 equals r13 inside of the same comment
that lines up with the the compare instruction because the compare instruction as i’ve said in
other videos already it doesn’t actually check to see if something’s equal it just makes a bunch of
called r flags with information that we can later use to decide if the two things were equal or not
equal or greater than or less than or whatever so that’s why i chose to put that on on the next line
so at this point we’re saying if those two things were equal and that’s how i implement the expression
in the middle then let’s jump to a special label called if test if was equal so you can come up
with any scheme you want for your labels but for me when i have when i have sub labels inside of a
when i have sub labels inside of a function i like to just suffix the function’s name with an
underscore and then start thinking of sub labels after that so everything’s like kind of clean
there’s less chance of overlap in labels if you have like a giant module with tons of functions
so i’m going to say this is like my main if that i’m checking and uh i’m going to jump to a label
called was equal meaning you know this evaluated to true that means that should be the true part
block let’s see do i still have that code here yeah right so here i’m going to jump to
the true block so you know if was true in the first example that we talked about so i’m going
to say if it’s if those things were equal jump to the code for the true block okay that means i
actually need the true block uh but i guess we’re going to set that up in a second otherwise if that
did not jump away it means that those two things are not equal so i said i should jump to the
I should jump to the else block or the false block.
Wait, do I have else in this example?
Oh, okay, okay.
This first thing that we’re looking at is only if.
So we don’t even have an else block yet.
We’re going to do that as the second example.
So we’re basically going to jump to the done area
if we didn’t jump into the true area.
And then at the end of the true area,
we can either jump to the done area
or we can let the execution fall through.
fall through okay so now that means i need if was equal and if i just copy paste a big giant
block of code and try to explain it to you real fast let’s do this
okay so we were going to jump to if was equal if r12 was equal to r13 and then um
we uh have this you know label here and notice how i’ve kind of like put a brace here indicating
like put a brace here indicating hey this is the beginning of the true block body you should
consider doing this too when you’re first learning and even after you’ve learned because let’s face
it assembly is tough and so in the true area i’m just going to print the equality message i’m going
to say hey your number was equal to you know whatever and then uh i’m going to actually print
the let’s see r13 number so that was uh i think the number to compare against the test against
against me number so that means here in this message we’re going to say hey your number was
equal to the number that we tested against so then otherwise let’s see or sorry after that
we’ll print the suffix of the message um and so you know i just i just like to make pretty
pretty uh printed messages so let’s see where’s the suffix here i can’t even find it um how about
oh i should have put suffix instead of the number two that would have been better so what i wanted
to do is say your input was equal to and then print the number and then after that print an
exclamation just to prove to you how easy it is to to make a pretty message that’s formatted nicely
for the user um or your professor or whoever so uh you know you basically just print a number and
then you or sorry you print the prefix and then you print the number and then you print the suffix
suffix and then that’s the end of the true body and then since we’re done with the true body we
can basically just say all right now we’re done with the if so the next instruction that follows
is the done area again looking back at the example here that would be sort of like here after the
whole entire block was finished we’re ignoring the else in this code but you can imagine we’ll do
that soon so if the user’s number matched something we execute a true body if not we jump to the done
to the done area and if the user’s uh number did not match then we just immediately jump to the
done area so that we don’t do the true area and then we write comments to ourselves to help us
remember oh look here’s like the comparison and then here’s the body of true and then uh the done
area is like we could put another comment if we want we could say like this is done but i kind of
think like i kind of think the label is self-explanatory so let’s see if this worked it’s
was talking too fast we’ll run it and we’ll say 44. okay so nothing matched any of the numbers so
let’s type the number six so that we get a little message on the second one so i’m going to type the
number six and you can see it did not match the number five and it did match the number six so
we got that true block executing when we called on that function where the number to compare to
nothing there. So now we know simple if blocks.
The next thing we’re going to do is if else blocks.
All right.
So let’s see.
Not sure if I’m going to cut the video and split this up into multiple parts.
Probably would have been a smart idea.
Let me know if I ended up doing it.
We’re at about 25 minutes now.
But anyway,
so now we’re going to look at if else blocks.
if else blocks.
So I’m going to start off with another function.
I’m going to call it if else test.
So here’s the tester.
It called on if test.
And then I’m going to, you know, I had the if test function that I did previously.
And so now we’re just going to make an if else test function.
The if else test, it just has one input, one argument for input.
And we’re going to just sort of compare it against different values.
of compare it against different values we’re not going to call this multiple times with different
values to compare against so that means let’s see we only need to use one register so
i’ve designated r12 as the user’s input so that’s where we’re going to store it which means we
should preserve it in the prologue so i’m going to push r12 and then again if you don’t understand
some of the basic stuff that i’m that i’m skipping over see my other videos where i explained
to know to actually have this kind of a program. So I’m going to have a function that enters and
it returns at the end. It uses R12 so we will preserve it with a push pop pair.
And then the first thing that I should do is grab the user’s input from the first argument.
And if you’re respecting the ABI that means it should come from RDI. So I’m going to move RDI
somebody remind me that the first part of the program has to actually call this function or
nothing will happen. So we’re going to say hello. That’s just a simple message that we talked about
before. And then now we’re going to actually implement the if else block. So it’s like a
little bit more complicated than just the simple if block. It’s going to be this whole example that
we talked about before. Let me see. Maybe I should add the calls to this block real fast. So we have
to this block real fast so we have the if tester and then run the complex if else tests
right before r12 okay let me just double check that i’m making a call at the right spot here
so we have r12 and 7 and then epilog okay so now finally in our program we’re going to have a call
to um the if else test function that we’re just making right now
Okay, so we have that.
And let me find that source again real fast.
If else test, we got the prologue.
We take their input and then we say hello.
Okay, so now we need another label that begins the if block.
So what we’re doing is we’re checking to see if the user’s input was equal to five.
And then we’re going to say something if it was.
And otherwise, we’re going to do an else block on that.
block on that so again i like to write my comparison instructions with a blank expression
in terms of the c equivalent comment so notice how the we’re checking to see if r12 is equal to
five i put that on the next block because we’re going to jump to the to the true part of the if
block if it equals five so that’s why i put that there the comparison instruction pretty much just
compares r12 with five sets a bunch of values into the r flags registers so that we can later
so that we can later conditionally jump if we want to.
So basically we’ll jump to the true place if that was true.
And then if not, execution falls through to the next statement,
which will just jump to the else place.
So we need more labels is what I’m saying.
So now we need a body for if the statement was true
or the expression was true,
we want to be able to execute the true portion of the if block.
the if block so that’s this right here so we’re going to jump to if it did equal to five you
could imagine you know making a better label instead of equal five you could say first if
first else if complicated block true scope or true block or something but i just put equal to five
basically saying we’ll execute this code if it was equal to five so again we’re just kind of like
into this label equal five if r12 was indeed equal to five so that means if it was we execute
all this code right here we know we’re finished when we have the very last line saying let’s jump
to finish the the if else block again just just to clarify
we do the comparison first and if the comparison was true then we’ll jump into the true area so
you know we’ll jump into the true area and then all of these uh instructions get executed
instructions get executed but if we don’t have a way to jump out of that block then whoops
all of the else statements are going to get executed too right so we don’t want that
we don’t want to execute both the true and the false statements we want to have a jump instruction
at the very end i’ll put jmp just so that we jump to the to the end of the if else block
you know jump to the place where it’s just all over and finished
Okay, so now I’m going to look at, whoops, turn that off.
So we have equal five.
So we’re going to jump to if else test if done.
Let me just double check to make sure I’m not forgetting anything.
Oh, we need to jump here.
Basically meaning we’re going to jump into the else portion.
So here we covered jumping into the true portion, you know, the regular top block.
Now here we’re going to jump into the else portion.
We need a label and some code for that.
code for that so this is the else six begin i copy that oh man it’s starting to get kind of
hectic in my brain here the copy pasting is worse than actually writing the program
so uh if the comparison was not equal like if r12 was not equal then execution falls through
to line 216 and then we unconditionally jump to the l6 begin area which is like down here
like down here and then we’ll print something else.
We’ll, oh, we’ll, we’ll check again.
So we’re doing like, um, if else, if else.
Okay. So originally when I was talking about the, uh,
if else block, I didn’t do a,
I didn’t do like a very complex if else statement.
We’ll say a is greater than B something like that.
So I’ll just put a more code here just so you know that we can do if else,
if else blocks but just you know again keep in mind that every scope here that you’re going to
try to run based on some condition you just make it its own label and make sure that at the very
end of the scope you jump away so that you reach the very end of all this stuff because just as a
quick review if we are just writing in c or c plus plus only one of these blocks is going to execute
right like if a is equal to b then only that first block will execute the second and third blocks
will not execute it’ll jump after that all the way down to line 21 only if a does not equal b
do we even have the chance of checking to see if a is more than b if it’s false then we’ll have the
chance to check the else and if it’s true we will only execute the code in the line 12 block you
know imagine there are more statements there and when that block is done then we will jump to line
to b and a is not greater than b so just a quick uh you know c plus plus uh you know design pattern
review if else block review so we have like an else if here we’re going to say check if the input
was equal to six so we just do the same thing that we did before we compare r12 the user’s input with
six we jump if they were equal to the else if equals true block and if not execution falls
Less than 10 begin block. So this is going to be like really complicated
How many lines did I actually I think I got excited when I wrote this
Okay, else if equal six true
My challenge to you is to come up with labels that are like way easier than the labels that I came up with
All right, so we’re gonna do this I
Can almost guarantee that when I’m done copy pasting everything something is not going to compile because I forgot a label somewhere
Else if equals six true, okay
equals six true okay so what’s happening here again um uh so at this point you know the first
if uh expression was not true r12 was definitely not equal to five so we jumped down to else if
equal six begin which was here and so then we just make another comparison to see well okay it was
those two things weren’t equal it wasn’t equal to five so let’s check to see if it was equal to six
to yet another scope.
If it was false, we go down to line 237
and jump to yet another scope.
So here is what will get executed
if R12 was indeed equal to six,
and then we’re just basically gonna say it to the user
and then jump to the done label,
meaning like we’re totally done with our if else block.
Notice how the first if here,
when it was totally finished, it jumped to the done area.
this else if block is also jumping down to the if done area.
So eventually we’re going to need that label.
Okay.
So then next we’re going to check to see if the user’s input was equal to a 10.
So like kind of the same thing here.
We’re going to do another copy paste and we’re going to say, all right.
So if the user’s input was not equal to, let’s see,
if it was not equal to five, then we jump down here for our next comparison.
comparison we check to see if it’s equal to six if it was not equal to six then we jump down to
the less 10 begin line which is like all the way down here we do another comparison to see all right
well is it less than 10 you know if it was not equal to five or not equal to six then we check
is it less than 10 if it uh if it is then we uh jump to the else if equal less 10 true block which
I made this way too complicated. I realize that now, but it’s too late. I’m going for it, man.
Anyway, so if that statement is true, if R12 was indeed less than 10, then we jump to this block
and we basically just say that to the user and then we jump to the done. So finally, notice how
this part right here on line 259, it’s basically saying if R12 was not less than 10, then we’ll
then we’ll jump somewhere else notice how it’s just else right so this is like the very the very
bottom so i think the way that i wrote this uh code is uh we have two else ifs right we have like
an if five else if six else if less than 10 so maybe i could do something like this um if r12
r12 I think I said six just now right hopefully I actually did say six
otherwise if r12 is less than 10 then do some stuff otherwise if nothing else
matched then we’ll execute you know this block right here so again remember
every single scope has to have its own label so that you know where to jump and
it’s also a really really smart idea for every single scope to have you know
to have a little jump instruction that jumps past all of the if else if else if else stuff
so we’ll say like you know label you know done so that we can make sure that only one of these
blocks actually executes which is how you’re supposed to imagine c and c plus plus work
um and so it’s just complicated because there’s a lot of stuff to copy paste but you can just
still see you know only one of these blocks ever is supposed to execute so we give the first one
we jump into it if it’s true if it’s not true then we give the second one a chance
we jump into it if it’s true if not we jump to compare the third one if it’s true then we jump
to its scope if not we jump to the else and the else always executes if nothing else above
was true so that’s the basic idea here oh dear i’ve probably lost my place
looks like i just copy pasted less 10 true which was this right here so
so um less than true or less than 10 true okay so we told the user your stuff is less than 10
and then we jumped to the done area so that means we are probably working on the else area okay let
me grab that so now finally we’re going to have the else area which is going to you know finish
this all up that’s going to be after the if done so if nothing else matched then we will end up
nothing else matched then we will end up jumping to the else area and then we’ll basically
just tell the user none of the conditions seemed to have applied and then even at the
end of the else block even though you could probably get away with just letting execution
fall through just to save yourself one instruction you know you could comment that out assuming
you were sure that the very next instruction was the beginning of the done area but otherwise
I’m just going to play it safe and jump directly there then we have to make the actual done
So, just so you know, a label doesn’t have to have any instructions.
We could have something like this, if else test say goodbye.
We could have two labels right next to each other and one doesn’t actually have instructions.
That’s totally fine.
If you jumped to the done area, then execution would just fall through to the next valid
instruction which could go through another label.
So you know, we could have a say goodbye label and an if done label.
if done label, I’m just going to have the goodbye stuff happening inside of the done.
But for clarity’s sake, you might want to keep that label in there that I just deleted.
And all that we need to do at the very end when we’re done with everything is just say goodbye.
So I’m just printing a message.
So just to do a quick recap here, let’s see.
We come in with the user’s input as R12.
We ask, does R12 equal five?
If that’s true, we’ll say that it was equal to 5, and then we’ll go to the done area,
meaning we’ll skip past all the other blocks for the if-else block, or all the other scopes.
But if that did not equal 5, then we’ll fall through to that jump instruction,
which takes us to the next test, which is going to be our else-if equals 6.
So we are checking now to see if R12 is equal to 6.
If that’s true, we jump to this next block.
Why do we need to jump to a block that’s so close?
Well, if we don’t, then we’re going to end up definitely jumping to the next comparison
and you know, that wouldn’t work.
So we’re just kind of jumping over this unconditional jump statement and we’re saying, all right,
your input was definitely equal to six.
And then we’re jumping to the done area just past everything.
But if that wasn’t true, then we hit this unconditional jump that takes us to the next
comparison to see if the user’s input was less than 10.
You know, if that’s true, then we go to the true area to print another message and then
go to the done area.
If it was false, we fall through to the else jump, which will take us to here.
And notice how the else scope doesn’t actually make any comparisons because, you know, when
you have like an if else, sorry, when you have an if else if else if else if, you know,
any number of else if blocks, the else will always be executed if nothing above it actually
did execute.
execute so if you have an else block that means something will execute so we’re not doing any
comparisons we’re just saying you know when that scope is done we’re just going to jump to the done
area so all of these different scopes they’re jumping to the done area when they finish and
the done area is just this label right here where we say goodbye and that’s it let’s see did i copy
paste everything that i was supposed to i think so probably so let’s run the program and see if it
All right, it at least compiled.
So the basic if test, that was the first part of either this video or the previous video,
depending on whether I chose to split this up.
So let me comment out those calls real fast.
So I’m going to just comment out these calls real quick so we can only deal with the complicated
if else block.
So I’m going to enter like a three.
Whoops, let me do it again.
Three.
And so begin the if else test.
test your input was definitely less than 10 and then we end the if-else test so notice how only
one scope executed three was definitely less than 10 what other numbers did we have let me write
them down somewhere so I don’t forget oh they’re written down right here so we entered a three
which was definitely not a five and not a six so that’s why the less than 10 block executed maybe
only the first scope should execute so it says your input was equal to five notice how it didn’t
mention that it was a six or less than ten and then if we do a six it should just tell us that
we have a six it will not mention the five it will not mention the ten so we did we did five
already and then we did six and we did like a two which was less than ten we could also do a one
which was less than ten we can do anything that was less than ten and then the else would be if
And then the else would be if our input is probably like 11 or greater,
meaning it’s not less than 10 and it’s also not five or six.
Just we can see the else block.
So I’m going to do 11, which is the first number that should trigger the else block.
And it says no conditions were satisfied,
which was the message inside of our else block.
Let me just show you that again real fast.
This was the else block.
So message if else else or labeling on my port, I realize that.
But it basically says no conditions were satisfied.
The if else else.
I think that’s basically everything that I wanted to show you.
At this point, you should feel like you’re starting to become an expert at complicated
if else if else blocks, converting those from a higher level language into assembly.
assembly and I honestly recommend that you practice this like crazy while you’re trying
to get more used to it but you know hopefully you have everything you need at this point
keep in mind I’ve said this at the beginning I’ve actually I think I said this in a different video
when we use these branching instructions notice how I have jump equal to where’s that less than
yeah notice how I have a instruction jump less than the the family of conditional branching
conditional branching instructions that compares less than greater than less than or equal to
greater than or equal to the ones that I’m using here apply to signed integers and they won’t
necessarily work with unsigned integers and they won’t work with floats if you compare floats later
so just keep that in mind let me pull up my favorite book again real fast
where what the heck is that book oh dude where’s my document viewer document viewer can I get
document viewer can I get there there we go so I guess I didn’t introduce this
book at the beginning of this video but I probably should have this is my
favorite assembly book you can turn yourself into an expert with this book
by just on its own it’s open source and free the author gives this away he’s a
genius the person who wrote this book is a dr. Ed Jorgensen he’s a professor he
wrote this for his own classes and again it’s like a free open source book you
download a copy from his website if you look this up and and convert yourself
into an expert so let me collapse everything here and then I’ll go to
instruction set overview control instructions conditional control
instructions and I just want you to see real fast just as a recap I talked about
this in a previous video but when it comes to comparing things and checking
operands because if you want to see if two operands are equal you just check to see if
all of their bits are equal you don’t even really care whether they’re both integers or not
on the other hand notice how there is like a family here jump less than jump less than equal
to jump greater than jump greater than equal to that those instructions apply only if your
if they are unsigned or if you’re using floats for your comparisons you have to use this other family
of jump conditional branching instructions called jump below jump below equal jump above jump above
equal and i’m sure you can infer that jump below is the same thing as jump less than right jump
less than or equal to is the same thing as jump below or equal to it’s just that you need to use
a different instruction uh if you’re using signed integers or floats versus sorry sorry
a versus sorry sorry you need to use different instructions if you’re using signed integers
versus unsigned integers or floats so keep that in mind the code demo that i just showed you it’s
for signed integers if you were going to use unsigned integers or floats you would this
program wouldn’t work for you you’d need to replace my my branching instructions with the
the unsigned versions which i mean they work the same thing you’re still going to do a comparison
it still works. Anyway, so after having shown you that and making sure that everything actually
did work, I think we’ve talked about everything that we need to for this video. So yeah, I hope
you feel like an expert practice this on your own, you know, write your own programs just to make
sure you know how to convert a higher level language block into an assembly block. And you
should be on your way. Thank you for watching this video. I hope you learned a little bit of
bit of stuff and had a little bit of fun 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 world to me and it’ll help make more videos and grow this community.
So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.
So please do me a kindness and subscribe.
You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.
It just wakes me up and I get filled with joy.
That’s exactly what happens every single time.
So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.
just 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 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
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 enjoy the cool music as as I fade into the darkness which is
the darkness which is coming for us all.
Thank you.
