Certified algorithms for program slicing

Algorithmes certifiés pour la simplification syntaxique de programmes

• Auteur / Autrice : Jean-Christophe Léchenet
• Direction : Pascale Le Gall
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 19/07/2018
• Etablissement(s) : Université Paris-Saclay (ComUE)
• Ecole(s) doctorale(s) : École doctorale Interfaces : matériaux, systèmes, usages (Palaiseau, Essonne ; 2015-....)
• Partenaire(s) de recherche : établissement opérateur d'inscription : CentraleSupélec (2015-....)
• Partenaire(s) de recherche : Laboratoire : Mathématiques et informatique pour la complexité et les systèmes (Gif-sur-Yvette, Essonne ; 2006-....)
• Jury : Président / Présidente : Claude Marché
• Jury : Examinateurs / Examinatrices : Catherine Dubois, Frédéric Loulergue, Nikolaï Kosmatov
• Jury : Rapporteurs / Rapporteuses : Torben Amtoft, David Pichardie

Mots clés

Mots clés contrôlés

Programmation parallèle (informatique)

Logiciels -- Vérification

Théorie des graphes

Mots clés libres

Slicing

Vérification formelle, dépendances de contrôle

Théorie des graphes

Coq

Why3

Program slicing, formal verification,

Control dependence

Graph theory

Coq

Why3

Résumé

La simplification syntaxique, ou slicing, est une technique permettant d’extraire, à partir d’un programme et d’un critère consistant en une ou plusieurs instructions de ce programme, un programme plus simple, appelé slice, ayant le même comportement que le programme initial vis-à-vis de ce critère. Les méthodes d’analyse de code permettent d’établir les propriétés d’un programme. Ces méthodes sont souvent coûteuses, et leur complexité augmente rapidement avec la taille du code. Il serait donc souhaitable d’appliquer ces techniques sur des slices plutôt que sur le programme initial, mais cela nécessite de pouvoir justifier théoriquement l’interprétation des résultats obtenus sur les slices. Cette thèse apporte cette justification pour le cas de la recherche d’erreurs à l’exécution. Dans ce cadre, deux questions se posent. Si une erreur est détectée dans une slice, cela veut-il dire qu’elle se déclenchera aussi dans le programme initial ? Et inversement, si l’absence d’erreurs est prouvée dans une slice, cela veut-il dire que le programme initial en est lui aussi exempt ? Nous modélisons ce problème sur un mini-langage impératif représentatif, autorisant les erreurs et la non-terminaison, et montrons le lien entre la sémantique du programme initial et la sémantique de sa slice, ce qui nous permet de répondre aux deux questions précédentes. Pour généraliser ces résultats, nous nous intéressons à la première brique d’un slicer indépendant du langage : le calcul générique des dépendances de contrôle. Nous formalisons une théorie élégante de dépendances de contrôle sur des graphes orientés finis arbitraires prise dans la littérature et améliorons l’algorithme de calcul proposé.Pour garantir un maximum de confiance dans les résultats, tous ces travaux sont prouvés dans l’assistant de preuve Coq ou dans l’outil de preuve Why3.

Program slicing is a technique that extracts, given a program and a criterion that is one or several instructions in this program, a simpler program, called a slice, that has the same behavior as the initial program with respect to the criterion. Program analysis techniques focus on establishing the properties of a program. These techniques are costly, and their complexity increases with the size of the program. Therefore, it would be interesting to apply these techniques on slices rather than the initial program, but it requires theoretical foundations to interpret the results obtained on the slices. This thesis provides this justification for runtime error detection. In this context, two questions arise. If an error is detected in the slice, does this mean that it can also be triggered in the initial program? On the contrary, if the slice is proved to be error-free, does this mean that the initial program is error-free too? We model this problem using a small representative imperative language containing errors and non-termination, and establish the link between the semantics of the initial program and of its slice, which allows to give a precise answer to the two questions raised above. To apply these results in a more general context, we focus on the first step towards a language-independent slicer: an algorithm computing control dependence. We formalize an elegant theory of control dependence on arbitrary finite directed graphs taken from the literature and improve the proposed algorithm. To ensure a high confidence in the results, we prove them in the Coq proof assistant or in the Why3 proof plateform.