\section{Conclusion}

  \subsection{Etat des lieux}

  Ainsi donc comme nous l'avons vu precedement les techniques 
  utilisées pour le traçage de code sont rodées, mais on peut aller
  encore plus loin. Le tracage de code est donc bien utile dans pas
  mal de cas (cf intro) mais il faut savoir que son utilisation est
  illégale dans le cas d'utilisation sur des programmes protégés. Le
  traçage de code ne doit donc être utilisé que pour travailler sur
  son propre code d'une façon légale. Ce nouvel outil d'aide aux
  développeurs se generalise de plus en plus et maintenant même les
  constructeurs se mettent à faciliter le tracage de code au point de
  vue hardware.
    
  \begin{itemize}
  \item décompilateurs existans (dcc, SourceAgain )
    \begin{itemize}
    \item SoftIce, developpé par la société compuware. Est un 
      débogueur avancé pour les programmes sous Windows. Ce debogueur 
      ne s'appuye pas sur les ressources Windows pour travailler et 
      est donc immunisé aux erreurs Windows.
	    
    \item GDB, est le plus connu des debogueur Unix. Il permet d'examiner 
      ce qui se passe quand le programme s'arrête et meme de changer des 
      choses dans le programme afin de corriger un bug et de continuer 
      dans l'execution du programme.
      
    \item SourceAgain, est actuellement le plus dévellopé des 
      décompilateur pour Java. Il est capable  d'analyser correctement 
      et de décompiler les plus complexe contrôle de flot en Java, 
      et d'en reproduire un code Java recompilable à chaque fois.
      
    \item Dcc, est un décompilateur développé par Cristina Cifuentes. 
      Il permet de décompiler des executables pour les plateformes i386 
      et DOS de programmes écrits en C. Il est basé sur sur les 
      techniques standart d'optimisation et de théorie des graphes.
      
    \end{itemize}
  \item les résultats obtenus
    
    Les résultats obtenues à l'aide de ces divers décompilateurs sont 
    dans l'ensemble bien plus que satisfaisant lorsqu'il s'agit de code 
    simple, mais peut s'averer divergeant du code initial dans le cas de 
    code plus complexe lorsque l'on tente de remonter vers des représentations 
    intermédiaires de plus haut niveau.
    
  \end{itemize}