---
# System prepended metadata

title: Untitled

---


##  EXERCICE 1 : Affichage de chaînes de caractères.

### PARTIE A - Programme Hello world.

### Question 1.
Sachant que la longueur de la chaîne va être comparée  avec le registre r13 qui a une taille mémoire de 32 bits, on doit utiliser une longueur similaire pour que la comparaison puisse être faite on doit donc louer 32 bits pour la longueur.


### Question 2.

```assy
/*lea sauvegarde la direction de mémoire
du premier caractère du message*/
        lea     r12, msg[rip]
/*mov attribue la valeur 0 à r13.
Dans ce cas, il est plus optimal utiliser xor r13, r13*/

/*Pour effectuer un appel système,
il est nécessaire de placer
le numéro d'appel système dans rax
et ses arguments puis appeler syscall.
rsi c'est le message à afficher et rdx sa taille.*/
        mov     r13, 0
        
/*Le descripteur de fichier 1 est stdout*/
        mov     rdi, 1
/* 1 seul caractère*/
        mov     rdx, 1  
        
suivant:
/*
On va pointer vers l'adresse du premier registre du msg dans r12.
On va parcourir la chaîne caractère par caractère à l’aide d' une boucle,
sur r13 on va stocker le numéro relatif
du caractère dans laquelle on se trouve.*/

/* Adresse du caractère */
        lea     rsi, [r12+r13]
/* Appel no 1 (write)*/
        mov     rax, 1 
/* Appel système*/
        syscall                     
/*on va comparer la longeur de la chaine avec le compteur de
caracter actuelle si ce derniere est plus petit, on va rebucler 
sinon on va terminer le processus*/
        add     r13, 1       
        cmp     r13, longueur[rip]  
        jb      suivant 
/*On utilise l'appel système exit(retval) pour mettre fin à un
processus. Cet appel est le nunméro 60*/

/* Valeur de retour (ici 0)*/
        mov     rdi, 0 
/* Appel  60 (exit)*/
        mov     rax, 60             
        syscall
```
### PARTIE B - Chaîne de taille variable.

### Question 1.

Le but d'ajouter un caractère nul à la fin est d'éviter calculer la longueur du message à chaque fois et seulement comparer si le caractère est non zero.

### Question 2.

```assy=
.data
        msg: .asciz "Bonjour tout le monde!\0"
.global _start
_start:
        lea     r12, msg[rip]
        mov     r13, 0
        mov     rdi, 1
        mov     rdx, 1
suivant:
        lea     rsi, [r12+r13]
        mov     rax, 1
        syscall
        add     r13, 1
        cmp     rsi, 0
        jne     suivant
        mov     rdi, 0
        mov     rax, 60
        syscall\

```

##  EXERCICE 2 : Conversion et affichage de nombres.

### PARTIE A - Conversion d’un nombre non signé en base 10.

### Question 1.

Sachant que le nombre s'exprime sur 64 bits en base 2, l'espace d'adressage est respresenté par : $2^n-1$, en déduisant que:

$log(2^{64} - 1) = 19.26$
        
Nous avons besoin de  chifres pour exprimer la même quantité de nombres en base 10. Nous devons alors allouer 20 bits avec l'instruction .fill 20; 


### Question 2.

Nous avons fait la conversion sans l'afficher sur la console. L'affichage sera montré dans la question suivante. Pour l'instant nous avons vérifier les données avec le débouger.

```assy=
.data
        nombre: .quad 0x9aa5976dbe
        chaine: .fill 20
.global _start
_start:
        lea rbx, chaine[rip]
        mov rax, nombre[rip]
        mov rcx, 10
        xor r9, r9 
    iteration:
 /*xor : le reste de la division stocke en rdx*/
        xor rdx,rdx
/*div : On divise par la base*/
        div rcx
/*Addition : rdx = rdx + 0x30*/
        add rdx,0x30
/*rdx = valeur de rdx*/
        mov [rbx],rdx
/*Incrementation de r9 et rbx*/
        inc rbx
        inc r9
        cmp rax,0
/*On bloucle s'il est superieur de null*/
        ja iteration
    lea rsi,[rbx-1]
        mov     rax, 60
        mov     rdi, 0
        syscall
```

### PARTIE B - Affichage du nombre.

### Question 1.

```assy=
.data
        nombre: .quad 0x9aa5976dbe
        chaine: .fill 20
.global _start
_start:
        lea rbx, chaine[rip]
        mov rax, nombre[rip]
        mov rcx, 10
        xor r9, r9
    iteration:
        xor rdx,rdx
        div rcx
        add rdx,0x30
        mov [rbx],rdx
        inc rbx
        inc r9
        cmp rax,0
        ja iteration
    lea rsi,[rbx-1]
    affichage:
        mov rax,1
        mov rdi,1
        mov rdx,1
        syscall
        dec rsi
        dec r9
        jne affichage
        mov     rax, 60
        mov     rdi, 0
        syscall

```

### PARTIE C - Base quelconque entre 2 et 36.

### Question 1.
Un fois la division faite, le reste va representer la position absolue du caracter dans le tableau. C'est à dire le rest va nous indiquer quelle caractère prendre p.e 32=>Z


### Question 2.
Vu que le base minimal es 2 et le nombre est exprimé en 64 bits, la taille maximal de la chaîne sera de 64:

$$log(2^{64} - 1) = 19.26$$

### Question 3.
En base 32 le programme affiche JAIPERDU.

![](https://i.imgur.com/KtJ9h4R.png)


### CONCLUSION

Ce premier TP nous avons permis de manipuler l'IDE Eclipse afin de programmer en assembler. En utilisant des outils très fondamentaux, il est le cas du débouger et ses affichages des registres, le principe de l'appel système, l'interêt de la manipulation des drapeaux, de plus les differents conversions de base.