\documentclass[12pt,a4paper]{article}
%\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}

\usepackage[francais]{babel}
\usepackage[]{epsfig}
\usepackage[]{color}
\topmargin -0.5in
\textheight 9.5in
\textwidth 6in
\evensidemargin -0in
\oddsidemargin = \evensidemargin

%\special{landscape}

\newcommand{\br}{\overline}
\date{}
\begin{document} 
\boldmath
\title{TD7:  Introduction à l'assembleur sous linux}
\author{Première année d'IUT Informatique}
\maketitle


\section{Premier programme}
Voici un exemple\begin{verbatim}
.data  #debut segment de donnée
bonjour:
        .string "hello world!\n"
taille: 
        .long taille - bonjour  #longueur du texte bonjour
.align 4
        
.text  #début segment du code
.globl main  #rend le symbolel visible
main:
       ## ecriture via l'appel système write ()
        movl $4, %eax           # write () system call
        movl $1,%ebx            # %ebx = 1, fd = stdout
        leal bonjour, %ecx      # %ecx ---> hello
        movl taille, %edx       # %edx = count
        int $0x80               # execute write () system call
        
        ##fin de programme via   exit () system call 
        xorl %eax, %eax         # %eax = 0
        incl %eax               # %eax = 1 system call _exit ()
        xorl %ebx, %ebx         # %ebx = 0 normal program return code
        int $0x80               # execute system call _exit ()
\end{verbatim}



\begin{enumerate}
  \item Sauvegarder ce texte dans un fichier dont le nom se termine par ".s", par exemple \texttt{hello.s}
  \item Générer un exécutable avec la commande gcc , exemple:  \texttt{gcc hello.s -o hello}
  \item Vérifier l'exécution : 
\begin{verbatim}
JCB@taxus/TESTS 47 % gcc hello.s -o hello
JCB@taxus/TESTS 48 % hello
hello  world!
\end{verbatim}
\end{enumerate}

\section{Utilisation d'un "debuggueur"}

\texttt{gdb} est un debuggueur fourni par GNU (fournisseur de logiciel libre). La commande \texttt{man gdb} permet d'afficher le mode d'emploi.

\begin{enumerate}
  \item Lancer \texttt{gdb} sur l'exécutable que vous venez de générer, exemple  \texttt{gdb hello}
  \item Commenter la série de manipulations :
\begin{enumerate}
  \item \texttt{break main}
  \item \texttt{run}
  \item \texttt{disassemble}
\end{enumerate}
(help une commande donne un court mode d'emploi)
  \item La visualisation du contenu de la mémoire se fait avec la commande "x": exemple  \texttt{(gdb)x /20xb 0x80483c0}
permet d'afficher à partir de l'adresse  \texttt{0x80483c0} les 20 octets (b) suivants en hexadécimal (x) (format  \texttt{/20xb} )\begin{enumerate}
  \item Afficher le code mis en mémoire (il faut donc repérer l'adresse de la première instruction et calculer la taille du code)
  \item Afficher le segment de données. 
\end{enumerate}
\item Le contenu des registres peut être affiché en utilisant la commande \texttt{info reg} suivie des noms des registres, exemple \texttt{info reg eax ebx cs}, sans argument elle affiche tous les registres.
\item L'exécution pas à pas se fait avec la commande \texttt{stepi} ( \texttt{nexti} idem sans rentrer dans les appels de fonctions)\begin{enumerate}
  \item Avancer pas à pas en affichant à chaque pas le contenu du registre modifié.
  \item Que se passe-t-il lors de l'exécution de la commande \texttt{int    \$0x80}?
\end{enumerate}
\end{enumerate}

\section{Un petit exercice}

Voici quelques informations:






\begin{description}
  \item \texttt{.skip size , fill}  réserve \texttt{size} octets contenant \texttt{fill} (sinon des 0)

  \item Les numéros correspondant aux appels systèmes sont dans
\texttt{/usr/include/asm/unistd.h}

  \item Le mode d'emploi est donné par \texttt{man}  (\texttt{man 2 read}), il y a correspondance avec les noms de registres (le numéro de l'appel est dans \texttt{eax} ainsi que le retour après l'exécution, ensuite les arguments sont dans l'ordre dans \texttt{ebx} \texttt{ecx} \texttt{edx} \texttt{esi} \texttt{edi})
\begin{verbatim}
   read(int fd, void *buf, size_t count);
   eax      ebx        ecx           edx
\end{verbatim}

\item Les descripteurs de fichiers sont dans   \texttt{/usr/include/unistd.h}
\begin{verbatim}
/* Standard file descriptors.  */
#define STDIN_FILENO    0       /* Standard input.  */
#define STDOUT_FILENO   1       /* Standard output.  */
#define STDERR_FILENO   2       /* Standard error output.  */
\end{verbatim}
\end{description}

Ecrire un programme assembleur qui lit une chaîne de caractère (entrée avec un retour-à-la-ligne),  la place
ainsi que sa taille  dans une partie réservée en mémoire de la section des données, puis l'affiche à l'écran.

\newpage

CORRECTION du 2
\begin{verbatim}
JCB@taxus/TESTS 82 % gdb hello
(gdb) break main
Breakpoint 1 at 0x80483c0
(gdb) r
Starting program: /auto/bajard/ENSEIGNEMENT/ARCHI/2003/TESTS/base1 
(no debugging symbols found)...(no debugging symbols found)...
Breakpoint 1, 0x080483c0 in main ()
(gdb) disassemble 
Dump of assembler code for function main:
0x80483c0 <main>:       mov    $0x4,%eax
0x80483c5 <main+5>:     mov    $0x1,%ebx
0x80483ca <main+10>:    lea    0x8049444,%ecx
0x80483d0 <main+16>:    mov    0x8049453,%edx
0x80483d6 <main+22>:    int    $0x80
0x80483d8 <main+24>:    xor    %eax,%eax
0x80483da <main+26>:    inc    %eax
0x80483db <main+27>:    xor    %ebx,%ebx
0x80483dd <main+29>:    int    $0x80
End of assembler dump.
(gdb) x /31xb 0x80483c0
0x80483c0 <main>:     0xb8    0x04    0x00    0x00    0x00    0xbb    0x01    0x00
0x80483c8 <main+8>:   0x00    0x00    0x8d    0x0d    0x44    0x94    0x04    0x08
0x80483d0 <main+16>:  0x8b    0x15    0x53    0x94    0x04    0x08    0xcd    0x80
0x80483d8 <main+24>:  0x31    0xc0    0x40    0x31    0xdb    0xcd    0x80
(gdb) x /31cb 0x8049444
0x8049444 <data>:   104 'h' 101 'e' 108 'l' 108 'l' 111 'o' 32 ' '  32 ' '  119 'w'
0x804944c <data+8>: 111 'o' 114 'r' 108 'l' 100 'd' 33 '!'  10 '\n' 0 '\0'  15 '\017'
0x8049454 <taille+1>: 0 '\0'  0 '\0'  0 '\0'  65 'A' 
(gdb) stepi
0x080483c5 in main ()
(gdb) info reg eax ebx ecx edx
eax            0x4      4
ebx            0x4013be48       1075035720
ecx            0x1      1
edx            0x80483c0        134513600
.....
(gdb) stepi
0x080483d6 in main ()
(gdb) info reg eax ebx ecx edx
eax            0x4      4
ebx            0x1      1
ecx            0x8049444        134517828
edx            0xf      15
(gdb) stepi
hello  world!
0x080483da in main ()
\end{verbatim}

CORRECTION 3

\begin{verbatim}
.data
bonjour:
        .skip  80,0
taille:
        .long

.align 4,'A'

.text

.globl main

main:
      ## display string using read () system call
        movl $3, %eax           # read () system call
        movl $0,%ebx            # %ebx = 0, fd = stdin
        leal bonjour, %ecx      # %ecx ---> hello
        movl $80, %edx       # %edx = count
        int $0x80               # execute read () system call
movl %eax,taille          #retour taille entree


       ## display string using write () system call
        movl $4, %eax           # write () system call
        movl $1,%ebx            # %ebx = 1, fd = stdout
        leal bonjour, %ecx      # %ecx ---> hello
        movl taille, %edx       # %edx = count
        int $0x80               # execute write () system call

        ## terminate program via _exit () system call
        xorl %eax, %eax         # %eax = 0
        incl %eax               # %eax = 1 system call _exit ()
        xorl %ebx, %ebx         # %ebx = 0 normal program return code
        int $0x80               # execute system call _exit ()
\end{verbatim}
\end{document}











