MICROPROCESSOR.pptx Microprocessor lec 2

MICROPROCESSOR
Types Of Bus
Three Types of BUS
Address Bus: Carries memory Addresses
from the processor to other components
such as Primary storage and Input Out Put
Devices.
Data Bus: Carries the Data between the
processor and other Components.
Control Bus: Carries control signals from
the Processor to other Components.

MICROPROCESSOR
• Key Components Of a Motherboard
• Mouse and keyboard Connectors
• Universal Serial Bus(USB)
• CPU
• RAM Memory
• Bios System
• Chipset
• Cooling Fans
• Adopter Cards And Expansion Slots.

MICROPROCESSOR
• Functional Unit.
• 5 Functional Unit
INPUT
OUTPUT
MEMORY
ALU
CU

MICROPROCESSOR
• INPUT: Simple give input to system
• Input Devices Keyboard, Joysticks
• Coding Writing.
• OUTPUT: Display on Screen is output.
• Monitor And Mobile Screen
• MEMORY: Read /Write Operation retrieve Data by
Address
• ALU: Arithmetic And Logical Operation are performed.
• CU: To control all devices.

MICROPROCESSOR
• In assembly language, a "register" is a small, fast,
and directly accessible storage location within
the CPU (Central Processing Unit) of a computer.
Registers are used to hold data temporarily while
the CPU performs operations on that data. Think
of them as tiny, ultra-fast storage units that the
CPU can work with very quickly.
• Here are some key points about registers in
assembly language:

MICROPROCESSOR
•
In assembly language, a "register" is a small, fast, and directly accessible
storage location within the CPU (Central Processing Unit) of a computer.
Registers are used to hold data temporarily while the CPU performs
operations on that data. Think of them as tiny, ultra-fast storage units that
the CPU can work with very quickly.
• Here are some key points about registers in assembly language:
• Limited in Number: A CPU typically has a limited number of registers,
often referred to as the register file. The number and types of registers can
vary between different CPU architectures.
• Faster Access: Registers are much faster to access than main memory
(RAM). This speed is essential for the CPU to perform calculations and
execute instructions quickly.
• Data Storage: Registers can store various types of data, such as integers,
floating-point numbers, memory addresses, or special-purpose values like
flags.

MICROPROCESSOR
• Operands: When performing operations like
addition, subtraction, or logical comparisons, the
CPU often uses registers as operands. For example,
you might add the contents of two registers together
or compare a register's value with another value.
• Temporary Storage: Registers are used for
temporary storage during program execution. Data is
loaded into registers from memory, manipulated,
and then often stored back in memory if needed for
long-term storage.

MICROPROCESSOR
• Limited Capacity: Registers have limited capacity,
both in terms of the amount of data they can hold
and the number of available registers. This limitation
can impact the efficiency and complexity of
assembly code.
• Special-Purpose Registers: Some registers have
special roles, like the program counter (PC) that
keeps track of the current instruction being
executed, or the stack pointer (SP) used for
managing function calls and memory allocation.

MICROPROCESSOR
• In summary, registers in assembly language are
small, high-speed storage locations within the
CPU that are essential for performing
operations and manipulating data during
program execution. They play a crucial role in
the efficient functioning of a computer's
processor.

MOTHERBOARD
• A computer motherboard is a complex circuit
board that houses many components and
connections essential for a computer to
function. In a simple and easy-to-understand
way, here's a basic diagram of a computer
motherboard with the names of its key parts:

MOTHERBOARD
• Here are the key parts and their names:
• Expansion Slots: These are slots where you can
install additional cards like graphics cards, sound
cards, or network cards.
• CPU Socket: The central processing unit (CPU) fits
into this socket, and it's the brain of the computer.
• RAM Slots: Random Access Memory (RAM) modules
are inserted into these slots to provide temporary
storage for data that the CPU is currently using.

MOTHERBOARD
• Northbridge: This chip connects the CPU to
high-speed components like RAM and graphics
cards.
• Southbridge: The Southbridge chip handles
communication with slower components like
storage devices and peripheral ports.
• CMOS Battery: A small battery that powers the
motherboard's CMOS memory, which stores
BIOS settings.

MOTHERBOARD
• BIOS Chip: This chip contains the Basic
Input/Output System (BIOS) firmware, which
initializes the computer's hardware during
startup.
• SATA Connectors: Used to connect Serial ATA
hard drives and optical drives.
• IDE Connector: An older type of connector for
connecting IDE hard drives and optical drives.

MOTHERBOARD
• PCI or PCIe Slots: Peripheral Component
Interconnect (PCI) or PCIe slots are used for
adding various expansion cards.
• USB Connectors: These ports are used for
connecting USB devices like keyboards, mice,
and external drives.
• Ethernet Port: Used for connecting to a wired
network.

MOTHERBOARD
• Audio Connectors: Ports for connecting
speakers, microphones, and headphones.
• Power Connector: This is where the computer's
power supply unit (PSU) connects to provide
power to the motherboard and other
components.
• Front Panel Connectors: These are used for
connecting buttons, LEDs, and audio jacks on
the front of the computer case.

MOTHERBOARD
• Integrated Components: This section includes
components like graphics chips (if integrated),
sound chips, and networking chips that are built
directly into the motherboard.
• This should give you a basic understanding of the
key parts of a computer motherboard and their
functions. Keep in mind that modern motherboards
may have additional components and features
depending on their specific design and purpose.

FLAGS
• In assembly language programming, flags are single-bit
indicators that provide information about the outcome of
various operations. These flags are typically set or cleared
based on the results of arithmetic or logical operations,
and they are used to control program flow, make
decisions, and check for conditions. The most common
flags in assembly language are:
• Zero Flag (ZF): This flag is set (ZF = 1) if the result of an
operation is zero. It is cleared (ZF = 0) if the result is non-
zero. You can use this flag to check if two values are
equal.

FLAGS
• Carry Flag (CF): The carry flag is set if an operation
generates a carry-out from the most significant bit. It's often
used in multi-byte arithmetic to detect overflows and
underflows.
• Overflow Flag (OF): The overflow flag is set if an operation
generates a signed overflow. For example, if the result of a
signed addition is too large to be represented, OF is set.
• Sign Flag (SF): This flag reflects the sign (positive or
negative) of the result of an operation. If the result is
negative, SF is set (SF = 1); otherwise, it's cleared (SF = 0).

FLAGS
• Parity Flag (PF): The parity flag is set if the number of
set bits in the result is even. It's used for simple error
checking and detection.
• Adjust Flag (AF): This flag is used in binary-coded
decimal (BCD) arithmetic. It's set if there is a carry-out
from the low nibble (4 bits) to the high nibble.
• Direction Flag (DF): The direction flag is used with
string operations. When DF is set, string operations
(e.g., moving data) decrement the memory addresses;
when cleared, they increment them.

FLAGS
• Interrupt Flag (IF): This flag enables or
disables interrupts. When IF is set, interrupts
are allowed; when cleared, they are disabled.
• Trap Flag (TF): The trap flag is used for
debugging purposes. When set, it causes the
processor to execute one instruction at a time,
facilitating step-by-step debugging.

FLAGS
• You can typically access and manipulate these
flags using conditional branch instructions
(e.g., JZ for Zero Flag, JO for Overflow Flag)
and other instructions that affect the flags
directly (e.g., ADD, SUB, AND, OR, etc.).
Understanding and working with flags is
essential in assembly programming to
implement logic and control flow effectively.

SIGNED
• In assembly language programming, signed
overflow occurs when an arithmetic operation
generates a result that is too large or too small
to be represented within the allotted number
of bits for a signed integer data type. Signed
integers use a bit to represent the sign
(positive or negative) of the number, and the
remaining bits represent the magnitude of the
number.

SIGNED
• For example, consider a 4-bit signed integer:
• The most significant bit (MSB) is the sign bit (0
for positive, 1 for negative).
• The remaining 3 bits represent the magnitude of
the number.
• In a 4-bit signed integer, the valid range is
typically from -7 to +7 (including 0). Here are
some examples of signed overflow in this
context:

SIGNED
• Positive Overflow: If you add two positive numbers and
the result is larger than +7, you have a positive overflow.
For instance, adding +6 and +3 would result in +9, which
cannot be represented in 4 bits, so it overflows.
• Negative Overflow: If you subtract two negative
numbers, and the result is smaller than -8 (or less than
the minimum representable value), you have a negative
overflow. For example, subtracting -3 from -5 would
result in -2, which is less than -7 (the minimum
representable value).

SIGNED
• Mixed Overflow: When you mix positive and
negative numbers in an operation and the
result goes beyond the representable range,
you have a mixed overflow. For example,
adding +5 and -7 would result in -2, which is
outside the valid range of -7 to +7.

SIGNED
• Detecting signed overflow is crucial in assembly
programming because it can lead to incorrect results or
unintended behavior in your programs. Many assembly
languages provide instructions or flags (such as the
Overflow Flag, often denoted as OF) that you can check
after arithmetic operations to determine if signed
overflow has occurred. Typically, you would use
conditional branch instructions to handle overflow cases
appropriately, such as branching to an error-handling
routine or taking some other corrective action.

SIGNED
• A signed integer is a data type used in
programming to represent whole numbers,
both positive and negative, including zero. The
term "signed" indicates that this data type
includes a sign bit to represent the sign of the
number (positive or negative).

SIGNED
• Here are some key characteristics of signed integers:
• Sign Bit: In a signed integer, one of the bits is reserved
to represent the sign of the number. Typically, the
most significant bit (MSB) is used for this purpose. If
the sign bit is 0, it indicates a positive number, and if
it's 1, it indicates a negative number.
• Magnitude: The remaining bits (excluding the sign bit)
represent the magnitude or absolute value of the
integer. These bits store the actual value of the
integer, ignoring its sign.

SIGNED
• Range: The range of values that can be
represented by a signed integer depends on the
number of bits allocated for it. For example:
• A signed 8-bit integer can represent values from -
128 to +127.
• A signed 16-bit integer can represent values from
-32,768 to +32,767.
• A signed 32-bit integer can represent values from
-2,147,483,648 to +2,147,483,647.

SIGNED
• Two's Complement: Most computer architectures use a
two's complement representation for signed integers. In
two's complement, negative numbers are represented by
flipping the bits (complementing) and adding 1 to the
positive representation of the number. This representation
simplifies arithmetic operations on signed integers.
• Here's an example in 8-bit binary:
• Positive 5: 0000 0101 (sign bit = 0, magnitude = 5)
• Negative -5: 1111 1011 (sign bit = 1, magnitude = 0101,
two's complemented)

SIGNED
• Signed integers are commonly used in
programming languages like C, C++, Java, and
many others to represent a wide range of
values, from simple counters to financial
transactions and beyond. Understanding the
representation and range of signed integers is
essential to avoid overflow and underflow
issues when performing arithmetic operations
on them.

REGISTERS
• Assembly language programming typically involves
working with registers, which are special storage
locations within a computer's central processing
unit (CPU). Registers are used to store data
temporarily during program execution, perform
arithmetic and logical operations, and facilitate data
movement. Registers have specific names and
purposes, and their availability and organization can
vary depending on the CPU architecture. Here are
some common registers and their typical roles:

REGISTERS
• General-Purpose Registers:
• EAX (Accumulator Register): Often used for arithmetic
and data manipulation operations. It's also the
destination register for most multiplication and division
instructions.
• EBX (Base Register): Used as a base address in memory
access operations.
• ECX (Counter Register): Often used as a loop counter.
• EDX (Data Register): Used in arithmetic operations
along with EAX or as a data register.

REGISTERS
• Segment Registers (x86 architecture):
• CS (Code Segment): Holds the base address of
the code segment.
• DS (Data Segment): Holds the base address of
the data segment.
• ES (Extra Segment): Used for additional data
segment operations.
• SS (Stack Segment): Holds the base address of
the stack segment.

REGISTERS
• Index Registers (x86 architecture):
– ESI (Source Index): Used for source data pointer
operations, often in string operations.
– EDI (Destination Index): Used for destination data
pointer operations, often in string operations.
• Pointer Registers (x86 architecture):
– EBP (Base Pointer): Used to point to the base of the
current stack frame in function calls.
– ESP (Stack Pointer): Points to the top of the stack,
used for managing the stack.

REGISTERS
• Flags Register (x86 architecture):
– EFLAGS (Flags Register): Contains individual bits
(flags) that indicate the status of various CPU
operations. Common flags include the Zero Flag
(ZF), Carry Flag (CF), Overflow Flag (OF), and
others.
• Instruction Pointer (IP):
– EIP (Instruction Pointer): Points to the memory
address of the next instruction to be executed.

REGISTERS
• Floating-Point Registers (x86 architecture):
– FPU Registers (ST0 to ST7): Used for floating-point
arithmetic operations.
• SIMD Registers (x86 architecture):
– XMM0 to XMM15: Used for Single Instruction,
Multiple Data (SIMD) operations, such as
multimedia processing and vector arithmetic.

REGISTERS
• It's important to note that the exact names and number
of registers can vary between CPU architectures (e.g.,
x86, ARM, MIPS) and specific models within those
architectures. Additionally, some CPU architectures have
more specialized registers for specific purposes.
• Assembly language programmers must be familiar with
the register set provided by their target CPU
architecture and understand how to use registers
effectively for data manipulation, control flow, and
memory access.

Addressing Modes
• In computer architecture and assembly language
programming, addressing modes are a set of rules
that dictate how the CPU accesses memory or
registers to perform operations. These addressing
modes define the way operands are specified
within machine instructions. Different CPU
architectures support various addressing modes,
and each mode has its advantages and use cases.
Here are some common addressing modes:

Addressing Modes
• Immediate Addressing Mode: In this mode, the operand
value is directly encoded within the instruction itself. For
example, MOV AX, 5 would load the value 5 into the AX
register. Immediate addressing is useful for constants and
small values that are known at compile time.
• Register Addressing Mode: In this mode, the operand is a
register, and the instruction operates on the content of
the specified register. For example, ADD AX, BX would add
the contents of registers AX and BX. Register addressing is
efficient for performing operations on data already in
registers.

Addressing Modes
• Direct Addressing Mode: This mode specifies a memory
address directly in the instruction. For example, MOV AL,
[1000] loads the value at memory address 1000 into
register AL. Direct addressing is useful when the exact
memory location is known.
• Indirect Addressing Mode: In this mode, the instruction
specifies a memory address that contains the actual
address of the operand. For example, MOV AL, [BX] loads
the value from the memory address stored in the BX
register into AL. Indirect addressing is often used in
pointer manipulation.

Addressing Modes
• Indexed Addressing Mode: This mode involves adding an
offset to a base address to calculate the memory location
of the operand. For example, MOV AX, [SI+10] loads the
value from the memory location at address SI + 10 into
AX. Indexed addressing is helpful for iterating over arrays
or data structures.
• Base-Indexed Addressing Mode: Combines both a base
address and an index offset. It's often used for more
complex data structures and multi-dimensional arrays. For
example, MOV AX, [BX+SI] loads the value from the
memory location at address BX + SI into AX.

Addressing Modes
• Relative Addressing Mode: Used primarily in branch
instructions, this mode specifies an offset relative to the
current program counter (PC) or instruction pointer (IP). For
example, JMP +5 would jump to the instruction five bytes
ahead of the current instruction. Relative addressing is crucial
for implementing conditional and unconditional jumps.
• Stack Addressing Mode: This mode involves pushing data
onto the stack or popping data from the stack. The stack
operates as a last-in, first-out (LIFO) data structure, and this
addressing mode is essential for function calls and managing
local variables.

Addressing Modes
• Indexed with Displacement Addressing Mode: Similar to
indexed addressing but includes a constant displacement
value. This mode is useful when you need to access
elements of a data structure with an offset. For example,
MOV AX, [BX+SI+10] loads the value from memory at
address BX + SI + 10 into AX.
• Different CPU architectures may support a subset of these
addressing modes, and assembly language programmers
need to understand and choose the appropriate
addressing mode for their specific tasks to optimize code
efficiency and readability.

OFFSET
• The term "offset" is commonly used in
computer programming and computer
systems in various contexts. It generally refers
to a displacement or a relative distance from a
reference point, often used to locate or access
data or memory locations. Here are a few
common uses of the term "offset" in
computing:

OFFSET
• Memory Offset: In memory addressing, an
offset is an integer value that represents the
distance between a reference point (usually a
base address) and a specific memory location.
When combined with the base address, it
allows you to access a particular memory
location. For example, if you have a base
address of 1000 and an offset of 20, you can
access memory location 1020.

OFFSET
• File Offset: In file operations, particularly when reading
or writing files, an offset represents the position within
the file where data should be read from or written to.
It's often used in functions like fseek in C/C++ to set the
file pointer to a specific offset within a file.
• Stack Offset: In the context of a call stack, an offset is
used to access local variables and parameters within a
function. The offset indicates how far from the current
stack frame's base pointer (BP or EBP in x86 assembly,
for example) a variable or parameter is located.

OFFSET
• Data Structure Offset: When dealing with complex data
structures, like structs or classes, an offset may be used
to access individual fields or members within the
structure. It specifies the position of the member
relative to the beginning of the structure.
• Instruction Offset: In the context of assembly language
or machine code, an instruction offset represents the
relative position of an instruction within the program
code. It's used in branch or jump instructions to specify
where to transfer control within the program.

OFFSET
• Relative Offset: This is a more general term referring to the
difference or distance between two values or positions. For
example, a relative offset could describe how much one
element in an array is distant from another element.
• Offsets are a fundamental concept in low-level
programming, and they are used extensively to navigate
memory, files, data structures, and program control flow.
Understanding and manipulating offsets correctly is crucial
for writing efficient and correct code in these domains.

Instruction Sets including Data Movement
• An instruction set in computer architecture is
a collection of instructions that a computer's
central processing unit (CPU) can execute.
These instructions cover a wide range of
operations, including data movement,
arithmetic and logical operations, control flow,
and more. Here, I'll provide an overview of
data movement instructions commonly found
in many instruction sets:

• Load and Store Instructions:
• LOAD: These instructions are used to load data from
memory into registers or other storage locations.
– LOAD R1, [Memory Address]: Load data from memory at
the specified address into register R1.
• STORE: These instructions are used to store data
from registers or memory to other memory
locations.
– STORE R2, [Memory Address]: Store the contents of
register R2 to the memory location at the specified
address.

• Move and Copy Instructions:
– MOVE: These instructions are used to copy data from one
location to another.
• MOVE R3, R4: Copy the contents of register R4 into register R3.
• Push and Pop Instructions:
– PUSH: Push data onto the stack (used in stack-based
architectures).
• PUSH R5: Push the contents of register R5 onto the stack.
– POP: Pop data from the stack (used in stack-based
architectures).
• POP R6: Pop the top value from the stack and store it in register R6.

• Exchange Instructions:
– EXCHANGE: Swap the contents of two registers or memory
locations.
• EXCHANGE R7, R8: Swap the contents of registers R7 and R8.
• Load Immediate Instructions:
– LOAD IMMEDIATE: Load an immediate (constant) value into a
register.
• LOAD R9, 42: Load the value 42 into register R9.
• Load Effective Address (LEA):
– LEA: Calculate the effective memory address of a variable or label
and load it into a register.
• LEA R10, [Label]: Load the effective address of "Label" into register R10.

• Data Copy and Move Operations:
– Some architectures offer specialized instructions for data
movement and copying, like block copy and move instructions,
which can efficiently transfer blocks of data between memory
locations.
• These are general categories of data movement instructions
commonly found in instruction sets. The specific instructions
and their syntax can vary significantly between CPU
architectures (e.g., x86, ARM, MIPS, etc.) and programming
languages. Assembly language programmers use these
instructions to manipulate data efficiently, manage memory,
and control program flow.

Arithmetic AND Logic
• In assembly language programming, arithmetic and
logic operations are fundamental components used
to manipulate data and control program flow.
Assembly language is a low-level programming
language that provides a one-to-one
correspondence between the instructions executed
by a computer's central processing unit (CPU) and
the machine code that the CPU understands. Here's
how arithmetic and logic operations are typically
used in assembly language:

• Arithmetic Operations:
• Addition: Assembly language provides
instructions for adding two values together. For
example, on the x86 architecture, the ADD
instruction is used to add values from registers or
memory locations.
• Assembly Copy code
• ADD AX, BX ; Add the contents of registers AX
and BX

• Subtraction: Subtraction is accomplished using the SUB
instruction, which subtracts one value from another.
• SUB CX, DX ; Subtract the contents of register DX from CX
• Multiplication: Assembly languages often have
instructions for multiplication, such as MUL (multiply).
For example, on x86, you can multiply the contents of
two registers or memory locations.
• MUL SI ; Multiply the contents of SI register with AX
register

• Division: Division is performed using the DIV instruction. It
divides one value by another and stores the quotient and
remainder.
• DIV BX ; Divide AX by the value in BX; quotient in AX, remainder
in DX
• Logic Operations:
• AND Operation: The AND operation is used to perform a
bitwise AND operation between two values. It sets each bit in
the result to 1 if both corresponding bits in the operands are 1.
• AND AL, 0Fh ; Perform a bitwise AND between AL and 0Fh

• OR Operation: The OR operation performs a bitwise OR
between two values, setting each bit in the result to 1 if at
least one corresponding bit in the operands is 1.
• OR BH, 20h ; Perform a bitwise OR between BH and 20h
• XOR Operation: The XOR operation performs a bitwise XOR
(exclusive OR) between two values, setting each bit in the
result to 1 if the corresponding bits in the operands are
different.
• XOR DL, 0FFh ; Perform a bitwise XOR between DL and 0FFh

• NOT Operation: The NOT operation inverts the bits of a
value, changing 1s to 0s and vice versa.
• NOT CX ; Invert all bits in the CX register
• These arithmetic and logic operations are used to perform
calculations, make decisions based on the values of registers
or memory locations, and control the flow of programs in
assembly language. Additionally, assembly language
instructions often involve moving data between registers and
memory locations before performing these operations.
Understanding these operations is crucial for writing efficient
and precise assembly language programs.

BITWISE
• Bitwise operations in assembly language and
programming involve manipulating individual
bits within binary representations of numbers.
These operations are commonly used for tasks
such as setting or clearing specific bits, checking
the state of particular bits, or combining or
separating bits within binary data. Bitwise
operations are crucial when working with low-
level data manipulation and bitwise flags.

BITWISE
• Here are the common bitwise operations:
• Bitwise AND (&): This operation performs a
bitwise AND on each pair of corresponding bits
between two binary numbers. The result will
have a 1 in each position where both operands
have a 1.
• Example in C:
code is
• int result = num1 & num2;

BITWISE
• Bitwise OR (|): This operation performs a
bitwise OR on each pair of corresponding bits
between two binary numbers. The result will
have a 1 in each position where at least one of
the operands has a 1.
• Example in C:
• code is
• int result = num1 | num2;

BITWISE
• Bitwise XOR (^): This operation performs a bitwise XOR
(exclusive OR) on each pair of corresponding bits
between two binary numbers. The result will have a 1 in
each position where exactly one of the operands has a 1.
• Example in C:
• code
• int result = num1 ^ num2;
• Bitwise NOT (~): This operation inverts all the bits in a
binary number, changing 1s to 0s and vice versa.
• Example in C:
• code
• int result = ~num;

BITWISE
• Bitwise Shift Left (<<): This operation shifts the
bits of a binary number to the left by a specified
number of positions. It effectively multiplies the
number by 2 raised to the power of the shift
amount.
• Example in C:
code
• int result = num << 2; // Shift num 2 positions to
the left

BITWISE
• Bitwise Shift Right (>>): This operation shifts the
bits of a binary number to the right by a specified
number of positions. It effectively divides the
number by 2 raised to the power of the shift
amount.
• Example in C:
• code
• int result = num >> 3; // Shift num 3 positions to
the right

BITWISE
• Bitwise operations are used extensively in low-
level programming, such as in assembly language
programming, embedded systems development,
and device driver development. They are also
used for various tasks like setting and clearing
specific flags in control registers, encoding and
decoding data, and performing bit-level
optimizations. Understanding how to use bitwise
operations efficiently is important when working
with binary data and hardware interfaces.

XOR
• The XOR (exclusive OR) operation is a bitwise
operation that compares two binary values bit
by bit. It returns a result where each bit in the
output is set to 1 if the corresponding bits in
the input values are different (one bit is 1 and
the other is 0), and it returns 0 if the
corresponding bits are the same (both 0 or
both 1).

PROGRAM CONTROL
• Program control in assembly language involves
using instructions and constructs specific to the
architecture to manage the flow of execution in
a program. Assembly language provides low-
level control over a computer's hardware,
allowing for precise manipulation of registers,
memory, and program counter (instruction
pointer). Here are some common program
control mechanisms in assembly language:

PROGRAM CONTROL
• Branching Instructions: Assembly language typically
includes conditional and unconditional branching
instructions to change the flow of execution. These
instructions allow you to jump to different parts of the
program based on specific conditions or without conditions.
• JMP (Jump): This is an unconditional jump instruction that
transfers control to a specified memory address.
• JE, JNE, JZ, JNZ, etc. (Jump if Equal, Jump if Not Equal, Jump
if Zero, Jump if Not Zero): These are conditional jump
instructions that transfer control based on the outcome of a
previous comparison or operation.

PROGRAM CONTROL
• Conditional Execution: Assembly languages often
include conditional execution instructions like CMP
(compare) and TEST (bitwise AND) to set flags based on
the outcome of comparisons. Conditional jumps are
then used to decide the next instruction to execute
based on these flags.
• Loops: Assembly languages provide instructions for
creating loops. For example, you can use CX or ECX
(counter) register along with LOOP or LOOPZ/LOOPE and
LOOPNZ/LOOPNE instructions to create loops that
repeat a block of code a specified number of times or
until a condition is met.

PROGRAM CONTROL
• Procedure Calls and Returns: Assembly languages
support subroutine calls and returns. The CALL
instruction transfers control to a specified
subroutine or function, and the RET instruction
returns control to the calling code.
• Interrupts: Many assembly languages support
interrupts, which are mechanisms for
asynchronously transferring control to predefined
interrupt service routines (ISRs) when specific
hardware events occur, such as hardware interrupts
or system calls.

PROGRAM CONTROL
• Conditional Execution Flags: Assembly languages
maintain condition flags, like the Zero Flag (ZF) or
Carry Flag (CF), which can be tested using conditional
jump instructions. These flags reflect the results of
arithmetic and logic operations, allowing you to
control the flow based on these results.
• GOTO-Like Control: Although structured
programming principles discourage the use of GOTO-
like instructions, assembly languages often provide
unconditional jump instructions (JMP) that can be
used for unstructured control flow when needed.

PROGRAM CONTROL
• MOV AX, 10 ; Load 10 into AX CMP AX, 5 ; Compare
AX with 5 JGE greater ; Jump to "greater" if AX is
greater than or equal to 5 ; Code here executes if AX
is less than 5 JMP end ; Jump to the end greater: ;
Code here executes if AX is greater than or equal to 5
end: ; Rest of the program.
• his code uses conditional jumps (JGE) to control the
flow based on the comparison result between AX
and 5. If AX is greater than or equal to 5, it jumps to
the "greater" label; otherwise, it falls through to the
next instruction.

MICROPROCESSOR.pptx Microprocessor lec 2

More Related Content

Similar to MICROPROCESSOR.pptx Microprocessor lec 2 (20)

More from Abdul salam (16)

Recently uploaded (20)

MICROPROCESSOR.pptx Microprocessor lec 2