Tag Archives: MP

8086, 8086 TASM

8086 Assembly Program to Add Two 16-bit Numbers with Carry Handling

Leave a comment

In this blog post, we’ll explore an 8086 assembly language program that adds two 16-bit numbers while also checking for a carry flag.

; Data Segment

data segment
    a dw 0FFFFh      ; Example value that will cause a carry
    b dw 0001h       ; Example value
    c dw ?           ; To store result
    carry_flag db 0  ; To store carry (0 or 1)
data ends

; Code Segment

code segment
assume cs:code, ds:data
start:
    mov ax, data
    mov ds, ax      ; Initialize data segment

    mov ax, a       ; Load first number
    mov bx, b       ; Load second number
    add ax, bx      ; Perform addition

    mov c, ax       ; Store result in 'c'

    jc carry_occurred  ; Jump if carry flag is set
    mov carry_flag, 0  ; No carry, store 0
    jmp end_program    

carry_occurred:
    mov carry_flag, 1  ; Store carry flag as 1

end_program:
    int 3             ; Halt program

code ends
end start
Continue reading 8086 Assembly Program to Add Two 16-bit Numbers with Carry Handling →
Mix (C++ and Assembly), Snippets

Mix (C++ and Assembly) Program to Find Largest Number from Given Numbers

Leave a comment

This C++ program demonstrates how to find the largest element from a set of five integers using 8086 assembly instructions embedded directly into the code. The inline assembly helps perform comparisons and updates the result with the highest value found.

Continue reading Mix (C++ and Assembly) Program to Find Largest Number from Given Numbers →
Mix (C++ and Assembly), Snippets

Mix (C++ and Assembly) Program to Sort Numbers in Ascending Order

Leave a comment

This post demonstrates how to sort an array of integers using inline assembly in C++. Here, we perform sorting in ascending order by comparing and swapping adjacent elements using embedded assembly within a C++ program.

#include<iostream.h>
#include<conio.h>
void main()
{
    int a[5], x, y;
    int i, j;
    cout << "\n Enter 5 Numbers:";
    for(i = 0; i < 5; i++)
    {
        cin >> a[i];
    }
    //Sorting
    for(i = 0; i < 4; i++)
    {
        for(j = 0; j < 4; j++)
        {
            x = a[j];
            y = a[j + 1];
            _asm {
                mov ax, x
                mov bx, y
                cmp ax, bx
                jl nxt
                mov cx, ax
                mov ax, bx
                mov bx, cx
                mov x, ax
                mov y, bx
            }
            nxt:
            a[j] = x;
            a[j + 1] = y;
        }
    }
    cout << "\n Sorted Array:";
    for(i = 0; i < 5; i++)
        cout << a[i] << " ";
    getch();
}
Continue reading Mix (C++ and Assembly) Program to Sort Numbers in Ascending Order →
Mix (C++ and Assembly), Snippets

Mix (C++ and Assembly) Program to Find Smallest Number from Given Numbers

Leave a comment

This C++ program demonstrates how to find the smallest number from an array using inline 8086 assembly language instructions. The logic involves comparing each array element and storing the smallest found so far using cmp and conditional jump instructions.

#include<iostream.h>
#include<conio.h>

void main()
{
    short a[5], x, y, res;
    short i, j;
    y = 999; // Initialize with a large number

    cout << "\n Enter 5 Numbers:";
    for (i = 0; i < 5; i++) {
        cin >> a[i];
    }

    asm {
        mov bx, y
    }

    // Finding smallest
    for (i = 0; i < 5; i++) {
        x = a[i];
        asm {
            mov ax, x
            mov bx, y
            cmp ax, bx
            jnb nxt   // Jump if not below (i.e., current is not smaller)
            mov bx, ax
            mov y, bx
        }
    nxt:
    }

    asm {
        mov res, bx;
    }

    cout << "\n Smallest Element:" << res;
    getch();
}
Continue reading Mix (C++ and Assembly) Program to Find Smallest Number from Given Numbers →
8086, 8086 TASM, Snippets

8086 Assembly Program to Find Smallest Number from Given Numbers

3 Comments

​In this blog post, we’ll explore how to find the smallest number from a given set of values using an 8086 assembly language program. The following code snippet demonstrates this process:

data segment
STRING1 DB 08h,14h,05h,0Fh,09h
res db ?
data ends

code segment
assume cs:code, ds:data
start: mov ax, data
mov ds, ax
mov cx, 04h

mov bl, 79h
LEA SI, STRING1
up:
mov al, [SI]
cmp al, bl
jge nxt
mov bl, al
nxt:
inc si
dec cx
jnz up

mov res,bl
int 3
code ends
end start
Continue reading 8086 Assembly Program to Find Smallest Number from Given Numbers →
8086, 8086 TASM, Snippets

8086 Assembly Program to Sort Numbers in Descending Order

2 Comments

In this blog post, we will explore an 8086 assembly language program designed to sort a list of numbers in descending order. Sorting is a fundamental operation in computer science, and understanding how to implement it at the assembly level provides valuable insights into low-level programming and processor operations.

The following assembly program sorts an array of numbers in descending order using the bubble sort algorithm:

DATA SEGMENT
STRING1 DB 99H,12H,56H,45H,36H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV CH,04H
UP2: MOV CL,04H
LEA SI,STRING1

UP1:MOV AL,[SI]
MOV BL,[SI+1]
CMP AL,BL
JNC DOWN
MOV DL,[SI+1]
XCHG [SI],DL
MOV [SI+1],DL

DOWN: INC SI
DEC CL
JNZ UP1
DEC CH
JNZ UP2
INT 3
CODE ENDS
END START
Continue reading 8086 Assembly Program to Sort Numbers in Descending Order →