EP2507702A1

EP2507702A1 - Software application fine-tuning method, system, and corresponding computer program product

Info

Publication number: EP2507702A1
Application number: EP10785435A
Authority: EP
Inventors: Gilbert Cabillic; Jean-Philippe Lesot
Original assignee: Flexycore SAS
Current assignee: Flexycore SAS
Priority date: 2009-12-03
Filing date: 2010-12-03
Publication date: 2012-10-10
Also published as: US20120304154A1; WO2011067398A1; FR2953612A1; US8776024B2

Abstract

The invention relates to a method for fine-tuning a software application that is written in a source programming language and is executable on a target platform. According to the invention, such a method includes: a stage of compiling said software application that is written in said source language and supplies the code of an intermediate software application that is written in an intermediate language, said stage comprising a step of inserting, into the code of said intermediate software application, a specific construction for intercepting events by means of complementary instructions, and a step of formatting the intermediate code of said software application such that the matching of a line of source code with a line of intermediate code is the most frequent possible matching; a stage of compiling the code from said intermediate software application into an executable software application; and a stage for fine-tuning said software application, said stage including at least one step of converting at least one piece of fine-tuning information between a program for fine-tuning said intermediate language and a program for fine-tuning said source language.

Description

A software application debugging method, system and corresponding computer program product.

1 FIELD OF THE INVENTION

The present invention relates to the field of development of programs or software applications.

The present invention relates more particularly to the development of programs or software applications in heterogeneous environments.

A computer program, or a software application is generally composed of a set of binary or intermediate instructions said executable. These executable instructions are usually derived from a compilation of a program written in a source language. Thus, to be able to create a software application, a developer writes a source program written in a specific programming language. This source program is then compiled to form an executable program. During this compilation, the instructions written in source language are transformed into a binary program which is itself executed on a hardware platform such as a computer, a communication terminal.

To compile a program written in a source language for a certain target (processor, platform, ...), there are four general methods: to have a complete compiler, that is to say including a part that takes care of to recognize the source language, and another which is responsible for creating the executable program for the chosen target. This is the general case; have a compiler from the source language to an intermediate code, and provide a virtual machine of this intermediate code on the chosen target.

This is the general case for the Java ™ language for example;

provide, to a compiler that already exists for the chosen target, an add-on to recognize the source language;

have a compiler that transforms a program written in a source language into a program written in an intermediate language, and implement an existing intermediate language compiler for the chosen target.

Thus, apart from the general case above, there are more complex procedures in which the source program undergoes a succession of compilations: the source program is for example compiled a first time in an intermediate language in order to provide an intermediate program then the intermediate program is compiled into a binary format to deliver the final binary application. Such a situation arises when the developer who writes the source program wants the final software application to run on a particular hardware platform or the final software application has a higher performance than the one that would be delivered. compiling the source program with a traditional compiler. Successive compilations are also used when the developer does not wish to change the programming platform despite the fact that the platform on which the final software application is to run does not have a compiler to compile a program written in a given source language.

2 SOLUTIONS OF THE PRIOR ART

Thus, when a developer wishes to create a software application that will undergo a succession of compilation (that is to say at least two) prior to the completion of a binary computer program, there is the problem of setting or point (also called "debugging") of the application.

In relation to FIG. 1, the general principle of the successive compilation of an application is presented. A source software application (101) is written by an application developer. This source program includes computer program instructions written in a source programming language. The source program (101) undergoes a first compilation phase by a compiler (10) which results in its transformation into an intermediate program (102). This intermediate program (102) is written in an intermediate programming language. For example, the program source can be written in Java ™ language while the intermediate program resulting from the first compilation phase can be written in C ++ or C language.

In the case where a suitable compiler exists, the intermediate program (102) also undergoes a compilation phase, using a compiler (20) during which it is transformed into an executable program (103). In other cases, several phases of successive compilations can be performed in different intermediate programming languages to provide an executable program that meets the requirements of the target platform on which it must be executed.

During such successive compilation operations, the inventors have found that it is extremely complicated to perform a development of the software application. Indeed, conventionally, a software application contains multiple anomalies (also called "bug"). These anomalies are usually identified and corrected during a unit testing phase and then during a so-called recipe phase.

To make these corrections, the developers are helped by a debugging program, also called "debugger". A debugger is a program that, in connection with the compiler, allows to control the execution of the software application written in the source language. The source software application to be debugged is run through the debugger and runs normally. The debugger then offers the developer the ability to control the execution of the software application, allowing it by various means to stop, pause the execution of the software application or to observe for example the content of the software application. different variables in memory. The execution state can then be observed to, for example, determine a cause of a failure.

Debuggers work properly when a single compile step is required to transform a software application written in a source language into an executable software application. In relation to FIG. 2, the general principle of implementation of a debugger (11) is presented. The source program (101) is compiled, according to a specific method (DB), by the compiler (10). This specific method is usually called "Debug Mode". The developer can then control the execution of the program compiled by the debugger (1 1) by viewing, through a debugger debug interface, the various aspects of the program. To do this, the debugger uses the relationships between the instructions of the source program and the instructions of the compiled program that the compiler (10) generated according to the specific method (DB).

A problem is posed when debugging applications that undergo several (at least two) successive compilations in at least one intermediate language. Currently, when a program written in an A language is compiled into a program written in a B language, then a program written in the B language compiled in turn into a binary form, the debugging is done using a debugger dedicated to language B, and using the intermediate program written in language B. For this the intermediate code must be humanly readable to facilitate this task, which is far from the case. As a general rule, compilers do not provide compiled programs intended to be read and understood by humans. Compiled programs include many optimizations that make them unreadable for most developers.

In addition, having to use an intermediate language debugger has at least the following two problems:

The program developer in the source language must also know the intermediate language to debug the binary code with the intermediate language debugger. It must then report all the corrections made to the intermediate program in the program written in source language, and for that purpose understand how the compiler from the source language to the intermediate language works. This greatly reduces the appeal of such a solution. The compiler of the source language to the intermediate language must as much as possible make the generation of its code in intermediate language (same name, same construction, ...) as humanly readable. This is not always possible because the source language and the intermediate language can be too semantically distant from each other to ensure this property. In any case, these constraints influence too much the design of the compiler, and the optimizations it can do.

Thus, the problems generated by multiple compilations make it very difficult to use debuggers when developing software applications requiring multiple intermediate compilations.

3 SUMMARY OF THE INVENTION

The invention provides a novel and inventive solution to these problems of the prior art.

Indeed the invention proposes a method for developing a software application written in a source and executable programming language on a target platform,

According to the invention, such a method comprises:

a compilation phase of said software application written in said source language delivering the code of an intermediate software application written in an intermediate language, said compilation phase furthermore comprising:

a step of insertion within the code of said intermediate software application, of a specific construction of interception of events occurring during the execution of a debugging program of said intermediate language, by means of complementary instructions;

a step of formatting the intermediate code of said software application so that the correspondence between a line of the source code and a line of the intermediate code is as frequent as possible; a phase of compiling the code of said intermediate software application into a software application executable on said target platform;

a development phase of said software application comprising at least one step of transforming at least one debug information between a debugging program of said intermediate language and a debugging program of said source language.

Thus, according to this aspect, the invention makes it possible to control a future process for debugging the intermediate program by means of instructions which are intended for the debugger of the intermediate program. These additional instructions, which are not necessary, as such, in the process of compiling the program written in the intermediate programming language towards the target platform, make it possible to check the execution of the intermediate program when it is itself being debugged. These additional instructions also make it possible to transmit to a debugger of the source program the information necessary for debugging the source program.

Thus, the invention is based on a completely new and inventive approach to the debugging of software applications whose source language undergoes successive compilations. The invention makes it possible on the one hand not to have to learn the intermediate language or languages in which the source program is successively compiled. On the other hand, the invention makes it possible not to debug the application in an intermediate language to reintegrate subsequently the corrections made in the program written in source language.

According to a particular embodiment of the invention, said compilation phase further comprises a step of generating at least one specific representation of said software application within an intermediate data structure and said debugging phase sets implement said intermediate data structure. Thus, the invention makes it possible to construct a data structure that can be used for debugging by indicating, in this intermediate data structure, the information that could be useful to the gateway debugger to improve or facilitate the tuning from the source language debugger.

According to a particular characteristic of the invention, said development phase comprises:

a step of receiving, from said debugging program of said source language, a request to obtain at least one piece of data that does not depend on the execution of said software application, called static data;

a step of searching for said at least one static data in said intermediate data structure;

a step of transmitting said at least one static data to said debugging program of said source language.

Thus, the gateway debugger that implements the method of the invention can manage the static requests that it intercepts from the debugging program of the source language.

According to a particular embodiment of the invention, said development phase comprises:

a step of receiving, from said debugging program of said source language, a request for obtaining at least one data item dependent on the execution of said software application, called dynamic data;

a step of transforming said request for obtaining at least one dynamic data item into a request for obtaining at least one dynamic data item for said debugging program of said intermediate language, delivering a transformed obtaining request request; a step of transmitting said transformed obtaining request to said debugging program of said intermediate language; a step of executing said obtaining request transformed by said debugging program of said intermediate language delivering said at least one dynamic datum;

a step of transmitting said at least one dynamic data item delivered to said debugging program of said source language.

Thus, the gateway debugger that implements the method of the invention can manage the dynamic requests that it intercepts from the debugging program of the source language and ask the debugging program of the intermediate language to execute these queries on behalf of the source language debugger program.

a step of receiving, from said debugging program of said source language, an execution control request of said software application;

a step of transforming said received execution control request into an equivalent execution control request for said debugging program of said intermediate language, delivering a transformed execution control request;

a step of transmitting said transformed execution control request of said debugging program of said intermediate language.

Thus, the gateway debugger that implements the method of the invention can manage the execution flow control requests that it intercepts from the source language debugging program and request the debugger program to intermediate language to execute these queries on behalf of the source language debugger.

a reception step, from said debugging program said source language, an event management request of said software application;

a step of transforming said received event management request into a control request on the execution of at least one complementary instruction for said debugging program of said intermediate language, delivering a transformed management request;

a step of transmitting said transformed management request to said debugging program of said intermediate language.

Thus, the gateway debugger that implements the method of the invention can handle the event management requests it intercepts from the source language debugger and request the intermediate language debugger program. execute these queries on behalf of the source language debugger.

According to another aspect, the invention also relates to a method of compiling a program written in a source programming language to an intermediate program written in an intermediate programming language, said intermediate program being itself intended to be compiled at its destination. a target platform.

According to the invention, such a compilation method is characterized in that it comprises a step of insertion, within said intermediate program, of at least one complementary control instruction of said intermediate program by a gateway debugger.

Thus, the invention makes it possible to use the program written in the intermediate language, at the end of the compilation according to the compilation method of the invention, by a program of debugging in the intermediate language while allowing the controlling it by a gateway debugging program providing an interface between the source language debugger and the intermediate language debugger. In another aspect, the invention relates to a system for debugging a software application written in a source programming language and executable on a target platform. According to the invention, such a system comprises: means for compiling said software application written in said source language delivering the code of an intermediate software application written in an intermediate language, said compilation means comprising:

means for inserting into the code of said intermediate software application a specific event interception construct occurring during the execution of a debugging program of said intermediate language by means of complementary instructions;

means for formatting the intermediate code of said software application so that the correspondence between a line of the source code and a line of the intermediate code is as frequent as possible;

code compilation means of said intermediate software application into a software application executable on said target platform;

means for debugging said software application comprising at least means for transforming at least one debug information between a debugging program of said intermediate language and a program for debugging said source language.

The invention also relates to a computer program comprising instructions for implementing the debugging method previously described when this program is executed by a processor, or a computer program product downloadable from a communication network and / or stored on a computer-readable and / or executable medium by a processor, including program code instructions for carrying out the debugging method described above, when executed by a processor.

4 LIST OF FIGURES

Other characteristics and advantages of the invention will appear more clearly on reading the following description of a preferred embodiment, given as a simple illustrative and nonlimiting example, and the appended drawings, among which:

Figure 1, already commented, presents the general principle of the successive compilation of a software application;

Figure 2, also already commented, illustrates the operation of a debugger program of a software application; Figure 3 describes the principle of the invention;

DETAILED DESCRIPTION OF THE INVENTION

5.1 Recall of the principle of invention

The invention makes it possible to debug the software application directly using the debugger program of the source language. It is therefore not necessary when the invention is implemented to debug the software application using the debugger of the intermediate language. The invention thus makes it possible to save in time of development and facilitates the task of development of the developer. Indeed, on the one hand the developer does not need to know the intermediate programming language, and on the other hand he does not need to report, in the program written in the source programming language, the modifications made in the intermediate program written in the intermediate programming language.

The debugging method is implemented, in at least one embodiment of the invention, using a gateway debugger, used to dialogue between the source language debugger and the intermediate language debugger. . More specifically, the gateway debugger is a program or software that defines an interface between the source language debugger and the destination language debugger. The gateway debugger can also interact directly with the destination language compiler to evaluate, on behalf of the debugger of the source language or other component, an expression, for example a dynamic expression, which is transmitted to it and when this expression has been evaluated by the compiler of the destination language, retransform the result of this expression into an understandable result for the debugger of the source language or other component.

Those skilled in the art will understand, on reading the present application, that the principle of the invention can be applied successively. Thus, by implementing the invention, it is possible to develop a software application written in a source language even if several stages of compilation in successive intermediate languages would be necessary before a final compilation to the platform target.

The general principle of the invention rests, in part, on the insertion, during the compilation of the source language into the intermediate language, of additional instructions intended to allow the control of the debugging program of the intermediate language and to transmit the information needed for debugging to the source language debugger.

The invention proposes, as it were, an interface between the various debugging programs, which interface is made operational by means of, in particular, complementary instructions which are inserted during the compilation of the source language into the intermediate language.

The principle of the invention will be better understood with reference to FIG. 3, in which the general principle of the invention is presented. The numerical references common to Figures 1 and 2 have been retained for clarity.

A software application 1 0 1 is written in a source programming language A. It has, for the programming language A, a compiler 10 and a debugging program 11. This set is called the development environment of the program. language A.

There is also a programming language B, which can be used to write software applications natively. We have for this language of programming B, a compiler 20 and a debugging program 21. When one has a program written using the programming language B. This set is called the B language development environment. According to the invention, the programming language B is called the intermediate programming language, in the sense that it serves as an intermediary between the software application written in the source programming language A and the binary version of the software application for the target platform.

According to the invention, there is also:

a gateway compiler 30 of the source language A to the language B; a gateway debugging program 31 providing an interface between the debugging program 11 of the language A and the tuning program 21 of the language B.

According to the invention, this gateway debugging program 31 makes it possible to control, for the debugging program 11 of the language A, the execution of an executable which would have been compiled using the compiler 10, whereas this is not the case. According to the invention, this gateway debugging program 31 makes it possible to simulate, for the debugging program 21 of the B language, the presence of a debugging data reception interface (which could for example be used through a graphical interface).

To achieve tuning according to the invention, the gateway debugging program 31 receives from the compiler 30 of the source language A to the language B, compilation data. This compilation data are derived for a part from additional instructions which are inserted by the compiler 30 of the source language A to the language B, during the compilation of the software application. This compilation data is derived for another part from data in the compiler's memory or from their file writing in a particular data structure, allowing for example to respond to static and dynamic queries that can be issued by the scheduling program. at the point of the source language (language A). Thus, during the actual development phase, the gateway debugging program 31 uses this compilation data to intercept and translate incoming requests from the debugger program 11 of the A language (using a protocol of communication with this debugging program 11 of the language A). Incoming queries are of the conventional type and may consist of static, dynamic or control flow type queries ("control flow").

The gateway debugging program 31 transforms these incoming requests so that they are understandable by the B-language development environment. More particularly, depending on the type of the incoming requests coming from the debugger program 1 1 of the language A , the gateway debugging program 31 can:

query directly, or indirectly via a suitable file, the gateway compiler 30 from the language A to the language B to obtain a response;

interrogate the B language development program 21 to evaluate a particular expression;

obtain control flow information from B-language debugger program 21 and transform the latter to be understandable for the A-language debugger program.

Thus, using a gateway debugging program 31 and a gateway compiler 30 to debug the source software application written in A language provides several advantages:

it is not necessary to provide a compiler of the language A to the language B which must keep as much as possible the constructions of the language A, or the different names of the program written in language A. By releasing these constraints, the compiler has more latitude to compile and optimize the program;

it is not necessary to write a debugging program for languages A and B: just use pre-existing ones; there is no need for the developer to learn, or maintain his B-language skills;

it is not necessary for the developer to learn a new compiler, he continues to use the one associated with the language A.

Subsequently, we present the case of a use of the Objective-C ™ intermediate language and the Java ™ source language. It is clear, however, that the invention is not limited to this particular application, but can also be implemented in many other cases, for example from Pascal language to C language and more generally in all cases where the objectives Listed below are interesting.

5.2 Description of an embodiment

In this embodiment, the implementation of the invention is presented to a gateway debugging program between an Eclipse debugger for Java ™ and a GDB debugger for Objective-C ™.

5.2.1 Initial compilation phase

According to the invention, prior to debugging, the compiler, in debug mode, performs a transformation of the source code of the software application written in the source programming language into the intermediate programming language by inserting additional instructions. More particularly, the compiler of the source language to the intermediate language makes the following modifications:

It formats the code so that each line in source language is as much as possible transformed into a line of the intermediate language. This formatting makes it possible to use the 'step over' function of the debugging program of the intermediate language to make a 'step over' for the source language.

In the case where the compiler can not maintain this previous property (a line in language A on a line in language B), it inserts compilation directives (ie "#line" for compilers of strain C (Objective -C, C ++, C, ...)). It will indicate that these different Lines in intermediate language come from the same line in source language. For example, if the language A supports the initialization of variable at the same time as its declaration, and the language B does not support this construction, the compiler will have to move the initialization of the variable in one or more methods of initializations. It will insert, in this case, compilation directives to indicate that these different initializations in language B come from the same line in language A, that is to say the one where the declaration of this variable is.

The name and line number are used, in the method of the invention, not as a pointer to an actual line of the source code, but by the gateway debugger as the unique line identifier. This line identifier will be retained, according to the invention, in the intermediate representation of the compiler so that the gateway debugging program can make the necessary conversions during the actual tuning.

It generates unnecessary constructs for program execution so that the gateway debugger can insert breakpoints on certain events. For example, for the Exception Management System (EMS), the A language debugger may need to know when an error is reported with an exception ("throw" keyword in some languages). In this case, it replaces all occurrences of the keyword "throw" with a call to a particular method before actually sending them. Thus, the gateway debugger is informed of all program exception shipments by inserting a breakpoint in this method. In general, it inserts a method call before each statement that generates an event whose debugger of the language A wants to know (introduction into an exception processing block, creation / destruction of a thread, introduction into a particular method, ...). Thus, the software application written in intermediate language is specifically constructed to be able to generate data that will subsequently be used by the gateway debugger. This is an important point of the invention. Buildings called 'useless' (useless because they do not fulfill a specific function in the application) are actually very useful for the gateway constructor.

5.2.2 Focusing phase

As already mentioned, the development phase of a software application comprises a plurality of requests transmission step of the program of development of the language concerned. More particularly, these request transmission steps are intended to control the execution of the program and to obtain information on the state of the program (content of the variables, methods executed, etc.).

According to the invention, the gateway debugger intercepts all incoming requests from the source language debugger in the debugger protocol of the source language. For this, he knows, according to the invention, the protocol used, and masquerading as the final debugger. It reacts in the same way, giving the GUI or the developer the same interactions as with a classic debugger.

5.2.2.1 Static Queries

For requests of static types, that is to say not asking for data depending on the execution of the program such as the names of classes, methods, fields:

Either the gateway debugger finds the information in an information file written by the compiler (equivalent to the debug information in DWARF format for example);

Either the gateway debugger directly queries the compiler, which will internally search for the information needed to respond to the request; Either the gateway debugger directly uses the intermediate representation in the compiler process to find the necessary information.

In all three cases, the information provided by the compiler, from an intermediate data structure (internal or external to the compiler), contains all the structural information of the program, it is then possible to ask to find the set of classes, the set of methods of instances or classes, fields of instances or classes, the set of classes contained, ... of a certain class.

5.2.2.2 Dynamic Queries

For dynamic type requests, that is, requesting data depending on the execution of the program, the gateway debugger:

Express this request in an A language expression, for example, to know the value of a C class field of the xxx.yyy.zzz package in a Java program, it will build an expression such as xxx.yyy.zzz. C.f and will apply the same transformations that the gateway compiler would have done on such an expression;

Ask the debugger of the language B, in its protocol, to evaluate this expression. For example, with gdb-mi, it will send the command "-data- evaluate-expression xxx_yyy_zzz_C_f ';

Retrieves the value of the expression and translates it into an understandable value in source language;

Respond to the request.

By passing (transferring) the entire expression into the compiler, it gives the compiler complete freedom to generate code in the target language. To illustrate this point, it is for example possible for the compiler to generate a management of the fields autonomously in memory (with a couple symbol + offset: xxx.yyy.zzz.C + 0x10), without relying on the fields of the language target (with a symbol: xxx.yyy.zzz). Indeed, the other solutions of the state of the art rely on a correspondence of symbols, which is not the case of the invention. This property of the invention is all the more important as the levels of the source language and the target language are far apart.

This solution also has the advantage of making the compiler of the gateway debugger independent. Indeed, the gateway debugger does not have the knowledge of the correspondence between the expression in the source language and the expression in the target language, it queries the compiler for that.

Control Flow Queries

Several flow control requests may arrive on the gateway debugger:

- The installation of a 'Breakpoint'. The query includes a location of the breakpoint as the file name and line number in the file. The gateway debugger must retrieve the unique line identifier that the compiler to be inserted during the compilation phase as a file name and fictitious line number II must request this information from the compiler, directly or indirectly via a file , or will look for this information directly in the intermediate representation of the compiler. It will then ask to set this breakpoint to the program of debugging the intermediate language.

- The 'step-over', the 'step-into', .... Thanks to the formatting of the source code in intermediate language previously done by the compiler, the gateway debugger has only to transmit the request in the protocol of the debugger of the intermediate language. If the transformation of the code of the source language into intermediate language does not make it possible to do this manipulation, or if the target debugger does not support the operation, an analysis of the control flow as described in the state of the art makes it possible to find all of the following possible instructions. The method then comprises according to the invention a step of insertion, thanks to the previous technique, breakpoints ('breakpoint') on all the following potential lines. It is then sufficient to continue the execution of the program to ensure that the next instruction executed will be stopped.

5.3 Other optional features and benefits

A debugging system according to the invention is described below.

A system that implements the method of the invention comprises:

means for compiling the software application written in the source language A delivering the code of an intermediate software application written in the intermediate language B. These compilation means are mainly in the form of an ad hoc compiler which can be run on a computer. This compiler however comprises, according to the invention:

means for insertion within the code of the intermediate software application written in B language, of a specific construction of interception of events occurring during the execution of the debugging program of said intermediate language B by means of additional instructions. These additional instructions are used by the gateway debugger to allow the information requested by the A language debugger to be returned.

means for formatting the intermediate code of the software application so that the correspondence between a line of the source code and a line of the intermediate code is as frequent as possible. These formatting means act to ensure a construction of the intermediate program written in the B language that is as similar as possible to the original A language construct.

code compilation means of the intermediate software application into a software application executable on the target platform. These compilation means are mainly in the form of an ad hoc compiler that can be run on a computer. means for debugging the software application which according to the invention comprise at least means for transforming at least one debugging information between a debugging program of said intermediate language B and the program for setting the point of said source language A.

Claims

Method for debugging a software application written in a source and executable programming language on a target platform, characterized in that it comprises:

a step of formatting the intermediate code of said software application so that the correspondence between a line of the source code and a line of the intermediate code is as frequent as possible;

a phase of compiling the code of said intermediate software application into a software application executable on said target platform;

Method according to claim 1 characterized in that said compilation phase further comprises a step of generating at least one specific representation of said software application within an intermediate data structure and in that said debugging phase implements said intermediate data structure. Focusing method according to claim 2, characterized in that said focusing phase further comprises:

Focusing method according to claim 1, characterized in that said focusing phase further comprises:

a step of transforming said request for obtaining at least one dynamic data item into a request for obtaining at least one dynamic data item for said debugging program of said intermediate language, delivering a transformed obtaining request request; a step of transmitting said transformed obtaining request to said debugging program of said intermediate language;

a step of executing said obtaining request transformed by said debugging program of said intermediate language delivering said at least one dynamic datum;

a reception step, from said debugging program said source language, an execution control request of said software application;

a step of receiving, from said debugging program of said source language, an event management request of said software application;

A method of compiling a program written in a source programming language to an intermediate program written in an intermediate programming language, said intermediate program being itself intended to be compiled for a target platform, characterized in that it comprises a step of insertion, within said intermediate program, of at least one complementary control instruction of said intermediate program by a gateway debugger.

System for debugging a software application written in a source programming language and executable on a target platform, characterized in that it comprises:

means for compiling said software application written in said source language delivering the code of an intermediate software application written in an intermediate language, said compilation means comprising:

means for inserting into the code of said intermediate software application, a specific event interception construction occurring during the execution of a debugging program of said intermediate language, by means of complementary instructions;

means for compiling the code of said intermediate software application into a software application executable on said target platform;

Computer program product downloadable from a communication network and / or stored on a computer readable medium and / or executable by a microprocessor, characterized in that it comprises program code instructions for executing the method of setting in accordance with at least one of claims 1 to 6 when executed on a computer.