Votre aide s'il vous plaait :/ ?

Quant à ta seconde question, hé bien en fait "cmp al,09" ne modifie pas le registre "al", donc c'est pas une simple addition, c'est qu'on compare le registre "al" à 9, et on saute selon le résultat de cette comparaison.

Aaah ouuii j'ai compris merci beaucoup Nicocorico pour l'aide !! vrémenent , est ce que vous pouvez me dire autre chose ? d'habitude en c on fait tout ce qu'on veut sans prendre en consideration est que le compilateur va se souvener des contenu des variable et tout meme si qu'on utilisé plusieurs instructions , main en assembleur , nous devans utiliser les ' push" , et "pop" pour garder la valeur qu'on a affecté a un registre .. , ca on l'utilise si on fait du saut dans notre code par exemple
mov ah,01h
int 21h
mov dl,al
push dx
mov dx,saut
mov ah,09h
int 21h
saut dx ,
je voulais savoir, est que seulement dans les saut qu'on qu'on peut risquer de perdre nos valeur ?? ou bien il y'en a d'autres cas? , est ce que si on a utilisé des jmp , et si les conditions sont vérifié , avans l"utilisé , il faut fair du push , et au mileux des instructions du jmp on fait les push ?? ou bien nn , seulement quand on fait du saut ?? repondez moi s'il vous plaaait !!!

le code plutot devrait aitre :
mov ah,01h
int 21h
mov dl,al
push dx
mov dx,saut
mov ah,09h
int 21h
pop dx

Non non, en fait ce qu'il faut comprendre c'est que les registres ne sont pas modifiés sans raison apparente! Les registres ne sont pas modifiés dans le cas des sauts, ni des call! En fait les instructions "call-ret" servent à faire un appel de fonction (comme en C donc) c'est à dire que l'éxécution se poursuit à l'endroit déterminé au moment du call jusqu'à ce qu'une instruction "Ret" force le retour au point de départ... alors que le "jmp" se contente d'un aller simple. Donc, étant donné qu'une fonction peut en appeler une autre, etc.., hé bien il faut retenir chaque adresse de retour! Ainsi à n'importe quel endroit du programme on peut appeler des fonctions sans perdre le fil du programme appelant.. Et comme chaque fonction peut appeler une autre fonction, il faut pouvoir retenir un nombre indéterminé d'adresse, donc c'est la pile qui est utilisée pour ça: La pile est tout simplement un espace en mémoire, et le processeur contient un registre (esp) qui pointe dessus; Ce registre est incrémenté et décrémenté à chaque fois qu'on empile et dépile, donc à chaque fois qu'on fait un push, on ajoute une valeur en haut de la pile, et quand on dépile, ça retire la valeur qui est tout en haut. Donc on dépile dans l'ordre inverse de l'empilement pour retrouver les valeurs dans le bon ordre. et on se sert éventuellement de ce mécanisme pour retenir temporairement des données, pour les variables locales des programmes ou pour passer des paramètres aux fonctions.
Et donc pour en revenir au "call" et au "jmp", en fait le call est un jmp avec empilement d'adresse, et le "ret" dépile l'adresse et fait un "jmp" dessus en passant à la ligne suivante, donc l'éxécution se poursuit ensuite à l'instruction suivant le "call". Le jmp lui, est un saut simple, c'est comme un saut conditionnel mais sans condition, tout simplement!
En fait un jmp sert à passer à la suite du programme dans certains cas précis, alors qu'un call sert à effectuer un traitement temporaire dans le code en cours sans l'interrompre.
Par exemple, on va faire un "call" vers une fonction de tracé de ligne, et comme toutes les fonctions finissent par "ret", la ligne va être tracée et la main sera rendu à l'appelant quel qu'il soit...

J'ai cherché un peu des sites qui pourraient être utile pour apprendre les bases, mais je trouve rien de vraiment bien! C'est très austère!
https://asm.developpez.com/intro/

En fait les compilateurs eux-mêmes auraient très bien pu implémenter le principe de fonctions sans l'aide du processeur, puisqu'il leur suffit de faire ceci:

// définition d'une fonction

Fonction1:
  // code de la fonction
  // ...
  // fin de la fonction
  Pop  DX    // dépile l'adresse de l'appelant
  Jmp  DX    // Saute à l'adresse sauvée, c'est à dire l'étiquette @retour


// Corps du programme principal (main)
  Push  @retour       // Sauve l'adresse de retour sur la pile
  Jmp   Fonction1    // Saute à la fonction
@retour:  

En fait c'est l'équivalent de ce qu'on trouve avec "call-ret"

// définition d'une fonction

Fonction1:
  // code de la fonction
  // ...
  // fin de la fonction
  Ret  // Saute à l'adresse sauvée, c'est à dire l'étiquette @retour


// début du programme
  call Fonction1 // Sauve l'adresse de retour et saute à la fonction
@retour:         // l'exécution continuera ici après retour de fonction

Voilà, en fait l'adresse de retour est en quelque sort un paramètre obligatoire qui est passé à la fonction par l'intermédiaire de la pile.
Et donc le processeur intègre les mots clés "call-ret" tout simplement parce que les appels de fonction sont légions et ils devaient être optimisés et prendre le moins de place possible dans le code...