Assembly Instructions
We covered a lot so far that built the foundation for working with assembly, but so far we haven’t learned about the different instructions that are used to write an assembly program. Remember our warmup code? We used the mov and add instructions there. In this section, we dive deeper into those instructions.
You may say: “Why now?” Well, let me give you some context. To work with assembly language, we need 2 things (there’s more in reality, but for now these two are enough):
Registers & Memory
Instructions
You can see we already learned about different types of registers and memory addressing modes. The only thing left was instructions—so that’s what we tackle now.
Registers and memory are where we store data, but what do we do with that data? That’s where instructions come in. Using instructions, we work with the data and perform operations to solve specific problems. I hope that makes sense?
When we talk about instructions, it’s better to address one thing early: because assembly language is a low-level representation of machine language, it is tightly coupled to the CPU design. There are many CPU vendors out there, and each of them has its own way of doing things. Because of that, there is no single universal set of assembly instructions.
Let’s suppose we are very familiar with assembly programming. Still, one day you might come across an instruction that looks completely new. Why? Because that instruction is valid only for a specific vendor’s processor. In that case, we need to check that vendor’s documentation. Don’t worry—it’s not as hard as it sounds. If you understand the basics of assembly (what we are learning now), then adapting to a new instruction set is much easier.
Now, here’s the good news: while some instructions are vendor-specific, there are common categories of instructions that exist in almost every assembly language. And these are enough for us to start writing assembly programs as beginners. These categories are:
Data Transfer Instructions
Arithmetic and Logic Instructions
Control Flow Instructions
System Control Instructions
Control Flow Instructions
Control flow instructions are what make assembly programming more dynamic. So far, we’ve only learned about data and arithmetic or logical operations. That executes instruction after instruction in a line-wise manner.
But programming is not just about straight execution — it’s about making decisions, based on decisions either rejecting or accepting some instructions, temporarily going to different instructions but later coming back, etc.
This is exactly where control flow instructions come into play.
These instructions allow us to alter the normal flow of execution and jump through different sets of instruction blocks, we call it branching in assembly.
Jump to another part of the program.
Execute code only if a certain condition is true.
Repeat instructions in loops.
Call functions and return back when done.
Let’s go step by step, and we start with Jumping instructions. There are two categories of jump instructions available in assembly language.
Unconditional Jumps
Conditional Jumps
Below we dive deep into each of them:
Unconditional Jump (
JMP)The
JMPinstruction transfers execution to a different part of the program, no matter what. It doesn’t care about conditions — it just goes straight to the specified label.Syntax:
jmp <Label>
Types of Unconditional Jumps
Unconditional jumps are divided into two main categories:
Intrasegment jumps → jump inside the same code segment (only IP changes).
Intersegment jumps → jump to a different code segment (both CS and IP change).
1. Intrasegment Jumps
These jumps remain inside the current code segment. They only update the Instruction Pointer (IP).
Short Jump
Used when the target label is close (within -128 to +127 bytes from the current instruction).
Opcode: EB
Size: 2 bytes → 1 byte for opcode EB, 1 byte for displacement.
Example:
jmp short label1 ; Jump in (-128 to +127 range)
Near Jump
Used when the target is within the same segment, but the range is larger than short jump allows.
Opcode: E9
Size: 3 bytes → 1 byte for opcode E9, 2 bytes for displacement.
Example:
jmp near label2 ; Jump in (-32768 to +32768 range)
Fig 4.0: Short and Near Jump
2. Intersegment Jump
These jumps transfer control to a different code segment. That means both CS (code segment register) and IP (instruction pointer) are updated.
Far Jump
Opcode: EA
Size: 5 bytes → 1 byte for opcode EA, 2 bytes for new IP, 2 bytes for new CS.
Example:
jmp far ptr label3 ; Jump to another code segment
Examples:
jmp start ; Jump unconditionally to label 'start'
jmp exit ; Skip code and go directly to 'exit'
jmp short loop1 ; Example of short jumpConditional Jumps
Conditional jumps are the real deal when writing logic. They depend on the status of flags in the FLAGS register (set by arithmetic/logical instructions).
Common conditional jumps:
JE / JZ (Jump if Equal / Zero):
This jump changes the flow of instructions if and only if the zero flag (ZF) is 1. That happens when the result of the previous operation (often a comparison) was zero.
JE start ; Jump if ZF = 1 JZ start ; (same as JE)JNE / JNZ (Jump if Not Equal / Not Zero):
Works opposite to JE. It jumps if the zero flag (ZF) is 0, meaning the result of the previous operation was not zero.
JNE loop ; Jump if ZF = 0 JNZ loop ; (same as JNE)JG / JNLE (Jump if Greater):
This jump is taken if the zero flag (ZF) is 0 and the sign flag (SF) equals the overflow flag (OF). Used for signed comparisons where the left operand is greater.
JG greater_case ; Jump if ZF = 0 AND SF = OF JNLE greater_case ; (same as JG)JL / JNGE (Jump if Less):
This jump is taken when the sign flag (SF) is not equal to the overflow flag (OF). Used for signed comparisons where the left operand is less.
JL less_case ; Jump if SF ≠ OF JNGE less_case ; (same as JL)JGE / JNL (Jump if Greater or Equal):
This jump is taken when the sign flag (SF) equals the overflow flag (OF). Used for signed comparisons where the left operand is greater or equal.
JGE check_done ; Jump if SF = OF JNL check_done ; (same as JGE)JLE / JNG (Jump if Less or Equal):
This jump is taken when either the zero flag (ZF) is 1 or the sign flag (SF) is not equal to the overflow flag (OF). Used for signed comparisons where the left operand is less or equal.
JLE exit ; Jump if ZF = 1 OR SF ≠ OF JNG exit ; (same as JLE)
CMP Instruction (Compare)
Above we kept mentioning comparison again and again. Now let’s talk about it.
CMP is not a jump itself, but it is always used before conditional jumps. Its acronym is Compare but it doesn’t do it like we normally do. It basically subtracts things like the SUB instruction we learned in the Arithmetic and Logic instructions section but with one difference.
It subtracts the source from the destination internally, but it doesn’t store the result back, it just updates the flags. You may say what the hell, it doesn’t make sense? So I’ll try to explain the purpose with a simple example so the concept becomes more solid.
Working Example
Let’s say we have stored 5 in AX register and we want to compare if they are equal or not with the value placed in BX, let’s say 4. What we know about the cmp instruction: it subtracts things and updates the flags.
We do that here: ax - bx → 5 - 4 = 1 which is not zero, right?
We know the zero flag only becomes 1 if the answer is zero, but in this case it is not. Meaning the zero flag is 0. That’s the whole logic: if our answer is zero (only when both values are the same) then the zero flag becomes 1, which tells us that both numbers are equal. If not, then other flags will get updated based on the result, and we judge things from that. I hope it makes sense?
Now let’s see the syntax and examples of how compare instructions are written.
Syntax
cmp <Destination>, <Source>Examples
cmp ax, bx ; Compare AX with BX
je equal_case ; Jump if equalLOOP Instruction
When solving any problem, we often come to situations where we have to keep going through the same process with different results again and again. Let’s say we are writing a code to find a factorial. As we know, we have to keep multiplying the number with its previous number until the previous number becomes one.
Now let’s engineer this problem: we know the mul instruction is used for multiplication, and we have to find 4!. What we can do is write 4 mul instructions with subtracted 1 values. However, think of it: what if the number is larger or comes from the user? Now how do we deal with it? Should we have to keep writing the same instruction one by one, again and again? Nah, I don’t know about you but if I were you then I’d take Arts instead of Computer Science. 🎨
That’s where LOOP comes as a savior of programmers. The LOOP instruction is designed specifically for iteration to solve these kinds of problems, where we have to execute the same instructions again and again without writing 100 lines.
In assembly language we uses the CX register as a counter. That counts how many iterations are complete, and if it becomes zero that tell loop cycle to get finished.
Syntax
<Label>:
; instructions here
loop <Label>In the above syntax, we first define a label that tells where the loop branch starts. Later we write the actual loop instruction that transfers the control flow to that branch and keeps executing it until the cx register becomes 0.
Example
mov cx, 5 ; Repeat 5 times
start_loop:
; some code here
loop start_loopCALL Instruction
To understand the call instruction, let’s take an example first like we did in the Loop instruction above.
Imagine we’re solving a problem: we have 5 sets of numbers. For each set, we want to calculate the sum and the average.
The sum is easy — we can just use the add instruction again and again. Each set has five numbers, and we can go through them one by one using a loop.
For the average, we simply take the sum and divide it by the total count (which is 5). We can use the div instruction for that. Simple enough, right?
Well… yes. But here’s the catch: we don’t just have one set. We have to repeat the exact same process for each of the 5 sets. That’s still manageable — five sets, five sums, five averages.
But then the Lord of Numbers appears and says:
“I have thousands of sets waiting for you, and I’ll keep sending more.”
At that point, Sorry, I’m not a computer science student, I love Picasso. 🎨
To handle situations like we have functions, subroutines, or procedures. What we do in a function is branch all of the required steps one time, and later we just pass the data that we have to perform operations on. They perform operations and give the result back. We can reuse it again and again many time as we want.
In assembly we have the CALL instruction to call a procedure (function). It saves the current instruction pointer (next instruction) onto the stack and jumps to the given label.
Syntax
call <Label>Logical Flow
CPU pushes current IP (address of the next instruction) onto the stack.
Jumps to the procedure at
<Label>.Execute all the instruction in the labeled branch until
retinstruction come.When
retinstructions comes remove the current IP address from stack and jump back to next instruction after thecallinstruction.
Example
call my_func ; Call procedure 'my_func'
...
my_func:
; do something
retRET Instruction
In the above example of the call instruction notice we use ret at the end. The RET instruction does nothing but return control back to the location stored on the stack (the instruction after CALL).
Syntax
retLogical Flow
CPU pops the return address from the stack.
Loads it into IP (instruction pointer).
Execution resumes where it left off.
Last updated
Was this helpful?