Section courante

A propos

Section administrative du site

Assembleur 80x86

DIV

INTEL 8088+ Division

Syntaxe

DIV Opérande

Paramètres

Nom Description
opérande Ce paramètre permet d'indiquer le diviseur

Description

L'instruction DIV permet d'effectuer une division non-signée (nombre naturel). 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

Remarque

Algorithme

MODULE DIV(Opérande)
   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
DIV reg/mem8 F6h /6 Division naturel de AX par le contenu d'un emplacement mémoire ou registre 8 bits et entrepose le quotient dans AL et restant dans AH.
DIV reg/mem16 F7h /6 Division naturel 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.
DIV reg/mem32 F7h /6 Division naturel 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.
DIV reg/mem64 F7h /6 Division naturel 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 'div(-81,9) = ','$'
  5. Message2       DB 'div(15,3) = ','$'
  6. Message3       DB 'div(16,3) = ','$'
  7. Message4       DB 'div(17,3) = ','$'
  8. Message5       DB 'div(18,3) = ','$'
  9. Message6       DB 'div(19,3) = ','$'
  10. Message7       DB 'div(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.      ; div(-81,9)
  45.     MOV  AX,@data
  46.     MOV  DS,AX                  
  47.     MOV  AH,9                   
  48.     MOV  DX,OFFSET Message1
  49.     INT  21h                    
  50.     MOV  AL,81
  51.     XOR  AH,AH
  52.     NEG  AH
  53.     MOV  CX,9
  54.     DIV  CL
  55.     NEG  AX
  56.     CALL PrintDigit
  57.     MOV  AH,9                   
  58.     MOV  DX,OFFSET CRLF
  59.     INT  21h
  60.  
  61.      ; div(15,3)
  62.     MOV  AX,@data
  63.     MOV  DS,AX                  
  64.     MOV  AH,9                   
  65.     MOV  DX,OFFSET Message2
  66.     INT  21h                    
  67.     MOV  AX,15
  68.     XOR  DX,DX
  69.     MOV  CX,3
  70.     DIV  CX
  71.     CALL PrintDigit
  72.     MOV  AH,9                   
  73.     MOV  DX,OFFSET CRLF
  74.     INT  21h
  75.  
  76.      ; div(16,3)
  77.     MOV  AX,@data
  78.     MOV  DS,AX                  
  79.     MOV  AH,9                   
  80.     MOV  DX,OFFSET Message3
  81.     INT  21h                    
  82.     MOV  AX,16
  83.     XOR  DX,DX
  84.     MOV  CX,3
  85.     DIV  CX
  86.     CALL PrintDigit
  87.     MOV  AH,9                   
  88.     MOV  DX,OFFSET CRLF
  89.     INT  21h
  90.  
  91.      ; div(17,3)
  92.     MOV  AX,@data
  93.     MOV  DS,AX                  
  94.     MOV  AH,9                   
  95.     MOV  DX,OFFSET Message4
  96.     INT  21h                    
  97.     MOV  AX,17
  98.     XOR  DX,DX
  99.     MOV  CX,3
  100.     DIV  CX
  101.     CALL PrintDigit
  102.     MOV  AH,9                   
  103.     MOV  DX,OFFSET CRLF
  104.     INT  21h
  105.  
  106.      ; div(18,3)
  107.     MOV  AX,@data
  108.     MOV  DS,AX                  
  109.     MOV  AH,9                   
  110.     MOV  DX,OFFSET Message5
  111.     INT  21h                    
  112.     MOV  AX,18
  113.     XOR  DX,DX
  114.     MOV  CX,3
  115.     DIV  CX
  116.     CALL PrintDigit
  117.     MOV  AH,9                   
  118.     MOV  DX,OFFSET CRLF
  119.     INT  21h
  120.  
  121.      ; div(19,3)
  122.     MOV  AX,@data
  123.     MOV  DS,AX                  
  124.     MOV  AH,9                   
  125.     MOV  DX,OFFSET Message6
  126.     INT  21h                    
  127.     MOV  AX,19
  128.     XOR  DX,DX
  129.     MOV  CX,3
  130.     DIV  CX
  131.     CALL PrintDigit
  132.     MOV  AH,9                   
  133.     MOV  DX,OFFSET CRLF
  134.     INT  21h
  135.  
  136.      ; div(0,1)
  137.     MOV  AX,@data
  138.     MOV  DS,AX                  
  139.     MOV  AH,9                   
  140.     MOV  DX,OFFSET Message7
  141.     INT  21h                    
  142.     MOV  AX,0
  143.     XOR  DX,DX
  144.     MOV  CX,1
  145.     DIV  CX
  146.     CALL PrintDigit
  147.     MOV  AH,9                   
  148.     MOV  DX,OFFSET CRLF
  149.     INT  21h
  150.  
  151.     
  152.     MOV  AX,4C00h                 
  153.     INT  21h                    
  154.     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 MUL
Instruction assembleur 80x86 - Instruction IDIV

Références

Le livre d'Or PC, Martin Althaus, 1992, ISBN: 2-7361-0934-1, page 810
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 109.
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 358 à 360.

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