Comment détecter les débordements dans Assembly Langauge X86

J’ai une tâche dans laquelle nous devons écrire deux fonctions. Doit également détecter les conditions de débordement à l’aide des codes de condition du processeur et renvoyer 0 pour indiquer qu’une erreur a été rencontrée. J’ai pu écrire les fonctions.

  .file "formula.c" .text .globl _nCr .def _nCr; .scl 2; .type 32; .endef _nCr: pushl %ebp movl %esp, %ebp subl $56, %esp movl 8(%ebp), %eax movl %eax, (%esp) testl %eax, %eax call _factorial movl %eax, -12(%ebp) movl 12(%ebp), %eax addl $1, %eax movl %eax, (%esp) call _factorial movl %eax, -16(%ebp) movl 12(%ebp), %eax notl %eax addl 8(%ebp), %eax movl %eax, (%esp) call _factorial movl %eax, -20(%ebp) movl -16(%ebp), %eax movl %eax, %edx imull -20(%ebp), %edx movl %edx, -28(%ebp) movl -12(%ebp), %eax movl %eax, %edx sarl $31, %edx idivl -28(%ebp) leave ret .globl _factorial .def _factorial; .scl 2; .type 32; .endef _factorial: pushl %ebp movl %esp, %ebp subl $16, %esp movl $1, -8(%ebp) movl $1, -4(%ebp) jmp L3 L4: movl -8(%ebp), %eax imull -4(%ebp), %eax movl %eax, -8(%ebp) addl $1, -4(%ebp) L3: movl -4(%ebp), %eax cmpl 8(%ebp), %eax jle L4 movl -8(%ebp), %eax leave ret .def ___main; .scl 2; .type 32; .endef .section .rdata,"dr" .align 4 

Cette fonction fait fondamentalement n!/r!(nr)! . Le débordement se produit en factorielle lorsque les nombres deviennent plus grands. Je ne comprends tout simplement pas comment définir les conditions de débordement.

1) Vos commandes arithmétiques sont les opérations susceptibles de définir le bit de débordement

2) Le “JO” (débordement) et le “JNO” (saut non débordement) vous permettent de créer une twig, selon que le débordement a eu lieu ou non.

3) Vous voudriez probablement simplement mettre “% eax” à 0 après “JO”.

4) Excellente, excellente ressource si vous ne la connaissez pas déjà:

Programmation à partir de zéro, Jonathan Bartlett

Sur l’architecture x86, lorsqu’une instruction arithmétique est addl 8(%ebp), %eax telle que addl 8(%ebp), %eax les codes de condition sont définis dans le mot d’état de la CPU. Il existe des instructions dont le comportement dépend des codes de condition.

Vous pouvez demander au code de prendre un autre chemin (exécuter une twig) pour une condition donnée. Le x86 a une famille d’instructions de twigment conditionnelles sous les mnémoniques Jxx : JA, JAE, JB, JBE, JC, JCXZ, ..., JZ . Par exemple, JZ signifie saut si zéro: prenez une twig si l’instruction produit un résultat zéro, en définissant l’indicateur zéro. JO est sur le trop-plein.

Une condition peut également être convertie en une donnée d’octet et stockée dans un registre ou une mémoire. Ceci est utile pour comstackr des expressions C telles que:

  x = (y != 3); /* if (y != 3) x = 1; else x = 0 */ 

Cela est fait par le groupe d’instructions SETx qui sont aussi nombreuses, comme les twigs conditionnelles: SETA, SETAE, SETB, ..., SETZ . Par exemple, SETZ définira un octet donné sur 1 si la condition zéro est vraie. Par exemple

  seto %bl /* set bottom byte of B register to 1 if overflow flag set */