Bonjour!
 
je débute en ASM. j'ai épeluché pas mal de cours/posts/forums/tutorials...etc et je n'ai pas réussi à trouver un schéma qui (en fonction d'un programme type) décrit les mouvement de mémoires/registres/variables pour bien saisir comment marche un programme assembleur et de ce fait comment programmer en assembleur(je sais pas si je suis clair...)
 
Par exemple, je souhaitais juste faire un prog qui fait un simple login/passwd,j'ai réussi à coder et a vérifier à la touche saisie mais je n'arrive pas à faire pour un mot. je me doute que cela doit être simple mais justement je pense que y'a une subtilité en ASM que je n'ai pas saisi ou la syntaxe/méthode . je sais qu'il y a des transfert de registre en registre à faire, a créer un compteur...etc a comparer aussi, mais j'arrive pas à saisir justement le pourquoi du comment on doit bouger de mémoire en mémoire,que veulent dire ces syntaxes....
 
Je sais pas pourquoi,je bloque.je pense que je n'ai pas saisi le fonctionnement de quelque chose.
 
merci pour vos réponses.

Bonjour
Une case mémoire peut être considérée comme une variable.
Lorsqu'en C on fait un a = b; on fait un déplacement mémoire
en assembleur cela donnerait :
mov eax,[a]
mov [b], eax
on est obligé de passer par l'intermédiaire d'un registre la plupart du temps car il n'y a que très peu d'opérations de transfert direct en mémoire.
La différence essentielle entre un registre et la mémoire est sa rapidité d'accès et sa polyvalence.
On peur par exemple mettre un compteur de boucle en mémoire ou dans un registre. L'utilisation du registre ecx accélèrera le calcul.
Seul un registre peut servir de pointeur
soit en C :
char tamp[16];
char *puc;
int i;
puc = tamp
for (i=0; i < 16; i++)
{
  if (*puc++ == 0)
    break;
}
donnerait en asm
lea esi, [tamp] ; charge le pointeur (puc) dans le registre esi
mov ecx, 16     ; charge le nombre de passages dans la boucle
lbl1: mov al,[esi]  ; charge le caractère courant dans al (*puc)
                    ; lodsb marche très bien aussi
cmp al, 0       ;le compare à 0 -> or al, al marche très bien aussi
jz lbl2         ; branche au lbl2 si nul (break)
inc esi         ; incrémente le pointeur (puc++) inutile avec lodsb
dec ecx         ; décrémente le compteur
jnz lbl1        ; boucle tant que pas fini
lbl2:            ; suite  
 
un registre tel al ne peut contenir qu'un octet il faut donc utiliser la mémoire pour mettre ses variables.
l'énorme avantage de l'assembleur, c'est qu'il n'y a pas de type. Il ne connait que des suites d'octets, on peut donc les manipuler comme on veut, mais il faut que cela soit bien clair dans la conception du programme auparavant sinon le segmentation fault revient souvent.
 
tout cela peut paraitre confu, mais si on a pas bien compris la manipulation des pointeurs en C, c'est difficile de faire de l'assembleur, où on passe son temps à en manipuler.
 
Cordialement

effectivement j'ai eu beaucoup de mal à saisir les pointeurs en C.... je sais pas pourquoi les accèes mémoire m'ont toujours parus flous!
c'est pour cela que je doit bloquer.
je vais essayer de mieux comprendre justement les pointeurs.
 
merci!
en revanche, existe t'il un schéma simple qui décrit ce que fait exactement le CPU (avec les registres,les mémoires...etc)avec par exemple un programme ASM du type:
afficher écran bleu ou 1 pixel
 
   ;NASM-IDE ASM Assistant Assembler Project File
BITS 16    
ORG 0x0100  
 
SEGMENT .text  ;Main code segment
mov ax,0013h;           ;init du mode 320x200/256
int 10h;
mov ax,0a000h;          
mov es,ax;              
mov di,0;              
 
debut:
mov byte[es:di],01h;    ;on pointe vers le point couleur bleu 01h
inc di;                 ;on va mettre en memoire le suivant
cmp di,64001;           ;
je fin;                 ;fin du programme
jmp debut;              ;sinon on boucle
 
fin:
mov ah,00h;              
int 16h;  
mov ax,4c00h;    
int 21;

Bonjour
Pour pouvoir voir ce qui se passe exactement, le mieux est d'utiliser un débogueur assembleur. Il affiche les registres avec leur contenu, des portions de mémoire et la pile et permet de faire du pas à pas. Jadis j'utilisai celui de Borland
Je ne fais plus d'assembleur en mode DOS depuis 1992. C'est un peu désuet et à mon avis d'un intéret assez limité.
l'assembleur en mode 386 sur linux est bien plus palpitant.
l'assembleur se pratique en général pour des raisons de performance ou de place mémoire.
préférer xor di, di à mov di, 0
j'aurai plutôt écrit
xor di, di      ; pointe la mémoire à remplir
mov al, 1       ; valeur à mettre en mémoire
mov cx, 64000   ; nombre de case à modifier
rep stosb       ; rempli la mémoire
en plus performant
xor di, di      ; pointe la mémoire à remplir
mov ax, 0101h   ; valeur à mettre en mémoire
mov cx, 32000   ; nombre de case à modifier / 2
rep stosw       ; rempli la mémoire 2 cases à la fois
avec un 386 et + on peut même faire 4 cases à la fois
bon courage
cordialement

merci pour vos réponses!