JP2003122595A - Method and device for software fault analysis - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method and a device for software fault analysis capable of reducing the amount of a memory required for recording a log to increase the range of allowing an execution to be performed in reverse direction with the same amount of memory by improving a method based on a reverse instruction to separate information on types of instructions and information on addresses of a memory operated by the instruction and data size from the log in the form of a program in reverse direction. SOLUTION: When a source program (source code) is translated (compiled), a program in a direction reverse to the direction of reflection of a log generation processing on the translated results. The program in the reverse direction is executed by using, as an input, the log information generated at execution of the program to execute the program in the reverse direction and recover the state of the program in the past.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software failure analysis (debugging) method and apparatus, and more particularly to a method for reversing a program by devising a method for translating (compiling) a source program into an instruction word of a computer. By making it possible to execute in the direction so that the state before the time when the failure occurs can be reproduced, the failure analysis is facilitated.

[0002]

2. Description of the Related Art In software failure analysis, a method of presuming the cause of the failure is widely used by stopping the operation of the program at the time when any abnormality (failure) is detected and examining the memory state at that time in detail. ing.

However, in this method, since only the information at the time when the failure is detected is obtained, there is a problem that it is not possible to obtain accurate information as to what progress has been taken before the failure. is there. In the prior art, the following techniques are known to solve this problem.

(1) Embedding a process for displaying or saving a variable value or the state of the program in a file,
A method of estimating the cause of failure by recording the intermediate results during execution. However, it is necessary to embed the display processing and the recording processing at the time of designing the program, and it is also necessary to make a determination at the time of designing which information should be recorded. Further, there is a drawback that the amount of information to be recorded is large in order to know the state of the program accurately.

(2) Method based on reverse instruction log. Generally, this is a method used to realize UNDO processing (cancellation processing) in the user interface portion of an application program, and an instruction string (reverse processing) that cancels processing every time the execution program is processed. Instruction) is a method of keeping a record. By executing this reverse instruction, it is possible to reproduce the state before the time when the program stopped and to estimate the cause of the failure. This method has a feature that multi-step cancellation can be easily realized.

[0006]

In order to investigate the process of operation of a program, a method of investigating from the time of failure to the past state is effective, but the method based on the reverse instruction log is used. If it is realized, there is a problem that the amount of information to be recorded in the log is large and the recording cannot be performed for a long time. This is because in the conventional technology, the log contains all the information necessary for processing, such as the type of instruction, the size of memory address and data operated by the instruction, and the data for recovering the state. This is because

The present invention has been made in view of the above-mentioned points, and improves the method based on the above-mentioned reverse instruction so that the information of the type of the instruction, the address of the memory operated by the instruction, and the information of the data size can be obtained. By separating the log in the form of a backward program, the amount of memory required for recording the log can be reduced and the range in which backward execution can be performed with the same amount of memory can be expanded. The purpose is to provide a device.

[0008]

A software fault analysis method according to the present invention is a source program (source code).
When the program is translated (compiled), the log generation process is embedded in the translation result and the backward direction program is generated, and the backward direction program is executed by using the log information generated at the time of program execution as input. It is characterized by executing and restoring the past state of the program.

Further, the software fault analysis apparatus according to the present invention includes a compiler for embedding log generation processing in a translation result and generating a backward program when a source program (source code) is translated (compiled), and a program. And a failure analysis means (debugger) for executing the backward direction program by executing the backward direction program using the log information generated at the time of execution of the program and restoring the past state of the program. Is.

[0010]

BEST MODE FOR CARRYING OUT THE INVENTION In the present invention, a program compiling means (compiler) having the following features,
The above problem is solved by using the failure analysis means (debugger).

When the source code is translated into a program, the compiler of the present invention generates a "forward program" that is executed in the same order as a normal program and a "backward program" that is executed in the reverse order. The backward program is configured to cancel the operation result of the forward program by executing it. In order to generate such two programs, it is necessary to perform special processing on a portion where the contents of the memory are rewritten in the operation of the program and a portion where the flow of the program (control flow) is changed.

First, the processing for the portion where the contents of the memory are rewritten will be described. To rewrite the memory contents,
There are three types: (1) initializing the uninitialized memory, (2) overwriting the contents of the initialized memory, and (3) releasing the initialized memory.

When initializing the uninitialized memory, a backward program is output as a backward program which informs the failure analysis means (debugger) that the memory contents have returned to the uninitialized state. As a result, the process of initializing the uninitialized memory in the forward program is reproduced as the process of returning the initialized memory to the uninitialized state in the reverse program.

When the contents of the initialized memory are overwritten, the contents of the memory before being overwritten are saved by some method, and the values saved in the backward program side are restored to overwrite the memory. Restore the state before. At this time, in order to restore the contents of the memory before being overwritten, the following three methods are used.

The first method is to store lost data in a log memory on the forward program side, and retrieve and restore it on the backward program side.
This method is very similar to the reverse instruction log method which is a conventional technique, but in the reverse instruction log method, information such as reverse instruction, address and size is recorded in the log as the log information. Since this information can be obtained by executing the backward program, there is no need to record it in the log.

The second method is a method of reconstructing a value by utilizing the reversibility when the contents of the process are originally reversible operations. For example, an operation that increases the value of an integer by 1 (increment operation) is a reversible operation, and this is an operation that decreases the value by 1 (decrement operation).
By performing the above, the state before the calculation can be restored. Therefore, the past state can be restored by performing the decrement operation on the backward program side for the portion on which the forward program side performs the increment operation.

The third method is to reproduce the data by recalculating the data lost by overwriting the memory. It is used when the data used to calculate the lost data still remains in other variables or log areas. For example, assume that the value of variable A is the sum of variable B and variable C. At this time, even if the value of the variable A is lost by overwriting, if the values of the variable B and the variable C still remain, the lost data can be restored by calculating the sum of B and C again. it can.

Next, the case where the memory is released will be described. Freeing memory is essentially the same as overwriting memory in that the data it held is lost. Therefore, the data can be reproduced by using the same method as the case of the memory overwrite. However,
Since freeing memory is not a reversible operation, only two methods can be used: logging lost data and replaying data by recalculating.

Next, a process for a portion where the control flow is changed will be described. When the control flow is changed, the control flow of the backward program is configured to be the reverse of the control flow of the forward program. There are five types of control flow changes: conditional branch, unconditional branch, repeat (loop), subroutine call, and interrupt.

The processing for performing a conditional branch in the forward program is the processing for performing a conditional branch in the backward program as well.
In the backward program, it is necessary to reproduce which one of the options (routes) for conditional branching was selected, so the forward program side records the selection result, and the backward program records the conditions based on that information. Reproduce the branch selection.
The method of recording the selection results is the same method used to restore the values lost due to the memory overwrite.

For a portion where an unconditional branch is performed in the forward program, a program for performing a conditional branch is generated on the backward program side. This is because in an unconditional branch, multiple branches may jump toward one jump destination (jump destination label). This is because it is necessary to select whether it was possible. Along with this, it is necessary to record the location from which the jump is made at the location of the unconditional branch on the forward program side.

A loop process is also generated on the backward program side for a portion where the iterative process (loop) is performed in the forward program. Since it is necessary to reproduce how many times the loop has turned when executing the backward program, record information on the number of times the loop is executed by some means when executing the forward program,
The reverse program takes it out and configures it to loop as many times as the forward program.

The process of calling a subroutine in the forward program is the process of calling a subroutine in the corresponding backward program in the backward program.
No special treatment is required for this.

Special processing is required for interrupts. Since it is not possible to predict when an interrupt will occur, it is necessary to record when and where it occurred. The interrupt generation log is used for this. The interrupt generation log is saved in an area different from the normal backward execution log. The process of recording the interrupt generation log is embedded in the program (interrupt handler) executed by the interrupt.

A pair of a counter (pointer) indicating the head of the log area at that time and an address on the program where the interrupt occurred is used as the data indicating the interrupt time. In order for this pair to uniquely represent the interrupt point, there must be no loop processing or subroutine call that does not output the log at all.Therefore, at the location of such loop processing or subroutine call, a dummy log Put processing.

In either case, upon execution in the backward direction, when the location indicated by the interrupt generation log is reached, the corresponding interrupt processing on the backward program side must be called.
This call processing is performed by the failure analysis means (debugger).

Next, the operation of the failure analysis means (debugger) will be described. The failure analysis means first finds the point at which the forward program is stopped, and uses the information indicating the correspondence between the forward program and the backward program generated by the compiler to determine the position of the backward program corresponding to the stopped point. Then, the backward state of the forward program is restored by executing the backward program from that position.

The extent to which the state is restored is determined by the user indicating the position on the source code. By using the correspondence between the source code and the forward program and the correspondence between the forward program and the backward program, the position on the backward program can be obtained,
If the backward program is executed up to that point, it will be restored to the specified time.

Specific embodiments shown in the drawings will be described below. FIG. 1 shows a hardware configuration when the failure analysis unit (debugger) according to the present embodiment is operating, and a software configuration in the memory. The computer main body (0101) has a central processing unit (processor) (0
102) and a main memory (memory) (0103). The main memory (0103) contains the software of the forward program (0104) created by the translation means (compiler), the backward program (0105), and the failure analysis means (debugger) (0106).

The forward program and the backward program share one data area (0107) and use this area to perform calculation. Also, the log information generated by the execution of the forward program is written in the log area (0108) and read when the backward program is executed. The log (0109) related to the interrupt is taken separately from the normal log area.

Switching between the forward program and the backward program, and other processing related to failure analysis are performed by software (debugger) of failure analysis means. This software controls whether the processor is assigned to forward or backward programs. A user (user) who performs a failure analysis operates this debugger via the control terminal (0110) to execute a forward program or a backward program and display or modify data in the memory.

Next, FIG. 2 shows a block structure and a data flow inside the compiler (translating means). The compiler (0202) reads the source program (0201) by the source reading unit (0203), the lexical analysis unit (0204) extracts a symbol from the character string, and the syntax analysis unit (0205) analyzes the grammar. Create a data structure called an intermediate parse tree. After removing a useless part included in the intermediate parse tree by the syntax tree optimizing unit (0206), the forward code generating unit (0207) and the backward code generating unit (0208) generate the instruction code of the computer. .

This part is a characteristic part of the present invention. A normal compiler generates only one code, whereas the compiler of the present invention generates two codes, one for forward execution and the other for backward execution. Details of this portion will be described later.

Next, optimization is performed again on the instruction code of the computer created by the code generation processing. This is because optimization is performed by taking advantage of the characteristics of each computer. Finally, in the code output unit (0210) and the correspondence relationship table generation unit (0211), the forward program (0213), the backward program (0214), the file (execution program) (0212) of the compilation result, A correspondence relation table (0215) representing the correspondence relation between the source program (source code) and each program is generated.

Next, FIG. 3 shows a data structure used internally by the compiler. This data structure determines whether the value before being overwritten needs to be logged or is recalculated from another variable when data is lost due to overwriting of memory. Used for.

The entire data structure is the reproduction information table (0
301). This table includes information about a variable or a substitutable memory area (collectively referred to as an lvalue) and reproduction information (0302) indicating information about an expression (left-side expression) that refers to an lvalue. . Also, since the reproduction information is registered in the form of being added to the table one after another, a pointer (030
Use 3).

The reproduction information is a left-side expression (0304) used to identify each left-side value and a true / false indicating whether or not the left-side value may be rewritten via a pointer (aliasing possibility). A value (0305), an expression (reference expression) (0306) for referencing the left side value, a list of other left side expressions (reference dependents) (0307) required to calculate the reference expression, and a left side value is A replay formula (0308) showing how to recalculate when lost, a list of other left-hand side formulas required for replay formula calculation (playback destination) (03
09) composed of a total of 6 elements.

The reference expression and the reproduction expression hold expression information in the form of an intermediate parse tree (0311, 0312). One intermediate parse tree recursively includes a plurality of left-side expressions, and the reproduction information regarding these partial left-side expressions is also secured in the table. The reference dependence destination list (0313) and the reproduction dependence destination list (0314) are used to indicate which partial left side expression is assigned to which part of the table. A numerical value indicating a relative positional relationship (for example, 10 positions before the table) is used to indicate at which position in the table the dependence destination exists.

The left side expression of the first element of the reproduction information and the left side expression included in the reference dependence destination list (0313),
And the left-side expression included in the playback dependence list,
Since it is used for retrieval of reproduction information, it is expressed by a character string expression instead of the format of the intermediate parse tree.

Next, a procedure for generating codes for a forward program and a backward program using this data structure will be described. First, FIG. 4 shows a processing procedure for code generation of an assignment statement. In this procedure, two pieces of data, an expression representing a substitution destination and an expression for calculating a value to be substituted, are received as arguments (S0401). Next, a procedure (S0402) for performing a special process required when the variable holding the pointer can be aliased is called.

Next, the reproduction information that matches the expression on the left side of the substitution destination is searched from the reproduction information table. At this time, if there are a plurality of pieces of reproduction information having the same left-hand side expression, the reproduction information registered last among them is selected. Since the reproduction information includes data that can be determined by recalculation when the data of the substitution destination is lost, the reproduction possibility determination procedure shown in FIG. 5 described later is used. It is determined whether reproduction is possible (S0404).

If it is determined that the reproduction is possible, a code for performing a normal substitution process is generated for the forward program. For the backward program, the value lost by the recalculation is reproduced, and a process of writing it back to the left-side value of the assignment destination is generated (S0405). Also,
The reproduction code generation procedure shown in FIG. 7 to be described later is used to generate the recalculation process (in the flowchart of FIG. 4, “forward:” is used for code generation for the forward program, and “forward:” for code generation for the backward program). Is written as "reverse:").

Next, in the reference expression of the reproduction information and the reference dependence destination,
The reproduction formula and reproduction dependence destination are copied (S0406). This means that when referring to a value lost due to substitution, it is necessary to refer to it using a regenerating formula.

If the left-hand side expression of the substitution destination is not reproducible, the forward program side generates the _SAVE processing for saving the data in the log before the substitution and the substitution processing for performing the normal substitution after that. For the backward program, read the data from the log and write it back to the assignment destination_RE.
A STORE process is generated (S0407). _SAVE
The processing and the operation of the _RESTORE processing are shown in FIGS. 20 and 21. Further, the log generation number counter indicating how many _SAVE processes have been generated is incremented (S0408).

Next, the reference expression of the reproduction information is replaced with the _PEEK expression for extracting the data from the log (S040).
9). The _PEEK expression needs to be given an argument that indicates from which part of the log the data should be extracted, and the value is given as the value of the current log generation number counter. This value is tentative and will be modified later when the lookup expression is actually used. Also, the reference dependency destination is empty. The operation of the _PEEK formula is shown in FIG.

Next, the reproduction information regarding the newly written value is registered (S0410). Since this registration is performed by adding new reproduction information, if there are a plurality of substitutions for the same left-side expression, a plurality of reproduction information will be registered. This is so that the information indicating the past state of the left side value and the information indicating the latest state are all recorded.

Each element of the reproduction information is set as follows. (1) The left-hand side expression sets the left-hand side expression to be registered as a character string. (2) For the boolean value indicating whether aliasing is possible, false is set for the local variable and the argument passed by value, and true is set for the other left-side expressions. (3) For the reference expression, the intermediate parse tree of the expression on the left side is set as it is. (4) As for the reference dependence destination, all the left-hand side expressions of the reference expressions are taken out to form a list, and they are searched from the reproduction information table to set the information on the relative positional relationship. (5) The expression on the right side of the substitution process (right side expression) is set as the reproduction expression. This is to record how the last substitution made. (6) As for the reproduction dependence destination, as in the case of the reference dependence destination, a list in which all partial left-side expressions of the right-side expression are extracted is created and set.

Next, FIG. 5 shows the procedure for determining the reproducibility. This procedure is false (unreproducible) because the reproduction information of the left-hand side expression to be judged is received (S0501), and if the reproduction expression of the received reproduction information is empty, it means that reproduction is impossible. And terminates (S05
02, S0503). On the contrary, if there is a replay formula, it is checked whether or not all the dependees necessary for replay formula calculation can be referenced (S0504, S0506, S050).
7). If all the dependees can be referred to, it is determined to be true (reproducible) and the process ends (S050).
5). On the contrary, if even one of the dependents cannot be referred to, it is determined to be false (reproducible) and the processing ends (S05).
08).

Whether or not the dependee can be referred to is shown in FIG.
Use the referenceability determination procedure shown in. This procedure
Recursively traces all the reference dependence destinations of the left-hand side expression passed as the reproduction information (S0601, S0602, S0603
S0604, S0606, S0607), and if all of them can be referenced, it is determined to be true (reference is possible) (S0
605). If even one is unreferenceable, it is determined to be false (reference not possible) (S0609). In addition, once the data becomes unreferenceable, it will not return to the referenceable state later, so by leaving the reference expression of the left-hand side expression that is determined as unreferenceable empty, the next determination can be made faster. (S0608).

Next, FIG. 7 shows a processing procedure for generating a reproduction code (a program code for restoring data lost by recalculation). In the generation of the reproduction code, a process for referring to all the lvalues of the reproduction dependence destination is generated (S0
701, S0702, S0703), and a process for calculating a reproduction formula using the data referred to by them (S0705). However, when the playback expression includes the _PEEK expression, the value of the current log generation number counter is subtracted from the argument of the _PEEK expression to calculate the value,
A code for performing recalculation is created by creating an expression in which the arguments of the PEEK expression are replaced (S0706, S0707). This is to calculate how deep the location of the referenced log is when actually referring to it.

FIG. 8 shows the procedure for generating the reference code. This is the same as the reproduction code generation procedure shown in FIG. 7, except that the target of calculation and inspection is the reference expression and the reference dependence destination, not the reproduction expression and the reproduction dependence destination. That is, in the generation of the reference code, a process of referring to all the lvalues of the reference dependence destination is generated (S0801, S0802,
(S0803), a process of calculating a reference expression using the data referred to by them is generated (S0805). However, when the _PEEK expression is included in the reference expression, the value of the current log generation number counter is subtracted from the argument of the _PEEK expression to calculate the value, and the expression that replaces the argument of the _PEEK expression is created. Generate code for recalculation (S
0806, S0807). .

Next, the self-destructive substitution avoidance process will be described. Self-destructive assignment is an assignment in which the pointer itself is lost when writing a value via a pointer, and only if the left-side expression of the assignment destination is the left-side expression via the pointer and the left-side value holding the pointer is aliasable. Occur. For such assignments, it is necessary to save the pointer before the assignment causes the pointer value to be lost.

FIG. 9 shows a procedure for generating a process for saving a pointer for a portion where self-destructive substitution may occur.
First, it is determined whether the left-side expression of the assignment destination is an assignment via a pointer (S0902), and it is determined whether aliasing is possible by referring to the reproduction information of the variable holding the pointer (S0903). In this case, it is necessary to save the pointer because self-destructive substitution may occur.

However, since the state where such a pointer points to the pointer itself does not occur in many programs, if it is possible to instruct the compiler not to perform the avoidance processing by the option directive, most of the The overhead can be avoided with the program. The step (S0904) of FIG. 9 is a part for determining whether or not to generate the avoidance process, and the pointer saving process and the reproducing process are generated only when the user selects to generate the avoidance process (S0905).

Next, FIG. 10 shows a code generation procedure for the whole mathematical expression including substitution. The code generation procedure relating to the assignment process shown in FIGS. 4 to 9 is called from the code generation procedure for the entire expression shown in FIG.

In the code generation of the entire expression, first, the entire expression is decomposed into partial left-side expressions, and if they are not registered in the reproduction information table, a new registration processing is performed (S1002). At this time, as in the reproduction information registration process (S0410) shown in FIG. 4, each information inside the reproduction information is initialized. However, in this case, since there is no equivalent to the right-hand side expression, the reproduction expression and the reproduction dependence destination are generated in an empty state.

Next, it is determined whether or not the expression includes an operation for obtaining the address of the left side expression (S100).
3). When the address of the left-hand side expression is acquired, the left-hand side expression can be aliased, and therefore it is recorded in the reproduction information that it can be aliased.

Next, it is judged whether or not the expression includes a function call (S1005), and if the function call is included, a local variable holding the return value of the function is added to the function call part. Is separated from the expression (S100
6), the separated function call is made before the calculation of the expression (S1007). This is to remove side effects other than assignment from the expression. The code generation procedure for function call is shown in FIG. 11 described later.

Next, it is determined whether the expression matches the reversible operation pattern (S1008). Calculations such as addition and subtraction of integers and inversion of signs, exclusive OR (XOR) of bit values and bit inversion can accurately reproduce the value before calculation from the calculation result without using a log. With respect to the above calculation, a forward program and a backward program are generated based on a conversion pattern prepared in advance (S1011). At this time, the equations are separated in advance for the portions other than the reversible pattern (S100
9), for expressions other than the reversible pattern, code generation is performed by recursively calling the code generation procedure of the expression (S
1010).

Next, it is determined whether or not the expression includes an assignment operation (S1012). If the expression includes an assignment operation, it is separated into an assignment destination (left side expression) and an expression for obtaining an assignment value (right side expression). (S1013), by calling the code generation procedure (FIGS. 4 to 9) of the assignment process for the pair of the left-side expression and the right-side expression, a code related to the assignment is generated (S1014).

If the expression does not match the reversible arithmetic pattern,
If it is not an assignment operation, it is a normal numerical calculation, so
In the same manner as a normal compiler does, a process for performing a calculation is generated (S1015).

Next, FIG. 11 shows a procedure for calling a function. In the function call, first, a process for evaluating an actual argument is first generated (S1102). However, this is only the case for forward programs, and backward programs do not require argument evaluation. This is because the forward program obtains the result from the argument, while the backward program goes back from the result to the original data. However, regarding the amount of data to be given to the function, the forward program and the backward program should be matched. This is to ensure that the stack memory layout is the same in the forward and reverse directions.

After the code for evaluating the arguments is generated, it is determined whether the called function belongs to the function classified as "no side effect" (S1103). This is because it is not necessary to generate backward programs for mathematical functions such as SIN and COS that have no side effects. If the function has no side effect, the function call code is generated only on the forward program side (S1104).

On the other hand, for functions not registered as "no side effect", functions for forward program (function name has _F_ at the beginning) and functions for backward program (function name at the beginning) Since _B_ is added to each of the forward and backward directions, a function call code is generated for each of the forward direction and the backward direction (S1105).

When a function having a side effect is called, there is a possibility that the aliasable left side value of the global variable or the variable on the memory pointed to by the pointer is rewritten by the function. Since the playback formula cannot be used when the data value and the playback formula do not match, clear the playback formula from the playback information for all left-hand side expressions that may be rewritten, that is, the left-hand side expressions that can be aliased. It is necessary to keep it (S1106).

Similarly, since the number of logs generated in the function is unknown, the data accumulated in the old part of the log cannot be accessed by the _PEEK expression. Therefore, the reference expression is cleared for the reproduction information including the _PEEK expression in the reference expression (S110).
6). In addition, at this time, the log generation number counter used for obtaining the position to access the old log is also set to zero.

Next, FIG. 12 shows a function definition code generation procedure. In the function definition, the function for the forward direction and the function for the backward direction are generated in one program, so it is possible to distinguish them by renaming each function. At this time, _F_ is added to the head of the function name for the forward function. Similarly, the function for the reverse direction is _B
Add _ (S1202).

Next, preparations are made for code generation of the function body. First, the reproduction information table is initialized to be empty (S1203). This is because the reproduction information in the present invention is managed for each individual function, and the state of the left side value is not managed beyond the range of the function. Therefore, a table is created (S1203) and discarded (S1213) for each function.

Next, reproduction information for local variables is assigned (S1204). At this time, the left side expression, the true / false value of whether or not aliasing is possible, the reference expression, and the reference dependence destination are set in the same manner as in the reproduction information allocation (S0410) in FIG. However, regarding the playback formula, _INVALIDA
TE processing is set. This is to show that the local variable is in an undefined state before being first assigned.

Next, the reaching route number used in the unconditional branching process and the data used when generating the code of the function body such as the log generation number counter are initialized (S120).
5).

Next, it is judged whether or not the function is designated for the interrupt handler (S1206). This is because it is necessary to perform a frame initialization procedure and a frame release procedure different from those of normal functions for interrupt handlers. If it is an ordinary function, a frame generation process for the ordinary function is generated. If it is designated for the interrupt handler, a frame generation process for the interrupt handler is generated (S1208). Furthermore, a process for recording that an interrupt has occurred (_
INTERRUPT_START processing) is generated on the forward program side (S1209).

With the above procedure, the code generation of the function body is ready, so the code generation procedure of the program sequence is called to generate the code of the function definition body (S12).
10). When the code generation of the function body portion is completed, the frame size information is corrected by the amount of the local variable added in the code generation procedure (S121).
1).

Next, the process required for ending the function is generated. For local variables and arguments, the variables are discarded when the function ends, so if the discarded variable values are not reproducible, the save process (_SAVE process) to the forward program side and the reverse direction are performed. A return process (_RESTORE process) to the program side is generated. For a reproducible item, a reproduction code is generated on the backward program side (S1212).

Next, if there is no process for creating a log in the function body, a process for creating a dummy log and a process for reading are created (S1213).
This is because the log head position is used as a means for accurately recording the interrupt generation time point, so that a problem occurs if there is a function that does not generate a log at all. With the above, the process related to code generation of the function body is completed. The reproduction information table regarding the data of the function body is unnecessary and is deleted (S1214).

Finally, a frame deletion process at the end of the function is generated. Since the frame deletion process differs between the interrupt handler and the normal function, it is determined which type the function is (S1215), and if it is the normal function, the normal frame deletion process is generated (S1216). If it is an interrupt handler, log processing (_INTERRUPT_E) that records the termination of the interrupt handler is recorded.
ND processing) is generated on the forward program side (S121
7) Finally, a frame deletion process for interrupt handler is generated (S1218).

Next, FIG. 13 shows a code generation procedure for conditional branching. In the conditional branch, the control flow of the program (control flow) is recorded by recording some of the choices of the conditional branch during execution of the forward program by some means, and reproducing it in the backward program. It is necessary to trace in the opposite direction. In order to realize this, it is sufficient that the value of the conditional expression for selecting the option of the conditional branch remains.

If the value of the conditional expression is reproducible,
The value of the conditional expression may be reproduced using the reproduction expression. If reproduction is not possible, prepare a local variable that holds the result of the conditional expression for each conditional expression, and leave the result of the conditional expression in the local variable. The reason for doing this is that if the result of the conditional expression is left using logs, the log amount of the result of executing each option of the conditional branch is different, so the position where the log of the conditional expression is stacked. This is because there is a possibility that cannot be calculated.

Therefore, first, a process of storing the result of calculating the conditional expression in a local variable is generated (S1302),
The forward program side generates a code that immediately uses the calculation result for branching, and the backward program side generates a code that branches using the result of the conditional expression remaining in the local variable (S1303). By the above, the procedure for reproducing the selection result of the conditional branch is completed.

Next, the procedure concerning the generation of the execution code of each option and the selection of the reproduction information that can be used after the execution of the option is completed is performed. First, before the code generation of the options, a copy of the reproduction information table is created for them (S1304). A code is generated for each option using this copied information (S1305, S1
306, S1307), and finally, the information of the reproduction information table changed by the code generation of each option is mixed and unified (S1306). The merging procedure is shown in FIG. 16 described later. This makes it possible to use the log generated at the position beyond the conditional branch and the information on the replay formula.

Next, the procedure for unconditional branching and label code generation is shown in FIGS. The unconditional branch and the processing related to the label are performed as a pair. First, on the unconditional branching side, a process of recording path information in a log on the forward program side is generated (S1402). This is because when there are a plurality of execution routes that reach one label, it is necessary to record which route was taken. Next, the log generation number counter is incremented (S140).
3). This is used to calculate the location of the log when accessing the log using the _PEEK expression.

Next, the route number is incremented (S
1404). This is to generate a unique number for each unconditional branch. This path number is used to determine the jump destination when the backward program branches backward from the label to the position of the unconditional branch (S1).
502, S1503). Finally, the process of deleting the entire reproduction information table is performed after the label code is generated. Since the lost data cannot be replayed, the log will be used less efficiently, because it is difficult to calculate what replay information will be provided from multiple routes.

Next, FIG. 16 shows the procedure for merging the reproduction information tables. First, the two tables A and B to be merged and the conditional expression used in the conditional branch are received as arguments (S1601). Next, the process is repeated by looping until all the elements of table A are processed (S
1602, S1603, S1609). If table A
If the element exactly the same as the element in the table B is also present in the table B (S1606), it is not affected by the conditional branch, or the same result is obtained in either path, and therefore, it is directly in the table A. Leave it.

Next, if there is an element that differs only in the reference expression and the reference dependent, create a conditional expression that switches the two reference methods by the conditional expression, and replace the reference cow tree with that element in Table A. (S1608). Elements other than these are discarded because the effect of the result of the conditional branch is too large (S16).
07). Finally, the table A is returned as the merge result, and the process ends (S1604).

Next, FIG. 17 to FIG. 19 show the code generation procedure of the repetitive processing (loop). In the repetitive processing, the reproduction information is different because the processing at the first execution of the loop and the processing at the second and subsequent times reach the processing in the loop through different routes. Two
What has different information at the time of the loop of the first time is the information about the left-side expression that is assigned in the loop. Therefore, by not allowing the playback information to be inherited until the next cycle of the loop for the left-hand side expression that is updated in the loop,
You can avoid being affected by loops. The list of left-side expressions rewritten in the loop can be acquired at the syntax analysis stage (0205 in FIG. 2), and is used.

Similarly, in the loop, since the amount of data to be accumulated in the log cannot be calculated in advance, there arises a problem that the position when referring to the log cannot be calculated. This can also solve the problem by making sure that the log is not referenced beyond the cycle of the loop.

FIG. 17 shows the procedure of processing for making these adjustments. First, at the position before the loop starts, the reproduction expressions are rewritten to empty for all the left-side expressions updated in the loop (S1702, S1703, S1704, S170).
5). As a result, the information about the replay expression before the loop is started and the information about the left-hand side expression that seems to have been rewritten in the cycle before the loop are not used, so that the problem that the replay information conflicts can be avoided. . next,
_P is used as a reference expression for all elements in the playback information table.
The one that includes the EEK expression is rewritten to be empty (S17).
06, S1707, S1708). As a result, since there is no portion to be referred using the log position, it is possible to avoid the problem that the log position cannot be calculated. Finally, since the information regarding the log position is lost, the log generation number counter is also reset to zero (S170).
9).

Since these problems similarly occur in the program after the loop is executed, the same reproduction information rewriting process is performed at the position immediately after the loop ends.

Next, the problem of how to reproduce the loop execution count will be described. There are two solutions to this. One is a method of counting the number of times of looping and recording, and the other is a method of leaving a flag indicating whether the loop is continued or ended each time the loop is executed. The method of counting the number of loops has an advantage that the amount of logs used is small, but it cannot be used for a process that loops endlessly because the counter overflows. Therefore, the method by the counter is applied to the processing in which it is clear that the number of loops can be counted by the counter. Apply the method to leave the flag on. For processing with a fixed number of loops, a loop control processing that generates loop indexes in the reverse order is generated, so that the processing is performed in the reverse direction without using any log. Because it is possible
These are dealt with by generating loop control processing for the forward program and the reverse method program prepared for each reversible pattern.

FIG. 18 shows a code generation procedure when the loop counter is used. First, an adjustment procedure (procedure of FIG. 17) for preventing reproduction information from causing a problem is called for all the left-side values to be rewritten in the loop (S1802). Next, it is determined whether the loop matches the reversible pattern (S1803). If it matches the reversible pattern, a code based on the pattern is generated for each of the forward program and the backward program (S1805). In the case of a loop that does not match the reversible pattern, a local variable for the loop counter is added (S1806), a code for counting the number of loops is generated on the forward program side (S1807), and after the loop ends. Generate a process to save the counter (S
1809). On the other hand, on the backward program side, a loop control code for retrieving the counter stored in the log and repeating the loop by the number of the values is generated (S180).
7). Finally, an adjustment procedure (procedure in FIG. 17) is called to adjust the reproduction information relating to the left-hand side expression rewritten by the loop, and the reproduction information table is sorted and ended (S1810).

Next, FIG. 19 shows a code generation procedure in the case where the method of leaving a flag indicating whether or not the loop is continued in the log is applied. This procedure is similar to the code generation procedure using a loop counter, so only the differences are shown. First, before the forward program loop, a flag (zero) to stop the backward program loop
Is generated in the log (S1906). Also,
After the processing performed in the loop is generated (S1907), the processing of leaving the flag (1) indicating that the loop has been executed in the log is generated at the end (S1908).
As a result, when the forward program is executed, first, the flag for stopping the loop is generated, and then, the number of flags indicating the loop execution is generated by the number of times the loop is executed. The backward program reads this and generates loop control processing for determining whether to loop (S1906).

Next, FIG. 20 shows a procedure for code generation of a program string appearing in the main body of the function definition, the conditional branch execution part, and the repeat process execution part. The program sequence is a simple arrangement of units that make up a program such as assignment statements, function calls, and conditional branches. In the code generation of the forward direction program, these programs may be continuously generated for one unit (S2008) and repeated until the end of the program sequence is reached (S2002, S2).
003, S2004).

The backward program must be executed in the reverse order of the forward program. For example, in a forward program, _F_func1 (), _F_fu
When function calls are performed in the order of nc2 () and _F_func3 (), _B_fun is set on the reverse program side.
c3 (), _B_func2 (), _B_func
The functions must be called in the order of 1 (). Therefore, every time the backward program side generates a code for one unit of the program, the codes are arranged in the reverse order (S2004).

At this time, information indicating the correspondence between the forward program and the backward program is also generated (S200).
5). This is used by the failure analysis means (debugger) to determine where in the backward program the stopped portion of the forward program is. The data structure of the generated correspondence table is shown in FIG. This table (28
In 01), the position on the program is managed by the line of the source code in order to improve the convenience for the user. Therefore, for the forward program and the backward program, information on which line of the source code each corresponds (280
2) and information (2
803, 2804) is generated.

Next, FIG. 21 shows the code generation procedure of the entire program. Since the entire program consists of a sequence of procedures (function definitions), unlike the case of the program sequence,
The order of the generated code and the order of execution are irrelevant.
Therefore, it is sufficient to generate code for all function definitions in order in the same way on both the forward program side and the backward program side (S2102, S2103).

Next, the contents of the log processing embedded in the forward and backward programs in the code generation procedure up to this point will be described. FIG. 22 shows _SAVE processing, FIG. 23 shows _RESTORE processing, and FIG. 24 shows _PEE.
The processing content of the K processing is shown. These processing procedures are used to save and retrieve data in the log area.

In the _SAVE processing shown in FIG. 22, the address indicating where the data to be saved in the log is in the memory and the size of the data are received (S220).
1) Copy the specified amount of data to the log area (S
2202), the pointer pointing to the beginning of the log is updated (S2203). At this time, if the log area is completely used up, some kind of action is required and the debugger is notified of it (S2204, S).
2205).

The _RESTORE processing shown in FIG.
Data is taken out from the log area by the procedure completely opposite to the SAVE processing. First, the address indicating where the fetched data should be stored and the size of the data are received (S23
01), if there is no data in the log area, it is notified to the debugger (S2302, S2303). Next, a pointer pointing to the beginning of the log is returned by the amount corresponding to the data size (S2304), and the data corresponding to the designated data size is copied to the copy destination (S2305).

In the _PEEK process shown in FIG. 24, the log area itself is not updated, but the data is copied from a position shifted from the beginning of the log by the designated size. First, the copy destination address, the size of the data, and the size of the offset from the beginning of the log are received (S2401). Next, data is copied from the position of the designated offset to the copy destination by the designated data size (S
2403).

Next, FIG. 25 shows the _INVALIDATE processing. The _INVALIDATE processing is used to notify the debugger that the state of the local variable has returned to the state before the first assignment by the execution of the inverse program. Therefore, _INVALIDA
The TE process is composed only of a notification process to the debugger (S2502). Such processing is necessary because the state of the memory before the first substitution is performed is undefined for the local variable. Debugger is _INVALI
When instructed to display the contents of the memory area designated as DATE, it is displayed that it is indefinite.

Next, _INTERRUPT_START processing inserted at the beginning and end of the interrupt handler and _
The INTERRUPT_END process is shown in FIGS. 26 and 27. These processes are used to record when and where the interrupt occurred. The area for recording data is different from the normal log, and is saved in a dedicated area for recording only the interrupt log. This is because it is difficult to distinguish the normal log information from the log information indicating the interrupt because it is uncertain when the interrupt will occur.

The procedure for writing and retrieving data in the interrupt log area uses the same procedure as the _SAVE processing and _RESTORE processing except that the interrupt log area is targeted.

_INTERRUPT_ST shown in FIG.
The ART process is a process called at the beginning of the interrupt handler on the forward program side, and saves the address at which the interrupt occurred in the log (S2602). The _INTERRUPT_END process shown in FIG. 27 is a process called at the end of the interrupt handler on the forward program side, and records when the interrupt handler has finished (S2702). For this, the information of the pointer that points to the beginning of the log area is used. This pointer is used to specify the execution time of the interrupt when a single address is executed many times, such as when calling a function or looping. When executing the backward program, the debugger can trace the interrupt process in the reverse direction by simulating the occurrence of the interrupt based on this information.

Next, the processing procedure of the failure analysis means (debugger) will be described. Since the failure analysis means usually has various functions such as displaying and rewriting data to be analyzed, loading a program, and setting and executing breakpoints, it is related to the backward execution, which is the central issue of the present invention. Only the part that has been done will be explained.

FIG. 29 shows a processing procedure at the time of backward execution.
First, in order to determine where to start execution in the reverse direction program, the address at which the forward direction program stopped is acquired (S2902), and then that address is used for the reverse direction program using the correspondence table (FIG. 28). The address is converted to the side address (S2903).

Then, the user is instructed as to which position in the source code the backward execution should be performed (S2906). Next, the position on the source code designated by the user is converted into an address on the backward program side using the correspondence table (S2908), and a break point is set for that address (S290).
9). Next, the backward program is executed (S2
910), when the position of the break point is reached, the reverse execution is ended (S2911), and the next instruction from the user is waited (S2906). If the user gives an instruction to end, the backward execution is ended (S2907, S2).
912).

However, at this time, the debugger must also simulate the occurrence of an interrupt. Therefore, read the contents of the interrupt log before starting the execution of the backward program (S
2904), break points are set for all interrupt generation addresses (S2905). As a result, the backward execution is interrupted each time the interrupt generation address is passed, so it is determined whether the interrupt has occurred until the time when the interrupt occurred by comparing the value of the pointer that points to the beginning of the log (S2913). When it arrives, processing for calling the interrupt handler on the backward program side is performed (S2914).

As described above, in the present embodiment, in the failure analysis of the program, the past state of the program can be reproduced by executing the program in the reverse order. All processes can be investigated, and the effect of facilitating program failure analysis is obtained.

Further, in contrast to the conventional reverse instruction log method in which information such as reverse instruction, address, size, etc. is recorded as log information in the log, in the present embodiment, these are executed by executing a backward program. Since the information is obtained, it is not necessary to record it in the log, and the amount of memory required for the log is reduced, so that the range in which the backward execution is possible with the same amount of memory is expanded.

Further, since the backward program can be optimized, there is an effect that it can be executed at a higher speed than the backward instruction log method.

[0110]

As described above, according to the present invention, the instruction type information, the memory address operated by the instruction, and the data size information are separated from the log in the form of a backward program. Thus, it is possible to provide a software failure analysis method and apparatus capable of reducing the amount of memory required for recording a log and expanding the range in which backward execution is possible with the same memory amount.

[Brief description of drawings]

FIG. 1 is a diagram showing a hardware configuration at the time of failure analysis and a software configuration inside a memory according to an embodiment of the present invention.

FIG. 2 is a processing flow chart of compilation.

FIG. 3 is a diagram showing a data structure of a reproduction information table.

FIG. 4 is a flowchart showing a code generation procedure of substitution processing.

FIG. 5 is a flowchart showing a procedure of determining the reproducibility.

FIG. 6 is a flowchart showing a reference possibility determination procedure.

FIG. 7 is a flowchart showing a reproduction code generation procedure.

FIG. 8 is a flowchart showing a procedure for generating a reference code.

FIG. 9 is a flowchart showing a self-destructive substitution avoidance process generation procedure.

FIG. 10 is a flowchart showing a code generation procedure of an expression.

FIG. 11 is a flowchart showing a code generation procedure for calling a function.

FIG. 12 is a flowchart showing a procedure for generating a code for function definition.

FIG. 13 is a flowchart showing a code generation procedure for conditional branching.

FIG. 14 is a flowchart showing a code generation procedure for an unconditional branch.

FIG. 15 is a flowchart showing a label code generation procedure.

FIG. 16 is a flowchart showing a procedure for merging reproduction information tables.

FIG. 17 is a flowchart showing a reproduction information table adjustment procedure for repetitive processing.

FIG. 18 is a code generation procedure for iteration processing (loop /
It is a flowchart which shows (when using a counter).

FIG. 19 shows a code generation procedure for iterative processing (loop
It is a flowchart which shows (when a log is used).

FIG. 20 is a flowchart showing a code generation procedure for a program sequence.

FIG. 21 is a flowchart showing the code generation procedure of the entire program.

FIG. 22 is a flowchart showing the processing contents of _SAVE processing.

FIG. 23 is a flowchart showing the processing contents of _RESTORE processing.

FIG. 24 is a flowchart showing the processing contents of _PEEK processing.

FIG. 25 is a flowchart showing the processing contents of _INVALIDATE processing.

FIG. 26 is a flowchart illustrating a processing procedure of _INTERRUPT_START processing.

FIG. 27 is a flowchart illustrating a processing procedure of _INTERRUPT_END processing.

FIG. 28 is a diagram showing a data structure of a correspondence table.

FIG. 29 is a flowchart showing the processing procedure of the failure analysis means (debugger).

[Explanation of symbols]

0101 central processing unit (processor), 0103 memory, 0104 forward program, 0105 backward program, 0106 failure analysis means (debugger), 0107 data area, 0108 log area, 0109 interrupt log area, 0110 control terminal, 0201 source program, 0202 whole compiler, 0203 source read processing, 0204
Lexical analysis processing, 0205 Syntax analysis processing, 0206
Syntax tree optimization processing, 0207 forward program code generation processing, 0208 backward program code generation processing, 0209 code optimization processing, 0210 code output processing, 0211 correspondence relation table output processing, 0212
Compile result file (execution program), 02
13 forward program, 0214 reverse program, 0215 correspondence table, 2801 correspondence table, 2802 source program row information, 2
803 Forward program address, 2804 Reverse program address.

Claims (2)

[Claims] 1. When a source program (source code) is translated (compiled), a log generation process is embedded in a translation result and a backward direction program is generated, and the log information generated at the time of executing the program is used as an input in the backward direction. A software failure analysis method characterized by executing a program in the reverse direction to restore the past state of the program. 2. A compiler that embeds a log generation process in a translation result and generates a backward program when a source program (source code) is translated (compiled), and a log information generated when the program is executed as input. A software failure analysis apparatus comprising: a failure analysis means (debugger) for executing a backward direction program to reversely execute the program and restore the past state of the program.