Section courante

A propos

Section administrative du site

Assembleur 80x86

IDIV

INTEL 8088+ Division entière

Syntaxe

IDIV Opérande

Description

Cette instruction permet d'effectuer une division signée (nombre entier). Le dividende est implicite; il est ajuster en fonction de la taille du diviseur. Le restant est toujours plus petit que le diviseur. Le type de diviseur détermine quel registre l'instruction utilisera:

Taille Dividende Diviseur Quotient Restant
Octet AX Opérande AL AH
Mot DX:AX Opérande AX DX
Double mot EDX:EAX Opérande EAX EDX

Remarques

Algorithme

SI Opérande = 0 ALORS
   Interruption 0
SINON
   SI Opérande 8 bits ALORS
      ALAX ÷ Opérande
      AHAX MOD Opérande
   FIN SI
   SI Opérande 16 bits ALORS
      AX ← ( ( DX x 65536 ) + AX ) ÷ Opérande
      DX ← ( ( DX x 65536 ) + AX ) MOD Opérande
   FIN SI
   SI Opérande 32 bits ALORS
      EAX ← ( ( EDX x 65536 x 65536 ) + EAX ) ÷ Opérande
      EDX ← ( ( EDX x 65536 x 65536 ) + EAX ) MOD Opérande
   FIN SI
FIN SI

Mnémonique

Instruction Opcode Description
IDIV reg/mem8 F6h /7 Division entière de AX par le contenu d'un emplacement mémoire ou registre 8 bits et entrepose le quotient dans AL et restant dans AH.
IDIV reg/mem16 F7h /7 Division entière de DX:AX par le contenu d'un emplacement mémoire ou registre 16 bits et entrepose le quotient dans AX et restant dans DX.
IDIV reg/mem32 F7h /7 Division entière de EDX:EAX par le contenu d'un emplacement mémoire ou registre 32 bits et entrepose le quotient dans EAX et restant dans EDX.
IDIV reg/mem64 F7h /7 Division entière de RDX:RAX par le contenu d'un emplacement mémoire ou registre 64 bits et entrepose le quotient dans RAX et restant dans RDX.

Exceptions

Message Mode réel Virtuel 8086 Mode protégé Description
#DE(Division par zéro) X X X L'opérande de diviseur vaut 0.
X X X Le quotient est trop large pour le registre désigné.
#SS(Pile) X X X Une adresse mémoire dépasse la limite du segment de pile ou n'est pas canonique
#GP(Protection général) X X X Une adresse mémoire dépasse la limite du segment de données ou n'est pas canonique
    X Un segment de données nulle est utilisé comme référence mémoire
#PF(Faute de page)   X X Une faute de page résultat de l'exécution de l'instruction
#AC(Vérifie l'alignement)   X X Un désalignement de la référence mémoire est effectué quand une vérification d'alignement est activé

Exemple

Voici quelques exemples typiques de l'utilisation de cet opérateur :

  1. .MODEL small
  2.    .STACK 100h
  3.    .DATA
  4. Message1       DB 'idiv(-81,9) = ','$'
  5. Message2       DB 'idiv(15,3) = ','$'
  6. Message3       DB 'idiv(16,3) = ','$'
  7. Message4       DB 'idiv(17,3) = ','$'
  8. Message5       DB 'idiv(18,3) = ','$'
  9. Message6       DB 'idiv(19,3) = ','$'
  10. Message7       DB 'idiv(0,1) = ','$'
  11. CRLF           DB 13,10,'$'
  12.    .CODE
  13. PrintDigit PROC NEAR
  14.     OR  AX,AX
  15.     JNS Positif    
  16.     PUSH AX
  17.      MOV AH,02h
  18.      MOV DL,'-'
  19.      INT 21h
  20.     POP AX
  21.     NEG AX
  22. Positif:
  23.     MOV BX,10           
  24.     XOR CX,CX
  25. NextDigit:
  26.     XOR DX,DX
  27.     DIV BX
  28.     PUSH DX
  29.      INC CX              
  30.      OR  AX,AX
  31.      JNZ NextDigit
  32. PrintOneDigit: 
  33.     POP AX       
  34.     ADD AL,48           
  35.     MOV DL,AL           
  36.     MOV AH,02h
  37.     INT 21h             
  38.     LOOP PrintOneDigit
  39.     RET
  40. ENDP
  41.  
  42.     .startup   
  43.  
  44.      ; idiv(-81,9)
  45.     MOV  AX,@data
  46.     MOV  DS,AX                  
  47.     MOV  AH,9                   
  48.     MOV  DX,OFFSET Message1
  49.     INT  21h                    
  50.     MOV  AX,81
  51.     XOR  DX,DX
  52.     MOV  CX,9
  53.     IDIV  CX
  54.     NEG  AX
  55.     CALL PrintDigit
  56.     MOV  AH,9                   
  57.     MOV  DX,OFFSET CRLF
  58.     INT  21h
  59.  
  60.      ; idiv(15,3)
  61.     MOV  AX,@data
  62.     MOV  DS,AX                  
  63.     MOV  AH,9                   
  64.     MOV  DX,OFFSET Message2
  65.     INT  21h                    
  66.     MOV  AX,15
  67.     XOR  DX,DX
  68.     MOV  CX,3
  69.     IDIV  CX
  70.     CALL PrintDigit
  71.     MOV  AH,9                   
  72.     MOV  DX,OFFSET CRLF
  73.     INT  21h
  74.  
  75.      ; idiv(16,3)
  76.     MOV  AX,@data
  77.     MOV  DS,AX                  
  78.     MOV  AH,9                   
  79.     MOV  DX,OFFSET Message3
  80.     INT  21h                    
  81.     MOV  AX,16
  82.     XOR  DX,DX
  83.     MOV  CX,3
  84.     iDIV  CX
  85.     CALL PrintDigit
  86.     MOV  AH,9                   
  87.     MOV  DX,OFFSET CRLF
  88.     INT  21h
  89.  
  90.      ; idiv(17,3)
  91.     MOV  AX,@data
  92.     MOV  DS,AX                  
  93.     MOV  AH,9                   
  94.     MOV  DX,OFFSET Message4
  95.     INT  21h                    
  96.     MOV  AX,17
  97.     XOR  DX,DX
  98.     MOV  CX,3
  99.     IDIV  CX
  100.     CALL PrintDigit
  101.     MOV  AH,9                   
  102.     MOV  DX,OFFSET CRLF
  103.     INT  21h
  104.  
  105.      ; idiv(18,3)
  106.     MOV  AX,@data
  107.     MOV  DS,AX                  
  108.     MOV  AH,9                   
  109.     MOV  DX,OFFSET Message5
  110.     INT  21h                    
  111.     MOV  AX,18
  112.     XOR  DX,DX
  113.     MOV  CX,3
  114.     IDIV  CX
  115.     CALL PrintDigit
  116.     MOV  AH,9                   
  117.     MOV  DX,OFFSET CRLF
  118.     INT  21h
  119.  
  120.      ; idiv(19,3)
  121.     MOV  AX,@data
  122.     MOV  DS,AX                  
  123.     MOV  AH,9                   
  124.     MOV  DX,OFFSET Message6
  125.     INT  21h                    
  126.     MOV  AX,19
  127.     XOR  DX,DX
  128.     MOV  CX,3
  129.     IDIV  CX
  130.     CALL PrintDigit
  131.     MOV  AH,9                   
  132.     MOV  DX,OFFSET CRLF
  133.     INT  21h
  134.  
  135.      ; idiv(0,1)
  136.     MOV  AX,@data
  137.     MOV  DS,AX                  
  138.     MOV  AH,9                   
  139.     MOV  DX,OFFSET Message7
  140.     INT  21h                    
  141.     MOV  AX,0
  142.     XOR  DX,DX
  143.     MOV  CX,1
  144.     IDIV  CX
  145.     CALL PrintDigit
  146.     MOV  AH,9                   
  147.     MOV  DX,OFFSET CRLF
  148.     INT  21h
  149.  
  150.     
  151.     MOV  AX,4C00h                 
  152.     INT  21h                    
  153.     END

on obtiendra le résultat suivant :

div(-81,9) = -9
div(15,3) = 5
div(16,3) = 5
div(17,3) = 5
div(18,3) = 6
div(19,3) = 6
div(0,1) = 0

Voir également

Instruction assembleur 80x86 - Instruction IMUL
Instruction assembleur 80x86 - Instruction DIV

Références

Le livre d'Or PC, Martin Althaus, 1992, ISBN: 2-7361-0934-1, page 811
Assembleur Facile, Philippe Mercier, 1990, ISBN: 2-501-01176-7, page 404
AMD64 Architecture Programmer's Manual Volume 3: General-Purpose and System Instructions, Edition Advanced Micro Devices, Revision 3.14, September 2007, Publication No. 24594, page 113 à 114.
Intel® 64 and IA-32 Architectures Software Developer’s Manual Volume 2A: Instruction Set Reference, A-M, Edition Intel, Mars 2010, Publication No. 253666-034US, page 559 à 562.

Dernière mise à jour : Lundi, le 1 septembre 2014