CT Amphi4 Mips

Amphi 4 : Introduction au
langage d’assemblage MIPS

(suite)
I. Codage des instructions :

Format, adressage
II. Désassemblage
Oct. 2009 Archi INFO1 Ch. T. Amphi 4 1

Représentation des instructions
2. Représentation des instructions

3. Format pour les opérations registre-
registre
4. Format pour les immédiats et
adressage relatif
5. Format pour les sauts et adressage
absolu

Le concept de “Stored-Program”
• Les ordinateurs sont construits selon 2 principes
clés :
1) Les instructions sont représentées par des
nombres.
2) Par conséquent, les programmes peuvent
être stockés en mémoire comme des données
(d’où la possibilité de les lire et d’y écrire).
• Cela simplifie la technologie SW/HW :
– Les mêmes circuits sont utilisés pour tout ce
qui est stocké en mémoire

Conséquence 1 : tout a une adresse
• Puisqu’instructions et données sont également
stockées en mémoire comme des nombres, tout a
une adresse mémoire.
– Les branchements et les sauts les utilisent
• Rappel : les pointeurs (en C) ne sont rien d’autre
que des adresses mémoire : ils peuvent “pointer”
n’importe quel octet stocké en mémoire
– Un usage non contraint des adresses peut mener à des
bogues sournoises
• Un registre conserve l’adresse de l’instruction en
cours d’exécution : “Program Counter” (PC)
– Tout simplement un pointeur (cf le nom utilisé par Intel :
Instruction Address Pointer)
Conséquence 2: compatibilité binaire
• Les programmes sont distribués sous forme
binaire
– Ils sont liés à des jeux d’instructions spécifiques
– Versions différentes pour Macintosh et PC
• On souhaite pouvoir exécuter les anciens
programmes sur les machines récentes
• Cela influe sur l’évolution des jeux d’instructions
• Par exemple, le choix d’Intel 8086 en 1981 pour le
1er PC IBM est la principale raison pour laquelle les
PC les plus récents (Pentium 4) utilisent un jeu
d’instructions de la famille 80x86
Codage numérique des instructions (1/2)
• Jusqu’à présent, toutes les données sont
codées dans des mots (blocs de 32 bits) :
– Chaque registre accueille un mot.
– lw et sw transfèrent un mot à la fois.
• Comment représenter les instructions?
– Rappel : la machine ne reconnaît que des
suites de 0 et de 1.
– MIPS recherche la simplicité : puisque les
données sont des mots, on adopte le
même format pour les instructions
Codage numérique des instructions (2/2)
• 1 mot = 32 bits, on divise donc chaque mot-
instruction en champs (fields).
• Chaque champ donne à la machine une
information sur l’instruction.
• On pourrait définir des champs différents pour
chaque instruction, mais le choix de la
simplicité pousse à se restreindre à
seulement 3 formats de base :
– Format R
– Format I
– Format J
Formats d’instructions
• Format I : utilisé pour les instructions utilisant
des immédiats, pour lw et sw (car l’offset
compte comme un immédiat), et pour les
branchements (beq et bne),
– (mais pas pour les décalages)
• Format J : utilisé pour j et jal
• Format R : utilisé pour toutes les autres
instructions

Instructions de format R (1/5)
• On partitionne le mot-instruction en champs de
longueurs respectives : 6 + 5 + 5 + 5 + 5 + 6 = 32
6 5 5 5 5 6
• Chaque champ porte un nom

opcode rs rt rd shamt funct
• Important : chaque champ est traité comme

un entier non signé.
– Par exemple, les champs de 5 bits peuvent
représenter tout entier compris entre 0 et 31 (et les
champs de 6 bits tout entier compris entre 0 et 63)
• Que nous disent ces champs ?
– opcode: détermine partiellement l’instruction
• N.B. : vaut 0 pour toutes les instructions R.
– funct: en combinaison avec l’ opcode, ce
nombre détermine complètement l’instruction
– Question : pourquoi ne fusionne-t-on pas
opcode et funct en un unique champ de 12
bits ?
• Réponse : plus tard.

• Les autres champs :
– rs (pour Source Register): en général,
utilisé pour spécifier le registre contenant le
1er opérande
– rt (pour Target Register): en général,
utilisé pour spécifier le registre contenant le
2e opérande (N.B. Le nom est trompeur)
– rd (pour Destination Register): en général,
utilisé pour spécifier le registre destiné à
accueillir le résultat du calcul

• Remarques sur les champs registres :
– Chaque champ registre a exactement 5 bits, il peut
donc représenter un entier non signé entre 0 et 31.
– Sur la diapo précédente, on a utilisé “généralement”
à cause des exceptions (voir plus tard). E.g.,
• mult et div ne codent rien d’important dans le
champ rd puisque les registres destinataires sont
hi et lo
• mfhi et mflo ne codent rien d’important dans les
champs rs et rt puisque la source est
déterminée par l’instruction (cf. P&H p. 264)

• Champ shamt (pour shift amount):

– Ce champ code l’amplitude du décalage.
Décaler un mot de 32 bits de plus de 31
positions est inutile, le champ shamt a
donc seulement 5 bits, ce qui permet de
représenter tous les entiers entre 0 et 31.
– Ce champ vaut 0 pour toutes les
instructions sauf les décalages.
• Pour tous les détails, cf. le “green insert card”
de P&H, COD 3e

Format R : exemple (1/2)
• Instruction MIPS :
add $8,$9,$10
opcode = 0
funct = 32
rd = 8 (destination)
rs = 9 (1er opérande)
rt = 10 (2e opérande)
shamt = 0 (ce n’est pas un décalage)

Format R : exemple (2/2)
add $8,$9,$10
Représentation décimale de chaque champ :
0 9 10 8 0 32
Représentation binaire de chaque champ :
000000 01001 01010 01000 00000 100000
hex
Représentation hex de l’instruction : 012A4020hex
(Représentation décimale de l’instruction : 19,546,144ten)
– C’est une instruction en langage machine

Instructions de format I (1/4)
• Que faire pour les instructions qui manient des
immédiats ?
– Un champ de 5 bits ne peut représenter que
32 valeurs différentes : c’est très insuffisant
pour les immédiats
– Idéalement, MIPS aurait un seul format, mais
il est nécessaire de faire des compromis
• On définit un nouveau format d’instruction qui
est partiellement cohérent avec le format R :
– On remarque d’abord qu’une instruction qui
manie un immédiat utilise au plus 2 registres.
• On partitionne le mot-instruction en champs de
longueurs respectives : 6 + 5 + 5 + 16 = 32
6 5 5 16
• Chaque champ a un nom :
opcode rs rt immediate
• Points clés : seul un champ ne correspond à

aucun champ du format R ; le champ opcode
est toujours au même endroit.

• Que nous disent ces champs ?
– opcode: même signification que pour le format R, mais
suffit à déterminer complètement l’instruction (il n’y pas
de champ funct dans le format I)
– Cela explique aussi pourquoi le format R a 2 champs
de 6 bits (au lieu d’un champ de 12 bits) pour
déterminer l’instruction : on garantit ainsi une certaine
cohérence des formats.
– rs: spécifie le n° de l’unique registre opérande (s’il y en
a un)
– rt: spécifie maintenant le n° du registre qui recueille le
résultat du calcul (d’où le nom de target register)

• Le champ immediate :
– Pour addi, slti, sltiu, le signe de
l’immédiat est étendu aux 16 bits de plus
haut poids. L’immédiat est donc traité
comme un entier signé.
– 16 bits  on peut donc représenter 216
valeurs différentes
– C’est suffisant pour traiter l’offset d’une lw
ou sw typique, ainsi que la majorité des
valeurs utilisées dans un slti.
• N.B. Si l’immédiat est trop grand : cf. plus tard

Format I : exemple (1/2)
addi $21,$22,-50
opcode = 8
rs = 22 (opérande)
rt = 21 (registre cible)
immediate = - 50

Format I : exemple (2/2)
addi $21,$22,-50
Représentation décimale des valeurs de champs :
8 22 21 -50
Représentation binaire des valeurs de champs :

001000 10110 10101 1111111111001110
Représentation hex de l’instruction : 22D5 FFCEhex
(Représentation décimale de l’instruction: 584,449,998ten)

Format I : deux problèmes (1/4)
• Problème 1 : un nombre non signé qui subit une extension
de signe ?
– addiu, sltiu, étendent le signe de leur immédiat.
• Justification
– addiu permet d’additionner sans test d’overflow
– sltiu doit pouvoir utiliser le même HW
• Cela signifie-t-il qu’on obtient des réponses fausses?
• Non, mais l’assembleur doit traiter tout immédiat non
signé 215 ≤ n < 216 (i.e., avec un 1 en position 15 et
des 0 dans les deux octets de plus haut poids) de la
même façon que des nombres trop grands …

• Problème 2 :
– Les instructions addi, lw, sw et slti
opèrent le plus souvent sur des immédiats
assez petits pour tenir dans le champ
immediate…
– …mais si l’immédiat est trop grand ?
– Il faut un moyen de traiter des immédiats
de 32 bits.

• Solutions envisagées pour le problème 2 :
– Le traiter au niveau software et ajouter une
instruction
– Ajouter une instruction d’assemblage (sans
changer les instructions existantes)
• Nouvelle instruction :
lui register, immediate
– lui pour Load Upper Immediate
– place un immédiat de 16 bits dans les deux
octets de plus haut poids du registre spécifié
– les autres bits sont mis à 0.
• Qu’apporte lui ?
– Exemple:
addi $t0,$t0, 0xABABCDCD
devient:
lui $at, 0xABAB
ori $at, $at, 0xCDCD
add $t0,$t0,$at
– Toute instruction de format I a un champ
immediate de 16 bits.
– L’assembleur peut-il faire ce genre de
transformation automatiquement ?
Branchements: adressage relatif (1/5)
• On utilise le format I pour les branchements :
opcode rs rt immediate
• L’opcode différencie beq de bne
• rs et rt codent les n° des registres à comparer
• Que peut représenter le champ immediate ?
– Immediate n’a que 16 bits
– PC (pour Program Counter) contient l’adresse
mémoire de l’instruction en cours d’exécution; c’est
un pointeur de 32 bits (en français, CP)
– Le champ immediate ne peut donc pas spécifier
absolument l’adresse de branchement.
• Quelle est l’utilisation normale des branchements ?
– Compilation de if-else, while, for
– Les boucles sont généralement “petites” :
typiquement moins de 50 instructions
– Les appels de fonctions et les branchements
inconditionnels sont compilés en utilisant les
instructions de saut (j and jal), pas des
branchements.
• Conclusion : on peut souhaiter se brancher
n’importe où en mémoire, mais généralement un
branchement modifie peu la valeur du CP.
• Une solution : l’adressage relatif (PC-
Relative Addressing)
• On décide de considérer le champ de 16 bits
immediate comme un entier signé en
complément à deux à ajouter à la valeur du
CP.
• On peut maintenant se brancher à une
distance de ± 215 octets du contenu du CP, ce
qui devrait suffire pour traiter les boucles.
• Peut-on faire mieux ?

• On sait que les instructions sont des mots ;
elles sont donc alignées (l’adresse mémoire,
en octets, est toujours un multiple de 4).
– Le nombre d’octets à ajouter au contenu du
CP sera donc toujours un multiple de 4.
– On peut donc considérer que le champ
immediate compte des mots.
• On peut maintenant se brancher à une
distance de ± 215 mots du contenu du CP (ou
± 217 octets), et traiter des boucles 4 fois plus
grosses.
• Calcul de l’adresse de branchement :
– Si la condition de branchement n’est pas
respectée : CP = CP + 4
(CP+4 = adresse en octets de l’instruction suivante)
– Si la condition de branchement est
respectée: CP = (CP + 4) + (immediate * 4)
– Observations
1 Le champ Immediate spécifie le nombre de mots à
sauter, c’est-à-dire le nombre d’instructions.
2 Le champ Immediate peut être positif ou négatif.
3 Pour des raisons matérielles, on ajoute immediate à
(CP+4)
Branchement : exemple (1/3)
• Code MIPS :
Loop: beq $9,$0,End
add $8,$8,$10
addi $9,$9,-1
j Loop
End:
•beq est au format I :
opcode = 4
rs = 9 (1er opérande)
rt = 0 (2e opérande)
immediate = ???
• Code MIPS :
Loop:beq $9,$0,End
addi $8,$8,$10
addi $9,$9,-1
j Loop
End:
• Valeur du champ immediate =
Le nombre d’instructions à ajouter (ou
soustraire) au CP, en commençant à
l’instruction qui suit le branchement.
– Dans le cas du beq supra, immediate = 3
• Code MIPS :
Loop:beq $9,$0,End
addi $8,$8,$10
addi $9,$9,-1
j Loop
End:
Représentation décimale des champs :

4 9 0 3
Représentation binaire des champs :
000100 01001 00000 0000000000000011
Instructions de format J (1/5)
• Pour les branchements, on a supposé qu’on
ne chercherait pas à se brancher trop loin ; on
s’est limité à spécifier le changement du CP.
• En revanche, pour des sauts (j et jal), on
doit pouvoir sauter à n’importe quelle adresse
de la mémoire.
• Idéalement, on souhaiterait pouvoir spécifier
une adresse mémoire de 32 bits.
• Malheureusement, on ne peut pas faire tenir
un opcode de 6 bits et une adresse de 32 bits
dans un seul mot.
• On définit deux champs de 6 + 26 = 32 bits :
6 bits 26 bits
• Comme d’habitude, les champs ont un nom
opcode target address
• Remarques clés
– Le champ opcode ne change pas par
rapport aux formats R et I : cohérence.
– On réunit tous les autres champs pour faire
de la place pour de “grandes” adresses.
• On peut ainsi spécifier 26 des 32 bits d’une
adresse.
• Optimisation liée à l’alignement :
– Comme pour les branchements, les sauts
n’ont pour cible que des adresses word-
aligned (les deux derniers bits sont donc
toujours 00, en binaire).
– On peut considérer cela comme
systématiquement acquis.

• On peut ainsi spécifier 28 des 32 bits d’une
adresse.
• Comment obtenir les 4 bits manquants ?
– Par convention, on prend les 4 bits de plus
haut poids du PC.
– Techniquement, cela signifie qu’on ne peut
sauter à n’importe quelle adresse mémoire,
mais cela suffit dans 99.9999…% des cas
(longueur des programmes < 256 Mo)
– N.B. s’il faut absolument une adresse de 32 bits, on
peut la placer dans un registre et utiliser un jr.
• Résumé :
PC actualisé = { PC[31..28], target address, 00 }
• N.B. : { , , } représente une concaténation
{ 4 bits , 26 bits , 2 bits } = adresse de 32 bits
• Par exemple,
{ 1010, 11111111111111111111111111, 00 }
= 10101111111111111111111111111100
– N.B. cette notation est celle de Verilog

Récapitulatif sur les formats
• MIPS Machine Language Instruction:
32 bits représentant une instruction unique
R opcode rs rt rd shamt funct
I opcode rs rt immediate
J opcode target address
• Les branchements utilisent l’adressage relatif

au CP, les sauts utilisent l’adressage absolu.
• Le désassemblage est facile et commence par
le décodage de l’opcode.

II. Désassemblage
1. Désassemblage
2. Pseudo-instructions et variétés
de langages d’assemblage
(TAL vs MAL)

Décodage du langage machine
• Comment “traduire” du code binaire en code C ?
• Pour chaque mot de 32 bits :
– Regarder l’opcode: 0 correspond au format R,
2 ou 3 au format J, les autres valeurs au
format I.
– Utiliser le type pour déterminer les champs.
– Écrire le code MIPS, en traduisant
convenablement chaque champ (en nom, n°
de registre, nombre binaire/hex).
– Traduire ce code MIPS en code C valide. Est-
ce toujours possible ? Unique?
Décodage : exemple (1/7)
• Voici 6 instructions en langage machine (en
hexadécimal) :
00001025hex
0005402Ahex
11000003hex
00441020hex
20A5FFFFhex
08100001hex
• On suppose que la 1re instruction se trouve à
l’adresse 4.194.304ten (0x00400000hex).
• 1re étape : on convertit l’hex en binaire
• Les 6 instructions en binaire:
00000000000000000001000000100101
00000000000001010100000000101010
00010001000000000000000000000011
00000000010001000001000000100000
00100000101001011111111111111111
00001000000100000000000000000001
• 2e étape : identifier l’opcode et le format
R 0 rs rt rd shamt funct
I 1, 4-63 rs rt immediate
J 2 ou 3 target address
• On examine les 6 premiers bits pour
déterminer le format :
Format:
R 00000000000000000001000000100101
R 00000000000001010100000000101010
I 00010001000000000000000000000011
R 00000000010001000001000000100000
I 00100000101001011111111111111111
J 00001000000100000000000000000001
• Décodage de l’opcode:
0 correspond au format R, 2 et 3
correspondent au format J, les autres valeurs
au format I.
• 3e étape : séparation des champs
• On sépare les champs (en utilisant l’opcode)
Format:
R 0 0 0 2 0 37
R 0 0 5 8 0 42
I 4 8 0 +3
R 0 2 4 2 0 32
I 8 5 5 -1
J 2 1,048,577
• 4e étape : traduire (“désassembler”) en

instructions d’assemblage MIPS
• Code assemblage MIPS (1re mouture) :
Adresses : Instructions d’assemblage :
0x00400000 or $2,$0,$0
0x00400004 slt $8,$0,$5
0x00400008 beq $8,$0,3
0x0040000c add $2,$2,$4
0x00400010 addi $5,$5,-1
0x00400014 j 0x100001
• On peut faire mieux : on traduit en utilisant des
instructions MIPS plus “parlantes” (on ajoute
des étiquettes, etc.)
• Code assemblage MIPS (2e mouture):
or $v0,$0,$0
Loop: slt $t0,$0,$a1
beq $t0,$0,Exit
add $v0,$v0,$a0
addi $a1,$a1,-1
j Loop
Exit:
• 5e étape : traduire en code C (faire
preuve d’imagination !)

Départ Hex : Arrivée code C (cf. associations infra)
$v0: produit
00001025hex
$a0: multiplicande
0005402Ahex
11000003hex $a1: multiplicateur
00441020hex produit = 0;
20A5FFFFhex while (multiplicateur > 0) {
08100001hex produit += multiplicande;
or $v0,$0,$0 multiplicateur -= 1;}
Loop: slt $t0,$0,$a1 La grande idée : les
beq $t0,$0,Exit instructions sont des
add $v0,$v0,$a0 nombres, le code est traité
addi $a1,$a1,-1 comme des données
j Loop
Exit:
Retour sur lui
• Rappel : à quoi lui sert-elle ?
– Exemple: addi $t0,$t0, 0xABABCDCD
devient : lui $at, 0xABAB
ori $at, $at, 0xCDCD
add $t0, $t0, $at
• L’assembleur pourrait-il faire cela
automatiquement ?
• Si l’immédiat ne tient pas sur 16 bits, alors
remplacer automatiquement addi par la
séquence lui, ori, add

“True Assembly Language” (1/3)
• Pseudo-instruction: une instruction MIPS qui
ne correspond pas à une instruction en langage
machine, mais à plusieurs instructions MIPS
• Comment traiter les pseudo-instructions?
– Elles sont décomposées par l’assembleur en
plusieurs “véritables” instructions MIPS.
– Qu’est-ce qu’une “véritable” instruction MIPS ?
Réponse infra
• D’abord quelques exemples

Pseudo-instructions : exemples (1/3)
• Register Move
move reg2,reg1
correspond à :
add reg2,$zero,reg1
• Load immediate
li reg,valeur
Si la valeur tient sur 16 bits :
addi reg,$zero,value
Sinon :
lui reg, bits 31-16 de valeur
ori reg, $zero, bits 15-0 de valeur

• Problème :
– Pour décomposer une pseudo-instruction,
l’assembleur peut avoir besoin d’un registre
supplémentaire.
– S’il utilise un registre ordinaire, il écrasera ce
que le programme y a écrit.
• Solution :
– On réserve un registre ($1, appelé $at pour
assembler temporary) pour cette tâche.
– Comme l’assembleur peut l’utiliser à tout
moment, il est sage de le laisser de côté pour
coder.

Pseudo- instructions : exemples (2/3)
• Instruction Rotate Right
ror reg, value
décomposée en :
srl $at, reg, valeur 0
sll reg, reg, 32-valeur
or reg, reg, $at 0
• Instruction No Operation
nop
Décomposée en :,
sll $0, $0, 0 (= 0ten)

Pseudo-instructions : exemples (3/3)
• Opérande erroné pour l’instruction
addu reg,reg,valeur # addiu attendu
Si valeur tient sur 16 bits, l’instruction ci-dessus

est changée en :
addiu reg,reg,valeur
Sinon elle est changée en :
lui $at, bits 31-16 de valeur
ori $at,$at,bits 15-0 de valeur
addu reg,reg,$at
• Comment éviter la confusion ?

• MAL (pour MIPS Assembly Language) : le
jeu d’instructions qu’un prorammeur peut
utiliser pour coder en MIPS ; cela inclut les
pseudo-instructions
• TAL (pour True Assembly Language):
ensemble des instructions qui peuvent
effectivement être traduites en une unique
instruction machine (un mot de 32 bits)
• Tout programme doit être traduit de MAL
en TAL avant la traduction en binaire.
Traitement des pseudo-instructions
• Question :
– Comment MIPS reconnaît-il les pseudo-
instructions ?
• Réponse :
– Il cherche les pseudo-instructions
“officielles”, comme ror ou move
– Il cherche les cas spéciaux (opérandes ne
correspondant pas à l’opération) et cherche
à les traiter adéquatement

Exemple : récrire du TAL en MAL
• TAL:
or $v0,$0,$0
beq $t0,$0,Exit
add $v0,$v0,$a0
addi $a1,$a1,-1
j Loop
Exit:

Exemple : récrire du TAL en MAL
• TAL : or $v0,$0,$0
beq $t0,$0,Exit
add $v0,$v0,$a0
addi $a1,$a1,-1
j Loop
• MALExit:
: li $v0,0
Loop: bge $zero,$a1,Exit
add $v0,$v0,$a0 sub
$a1,$a1,1 j Loop
Exit:

CT Amphi4 Mips

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

CT Amphi4 Mips

Hochgeladen von

Copyright:

Verfügbare Formate

Amphi 4 : Introduction au

langage d’assemblage MIPS

I. Codage des instructions :

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 1

2. Représentation des instructions

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 2

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 3

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 8

• Chaque champ porte un nom

• Important : chaque champ est traité comme

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 10

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 11

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 12

• Champ shamt (pour shift amount):

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 13

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 14

– C’est une instruction en langage machine

• Points clés : seul un champ ne correspond à

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 17

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 18

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 19

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 20

Représentation binaire des valeurs de champs :

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 21

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 22

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 23

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 28

Représentation décimale des champs :

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 36

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 38

• Les branchements utilisent l’adressage relatif

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 39

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 40

• 4e étape : traduire (“désassembler”) en

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 47

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 49

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 50

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 51

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 52

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 53

Si valeur tient sur 16 bits, l’instruction ci-dessus

• Comment éviter la confusion ?

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 54

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 56

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 57

Oct. 2009 Archi INFO1 Ch. T. Amphi 4 58

Das könnte Ihnen auch gefallen