Haypo: /* Solution Assembleur (2) */

Haypo — Mon, 19 Nov 2012 20:28:00 GMT

Solution Assembleur (2)

← Version précédente		Version du 19 novembre 2012 à 20:28
Ligne 151 :		Ligne 151 :
	* (2) - Pour mettre un registre Ã zÃ©ro, la mÃ©thode la plus rapide est "xor reg,reg", car XOR est une fonction de base du processeur.		* (2) - Pour mettre un registre Ã zÃ©ro, la mÃ©thode la plus rapide est "xor reg,reg", car XOR est une fonction de base du processeur.

-	* (3) - Turbo Pascal 7 ne connaissant pas les instructions 32 bits, on peut toujours les Ã©crire en langage machine. Pour avoir le code machine d'une instruction, on peut compiler un programme en assembleur ne contenant que cette instruction en demandant au compileur de crÃ©er un listing (avec le paramÃ¨tre "/Z" pour TASM 1.0 et 2.0), c'est Ã dire un fichier contenant le code assembleur dÃ©composÃ©e, interprÃ©tÃ© et traduit en code machine. Sinon, il existe aussi des programmes effectuant la convertion, mais je n'en connais pas directement. Pour revenir Ã notre "xor edi, edi", l'~~Ã©quivalant~~ en code machine est "66 33 FF", or "xor di,di" est Ã©quivaut Ã "33 FF", il suffit donc de rajouter le code "66h" en prÃ©fixe, prÃ©fixe de nombreuses instructions 32 bits en fait.	+	* (3) - Turbo Pascal 7 ne connaissant pas les instructions 32 bits, on peut toujours les Ã©crire en langage machine. Pour avoir le code machine d'une instruction, on peut compiler un programme en assembleur ne contenant que cette instruction en demandant au compileur de crÃ©er un listing (avec le paramÃ¨tre "/Z" pour TASM 1.0 et 2.0), c'est Ã dire un fichier contenant le code assembleur dÃ©composÃ©e, interprÃ©tÃ© et traduit en code machine. Sinon, il existe aussi des programmes effectuant la convertion, mais je n'en connais pas directement. Pour revenir Ã notre "xor edi, edi", l'Ã©quivalent en code machine est "66 33 FF", or "xor di,di" est Ã©quivaut Ã "33 FF", il suffit donc de rajouter le code "66h" en prÃ©fixe, prÃ©fixe de nombreuses instructions 32 bits en fait.

	* (4) - En 32 bits, l'instruction "STOSD" Ã©crira EAX et non AL, il faut donc rÃ©pÃ©ter "Coul" quatre fois dans EAX. On commence par l'Ã©crire dans AL, puis le copier dans AH, et enfin un "truc" pour le copier dans EAX. Le truc est en fait de dÃ©caler les octets de EAX de 16 bits vers la gauche Ã l'aide de l'instruction SHL, puis recopier l'ancienne valeur de AX dans AX (qui est la partie basse de EAX pour souvenir !). Remarque : l'instruction "SHL" nÃ©cessite de compiler en mode 286/287, on peut rajouter "{$G+}" au dÃ©but du programme pour ce fait.		* (4) - En 32 bits, l'instruction "STOSD" Ã©crira EAX et non AL, il faut donc rÃ©pÃ©ter "Coul" quatre fois dans EAX. On commence par l'Ã©crire dans AL, puis le copier dans AH, et enfin un "truc" pour le copier dans EAX. Le truc est en fait de dÃ©caler les octets de EAX de 16 bits vers la gauche Ã l'aide de l'instruction SHL, puis recopier l'ancienne valeur de AX dans AX (qui est la partie basse de EAX pour souvenir !). Remarque : l'instruction "SHL" nÃ©cessite de compiler en mode 286/287, on peut rajouter "{$G+}" au dÃ©but du programme pour ce fait.

Haypo le 18 octobre 2005 à 03:11

Haypo — Tue, 18 Oct 2005 03:11:40 GMT

Nouvelle page

[[CatÃ©gorie:Assembleur]]
{{Retour|Assembleur Intel x86|Retour Ã l'assembleur}}

== Lecture d'une touche au clavier ==

=== Principe ===

L'interruption matÃ©rielle 16h gÃ¨re le clavier. Elle possÃ¨de deux fonctions intÃ©ressantes :
* 00h : Lecture d'une touche;
* 01h : VÃ©rification de la prÃ©sence d'une touche dans le tampon clavier.

Mais si une touche est Ã©tendue (touches flÃ©chÃ©es, Â« page haut Â», etc.), il faudrait appeler deux fois la fonction 00h pour obtenir le code de la touche : la premiÃ¨re fois, un code null (00h) est renvoyÃ©, la seconde fois le code Ã©tendu de la touche. Sachant que le code ASCII est toujours infÃ©rieur Ã 128, on pourra ajouter 128 aux codes Ã©tendus pour, au final, n'avoir Ã appeler notre nouvelle fonction qu'une seule fois.

=== Solution Turbo Pascal ===

<pre>
(uses Dos;)
const MasqueFlagsCF = 1; { Masque pour isoler le bit CF des flags } (1)

function TouchPresse : Boolean;
var Regs: Registers; (2)
begin
with Regs do begin
AH := $01; { Fonction 01h: VÃ©rification de la prÃ©sence d'une touche }
Intr ($16,Regs); (3)
TouchPresse := (Flags and MasqueFlagsCF = MasqueFlagsCF); (1)
end;
end;

function LitTouche : Char;
var Regs: Registers;
begin
with Regs do begin
AH := $00; { Fonction 00h : Lecture d'une touche }
Intr ($16,Regs);

if AL=0 then (4)
LitTouche := Char(AH or 128) (5)
else
LitTouche := Char(AL);
end;
end;
</pre>

Analyse :
* (1) - Le type Registre
* (2) nous met Ã disposition les [#Flags Flags], met dans un mot d'ensemble (Word). Pour isoler le flag [#ListeFlag CF] (bit #0), on utilisera le truc : "if Flags and MASQUE = MASQUE" oÃ¹ MASQUE est une puissance de 2, la puissance est la position du bit (en partant de zÃ©ro). CF Ã©tant Ã la position 0 (bit #0), le MASQUE est donc 1 (2^0).(2) - Pour appeler une interruption, Turbo Pascal nous met Ã disposition (par l'unitÃ© DOS) le type "Registers" qui permet d'accÃ©der de faÃ§on virtuelle aux registres. Virtuelle car celÃ ne modifie par directement les registres, les registres sont tous envoyÃ©s comme "paramÃ¨tre", puis sont lus aprÃ¨s l'appel de "Intr" (3) (appelle d'une l'interruption).
* (3) - Enfin pour appeler une interruption, on utilise la fonction "Intr" avec comme paramÃ¨tre le numÃ©ro de l'interruption et les registres. Ici on utilise la fonction 00h de l'interruption 16h. Celle-ci retourne dans AL le code ASCII de la touche et AH contient le code Ã©tendu de la touche (si AL=0).
* (4) - Pour savoir si une touche est Ã©tendue, on vÃ©rifie que AL = #0.
* (5) - Pour ajouter 128 Ã la valeur de la touche Ã©tendue, on peut Ã©galement faire "OR 128", celÃ pose dans tous les cas le bit #7 de AH. Ca ne fonctionne que pour les puissances de 2 (1, 2, 4, 8, 16, 32, 64, 128, 256, ...).

=== Solution Assembleur ===

<pre>
function TouchPresse : boolean; assembler;
asm
mov ah,01h { Fonction 01h : VÃ©rifie qu'une touche soit disponnible }
int 16h { Appel l'interruption clavier }

mov al,1 { Une touche est prÃ©sente (TRUE) }
jnz @PasVide (1)
xor al,al { Pas de touche touche (FALSE) }

@PasVide:
end;

function LitTouche : char; assembler;
asm
xor ah,ah { Fonction 00h = Lit une touche du clavier }
int 16h { Appel l'interruption clavier }

or al,al { Est-ce une touche Ã©tendue? (AL=0) } (2)
jz @Etendue { Ouais -> AL = code Ã©tendu (AH) + 128 } (2)

ret { Touche standard -> on se tire }

@Etendue:
mov al,ah { AL = Code ASCII Ã©tendu }
or al,128 { Ajoute 128 Ã celui-ci pour le distinguer }
end;
</pre>

Analyse :
* (1) - La fonction 01h de l'interruption 16h renvoi la prÃ©sence d'une touche par le flag ZF. Pour le tester on utilise JNZ : ZF=0, ne fait rien; ZF=1 : Saute !
* (2) - La fonction 00h de l'interruption 16h renvoi le code ASCII de la touche dans le registre AL. Si celui-ci vaut 0, alors la touche est Ã©tendue, et le code est stockÃ© dans AH. Pour savoir si AL=0, on peut faire "cmp al,0; jz @Saut", mais il est plus rapide de faire le test par "or". Celui-ci modifie le flag ZF : Si AL=0, ZF=1 (ZF = Zero Flag !); si AL<>0, ZF=0.

== Effacement de l'Ã©cran dans le mode VGA ==

Mode VGA : 320x200 pixels en 256 couleurs.

Dans le mode VGA, la mÃ©moire vidÃ©o est placÃ©e Ã l'adresse $A000:$0000, et prend 320*200=64 000 octets. Le but du jeu est de remplir ces 64 000 octets avec une couleur prÃ©cise, c'est Ã dire un valeur codÃ©e sur un octet.

=== Solution en Turbo Pascal ===

fillchar (Mem[$A000:0],64000,Couleur); { Couleur Ã©tant un "Byte", un octet }

CelÃ fonctionne trÃ¨s bien, mais Turbo Pascal Ã©tant dÃ©veloppÃ© pour fonctionner avec les 286, processeur en 16 bits, fillchar fonctionnera donc en 16 bits (voir en 8 bits, je ne sais pas trop). On va donc l'optimiser en passant Ã©crivant dans la mÃ©moire avec les instructions 32 bits.

=== Solution Assembleur (1) ===

(intÃ©grÃ©e dans un programme Turbo Pascal, premiÃ¨re version, dite "Ã©ductive")

<pre>
Procedure EffaceEcran (Coul: byte);
begin
asm (1)
mov ax,0A000h(2)
mov es,ax { ES = A000h }

mov di,0 { Maintenant ES:DI pointe sur l'adresse A000:0000 }
mov al,[coul] { On lit la couleur passÃ©e en paramÃ¨tre } (3)
mov cx,64000 { 64 000 octets Ã remplir}
rep stosb { Ecrit CX fois l'octet AL Ã l'adresse ES:DI }
end; (1)
end;
</pre>

Analyse :
* (1) - En turbo Pascal, on peut intÃ©grer de l'assembleur n'importe oÃ¹ en tapant "asm { les instructions } end;".
* (2) - Les nombres hexadÃ©cimaux dÃ©butants par des lettres peuvent Ãªtre confondus avec des noms de variables, il faut alors rajouter un zÃ©ro en prÃ©fixe.
* (3) - Pour lire les paramÃ¨tres, rien de plus simple : taper son nom (les crochets ne sont pas obligatoires).

=== Solution Assembleur (2) ===

(version optimisÃ©e 32 bits)

<pre>
Procedure EffaceEcran (Coul: byte);
assembler; asm (1)
mov ax,0A000h
mov es,ax

{ xor edi, edi } (2)db 66h; xor di,di (3) { ES:DI pointe
sur l'adresse A000:0000 }
mov al,[coul] { On lit la couleur passÃ©e en paramÃ¨tre }
mov ah, al { Copie AL dans AH, donc AX = deux fois la couleur } (4)

mov bx, ax { Sauve AX dans le registre BX } (4)
{ shl eax,16 } db 66h; shl ax,16 { DÃ©place les deux octets de poids faible }
{ de EAX dans les octets de poids fort } (4)
mov ax, bx { Relit AX du registre BX } (4)
mov cx,64000/4 { 16 000 double-mots Ã remplir } (5)
{rep stosd } db 66h; rep stosw { Ecrit ECX fois le double-mot EAX Ã l'adresse ES:EDI } (6)
end; (1)
</pre>

Analyse :

* (1) Encore mieux, en turbo Pascal on peut dÃ©clarer une procÃ©dure qui n'utilise que l'assembleur, ce qui Ã©vite d'avoir Ã taper "begin" et "end;" inutiles.

* (2) - Pour mettre un registre Ã zÃ©ro, la mÃ©thode la plus rapide est "xor reg,reg", car XOR est une fonction de base du processeur.

* (3) - Turbo Pascal 7 ne connaissant pas les instructions 32 bits, on peut toujours les Ã©crire en langage machine. Pour avoir le code machine d'une instruction, on peut compiler un programme en assembleur ne contenant que cette instruction en demandant au compileur de crÃ©er un listing (avec le paramÃ¨tre "/Z" pour TASM 1.0 et 2.0), c'est Ã dire un fichier contenant le code assembleur dÃ©composÃ©e, interprÃ©tÃ© et traduit en code machine. Sinon, il existe aussi des programmes effectuant la convertion, mais je n'en connais pas directement. Pour revenir Ã notre "xor edi, edi", l'Ã©quivalant en code machine est "66 33 FF", or "xor di,di" est Ã©quivaut Ã "33 FF", il suffit donc de rajouter le code "66h" en prÃ©fixe, prÃ©fixe de nombreuses instructions 32 bits en fait.

* (4) - En 32 bits, l'instruction "STOSD" Ã©crira EAX et non AL, il faut donc rÃ©pÃ©ter "Coul" quatre fois dans EAX. On commence par l'Ã©crire dans AL, puis le copier dans AH, et enfin un "truc" pour le copier dans EAX. Le truc est en fait de dÃ©caler les octets de EAX de 16 bits vers la gauche Ã l'aide de l'instruction SHL, puis recopier l'ancienne valeur de AX dans AX (qui est la partie basse de EAX pour souvenir !). Remarque : l'instruction "SHL" nÃ©cessite de compiler en mode 286/287, on peut rajouter "{$G+}" au dÃ©but du programme pour ce fait.

* (5) - STOSD Ã©crit des double-mots (4 octets), or nous voulons remplir 64 000 octets. Il nous faudra donc Ã©crire 64 000/4 fois EAX. Remarque : pour STOSW, on divisera par 2 tout simplement :-)

* (6) - Une fois de plus, on peut Ã©tendre une instruction 16 bits Ã son Ã©quivalant en 32 bits en rajoutant le prÃ©fixe "66h". En rÃ©alitÃ© "REP STOSW" est "F3 AB" (F3 = "REP"), et "REP STOSD" est "F3 66 AB". Mais le processeur est tolÃ©rant, et le code est d'autant plus clair avec "db 66h; stosw", alors pourquoi s'en priver.

Exemples en assembleur Intel x86 - Historique des versions

Haypo: /* Solution Assembleur (2) */

Haypo le 18 octobre 2005 à 03:11