In What Register Will The Remainder Of The Following Instruction Be Found? Div Ebx

Associates - Arithmetic Instructions

The INC Instruction

The INC didactics is used for incrementing an operand by one. It works on a single operand that tin exist either in a register or in retentivity.

Syntax

The INC instruction has the following syntax −

INC destination

The operand destination could be an eight-fleck, 16-chip or 32-bit operand.

Example

INC EBX	     ; Increments 32-flake annals INC DL       ; Increments 8-flake annals INC [count]  ; Increments the count variable

The Dec Teaching

The DEC instruction is used for decrementing an operand by ane. Information technology works on a single operand that can be either in a annals or in memory.

Syntax

The Dec instruction has the following syntax −

DEC destination

The operand destination could be an eight-scrap, 16-bit or 32-chip operand.

Example

segment .information    count dw  0    value db  fifteen 	 segment .text    inc [count]    dec [value] 	    mov ebx, count    inc discussion [ebx] 	    mov esi, value    december byte [esi]

The Add and SUB Instructions

The Add together and SUB instructions are used for performing simple addition/subtraction of binary information in byte, discussion and doubleword size, i.e., for adding or subtracting 8-bit, 16-bit or 32-fleck operands, respectively.

Syntax

The Add together and SUB instructions have the following syntax −

Add together/SUB	destination, source

The Add/SUB instruction tin accept identify between −

Register to register
Memory to register
Annals to memory
Register to constant data
Memory to constant information

However, like other instructions, memory-to-retentivity operations are not possible using ADD/SUB instructions. An ADD or SUB operation sets or clears the overflow and conduct flags.

Example

The following example will enquire 2 digits from the user, store the digits in the EAX and EBX register, respectively, add the values, store the result in a memory location 'res' and finally display the outcome.

SYS_EXIT  equ 1 SYS_READ  equ three SYS_WRITE equ 4 STDIN     equ 0 STDOUT    equ 1  segment .data      msg1 db "Enter a digit ", 0xA,0xD     len1 equ $- msg1      msg2 db "Delight enter a 2nd digit", 0xA,0xD     len2 equ $- msg2      msg3 db "The sum is: "    len3 equ $- msg3  segment .bss     num1 resb 2     num2 resb 2     res resb 1      section	.text    global _start    ;must be alleged for using gcc 	 _start:             ;tell linker entry point    mov eax, SYS_WRITE             mov ebx, STDOUT             mov ecx, msg1             mov edx, len1     int 0x80                     mov eax, SYS_READ     mov ebx, STDIN      mov ecx, num1     mov edx, 2    int 0x80                 mov eax, SYS_WRITE            mov ebx, STDOUT             mov ecx, msg2              mov edx, len2             int 0x80     mov eax, SYS_READ      mov ebx, STDIN      mov ecx, num2     mov edx, 2    int 0x80             mov eax, SYS_WRITE             mov ebx, STDOUT             mov ecx, msg3              mov edx, len3             int 0x80     ; moving the first number to eax annals and second number to ebx    ; and subtracting ascii '0' to catechumen information technology into a decimal number 	    mov eax, [num1]    sub eax, '0' 	    mov ebx, [num2]    sub ebx, '0'     ; add eax and ebx    add eax, ebx    ; add together '0' to to catechumen the sum from decimal to ASCII    add together eax, '0'     ; storing the sum in memory location res    mov [res], eax     ; print the sum     mov eax, SYS_WRITE            mov ebx, STDOUT    mov ecx, res             mov edx, one            int 0x80  go out:            mov eax, SYS_EXIT       xor ebx, ebx     int 0x80

When the above code is compiled and executed, it produces the following result −

Enter a digit: three Delight enter a second digit: iv The sum is: 7

The program with hardcoded variables −

section	.text    global _start    ;must be declared for using gcc 	 _start:             ;tell linker entry betoken    mov	eax,'3'    sub     eax, '0' 	    mov 	ebx, '4'    sub     ebx, '0'    add 	eax, ebx    add	eax, '0' 	    mov 	[sum], eax    mov	ecx,msg	    mov	edx, len    mov	ebx,1	;file descriptor (stdout)    mov	eax,4	;system call number (sys_write)    int	0x80	;call kernel 	    mov	ecx,sum    mov	edx, 1    mov	ebx,1	;file descriptor (stdout)    mov	eax,4	;system call number (sys_write)    int	0x80	;call kernel 	    mov	eax,1	;system call number (sys_exit)    int	0x80	;telephone call kernel 	 section .data    msg db "The sum is:", 0xA,0xD     len equ $ - msg       segment .bss    sum resb 1

When the above code is compiled and executed, it produces the following result −

The sum is: seven

The MUL/IMUL Education

There are two instructions for multiplying binary data. The MUL (Multiply) education handles unsigned data and the IMUL (Integer Multiply) handles signed data. Both instructions affect the Bear and Overflow flag.

Syntax

The syntax for the MUL/IMUL instructions is as follows −

MUL/IMUL multiplier

Multiplicand in both cases volition be in an accumulator, depending upon the size of the multiplicand and the multiplier and the generated product is also stored in two registers depending upon the size of the operands. Post-obit section explains MUL instructions with three unlike cases −

Sr.No.	Scenarios
1	When two bytes are multiplied − The multiplicand is in the AL annals, and the multiplier is a byte in the retentivity or in some other annals. The product is in AX. High-order eight bits of the product is stored in AH and the depression-club 8 $.25 are stored in AL.
ii	When two one-word values are multiplied − The multiplicand should exist in the AX register, and the multiplier is a word in memory or another register. For example, for an instruction like MUL DX, you must store the multiplier in DX and the multiplicand in AX. The resultant production is a doubleword, which will demand ii registers. The high-order (leftmost) portion gets stored in DX and the lower-order (rightmost) portion gets stored in AX.
3	When two doubleword values are multiplied − When two doubleword values are multiplied, the multiplicand should be in EAX and the multiplier is a doubleword value stored in retentiveness or in another annals. The product generated is stored in the EDX:EAX registers, i.eastward., the high lodge 32 bits gets stored in the EDX register and the depression order 32-bits are stored in the EAX register.

Sr.No.

Scenarios

When two bytes are multiplied −

The multiplicand is in the AL annals, and the multiplier is a byte in the retentivity or in some other annals. The product is in AX. High-order eight bits of the product is stored in AH and the depression-club 8 $.25 are stored in AL.

Arithmetic1

When two one-word values are multiplied −

The multiplicand should exist in the AX register, and the multiplier is a word in memory or another register. For example, for an instruction like MUL DX, you must store the multiplier in DX and the multiplicand in AX.

The resultant production is a doubleword, which will demand ii registers. The high-order (leftmost) portion gets stored in DX and the lower-order (rightmost) portion gets stored in AX.

Arithmetic2

When two doubleword values are multiplied −

When two doubleword values are multiplied, the multiplicand should be in EAX and the multiplier is a doubleword value stored in retentiveness or in another annals. The product generated is stored in the EDX:EAX registers, i.eastward., the high lodge 32 bits gets stored in the EDX register and the depression order 32-bits are stored in the EAX register.

Arithmetic3

Example

MOV AL, 10 MOV DL, 25 MUL DL ... MOV DL, 0FFH	; DL= -1 MOV AL, 0BEH	; AL = -66 IMUL DL

Example

The following example multiplies 3 with ii, and displays the issue −

section	.text    global _start    ;must be declared for using gcc 	 _start:             ;tell linker entry point     mov	al,'three'    sub     al, '0' 	    mov 	bl, '2'    sub     bl, '0'    mul 	bl    add	al, '0' 	    mov 	[res], al    mov	ecx,msg	    mov	edx, len    mov	ebx,1	;file descriptor (stdout)    mov	eax,4	;organisation call number (sys_write)    int	0x80	;call kernel 	    mov	ecx,res    mov	edx, one    mov	ebx,ane	;file descriptor (stdout)    mov	eax,four	;system phone call number (sys_write)    int	0x80	;phone call kernel 	    mov	eax,1	;organisation call number (sys_exit)    int	0x80	;call kernel  department .data msg db "The result is:", 0xA,0xD  len equ $- msg    segment .bss res resb ane

When the above code is compiled and executed, it produces the following result −

The result is: 6

The DIV/IDIV Instructions

The division operation generates two elements - a quotient and a remainder. In case of multiplication, overflow does not occur because double-length registers are used to continue the product. However, in case of division, overflow may occur. The processor generates an interrupt if overflow occurs.

The DIV (Split up) instruction is used for unsigned data and the IDIV (Integer Divide) is used for signed data.

Syntax

The format for the DIV/IDIV didactics −

DIV/IDIV	divisor

The dividend is in an accumulator. Both the instructions tin work with 8-scrap, xvi-bit or 32-bit operands. The functioning affects all six status flags. Following section explains three cases of partitioning with dissimilar operand size −

Sr.No.	Scenarios
ane	When the divisor is 1 byte − The dividend is assumed to exist in the AX annals (sixteen bits). After sectionalisation, the quotient goes to the AL annals and the residue goes to the AH register.
2	When the divisor is 1 word − The dividend is assumed to exist 32 bits long and in the DX:AX registers. The high-order 16 bits are in DX and the low-society 16 bits are in AX. Later division, the 16-bit quotient goes to the AX annals and the 16-bit remainder goes to the DX annals.
3	When the divisor is doubleword − The dividend is assumed to be 64 $.25 long and in the EDX:EAX registers. The high-social club 32 bits are in EDX and the low-order 32 bits are in EAX. Later division, the 32-bit caliber goes to the EAX annals and the 32-bit remainder goes to the EDX register.

Sr.No.

Scenarios

ane

When the divisor is 1 byte −

The dividend is assumed to exist in the AX annals (sixteen bits). After sectionalisation, the quotient goes to the AL annals and the residue goes to the AH register.

Arithmetic4

When the divisor is 1 word −

The dividend is assumed to exist 32 bits long and in the DX:AX registers. The high-order 16 bits are in DX and the low-society 16 bits are in AX. Later division, the 16-bit quotient goes to the AX annals and the 16-bit remainder goes to the DX annals.

Arithmetic5

When the divisor is doubleword −

The dividend is assumed to be 64 $.25 long and in the EDX:EAX registers. The high-social club 32 bits are in EDX and the low-order 32 bits are in EAX. Later division, the 32-bit caliber goes to the EAX annals and the 32-bit remainder goes to the EDX register.

Arithmetic6

Example

The following case divides 8 with 2. The dividend viii is stored in the 16-scrap AX register and the divisor ii is stored in the 8-flake BL annals.

section	.text    global _start    ;must exist alleged for using gcc 	 _start:             ;tell linker entry signal    mov	ax,'viii'    sub     ax, '0' 	    mov 	bl, '2'    sub     bl, '0'    div 	bl    add	ax, '0' 	    mov 	[res], ax    mov	ecx,msg	    mov	edx, len    mov	ebx,i	;file descriptor (stdout)    mov	eax,4	;organization call number (sys_write)    int	0x80	;call kernel 	    mov	ecx,res    mov	edx, i    mov	ebx,1	;file descriptor (stdout)    mov	eax,4	;organization telephone call number (sys_write)    int	0x80	;phone call kernel 	    mov	eax,ane	;arrangement phone call number (sys_exit)    int	0x80	;call kernel 	 section .data msg db "The issue is:", 0xA,0xD  len equ $- msg    segment .bss res resb 1

When the above code is compiled and executed, information technology produces the following issue −

The result is: four