GE34 2020/2021

Exercices #4

1) Traduire les codes machine suivants en instructions MIPS

a) 00000000000010000101010011000000

sll $t2 , $t0, 19

b) 10001101001010000000000000100000

lw $t0, 32($t1)

2) Quelle est la valeur dans $s2 après les instructions suivantes, si la valeur du registre $s0
est 0x55555555 et la valeur de $s1 est 0x12345678?
a)
sll $s2, $s0, 4
or $s2, $s2, $s1

$s0 = 0101 0101 0101 0101 0101 0101 0101 0101

$s2 = 0101 0101 0101 0101 0101 0101 0101 0000 (sll de 4 bits)

$s2 = 0x57755778
b)
srl $s2, $s0, 3
andi $s2, $s2, 0xFFEF

$s0 = 0101 0101 0101 0101 0101 0101 0101 0101

$s2 = 0000 1010 1010 1010 1010 1010 1010 1010 (srl de 3 bits)

0xFFEF extension sur 32 bits

0x0000FFEF
0000 0000 0000 0000 1111 1111 1110 1111

$s2 = 0x0000AAAA
 3) Donnez l’instruction MIPS équivalente pour l’instruction C suivante
f = 105 | a;
ori $t1, $t0, 105

4) Traduire les instructions C suivantes en langage d'assembleur MIPS équivalent. Les

variables f, a et b soient respectivement assignées aux registres $s0, $s1, $s2
respectivement. Les adresses de base des tableaux K et L se trouvent respectivement
dans les registres $s6 et $s7.

a) f = a + b + L[4]
lw $t0, 16($s7)
add $s0, $s1, $s2
add $s0, $s0, $t0
b) f = a – K[L[4]]
lw $t0,16($s7)
sll $t1, $t0, 2
add $t2, $t1, $s6
lw $t3, 0($t2)
sub $s0, $s1, $t3

5) Montrez les effets des instructions suivantes sur la mémoire et les registres. Une partie
de la mémoire contient les données suivantes.

Le registre $t0 contient 0x10000000 et $s0 contient 0x01234567. On commence par les
valeurs données ci-dessous et on considère que l'architecture MIPS est en Big-Endian.

La mémoire
 a) lw $s1, 0($t0)
$s1 = 0x12345678
b) lw $s2, 4($t0)
$s2 = 0x9ABCDEF0
c) lb $s3, 0($t0)
$s3 = 0x00000012
d) lb $s4, 4($t0)
$s4 = 0xFFFFFF9A

e) sw $s0, 0($t0)

l’adresse 0x10000000 contient alors 0x01234567

f) sb $s0, 4($t0)

L’adresse 0x10000004 contient alors 0x67BCDEF0

6) Traduire la partie du programme MIPS suivant en code machine.

0XEB00000C Begin : …………………

0XEB000010 loop : addi $t1, $t1, -1
0XEB000014 lw $t1, 8($t2)
0XEB000018 beq $t1, $t4, loop
0XEB00001C j Begin

opcode
addi 0x08
lw 0x23
beq 0x04
j 0x02

addi $t1, $t1, -1

lw $t1, 8($t2)

beq $t1, $t4, loop

Soit (PC + 4) est l’adresse de l’instruction qui suit

Adresse de destination = (PC+4) + (immediate * 4)

immediate = (adresse de destination – (PC+4)) / 4
= (EB000010 – EB00001C) /4

Le complément à deux de EB00001C :

0001 0010 1111 1111 1111 1111 1110 0100
=>

1111 1111 1111 1111 1111 1111 1111 0100 /4

= 11 1111 1111 1111 1111 1111 1111 1101
On prend les 16 bits les moins significatifs : 1111 1111 1111
1101

j Begin
Adresse de destination = les 4 bits les plus significatifs du PC : ((jump target) *4)
Jump target = les premiers 28 bits de l’adresse de destination /4
= B00000C /4 = 2C00003
= 1011 0000 0000 0000 0000 0000 1100 /4  srl 2
= 10 1100 0000 0000 0000 0000 0011

7) Traduire cette partie d’un programme C en code assembleur MIPS équivalent

Switch(i) {
Case(1): i++ ;
Case(2): i+ =2;
Break ;
Case(3): i+=3;
}

addi $t0 , $zero , 1

bne $s0 , $t0 , C2_Condition
j C1
C2_Condition : addi $t0 , $zero , 2
bne $s0 , $t0 , C3_Condition
j C2
C3_Condition : addi $t0 , $zero , 3
bne $s0 , $t0 , Exit
j C3
C1 : addi $s0, $s0, 1
C2 : addi $s0, $s0 , 2
j Exit
C3 : addi $s0 , $s0 , 3
Exit :
8) Traduire cette partie d’un programme C en MIPS équivalent. Les variables a, b, c, d et i
sont dans les registres $ t1, $ t2, $ t3, $ t4, $ s0 respectivement.
a)
if (a<b && c==0) d=1 ;
b)
for(int i=0; i<5; i++){
a += b;
}

9) Traduire la fonction suivante en MIPS

int foo (int *a, int b) {

int f = 0;
while (b >= 0) {
f = f + *(a + b);
b=b–1
}
return f;
}

10) Ci-dessous une version récursive d’une fonction qui compte le nombre de bits mis à 1
dans un entier. Traduire cette fonction en MIPS.

int Bit1_counter(unsigned a) {
int bit_v;
if (a == 0)
return 0;
bit_v = a & 0x1;

return bit_v + Bit1_counter(a >> 1);

}