Rapport de stage : Interprétation abstraite orientée ?· Rapport de stage : Interprétation abstraite…

Download Rapport de stage : Interprétation abstraite orientée ?· Rapport de stage : Interprétation abstraite…

Post on 16-Sep-2018

215 views

Category:

Documents

0 download

Embed Size (px)

TRANSCRIPT

  • Rapport de stage :Interprtation abstraite oriente

    objet, contrats et invariants d'objets

    Michal Monerau

    Juillet - Octobre 2009

    Sous la direction de Manuel Fhndrich

    Microsoft Research, Redmond, WA, USA

  • Table des matires

    1 Le cadre du stage 2

    1.1 Merci ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2 Microsoft Research . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Place dans mon cursus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

    2 Contenu scientique 3

    2.1 CodeContracts & Clousot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.1.1 L'environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.1.2 Mon travail dans ce cadre . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.1.3 L'implmentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

    2.2 Les contrats infrs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2.1 Le contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2.2 Stockage des contrats infrs . . . . . . . . . . . . . . . . . . . . . . . . . 62.2.3 Utilit des contrats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.2.4 Validit des contrats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

    2.3 Invariants d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.3.1 Intgration d'une analyse d'objets dans Clousot . . . . . . . . . . . . . . . 102.3.2 Analyse des champs readonly . . . . . . . . . . . . . . . . . . . . . . . . 11

    3 Exprience et conclusions 13

    1

  • 1 Le cadre du stage

    1.1 Merci !

    Je tiens remercier Manuel Fhndrich pour m'avoir encadr dans ce stage avec disponibilitet enthousiasme. C'tait trs motivant et agrable. Je remercie galement Francesco Logozzopour son aide et sa disponibilit sans faille. Plus globalement, je remercie toutes les autrespersonnes avec qui j'ai pu discuter ou travailler MSR et les autres stagiaires (hey Jean !). Tousont contribu me faire passer un t gnial, c'tait un vrai plaisir de travailler au sein de cettequipe. Et merci tout particulirement Radhia et Patrick Cousot pour les discussions toujoursagrables et intressantes.

    1.2 Microsoft Research

    Microsoft est le gant du software que tout le monde connat, bas Redmond, WA aux tats-Unis. La compagnie emploie prs de 100 000 personnes au total. Sur le campus de Redmond, ily a plus de 30 000 employs, ce qui reprsente le cur de la rme.

    La principale mission de Microsoft est d'diter des solutions logicielles pour permettre d'uti-liser l'outil informatique de manire naturelle et ecace.

    Dans le cadre de cette mission, rester la pointe de l'innovation et de la recherche reprsenteun enjeu de taille. C'est pourquoi Microsoft a une lire de recherche trs importante. MicrosoftResearch regroupe prs de 1 000 chercheurs dans des domaines aussi varis que les langages deprogrammation, la vision, le hardware, la cryptographie, des sujets purement thoriques, etc.

    Le nancement de cette lire Microsoft Research est trs confortable et permet un travailserein dans toutes les considrations matrielles.

    J'ai travaill dans l'quipe RiSE (Research in Software Engineering), et plus prcisment dansl'quipe Programming Languages and Analysis dirige par Manuel Fhndrich(http ://research.microsoft.com/en-us/groups/pla).

    1.3 Place dans mon cursus

    J'ai un L3/M1 de Mathmatiques & Informatique, ainsi que l'agrgation de Mathmatiques,option Informatique.

    En cette anne scolaire 2009-2010, j'ai dcid de prendre une anne de csure an de travailleren recherche dans le domaine de l'interprtation abstraite. Ce stage chez Microsoft constitue lapremire tape de ce projet.

    2

  • 2 Contenu scientique

    2.1 CodeContracts & Clousot

    2.1.1 L'environnement

    CodeContracts est un projet visant globalement fournir au programmeur des outils ecacesd'analyse statique et dynamique de code.

    La partie analyse statique est base sur l'interprtation abstraite et s'applique tout binaire.NET compil. C'est--dire que l'analyse peut tre excute sur n'importe quelle librairie ouexcutable provenant d'un langage .NET (C#, Managed C++, VB .NET, ...).

    En eet, le framework .NET fonctionne de la manire suivante : le code source est critdans n'importe quel langage .NET, puis un compilateur transforme ce code en code MSIL quipeut tre assimil du code assembleur pour une machine virtuelle .NET, qui, elle, se charged'excuter le code. Un des intrts de MSIL par rapport un langage assembleur classique estqu'il conserve des informations smantiques comme les dnitions des classes, des types, etc.

    Figure 1 Organisation de .NET Framework et analyse statique de Clousot

    C'est pourquoi faire l'analyse statique au niveau MSIL est si intressant : cela permet decibler tous les langages .NET, et de plus on accde au code aprs compilation ce qui vite d'avoir vrier le compilateur en lui-mme. D'autre part, on dispose dj d'outils pour extraire lasmantique du code MSIL.

    Le droulement de l'analyse se fait en plusieurs tapes.Premirement, au moment de l'criture du code, une librairie .NET permet au programmeur

    d'insrer des annotations dans le code (sous forme de vrai code, pas des commentaires, ce quipermet de tester smantiquement ces annotations) : pr-conditions et post-conditions sur lesmthodes, invariants d'objets pour les classes, assertions, assomptions.

    3

  • Aprs compilation (avec le compilateur habituel correspondant au langage utilis) et siCodeContracts est activ, ces annotations sont propages dans l'assembly MSIL an de per-mettre une analyse ultrieure (statique et/ou l'excution).

    Clousot, l'analyseur statique intervient alors : il excute plusieurs analyses sur le code (v-rication qu'il n'y a pas de drfrencement de rfrences nulles, que les accs aux tableaux nedbordent pas, etc.) en prenant en compte les annotations du programmeur et en infrant auto-matiquement un maximum d'autres. Au bout du compte, on obtient une liste de warnings (resp.erreurs) selon les rsultats, qui pointent vers les endroits du code o un bug est possible (resp.prsent).

    Figure 2 Workow de Clousot, l'analyseur statique au cur du projet CodeContracts

    Comme tout ceci repose sur la thorie de l'interprtation abstraite, on est garanti que l'ana-lyse est correcte (aux erreurs humaines de programmation dans l'analyseur prs) mais il peutventuellement y avoir des avertissements superus du fait d'un manque de prcision dans l'in-frence.

    Si l'analyse dynamique est active, toutes les assertions, pr et post conditions sont vriesen direct l'excution et terminent le programme si elles ne sont pas respectes.

    2.1.2 Mon travail dans ce cadre

    J'ai ralis deux projets durant mon stage. Le premier vise permettre de rutiliser lesrsultats d'une analyse, le deuxime vise infrer des invariants d'objets. Voyons cela plus pr-cisment.

    1er projet : si un assembly A rfrence un autre assembly B, on veut importer les contratsde B dans l'analyse de A. Avant mon stage, on ne pouvait importer que les contrats critsexplicitement par le programmeur dans le code de B parce que tous les contrats infrs nevivaient qu'en mmoire lors de l'analyse de B.

    4

  • Figure 3 Mon premier projet : Workow de Clousot, on voudrait rutiliser les contrats infrs

    Mon premier projet a donc eu pour but de rendre les contrats infrs lors de l'analyse de Bvisibles par A. Comme on peut s'y attendre, le caractre automatique de l'infrence gnre beau-coup plus de contrats que ce qu'on peut crire la main. En particulier, une telle fonctionnalitest trs utile pour les assemblies systme : on peut lancer une analyse sur les DLLs systmessouvent rfrences puis utiliser les rsultats pour toutes les futures analyses qui en dpendent.

    De plus, la thorie de l'interprtation abstraite permettant de choisir la prcision d'analysede manire trs pratique, on peut imaginer lancer des analyses trs prcises mais longues sur lesDLLs souvent rfrences, puis stocker les rsultats une bonne fois pour toutes.

    2me projet : l'objectif tait d'intgrer des analyses d'objets dans Clousot an d'infrer desinvariants d'objets. En eet jusque l, l'analyseur n'infrait que des contrats sur les mthodes declasses.

    2.1.3 L'implmentation

    L'intgralit du projet CodeContracts est implmente en C#. Nous nous intresserons iciseulement l'interprteur abstrait.

    La lecture du code MSIL se fait travers la librairie Microsoft CCI (disponible sur internet).La structure du code est ensuite abstraite pour que l'analyseur puisse manipuler des objets demoins bas niveau que le code MSIL directement.

    Les analyses de mthodes, indpendantes et utilisant chacune leur propre domaine abstrait,sont excutes squentiellement. L'ordre d'analyse des mthodes suit les contraintes imposespar le graphe des appels.

    Le projet est scind en dirents modules, indpendants les uns des autres qui limitent lesdpendances logiques entre les lments orthogonaux de l'implmentation.

    5

  • Donnons prsent une ide de l'chelle. Le code du projet CodeContracts occupe plusieurscentaines de milliers de lignes, et Clousot reprsente lui seul entre 50 000 et 100 000 lignes.

    2.2 Les contrats infrs

    2.2.1 Le contexte

    Lorsqu'il crit son code, le programmeur peut fournir des contrats lui-mme (sous la formede ce qu'on peut voir en gure 5 bien plus bas). On s'attend ce qu'il fournisse l'analyseurles contrats non-triviaux qui sont trop complexes pour tre dduits automatiquement. De faoncomplmentaire, l'analyseur doit, pour sa part, dduire un maximum de contrats pour qu'unmaximum d'assertions puissent tre prouves (et ainsi viter des avertissements inutiles).

    Pour avoir un ordre d'ide, le nombre de contrats dduits sur une DLL de grande chelle(par exemple System.dll, provenant du .NET Framework) est de quelques dizaines de milliers(cf. chires exacts plus bas en gure 6).

    Dans ce contexte, il se pose quelques questions naturelles sur ces contrats infrs :

    1. Comment les stocker pour les rutiliser dans une autre analyse ? C'est ce qu'on a dj vuen Figure 3.

    2. Sont-ils tous utiles ? Dans le cas contraire, il serait intressant de supprimer les contratsinutiles an d'acclrer l'analyse.

    3. Sont-ils tous valides ? On ne veut videmment pas faire de raisonnements faux.

    Voyons tour tour comment rpondre ces inquitudes.

    2.2.2 Stockage des contrats infrs

    Le stockage des contrats infrs n'est pas si vident qu'il pourrait y paratre. En eet, on neveut pas stocker simplement le contrat en lui-mme (une reprsentation sous forme de chane decaractres par exemple), mais bien des informations smantiques associes (il serait inecace etcompliqu de rinterprter chaque contrat l'importation).

    Principe

    La solution que nous avons retenue pour raliser cette tche est de repasser par du code C# :l'ide est que, pour chaque assembly analys, on gnre tout le code C# de l'assembly, sauf quele corps de chaque mthode contient seulement les contrats infrs.

    Une fois qu'on dispose de ce code, on peut le compiler simplement avec le compilateur habituel,et on obtient gratuitement une DLL contenant tous les contrats infrs. prsent, on peutfournir cette DLL de contrats infrs en entre lors de l'analyse d'lments qui dpendent denotre assembly de rfrence (Figure 4 ci-dessous).

    6

  • Figure 4 Stocker les contrats infrs sous forme de code C#

    Avantages et intrts

    Cette solution, outre de remplir l'objectif x, prsente beaucoup d'autres avantages commenous allons le voir.

    Citons d'ores et dj le fait que le code produit est tout fait lisible. Il permet donc une ditionhumaine qui peut s'avrer trs intressante. En eet, gnrer une bibliothque de contrats pourles DLLs systme est videmment d'une trs grande importance pour l'utilit de CodeContracts.Jusque l, la seule solution pour gnrer ces contrats taient de les crire la main sous formede code C#. Il n'est pas besoin de prciser quel point cette tche est fastidieuse et longue. Ici,on obtient dj le squelette avec tous les contrats infrs et on n'a qu' ajouter simplement ceuxqu'on dsire, comme le montre l'exemple en gure 5 plus bas.

    De plus, on obtient une vrication smantique gratuite des contrats (car eectue par lecompilateur C#) qui est trs utile. En eet, il y a tellement de raisons pour un contrat gnrautomatiquement qu'il ne se compile pas (il sut de violer la moindre petite rgle C#), qu'ilfaut faire un vrai eort pour le rendre compilable. Par consquent, un contrat qui compile a detrs bonnes chances d'tre eectivement voulu. C'est ce que nous avons constat dans les faits.

    Enn, une fois les contrats stocks, on peut itrer l'analyse en fournissant en entre les contratsinfrs jusqu' ce qu'on ne dduise rien de plus. Cependant, cause de petits problmes ind-pendants dans Clousot, je n'ai pas pu faire de mesure exacte de l'ecacit d'une telle approche.

    7

  • Figure 5 Sortie typique de l'outil OutputPrettyC# : le squelette de l'assembly mais avec tousles contrats (et invariants, cf. projet 2) infrs lors de l'analyse. Ici provenant d'une analyse deSystem.Conguration.dll

    Mon travail

    Pour raliser ce projet, il fallait intercepter les contrats gnrs dans Clousot et les nettoyer(cf. plus bas). Indpendamment, j'ai programm une librairie permettant de produire du codeC# valide (et joli !), et l'ai utilise en particulier pour gnrer tout le code C# voulu.

    Au bout du compte, tout a fonctionn correctement. Les DLLs les plus importantes du frame-work .NET menaient un code gnr qui compile sans erreur, et qui contient tous les contratsinfrs intressants.

    2.2.3 Utilit des contrats

    Comme voqu ci-dessus, cette approche fournit une vrication smantique gratuitement.Cette vrication reprsentait la premire mise l'preuve des contrats fournis par Clousot. Eneet, jusque l, les contrats taient utiliss de manire interne et simplement achs l'cran.Il n'y avait pas vraiment de moyen de vrier qu'ils voulaient bien dire quelque chose.

    Nous avons beaucoup appris de cette nouvelle approche.

    La programmation sur la plateforme .NET est rsolument oriente objet. Cependant, l'ana-lyseur statique n'est pas intgralement orient objet. Bien entendu, la structure objet du codeest prise en compte lors de l'abstraction du code MSIL, mais nous nous sommes aperus qu'certains endroits il tait possible de faire des optimisations supplmentaires.

    La premire chose qui est ressortie des tests de compilation des contrats infrs est qu'il yavait une bonne proportion de contrats qui n'avaient pas d'utilit pour l'analyse (et qui menaient des erreurs de compilation).

    Typiquement, on trouvait dans le corps d'une mthode des contrats sur un champ privd'une autre classe, inaccessible depuis ce point. Un tel contrat ne peut tre d'aucune utilit

    8

  • localement puisque le champ rfr ne pourra jamais tre accd. Il peut donc tre ignor sansperte d'information. Attention cependant : ce contrat pourrait servir dans l'analyse interne del'autre classe, il convient donc ne pas le supprimer compltement partout.

    Cela conduit faire une distinction de principe entre les contrats : certains sont des contratsd'interface, ie. ils concernent des membres publics et donnent des informations pour une m-thode utili...

Recommended

View more >