Home » Posts filed under assembly language

Monday, October 10, 2016

calculate students grade and display using assembly language

Posted by Maaz Ali at 12:16 AM Labels: assembly language , assembly language programs 0 comments

Problem

Calculate grade of the students by adding subject marks input by the user. Display the grade to the user.

Code

include irvine32.inc

.data

array1 sdword 10 dup(?)

array2 sdword 10 dup(?)

array3 sdword 10 dup(?)

array4 sdword +100,+100,+100,+100,+100

array5 sdword +100,+100,+2,+2,+100

mul_array sdword 32 dup(0)

mine dword ?

temp dword 0

temp1 dword 0

temp2 dword 0

two dword 2

student1_msg byte " -*-*-*-*-*- Student # 01 -*-*-*-*-*-*-",0

student2_msg byte " -*-*-*-*-*- Student # 02 -*-*-*-*-*-*-",0

la_marks_msg byte " LA = ",0

ms_marks_msg byte " MS = ",0

ds_marks_msg byte " DS = ",0

algo_marks_msg byte " ALGO = ",0

coal_marks_msg byte " COAL = ",0

grade_msg byte "Grade = ",0

grade_f_msg byte "F",0

grade_c_msg byte "C",0

grade_b_msg byte "B",0

grade_a_msg byte "A",0

num1_msg byte "Enter 1st value: ",0

num2_msg byte "Enter 2nd value: ",0

equation_msg byte "Solving the equation: ",0ah,0dh,0

result byte " Result = ",0

even1_msg byte " 1st number is even.",0ah,0dh,0

even2_msg byte " 2nd number is even.",0ah,0dh,0ah,0dh,0

pos_msg byte "1st number is positive.",0ah,0dh,0

pos1_msg byte "2nd number is positive.",0ah,0dh,0

odd_msg byte " one number is odd.",0ah,0dh,0ah,0dh,0

neg_msg byte "number is negative.",0ah,0dh,0

ans_msg byte "Answer = ",0

.code

main proc

comment !

mov esi, offset array1

mov edi, offset array2

mov ebp, offset array3

mov ecx, 10

main_loop:

mov edx, offset num1_msg

call writestring

call readint

mov [esi], eax

mov edx, offset num1_msg

call writestring

call readint

mov [edi], eax

mov eax, [esi]

cmp eax, 0

jge positive_value1

jmp negative_value1

positive_value1:

mov edx, offset pos_msg

call writestring

mov eax, [edi]

cmp eax, 0

jge positive_value2

jmp negative_value1

positive_value2:

call positive

jmp jmp_to_loop

negative_value1:

call negative

jmp_to_loop:

add esi, 4

add edi, 4

add ebp, 4

loop main_loop

mov esi, offset array4

mov edi, offset array5

mov ecx, 5

mov ebp, offset array3

l1:

call crlf

mov eax, [ebp]

;call writeint

mov [esi], eax

add ebp, 4

add esi,4

loop l1

mov ecx, 5

l2:

call crlf

mov eax, [ebp]

;call writeint

mov [edi], eax

add ebp, 4

add edi, 4

loop l2

mov esi, offset array4

mov ecx, 5

l3:

call crlf

mov eax, [esi]

cmp eax, 0

jl negative_to_positive

mov eax, [esi]

cmp eax, 100

ja make_it_100

jmp normal_execution

negative_to_positive:

mov ebx, -1

imul ebx

cmp eax, 100

ja make_it_100

jmp normal_execution

make_it_100:

mov eax, 100

mov [esi], eax

normal_execution:

call writeint

add esi, 4

loop l3

call crlf

mov edi, offset array5

mov ecx, 5

l4:

call crlf

mov eax, [edi]

cmp eax, 0

jl negative_to_positive_1

mov eax, [edi]

cmp eax, 100

ja make_it_100_1

jmp normal_execution_1

negative_to_positive_1:

mov ebx, -1

imul ebx

cmp eax, 100

ja make_it_100

jmp normal_execution_1

make_it_100_1:

mov eax, 100

mov [edi], eax

normal_execution_1:

call writeint

add edi, 4

loop l4

mov edx, offset student1_msg

call writestring

call crlf

mov edx, offset coal_marks_msg

call writestring

mov eax, array4

call writeint

call crlf

mov edx, offset ms_marks_msg

call writestring

mov eax, [array4+4]

call writeint

call crlf

mov edx, offset ds_marks_msg

call writestring

mov eax, [array4+8]

call writeint

call crlf

mov edx, offset algo_marks_msg

call writestring

mov eax, [array4+12]

call writeint

call crlf

mov edx, offset la_marks_msg

call writestring

mov eax, [array4+16]

call writeint

call crlf

mov edx, offset grade_msg

call writestring

mov esi, offset array4

mov ecx, 5

mov eax, 0

l5:

mov ebx, [esi]

add eax, ebx

;call writeint

add esi, 4

loop l5

cmp eax, 399

ja grade_A

cmp eax, 299

ja grade_B

cmp eax, 199

ja grade_C

cmp eax, 0

ja grade_F

jmp grading_L3

grade_A:

mov edx, offset grade_a_msg

call writestring

jmp grading_L3

grade_B:

mov edx, offset grade_b_msg

call writestring

jmp grading_L3

grade_C:

mov edx, offset grade_c_msg

call writestring

jmp grading_L3

grade_F:

mov edx, offset grade_f_msg

call writestring

grading_L3:

call crlf

mov edx, offset student2_msg

call writestring

call crlf

mov edx, offset coal_marks_msg

call writestring

mov eax, array5

call writeint

call crlf

mov edx, offset ms_marks_msg

call writestring

mov eax, [array5+4]

call writeint

call crlf

mov edx, offset ds_marks_msg

call writestring

mov eax, [array5+8]

call writeint

call crlf

mov edx, offset algo_marks_msg

call writestring

mov eax, [array5+12]

call writeint

call crlf

mov edx, offset la_marks_msg

call writestring

mov eax, [array5+16]

call writeint

call crlf

mov edx, offset grade_msg

call writestring

mov edi, offset array5

mov ecx, 5

mov eax, 0

l6:

mov ebx, [edi]

add eax, ebx

add edi,4

;call writeint

loop l6

cmp eax, 399

ja grade_A_1

cmp eax, 299

ja grade_B_1

cmp eax, 199

ja grade_C_1

cmp eax, 0

ja grade_F_1

jmp grading_L4

grade_A_1:

mov edx, offset grade_a_msg

call writestring

jmp grading_L4

grade_B_1:

mov edx, offset grade_b_msg

call writestring

jmp grading_L4

grade_C_1:

mov edx, offset grade_c_msg

call writestring

jmp grading_L4

grade_F_1:

mov edx, offset grade_f_msg

call writestring

grading_L4:

call crlf

;call equation

call crlf

exit

main endp

positive proc

mov edx, offset pos1_msg

call writestring

mov edx, 0

mov eax, [esi]

cdq

idiv two

cmp edx, 0

je even_value1

jmp odd_value1

even_value1:

call crlf

mov edx, offset even1_msg

call writestring

mov edx, 0

mov eax, [edi]

cdq

idiv two

cmp edx, 0

je even_value2

jmp odd_value1

even_value2:

mov edx, offset even2_msg

call writestring

call multiply

call display

jmp jmp_from_even

odd_value1:

mov edx, offset odd_msg

call writestring

call divide

call display

jmp_from_even:

ret

positive endp

negative proc

call crlf

mov edx, offset neg_msg

call writestring

mov edx, 0

mov eax, [esi]

cdq

idiv two

cmp edx, 0

je even_value3

pop edx

jmp odd_value3

even_value3:

mov edx, offset even1_msg

call writestring

mov edx, 0

mov eax, [edi]

cdq

idiv two

cmp edx, 0

je even_value4

jmp odd_value3

even_value4:

mov edx, offset even2_msg

call writestring

call multiply

call display

jmp jmp_from_even

odd_value3:

mov edx, offset odd_msg

call writestring

call divide

call display

jmp_from_even:

ret

negative endp

multiply proc

push ecx

mov edx, offset mul_array

mov ebx, [esi]

mov mine, 0

mov temp, 0

mov ecx, 32

shr ebx,1

jc one_jump

jmp else_jump

one_jump:

mov eax, mine

mov temp, eax

mov eax, [edi]

l1:

cmp temp, 0

je outside_loop

sub temp, 1

shl eax, 1

jmp l1

outside_loop:

mov [edx], eax

add edx, 4

else_jump:

add mine, 1

loop l

mov ecx, lengthof mul_array

mov edx, offset mul_array

mov eax, 0

add_array:

add eax,[edx]

add edx, 4

loop add_array

mov ecx, 32

mov ebx, 0

mov edx, offset mul_array

empty_mul_array:

mov [edx],ebx

add edx, 4

loop empty_mul_array

pop ecx

ret

multiply endp

divide proc

push ecx

mov edx, 0

mov eax, [esi]

cdq

mov ecx, [edi]

idiv ecx

pop ecx

ret

divide endp

display proc

call crlf

mov edx, offset ans_msg

call writestring

call writeint

call crlf

mov [ebp], eax

ret

display endp

equation proc

mov edx, 0

mov eax, [array3+24]

cdq

idiv [array3+12]

mov temp2, eax

mov esi, offset temp2

mov edx, 0

mov eax, array3

cdq

idiv [array3+4]

mov temp1, eax

mov edi, offset temp1

call multiply

mov edx, [array3+16]

add edx, [array3+20]

add eax, edx

mov temp1, eax

mov esi, offset temp1

mov edi, offset [array3+8]

call multiply

add eax, array3[28]

call crlf

mov edx, offset equation_msg

call writestring

call crlf

mov edx, offset result

call writestring

call writeint

ret

equation endp

end main

Output

take input from user and take decision on the basis of these numbers whether to multiply or divide or shift

Posted by Maaz Ali at 12:06 AM Labels: assembly language , assembly language programs 0 comments

Problem:

Taking two inputs from user and taking decision on the basis of these numbers:

If both numbers are positive and even, than multiply those using shift command.
It both numbers are positive but one of them is odd, than divide those using div or idiv.
If one is negative and both numbers are even, than again multiply using shift.
If one number is negative and one of them is odd than divide using idiv or div.

Code

include irvine32.inc

.data

array1 sdword 10 dup(?)
array2 sdword 10 dup(?)
array3 sdword 10 dup(?)

array4 sdword 5 dup(?)
array5 sdword 5 dup(?)

mul_array sdword 32 dup(0)

mine dword ?
temp dword 0
temp1 dword 0
temp2 dword 0

two dword 2

num1_msg byte "Enter 1st value: ",0
num2_msg byte "Enter 2nd value: ",0

equation_msg byte "Solving the equation: ",0ah,0dh,0
result byte " Result = ",0

even1_msg byte " 1st number is even.",0ah,0dh,0
even2_msg byte " 2nd number is even.",0ah,0dh,0ah,0dh,0

pos_msg byte "1st number is positive.",0ah,0dh,0
pos1_msg byte "2nd number is positive.",0ah,0dh,0

odd_msg byte " one number is odd.",0ah,0dh,0ah,0dh,0

neg_msg byte "number is negative.",0ah,0dh,0

ans_msg byte "Answer = ",0

.code
main proc

mov esi, offset array1
mov edi, offset array2
mov ebp, offset array3

mov ecx, 10

main_loop:

mov edx, offset num1_msg
call writestring
call readint

mov [esi], eax

mov edx, offset num1_msg
call writestring
call readint

mov [edi], eax

mov eax, [esi]
cmp eax, 0

jge positive_value1
jmp negative_value1

positive_value1:

mov edx, offset pos_msg
call writestring

mov eax, [edi]
cmp eax, 0

jge positive_value2
jmp negative_value1

positive_value2:
call positive
jmp jmp_to_loop

negative_value1:
call negative

jmp_to_loop:
add esi, 4
add edi, 4
add ebp, 4
loop main_loop

mov esi, offset array4
mov edi, offset array5

mov ecx, 5
mov ebp, offset array3

l1:
call crlf
mov eax, [ebp]
;call writeint
mov [esi], eax
add ebp, 4
add esi,4

loop l1

mov ecx, 5

l2:
call crlf
mov eax, [ebp]
;call writeint
mov [edi], eax
add ebp, 4
add edi, 4
loop l2

mov esi, offset array4
mov ecx, 5

l3:
call crlf
mov eax, [esi]

call writeint
add esi, 4
loop l3

mov edi, offset array5
mov ecx, 5

l4:
call crlf
mov eax, [edi]
call writeint
add edi, 4
loop l4

;call equation

call crlf
call crlf
call crlf
exit
main endp

positive proc

mov edx, offset pos1_msg
call writestring

mov edx, 0
mov eax, [esi]
cdq
idiv two

cmp edx, 0
je even_value1
jmp odd_value1

even_value1:
call crlf
mov edx, offset even1_msg
call writestring

mov edx, 0
mov eax, [edi]
cdq
idiv two

cmp edx, 0
je even_value2
jmp odd_value1

even_value2:
mov edx, offset even2_msg
call writestring
call multiply
call display
jmp jmp_from_even

odd_value1:
mov edx, offset odd_msg
call writestring
call divide
call display

jmp_from_even:

ret
positive endp

negative proc

call crlf
mov edx, offset neg_msg
call writestring

mov edx, 0
mov eax, [esi]
cdq
idiv two

cmp edx, 0
je even_value3
pop edx
jmp odd_value3

even_value3:
mov edx, offset even1_msg
call writestring

mov edx, 0
mov eax, [edi]
cdq
idiv two

cmp edx, 0
je even_value4
jmp odd_value3

even_value4:
mov edx, offset even2_msg
call writestring
call multiply
call display
jmp jmp_from_even

odd_value3:
mov edx, offset odd_msg
call writestring
call divide
call display
jmp_from_even:
ret
negative endp

multiply proc
push ecx

mov edx, offset mul_array

mov ebx, [esi]

mov mine, 0
mov temp, 0
mov ecx, 32

l:
shr ebx,1
jc one_jump

jmp else_jump

one_jump:

mov eax, mine
mov temp, eax

mov eax, [edi]

l1:
cmp temp, 0
je outside_loop
sub temp, 1
shl eax, 1
jmp l1
outside_loop:
mov [edx], eax
add edx, 4
else_jump:
add mine, 1
loop l

mov ecx, lengthof mul_array
mov edx, offset mul_array
mov eax, 0

add_array:

add eax,[edx]
add edx, 4

loop add_array

mov ecx, 32
mov ebx, 0
mov edx, offset mul_array

empty_mul_array:

mov [edx],ebx
add edx, 4

loop empty_mul_array

pop ecx

ret
multiply endp

divide proc
push ecx

mov edx, 0
mov eax, [esi]
cdq
mov ecx, [edi]
idiv ecx

pop ecx
ret
divide endp

display proc

call crlf
mov edx, offset ans_msg
call writestring
call writeint
call crlf
call crlf
mov [ebp], eax

ret
display endp

equation proc

mov edx, 0
mov eax, [array3+24]
cdq
idiv [array3+12]

mov temp2, eax
mov esi, offset temp2

mov edx, 0
mov eax, array3
cdq
idiv [array3+4]

mov temp1, eax

mov edi, offset temp1

call multiply

mov edx, [array3+16]
add edx, [array3+20]

add eax, edx

mov temp1, eax

mov esi, offset temp1
mov edi, offset [array3+8]
call multiply

add eax, array3[28]

call crlf
call crlf

mov edx, offset equation_msg
call writestring
call crlf

mov edx, offset result
call writestring
call writeint

ret
equation endp

end main

Output

Wednesday, October 5, 2016

Write a simulator for the assembly language ISA design in C language.

Posted by Maaz Ali at 2:46 AM Labels: assembly language , C Language 0 comments

Code

#include "stdafx.h"

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

//initializing the memory and registers

void initialization(int a[]){

for(int i=0;i<16;i++)

a[i] = (i+1)*10;

}

//number of instructions

int input_instructions(){

int x;

printf("Enter the number of instructions you want to perform: ");

scanf_s ("%d",&x);

return x;

}

//loading the register from memory

void load(int row, int inst[][3]){

inst[row][0] = 1;

printf("Enter the number of register ranging from 1 to 16: ");

scanf_s("%d",&inst[row][1]);

printf("Enter the number of memory from which you want to load ranging from 1 to 16: ");

scanf_s("%d",&inst[row][2]);

}

//adding the two registers

void add(int row,int inst[][3]){

inst[row][0] = 5;

printf("Enter the destination register number: ");

scanf_s("%d",&inst[row][1]);

printf("Enter the source register number: ");

scanf_s("%d",&inst[row][2]);

}

//storing the value to the memory

void store(int row,int inst[][3]){

inst[row][0] = 3;

printf("Enter the register number: ");

scanf_s("%d",&inst[row][1]);

printf("Enter the memory number: ");

scanf_s("%d",&inst[row][2]);

}

//display the instruction memory

void display_pattern(int no_of_ins,int inst[][3]){

system("cls");

printf("\********************************************************************************");

printf("\n****************************** Instruction Memory ******************************");

printf("\n********************************************************************************");

for(int i=0;i<no_of_ins;i++){

printf("\n\t\t\t\t%d\t%d\t%d\n",inst[i][0],inst[i][1],inst[i][2]);

}

printf("\n\n");

for(int i=0;i<no_of_ins;i++){

if(inst[i][0] == 1){

printf("\t\t\t\tLoadR\tR%d\tM%d\n\n",inst[i][1],inst[i][2]);

}

else if(inst[i][0] == 3){

printf("\t\t\t\tStoreR\tR%d\tM%d\n\n",inst[i][1],inst[i][2]);

}

else if(inst[i][0] == 5){

printf("\t\t\t\tAddR\tR%d\tR%d\n\n",inst[i][1],inst[i][2]);

}

printf("\n\n\n\nPress any key to continue...");

_getch();

}

//display registers and memorys

void display_reg_mem(int reg[],int mem[]){

printf("\n\nRegister: ");

for(int j=0;j<16;j++)

printf("%d ",reg[j]);

printf("\n-----------------------------------------------------------------------------");

printf("\nMemory: ");

for(int j=0;j<16;j++)

printf("%d ",mem[j]);

}

//ISA simulator

void display_cycles(int no_of_inst,int inst[][3],int reg[],int mem[]){

for(int i=0;i<no_of_inst;i++){

system("cls");

printf("********************************************************************************");

printf("\n****************************** ISA Simulator ***********************************");

printf("\n********************************************************************************");

printf("\n\n\n\n\n******************************* Instruction # %d ********************************",(i+1));

printf("\n\n\n\n\nFetch Instruction:\t %d\t%d\t%d\n",inst[i][0],inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

if(inst[i][0] == 1){

printf("\n\n\n\n\nDecode Instruction:\t LoadR\tRegister%d\tMemory%d\n",inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

printf("\n\n\n\n\nExecute Instruction:\t Register updated Succesfully\n");

reg[(inst[i][1]-1)] = mem[(inst[i][2]-1)];

display_reg_mem(reg,mem);

}

if(inst[i][0] == 5){

printf("\n\n\n\n\nDecode Instruction:\t AddR\tRegister%d\tRegister%d\n",inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

printf("\n\n\n\n\nExecute Instruction:\t Register updated Succesfully\n");

reg[(inst[i][1]-1)] = reg[(inst[i][1]-1)] + reg[(inst[i][2]-1)];

display_reg_mem(reg,mem);

}

if(inst[i][0] == 3){

printf("\n\n\n\n\nDecode Instruction:\t StoreR\tRegister%d\tMemory%d\n",inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

printf("\n\n\n\n\nExecute Instruction:\t Memory updated Succesfully\n");

mem[(inst[i][2]-1)] = reg[(inst[i][1]-1)];

display_reg_mem(reg,mem);

}

printf("\n\n\n\nPress any key to continue...");

_getch();

}

int main(){

system("color 3f");

int choice,count=0,row=0,lines;

int registers[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int memorys[16];

initialization(memorys);

lines = input_instructions();

int instructions[100][3];

for(int i=0;i<lines;i++){

system("cls");

printf("Select one of the following instruction type from the following:\n");

printf("\t1. Load \n");

printf("\t2. Add \n");

printf("\t3. Store \n");

printf("\t4. Exit \n\n");

printf("Enter your choice: ");

choice = _getche();

switch (choice)

{

case '1': //load

system("cls");

load(row,instructions);

row++;

break;

case '2': //add

system("cls");

add(row,instructions);

row++;

break;

case '3': //store

system("cls");

store(row,instructions);

row++;

break;

case '4': //exit

exit(0);

default:

system("cls");

printf("\n\nInvalid input! Press any key to continue.");

break;

}

system("cls");

display_pattern(lines,instructions);

system("cls");

display_cycles(lines,instructions,registers,memorys);

exit(0);

return 0;

}

Program Output - Screen Shots

Screen 01

In the above screen 01 user must enter the instructions to run the program. For example we want to run our code for 4 instructions, so we will write 4 and hit enter.

The following screen will be displayed.

Screen 02

There are 4 options 1^st option is used to load the register from memory, 2^nd option add the two registers, 3^rd option stores the value from register to the memory, and the 4^th option is used to quit the program. For example, we press 1 and hit enter.

The following screen will be displayed.

Screen 03

User will be asked to enter the register number and the memory number. We will enter 2 for register and 7 for memory.

Screen 04

Same procedure will be followed again i.e. steps for screen 02.

Screen 05

This time we will enter 3 for register and 6 for the memory.

After you have entered the value in the memory hit enter… the program will show you the following screen.

Screen 06

This time press 2 and hit enter.

Screen 07

It will ask you to enter two register numbers one by one. The 1^st register is the destination and the 2^nd register is the source i.e. after the value is entered, the value of the destination will be overwritten with the sum of the two registers in the add instruction. Here we have entered 2 and 3 register numbers where 2^nd register will be overwritten after the execution with the sum of the register no 2 and 3.

Screen 08

After you enter the register number, the above screen will be displayed again, press 3 this time and hit enter.

Screen 09

The above screen will be shown asking the user to enter the register number from which he/she wants to store data and then the program will ask for the memory number. For instance, we enter 2 for register and 6 for memory and press enter.

Screen 10

As, we have entered 4 instructions (2 load, 1 add and 1 store). The above screen will be displayed asking the user to press any key to continue if he/she have viewed the instructions. After we hit enter the following screen will be displayed.

Screen 11

The program will show the user ISA simulator with the 1^st instruction. As, the 1^st instruction was to load the register from the memory i.e. 1 2 7. After the execution the register’s value will be updated and as we can see in our example it has updated the 2^nd register with the value 70 taken from the memory’s 7^th location.

Let’s have a closer look at the above screen 11, we can see there are three steps involved are involved for each cycle (instruction).

1^st step - the fetch instruction

It fetches the instruction from the memory and loads it into the processor.

2^nd step - the decode instruction

After the 1^st step the 2^nd step takes place: It decodes the instruction after it has been fetched, so that the computer can perform its specific operation.

3^rd step - execute instruction

It executes the instruction and updates the values according to the instruction, for instance in this instruction it will update the value of the 2^nd register.

Screen 12

Similarly 2^nd instruction will be displayed. It will update the 3^rd register with the value 60.

Screen 13

The third instruction was to add the 2^nd and 3^rd register and answer have to be stored in the 2^nd register as it was the destination register. Hence, we can see the value of the 2^nd register have been updated to 130 from 70.

Screen 14

The last and 4^th instruction that we entered was to store the result of add instruction from the 3^rd instruction to the memory. In the above example we have stored the value of the 2^nd register in the 6^th memory location.

The user will be asked to press any key to continue and the program will be terminated as there were no more instructions to show.

C, C++, and Assembly Language Programs & Tutotrials

Monday, October 10, 2016

calculate students grade and display using assembly language

Problem

Code

Output

take input from user and take decision on the basis of these numbers whether to multiply or divide or shift

Problem:

Code

Output

Wednesday, October 5, 2016

Write a simulator for the assembly language ISA design in C language.

Code

Program Output - Screen Shots

1^st step - the fetch instruction

2^nd step - the decode instruction

3^rd step - execute instruction

Categories

Popular Posts

Contact

Stay Connected

C, C++, and Assembly Language Programs & Tutotrials

Monday, October 10, 2016

calculate students grade and display using assembly language

Problem

Code

Output

take input from user and take decision on the basis of these numbers whether to multiply or divide or shift

Problem:

Code

Output

Wednesday, October 5, 2016

Write a simulator for the assembly language ISA design in C language.

Code

Program Output - Screen Shots

1st step - the fetch instruction

2nd step - the decode instruction

3rd step - execute instruction

Categories

Popular Posts

Contact

Stay Connected

1^st step - the fetch instruction

2^nd step - the decode instruction

3^rd step - execute instruction