Photographie/Sociétés et Organisations/Éditeurs de cartes postales/Melin-Ardeau

Melin-Ardeau était un éditeur de cartes postales installé à Saint-Denis-en-Val (Loiret).

Photographie/Sociétés et Organisations/Éditeurs de cartes postales/A. J. Laporte

Laporte était un éditeur français de cartes postales.

Photographie/Sociétés et Organisations/Éditeurs de cartes postales/Monton et Lescuy

Monton et Lescuy était un éditeur de cartes postales installé à Lyon (Rhône.

Photographie/Personnalités/B/Avgust Berthold

Avgust Berthold était un photographe slovène né à Puštal en 1880 et décédé à Ljubljana en 1919.

Programmation Assembleur/x86/Copie entre registres et mémoire

Syntaxes des assembleurs.
Il existe deux variantes principales et opposées de syntaxe pour les instructions en assembleur :
L'interprétation peut donc être ambiguë si on ne sait pas quelle syntaxe est employée.
Les assembleurs sous DOS et Windows utilisent la syntaxe Intel, qui semble plus naturelle pour les opérations arithmétiques et conserve l'ordre des expressions arithmétiques :
add eax, 7 ; EAX <- EAX+7
Les assembleurs sous Linux utilisent la syntaxe AT&T, qui conserve l'ordre des mots pour expliquer les expressions arithmétiques :
add $7, %eax ; Ajouter 7 à EAX
La distinction entre les deux syntaxes est donc importante à faire :
Transfert unitaire.
L'instruction la plus courante est MOV (abréviation de l'anglais "move" : déplacer) qui permet de transférer le contenu d'un emplacement mémoire vers un registre et inversement, ou entre deux registres de même taille.
Le nombre de bits transféré est défini par la taille du registre source ou cible du transfert.
Exemple (syntaxe destination, source) :
mov ax, bx ; transfert des 16 bits de BX vers AX.
Les assembleurs peuvent employer des suffixes pour le nom de l'instruction indiquant ce nombre d'octets :
Exemple (syntaxe source, destination) :
.data
valeur:
 .long 2
.text
 .global _start
_start:
 movl $6, %eax
 # %eax = 6
 movw %ax, valeur
 # valeur = 6
 movl $0, %ebx
 # %ebx = 0
 movb %al, %bl
 # %ebx = 6
 movl valeur, %ebx
 # %ebx = 6
 movl $valeur, %esi
 # %esi = l’address de valeur
 xorl %ebx, %ebx
 # %ebx = 0
 movw valeur(, %ebx, 1), %bx
 # %ebx = 6
 mov $1, %eax
 xorl %ebx, %ebx
 int $0x80
Transfert de séquence.
Une famille d'instructions gère les séquences d'octets en mémoire :
Quantité traitée.
Le nom de ces opérations se termine par un préfixe indiquant la quantité traitée à chaque appel :
Registres utilisés et opérations.
Ces opérations utilisent les registres dédiés pour adresser la mémoire :
Ces registres sont incrémentés ou décrémentés après chaque traitement par ces opérations, selon la valeur de l'indicateur de direction (DF) :
Mnémotechnique : "DF = Decrement Flag"
Cet indicateur est généralement positionné juste avant les instructions de traitement en utilisant l'instruction codice_31 (CLear Direction") ou codice_32 (SeT Direction").
Le tableau ci-dessous résume les opérations effectuées par les instructions et les registres utilisés :
Répétition et boucle.
Ces instructions effectuent le traitement d'une quantité unitaire de données, mais deviennent efficaces et puissantes en combinaison d'instructions répétant l'opération en boucle.
Pour répéter ces opérations, les instructions de boucle et répétition utilisent le registre CX (Counter) en le décrémentant et répétant l'opération tant que le compteur n'atteint pas zéro.
Le registre CX est donc initialisé avant la boucle ou répétition avec le nombre d'octets, de mots ou de double-mots à traiter.
mov cx, 0x1FF ; transférer 511 mots de 16 bits
cld ; incrémenter les pointeurs après chaque itération
rep ; répéter CX fois...
movsw ; ...le transfert d'un mot de 16 bits
Le flag Zero (ZF) est pris en compte seulement si l'opération qui suit est codice_25 ou codice_30.
Il est ignoré pour les opérations de transfert codice_24, codice_26 ou codice_29.
Cela signifie que pour ces 3 opérations codice_33 et codice_34 sont identiques, et les assembleurs ajoutent donc un alias codice_42 qui en général est compilé en une instruction codice_33.
Les préfixes codice_33 et codice_34 ne répète que l'instruction de séquence qui suit.
Pour répéter une série d'instructions, notamment pour codice_26 où l'assignation répétée dans le registre AX n'a pas d'intérêt réel, il faut utiliser les instructions codice_47.
Les instructions codice_47 ont 3 variantes dont le comportement ne varient que par rapport au flag zéro (ZF) :
 mov cx, 200 ; lire 200 octets
 cld ; incrémenter les pointeurs après chaque itération
 lodsb ; lecture d'un octet de DS:(E)SI dans AL
 call printchar ; appel à une sous-routine pour afficher le caractère de code AL
 cmp al, 0 ; compare AL à 00 qui marque la fin de chaîne de caractère
 loopnz iteration ; décrémente CX, et boucle si ZF=0 (AL différent de 00)
Enfin, il existe une instruction codice_52 qui ne modifie pas le registre (E)CX mais saute à l'adresse indiquée si le registre (E)CX vaut 0.
Dans le cas d'un compteur d'itération, elle permet donc de sortir d'une boucle infinie.
Préfixes de changement de segment.
Les préfixes de changement de segment n'influence que le registre de segment DS utilisé pour la source.
Cela signifie qu'ils n'influencent que les instructions codice_24, codice_25, codice_26.
mov cx, 0x1FF ; transférer 511 mots de 16 bits
cld ; incrémenter les pointeurs après chaque itération
es: ; utiliser le segment ES au lieu de DS
rep ; répéter CX fois...
movsw ; ...le transfert d'un mot de 16 bits
Autres transferts.
Le transfert entre certains registres pour lesquels il n'existe pas d'instruction peut s'effectuer en utilisant la pile, comme par exemple pour le transfert entre le registre AX et celui des indicateurs (FLAGS) :
pushf ; met la valeur du registre FLAGS dans le pile,
pop ax ; puis la retire de la pile pour la mettre dans le registre AX.
L'instruction codice_56 ("Load AH from Flags") permet de transférer la valeur des 8 bits de poids faible du registre FLAGS vers le registre AH (bits 15 à 8 du registre AX / EAX).
L'instruction codice_57 ("Save AH to Flags") effectue le transfert inverse.
L'instruction codice_58 transfère l'octet pointé par DS:(BX+AL) dans le registre AL.

Photographie/Personnalités/B/Inga Breder

Inga Breder était une photographe norvégienne née à Bodø en 1855 et décédée à Oslo le 28 décembre 1933.

Photographie/Personnalités/M/Elisabeth Meyer