salut c'est mon premier post dans la section asm,
j'ai une question sur le mot PTR
J'utilise MASM
par exemple
 
double DWORD ?
 
mov ax, WORD PTR double
 
pourquoi l'expression  
mov ax, double
 est elle fausse  
 
double est une varialble contenant une adresse de depart
WORD PTR double est ausi une variable contenant une adresse de depart  
en quoi WORD PTR est il necessaire pour ne prendre que le premier mot de double
quelle difference y a t il entre les deux formes  
 
merci  

bin ax fait 16bits, donc fo que ty fasse entrer qqchose de 16bits

DWORD = 4 octets
WORD = 2 octets
 
mov ax,double => j'essaie de faire rentrer 4 octets dans un espace de 2 octets => BOUM
mov ax,WORD PTR double => j'essaie de faire entrer les 2 premiers octets pointés par l'adresse "double" dans un espace de 2 octets => OK

pouvez vous me dire la difference physique entre un pointeur WORD PTR et [double]
comment le processeur sait il que l'un est sur 4 bytes et l'autre sur 2

WORD PTR renvoie les 2 premiers octets pointés par l'adresse "double"
[double] renvoie le contenu de l'adresse mémoire "double", qui sera donc obligatoirement sur 4 octets (puisque "double" est déclaré comme une variable de 4 octets)

ce que je ne comprend pas c'est que double est une adresse
par exemple double remplace 0x00000000
 
si je fais  
mov eax, double
 
ca equivaut a
mov eax, [0x00000000]
 
et si je fais  
mov ax, [0x00000000]
ca devrait aussi marcher non.
 
Etantdonné que l'adresse ne donne aucune information sur la taille de la variable comment celle ci est elle definie?
 
est ce que double contient plus d'information qu'un simple
0x00000000
 

Le problème c'est que pour l'assembleur qui va transformer ton code en langage machine tu déclare une adresse symbolique comme pointant sur un mot de 32 bits
AX étant un registre 16 bits, l'assembleur te signal juste que tu essaie de mettre dans AX (16 bits) un contenu de 32 bits en C on ferait un cast ici le word ptr est l'équivalent du cast.
Ce n'est pas un problème du langage machine, seulement un problème de syntaxe propre à l'assembleur masm
je pense que nasm accepterait la conversion implicite sans problème.
exemple
mov [0], 1             provoquera une erreur car l'assembleur est incapable de déterminer s'il travaille sur des octets ou 16 bits ou 32 bits
mov [double], 1        ne provoquera pas d'erreur car l'assembleur sait qu'il travaille sur un 32 bits vu la déclaration préalable.

mov eax, [0x00000000]
et
mov ax, [0x00000000]
 
n'ont pas le même opcode forcément.

Sauf erreur de ma part,
mov eax, [0x00000000] et mov ax, [0x00000000]
ont le même code machine
il y aura éventuellement un octet avant ce code suivant le contexte du processeur à ce moment.
en contexte 16 bits mov eax, [0x00000000] aura un octet préfixe pour indiquer une opération 32 bits alors que
mov ax, [0x0000] n'en aura pas
en contexte 32 bits mov eax, [0x00000000] n'aura pas d'octet préfixe mais mov ax, [0x00000000] en aura un
tout comme mov eax, ebx et mov ax, bx ont le même code machine seul le contexte 32 bits ou 16 bits fera la différence et il faudra utiliser un octet préfixe modificateur de contexte pour passer du 16 bits au 32 bits ou inversement.

oui j'entends avec l'octet de préfixe.
sinon c'est tout à fait ça, et c'est 66h l'octet de préfixe (bon à savoir pour faire du 32bits avec un assembleur 16bits)