JPH11110256A - Device and method for debugging program, and computer readable recording medium recorded with the method for the same - Google Patents

Abstract

PROBLEM TO BE SOLVED: To debug a program by generating an object file so that the debugging object and the final object are managed with the same execution object a mem ory of target machine side is not burdened in debugging. SOLUTION: An object file 24 generated by a compiler 21 based on a source file 23 is divided into a debug script file activated in debugging, an execution object file which does not include a debug script, and a symbol table of debug script activation information relating the debug script with a position of a source line. In downloading the execution object file in a target machine 11, executing this file and debugging it, when an execution of the program reaches the debug script part, a debugger 22 executes a debug script file on a host machine on the basis of debug script activation information and executes a debug.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compiler for developing a computer program, a program debugging device having a debugger, a program debugging method, and a computer-readable recording medium recording the method.

[0002]

2. Description of the Related Art Conventionally, in developing an application of an embedded system, when debugging a program on a target system, an error check routine is incorporated and debugging is performed. When releasing a program, an error check is performed. In many cases, code without routines was generated anew.

In this case, recompilation is required and the development efficiency is low. In addition, there is a problem in property management due to the difference between the program itself at the time of debugging and the release at the time of the presence or absence of an error check routine, and a problem that more memory is required at the time of debugging because the error check routine is included.

In general, when writing a program, a program developer often creates the program in consideration of debugging. Specifically, an error check routine is often included in the source file. And compile with this enabled in the compile options,
Create and debug an executable.

When the debugging is completed, a final program is generated by invalidating such code and compiling. In particular, there are many cases where it is desired to finally eliminate the error processing routine in a program for an embedded product.

In many debuggers, a script can be described and a new debug command can be described, but is independent of a source program.
If a specific image is described in a pseudo language, the following code will be described by the developer.

[0007] After DEBUG is turned on (compiled) to generate an object and debugging is completed, DEBUG is turned off and the object is generated again (compiled) to create a final property.

[0008] In this case, the object at the time of debugging is different from the final object, which causes a management problem and requires recompilation, resulting in poor development efficiency. Also, at the time of debugging, since more code is included than the final program, more memory is required even temporarily. This can be problematic for embedded products with strict memory restrictions.

[0009]

In order to solve the problems as described above, it is desirable to provide the following development environment. 1. The property at the time of debugging and the final property can be managed with the same execution object.

[0010] 2. Make sure there is no memory load on the target machine during debugging. These development environments are realized by changing the parts related to the compiler and the debugger from the conventional one.

Therefore, the present invention has been made in view of the above circumstances, and describes a script description for debugging or a description (mainly error checking, etc.) in a program description language.
It can be described in the source file, the compiler automatically extracts it, saves it in the object file, and automatically writes the debug script or By executing the description in the program description language (mainly error checking etc.), the property at the time of debugging and the final property can be handled as the same object file, and the code for debugging in the case of cross development And a program management method capable of avoiding loading of a program into a target machine, and a computer-readable recording medium recording the method.

[0012]

According to the present invention, in order to achieve the above object, a program debugging apparatus according to the present invention includes a source file including a debug script describing processing executed only at the time of execution of a program. An object file including an execution object file which is a normal program part, a debug script file which is the above debug script part, and a symbol table having debug script activation information for associating the position of a source line of the above source file with the above debug script. Compiler to be compiled, debug specification means for specifying whether to enable the debug script at the time of debugging, and, when the debug script is enabled by the debug specification means, the execution object file A determining means for determining that the control of the program has reached the debug script at the time of execution, and responding based on the debug script activation information when determining that the control of the program has reached the debug script. And executing the debug script file described above.

With this configuration, the program at the time of debugging and the final program can be handled as the same object file. Also, since the code for debugging is managed as a separate object file, it is possible to avoid loading the code for debugging into the target machine. Further, the same effect can be obtained by replacing the compiler having the above configuration with an interpreter. The same effect can be obtained by replacing the debug script with the log output code and using the log output code at the time of debugging.

[0014]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be described below with reference to the drawings. (First Embodiment) FIG. 1 is a block diagram showing a system configuration as a premise of an embodiment of the present invention.

Here, the machine on which the program to be debugged runs is called the target machine 11, and the machine that develops (generates) the program is called the host machine 10. Although both may be the same hardware, it is assumed here that a program that operates on the target machine 11 is developed using a separate host machine 10 as described below. Although not particularly shown, both of them naturally have a configuration provided in an ordinary computer, such as an auxiliary storage device such as a CPU, a memory, and an HDD, a display device, and a communication unit. And both are LAN (Local Area Net)
work) or a communication medium such as a serial or the like, for example, a network 12, and transmits and receives data to and from each other.

Referring to FIG. 2, the configuration on the host machine 10 will be described. In the host machine 10, the program source (source file) 23 is compiled by the compiler 21. Then, the created object file 24
Thus, the debugger 22 on the host downloads the execution image to the target machine 11 via the network 12.

The debugger 22 allows the user to perform symbolic debugging on the host machine 10 by taking in the symbol information of the program. The source file 23 described by the user can include a “debug script” in addition to a normal program. This guarantees that the debug script is executed when the program reaches a corresponding part by an option during debugging. If this option is not specified, this part will not be executed at all.

In this tool, a compiler defines a section for storing a debug script in a normal object file 24. As a result, the compiled object file 24 includes a section of an ordinary program execution object file including a section (text section) corresponding to program code, a section (data section) corresponding to data, and the like, and an object file of a debug script. And a symbol table including debug script activation information for associating the debug script with the position of the source line.

When a debug script is not used, the debugger 22 has the same appearance as a normal remote debugging system. Even when the debug script option is specified, the function of downloading the program to the target machine 11 is exactly the same.

With reference to FIG. 3, the configuration of the target machine 11 will be described. In the present embodiment, a target monitor 31 that is often used in a normal target system is assumed, but is not essential. The target monitor 31 has a communication function with the host machine 10, and notifies the host machine 10 when an exception occurs due to a break instruction during debugging. Reference numeral 32 denotes a target program (object file) downloaded from the host machine 10.

Next, the language processing system on the host side will be described. The user program assumes the presence of a normal high-level programming language and a compiler for this language. Although not particularly shown, the compiler includes a syntax analyzer, an optimizer, a code generator, and the like. Among them, the syntax analyzer is mainly relevant in the present embodiment.

The syntax analyzer separates and processes the debug script part and the part that is not. This identification is performed by embedding a “compiler designator” in the source file when the program developer creates the source file. As a concrete example of the debug script,
"The same language as the source program itself (in some cases,
Describing by grammar subset), or "description consisting of debugger commands", or a mixture of the above.

In the C-language-like expression, a debug command portion and the like are described in a source file description using a compile indicator as follows. The syntax analysis unit of the compiler performs this part differently from a normal program.

In the following example, the compile indicator is "#if
def debug_by_command. . .
#Endif ""#ifdef debug_by_C
. . . #Endif ". These are not the original description of the program but the operation instructions to the compiler when compiling.

In this example, the compiler determines "#ifde
When "f debug_by_command" is found, it is recognized as a debug command, not an ordinary program, and is processed. Similarly, “#i
If "fdef debug_by_C" is found, it recognizes that it will be translated into a debug command. func (int a, int b) {int c; #ifdef debug_by_command // debugger command from here watch a // debugger command example print a #endif #ifdef debug_by_C // check C language // → convert to debug command c = convert (a, b); // → Convert to function temporary execution command // call $ 1 = check (a, b) // set c = $ 1 if (a> b) printf ("error: a =% d \ n ", a); // → Convert to expression evaluation: // set $ 2 = a // set $ 3 = b // if ($ 2> $ 3) call printf // (" error: a =% d \ n ", a) #endif c = .... ....} As described above, the" compiler specifier "specifies the type of the description language. Now, assume that the type is the same programming language and debugger command as the source. In the case of the same programming language as the source, this is automatically converted to a debugger command.

Referring to FIG. 4, the flow of the above-described source file compiling process on the host machine 10 will be described. When compiling the source file 23 with the compiler 21, first, the compiler 21 determines whether or not the compiler designator is a language description (step A1).

If it is a language description (yes in step A1)
s), a conversion routine to a debug script is called (step A4), and a debug script section is defined and translated (step A5). If it cannot be converted to the debug script, the process ends as an error process (step A6).

If it is not a language description (n in step A1)
o) Then, it is determined whether or not the compiler designator is a debug command (step A2). If the compiler specifier is a debug command (Yes in step A2), a debug script section is defined and translated (step A5). If the compiler designator is not a debug command (No in step A2), the process is the same as the conventional process (step A3).

FIG. 5 is a conceptual diagram of object file generation by compiling the source file 23 on the host machine 10. An object file generated by compiling a source file 50 which is an example of the source file 23 by the compiler 21 includes an execution object file 51 and a debug script file 5
2. The symbol table 53 is divided into three parts.

The execution object file 51 is a section of the execution object file that does not include the debug script part. Debug script file 52
Is a script file section for a debugger which is an object file of a debug script, and is used at the time of debugging. The symbol table 53 is a section of a file containing symbol information. The symbol information is, for example, mapping information between a source line used when activating a debugger script and a location of an execution object file corresponding to the source line.

Then, only the section, which is the object file 51, is loaded into the target machine 11. Next, an operation at the time of debugging on the host machine 10 will be described.

First, the flow of a normal breakpoint designation process will be described with reference to FIG. What is a breakpoint?
This is a point for the debug operator to interrupt the execution of the execution object file as needed during debugging, and a break instruction is inserted into the execution object file to indicate this breakpoint. The debugging in this example is performed on the execution object file 51 generated by compiling the source file 50. At this time, the debug script file 52 and the symbol table 53 are referred to.

The break point is specified by the debug operator by specifying the source line corresponding to the break point (step B1). Based on the symbol information in the symbol table 53 (here, the mapping information between the source line and the location of the execution object file 51 corresponding thereto), the debugger 22 of the host sets the location of the execution object file 51 corresponding to the specified breakpoint in the Write a break instruction (step B2). At this time, the original instruction at the location of the execution object file 51 into which the break instruction specified in step B1 has been written is stored in the memory of the debugger 22 (step B3).

Next, with reference to FIG. 7, the flow of a normal break point clearing process will be described. The debugger operator releases the break point (step C1). The debugger 22 writes the original instruction stored in the memory at the location of the break instruction in the location of the break instruction of the released break point in the execution object file 51 (step C2). As a result, even if the instruction at this location is executed, no exception occurs due to the break instruction.

In this embodiment, when the execution of the execution object file 51 on the target machine 11 at the time of debugging, when the processing of the program reaches the break instruction inserted in the execution object file 51, this break instruction corresponds to the debug script. If so, the debug script corresponding to this breakpoint is executed from the debug script file 52 on the host machine 10 based on the symbol information of the symbol table 53 on the host machine 10 to perform debugging.

The instruction by the debug operator to enable or disable the debug script will be described below. First, the flow of the debug script enabling process will be described with reference to FIG. The debug operator specifies to enable the debug script (step D1). When the debug script validation is specified, the debugger 22 checks a corresponding location of the execution object file 51 for each debug script from the symbol table 53 and writes a break instruction there (step D2). As a parameter of the break instruction, I for each debug script
A debug script ID indicating D is inserted. At step D2, the original instruction at the corresponding location in the execution object file 51 is stored in the memory of the debugger (step D3).

Next, the flow of the debug script invalidating process will be described with reference to FIG. The debug operator specifies the invalidation of the debug script (step E1). When the debug script invalidation is specified, the debugger 22
Finds the corresponding location of the execution object file 51 for each debug script from the symbol table 53, and replaces the original instruction at that location copied to the location of the corresponding break instruction into the storage area of the debugger. Is written (step E2). Thus, at the time of debugging, a break exception due to a break instruction does not occur and the debug script is ignored.

Referring to FIG. 10, the flow of the processing at the time of debugging will be described. When the execution object file 51 is executed on the target machine 11 at the time of debugging, when the program reaches a break instruction (step F1), a normal C
An exception occurs in the PU. The exception also occurs at the time of interruption from the outside, division by zero, or the like. When this occurs, the CPU stops execution of the current program and jumps to an exception handler (not shown).

In the exception handler, what kind of exception has occurred and jumped here is determined by referring to a register of the CPU and the like, and jumps to each sub-routine. When an exception occurs, it is notified to the target monitor 31 if it is found that the exception was caused by a “break instruction”. The target monitor 31 notifies the debugger 22 of the host machine 10 that a break has occurred by using a built-in communication function.

Since the debugger 22 of the host machine 10 knows that a breakpoint has been set, the target machine 1
1 is displayed on the display device.

The target monitor 31 is connected to the next debugger 2.
Wait for command from 2. Here, first, the debugger 22 on the host machine 10 determines whether or not the occurred exception is a debug exception (Step F2).

If it is not a debug exception (No in step F2), normal exception processing is executed (step F6), and the process ends. If it is a debug exception (yes in step F2)
s) It is determined whether or not it is compatible with a debug script (step F3).

If the debug script is not supported (No in step F3), normal debug exception processing is executed (step F7), and the process ends. If the debug script is supported (yes in step F3), the debugger 22
Checks the debug script ID, executes each debugger command from the debug script file 52 on the host machine 10 based on the symbol information in the symbol table 53 (step F4), and returns from the exception processing (step F5). After returning from the exception processing, the program is continuously executed.

By doing as described above, the program at the time of debugging and the final program can be handled as the same object file, and loading of the code for debugging into the target machine can be avoided.

In the above-described first embodiment, a compiler is assumed. However, an interpreter method can be similarly used. Also, a plurality of types of programming languages can be assumed. Furthermore, the type of description is determined based on the type of the compilation indicator. However, it is conceivable that the compiler automatically determines the type of description.

A predetermined description, for example, if the function name and the variable name are d
ebug_. . . Expressions containing, and statements containing them are automatically converted to debug commands. Examples include the following. func (int a, int b) {int c; debug_watch a // Process as debug command: watch a debug_print a // Process as debug command: print a printf ("% d \ n", c); // Normal program C = debug_convert (a, b); // process as a debug command: // call $ 1 = check (a, b) // set c = $ 1} (Second Embodiment) Next, the present invention will be described. A second embodiment will be described.

This embodiment can be considered as a part in which the part corresponding to the debug script in the first embodiment is replaced with a code output as a log at the time of debugging.

FIG. 11 is a conceptual diagram of compiling a source file 70, which is an example of a source file according to the present embodiment, to generate an object file. Source file 7
0 is compiled by the compiler, the generated object file is an execution object file 71,
The log script file section 72 and the symbol table 73 are divided into three parts.

The execution object file 71 is a section of the execution object file that does not include the debug script part (code output as a log in this case). The log script file section 72 is a script file section for a debugger, and the log output is used for debugging.

The symbol table 73 is a section of a file containing symbol information. What is symbol information?
For example, it is mapping information of a source line used when starting a log which is a script for a debugger and a location of an execution object file corresponding to the source line.

The process of enabling / disabling log output according to the present embodiment is performed by enabling the debug script according to the first embodiment.
It can be handled in the same way as the invalidation processing. When the log output is enabled, when the program reaches a breakpoint of the log output instruction, a log output corresponding to the log output instruction can be selected from the log script file section 72 and executed to perform debugging.

[0052]

As described in detail above, according to the present invention, the property at the time of debugging and the final property can be handled as the same object file, and the loading of the code for debugging into the target machine is avoided. by doing,
The required memory amount of the target machine can be suppressed. In addition, source files and debugging scripts can be managed collectively. As a debug script, the language that describes the program itself can be used, and from the viewpoint of the programmer (program developer), there is no need to be aware that it is translated into a debug command and executed. To play.

[Brief description of the drawings]

FIG. 1 is a diagram showing a schematic configuration of an apparatus according to a first embodiment of the present invention.

FIG. 2 is an exemplary conceptual view showing components on the host machine according to the embodiment.

FIG. 3 is a conceptual diagram showing components on a target machine according to the embodiment.

FIG. 4 is an exemplary flowchart showing the flow of a source file compiling process according to the embodiment;

FIG. 5 is an exemplary conceptual view of an object file generated by compiling a source file according to the embodiment;

FIG. 6 is an exemplary flowchart showing the flow of a normal breakpoint designation process according to the embodiment;

FIG. 7 is an exemplary flowchart showing the flow of normal breakpoint release processing according to the embodiment;

FIG. 8 is a flowchart showing a flow of a debug script enabling process according to the embodiment;

FIG. 9 is an exemplary flowchart showing the flow of a debug script invalidating process according to the embodiment;

FIG. 10 is an exemplary flowchart showing the flow of a process during debugging according to the embodiment;

FIG. 11 is a conceptual diagram of an object file generated by compiling a source file according to the second embodiment of the present invention.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 10 ... Host machine 11 ... Target machine 12 ... Network 21 ... Compiler 22 ... Debugger 23 ... Source file 24 ... Object file 31 ... Target monitor 32 ... Downloaded target program

Claims (27)

[Claims] 1. A source file including a debug script describing a process to be executed only at the time of execution of a program during execution of a program includes an execution object file as a normal program portion, a debug script file as the debug script portion, and a A compiler that compiles an object file including a symbol table having debug script startup information for associating the position of a source line of a source file with the debug script, and a debug designating unit that specifies whether to enable the debug script during debugging And when the debug script is enabled by the debug designating means, when executing the execution object file, determining that program control has reached the debug script. And a step of executing the corresponding debug script file based on the debug script activation information when the determining means determines that the control of the program has reached the debug script. Debug device. 2. The program debugging device according to claim 1, wherein the compiler identifies and compiles the debug script according to a predetermined description when compiling the source file. 3. The source file is described with an identifier that allows the debug script to be grammatically distinguished from another program description part in the same language as another program. 2. The program debugging device according to claim 1, wherein the debug script is identified by the identifier and compiled. 4. The debug designating means, when the debug script is enabled, writes an instruction capable of identifying the debug script in a corresponding position of the execution object file based on the debug script activation information. 4. The program debugging device according to claim 1, wherein it is determined that control of the program reaches the debug script based on the command. 5. A source file including a debug script describing a process to be executed only at the time of execution of a program at the time of execution of a program includes an execution object file as a normal program part, a debug script file as the debug script part, An interpreter that translates and executes, at predetermined steps, an object file including a symbol table having debug script activation information for associating the position of the source line of the source file with the debug script, and whether to enable the debug script at the time of debugging Debug specification means for specifying whether or not the debug script is enabled by the debug specification means. When the execution object file is executed, program control reaches the debug script. A determination unit that, when the control program to the debug script determines that it has reached this decision means, a program debugging device for executing the debugging script file corresponding based on the debug script activation information. 6. The program debugging apparatus according to claim 5, wherein the interpreter identifies, translates and executes a debug script by a predetermined description when translating the source file. 7. The source file is described with an identifier by which the debug script can be grammatically distinguished from another program description part in the same language as another program. The interpreter reads the source file when translating the source file. 6. The program debugging apparatus according to claim 5, wherein said debug script is identified by said identifier, translated and executed. 8. The debug designator, when the debug script is enabled, writes an instruction capable of identifying the debug script in a corresponding position of the execution object file based on the debug script activation information. 8. The program debugging device according to claim 5, wherein it is determined that the control of the program has reached the debug script based on the command. 9. A source file including a log script which is a code for outputting a log when a program is executed,
An object file including an execution object file which is a normal program part, a log script file which is the log script part, and a symbol table having log script activation information for associating a position of a source line of the source file with the log script. A compiler that compiles the log script, and a debug specification unit that specifies whether to enable the log script during debugging. If the log script is enabled by the debug specification unit, the execution object file is executed when the log script is enabled. Judging means for judging that the control of the program has reached the log script; and determining, by the judging means, that the control of the program has reached the log script, the log corresponding to the log script start information. Program debugging device to run the script file. 10. The program debugging device according to claim 9, wherein the compiler identifies and compiles a log script based on a predetermined description when compiling the source file. 11. The source file is described with an identifier that allows the log script to be grammatically distinguished from another program description part in the same language as another program, and the compiler is configured to compile the source file when compiling the source file. 10. The program debugging device according to claim 9, wherein the log script is identified by the identifier and compiled. 12. The debug designating means, when the log script is enabled, writes an instruction capable of identifying the log script in a corresponding position of the execution object file based on the log script activation information. 12. The program debugging device according to claim 9, wherein it is determined that control of the program has reached the log script based on the command. 13. A source file including a debug script describing processing to be executed only at the time of execution of a program at the time of execution of a program includes an execution object file which is a normal program part, a debug script file which is the debug script part, and Compile into an object file that contains the location of the source line in the source file and a symbol table that has debug script startup information that associates the debug script with the above. Specify whether or not to enable the debug script during debugging. When the script is enabled, when the execution object file is executed, it is determined that the program control has reached the debug script, and it is determined that the program control has reached the debug script. And executing the corresponding debug script file on the basis of the debug script activation information. 14. The program debugging method according to claim 13, wherein when compiling said source file, said debug script is identified and compiled by a predetermined description. 15. The source file is described with an identifier that allows the debug script to be grammatically distinguished from another program description part in the same language as another program, and is used when compiling the source file. 14. The program debugging method according to claim 13, wherein the debugging script is identified and compiled. 16. When the debug script is enabled, an instruction capable of identifying the debug script is written in a corresponding position of the execution object file based on the debug script activation information, and the program is added to the debug script based on the instruction. 16. The program debugging method according to claim 13, wherein it is determined that the control has been reached. 17. A source file containing a debug script describing a process to be executed only at the time of execution of a program at the time of execution of a program includes an execution object file which is a normal program part, a debug script file which is the debug script part, and Translated and executed for each predetermined step into an object file including a symbol table having debug script startup information for associating the position of the source line of the source file with the debug script, and determine whether to enable the debug script at the time of debugging. If the specified debug script is enabled and the execution of the execution object file is executed, it is determined that the program control has reached the debug script, and the program control has reached the debug script. A program debugging method, comprising: executing a corresponding debug script file based on the debug script activation information when it is determined that the debug script file is reached. 18. The method according to claim 17, wherein, when translating the source file, a debug script is identified by a predetermined description, translated and executed. 19. The source file is described with an identifier by which the debug script can be grammatically distinguished from another program description part in the same language as another program, and is used when translating the source file. 18. The program debugging method according to claim 17, wherein the debugging script is identified, translated, and executed. 20. When the debug script is enabled, an instruction capable of identifying the debug script is written in a corresponding position of the execution object file based on the debug script activation information, and the program is added to the debug script based on the instruction. 20. The program debugging method according to claim 17, wherein it is determined that control has been reached. 21. A source file containing a log script, which is a code for outputting a log when a program is executed, includes an execution object file which is a normal program part, a log script file which is the log script part, and the source file Compiles into an object file that contains the location of the source line of the log script and a symbol table with log script startup information that associates the log script, specifies whether to enable the log script during debugging, and enables the log script. When executing the execution object file, it is determined that the control of the program has reached the log script.When it is determined that the control of the program has reached the log script, the log script startup information is included. Respond based on A program debugging method for executing the above log script file. 22. The program debugging method according to claim 21, wherein a log script is identified and compiled according to a predetermined description when compiling the source file. 23. The source file is described with an identifier by which the log script can be grammatically distinguished from another program description part in the same language as another program, and is used when compiling the source file. 22. The program debugging method according to claim 21, wherein the log script is identified and compiled. 24. When the log script is enabled, an instruction capable of identifying the log script is written in a corresponding position of the execution object file based on the log script activation information, and a program is stored in the log script based on the instruction. 3. The control system according to claim 2, wherein it is determined that the control has been reached.
24. The program debugging method according to any one of 1 to 23. 25. A source file including a debug script describing a process to be executed only at the time of execution of a program at the time of execution of a program includes an execution object file which is a normal program part, a debug script file which is the debug script part, and Compile into an object file that contains the location of the source line in the source file and the symbol table that has the debug script startup information that associates the above debug script, and specify whether or not to enable the above debug script during debugging. If enabled, determine that program control has reached the debug script when executing the execution object file, and determine that program control has reached the debug script. A computer-readable recording medium storing program information of a program debugging method for executing the debug script file corresponding to the debug script start information when the program is activated. 26. A source file including a debug script describing a process to be executed only at the time of execution of a program at the time of execution of a program includes an execution object file which is a normal program part, a debug script file which is the debug script part, and Translates and executes every predetermined step into an object file including a symbol table having debug script startup information for associating the position of the source line of the source file with the debug script, and whether to enable the debug script at the time of debugging When the above debug script is enabled, when the execution object file is executed, it is determined that the control of the program reaches the debug script, and the control of the program is transmitted to the debug script. A computer-readable recording medium storing program information of a program debugging method for executing a corresponding debug script file based on the debug script activation information when it is determined that the program has arrived. 27. A source file containing a log script, which is a code for outputting a log when a program is executed, includes an execution object file, which is a normal program part, a log script file, which is the log script part, and the source file. Compiles into an object file that contains the location of the source line of the log script and a symbol table with log script startup information that associates the log script, specifies whether to enable the log script during debugging, and enables the log script. When executing the execution object file, it is determined that the program control reaches the log script, and when it is determined that the program control reaches the log script, the Respond based on A computer-readable recording medium storing program information of a program debugging method for executing the log script file.