FR3025036A1

FR3025036A1 - PROCESS FOR AUTOMATICALLY PROCESSING A SOURCE CODE FOR ITS AERONAUTICAL CERTIFICATION; COMPUTER PROGRAM PRODUCT

Info

Publication number: FR3025036A1
Application number: FR1401896A
Authority: FR
Inventors: Martin Rayrole
Original assignee: Thales SA
Current assignee: Thales SA
Priority date: 2014-08-25
Filing date: 2014-08-25
Publication date: 2016-02-26
Anticipated expiration: 2034-08-25
Also published as: FR3025036B1

Abstract

Ce procédé traite un code source initial (CSI), en langage C ou C++, pour générer un code source simplifié (CSS) respectant des contraintes d'écriture requises pour la certification, en générant, suite à une analyse textuelle des fichiers de programmation et de commandes du code source initial, une liste des fichiers de programmation utiles à la compilation et un graphe d'appel des constantes et des fonctions définies par des directives de compilation, puis en marquant les nœuds du graphe d'appel qui correspondent à des constantes ou des fonctions qui sont utiles pour la compilation d'au moins un fichier de programmations utile, et à recopier les instructions des fichiers de programmation utiles pour constituer des fichiers de programmation du code source simplifié, en ne recopiant pas les instructions qui correspondent à des définitions de constantes ou de fonctions qui, d'après le graphe d'appel, ne sont pas utiles à la compilation.This method processes an initial source code (CSI), in C or C ++ language, to generate a simplified source code (CSS) complying with the writing constraints required for the certification, by generating, following a textual analysis of the programming files and of initial source code, a list of programming files useful for compilation and a call graph of constants and functions defined by compilation directives, then marking the nodes of the call graph which correspond to constants or functions that are useful for compiling at least one useful programming file, and copying the instructions of the useful programming files to form simplified source code programming files, by not copying instructions that correspond to definitions of constants or functions which, according to the call graph, are not useful for compilation.

Description

1 Procédé de traitement automatique d'un code source en vue de sa certification aéronautique ; produit programme d'ordinateur associé. L'invention a pour domaine celui des logiciels dans le domaine avionique.1 Automatic source code processing method for aeronautical certification; product associated computer program. The invention is in the field of software in the avionics field.

L'exécution d'une application logicielle sur une plateforme informatique embarquée à bord d'un aéronef permet de fournir une fonctionnalité particulière. Certaines fonctionnalités sont vitales pour la sureté de fonctionnement de l'aéronef. Il faut pouvoir garantir la bonne exécution d'une application logicielle embarquée, en particulier lorsqu'elle fournit une fonctionnalité vitale. Il est ainsi nécessaire de mettre en oeuvre un processus de certification pour chaque application logicielle embarquée. La certification d'une application logicielle embarquée induit différentes contraintes. En particulier, une application logicielle fournissant une fonctionnalité vitale pour l'aéronef doit être conforme à un niveau élevé de certification, qui définit des contraintes relatives à la manière d'écrire le code source de cette application logicielle. Dans ce qui suit, ces contraintes, relatives à la manière d'écrire le code source d'une application logicielle embarquée devant être certifiée, sont dénommées contraintes avioniques d'écriture.The execution of a software application on an onboard computer platform on board an aircraft makes it possible to provide a particular functionality. Some features are vital to the operational safety of the aircraft. It must be possible to guarantee the proper execution of an embedded software application, in particular when it provides a vital functionality. It is thus necessary to implement a certification process for each embedded software application. The certification of an embedded software application induces different constraints. In particular, a software application providing a vital functionality for the aircraft must comply with a high level of certification, which defines constraints on how to write the source code of this software application. In what follows, these constraints, relating to the manner of writing the source code of an onboard software application to be certified, are called avionic write constraints.

Parmi les contraintes avioniques d'écriture, il faut notamment que le code source ne contienne pas de code mort lié à la compilation, c'est-à-dire un ensemble d'instructions inutiles au sens où elles ne sont pas traitées par le compilateur lors de la compilation du code source afin de générer le code binaire. En effet, ces instructions inutiles complexifient le code source, qui devient alors difficilement lisible. De ce fait, la compréhension du code source ou sa maintenance deviennent difficiles. A cause de l'existence de ces contraintes avioniques d'écriture, le code source d'une application logicielle embarquée est spécifiquement écrit (c'est-à-dire développé) pour fournir la fonctionnalité correspondante à bord d'un aéronef.Among the avionic write constraints, it is necessary that the source code does not contain dead code linked to the compilation, that is to say a set of useless instructions in the sense that they are not processed by the compiler when compiling the source code to generate the binary code. Indeed, these useless instructions complicate the source code, which becomes difficult to read. As a result, understanding the source code or its maintenance becomes difficult. Because of the existence of these avionic write constraints, the source code of an embedded software application is specifically written (that is, expanded) to provide the corresponding functionality on board an aircraft.

Ainsi, à l'heure actuelle, si l'on souhaite réutiliser (c'est-à-dire porter) dans le domaine avionique un code source qui existe déjà pour une fonctionnalité particulière, mais qui a été développé sans prendre en compte les contraintes avioniques, en particulier les contraintes avioniques d'écriture, il est nécessaire de reprendre entièrement et manuellement ce code source de manière à le modifier pour qu'il respecte les contraintes avioniques d'écriture et que l'application logicielle correspondante puisse être certifiée.Thus, at present, if we wish to reuse (that is to say, wear) in the avionics domain source code that already exists for a particular feature, but has been developed without taking into account the constraints avionics, in particular avionic write constraints, it is necessary to completely and manually resume this source code so as to modify it so that it complies with the avionic write constraints and that the corresponding software application can be certified.

3025036 2 Cependant, la reprise manuelle d'un code source existant n'est envisageable que si la taille de celui-ci n'est pas trop importante. Par exemple, il n'est pas envisageable de porter dans le domaine avionique un système d'exploitation grand public, tel que le système d'exploitation « Linux ». Le code 5 source du noyau de ce système d'exploitation contient en effet plus de quatorze millions de lignes, ce qui rend impossible toute reprise manuelle en vue de garantir le respect des contraintes avioniques d'écriture et de passer avec succès les étapes du processus de certification relatives à la certification du code source. L'invention a donc pour but de pallier ce problème.3025036 2 However, the manual recovery of an existing source code is only possible if the size of this one is not too important. For example, it is not conceivable to bring into the avionics field a consumer operating system, such as the "Linux" operating system. The kernel source code of this operating system contains more than fourteen million lines, which makes manual recovery impossible to ensure compliance with avionic write constraints and to successfully pass through the process steps. certification related to source code certification. The invention therefore aims to overcome this problem.

10 L'invention a pour objet un procédé de traitement automatique d'un code source initial, écrit dans un langage de programmation du type C ou C++, pour générer un code source simplifié respectant des contraintes avioniques d'écriture requises par un processus de certification, le procédé comportant les étapes consistant à : - suite à une analyse textuelle des fichiers de programmation et des fichiers de 15 commandes du code source initial, à générer : - une liste des fichiers de programmation utiles à la compilation parmi lesdits fichiers de programmation ; et, - un graphe d'appel des constantes et des fonctions définies par des directives de compilation contenues dans lesdits fichiers de programmation, 20 - marquer des noeuds dudit graphe d'appel qui correspondent à des constantes ou des fonctions qui sont utiles pour la compilation d'au moins un desdits fichiers de programmations utiles, et - à recopier les instructions desdits fichiers de programmation utiles, de manière à constituer des fichiers de programmation du code source simplifié, en ne recopiant pas 25 les instructions qui correspondent à des définitions de constantes ou de fonctions qui, d'après le graphe d'appel, ne sont pas utiles à la compilation. Suivant des modes particuliers de réalisation, le procédé comporte une ou plusieurs des caractéristiques suivantes, prises isolément ou suivant toutes les combinaisons techniquement possibles : 30 - le procédé comporte une étape d'interprétation des fichiers de commandes « Makefile » (MF) du code source initial pour générer une liste des commandes ; - le procédé comporte une étape de localisation des instructions utiles dans les fichiers de programmation du code source initial à partir de la liste des commandes, de manière à générer au moins une liste de fichiers de programmation utiles et une liste des directives 35 conditionnelles vérifiées ; 3025036 3 - le procédé comporte une étape de recherche des définitions inutiles consistant, à partir de la liste des commandes et de la liste des directives conditionnelles vérifiées, suite à une analyse textuelle des fichiers de programmation utiles, à générer le graphe d'appel des constantes et des fonctions définies par des directives de compilation contenues dans 5 lesdits fichiers de programmation et à marquer des noeuds dudit graphe d'appel qui correspondent à des constantes ou des fonctions qui sont utiles pour la compilation d'au moins un desdits fichiers de programmation, afin de générer un fichier contenant les constantes et des fonctions qui ne sont pas utiles à la compilation ; et, - l'étape de recopie à partir de ladite au moins une liste des fichiers de programmation 10 utiles, de la liste des directives conditionnelles vérifiées et du fichier des constantes et des fonctions qui ne sont pas utilisées ; -la génération du graphe d'appel se limite aux appels effectués à l'intérieur des directives de compilation hormis les directives conditionnelles qui ne sont jamais vérifiées ; - l'étape de recopie consiste à recopier chaque fichier de programmation indiqué dans la 15 liste des fichiers de programmation utiles et à recopier l'arborescence des répertoires contenant lesdits fichiers de programmation utiles ; - à l'étape de localisation des instructions utiles dans les fichiers de programmation du code source initial, est associée, à chaque entrée de la liste des directives conditionnelles vérifiées, une donnée indiquant si la condition est vérifiée dans toutes les occurrences 20 d'utilisation du fichier de programmation correspondant ou seulement dans certaines occurrences d'utilisation ; -au cours de l'étape de recopie d'un fichier de programmation : - les instructions correspondant à des définitions de constantes ou de fonctions définies par des directives de compilation qui ne sont pas utiles ne sont pas 25 recopiées ; - les directives conditionnelles sont modifiées de manière à ne conserver que les directives conditionnelles qui sont du type « parfois vérifiées » ; - les lignes de code non utilisées ne sont pas recopiées ; - les directives d'inclusion de fichiers de programmation d'objets standards sont 30 remplacées par des directives d'inclusion de fichiers de programmation d'objets spécifiques ; et/ou, - les fichiers de commandes « Makefile » (MF) sont recopiés, en supprimant les références aux fichiers de programmation inutilisés et aux fichiers binaires correspondants ; 35 - à l'étape de localisation des instructions utiles dans les fichiers de programmation du code source initial, est créée une liste des inclusions de fichiers de programmation 3025036 4 d'objets standards avec le nom du fichier de programmation concerné et la ligne où se fait l'inclusion, le nom du fichier de programmation d'objet standards inclus et le chemin d'accès au répertoire qui le contient ; - dans l'étape de recopie, chaque fichier de programmation est recopié dans un espace 5 mémoire d'une plateforme informatique de mise en oeuvre du procédé, qui est séparé d'un espace mémoire de ladite plateforme informatique comportant le code source initial ; - le procédé comporte, en outre, une étape de comparaison bit à bit d'un code binaire de référence résultant d'une compilation, sur une première plateforme, par un compilateur du code source initial et d'un code binaire secondaire résultant d'une compilation du code 10 source simplifié par ledit compilateur, qui est exécuté sur une seconde plateforme, physiquement différente de la première plateforme et ne contenant aucun fichier source autre que les fichiers source du code source simplifié. L'invention a également pour objet un produit programme d'ordinateur comportant des instructions propres à être exécutées par un calculateur de manière à mettre en 15 oeuvre un procédé de traitement automatique d'un code source initial, tel que défini ci- dessus. Ainsi, l'invention permet une automatisation de la reprise d'un code source existant, de manière à générer un code source simplifié, de taille réduite, qui respecte de manière certaine une partie des contraintes avioniques d'écriture, en particulier celles 20 relatives à l'absence de code mort lié à la compilation dans le code source. L'invention et ses avantages seront mieux compris à la lecture de la description détaillée qui va suivre d'un mode de réalisation particulier, donné uniquement à titre d'exemple non limitatif, cette description étant faite en se référant aux dessins annexés sur lesquels : 25 La figure 1 est une représentation schématique du système pour la mise en oeuvre du procédé de traitement selon l'invention ; La figure 2 est une représentation schématique, sous forme de blocs, du procédé de traitement selon l'invention ; La figure 3 est une représentation schématique d'une étape du procédé de la 30 figure 2 correspondant à la localisation du code utile, sur un exemple de fichiers de données ; et, La figure 4 est une représentation schématique d'une étape du procédé de la figure 2 correspondant à la recherche des définitions inutiles, sur un autre exemple de fichiers de données.The subject of the invention is a method for automatically processing an initial source code, written in a programming language of the C or C ++ type, in order to generate a simplified source code that complies with avionic writing constraints required by a certification process. the method comprising the steps of: - following a textual analysis of the programming files and command files of the initial source code, to generate: - a list of the programming files useful for compilation among said programming files; and, - a call graph of the constants and functions defined by compilation directives contained in said programming files, - to mark nodes of said call graph which correspond to constants or functions which are useful for compiling at least one of said useful programming files, and - to copy the instructions of said useful programming files, so as to constitute programming files of the simplified source code, by not copying the instructions which correspond to definitions of constants or functions that, according to the call graph, are not useful for compilation. According to particular embodiments, the method comprises one or more of the following characteristics, taken separately or in any technically possible combination: the method comprises a step of interpreting the "Makefile" (MF) command files of the source code initial to generate a list of commands; the method comprises a step of locating the instructions that are useful in the programming files of the initial source code from the list of commands, so as to generate at least one list of useful programming files and a list of the verified conditional directives; The method comprises a step of searching for useless definitions consisting, from the list of commands and the list of conditional directives checked, following a textual analysis of the useful programming files, to generate the call graph of the constants and functions defined by compilation directives contained in said programming files and to mark nodes of said call graph which correspond to constants or functions which are useful for the compilation of at least one of said programming files , to generate a file containing constants and functions that are not useful for compilation; and, the step of copying from said at least one list of useful programming files, from the list of verified conditional directives and from the file of constants and functions that are not used; -the generation of the call graph is limited to the calls made within the compilation directives except the conditional directives which are never checked; the copying step consists in copying each program file indicated in the list of useful programming files and in copying the directory tree containing the said useful programming files; in the step of locating the instructions that are useful in the programming files of the initial source code, is associated, at each entry of the list of verified conditional directives, a data item indicating whether the condition is verified in all the occurrences of use the corresponding programming file or only in certain instances of use; during the step of copying a programming file: the instructions corresponding to definitions of constants or functions defined by compilation directives which are not useful are not copied; - the conditional directives are modified so as to retain only the conditional directives which are of the "sometimes verified" type; - unused lines of code are not copied; the inclusion directives of standard object programming files are replaced by directives for inclusion of specific object programming files; and / or, - "Makefile" (MF) command files are copied, deleting references to unused programming files and corresponding binaries; In the step of locating the instructions useful in the programming files of the initial source code, a list of the inclusions of programming files 3025036 4 of standard objects is created with the name of the programming file concerned and the line where includes inclusion, the name of the included standard object programming file, and the directory path that contains it; in the copying step, each programming file is copied into a memory space of a computer platform for implementing the method, which is separated from a memory space of said computer platform comprising the initial source code; the method further comprises a step of bit-wise comparison of a reference bit code resulting from a compilation, on a first platform, by a compiler of the initial source code and a secondary binary code resulting from a compilation of the source code simplified by said compiler, which is executed on a second platform, physically different from the first platform and containing no source file other than the source files of the simplified source code. The invention also relates to a computer program product comprising instructions that can be executed by a computer so as to implement a method of automatically processing an initial source code, as defined above. Thus, the invention allows an automation of the recovery of an existing source code, so as to generate a simplified source code, of reduced size, which certainly meets a part of the avionic write constraints, in particular those relating to the absence of dead code linked to the compilation in the source code. The invention and its advantages will be better understood on reading the detailed description which follows of a particular embodiment, given solely by way of non-limiting example, this description being made with reference to the appended drawings in which: Figure 1 is a schematic representation of the system for carrying out the treatment method according to the invention; FIG. 2 is a schematic representation, in block form, of the treatment method according to the invention; Figure 3 is a schematic representation of a step of the method of Figure 2 corresponding to the location of the wanted code, on an example of data files; and, Figure 4 is a schematic representation of a step of the method of Figure 2 corresponding to the search for unnecessary definitions, on another example of data files.

35 De manière connue en soi, l'obtention d'un code binaire, représentant une séquence d'instructions exécutables par le microprocesseur d'une plateforme 3025036 5 informatique cible, passe par l'écriture d'un code source, rédigé dans un langage de programmation compréhensible par le développeur. La façon dont est rédigé le code source est appelée langage de programmation. Le code source est ensuite converti en code binaire par un programme tiers, qui est soit un compilateur, soit un interpréteur.In a manner known per se, obtaining a binary code, representing a sequence of instructions executable by the microprocessor of a target computing platform 3025036, requires the writing of a source code written in a language programming comprehensible by the developer. The way the source code is written is called the programming language. The source code is then converted to binary code by a third-party program, which is either a compiler or an interpreter.

5 Les langages C et C++ sont des exemples de langages de programmation largement utilisés. Il s'agit de langages de programmation destinés à être compilés par un compilateur adapté. Le langage C a été normalisé par l'Organisation Internationale de Normalisation (ISO). Sa dernière version a été définie en 2011 (ISO/IEC 9899:2011). Il est à noter que le 10 langage C était jusqu'à il y peu encore le seul langage, avec le langage ADA, a être autorisé dans le domaine avionique pour de développement d'applications logicielles critiques. Le langage C++ a été normalisé par l'Organisation Internationale de Normalisation (ISO). Sa première normalisation date de 1998 (ISO/ IEC 14882:1998) et a ensuite 15 évoluée jusqu'à la norme actuelle (ISO/IEC 14882:2011). Un code source écrit en C ou C++ comporte ainsi un ensemble de fichiers source, qui sont des fichiers textes, regroupant généralement des fichiers de programmation et des fichiers de commandes « Makefile ». Parmi les fichiers de programmation, on peut par exemple citer les fichiers « .c » 20 (ou « .cpp » en C++), qui correspondent à la programmation d'objets spécifiques au fichier de programmation considéré, et les fichiers « .h », qui sont appelés par les fichiers « .c » et qui définissent le comportement d'objet programmés ailleurs que le fichier de programmation considéré, soit dans un autre fichier de programmation du code source dont il est question, soit dans des bibliothèques.5 The C and C ++ languages are examples of widely used programming languages. These are programming languages intended to be compiled by a suitable compiler. The C language has been standardized by the International Organization for Standardization (ISO). Its latest version was defined in 2011 (ISO / IEC 9899: 2011). It should be noted that the C language was until recently the only language, with the ADA language, to be authorized in the avionics field for the development of critical software applications. The C ++ language has been standardized by the International Organization for Standardization (ISO). Its first standardization dates back to 1998 (ISO / IEC 14882: 1998) and has since been upgraded to the current standard (ISO / IEC 14882: 2011). A source code written in C or C ++ thus comprises a set of source files, which are text files, generally containing programming files and "Makefile" command files. Among the programming files, it is possible to cite, for example, the ".c" files 20 (or ".cpp" in C ++), which correspond to the programming of objects specific to the programming file under consideration, and the ".h" files. , which are called by the ".c" files and which define the behavior of objects programmed elsewhere than the considered programming file, either in another programming file of the source code in question, or in libraries.

25 En effet, pour faciliter l'écriture du code source, le développeur peut faire appel à des fichiers de programmation d'objets standards appartenant à une bibliothèque prédéfinie. Pour les langages C et C++, il existe de nombreuses bibliothèques possibles en plus de celles définies dans la norme ISO. Par opposition, les fichiers de programmation relatifs à des objets développés 30 spécifiquement pour l'application logicielle considérée sont dénommés fichiers de programmation d'objets spécifiques dans ce qui suit. Le fichier de commandes « Makefile » comporte une succession de commandes. Il comporte des commandes qui ne sont pas des commandes de compilation et qui permettent de préparer les fichiers de programmation à compiler, et des commandes de 35 compilation qui permettent de compiler les fichiers de programmation intermédiaire ainsi préparés. Une commande spécifie l'environnement de compilation par une pluralité de 3025036 6 paramètres dont les valeurs sont spécifiées dans la commande, tels que le chemin d'accès à un fichier de programmation d'un objet standard, etc. Le langage utilisé dans le fichier de commandes « Makefile » est un langage déclaratif 5 La génération d'un code binaire par un compilateur à partir d'un code source se déroule en trois phases principales, à savoir une phase de précompilation, une phase de compilation proprement dite et une phase d'édition de liens. Dans la phase de précompilation, un module d'interprétation (tel que le programme « Make ») du compilateur exécute les commandes du fichier de commandes 10 « Makefile » qui ne sont pas des commandes de compilation de manière à construire chaque fichier intermédiaire, en allant chercher les fichiers de programmation nécessaires. Chaque fichier de programmation appelé est alors parcouru (ou parsé) de manière à identifier, parmi les différentes lignes de code qui le composent, des directives de 15 compilation commençant par un « # », telles que des directives « #define » permettant de définir une constante, ou des directives « #include » permettant d'inclure un fichier de programmation dans le fichier de programmation courant considéré. À l'issue de cette étape de substitution textuelle, il n'y a plus de directives de compilation dans les fichiers intermédiaires.Indeed, to facilitate the writing of the source code, the developer can use standard object programming files belonging to a predefined library. For C and C ++ languages, there are many possible libraries in addition to those defined in the ISO standard. In contrast, the programming files relating to objects developed specifically for the software application under consideration are referred to as specific object programming files in the following. The "Makefile" command file contains a succession of commands. It includes commands which are not compilation commands and which make it possible to prepare the programming files to be compiled, and compilation commands which make it possible to compile the intermediate programming files thus prepared. A command specifies the compilation environment by a plurality of parameters whose values are specified in the command, such as the path to a standard object programming file, and so on. The language used in the "Makefile" command file is a declarative language 5 The generation of a binary code by a compiler from a source code takes place in three main phases, namely a precompilation phase, a compilation itself and a phase of linking. In the precompilation phase, an interpretation module (such as the "Make" program) of the compiler executes the commands of the batch file "Makefile" which are not compilation commands so as to construct each intermediate file, in fetching the necessary programming files. Each called programming file is then scanned (or parsed) so as to identify, among the various lines of code that compose it, compilation directives starting with a "#", such as "#define" directives making it possible to define a constant, or "#include" directives to include a programming file in the current program file. At the end of this textual substitution step, there are no more compilation directives in the intermediate files.

20 Lors de la phase suivante de compilation proprement dite, le module principal du compilateur compile chaque fichier intermédiaire de manière à créer un fichier binaire (.o) par fichier intermédiaire. Enfin, durant la phase d'édition de lien, le module d'édition de lien du compilateur agrège chaque fichier binaire (.o) avec les éventuels fichiers binaires de bibliothèque qui 25 sont utilisés pour les objets standards (fichiers .a et .so sous « Linux » par exemple, fichiers .d11 et .lib sous « Windows » par exemple encore). A la fin de cette phase d'édition de lien, un code binaire exécutable (.exe sous « Windows », sans extension sous « Linux ») est créé, propre à être chargé dans la mémoire d'une plateforme cible, afin que le microprocesseur de cette plateforme cible 30 l'exécute. Le procédé de traitement 100 est mise en oeuvre sur un système informatique représenté à la figure 1. Le système 10 comporte une plateforme de référence 12, une plateforme de génération 14 et une plateforme cible 16, cette dernière étant embarquée à bord d'un 35 aéronef et permettant l'exécution d'un code binaire CB correspondant à une application logicielle fournissant une fonctionnalité requise.In the next actual compilation phase, the compiler main module compiles each intermediate file so as to create a binary file (.o) per intermediate file. Finally, during the link editing phase, the compiler link editing module aggregates each binary (.o) file with any library binaries that are used for the standard objects (.a and .so files). under "Linux" for example, .d11 and .lib files under "Windows" for example). At the end of this link-editing phase, an executable binary code (.exe under "Windows", without extension under "Linux") is created, able to be loaded into the memory of a target platform, so that the microprocessor of this target platform 30 executes it. The processing method 100 is implemented on a computer system represented in FIG. 1. The system 10 comprises a reference platform 12, a generation platform 14 and a target platform 16, the latter being on board an aircraft. aircraft and allowing the execution of a binary code CB corresponding to a software application providing a required functionality.

3025036 7 Un code source initial CSI est un code source écrit en langage C ou C++. Le code source initial CSI est d'abord compilé par un compilateur 50 exécuté sur la plateforme de référence 12. Ceci conduit à la production d'un code binaire de référence CBRef.3025036 7 An initial source code CSI is a source code written in C or C ++. The initial source code CSI is first compiled by a compiler 50 executed on the reference platform 12. This leads to the production of a reference binary code CBRef.

5 Parallèlement et de manière indépendante, le code source initial CSI est traité par un module 60 propre à mettre en oeuvre le procédé de traitement 100 selon l'invention, qui sera décrit en détail ci-après, de manière à générer un code source simplifié CSS. Le code source simplifié CSS est ensuite chargé sur la plateforme de génération 14.In parallel and independently, the initial source code CSI is processed by a module 60 able to implement the processing method 100 according to the invention, which will be described in detail below, so as to generate a simplified source code CSS. The simplified CSS source code is then loaded onto the generation platform 14.

10 Le code source simplifié CSS est alors compilé par un compilateur 50 (identique à celui utilisé sur la plateforme de référence 12) exécuté sur la plateforme de génération 14. Ceci conduit à la production d'un code binaire secondaire CBS. La plateforme de génération 14 ne contient aucun fichier de programmation, hormis les fichiers source du code source simplifié CSS. Il est important que la plateforme 15 de génération 14 soit différente de la plateforme de référence 12, afin de garantir qu'aucun fichier du code source initial CSI ne soit utilisé lors de la compilation du code source simplifié CSS. Le code binaire secondaire CBS est recopié sur la plateforme cible 16. Cette copie constitue le code binaire CB exécuté.The simplified source code CSS is then compiled by a compiler 50 (identical to that used on the reference platform 12) executed on the generation platform 14. This leads to the production of a secondary CBS binary code. The generation platform 14 does not contain any programming files, except the source files of the simplified CSS source code. It is important that the generation platform 14 is different from the reference platform 12, to ensure that no initial CSI source code file is used when compiling the simplified CSS source code. The secondary CBS binary code is copied onto the target platform 16. This copy constitutes the binary code CB executed.

20 La comparaison bit à bit du code binaire de référence CBRef et du code binaire secondaire CBS, réalisée par un module de comparaison 70 exécuté sur la plateforme de référence 12, permet de vérifier que ces deux codes binaires sont strictement identiques. Lorsque cette comparaison est positive et que les deux codes binaires sont effectivement identiques, les crédits d'expérience déjà acquis sur le code binaire lors de la 25 certification de l'application logicielle sont réutilisées. Cette certification, représentée schématiquement sur la figure 1 par le module 80, est alors essentiellement limitée aux étapes de certification du code source, qui sont appliquées au code source simplifié CSS. De plus, puisque l'équivalence entre le code source initial CSI et le code source simplifié CSS est garantie par l'identité des deux codes binaires obtenus, le code source 30 simplifié CSS est considéré comme le nouveau code source de l'application logicielle à certifier. De ce fait, c'est le code source simplifié CSS qui sera analysé en vue de la certification de l'application logicielle, notamment vis-à-vis des contraintes avioniques d'écriture. Ceci permet de sortir le module 60 de la chaîne de génération du code binaire CB. Par conséquent, le procédé de traitement automatique 100, qui n'apparaît pas dans 35 la chaîne de génération du code binaire n'a pas à être lui-même certifié.The bit-by-bit comparison of the reference binary code CBRef and the secondary binary code CBS, performed by a comparison module 70 executed on the reference platform 12, makes it possible to verify that these two binary codes are strictly identical. When this comparison is positive and the two binary codes are indeed identical, the experience credits already acquired on the binary code during the certification of the software application are reused. This certification, shown diagrammatically in FIG. 1 by the module 80, is then essentially limited to the certification stages of the source code, which are applied to the simplified source code CSS. In addition, since the equivalence between the initial CSI source code and the CSS simplified source code is guaranteed by the identity of the two binary codes obtained, the simplified source code CSS is considered to be the new source code of the software application. certify. As a result, it is the simplified CSS source code that will be analyzed in view of the certification of the software application, in particular with respect to the avionic write constraints. This makes it possible to output the module 60 from the generation chain of the binary code CB. Therefore, the automatic processing method 100, which does not appear in the binary code generation chain does not have to be itself certified.

3025036 8 Le procédé de traitement 100 est représenté à la figure 2. Il permet de supprimer automatiquement du code source initial CSI toutes les parties de ce code qui ne sont pas utiles pour la génération du code binaire secondaire CBS, c'est-à-dire tout le code mort lié à la compilation.The processing method 100 is shown in FIG. 2. It makes it possible to automatically delete from the initial CSI source code all the parts of this code which are not useful for the generation of the CBS secondary binary code, that is to say say all the dead code related to the compilation.

5 Pour cela, le procédé de traitement 100 supprime tous les fichiers de programmation ou parties de fichier de programmation du code source initial CSI qui sont inutiles au sens où ils ne seraient pas utilisés lors d'une compilation de ce code source initial CSI par le compilateur 50. Sont également supprimées toutes les directives de compilation inutiles, c'est-à-dire qui ne seraient pas utilisées ou qui seraient rendues 10 inutiles lors d'une compilation de ce code source initial CSI par le compilateur 50. Dans une première étape 110, les fichiers de commandes « Makefile » MF du code source initial CSI sont interprétés de manière à générer une liste des commandes LC. Une telle liste regroupe les commandes permettant la compilation.For this, the processing method 100 deletes all the programming files or parts of the programming file of the initial CSI source code which are useless in the sense that they would not be used during a compilation of this initial CSI source code by the compiler 50. Also deleted are all unnecessary compiler directives, that is, those which would not be used or which would be rendered useless when a compilation of this initial CSI source code by the compiler 50. In a first step 110, the MF Makefile command files of the initial CSI source code are interpreted to generate a list of LC commands. Such a list groups the commands allowing the compilation.

15 L'interprétation des fichiers de commandes « Makefile » MF est réalisée par n'importe lequel des logiciels « make » connus de l'homme du métier. A l'étape 120, les instructions utiles sont localisées. Pour ce faire, chaque commande de la liste des commandes LC est interprétée. Si cette commande n'est pas une commande de compilation, elle est exécutée.The interpretation of the "Makefile" MF command files is carried out by any of the "make" software known to those skilled in the art. In step 120, the useful instructions are localized. To do this, each command in the list of LC commands is interpreted. If this command is not a compilation command, it is executed.

20 Si cette commande est une commande de compilation, chaque option définissant l'environnement de compilation est mémorisée, et les fichiers de programmation à compiler sont analysés. L'analyse syntaxique des fichiers de programmation s'effectue selon l'état de l'art. Plus précisément, à partir de la liste des commandes LC, les fichiers de 25 programmation FS des objets spécifiques ou standards du code source initial CSI, en particulier les fichiers de programmation ayant comme extension .c, .cpp et .h , sont parcourus et interprétés afin de générer un premier fichier d'information F1 et un second fichier d'information F2. Le premier fichier d'information F1 contient : 30 Une liste L1 des noms des fichiers de programmation FS utilisés, avec le chemin d'accès aux répertoires qui les contiennent ; et, Une liste L2 des directives d'inclusion d'un fichier de programmation de bibliothèque (qui correspondent à des directives de compilation qui, dans un fichier de programmation FS, débutent syntaxiquement par « # include»), avec 35 le nom et la ligne du fichier de programmation FS où se fait l'inclusion, le nom 3025036 9 du fichier de programmation de bibliothèque inclus et le chemin d'accès au répertoire qui le contient. Le second fichier d'information F2 contient : Une liste L3 des directives conditionnelles (qui correspondent à des directives 5 de compilation, qui dans un fichier de programmation FS sont de la forme #ifdef, #if, #elif, #else) qui sont vérifiées, c'est-à-dire les directives de compilation pour lesquelles le bloc d'instructions qui suit est utilisé lors de la compilation; cette liste est constituée, pour chaque directive conditionnelle vérifiée, du nom et de la ligne du fichier de programmation FS où se trouve 10 cette directive de compilation et du chemin d'accès au répertoire qui contient ce fichier de programmation FS ; et, Pour chaque directive conditionnelle vérifiée, une donnée indiquant si la condition est vérifiée dans toutes les occurrences d'utilisation du fichier de programmation FS, ou seulement dans certaines occurrences d'utilisation.If this command is a compilation command, each option defining the compilation environment is stored, and the programming files to be compiled are analyzed. The syntax analysis of the programming files is done according to the state of the art. More precisely, from the list of LC commands, the FS programming files of the specific or standard objects of the initial CSI source code, in particular the programming files having the extension .c, .cpp and .h, are traversed and interpreted to generate a first information file F1 and a second information file F2. The first information file F1 contains: A list L1 of the names of the FS programming files used, with the path to the directories that contain them; and, A list L2 of the inclusion instructions of a library programming file (which correspond to compilation directives which, in an FS programming file, begin syntactically with "#include"), with the name and line of the FS programming file where the inclusion is made, the name 3025036 9 of the included library programming file and the directory path that contains it. The second information file F2 contains: An L3 list of conditional directives (which correspond to compilation directives, which in an FS programming file are of the form #ifdef, #if, #elif, #else) which are checked, that is, the compilation directives for which the following block of instructions is used during compilation; this list consists, for each verified conditional directive, of the name and the line of the FS programming file where this compilation directive and the directory path containing this FS programming file are located; and, for each verified conditional directive, a data item indicating whether the condition is verified in all occurrences of use of the FS programming file, or only in certain instances of use.

15 Il est à noter que l'analyse des fichiers de programmation FS à compiler se fait en traitant récursivement les inclusions de fichier. La figure 3 représente schématiquement un exemple de mise en oeuvre de cette étape 120. A l'étape 130, les définitions inutiles sont recherchées.It should be noted that the analysis of the FS programming files to be compiled is done by recursively processing the file inclusions. FIG. 3 diagrammatically represents an exemplary implementation of this step 120. In step 130, useless definitions are sought.

20 Pour ce faire, à partir de la liste des commandes LC et de la liste des directives conditionnelles vérifiées L3 du second fichier F2, les fichiers de programmation FS sont à nouveau parcourus et interprétés afin de générer un troisième fichier F3 contenant les constantes et les fonctions (« macros ») définies par des directives de compilation, mais qui ne sont pas utilisées.To do this, from the list of LC commands and from the L3 checked list of conditional directives of the second file F2, the programming files FS are again traversed and interpreted in order to generate a third file F3 containing the constants and the parameters. functions ("macros") defined by compilation directives, but not used.

25 Pour effectuer cette étape, comme dans l'étape 120, la liste des commandes LC est parcourue, mais ici l'analyse des fichiers de programmation FS diffère. En effet, cette analyse est maintenant réalisée en traitant récursivement les inclusions de fichiers de programmation FS, et en tenant compte de la liste des directives conditionnelles vérifiées L3 du second fichier F2, de manière à ignorer les lignes de code 30 des fichiers de programmation FS qui ne sont jamais utilisées. Lors de cette analyse, un graphe d'appel GA des constantes et des fonctions définies par les directives de compilation est construit, en se limitant aux appels effectués à l'intérieur des directives de compilation et en ne tenant pas compte des directives conditionnelles qui ne sont jamais vérifiées.To perform this step, as in step 120, the list of LC commands is scanned, but here the analysis of the FS programming files differs. Indeed, this analysis is now carried out by recursively processing the inclusions of FS programming files, and taking into account the list of verified conditional directives L3 of the second file F2, so as to ignore the lines of code 30 of the FS programming files. which are never used. In this analysis, a GA call graph of the constants and functions defined by the compilation directives is constructed, limited to calls made within the compilation directives and ignoring any conditional directives that do not are never verified.

3025036 10 L'analyse permet également de marquer les noeuds du graphe d'appel GA qui correspondent à des constantes ou des fonctions qui sont utilisées dans au moins une ligne de code ou au moins une directive conditionnelle du type « parfois vérifiée ». A l'issue de l'analyse de toutes les commandes de la liste LC, le graphe d'appel 5 GA est parcouru pour marquer tous les noeuds parents d'une constante ou d'une fonction utilisée dans au moins une ligne de code ou au moins une directive conditionnelle du type « parfois vérifiée ». Le graphe d'appel GA sera avantageusement parcouru selon l'ordre topologique des noeuds du graphe. Le troisième fichier F3 contenant les définitions inutiles est alors généré à partir de 10 tous les noeuds du graphe d'appel GA qui ne sont pas marqués. La figure 4 représente schématiquement un exemple de mise en oeuvre de cette étape 130, avec notamment un graphe d'appel GA. Sur cette figure, les noeuds surlignés en gras et portant un indice « M » sont les noeuds marqués. L'analyse syntaxique des fichiers de programmation FS et la génération du graphe 15 d'appel GA s'effectuent en mettant en oeuvre des algorithmes connus de l'homme du métier. Enfin, à l'étape 140, le code utile des fichiers source du code CSI est recopié pour générer le fichier de programmation simplifié CSS. Plus précisément, à partir des résultats des deux étapes 120 et 130, les fichiers de 20 programmation FS sont à nouveau parcourus, afin de générer l'ensemble des fichiers source du code source simplifié CSS. Pour effectuer cette étape 140, chaque fichier de programmation FS apparaissant dans la liste L1 des fichiers utilisés du premier fichier F1 est analysé. Cette analyse est réalisée sans traiter les inclusions de fichier.The analysis also makes it possible to mark the nodes of the call graph GA which correspond to constants or functions which are used in at least one line of code or at least one conditional directive of the "sometimes checked" type. After the analysis of all the commands of the list LC, the call graph 5 GA is traveled to mark all the parent nodes of a constant or a function used in at least one line of code or at least one conditional directive of the "sometimes verified" type. The call graph GA will advantageously be traversed according to the topological order of the nodes of the graph. The third file F3 containing the useless definitions is then generated from all the nodes of the call graph GA which are not marked. FIG. 4 diagrammatically represents an exemplary implementation of this step 130, in particular with a call graph GA. In this figure, the nodes highlighted in bold and bearing an index "M" are the marked nodes. The syntax analysis of the FS programming files and the generation of the call graph GA are carried out by implementing algorithms known to those skilled in the art. Finally, in step 140, the useful code of the source files of the CSI code is copied to generate the simplified programming file CSS. More precisely, from the results of the two steps 120 and 130, the FS programming files are again traversed, in order to generate the set of source files of the simplified CSS source code. To perform this step 140, each programming file FS appearing in the list L1 of the used files of the first file F1 is analyzed. This analysis is performed without processing the file inclusions.

25 Durant cette analyse, chaque fichier de programmation FS (y compris les fichiers du programmation standards) est recopié dans un espace mémoire de la plateforme de référence 12 séparé de l'espace mémoire du code source initial CSI, en y recopiant également l'arborescence des répertoires. Au cours de cette recopie, les lignes de code non utilisées d'un fichier de 30 programmation FS ne sont pas recopiées. De même les définitions des constantes ou des fonctions (« macros ») non utilisées ne sont pas recopiées. De plus, les directives conditionnelles sont modifiées de manière à ne conserver que les directives conditionnelles qui sont parfois vérifiées. Enfin, les directives d'inclusion de fichiers de programmation d'objets standards 35 (directives de compilation avec des chevrons du type « #include <FS> ») sont remplacées par des directives d'inclusion de fichiers de programmation d'objets spécifiques (directives 3025036 11 de compilation avec des guillemets du type « #include "FS" », en précisant le répertoire du fichier de programmation inclus). Finalement, les fichiers de commandes « Makefile » FM sont recopiés. Lors de cette recopie, les références à des fichiers de programmation FS non utilisés (c'est à dire 5 n'apparaissant pas dans la liste L1 du premier fichier F1) sont supprimées, de même que les références aux fichiers compilés (fichiers .o) de ces fichiers de programmation FS non utilisés. L'ensemble de ces fichiers recopiés constituent le code source simplifié CSS. De manière générale, le procédé selon l'invention permet un traitement 10 automatique d'un code source initial, écrit en langage C ou en langage C++, de manière à obtenir un code source simplifié, qui présente une taille réduite par rapport à celle du code source initial et dans lequel a été supprimée la totalité du code mort lié à la compilation présent dans le code source initial, c'est-à-dire le code qui n'est pas utilisé lors de la compilation.During this analysis, each FS programming file (including the standard programming files) is copied into a memory space of the reference platform 12 separated from the memory space of the initial CSI source code, also copying the tree structure therein. directories. During this copying, the unused code lines of an FS programming file are not copied. Similarly the definitions of constants or functions ("macros") not used are not copied. In addition, conditional directives are modified to retain only conditional directives that are sometimes verified. Finally, the directives for inclusion of standard object programming files 35 (compilation directives with brackets of the type "#include <FS>") are replaced by directives for inclusion of specific object programming files ( compile directives 3025036 11 with quotation marks of the "#include" FS "" type, specifying the directory of the included programming file). Finally, the "Makefile" FM command files are copied. During this copying, references to unused FS programming files (ie 5 not appearing in the L1 list of the first F1 file) are deleted, as are the references to the compiled files (.o files ) of these unused FS programming files. All of these copied files constitute the simplified CSS source code. In general, the method according to the invention allows automatic processing of an initial source code, written in C or in C ++, so as to obtain a simplified source code, which has a reduced size compared to that of the initial source code and in which was removed all of the dead code linked to the compilation present in the initial source code, that is to say the code which is not used during compilation.

15 Ce procédé de traitement automatique est effectué sans impact sur le code binaire généré à l'issue de la compilation, c'est-à-dire que le code binaire résultant de la compilation du code source initial et le code binaire résultant de la compilation du code source simplifié sont identiques entre eux. L'étape de comparaison entre les deux codes binaires étant avantageusement effectuée systématiquement pour garantir cette identité.This automatic processing method is carried out without impacting on the binary code generated at the end of the compilation, that is to say that the binary code resulting from the compilation of the initial source code and the binary code resulting from the compilation simplified source code are identical to each other. The comparison step between the two binary codes is advantageously carried out systematically to guarantee this identity.

20 La propriété de conservation du code binaire permet de conserver (c'est-dire de réutiliser) les crédits d'expérience (tels que par exemple les constats de bon fonctionnement durant une longue période d'exécution du code binaire, etc.) associés aux étapes de certification du code binaire dans le processus de certification, sans avoir à refaire les tests et vérifications correspondants.The retention property of the binary code makes it possible to keep (ie to reuse) the experience credits (such as, for example, statements of good functioning during a long period of execution of the binary code, etc.) associated with it. to the certification steps of the binary code in the certification process, without having to redo the corresponding tests and verifications.

25 De plus, en ce qui concerne les étapes de certification du code source dans le processus de certification et/ou de maintenance du code source, les tests et vérifications correspondants sont simplifiés du fait de la taille réduite du code source simplifié.Moreover, with regard to the steps of certification of the source code in the process of certification and / or maintenance of the source code, the corresponding tests and verifications are simplified because of the reduced size of the simplified source code.

Claims

CLAIMS- A method (100) of automatic processing of an initial source code (CSI), written in a programming language of the C or C ++ type, to generate a simplified source code (CSS) complying with avionic writing constraints required by a certification process, the method comprising the steps of: - following a textual analysis of the programming files and the command files of the initial source code, to generate: - a list (L1) of the programming files useful for compilation among said programming files; and, a call graph (GA) constants and functions defined by compilation directives contained in said programming files, - mark nodes of said call graph which correspond to constants or functions which are useful for compiling at least one of said useful programming files, and - copying the instructions of said useful programming files, so as to constitute programming files of the simplified source code, by not copying instructions that correspond to definitions of constants or functions that, according to the call graph, are not useful for compilation.

2. A method according to claim 1, comprising: a step (110) of interpreting the "Makefile" (MF) command files of the initial source code (CSI) to generate a list of commands (LC); a step (120) of locating the instructions that are useful in the initial source code (CSI) programming files from the list of commands (LC), so as to generate at least one list (L1, L2) of files of useful programming and a list (L3) of verified conditional guidelines; a step (130) of searching for useless definitions consisting, from the list of commands (LC) and list (L3) of the conditional directives checked, following a textual analysis of the useful programming files, to generate the graph of calling (GA) constants and functions defined by compilation directives contained in said programming files and to mark nodes of said call graph which correspond to constants or functions which are useful for the compilation of least one of said programming files, to generate a file (F3) containing the constants and functions that are not useful for compilation; and, 3025036 13 - said step (140) of copying from said at least one list (L1, L2) of the useful programming files, the list (L3) of the verified conditional directives and the file (F3) of the constants and functions that are not used. 5

3. The method of claim 2, wherein the generation of the call graph (GA) is limited to the calls made within the compilation directives except the conditional directives which are never checked.

4. The method according to claim 3, wherein the step of copying consists in copying each programming file indicated in the list of useful programming files and in copying the directory tree containing said useful programming files.

5. A method according to any one of claims 2 to 4, wherein at the step of locating useful instructions in the initial source code (CSI) programming files is associated with each entry of the list. (L3) conditional directives verified, a data item indicating whether the condition is verified in all occurrences of use of the corresponding programming file or only in certain occurrences of use. 20

6. A method according to claim 5, wherein, during the step of copying a programming file: the instructions corresponding to definitions of constants or functions defined by compilation directives which are not useful are not copied 25 - the conditional directives are modified so as to retain only the conditional directives which are of the "sometimes verified" type; - unused lines of code are not copied; the inclusion directives of standard object programming files are replaced by directives for inclusion of specific object programming files; and / or, - "Makefile" (MF) command files are copied, deleting references to the unused programming files and the corresponding binaries. 3025036 14

7. A method according to any one of claims 2 to 6, wherein, in the step of locating useful instructions in the initial source code (CSI) programming files, a list (L2) of the inclusions of standard object programming files with the name of the relevant program file and the row where the inclusion is made, the name of the included standard object programming file and the directory path that contains it.

8. A method according to any one of claims 2 to 6, wherein in the step of copying, each programming file is copied into a memory space of a platform (12) computer implementation of the method , which is separated from a memory space of said computer platform (12) comprising the initial source code (CSI).

9. A method according to any one of the preceding claims, further comprising a step of bit-wise comparison of a reference binary code (CBRef) resulting from a compilation, on a first platform (12), by a compiler (50) of the initial source code (CSI) and a secondary binary code (CBS) resulting from a compilation of the simplified source code (CSS) by said compiler (50), which is executed on a second platform ( 14), physically different from the first platform (12) and 20 containing no source file other than the source files of the simplified source code (CSS) ,.

A computer program product comprising instructions to be executed by a computer so as to implement an automatic source code processing method according to any one of claims 1 to 9.