Discussion :

[imkyozz]

Bonjour,

Je commence depuis cette années des études en informatique de gestion. J'ai aucuns difficultés pour les cours de web (php/css/html) ni pour les cours de C. Par contre, pour mon cours d'assembleur, ce n'est pas trop ça..

J'ai un devoir pour demain que je n'arrive pas vraiment à faire.

Voici l'exercice 1 :

Copier les valeurs 4321h et 8765h dans AX et BX.
–Échanger AX et BX
–Échanger AH et AL

Pour celui là je pense savoir plus ou moins comment faire.. J'ai écrit quelque chose du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
MOV AX, 4321h
MOV BX, 8765h
MOV CX, AX
MOV AX, BX
MOV BX, CX
MOV CH, AH
MOV AH, AL
MOV AL, CH

Ensuite on me demande un exercice deux :

•
Sauvegarder dans AX et DX les mots aux adresses 5002:3333 et 6004CBA.
–Echanger le contenu des 2 mots à ces adresses.

Là, les choses se compliquent.
Pour les adresses, je pensait les convertir en adresses physiques.. En faisant segment+offset..
De cette manière, 5002:3333 donnerait 8335h et 6004CBA donnerait : 14CBEh (?) pas sûr de moi pour celui là..

Pour la suite, je pensait faire pareil que l'exercice 1, mais je suis freiné par le fait que le contenu des variables aux adresses soient des mots et non des valeurs.. Est-ce que ça a de l'importance ? Ma manière est-elle bonne?

Pour l'exercice 3, c'est pareil que le 2 mais avec des valeurs, pas besoin de vous demander de l'aide.

Par contre le dernier exercice, ça ne va vraiment pas :

Dans les 8 octets à partir de F000:FFF5 de la mémoire, on trouve la date de création du BIOS au format JJMMAAaa.
–Amener aa,MM,jj dans AX, BX, CX.

Là par contre ça ne va vraiment pas, je ne vois vraiment pas comment copier seulement 2 octets à chaque fois.. Si vous pouviez m'éclairer..


Je sais que j'en demande vraiment beaucoup et que je ne comprends pas grand chose.. Mais je dois faire ce devoir qui sera côté pour demain et je suis vraiment en difficultés.. J'espères que vous voudrez bien m'apporter votre aide car je ne trouve vraiment pas grand chose pour m'aider là dessus sur internet.

Bonne journée.

[Obsidian]

Bonsoir,

Bonjour,
Je commence depuis cette années des études en informatique de gestion. J'ai aucuns difficultés pour les cours de web (php/css/html) ni pour les cours de C. Par contre, pour mon cours d'assembleur, ce n'est pas trop ça..

Je trouve que pour de l'informatique de gestion, le programme est assez poussé (peu de gens pratiquent encore l'assembleur, encore moins à l'école). Et pour quelqu'un qui débute, je trouve également que tu t'en sors plutôt bien.

J'ai un devoir pour demain que je n'arrive pas vraiment à faire.
Voici l'exercice 1 :
Pour celui là je pense savoir plus ou moins comment faire.. J'ai écrit quelque chose du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
MOV AX, 4321h
MOV BX, 8765h
MOV CX, AX
MOV AX, BX
MOV BX, CX
MOV CH, AH
MOV AH, AL
MOV AL, CH

Ce n'est pas mal du tout mais, en réalité, il existe l'instruction « XCHG » pour permuter facilement le contenu de deux registres. Tu peux également utiliser la pile si elle est correctement initialisée.

Ensuite on me demande un exercice deux :


Là, les choses se compliquent.
Pour les adresses, je pensait les convertir en adresses physiques.. En faisant segment+offset..
De cette manière, 5002:3333 donnerait 8335h et 6004:DCBA donnerait : 14CBEh (?) pas sûr de moi pour celui là..

C'est presque cela mais il faut décaler le segment de 4 bits vers la gauche avant de faire l'opération, sinon le segment en lui-même n'aurait aucun intérêt. Ça revient à le multiplier par 16 et/ou à lui rajouter un « zéro » hexadécimal :

      +--+--+--+--+
      |  |  |  |  |  <-- Offset
      +--+--+--+--+
   +--+--+--+--+
 + |  |  |  |  |     <-- Segment
   +--+--+--+--+
----------------------
   +--+--+--+--+--+
 = |  |  |  |  |  |  <-- Adresse physique
   +--+--+--+--+--+

Ceci donnerait « 6004:DCBA = 6DCFA » et « 5002:3333 ≡ (…je te laisse trouver) »

Par contre le dernier exercice, ça ne va vraiment pas :
Là par contre ça ne va vraiment pas, je ne vois vraiment pas comment copier seulement 2 octets à chaque fois.. Si vous pouviez m'éclairer..

Copier deux octets, c'est facile. Les registres que tu utilises sont naturellement larges de 16 bits, donc de deux octets.
Par contre, n'oublie pas qu'un octet s'écrit sur deux chiffres hexadécimaux, de 00 à FF. Et je pense que c'est le format qui t'est donné dans ton énoncé.

C'est à vérifier avec ton professeur mais si c'est bien le cas, cela signifie qu'il faut lire un seul octet par registre. Dans ce cas, commence par mettre à zéro les registres concernés, soit avec « MOV AX, 0 », soit avec « XOR AX, AX » si tu veux épater ton prof', et même chose avec les suivants. Ensuite, il te suffit de charger uniquement la partie basse du registre avec « MOV AL, xxxxxx », « MOV BL, xxxxx », etc.

Enfin, il faut retenir que tout cela ne concerne que le 8086 (et les x86 en général en mode réel). Les autres microprocesseurs fonctionnent selon des mécanismes similaires mais qui ont chacun leurs spécificités, et en suivant un jeu d'instructions propre.

[Invité]

Sympa tes exo tu est dans quel école ?

Personnellement je hais la gestion de la pile avec push et pop -_- je ne l'utilise tout simplement pas et donc pas d'initialisation, je nomme toujours les variables que j'utilise en RAM.
Après pour call et ret, je me suis pas penché sur l'idée que les adresses de début et de fin soient empilé, mais tant qu'il n'y a pas de problème, je n'ai pas a l'initialiser.

Enfin ça ne regarde que moi et ça fait plaisir de voir que dans certaines écoles, on apprend l'assembleur, ce langage est si mécompris selon moi, triste sort ^^

[imkyozz]

Donc, tout d'abord, je te remercie infiniment Obsidian. Ca fait plaisir de voir un forum où l'entraide existe encore et où on ne se fait pas agresser directement parce qu'on a pas suffisamment cherché.. Sachant que j'ai cherché, mais je n'ai pas trouvé énormément de site qui m'aidait pour ce que je cherchait et quand j'en ai trouvé, je les ai trouvés trop compliqués pour un débutant.. :/

Alors pour l'exercice un, nous n'avons pas vu la commande XCHG que tu m'as dit donc je préfères rester simple avec les bases que nous avons vues :p

Pour le deux, merci beaucoup. Pour l'autre si je calcule bien ça veut 53353h :p

Et pour l'exercice 4, il me semble avoir bien compris..

En tout cas, merci beaucoup à toi

@Typoli, je suis belge donc à mon avis tu ne dois pas connaître.. Mais sait-on jamais.. Je suis à Inpres à Seraing
Et oui nous apprenons l'assembleur et c'est pas mal, mais je trouve ça pas mal compliqué aussi, contrairement aux langages de programmations plus fréquemment utilisés

[chrtophe]

L'assembleur est plus proche de l'électronique. Les langages de type C, Pascal ont été inventé pour faciliter la programmation.

Pour la question de segment:offset, je vais essayer de t'expliquer simplement.

ce type d'accès vient surtout d'anciennes limitations en mémoire.

En fait il faut comprendre que la mémoire est divisé en blocs.

dans les adresses représentés en segment:offset le segment correspond au numéro du bloc et l'offset le décalage depuis ce bloc.
exemple :

l'adresse 07c0:0010 représente en réalité l'adresse 07C10 voici comment effectuer le calcul

07C0
.0010
07C10

Elle peut aussi être représenté par 0000:7C10

Vérifions :
0000
.7C10
07C10

Ce système de "fenêtre" permettait de dépasser les limitations en RAM.
pourquoi ?

Si je prends une case de 16 bits tels que 7C10, je vois que je peux aller de l'adresse 0000 à FFFF soit 64K
car FFFF en décimal=65535 donc 65536 valeurs 65536 octets/1024=64K

Avec le fenêtrage en segment offset, j'ai une case en plus donc je peux aller de l'adresse 00000 à FFFFF soit 1048576 octets/1024=1024 soit 1Mo. Par contre on ne pouvait travailler que par blocs de 64K

Voilà pour l'explication.

Avec l'évolution des CPUs le système de segment:offset a pris une autre signification en mode protégé (même fonctionnement en mode réel, en mode réel on est limité au 1er Mo de la RAM) : le segment est devenu un descripteur de segment (par rapport à sa valeur, une table contient le descriptif adresse physique de début, droits d'accès lecture/écriture, etc ...). Tu vois donc toujours des adresses de type 0010:C00000015 0010 étant le descripteur de segment, C00000015 l'adresse accédée (si le descripteur fait démarrer le "segment" à l'adresse 0 l'adresse physique sera C00000015 si il démarre à l'adresse 16, l'adresse physique sera C00000015+16=C0000002B) .

Ce système de segment:offset est sp&écifique au CPUs Intel, sur les autres CPUs, ce n'est quasiment pas utilisé.

[Obsidian]

Et oui nous apprenons l'assembleur et c'est pas mal, mais je trouve ça pas mal compliqué aussi, contrairement aux langages de programmations plus fréquemment utilisés

Oui mais malheureusement, il est devenu difficile aujourd'hui d'en saisir à la fois l'intérêt, la puissance et le plaisir que cela apporte. Nous sommes quelques uns à penser que ce sont les 8 bits des 1980 qui permettent d'en profiter le plus. Si tu as l'occasion de travailler sur ces anciens micro-processeurs (beaucoup faciles d'accès), lance-toi, quitte à continuer ensuite sur les artilleries lourdes que sont les micro-processeurs modernes. Ça te permettra de faire le distingo entre ce qui relève des grandes lignes communes à tous les assembleurs et ce qui tient des bizarreries d'un micro-processeur en particulier.

Pour la question de segment:offset, je vais essayer de t'expliquer simplement.
ce type d'accès vient surtout d'anciennes limitations en mémoire.
En fait il faut comprendre que la mémoire est divisé en blocs.

dans les adresses représentés en segment:offset le segment correspond au numéro du bloc et l'offset le décalage depuis ce bloc.
exemple :

l'adresse 07c0:0010 représente en réalité l'adresse 07C10 voici comment effectuer le calcul
07C0
.0010
07C10
Elle peut aussi être représenté par 0000:7C10
Vérifions :
0000
.7C10
07C10

C'est gentil mais c'est ce que l'on a expliqué au dessus.

Ce système de "fenêtre" permettait de dépasser les limitations en RAM.
pourquoi ? Si je prends une case de 16 bits tels que 7C10, je vois que je peux aller de l'adresse 0000 à FFFF soit 64K
car FFFF en décimal=65535 donc 65536 valeurs 65536 octets/1024=64K

Avec le fenêtrage en segment offset, j'ai une case en plus donc je peux aller de l'adresse 00000 à FFFFF soit 1048576 octets/1024=1024 soit 1Mo. Par contre on ne pouvait travailler que par blocs de 64K

Oui mais tout cela ne nous dit pas pourquoi Intel a développé un système à segments en particulier. Par exemple, on a toujours utilisé naturellement la mémoire paginée (avec ses avantages et ses inconvénients) pour augmenter facilement la quantité de mémoire disponible, sur à peu près toutes les architectures.

La nécessité vient d'abord du fait que la mémoire paginée a effectivement plusieurs inconvénients et qu'un plan visible de 64 Ko en soi, ça allait finir par devenir étroit. À partir du moment où la mémoire est « plus haute que large », il faut étendre un peu le plan mémoire. L'ennui est que ça ne se décrète pas : pour étendre le plan mémoire, il faut modifier physiquement le boîtier du circuit intégré en lui ajoutant des broches, l'implanter au sein du machine adaptée pour, et réécrire les logiciels pour qu'ils tiennent compte du nouveau plan mémoire et des registres étendus, qui n'ont donc plus la même largeur. Autrement dit : re-concevoir un ordinateur depuis zéro ou presque.

D'autre part, on essaie autant que possible de maintenir une largeur de bus qui soit elle-même une puissance de deux : les micro-processeurs 16 bits étaient au point depuis un moment déjà, mais il n'était pas concevable de passer directement au 32 bits. D'abord pour des raisons structurelles : les boîtiers DIL de l'époque n'étaient pas prévus pour recevoir autant de broches d'un coup. Ensuite, cela revenait à augmenter la complexité au carré : concevoir une puce qui contenait autant de transistors et être capable de la fondre de façon fiable et à grande échelle nécessitait une bonne décennie de développement. Avec cela, tous les points cités ci-dessus restaient à résoudre.

Ajouter 4 bits d'adresse pour multiplier par seize la taille du plan mémoire était revanche tout-à-fait envisageable. Il était même possible de recycler quelques lignes du boîtier original, quitte à leur conférer deux modes différents en fonction de la configuration locale de l'environnement et garantir ainsi la compatibilité matérielle du produit avec ses prédécesseurs. Le micro-processeur lui-même, par contre, resterait globalement le même. Il a donc fallu trouver un moyen de piloter ces quatre lignes supplémentaires.

Or, pour ce faire, il était totalement inconcevable d'implémenter d'emblée des registres de 20 bits : ils auraient occupé « deux octets et demi », leur contenu aurait été impossible à véhiculer sur l'architecture interne 16 bits et aurait nécessité plusieurs accès bus pour les enregistrer en mémoire. Ils auraient de fait brisé la compatibilité logicielle et électroniquement parlant, c'était une gageure. Par contre, il était très facile de créer deux registres de 16 bits, ou plus précisément, d'ajouter de nouveaux registres seize bits à ceux qui existaient déjà.

L'idée était alors d'utiliser ces nouveaux registres pour piloter les quatre lignes d'adresse supplémentaires à la manière d'un port d'entrée-sortie, les initialiser une fois, et laisser le micro-processeur travailler normalement ensuite. C'est pourquoi les registres de segments sont plus difficiles à manipuler que les registres d'index généraux habituels : c'est une extension limitée sur l'architecture 16 bits. C'est ce qui explique qu'on ne peut y accéder que par un MOV depuis une source déjà interne (donc un registre) ou par la pile, ne serait-ce que parce que c'est nécessaire pour les sauts longs.

À ce stade, on aurait pu se contenter d'utiliser les 4 bits de poids faible des registres de segments et de laisser inutilisé les suivants mais, outre le gâchis, cela serait revenu à accoler les segments consécutivement, les uns à suite des autres et par conséquent à ré-implémenter exactement le même système que la mémoire paginée ! Avec les mêmes inconvénients : il aurait été impossible de savoir simultanément la fin d'un segment et le début du suivant. Choisir en revanche d'utiliser les 4 bits de poids fort et d'additionner les autres, par contre, est déjà très facile à implémenter puisque les additions implicites se font déjà pour mettre en œuvre les modes d'adressage indexés. Cela permet en revanche de placer la fenêtre de 64 Ko n'importe sur le plan mémoire de 1 Mo, de façon totalement linéaire et avec une granularité de 16 octets ! Ça permet également de chevaucher les segments pour parcourir ce plan pratiquement sans interruption et donne la possibilité de charger plusieurs programmes conçus pour un plan de 64 Ko dans un espace propre et de façon complètement transparente pour eux.

La solution à segments s'est donc imposée d'elle-même.

[chrtophe]

imkyozz,

L'assembleur te permet de comprendre le fonctionnement interne d'un ordinateur. J'ai commencé sur CPU 68000, puis suis passé sur x86 et j'avoue que j'ai eu du mal avec la segmentation que je n'utilisais pas sur 68000.

C'est vrai que maintenant, on n'en fait quasiment plus de l'assembleur, mais c'est très bien d'en avoir au moins des notions.

La "pagination" est apparue tardivement sur les x86, et à l'époque des 8bits, il fallait ajouter une unité de pagination dans la machine pour pouvoir en avoir la fonctionnalité. C'était réservé aux gros systèmes (questions de coûts je pense, mais c'est une époque que j'ai à peine connue). la pagination sert à gérer la mémoire virtuelle, tu n'y a pas accès sur les 80x86 (en mode réel, un x86 de dernière génération se comporte comme un 80x86)

mais cela est un autre sujet...
Si le sujet t’intéresse jettes un oeil là-dessus :
pour l'assembleur x86 : http://esauvage.developpez.com/tutor...tel-avec-nasm/
celui-ci par l'aspect notation AT&T : http://asm.developpez.com/cours/gas/
http://fr.wikipedia.org/wiki/Mode_prot%C3%A9g%C3%A9