Des applications compilées en code-octet et encodées dans le format de fichier class sont normalement chargées et exécutées par une machine virtuelle. La vérification du code-octet est un processus utilisé par une machine virtuelle pour renforcer la sécurité des systèmes distribués en garantissant la conformité du code de classes avec les règles du langage. Les algorithmes actuels de vérification du code-octet utilisent des approches comme l'analyse de flot de données, le model checking ou le code-certifié (similaire au proof-carrying code). Mais l'on dénote certains problèmes, en particulier dus aux sous-routines, avec soit des spécifications informelles et incomplètes, soit des algorithmes ne supportant qu'un sous-ensemble du jeu d'instructions du code-octet, ou encore des performances exponentielles proportionnellement à la taille du code des méthodes à vérifier. Dans ce mémoire nous présentons une technique de vérification du code-octet avec sous-routines par code-certifié. Nous présentons en particulier la conception d'un format de certificat, d'un algorithme de calcul de certificat et d'un algorithme de vérification pour l'ensemble du jeu d'instructions du code-octet. Notre algorithme de vérification a une complexité linéaire en proportion de la taille du code des méthodes. Le développement d'un vérificateur et d'un compilateur de certificats a servi à conduire des expérimentations qui montrent que le format de certificat proposé est suffisamment riche pour effectuer la vérification du code-octet. De plus, nous présentons les résultats de l'évaluation du coût en espace mémoire de la certification de classes avec une telle technique. L'observation montre un accroissement relativement faible de la taille d'un échantillon de plus de 35 000 classes suite à leur certification. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Vérification, Code-octet, Code-certifié, Analyse de flot de données, Sous-routines, Java.

La compilation de codee source vers du code octet combiné avec l'utilisation d'une machine virtuelle ou d'un interpréteur pour l'exécuter est devenue une pratique courante qui permet de conserver une indépendance face à la plateforme matérielle. Les interpréteurs sont portables et offrent une simplicité de développement qui en font un choix intéressant pour la conception de prototypes de nouveaux langages de programmation. L'optimisation des techniques d'interprétation existantes est un sujet de recherche qui nous intéresse particulièrement. Nous avons voulu, par l'entremise de notre projet de recherche, étudier jusqu'où il est possible de pousser l'optimisation dans un interpréteur. Après avoir étudié les types d'interpréteurs existants, nous avons constaté que les interpréteurs les plus performants se basent tous sur le même principe: La réduction du coût associé aux répartitions entre les instructions interprétées. Ce coût est causé par les instructions de répartitions elles-mêmes, mais surtout par l'augmentation du taux d'erreur qu'elles procurent dans les prédicteurs de branchement qui se trouvent au sein des processeurs modernes. Des mauvaises prédictions de branchements occasionnent des coûts importants sur une architecture pipelinée. L'interpréteur linéaire inclusif est un des plus performants qui existe. En nous basant sur cet interpréteur, nous avons fait la conception et l'implémentation d'un mécanisme qui lui permet d'augmenter la longueur des ses super-instructions et par le fait même de diminuer le nombre de répartitions pendant l'exécution. Nous avons mis au point un mécanisme dynamique d'inclusion partielle des méthodes dans cet interpréteur. Nous avons aussi conçu un système de profilage qui nous permet de détecter les sites d'invocations chauds et d'y effectuer l'inclusion du chemin le plus fréquenté de la méthode appelée. En brisant ainsi la frontière entre le corps des méthodes, nous parvenons à augmenter la longueur moyenne des super-instructions. Nous avons surmonté et résolu toutes les difficultés inhérentes à l'implémentation d'un tel système dans une véritable machine virtuelle Java (synchronisation, exceptions, présence d'un nettoyeur de mémoire, présence de sous routines dans le code octet Java). Nous fournissons une étude empirique de l'impact de notre système sur un interpréteur linéaire inclusif en exécutant des applications Java d'envergure. Dans tous les cas étudiés, on arrive à augmenter la longueur moyenne des super-instructions invoquées et à diminuer le nombre de répartitions pendant l'exécution. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Interpréteur, Inclusion, Inclusion partielle, Profilage, Machine virtuelle, Java, JVM, SableVM.

L'utilisation du langage Java dans plusieurs environnements (web, systèmes embarqués, systèmes mobiles, etc.) a élevé considérablement le niveau d'exigence envers ce langage, ce qui a amené les chercheurs et les développeurs à s'intéresser au système de sécurité de la Machine Virtuelle Java (MVJ) qui repose principalement sur le vérificateur du code octet. Dans ce mémoire, nous expliquons le fonctionnement du vérificateur Java, son rôle, les différentes techniques proposées pour son implémentation et un algorithme que nous proposons comme alternative sérieuse aux autres vérificateurs qui existent déjà. Nous nous intéresserons plus particulièrement à l'effet des sous-routines sur le bon typage des instructions. Nous présentons aussi une nouvelle approche de vérification de la synchronisation en nous basant sur l'analyse de flot de données et en identifiant les références qui pointent vers le même objet. ______________________________________________________________________________ MOTS-CLÉS DE L’AUTEUR : Machine Virtuelle Java, Code octet, Vérificateur, Synchronisation, Java, ClassLoader, Instructions, Treillis, Analyse de flot de données, Fonctions de transfert, Point fixe.