Chargé de cours : Frédéric Pétrot Équipe pédagogique : Alban Bourge, Stéphane Mancini, Claire Maiza, Luc Michel, Olivier Muller (resp.), Sebastien Viardot Année universitaire 2013-2014
Structure du cours C1 Présentation du projet CEP et rappels de VHDL C2 Chaîne de compilation et assembleur MIPS C3 Conventions pour les appels de fonctions C4 Gestion des interruptions 2 / 24
Introduction Plan 1 Introduction 2 Chaîne de compilation, exécutable 3 Assembleur MIPS 4 Traduction systématique des structures de contrôle 5 Modes d adressage 3 / 24
Introduction Introduction Étude du langage d assemblage du processeur MIPS MIPS32 ISA symbolique RISC : Reduced Instruction Set Computer Constructeur MIPS a, 1988 Importante part de marché dans l embarqué (networking en particulier), mais nettement moins que ARM b, favori des smartphones et autres tablettes. a. www.mips.com, racheté par Imagination en 2013 b. www.arm.com 4 / 24
Chaîne de compilation, exécutable Plan 1 Introduction 2 Chaîne de compilation, exécutable 3 Assembleur MIPS 4 Traduction systématique des structures de contrôle 5 Modes d adressage 5 / 24
Chaîne de compilation, exécutable Rappel sur la chaîne de compilation Cible MIPS sur hôte x86_64 : développement croisé Compilation mips-elf-gcc -g -S pwet.c produit pwet.s mips-elf-gcc -g -S ctru.c produit ctru.s Assemblage mips-elf-as -o pwet.o pwet.s produit pwet.o mips-elf-as -o ctru.o ctru.s produit ctru.o Édition de liens mips-elf-ld -T cep.ld -o gonk pwet.o ctru.o produit l exécutable gonk En pratique on appelle toujours mips-elf-gcc! 6 / 24
Chaîne de compilation, exécutable Exécutable en mémoire Exécutable constitué de 4 parties majeures Code Directive.text En lecture seulement Commence «en bas» de la mémoire Données connues statiquement Directive.data Variables globales initialisées au lancement En lecture/écriture Directive.comm Variables globales non explicitement initialisées, initialisées à zéro au lancement En lecture/écriture 7 / 24
Chaîne de compilation, exécutable Exécutable en mémoire Données connues statiquement Directive.rodata (sur certains systèmes) Constantes initialisées au lancement En lecture seulement Placées à la suite du code Données allouées dynamiquement Pile Variables globales dont les adresses sont définies à l exécution : tas ou heap Placées à la suite des données initialisées Gérée par le matériel et/ou le logiciel lors des appels de fonctions Commence «à la fin» de la mémoire, «va» dans le sens des adresses décroissantes 8 / 24
Chaîne de compilation, exécutable Résumé 0xFFFFFFFF 0x.. 0x... pile.. tas.bss 0x...data 0x.. données.rodata 0x.. 0x.. code.text 0x.. 0x00000000. 0x00000000. 0x.. 0x.. code.text 0x...rodata 0x.. données.data.bss tas.. 0x.. 0x.. pile 0x.. 0xFFFFFFFF. 9 / 24
Chaîne de compilation, exécutable Rappel sur les types de données Types entiers de tailles fixes Types C99 (stdint.h) Taille en octets int64_t, uint64_t 8 int32_t, uint32_t 4 int16_t, uint16_t 2 int8_t, uint8_t 1 Cas des pointeurs (adresses) Forcément dépendant de l ISA : MIPS R3000 = 4 octets indépendant type donnée pointée (ex. : char *, int64_t *, )! Attention! Ne pas utiliser les types standards du C (int, long, ) dont la taille peut varier selon l ISA! 10 / 24
Assembleur MIPS Plan 1 Introduction 2 Chaîne de compilation, exécutable 3 Assembleur MIPS 4 Traduction systématique des structures de contrôle 5 Modes d adressage 11 / 24
Assembleur MIPS ABI MIPS Convention d usage des registres Registre Nom Usage $0 $zero toujours 0 $1 $at réservé à l assembleur $2-$3 $v0-$v1 valeur(s) de retour (caller saved) $4-$7 $a0-$a3 4 premiers arguments (caller saved) $8-$15,$24,$25 $t0-$t9 temporaires (caller saved) $16-$23,$30 $s0-$s8 à sauver (callee saved) $26-$27 $k0-$k1 réservés au noyau (ne pas toucher) $28 $gp pointeur global (ne pas toucher) $29 $sp pointeur de pile (callee saved) $31 $ra adresse de retour (caller saved) clarification caller/callee saved cours n 3 utilisation des registres $v, $a, $t, $s dans un premier temps 12 / 24
Assembleur MIPS Macro-instructions Macros Pseudo-instructions facilitant l écriture Expansées en une ou deux instructions par l assembleur Branchements blt, bgt, ble, bge blt $t0, $t1, label => slt $at, $t0, $t1 bne $at, $zero, label bgt $t0, $t1, label => slt $at, $t1, $t0 bnez $at, label ble $t0, $t1, label => slt $at, $t1, $t0 beqz $at, label bge $t0, $t1, label => slt $at, $t0, $t1 beqz $at, label 13 / 24
Assembleur MIPS Macro-instructions Chargements move $t1, $v0 => addu $t1, $v0, $zero li $t0, 0xdeadbeef => lui $at, 0xdead ori $t0, $at, Oxbeef la $t0, label => lui $at, %hi(label) ori $t0, $at, %lo(label) Notations : %hi(label) => (label >> 16) & 0xffff %lo(label) => label & 0xffff Autres not $t1 => nor $t0, $t0, $zero neg $t4 => sub $t4, $zero, $t4 14 / 24
Traduction systématique des structures de contrôle Plan 1 Introduction 2 Chaîne de compilation, exécutable 3 Assembleur MIPS 4 Traduction systématique des structures de contrôle 5 Modes d adressage 15 / 24
Traduction systématique des structures de contrôle if Conditions Condition assembleur complémentaire de celle exprimée au départ if if (x == 0) { x = 12; } if: bnez $s1, endif li $s1, 12 endif: if else if (x == 0) { x = 12; } else { x = 24; } if: bnez $s1, else li $s1, 12 j endif else: li $s1, 24 endif: 16 / 24
Traduction systématique des structures de contrôle if else if else if else if (x == 0) { x = 12; } else if (x > y) { x = 24; } else { x = 36; } if: bnez $s1, elseif li $s1, 12 j endif elseif: ble $s1, $s2, else li $s1, 24 j endif else: li $s1, 36 endif: Condition compliquée évaluation paresseuse utilisation de branchements successifs if ((a > 0 && b < 0xdead) c == d) { } if : blez $v1, L0 slti $a1,$a1,0xdead bnez $a1, L1 L0 : bne $v0,$a3, endif L1 : endif: 17 / 24
Traduction systématique des structures de contrôle while/for while while (i > 0) { i--; } loop : blez $v0, endloop addiu $v0, $v0, -1 j loop endloop :. for, autre manière d écrire un while en C for (i = 0; i < n; i++) { } li $v0, 0 loop : bge $v1, $v0, endloop addiu $v0, $v0, 1 j loop endloop :. 18 / 24
Traduction systématique des structures de contrôle case Case Après la section suivante! 19 / 24
Modes d'adressage Plan 1 Introduction 2 Chaîne de compilation, exécutable 3 Assembleur MIPS 4 Traduction systématique des structures de contrôle 5 Modes d adressage 20 / 24
Modes d'adressage Modes d adressage Ou comment accéder aux données en mémoire Constantes : placées dans l instruction elle-même C : MIPS : int32_t mcdo = 0x8badf00d; li $at, 0x8badf00d Variables scalaires : cases mémoire Identifiées par leur adresse C : int32_t dice = 420; void pwet(void) { dice++; } MIPS : relatif + dép..data dice:.word 420.text pwet: la $s0, dice lw $t0, ($s0) addiu $t0,$t0,1 sw $t0, ($s0) 21 / 24
Modes d'adressage Modes d adressage Horreur! Variable identifiée par adresse = pointeur! Variables de tous types : case mémoire Si connue statiquement (constante dans le code) : (en supposant qu'on laisse les variables automatiques one, five et nine dans des registres) C : int32_t p[] = { 1, 3, 0, 7, 9, 11, 13, 17}; void pwet(void) { int32_t one = p[0]; int32_t nine = p[4]; int32_t *five = &p[2]; *five = 5; } MIPS : relatif + dép..data p:.word 1, 3, 0, 7, 9, 11, 13, 17.text pwet: la $at, p lw $v0, 0*4($at) # $v0 est one lw $s1, 4*4($at) # $s1 est nine li $t0, 5 # $t0 est 5 sur 32 bits addiu $v1, $at, 2*4 # $v1 est five sw $a0, ($v1) # maj de p[2] 22 / 24
Modes d'adressage Modes d adressage Variables : case mémoire Accès indicé : (en supposant qu'on laisse les variables i et s dans des registres) MIPS : relatif + dép. C : int32_t p[] = { 1, 3, 5, 7, 9, 11, 13, 17 }; void pwet(void) { int32_t i, s = 0; } for (i = 7; i >= 0; i--) s += p[i]; p:.word 1, 3, 0, 7, 9, 11, 13, 17.text pwet: li $at, 7 # i la $v0, p # &p[0] li $a0, 0 # s for: bltz $at, endfor sll $t0, $at, 2 # i*4 addiu $t0, $v0, $t0 # p+i*4 lw $t1, ($t0) # accès addiu $a0, $a0, $t1 # ajout addiu $at, $at, -1 j for endfor: 23 / 24
Modes d'adressage Case, le retour Case void pwet(void) { switch (y) { case 0: x += 11; break; case 1: x += 13; break; case 2: x += 17; break; case 3: x += 19; break; default: x += 23; } }.rdata table :.word $L0, $L1, $L2, $L3.text pwet: sltu $s0, $s0, 4 beq $s0, $zero, def la $at, table sll $a1, $s0, 2 # y*4 dans $a1 addu $at, $at, $a1 # lw $t0, 0($at) # charge l'@ jr $t0 # saute $L0: addiu $a0, $a0, 11 j esw # break $L1: addiu $a0, $a0, 13 j esw # break $L2: addiu $a0, $a0, 17 j esw # break $L3: addiu $a0, $a0, 19 j esw # break def: addiu $a0, $a0, 23 esw : 24 / 24