Accès en mémoire en assembleur

Fermé
tathoc - 6 mars 2009 à 06:12
 loupius - 8 mars 2009 à 03:18
Bonjour,
lorsque je programme en assembleur, je n'arrive pas accéder à une case dont j'ai l'adresse.
Voici le bout de code si = 0, taille = 2,

mov ax, taille
mov cx, si
mul cl
mov si, ax
add ax, bx
add ax, 120h
mov bx, ax
mov dx, [bx]
A la fin bx contient bien 0121h.Cependant la valeur que contient dx n'est pas celle qui se trouve à l'adresse 0121h.
Comment faire?

1 réponse

Je ne comprends bien ton code (Peut-être vais-je me tromper car pour moi l'assembleur x86 est bien loin):
Au départ: si=0 et taille=2
mov ax, taille	-> ax=2
mov cx, si	-> cx=0
mul cl		-> al*cl =résultat dans ax=2*0 donc ax=0
mov si, ax	-> si=0
add ax, bx	-> bx ???, supposons que bx=1 alors ax=ax+bx=ax+1 donc ax=1
add ax, 120h	-> ax=ax+120h=1+120h donc ax=121h
mov bx, ax	-> bx=121h
mov dx, [bx]	-> dx=contenu de la case mémoire ds:bx
Le tout est de savoir ce que vaut ds?
J'ai l'impression qu'il y a du code qui ne sert à rien.
Ai-je fait une erreur?
0
Exactement bx vaut 1 dès le départ.
Je cherchais dans ce code à ajouter des adresses pour arriver à l'adresse 121h.
Quand tu parles de l'adresse ds:bx, qu'est-ce que cela veut dire?
merci.
0
loupius > tathoc
8 mars 2009 à 03:18
D'abord je dois t'informer que je ne programme plus en assembleur x86, donc je n'ai pas suivi toute l'évolution des processeurs 8086, 80286, 80386, 80486................
Il faut savoir que sur les processeurs de type 8086 à (au moins) 80286, les registres étaient des 16 bits... alors comment pouvaient faire ces processeurs pour adresser 1 Mo alors qu'avec 16 bits on ne peut dépasser 64 Ko ???
L'astuce, pour Intel, a été d'inventer la segmentation:
Une adresse mémoire n'était pas seulement représentée par un registre de travail (de type bx, cx, dx...), mais par un savant calcul entre deux registres. Le calcul, par exemple, était le suivant: 16*ds + bx, ce qui permettait d'atteindre: 16 * 2^16 soit 1 Mo. le registre ds est appellé registre de segment; il existait plusieurs registres de segment: cs, ds,es et ss. 'cs' était réservé pour le code, 'ss' était réservé pour la pile; par contre 'ds' et 'es' étaient réservés pour les données et, en fonction de la situation, l'adresse réelle était calculée à partir de 'ds' ou 'es'. Pour un segment donnné, on pouvait donc accéder à une zone de 64 Ko.
Dans le cas présent, l'adresse réelle eût été ds:bx; c'est ainsi que cela se passait. Maintenant on a des registres 32 bits... et n'ayant pas suivi l'évolution, je resterais dans une certaine expectative... désolé.
0