Jeu d instructions et modes d adressage MIPS
|
|
|
- Raoul St-Jean
- il y a 6 ans
- Total affichages :
Transcription
1 Jeu d instructions et modes d adressage MIPS Vincent Risch, mai 2008, révision mai 2014 I.U.T., Aix-Marseille Université Jeu d instructions et modes d adressage MIPS p. 1
2 MIPS : Introduction Architecture (0,3) typique d une machine RISC Jeu d instructions et modes d adressage MIPS p. 2
3 MIPS : Introduction Architecture (0,3) typique d une machine RISC Développé fin des années 90, à partir des travaux de John L. Hennessy Jeu d instructions et modes d adressage MIPS p. 2
4 MIPS : Introduction Architecture (0,3) typique d une machine RISC Développé fin des années 90, à partir des travaux de John L. Hennessy Implémentations actuelles : MIPS32 et MIPS64 Jeu d instructions et modes d adressage MIPS p. 2
5 32 registres Registres généraux : Nom Numéro de registre Usage $zero 0 Dédié à la constante 0 $v0 $v1 2 3 Dédié à l évaluation des expressions $a0 $a3 4 7 Stockage des arguments lors des appels de fonctions $t0 $t Registres temporaires $s0 $s Registres sauvegardés $t8 $t Registres temporaires supplémentaires $gp 28 Pointeur global $sp 29 Pointeur de pile $fp 30 Pointeur de frame $ra 31 Pointeur d adresse retour Jeu d instructions et modes d adressage MIPS p. 3
6 32 registres Registres généraux : Nom Numéro de registre Usage $zero 0 Dédié à la constante 0 $v0 $v1 2 3 Dédié à l évaluation des expressions $a0 $a3 4 7 Stockage des arguments lors des appels de fonctions $t0 $t Registres temporaires $s0 $s Registres sauvegardés $t8 $t Registres temporaires supplémentaires $gp 28 Pointeur global $sp 29 Pointeur de pile $fp 30 Pointeur de frame $ra 31 Pointeur d adresse retour Registres réservés : Nom Numéro de registre Usage $at 1 Réservé à l assembleur $k0 $k Réservé au système d exploitation Jeu d instructions et modes d adressage MIPS p. 3
7 Formats d instruction Trois formats d instruction : Registre (type R) instructions UAL Jeu d instructions et modes d adressage MIPS p. 4
8 Formats d instruction Trois formats d instruction : Registre (type R) instructions UAL Immédiat (type I) instructions UAL Jeu d instructions et modes d adressage MIPS p. 4
9 Formats d instruction Trois formats d instruction : Registre (type R) instructions UAL Immédiat (type I) instructions UAL Saut (type J) ruptures de séquence Jeu d instructions et modes d adressage MIPS p. 4
10 Format R 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits op rs rt rd décal fonct 1. op : code opération 2. rs : registre opérande source 3. rt : registre opérande source 4. rd : registre opérande destination 5. décal : décalage 6. fonction : sélectionne la variante de l opération Jeu d instructions et modes d adressage MIPS p. 5
11 Format I 6 bits 5 bits 5 bits 16 bits op rs rt immédiat 1. op : code opération 2. rs : registre opérande source ou destination 3. rt : registre opérande source ou destination 4. immédiat : valeur immédiate Jeu d instructions et modes d adressage MIPS p. 6
12 Format J 6 bits op 26 bits adresse 1. op : code opération 2. adresse : adresse de saut Jeu d instructions et modes d adressage MIPS p. 7
13 Addition 1. mémonique : add 2. exemple : add $s1, $s2, $s3 3. signification : $s1 = $s2 + $s3 Jeu d instructions et modes d adressage MIPS p. 8
14 Addition immédiate 1. mémonique : addi 2. exemple : addi $s1, $s2, signification : $s1 = $s Jeu d instructions et modes d adressage MIPS p. 9
15 Soustraction 1. mémonique : sub 2. exemple : sub $s1, $s2, $s3 3. signification : $s1 = $s2 - $s3 Jeu d instructions et modes d adressage MIPS p. 10
16 Opérations logiques 1. mémonique : and 2. exemple : and $s1, $s2, $s3 3. signification : $s1 = $s2 & $s3 1. mémonique : or 2. exemple : or $s1, $s2, $s3 3. signification : $s1 = $s2 $s3 1. mémonique : nor 2. exemple : nor $s1, $s2, $s3 3. signification : $s1 = ~($s2 $s3) Jeu d instructions et modes d adressage MIPS p. 11
17 Décalages 1. mémonique : sll 2. exemple : sll $s1, $s2, signification : $s1 = $s2 «10 1. mémonique : srl 2. exemple : srl $s1, $s2, signification : $s1 = $s2» 10 Le champs décalage comptient la valeur de décalage Jeu d instructions et modes d adressage MIPS p. 12
18 Chargement 1. mémonique : lw 2. exemple : lw $s1, 100($s2) 3. signification : $s1 = Mem[$s ] Jeu d instructions et modes d adressage MIPS p. 13
19 Rangement 1. mémonique : sw 2. exemple : sw $s1, 100($s2) 3. signification : Mem[$s ] = $s1 Jeu d instructions et modes d adressage MIPS p. 14
20 Offset mémoire L unité d adressage mémoire est l octet. Puisque instructions et données occupent 32 bits, tous les mots mémoire sont alignés sur des adresses multiples de quatre : adresses mémoire Jeu d instructions et modes d adressage MIPS p. 15
21 Exemple Soit l instruction C : A[12]=h + A[8]; avec h associé au registre $s2, et l adresse de base de A rangée dans le registre $s3. Jeu d instructions et modes d adressage MIPS p. 16
22 Exemple Soit l instruction C : A[12]=h + A[8]; avec h associé au registre $s2, et l adresse de base de A rangée dans le registre $s3. lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 48($s3) # t0 <- A[8] # t0 <- h + A[8] # A[12] <- h + A[8] Jeu d instructions et modes d adressage MIPS p. 16
23 Comparaison 1. mémonique : slt Set on Less Than 2. exemple : slt $s1, $s2, $s3 3. signification : if ($s2 < $s3) $s1 = 1; else $s1 = 0; Jeu d instructions et modes d adressage MIPS p. 17
24 Comparaison immédiate 1. mémonique : slti 2. exemple : slti $s1, $s2, signification : if ($s2 < 100) $s1 = 1; else $s1 = 0; Jeu d instructions et modes d adressage MIPS p. 18
25 Branchement conditionnel (=) 1. mémonique : beq Branch on EQual 2. exemple : beq $s1, $s2, Etiquette 3. signification : if ($s1 == $s2) goto Etiquette; Jeu d instructions et modes d adressage MIPS p. 19
26 Branchement conditionnel (!=) 1. mémonique : bne Branch on Not Equal 2. exemple : bne $s1, $s2, Etiquette 3. signification : if ($s1!= $s2) goto Etiquette; Jeu d instructions et modes d adressage MIPS p. 20
27 Branchement inconditionnel 1. mémonique : j Jump 2. exemple : j Etiquette 3. signification : goto Etiquette; Jeu d instructions et modes d adressage MIPS p. 21
28 Exemple Soit l instruction C : while (save[i] == k) i+=1; avec i et k associés au registres $s3 et $s5, et l adresse de base de save rangée dans le registre $s6. Jeu d instructions et modes d adressage MIPS p. 22
29 Exemple Soit l instruction C : while (save[i] == k) i+=1; avec i et k associés au registres $s3 et $s5, et l adresse de base de save rangée dans le registre $s6. Loop: sll $t1, $s3, 2 # t1 <- 4*i Jeu d instructions et modes d adressage MIPS p. 22
30 Exemple Soit l instruction C : while (save[i] == k) i+=1; avec i et k associés au registres $s3 et $s5, et l adresse de base de save rangée dans le registre $s6. Loop: sll $t1, $s3, 2 # t1 <- 4*i add $t1, $t1, $s6 # t1 <- adresse de save[i] Jeu d instructions et modes d adressage MIPS p. 22
31 Exemple Soit l instruction C : while (save[i] == k) i+=1; avec i et k associés au registres $s3 et $s5, et l adresse de base de save rangée dans le registre $s6. Loop: sll $t1, $s3, 2 # t1 <- 4*i add $t1, $t1, $s6 # t1 <- adresse de save[i] lw $t0, 0($t1) # t0 <- save[i] Jeu d instructions et modes d adressage MIPS p. 22
32 Exemple Soit l instruction C : while (save[i] == k) i+=1; avec i et k associés au registres $s3 et $s5, et l adresse de base de save rangée dans le registre $s6. Loop: sll $t1, $s3, 2 # t1 <- 4*i add $t1, $t1, $s6 # t1 <- adresse de save[i] lw $t0, 0($t1) # t0 <- save[i] bne $t0, $s5, Exit # goto Exit if save[i]!=k Exit: # sortie de boucle Jeu d instructions et modes d adressage MIPS p. 22
33 Exemple Soit l instruction C : while (save[i] == k) i+=1; avec i et k associés au registres $s3 et $s5, et l adresse de base de save rangée dans le registre $s6. Loop: sll $t1, $s3, 2 # t1 <- 4*i add $t1, $t1, $s6 # t1 <- adresse de save[i] lw $t0, 0($t1) # t0 <- save[i] bne $t0, $s5, Exit # goto Exit if save[i]!=k addi $s3, $s3, 1 # i += 1 j Loop # goto Loop Exit: # sortie de boucle Jeu d instructions et modes d adressage MIPS p. 22
34 Organisation de la mémoire Allocation mémoire $sp 7FFF FFFC 16 pile $gp données dynamiques données statiques PC texte 0 16 réservé Jeu d instructions et modes d adressage MIPS p. 23
35 Organisation de la mémoire Allocation mémoire Pile des contextes $sp 7FFF FFFC 16 pile $gp données dynamiques $fp... argument 6 argument 5 registres sauvegardés données statiques PC texte $sp variables locales 0 16 réservé Jeu d instructions et modes d adressage MIPS p. 23
36 Modes d adressage MIPS Immédiat : l opérande est une constante contenue dans l instruction Jeu d instructions et modes d adressage MIPS p. 24
37 Modes d adressage MIPS Immédiat : l opérande est une constante contenue dans l instruction Registre : l opérande est un registre Jeu d instructions et modes d adressage MIPS p. 24
38 Modes d adressage MIPS Immédiat : l opérande est une constante contenue dans l instruction Registre : l opérande est un registre Indexé : l opérande est à une adresse de base à laquelle est ajouté le contenu d un registre comme déplacement Jeu d instructions et modes d adressage MIPS p. 24
39 Modes d adressage MIPS Immédiat : l opérande est une constante contenue dans l instruction Registre : l opérande est un registre Indexé : l opérande est à une adresse de base à laquelle est ajouté le contenu d un registre comme déplacement Indexé sur le PC : l opérande est à une adresse à laquelle est ajouté le contenu du compteur de programme comme déplacement Jeu d instructions et modes d adressage MIPS p. 24
40 Modes d adressage MIPS Immédiat : l opérande est une constante contenue dans l instruction Registre : l opérande est un registre Indexé : l opérande est à une adresse de base à laquelle est ajouté le contenu d un registre comme déplacement Indexé sur le PC : l opérande est à une adresse à laquelle est ajouté le contenu du compteur de programme comme déplacement Pseudo-direct : saut obtenu par concaténation des 26 bits du champs adresse d une instruction j et des quatre bits de poids fort du PC Jeu d instructions et modes d adressage MIPS p. 24
41 Adressage immédiat L opérande est une constante contenue dans l instruction op rs rt immédiat Jeu d instructions et modes d adressage MIPS p. 25
42 Adressage registre L opérande est un registre op rs rt rd décal fonct registre Jeu d instructions et modes d adressage MIPS p. 26
43 Adressage indexé L opérande est à une adresse de base à laquelle est ajouté le contenu d un registre comme déplacement op rs rd adresse registre + octet 1/2-mot mot Jeu d instructions et modes d adressage MIPS p. 27
44 Adressage indexé sur le PC L opérande est à une adresse à laquelle est ajouté le contenu du compteur de programme comme déplacement op rs rd adresse PC + mot Jeu d instructions et modes d adressage MIPS p. 28
45 Adressage pseudo-direct Saut obtenu par concaténation des 26 bits du champs adresse d une instruction j et des quatre bits de poids fort du PC op adresse PC. mot Jeu d instructions et modes d adressage MIPS p. 29
46 Appels de fonction Six étapes : la fonction appelante place les paramètres données dans une zone accessible par la fonction appelée Jeu d instructions et modes d adressage MIPS p. 30
47 Appels de fonction Six étapes : la fonction appelante place les paramètres données dans une zone accessible par la fonction appelée elle transfère le contrôle à la fonction appelée Jeu d instructions et modes d adressage MIPS p. 30
48 Appels de fonction Six étapes : la fonction appelante place les paramètres données dans une zone accessible par la fonction appelée elle transfère le contrôle à la fonction appelée la fonction appelée acquiert les ressources mémoire nécessaires Jeu d instructions et modes d adressage MIPS p. 30
49 Appels de fonction Six étapes : la fonction appelante place les paramètres données dans une zone accessible par la fonction appelée elle transfère le contrôle à la fonction appelée la fonction appelée acquiert les ressources mémoire nécessaires le corps de la fonction appelée est exécuté Jeu d instructions et modes d adressage MIPS p. 30
50 Appels de fonction Six étapes : la fonction appelante place les paramètres données dans une zone accessible par la fonction appelée elle transfère le contrôle à la fonction appelée la fonction appelée acquiert les ressources mémoire nécessaires le corps de la fonction appelée est exécuté la fonction appelée place les paramètres résultats dans une zone accessible par la fonction appelante Jeu d instructions et modes d adressage MIPS p. 30
51 Appels de fonction Six étapes : la fonction appelante place les paramètres données dans une zone accessible par la fonction appelée elle transfère le contrôle à la fonction appelée la fonction appelée acquiert les ressources mémoire nécessaires le corps de la fonction appelée est exécuté la fonction appelée place les paramètres résultats dans une zone accessible par la fonction appelante elle rend le contrôle au point d appel de la fonction appelante Jeu d instructions et modes d adressage MIPS p. 30
52 Registres dédiés aux appels de fonction 1. $a0 $a3 : quatre registres dédiés au passage de paramètres 2. $v0 $v1 : deux registres dédiés au retour de résultats 3. $ra : registre-adresse de retour au point d appel, utilisé par l intruction jr 4. une instruction dédiée à l appel de fonction : jal 5. le registre de gestion de pile $sp pour le sauvegarde et la restauration de variables du programme appelant Jeu d instructions et modes d adressage MIPS p. 31
53 Appel de fonction 1. mémonique : jal Jump And Link 2. exemple : jal Etiquette 3. signification : $ra = PC + 4; goto Etiquette; Jeu d instructions et modes d adressage MIPS p. 32
54 Retour de fonction 1. mémonique : jr Jump Register 2. exemple : jr $ra 3. signification : goto $ra; Jeu d instructions et modes d adressage MIPS p. 33
55 Modèle général appelant-appelé appelant:... #... jal appelé # $ra=pc+4; goto appelé;... # adresse retour : PC+4 appelé: jr $ra retour à PC+4 Jeu d instructions et modes d adressage MIPS p. 34
56 Modèle général appelant-appelé appelant:... #... jal appelé # $ra=pc+4; goto appelé;... # adresse retour : PC+4 appelé: jr $ra retour à PC+4 Jeu d instructions et modes d adressage MIPS p. 34
57 Pile et registres supplémentaires 1. Tout registre de l appelant utilisé par la fonction appelée doit être sauvegardé à l entrée, et restauré au sortir par celle-ci. 2. La structure de donnée idéale est la pile : les valeurs des registres sont empilées à l entrée de la fonction, et dépilées à la sortie. 3. MIPS utilise le registre dédié $sp (Stack Pointer) 4. Pour des raisons historiques, la pile croît des adresses hautes vers les adresses basses. Jeu d instructions et modes d adressage MIPS p. 35
58 fonction_exemple/c int fonction exemple (int g, int h, int i, int j) { int f; f = (g+h)-(i+j); return f; } avec g, h, i, j associées aux registres $a0, $a1, $a2, $a3, f associée au registre $s0, la valeur de retour associée au registre $v0, et l adresse de retour au registre $ra Jeu d instructions et modes d adressage MIPS p. 36
59 Corps de la fonction_exemple/mips f = (g+h)-(i+j); va être compilé en : add $t0, $a0, $a1 # t0 <- g+h add $t1, $a2, $a3 # t1 <- i+j sub $s0, $t0, $t1 # f = $t0 - $t1 il faut préalablement sauvegarder les contenus des registres $s0, $t0, $t1 Jeu d instructions et modes d adressage MIPS p. 37
60 Sauvegarde des registres ( PUSH ) addi $sp, $sp, -12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp) # alloue l espace dans la pile # sauve $t1 dans la pile # sauve $t0 dans la pile # sauve $s0 dans la pile Jeu d instructions et modes d adressage MIPS p. 38
61 Passage des paramètres retours add $v0, $s0, $zero # renvoie f Transfert du registre $v0 vers $s0 Jeu d instructions et modes d adressage MIPS p. 39
62 Restauration des registres( POP ) lw $s0, 0($sp) lw $t0, 4($sp) lw $t1, 8($sp) addi $sp, $sp, 12 # restaure $s0 pour l appelant # restaure $t0 pour l appelant # restaure $t1 pour l appelant # rend l espace alloué dans la pile Jeu d instructions et modes d adressage MIPS p. 40
63 f_exemple f_exemple: addi $sp, $sp, -12 # alloue l espace dans la pile sw $t1, 8($sp) # sauve $t1 dans la pile sw $t0, 4($sp) # sauve $t0 dans la pile sw $s0, 0($sp) # sauve $s0 dans la pile add $t0, $a0, $a1 # t0 <- g+h add $t1, $a2, $a3 # t1 <- i+j sub $s0, $t0, $t1 # f = $t0 - $t1 add $v0, $s0, $zero # renvoie f lw $s0, 0($sp) # restaure $s0 pour l appelant lw $t0, 4($sp) # restaure $t0 pour l appelant lw $t1, 8($sp) # restaure $t1 pour l appelant addi $sp, $sp, 12 # rend l espace dans la pile jr $ra # retour à l appelant Jeu d instructions et modes d adressage MIPS p. 41
64 Conventions de programmation Registres : non sauvegardés à sauvegarder Jeu d instructions et modes d adressage MIPS p. 42
65 Conventions de programmation Registres : non sauvegardés $v0 $v1 $a0 $a3 $t0 $t9 à sauvegarder Jeu d instructions et modes d adressage MIPS p. 42
66 Conventions de programmation Registres : non sauvegardés à sauvegarder $v0 $v1 $s0 $s7 $a0 $a3 $gp $t0 $t9 $sp $fp $ra Jeu d instructions et modes d adressage MIPS p. 42
67 f_exemple (suite) f_exemple: addi $sp, $sp, -12 # alloue l espace dans la pile sw $t1, 8($sp) # sauve $t1 dans la pile sw $t0, 4($sp) # sauve $t0 dans la pile sw $s0, 0($sp) # sauve $s0 dans la pile add $t0, $a0, $a1 # t0 <- g+h add $t1, $a2, $a3 # t1 <- i+j sub $s0, $t0, $t1 # f = $t0 - $t1 add $v0, $s0, $zero # renvoie f lw $s0, 0($sp) # restaure $s0 pour l appelant lw $t0, 4($sp) # restaure $t0 pour l appelant lw $t1, 8($sp) # restaure $t1 pour l appelant addi $sp, $sp, 12 # rend l espace dans la pile jr $ra # retour à l appelant Jeu d instructions et modes d adressage MIPS p. 43
68 f_exemple (suite) f_exemple: addi $sp, $sp, -12 # alloue l espace dans la pile sw $t1, 8($sp) # sauve $t1 dans la pile sw $t0, 4($sp) # sauve $t0 dans la pile sw $s0, 0($sp) # sauve $s0 dans la pile add $t0, $a0, $a1 # t0 <- g+h add $t1, $a2, $a3 # t1 <- i+j sub $s0, $t0, $t1 # f = $t0 - $t1 add $v0, $s0, $zero # renvoie f lw $s0, 0($sp) # restaure $s0 pour l appelant lw $t0, 4($sp) # restaure $t0 pour l appelant lw $t1, 8($sp) # restaure $t1 pour l appelant addi $sp, $sp, -12 # rend l espace dans la pile jr $ra # retour à l appelant Jeu d instructions et modes d adressage MIPS p. 43
69 f_exemple (suite) f_exemple: addi $sp, $sp, -4 # alloue l espace dans la pile sw $s0, 0($sp) # sauve $s0 dans la pile add $t0, $a0, $a1 # t0 <- g+h add $t1, $a2, $a3 # t1 <- i+j sub $s0, $t0, $t1 # f = $t0 - $t1 add $v0, $s0, $zero # renvoie f lw $s0, 0($sp) # restaure $s0 pour l appelant addi $sp, $sp, 4 jr $ra # rend l espace dans la pile # retour à l appelant Jeu d instructions et modes d adressage MIPS p. 43
70 Deux cas à considérer Si la fonction appelée est terminale : Jeu d instructions et modes d adressage MIPS p. 44
71 Deux cas à considérer Si la fonction appelée est terminale : empiler $s0, $s1... utilisés Jeu d instructions et modes d adressage MIPS p. 44
72 Deux cas à considérer Si la fonction appelée est terminale : empiler $s0, $s1... utilisés non-terminale : Jeu d instructions et modes d adressage MIPS p. 44
73 Deux cas à considérer Si la fonction appelée est terminale : empiler $s0, $s1... utilisés non-terminale : empiler $ra Jeu d instructions et modes d adressage MIPS p. 44
74 Deux cas à considérer Si la fonction appelée est terminale : empiler $s0, $s1... utilisés non-terminale : empiler $ra empiler $a0, $a1,... utilisés Jeu d instructions et modes d adressage MIPS p. 44
75 Deux cas à considérer Si la fonction appelée est terminale : empiler $s0, $s1... utilisés non-terminale : empiler $ra empiler $a0, $a1,... utilisés empiler $s0, $s1... utilisés Jeu d instructions et modes d adressage MIPS p. 44
76 Deux cas à considérer Si la fonction appelée est terminale : empiler $s0, $s1... utilisés non-terminale : empiler $ra empiler $a0, $a1,... utilisés empiler $s0, $s1... utilisés Exemple important de fonction non-terminale : les fonctions récursives... Jeu d instructions et modes d adressage MIPS p. 44
77 fonction fact/c int fact (int n) { if (n<1) return 1; else return (n * fact(n-1)); } Le paramètre n est placé dans le registre $a0, la valeur de retour de la fonction dans le registre $v0. Jeu d instructions et modes d adressage MIPS p. 45
78 fact fact: addi $sp, $sp, -8 # alloue l espace dans la pile sw $ra, 4($sp) # empile l adresse de retour sw $a0, 0($sp) # empile l argument n slti $t0, $a0, 1 # test pour n < 1 beq $t0, $zero, recurs # if (n>=1) goto recurs; addi $v0, $zero, 1 # return 1; lw $a0, 0($sp) # dépile l argument n lw $ra, 4($sp) # dépile l adresse de retour addi $sp, $sp, 8 # pop des deux valeurs sauvées jr $ra # retour à l appelant recurs: addi $a0, $a0, -1 # n>=1: l argument reçoit n-1 jal fact # appel récursif lw $a0, 0($sp) # dépile l argument n lw $ra, 4($sp) # dépile l adresse de retour addi $sp, $sp, 8 # rend l espace dans la pile mul $v0, $a0, $v0 # return n*fact(n-1) jr $ra # retour à la fonction appelante Jeu d instructions et modes d adressage MIPS p. 46
79 fact fact: addi $sp, $sp, -8 # alloue l espace dans la pile sw $ra, 4($sp) # empile l adresse de retour sw $a0, 0($sp) # empile l argument n slti $t0, $a0, 1 # test pour n < 1 beq $t0, $zero, recurs # if (n>=1) goto recurs; addi $v0, $zero, 1 # return 1; lw $a0, 0($sp) # dépile l argument n lw $ra, 4($sp) # dépile l adresse de retour addi $sp, $sp, 8 # pop des deux valeurs sauvées jr $ra # retour à l appelant recurs: addi $a0, $a0, -1 # n>=1: l argument reçoit n-1 jal fact # appel récursif lw $a0, 0($sp) # dépile l argument n lw $ra, 4($sp) # dépile l adresse de retour addi $sp, $sp, 8 # rend l espace dans la pile mul $v0, $a0, $v0 # return n*fact(n-1) jr $ra # retour à la fonction appelante Jeu d instructions et modes d adressage MIPS p. 46
80 fact fact: addi $sp, $sp, -8 # alloue l espace dans la pile sw $ra, 4($sp) # empile l adresse de retour sw $a0, 0($sp) # empile l argument n slti $t0, $a0, 1 # test pour n < 1 beq $t0, $zero, recurs # if (n>=1) goto recurs; addi $v0, $zero, 1 # return 1; addi $sp, $sp, 8 # pop des deux valeurs sauvées jr $ra # retour à l appelant recurs: addi $a0, $a0, -1 # n>=1: l argument reçoit n-1 jal fact # appel récursif lw $a0, 0($sp) # dépile l argument n lw $ra, 4($sp) # dépile l adresse de retour addi $sp, $sp, 8 # rend l espace dans la pile mul $v0, $a0, $v0 # return n*fact(n-1) jr $ra # retour à la fonction appelante Jeu d instructions et modes d adressage MIPS p. 46
81 Compilateur et éditeur de liens Compilateur : transforme le programme source en programme en langage d assemblage utilisant des emplacements mémoire symboliques. Jeu d instructions et modes d adressage MIPS p. 47
82 Compilateur et éditeur de liens Compilateur : transforme le programme source en programme en langage d assemblage utilisant des emplacements mémoire symboliques. Editeur de liens : résoud les références symboliques sur des programmes compilés séparément. Jeu d instructions et modes d adressage MIPS p. 47
83 Compilateurs optimisants Un compilateur peut réaliser trois types d optimisation : Optimisations locales. Réalisées à l intérieur d un bloc. Jeu d instructions et modes d adressage MIPS p. 48
84 Compilateurs optimisants Un compilateur peut réaliser trois types d optimisation : Optimisations locales. Réalisées à l intérieur d un bloc. Optimisations globales. Réalisées sur plusieurs blocs. Jeu d instructions et modes d adressage MIPS p. 48
85 Compilateurs optimisants Un compilateur peut réaliser trois types d optimisation : Optimisations locales. Réalisées à l intérieur d un bloc. Optimisations globales. Réalisées sur plusieurs blocs. Allocation des registres. Association des variables aux registres en fonction des différentes portions de code. Jeu d instructions et modes d adressage MIPS p. 48
86 Compilateurs optimisants Un compilateur peut réaliser trois types d optimisation : Optimisations locales. Réalisées à l intérieur d un bloc. Optimisations globales. Réalisées sur plusieurs blocs. Allocation des registres. Association des variables aux registres en fonction des différentes portions de code. Beaucoup d optimisations sont réalisées à la fois localement et globalement, par exemple l élimination de sous-expressions communes, la propagation des constantes, la propagation par copie... Jeu d instructions et modes d adressage MIPS p. 48
87 Elimination de sous-expressions communes Le compilateur détecte plusieurs occurences d une même expression, et utilise la première pour éliminer les suivantes. Exemple : T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R106, T lw R107, i sll R108, R107, 2 add R109, R106, R108 sw R105, 0(R109) Jeu d instructions et modes d adressage MIPS p. 49
88 Elimination de sous-expressions communes Le compilateur détecte plusieurs occurences d une même expression, et utilise la première pour éliminer les suivantes. Exemple : T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R106, T lw R107, i sll R108, R107, 2 add R109, R106, R108 sw R105, 0(R109) Jeu d instructions et modes d adressage MIPS p. 49
89 Elimination de sous-expressions communes Le compilateur détecte plusieurs occurences d une même expression, et utilise la première pour éliminer les suivantes. Exemple : T[i]+=3; # T[i]+3; # T[i]+3; li R100, T li R100, T lw R101, i lw R101, i sll R102, R101, 2 sll R102, R101, 2 add R103, R100, R102 add R103, R100, R102 lw R104, 0(R103) lw R104, 0(R103) add R105, R104, 3 add R105, R104, 3 # T[i]= sw R105, 0(R103) li R106, T lw R107, i sll R108, R107, 2 add R109, R106, R108 sw R105, 0(R109) Jeu d instructions et modes d adressage MIPS p. 49
90 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R106, T lw R107, i sll R108, R107, 2 add R109, R106, R108 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
91 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R106, T lw R107, i sll R108, R107, 2 add R109, R106, R108 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
92 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R107, i sll R108, R107, 2 add R109, R100, R108 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
93 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R107, i sll R108, R107, 2 add R109, R100, R108 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
94 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R101, i sll R108, R101, 2 add R109, R100, R108 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
95 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R101, i sll R108, R101, 2 add R109, R100, R108 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
96 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R101, i sll R102, R101, 2 add R109, R100, R102 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
97 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R101, i sll R102, R101, 2 add R109, R100, R102 sw R105, 0(R109) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
98 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 sw R105, 0(R103) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
99 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # T[i]= li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 sw R105, 0(R103) # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
100 Compilation optimisée de T[i]+=3; # T[i]+3; li R100, T lw R101, i sll R102, R101, 2 add R103, R100, R102 lw R104, 0(R103) add R105, R104, 3 # adresse de base du tableau T # valeur de l incrément i # alignement sur 4 octets # valeur du déplacement # R104 <- adresse de T[i] # R105 <- T[i]+3 sw R105, 0(R103) # T[i]=T[i]+3; Jeu d instructions et modes d adressage MIPS p. 50
101 Directives d assemblage Dit à l assembleur comment interpéter ce qui suit en mémoire. Par exemple :.ascii <chaîne> : ce qui suit la directive est une chaîne de caractères.asciiz <chaîne> : ce qui suit la directive est une chaîne terminée par le caractère \0.byte <b1,..., bn> : range b1,..., bn dans n octets successifs.data : ce qui suit la directive est placé dans le segment de données Jeu d instructions et modes d adressage MIPS p. 51
102 Directives d assemblage.glob <étiquette> : ce qui suit la directive est une étiquette globale et peut être référencée à partir d autres fichiers.text : ce qui suit la directive est placé dans le segment Texte.word <w1,..., wn> : range w1,..., wn dans n mots successifs Jeu d instructions et modes d adressage MIPS p. 51
103 Exemple de directive.data tableau:.word 0x , 0x , 0x , 0x , 0x text main: la $t0, tableau... Jeu d instructions et modes d adressage MIPS p. 52
104 Exemple de directive.data tableau:.word 0x , 0x , 0x , 0x , 0x text main: la $t0, tableau... portion de programme référençant un tableau d entiers dans le segment de données la est une pseudo instruction permettant le chargement d une adresse Jeu d instructions et modes d adressage MIPS p. 52
105 Entrées-sorties : syscall Toutes les entrées sorties sont prises en charge par la routine système syscall Opération $v0 = Arguments Valeur retour print_int 1 $a0 = entier à afficher print_string 4 $a0 = chaîne à afficher read_int 5 $v0 = entier lu read_string 8 $a0 = buffer, $a1 = longueur exit 10 print_char 11 $a0 = car. à afficher $a0 = car. lu read_char 12 $a0 = car. lu exit2 17 $a0 = résultat Jeu d instructions et modes d adressage MIPS p. 53
106 Exemple : syscall.data str:.asciiz Bonjour.text main: ori $v0, $zero, 4 # $v0 <- 4 la $a0, str # $a0 <- str syscall # affiche Bonjour... ori $v0, $zero, 10 # $v0 <- 10 syscall # appel système de # terminaison de programme Jeu d instructions et modes d adressage MIPS p. 54
107 Exemple : syscall.data str:.asciiz Bonjour.text main: ori $v0, $zero, 4 # $v0 <- 4 la $a0, str # $a0 <- str syscall # affiche Bonjour... ori $v0, $zero, 10 # $v0 <- 10 syscall # appel système de # terminaison de programme l étiquette str: référence l adresse de la chaîne de caractères en mémoire $a0 est l adresse de la chaîne, passée comme argument à syscall Jeu d instructions et modes d adressage MIPS p. 54
Rappels d architecture
Assembleur Rappels d architecture Un ordinateur se compose principalement d un processeur, de mémoire. On y attache ensuite des périphériques, mais ils sont optionnels. données : disque dur, etc entrée
Compilation (INF 564)
Présentation du cours Le processeur MIPS Programmation du MIPS 1 Compilation (INF 564) Introduction & architecture MIPS François Pottier 10 décembre 2014 Présentation du cours Le processeur MIPS Programmation
CM2 L architecture MIPS32
CM2 L architecture MIPS32 Olivier Marchetti (CM-TD-TP) Alexandre Brière (TD-TP) Laboratoire d informatique de Paris 6 Pôle SoC UPMC Année 2014-2015 Instructions MIPS Contrôle Données en MIPS E/S en MIPS
Jeu d instructions NIOS II
Jeu d instructions NIOS II 1 Formats d instructions Le processeur NIOS II a un jeu d instructions de type RISC. Il possède 32 registres de 32 bits, notés r0 à r31, avec r0 0. Les instructions sont de longueur
DU BINAIRE AU MICROPROCESSEUR - D ANGELIS CIRCUITS CONFIGURABLES NOTION DE PROGRAMMATION
145 NOTION DE PROGRAMMATION 1/ Complétons notre microprocesseur Nous avons, dans les leçons précédentes décrit un microprocesseur théorique, cependant il s inspire du 6800, premier microprocesseur conçu
Architecture des ordinateurs
Architecture des ordinateurs Cours 7 17 décembre 2012 Archi 1/1 Fonctions, suite et fin Archi 2/1 Rappel Forme générale d un sous-programme (fonction) : etiquette sousprogramme: push ebp ; empile la valeur
Conception de circuits numériques et architecture des ordinateurs
Conception de circuits numériques et architecture des ordinateurs Frédéric Pétrot Année universitaire 2014-2015 Structure du cours C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 Codage des nombres en base 2, logique
Architecture des ordinateurs
Architecture des ordinateurs Cours 4 5 novembre 2012 Archi 1/22 Micro-architecture Archi 2/22 Intro Comment assembler les différents circuits vus dans les cours précédents pour fabriquer un processeur?
Assembleur. Faculté I&C, André Maurer, Claude Petitpierre
Assembleur Faculté I&C, André Maurer, Claude Petitpierre INTRODUCTION Logiciel utilisé Faculté I&C, André Maurer, Claude Petitpierre MEMOIRE Mémoire Faculté I&C, André Maurer, Claude Petitpierre Mémoire
Gestion mémoire et Représentation intermédiaire
Gestion mémoire et Représentation intermédiaire Pablo de Oliveira March 23, 2015 I Gestion Memoire Variables locales Les variables locales sont stockées: Soit dans un registre,
1. Structure d un programme C. 2. Commentaire: /*..texte */ On utilise aussi le commentaire du C++ qui est valable pour C: 3.
1. Structure d un programme C Un programme est un ensemble de fonctions. La fonction "main" constitue le point d entrée pour l exécution. Un exemple simple : #include int main() { printf ( this
ASR1 TD7 : Un microprocesseur RISC 16 bits
{Â Ö Ñ º ØÖ Ý,È ØÖ ºÄÓ Ù,Æ ÓÐ ºÎ ÝÖ Ø¹ ÖÚ ÐÐÓÒ} Ò ¹ÐÝÓÒº Ö ØØÔ»»Ô Ö Óº Ò ¹ÐÝÓÒº Ö» Ö Ñ º ØÖ Ý»¼ Ö½» ASR1 TD7 : Un microprocesseur RISC 16 bits 13, 20 et 27 novembre 2006 Présentation générale On choisit
Structure d un programme
Architecture des ordinateurs Cours 6 Structure d un programme 3 décembre 2012 Archi 1/30 Programme en Assembleur Archi 2/30 Sections de données programme en assembleur = fichier texte (extension.asm) organisé
INITIATION AU LANGAGE C SUR PIC DE MICROSHIP
COURS PROGRAMMATION INITIATION AU LANGAGE C SUR MICROCONTROLEUR PIC page 1 / 7 INITIATION AU LANGAGE C SUR PIC DE MICROSHIP I. Historique du langage C 1972 : naissance du C dans les laboratoires BELL par
Licence ST Université Claude Bernard Lyon I LIF1 : Algorithmique et Programmation C Bases du langage C 1 Conclusion de la dernière fois Introduction de l algorithmique générale pour permettre de traiter
Résumé Génération de code Le code intermédiaire
Résumé Analyse INFO0004 Structure des langages de programmation Génération de code ; liaison et exécution Justus H. Piater Programmation Analyse Compilation Liaison fichier texte Analyse lexicale flux
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if Pierre Boudes 28 septembre 2011 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE
EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE QCM Remarque : - A une question correspond au moins 1 réponse juste - Cocher la ou les bonnes réponses Barème : - Une bonne réponse = +1 - Pas de réponse = 0
Architecture des ordinateurs : Programmation des processeurs avec l'environnement «y86» (INF155)
Architecture des ordinateurs : Programmation des processeurs avec l'environnement «y86» (INF155) F. Pellegrini Université Bordeaux 1 Ce document est copiable et distribuable librement et gratuitement à
1/24. I passer d un problème exprimé en français à la réalisation d un. I expressions arithmétiques. I structures de contrôle (tests, boucles)
1/4 Objectif de ce cours /4 Objectifs de ce cours Introduction au langage C - Cours Girardot/Roelens Septembre 013 Du problème au programme I passer d un problème exprimé en français à la réalisation d
Traduction des Langages : Le Compilateur Micro Java
BARABZAN Jean-René OUAHAB Karim TUCITO David 2A IMA Traduction des Langages : Le Compilateur Micro Java µ Page 1 Introduction Le but de ce projet est d écrire en JAVA un compilateur Micro-Java générant
Programmation assembleur : aperçu
Assembleur : Younès EL AMRANI. 1 Programmation assembleur : aperçu Programmation en assembleur : NASM Module M14 Semestre 4 Printemps 2010 Equipe pédagogique : Younès El Amrani, Abdelhakim El Imrani, Faissal
MICROINFORMATIQUE NOTE D APPLICATION 1 (REV. 2011) ARITHMETIQUE EN ASSEMBLEUR ET EN C
Haute Ecole d Ingénierie et de Gestion Du Canton du Vaud MICROINFORMATIQUE NOTE D APPLICATION 1 (REV. 2011) ARITHMETIQUE EN ASSEMBLEUR ET EN C Programmation en mode simulation 1. DOCUMENTS DE RÉFÉRENCE...
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface
Exécution des instructions machine
Exécution des instructions machine Eduardo Sanchez EPFL Exemple: le processeur MIPS add a, b, c a = b + c type d'opération (mnémonique) destination du résultat lw a, addr opérandes sources a = mem[addr]
Machines virtuelles. Brique ASC. Samuel Tardieu sam@rfc1149.net. Samuel Tardieu (ENST) Machines virtuelles 1 / 40
Machines virtuelles Brique ASC Samuel Tardieu sam@rfc1149.net École Nationale Supérieure des Télécommunications Samuel Tardieu (ENST) Machines virtuelles 1 / 40 Machines virtuelles La compilation peut
UE Programmation Impérative Licence 2ème Année 2014 2015
UE Programmation Impérative Licence 2 ème Année 2014 2015 Informations pratiques Équipe Pédagogique Florence Cloppet Neilze Dorta Nicolas Loménie prenom.nom@mi.parisdescartes.fr 2 Programmation Impérative
Initiation à LabView : Les exemples d applications :
Initiation à LabView : Les exemples d applications : c) Type de variables : Créer un programme : Exemple 1 : Calcul de c= 2(a+b)(a-3b) ou a, b et c seront des réels. «Exemple1» nom du programme : «Exemple
Claude Delannoy. 3 e édition C++
Claude Delannoy 3 e édition Exercices Exercices C++ en en langage langage delc++ titre 4/07/07 15:19 Page 2 Exercices en langage C++ AUX EDITIONS EYROLLES Du même auteur C. Delannoy. Apprendre le C++.
TP, première séquence d exercices.
TP, première séquence d exercices. Benoît Valiron benoit.valiron@lipn.univ-paris13.fr 7 novembre 2010 Introduction Vous écrirez les réponses aux questions courtes sur une feuille à rendre à la fin de la
Java Licence Professionnelle CISII, 2009-10
Java Licence Professionnelle CISII, 2009-10 Cours 4 : Programmation structurée (c) http://www.loria.fr/~tabbone/cours.html 1 Principe - Les méthodes sont structurées en blocs par les structures de la programmation
Initiation à l algorithmique
Informatique S1 Initiation à l algorithmique procédures et fonctions 2. Appel d une fonction Jacques TISSEAU Ecole Nationale d Ingénieurs de Brest Technopôle Brest-Iroise CS 73862-29238 Brest cedex 3 -
1 Architecture du cœur ARM Cortex M3. Le cœur ARM Cortex M3 sera présenté en classe à partir des éléments suivants :
GIF-3002 SMI et Architecture du microprocesseur Ce cours discute de l impact du design du microprocesseur sur le système entier. Il présente d abord l architecture du cœur ARM Cortex M3. Ensuite, le cours
Architecture des ordinateurs TD1 - Portes logiques et premiers circuits
Architecture des ordinateurs TD1 - Portes logiques et premiers circuits 1 Rappel : un peu de logique Exercice 1.1 Remplir la table de vérité suivante : a b a + b ab a + b ab a b 0 0 0 1 1 0 1 1 Exercice
Qualité du logiciel: Méthodes de test
Qualité du logiciel: Méthodes de test Matthieu Amiguet 2004 2005 Analyse statique de code Analyse statique de code Étudier le programme source sans exécution Généralement réalisée avant les tests d exécution
Plan du cours. Historique du langage http://www.oracle.com/technetwork/java/index.html. Nouveautés de Java 7
Université Lumière Lyon 2 Faculté de Sciences Economiques et Gestion KHARKIV National University of Economic Introduction au Langage Java Master Informatique 1 ère année Julien Velcin http://mediamining.univ-lyon2.fr/velcin
IN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C
IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en
Ordinateurs, Structure et Applications
Ordinateurs, Structure et Applications Cours 10, Les interruptions Etienne Tremblay Université Laval, Hiver 2012 Cours 10, p.1 Les interruptions du 8086 Une interruption interrompt l exécution séquentielle
Algorithmique et Programmation, IMA
Algorithmique et Programmation, IMA Cours 2 : C Premier Niveau / Algorithmique Université Lille 1 - Polytech Lille Notations, identificateurs Variables et Types de base Expressions Constantes Instructions
Info0101 Intro. à l'algorithmique et à la programmation. Cours 3. Le langage Java
Info0101 Intro. à l'algorithmique et à la programmation Cours 3 Le langage Java Pierre Delisle, Cyril Rabat et Christophe Jaillet Université de Reims Champagne-Ardenne Département de Mathématiques et Informatique
INTRODUCTION A JAVA. Fichier en langage machine Exécutable
INTRODUCTION A JAVA JAVA est un langage orienté-objet pur. Il ressemble beaucoup à C++ au niveau de la syntaxe. En revanche, ces deux langages sont très différents dans leur structure (organisation du
Cours 1 : Introduction Ordinateurs - Langages de haut niveau - Application
Université de Provence Licence Math-Info Première Année V. Phan Luong Algorithmique et Programmation en Python Cours 1 : Introduction Ordinateurs - Langages de haut niveau - Application 1 Ordinateur Un
Conventions d écriture et outils de mise au point
Logiciel de base Première année par alternance Responsable : Christophe Rippert Christophe.Rippert@Grenoble-INP.fr Introduction Conventions d écriture et outils de mise au point On va utiliser dans cette
Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation 24 octobre 2007impérative 1 / 44 et. structures de données simples
Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation impérative et structures de données simples Introduction au langage C Sandrine Blazy - 1ère année 24 octobre 2007 Cours d Algorithmique-Programmation
Chapitre VI- La validation de la composition.
Chapitre VI- La validation de la composition. Objectifs du chapitre : Expliquer les conséquences de l utilisation de règles de typage souples dans SEP. Présenter le mécanisme de validation des connexions
Utilisation d objets : String et ArrayList
Chapitre 6 Utilisation d objets : String et ArrayList Dans ce chapitre, nous allons aborder l utilisation d objets de deux classes prédéfinies de Java d usage très courant. La première, nous l utilisons
PIC : COURS ASSEMBLEUR
PIC : COURS ASSEMBLEUR I) Fonctions de base d une machine informatique Contenir de façon permanente les tâches à exécuter (mémoire programme) en ROM ou sur support magnétique. Contenir de façon temporaire
Introduction au langage C
Introduction au langage C Cours 1: Opérations de base et premier programme Alexis Lechervy Alexis Lechervy (UNICAEN) Introduction au langage C 1 / 23 Les premiers pas Sommaire 1 Les premiers pas 2 Les
Assembleur i8086. Philippe Preux IUT Informatique du Littoral. Année universitaire 95 96
Assembleur i8086 Philippe Preux IUT Informatique du Littoral Année universitaire 95 96 1 Avertissement Ce document décrit le langage d assemblage étudié et utilisé dans le cadre des TP d architecture.
TP 1. Prise en main du langage Python
TP. Prise en main du langage Python Cette année nous travaillerons avec le langage Python version 3. ; nous utiliserons l environnement de développement IDLE. Étape 0. Dans votre espace personnel, créer
as Architecture des Systèmes d Information
Plan Plan Programmation - Introduction - Nicolas Malandain March 14, 2005 Introduction à Java 1 Introduction Présentation Caractéristiques Le langage Java 2 Types et Variables Types simples Types complexes
Représentation d un entier en base b
Représentation d un entier en base b 13 octobre 2012 1 Prérequis Les bases de la programmation en langage sont supposées avoir été travaillées L écriture en base b d un entier est ainsi défini à partir
Présentation du langage et premières fonctions
1 Présentation de l interface logicielle Si les langages de haut niveau sont nombreux, nous allons travaillé cette année avec le langage Python, un langage de programmation très en vue sur internet en
Licence Sciences et Technologies Examen janvier 2010
Université de Provence Introduction à l Informatique Licence Sciences et Technologies Examen janvier 2010 Année 2009-10 Aucun document n est autorisé Les exercices peuvent être traités dans le désordre.
Initiation à la programmation en Python
I-Conventions Initiation à la programmation en Python Nom : Prénom : Une commande Python sera écrite en caractère gras. Exemples : print 'Bonjour' max=input("nombre maximum autorisé :") Le résultat de
Cours 1 : La compilation
/38 Interprétation des programmes Cours 1 : La compilation Yann Régis-Gianas yrg@pps.univ-paris-diderot.fr PPS - Université Denis Diderot Paris 7 2/38 Qu est-ce que la compilation? Vous avez tous déjà
Introduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf
Introduction à Java Matthieu Herrb CNRS-LAAS http://homepages.laas.fr/matthieu/cours/java/java.pdf Mars 2014 Plan 1 Concepts 2 Éléments du langage 3 Classes et objets 4 Packages 2/28 Histoire et motivations
Fonctionnement et performance des processeurs
Fonctionnement et performance des processeurs Eric Cariou Université de Pau et des Pays de l'adour Département Informatique Eric.Cariou@univ-pau.fr 1 Plan Fonctionnement des processeurs Unités de calcul
INTRODUCTION AUX SYSTEMES D EXPLOITATION. TD2 Exclusion mutuelle / Sémaphores
INTRODUCTION AUX SYSTEMES D EXPLOITATION TD2 Exclusion mutuelle / Sémaphores Exclusion mutuelle / Sémaphores - 0.1 - S O M M A I R E 1. GENERALITES SUR LES SEMAPHORES... 1 1.1. PRESENTATION... 1 1.2. UN
ET 24 : Modèle de comportement d un système Boucles de programmation avec Labview.
ET 24 : Modèle de comportement d un système Boucles de programmation avec Labview. Sciences et Technologies de l Industrie et du Développement Durable Formation des enseignants parcours : ET24 Modèle de
Programmation en langage C
Programmation en langage C Anne CANTEAUT INRIA - projet CODES B.P. 105 78153 Le Chesnay Cedex Anne.Canteaut@inria.fr http://www-rocq.inria.fr/codes/anne.canteaut/cours C 2 Table des matières 3 Table des
Architecture : Circuits numériques et éléments d architecture
Ecole Nationale Supérieure d Informatique et de Mathématiques Appliquées Architecture : Circuits numériques et éléments d architecture 1 ère année Année scolaire 2014 2015 Consignes Les exercices de ce
Cours 1 : Introduction. Langages objets. but du module. contrôle des connaissances. Pourquoi Java? présentation du module. Présentation de Java
Langages objets Introduction M2 Pro CCI, Informatique Emmanuel Waller, LRI, Orsay présentation du module logistique 12 blocs de 4h + 1 bloc 2h = 50h 1h15 cours, 45mn exercices table, 2h TD machine page
Cours Informatique Master STEP
Cours Informatique Master STEP Bases de la programmation: Compilateurs/logiciels Algorithmique et structure d'un programme Programmation en langage structuré (Fortran 90) Variables, expressions, instructions
INF 321 : mémento de la syntaxe de Java
INF 321 : mémento de la syntaxe de Java Table des matières 1 La structure générale d un programme 3 2 Les composants élémentaires de Java 3 2.1 Les identificateurs.................................. 3 2.2
Microprocesseur + Logiciel
Microprocesseur + Logiciel Robot EVALBOT MOHAMED AKIL BUREAU 5253 UNITE IGI 1001 PROGRAMMATION DES MICROPROCESSEURS Présentation [IGI1001] CONTEXTE SCIENTIFIQUE... 4 1. OBJECTIFS DE L UNITE... 6 2. OBJECTIFS
TD3: tableaux avancées, première classe et chaînes
TD3: tableaux avancées, première classe et chaînes de caractères 1 Lestableaux 1.1 Élémentsthéoriques Déclaration des tableaux Pour la déclaration des tableaux, deux notations sont possibles. La première
Cours d Algorithmique et de Langage C 2005 - v 3.0
Cours d Algorithmique et de Langage C 2005 - v 3.0 Bob CORDEAU cordeau@onera.fr Mesures Physiques IUT d Orsay 15 mai 2006 Avant-propos Avant-propos Ce cours en libre accès repose sur trois partis pris
Rappels Entrées -Sorties
Fonctions printf et scanf Syntaxe: écriture, organisation Comportement Données hétérogènes? Gestion des erreurs des utilisateurs 17/11/2013 Cours du Langage C ibr_guelzim@yahoo.fr ibrahimguelzim.atspace.co.uk
REALISATION d'un. ORDONNANCEUR à ECHEANCES
REALISATION d'un ORDONNANCEUR à ECHEANCES I- PRÉSENTATION... 3 II. DESCRIPTION DU NOYAU ORIGINEL... 4 II.1- ARCHITECTURE... 4 II.2 - SERVICES... 4 III. IMPLÉMENTATION DE L'ORDONNANCEUR À ÉCHÉANCES... 6
Grandes lignes ASTRÉE. Logiciels critiques. Outils de certification classiques. Inspection manuelle. Definition. Test
Grandes lignes Analyseur Statique de logiciels Temps RÉel Embarqués École Polytechnique École Normale Supérieure Mercredi 18 juillet 2005 1 Présentation d 2 Cadre théorique de l interprétation abstraite
La mémoire. Un ordinateur. L'octet. Le bit
Introduction à l informatique et à la programmation Un ordinateur Un ordinateur est une machine à calculer composée de : un processeur (ou unité centrale) qui effectue les calculs une mémoire qui conserve
Bases de programmation. Cours 5. Structurer les données
Bases de programmation. Cours 5. Structurer les données Pierre Boudes 1 er décembre 2014 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. Types char et
IFT2880 Organisation des ordinateurs et systèmes
Représentation des nombres flottants Notation exponentielle Représentations équivalentes dans la base 10 de 1,234 1 2 3, 4 0 0. 0 x 1 0-2 1 2, 3 4 0. 0 x 1 0-1 1, 2 3 4. 0 x 1 0 1 2 3. 4 x 1 0 1 2. 3 4
La JVM. La machine virtuelle Java. La JVM. La JVM
La machine virtuelle Java Historique et rappels Organisation mémoire de la JVM Le garbage collector Le bytecode, la machine à pile. Les threads Suivi, tracé, optimisation d un programme Java JVM embarquées
Atelier C TIA Portal CTIA04 : Programmation des automates S7-300 Opérations numériques
Atelier C TIA Portal CTIA04 : Programmation des automates S7-300 Opérations numériques CTIA04 Page 1 1. Les types de données sous S7 300 Il existe plusieurs types de données utilisées pour la programmation
Logiciel de base. Première année ENSIMAG
Logiciel de base Première année ENSIMAG 1 Procédures, paramètres, pile En assembleur une fonction est une étiquette, c'est l'adresse de sa première instruction Lors de l'appel d'une fonction, la pile sert
Problèmes liés à la concurrence
ENS Cachan Problématique Difficile de gérer la concurrence : Pas toujours facile d avoir des fonctions réentrantes. Risque de race condition : ex : x :=x+1 x :=x+1 On voudrait des blocs d instructions
Rappel. Analyse de Données Structurées - Cours 12. Un langage avec des déclaration locales. Exemple d'un programme
Rappel Ralf Treinen Université Paris Diderot UFR Informatique Laboratoire Preuves, Programmes et Systèmes treinen@pps.univ-paris-diderot.fr 6 mai 2015 Jusqu'à maintenant : un petit langage de programmation
Cours de Programmation Impérative: Zones de mémoires et pointeurs
Cours de Programmation Impérative: Zones de mémoires et pointeurs Julien David A101 - david@lipn.univ-paris13.fr Julien David (A101 - david@lipn.univ-paris13.fr) 1 / 1 Z`o n`e s `d`e m`é m`o i r`e Julien
03/04/2007. Tâche 1 Tâche 2 Tâche 3. Système Unix. Time sharing
3/4/27 Programmation Avancée Multimédia Multithreading Benoît Piranda Équipe SISAR Université de Marne La Vallée Besoin Programmes à traitements simultanés Réseau Réseau Afficher une animation en temps
Partie 7 : Gestion de la mémoire
INF3600+INF2610 Automne 2006 Partie 7 : Gestion de la mémoire Exercice 1 : Considérez un système disposant de 16 MO de mémoire physique réservée aux processus utilisateur. La mémoire est composée de cases
Architecture des ordinateurs Introduction à l informatique
Architecture des ordinateurs Introduction à l informatique 17 septembre 2004 1 2 3 4 5 6 Les interrupteurs... 0V 5V Ce sont des composants électroniques qui laissent pser un courant principal lorsque la
Centre CPGE TSI - Safi 2010/2011. Algorithmique et programmation :
Algorithmique et programmation : STRUCTURES DE DONNÉES A. Structure et enregistrement 1) Définition et rôle des structures de données en programmation 1.1) Définition : En informatique, une structure de
Langage C. Patrick Corde. Patrick.Corde@idris.fr. 22 juin 2015. Patrick Corde ( Patrick.Corde@idris.fr ) Langage C 22 juin 2015 1 / 289
Langage C Patrick Corde Patrick.Corde@idris.fr 22 juin 2015 Patrick Corde ( Patrick.Corde@idris.fr ) Langage C 22 juin 2015 1 / 289 Table des matières I 1 Présentation du langage C Historique Intérêts
//////////////////////////////////////////////////////////////////// Administration bases de données
////////////////////// Administration bases de données / INTRODUCTION Système d informations Un système d'information (SI) est un ensemble organisé de ressources (matériels, logiciels, personnel, données
Introduction à MATLAB R
Introduction à MATLAB R Romain Tavenard 10 septembre 2009 MATLAB R est un environnement de calcul numérique propriétaire orienté vers le calcul matriciel. Il se compose d un langage de programmation, d
Cours 14 Les fichiers
Cours 14 Les fichiers F. Gayral 1 Fichier : définition /media/travaux/documents/fgenseignement/java1/courstpsfgfc/14-fichiers/voirtypefichiers Fichier = ensemble d informations codées et stockées sur une
4. Groupement d objets
Conception objet en Java avec BlueJ une approche interactive 4. Groupement d objets Collections et itérateurs David J. Barnes, Michael Kölling version française: Patrice Moreaux Rédigé avec 1.0 Principaux
Programmer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr)
Programmer en JAVA par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Plan 1. Présentation de Java 2. Les bases du langage 3. Concepts avancés 4. Documentation 5. Index des mots-clés 6. Les erreurs fréquentes
La programmation des PIC en C. Les fonctions, les interruptions.
La programmation des PIC en C Les fonctions, les interruptions. Réalisation : HOLLARD Hervé. http://electronique-facile.com Date : 26 août 2004 Révision : 1.2 Sommaire Sommaire... 2 Introduction... 3 Structure
6 - Le système de gestion de fichiers F. Boyer, UJF-Laboratoire Lig, Fabienne.Boyer@imag.fr
6 - Le système de gestion de fichiers F. Boyer, UJF-Laboratoire Lig, Fabienne.Boyer@imag.fr Interface d un SGF Implémentation d un SGF Gestion de la correspondance entre la structure logique et la structure
Programmation en langage C d un µcontrôleur PIC à l aide du compilateur C-CCS Sommaire
Programmation en langage C d un µcontrôleur PIC à l aide du compilateur C-CCS CCS Sommaire Généralités sur le langage. 2 Structure d un programme en C.. 3 Les constantes et équivalences.. 4 Les variables...
SGM. Master S.T.S. mention informatique, première année. Isabelle Puaut. Septembre 2011. Université de Rennes I - IRISA
SGM Master S.T.S. mention informatique, première année Isabelle Puaut Université de Rennes I - IRISA Septembre 2011 Isabelle Puaut SGM 2 / 1 Organisation de l enseignement Semestre 1 : processus, synchronisation
Mesure de performances. [Architecture des ordinateurs, Hennessy & Patterson, 1996]
![Mesure de performances. [Architecture des ordinateurs, Hennessy & Patterson, 1996]](/thumbs/23/1769821.jpg "Mesure de performances. [Architecture des ordinateurs, Hennessy & Patterson, 1996]")
Mesure de performances [Architecture des ordinateurs, Hennessy & Patterson, 1996] Croissance des performances des microprocesseurs Avant le milieu des années 80, le gain dépendait de la technologie. Après,
Le langage C. Introduction, guide de reference
Le langage C Introduction, guide de reference Ce document est une présentation du langage de programmation C, de sa syntaxe et de ses spécificités. Il est destiné essentiellement à servir de mémo-guide
Plan global Outils de développement et compilation. Ce que l on veut éviter. Plan. Git : gestion de code source et versionnement.
Plan global Outils de développement et compilation Git : gestion de code source et versionnement Timothée Ravier LIFO, INSA-CVL, LIPN 1 re année cycle ingénieur STI 2013 2014 1 Historique 2 Git 3 Pour
UE C avancé cours 1: introduction et révisions
Introduction Types Structures de contrôle Exemple UE C avancé cours 1: introduction et révisions Jean-Lou Desbarbieux et Stéphane Doncieux UMPC 2004/2005 Introduction Types Structures de contrôle Exemple
ARDUINO DOSSIER RESSOURCE POUR LA CLASSE
ARDUINO DOSSIER RESSOURCE POUR LA CLASSE Sommaire 1. Présentation 2. Exemple d apprentissage 3. Lexique de termes anglais 4. Reconnaître les composants 5. Rendre Arduino autonome 6. Les signaux d entrée