JP2010287101A - Software debugging device and method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a software debugging device and method for correctly displaying a call stack when tail call optimization is performed by using a break point during debugging of software without interrupting execution every time function call is made. <P>SOLUTION: A source program is prepared with the function name of each function in an execution image program and address information as a symbol table in accordance with debug information obtained with the execution image program by compile processing, instructions of program codes are executed in order of the program codes of the execution image program, the program code of a branch instruction is stored in a trace memory while including an operant in it when the execution instruction is the branch instruction, and a call stack showing hierarchy of function calls is prepared and displayed in accordance with correspondence relation between the operant of the trace memory and the address information of the symbol table. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a software debugging apparatus and method for acquiring a history of functions executed at a high-level language level in software debugging.

  During software debugging, the function of the call stack is used to know from which function a function executing processing is called at an arbitrary point during program execution. The call stack is a function that displays a hierarchy of function calls from the start of program execution until the currently executing function is called.

  For example, in a C language program, when three functions main, func1, and func2 are defined as shown in FIG. 1, the functions are called in order of main → func1 → func2 when the program is executed.

  When debugging this program at the source code level, if the debugger call stack window is opened while func2 is running, the debugger displays the hierarchy of function calls until func2 is called, as shown in Figure 2, and is currently running. The function inside is marked with an arrow and displayed, for example.

  In general, in order to display such call stack information, the debugger needs to analyze the contents of the stack. As an example, the stack operation and its analysis method in the execution of the program as shown in FIG.

  First, the compiler outputs an assembly code as shown in FIG. 3 for the source code as shown in FIG. In this assembly code, the bl instruction is an instruction for executing a function call. By this instruction, branching to the head address of the function and setting of the return address in the link register lr are performed. There is a “push lr” instruction at the beginning of main and func1, but this is an instruction to save the contents of the link register lr on the stack because the link register lr is overwritten by the bl instruction executed thereafter. Also, after this instruction, before entering the processing of each function, an area for local variables and an area for saving work registers used by each function are secured in the stack. Thus, an area secured in the stack for use by each function is called a stack frame. The stack frame size of each function can be known from debug information output together when the compiler generates assembly code. The functions are called in the order from main to func1 → func2, and the contents of the stack are as shown in FIG.

  When displaying the call stack, the debugger reads the value of the program counter (PC), and since the content is an address in the function of func2, it can know that func2 is being executed. Next, it can be seen from the debug information of func2 output by the compiler that the return address of func2 is stored in the link register lr, so the return address is read from lr. By examining which function the return address is in, it can be known that func2 is called from func1.

  Further, by examining the debug information of func1, it can be seen that the return address of func1 is saved in the stack. The saved address in the stack can be calculated by subtracting the stack frame sizes of func1 and func2 from the address pointed to by the current stack pointer. When the return address of func1 is read from the calculated address, it can be seen that the address is an address in the main function, and that func1 is called from main. In this way, the debugger displays the call stack as shown in FIG.

Japanese Patent Application Laid-Open No. 11-065885

  However, in the above method, when the output assembly code is optimized by the compiler, the call stack may not be displayed correctly.

  An example of a case where the call stack cannot be displayed correctly is "optimization of tail call" of a function by a compiler.

  The tail call optimization is an optimization performed when the function func2 is called at the end of the function, like the function func1 in FIG. Since the call to func2 is performed at the end of func1, even if the process of func2 is finished and the process returns to func1, it only returns to main after that. Therefore, the compiler discards the stack frame of func1 and calls func2 before calling func2, so that it returns directly to main without returning from func2 to func1. A branch instruction (b instruction) that does not set the return address in the link register lr is used as the branch instruction for executing the call to func2. That is, the value of the link register lr set when the func1 is called from the main remains stored in the link register lr. When returning from func2, the value of this link register lr is used as a return address, so that it is possible to return directly to main without returning to func1, thereby reducing the processing time overhead for returning to func1. The assembly code when this tail call optimization is performed is shown in FIG.

  In the assembly code as shown in FIG. 5, the contents of the stack that is executing func2 are as shown in FIG.

  When displaying the call stack in this state, the debugger first reads the value of the program counter (PC) and knows that func2 is being executed because its contents are the address in the function of func2. Can do. Next, it can be seen from the debug information of func2 output by the compiler that the return address of func2 is stored in the link register lr, and the return address is read from the link register lr. By examining which function the return address is in, it is possible to know the function of the caller. However, when optimization is performed as shown in FIG. 5, the function func2 is executed. In this state, the address stored in the link register lr is the address in the main function. Therefore, in such a case, since the debugger determines that func2 is called from main, information that func1 is called is output to the call stack between main and func2 calls. The problem of disappearing occurs. The call stack display at this time is as shown in FIG.

  In this way, when optimization of the tail call of the compiler is performed, even though func2 is actually called from func1, the information is missing, so the call stack is changed. If debugging is performed, it becomes a factor of reducing the efficiency of debugging work.

  As a method of displaying a call stack correctly when optimization by a compiler is performed, there is a conventional method described in Patent Document 1. This conventional method is a method in which software breakpoints are set at the start and end addresses of all functions, and function information is acquired when a break occurs at each breakpoint.

  However, this conventional method has another problem that the real-time property is impaired during execution during debugging because the execution is interrupted by breaking each time a function call occurs during program execution.

  Accordingly, an object of the present invention is to correctly display a call stack when tail call optimization is performed without interrupting execution for each function call using a breakpoint during software debugging. A software debugging apparatus and method is provided.

  A software debugging device according to claim 1 of the present application is a software debugging device that compiles a source program and debugs an execution image program generated together with debugging information, according to the debugging information. Symbol table creation means for creating function name and address information for each function in the execution image program as a symbol table, program execution means for executing program code instructions in order of program codes of the execution image program, and program execution means When the execution instruction is a branch instruction, the trace means for storing the program code of the branch instruction in the trace memory including the operand, and the correspondence between the operand of the trace memory and the address information of the symbol table It is characterized by and a call stack display means for displaying it to create a call stack showing the hierarchy of function calls in accordance with the.

  The software debugging method of the invention according to claim 4 of the present application is a software debugging method for performing a debugging process of an execution image program generated by compiling a source program together with debugging information, according to the debugging information. A symbol table creating step for creating function name and address information for each function in the execution image program as a symbol table, a program execution step for executing program code instructions in the program code order of the execution image program, and the program execution step A trace means for storing the program code of the branch instruction in the trace memory including the operand when the execution instruction by the branch instruction is a branch instruction, and the address information of the operand of the trace memory and the symbol table It is characterized by and a call stack display step of displaying it by creating a call stack showing the hierarchy of function calls in accordance with the corresponding relationship between the.

  In the software debugging device according to claim 5 of the present application, a first pseudo instruction indicating that there is a function call is arranged immediately before a branch instruction of a function call, which is generated together with debug information by compiling a source program. When the optimization of tail call is applied among the function calls, the software debug device performs debugging processing of an execution image program in which a second pseudo instruction is arranged instead of the first pseudo instruction. A symbol table creating means for creating function name and address information for each function in the execution image program according to the debug information as a symbol table; and program execution for executing program code instructions in the order of the program code of the execution image program Means and static for the source program A function call tree creating means for creating a function call tree indicating a function calling relationship by performing analysis, the first pseudo instruction and the second pseudo instruction in the execution image program, the function call tree and the symbol table A return address table creating means for creating a return address table composed of a function to which the tail call optimization is applied, a return source function and a return address, and stored in the link register by instruction execution by the program executing means Call stack display means for creating and displaying a call stack indicating a hierarchy of function calls according to a return address and the return address table is provided.

  In the software debugging method of the invention according to claim 9 of the present application, a first pseudo-instruction indicating that there is a function call is placed immediately before a branch instruction of a function call, which is generated together with debug information by compiling a source program. And a software debugging method for debugging an execution image program in which a second pseudo instruction is arranged instead of the first pseudo instruction when tail call optimization is applied among the function calls. A symbol table creation step for creating function name and address information for each function in the execution image program as a symbol table in accordance with the debug information, and program execution for executing program code instructions in the order of the program code of the execution image program Step and the source program A function call tree creating step for creating a function call tree indicating a function calling relationship by performing static analysis, the first pseudo instruction and the second pseudo instruction in the execution image program, and the function call tree array A return address table creation step for creating a return address table composed of a function to which the tail call optimization is applied based on a symbol table, a return source function and a return address thereof, and an instruction execution by the program execution step. A call stack display step of creating and displaying a call stack indicating a hierarchy of function calls according to the stored return address and the return address table.

  According to the software debugging apparatus of the invention according to claim 1 of the present application and the software debugging method of the invention according to claim 5, when the execution instruction of the program code is a branch instruction, the program code of the branch instruction is operated on Since it is stored in the trace memory and stored in the trace memory and the branch trace function is used, execution is interrupted for each function call during debugging even when the compiler performs tail call optimization. The call stack can be displayed correctly.

  According to the software debugging device of the invention according to claim 5 of the present application and the software debugging method of the invention according to claim 9, a function call tree that performs a static analysis on a source program and indicates a function calling relationship is provided. A first pseudo instruction in the execution image program, the second pseudo instruction, a function to which tail call optimization is applied based on a function call tree and a symbol table, a return source function, and a return address. A return address table is created. By using the return address stored in the link register and the symbol table or the return address table, even if tail call optimization is performed by the compiler, each function call during debugging Display the call stack correctly without interrupting execution Can.

It is a figure which shows the calling relationship of three functions defined in the program. It is a figure which shows the example of a display of the call stack in debugging. It is a figure which shows the output assembly code example of a compiler. It is a figure which shows the example of a stack frame. It is a figure which shows the output assembly code example of a compiler when the optimization of a tail call is implemented. It is a figure which shows the example of a stack frame when the optimization of a tail call is implemented. It is a figure which shows the example of a display of a call stack when the optimization of a tail call is implemented. It is a block diagram which shows the structure of a software debugging apparatus as 1st Example of this invention. It is a figure which shows the content of the symbol table. It is a figure which shows the content of the trace memory. It is a figure which shows the contents of the trace memory after returning from a function. It is a figure which shows the example of a display of the call stack after returning to a main function. It is a block diagram which shows the structure of a software debugging apparatus as 2nd Example of this invention. It is a figure which shows the calling relationship of three functions defined in the program. It is a figure which shows a function call tree. It is a figure which shows the output assembly code example of a compiler when the optimization of a tail call is implemented. It is a figure which shows a return address table.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.

  FIG. 8 shows the configuration of a software debugging apparatus as a first embodiment of the present invention. The software debug device includes a debugger 11 and a debug target 12. The debugger 11 includes a debugger control unit 21, a symbol table 22, and a call stack display unit 23.

  The debugger control unit 21 is connected to each of a symbol table 22 and a call stack display unit 23. The symbol table 22 includes a memory. The symbol table creation means includes a debugger control unit 21 and a symbol table 22.

  In addition, the debugger control unit 21 reads an execution image program (execution format program) 46 described later together with debug information 47, extracts a program code from the execution image program 46, and outputs the program code to the debug target 12. The debugger control unit 21 extracts a function from the read debug information 47 and stores (stores) the function name, the function start address, and the total size of the instruction code included in the function in the symbol table 22. The call stack display unit 23 displays the call stack on a display (not shown) in response to a command from the debugger control unit 21. The call stack display means includes a debugger control unit 21 and a call stack display unit 23.

  The debug target 12 includes a debug interface 31, a program memory 32, a program execution unit 33, and a trace memory 34. The debug interface 31 is connected to each of the program memory 32, the program execution unit 33, and the trace memory 34, and the program execution unit 33 is connected to each of the program memory 32 and the trace memory 34.

  The debug interface 31 is provided for input / output of information such as program code with the debugger control unit 21 of the debugger 11.

  The program memory 32 stores the program codes in the order of supply. The program execution unit 33 is a program execution unit, and executes the instructions of the program code stored in the program memory 32 in order. Further, the program execution unit 33 includes a tracing means for storing the instruction code of the executed branch instruction in the trace memory 34 including the operand information when the instruction is a branch instruction during program execution.

  In such a software debugging apparatus, information on a target branch trace is used when displaying call stack information. The branch trace is a function of storing the instruction codes of the executed branch instructions in the trace memory 34 in the order of execution when the program execution unit 33 executes the branch instructions during the program execution. With this function, the trace memory 34 stores the history data of the executed branch instruction.

  The debugger control unit 21 acquires the symbol table 22 included in the debug information 47 when the execution image program 46 is fetched together with the debug information 47, and the name and address of the function included in the execution image program 46 from the symbol table 22. The correspondence of is detected. Therefore, if the branch destination address is acquired from the operand of each branch instruction acquired from the trace memory 34 and the function specified by the address is included in the symbol table 22, it can be determined that the branch instruction is a function call. . If a branch instruction corresponding to a function call is detected from the trace memory 34, it can be interpreted as a function call history, and call stack information to be displayed is generated from the history information. The call stack information is supplied to the call stack display unit 23 and displayed.

  Next, a description will be given of a case in which a program in which tail call optimization is performed is debugged in such a software debugging apparatus.

  First, an execution image program 46 is generated from a C source file (C source program) 41 by a compiler 43, an assembler 44 and a linker 45 of a code generation tool 42, and the execution image program 46 is stored together with debug information 47. The compiler 43 generates an assembly program from the C source file 41, the assembler 44 converts the assembly program into an object file, and the linker 45 executes an execution image program 46 based on the object file obtained by the assembler 44. Generate. These code generation tools 42 are provided with so-called options so that debug information 47 is generated.

  The debugger control unit 21 of the debugger 11 extracts a program code from the execution image program 46. The extracted program codes are sequentially stored in the program memory 32 via the debug interface unit 31 of the debug target 12. A group of program codes stored in the program memory 32 is referred to as a program. At the same time, the debugger control unit 21 extracts a function from the debug information 47 of the execution image program 46 to form a function symbol table 22 as shown in FIG. The symbol table 22 includes information on the name of the function, the start address of the function, and the total size of instruction codes included in the function.

  After the program is stored in the program memory 32, the program execution unit 33 sequentially executes instructions in the program in response to a command from the debugger control unit 21 supplied via the debug interface unit 31. When the executed instruction is a branch instruction, the program execution unit 33 simultaneously stores the instruction code including the operand information in the trace memory 34. For example, the contents of the trace memory 34 when the execution of the program is interrupted (break) according to the operation to the debugger 11 during the execution of func2 are as shown in FIG.

  First, the debugger control unit 21 acquires the contents of the trace memory 34 and investigates whether the address value in the symbol table 22 in FIG. 9 is used as the operand of the branch instruction in the trace memory 34. That is, the correspondence between the operant in the trace memory 34 and the address information in the symbol table 22 is detected. In the case of the example of FIGS. 9 and 10, as a result of this investigation, the debugger control unit 21 indicates that the branch instruction at Index2 in FIG. 10 is a call to the function main, and the branch instruction at Index3 is a call to the function func1. Further, it can be detected that the branch instruction of Index4 is a call to the function func2. Since there is no index1 branch instruction whose operand address matches the value of the address in the symbol table 22, it can be determined that it is not a function call. The debugger control unit 21 displays the branch destination function names in descending order of the index of the branch instruction that has been determined to be a function call, so that the call stack display unit 23 displays the call stack as shown in FIG. Is displayed.

  Next, when the debugger operation is continuously executed and the program execution is broken when returning from func2 to main, it is assumed that the contents of the trace memory 34 are as shown in FIG.

  In the index memory 5 of the trace memory 34, an rt instruction that is a branch instruction for returning from the function func2 and information of the branch destination address are stored. When the debugger control unit 21 finds a return instruction from the function in the trace memory 34, the debugger control unit 21 checks the symbol table 22 in order to check which function range the return destination address is in. In the example of FIG. 11, the return destination address is 0x1020, which is included in the range from the information of FIG. 9 to the main function start address 0x1000 to the address advanced by the size 0x40.

  At this time, when displaying the call stack, the debugger control unit 21 examines the contents of the trace memory 34 in the same manner as described above, and determines the branch destination function name in descending order of the index of the branch instruction that can be determined to be a function call. Try to display them side by side. However, since it can be seen that the main function has been returned by the return instruction of Index5, the function call between Index2 and Index5 representing the main call (that is, func1 of Index3 and func2 of Index4) is already in the function. It can be considered that the execution has finished. Therefore, the call stack displayed on the call stack display unit 23 is displayed only for the main function as shown in FIG. 12 excluding the functions corresponding to Index 3 and Index 4 of the trace memory.

  As described above, according to the first embodiment, the tail call optimization of the compiler 43 can be optimized by using the branch trace function added to the debug target 12 and storing only the branch instruction in the trace memory 34. If done, the call stack can be displayed correctly. Also, since the function call history information necessary for displaying the call stack is acquired, the program is not broken at each function call, so that real-time performance during program execution is not impaired. Further, the branch trace function has an advantage that the information stored in the trace memory 34 is only a branch instruction and the capacity of the trace memory 34 can be reduced as compared with the normal trace function, and the cost does not increase greatly. .

  FIG. 13 shows the configuration of a software debugging apparatus as a second embodiment of the present invention. The software debug apparatus includes a debugger 11 and a debug target 12 as in the apparatus of the first embodiment shown in FIG. The debugger 11 includes a return address table 24 in addition to the debugger control unit 21, the symbol table 22, and the call stack display unit 23. The return address table 24 stores return addresses. The debugger control unit 21 and the return address table 24 constitute return address table creation means.

  The debug target 12 includes a debug interface 31, a program memory 32, and a program execution unit 33. The trace memory 34 is not provided.

  The software debugging apparatus includes a function call tree generation unit 13 and a function call tree memory 14. The function call tree generation unit 13 is a function call tree creation unit that statically analyzes the C source file 41 and outputs a call tree 14 representing a function calling relationship to the function call tree memory 15. The function call tree 14 is a representation of function calling relationships in a tree structure. For example, an output as shown in FIG. 15 is obtained as a function call tree 14 from a source program as shown in FIG. In the source program 41 shown in FIG. 14, func1 and func2 are called from the main2 function, and func2 is called from func1. This call relationship represents the call relationship on the C source program 41 before being optimized by the compiler 43.

  Further, in such a software debugging apparatus, the compiler 43 outputs a pseudo instruction indicating that the tail call optimization has been performed to the output assembly code of the function that has performed the tail call optimization. The debugger 11 can know which function is optimized for the tail call from the presence / absence of the pseudo instruction and the information of the function call tree, so that the call stack can be displayed correctly.

  Next, a description will be given of a case in which a program in which tail call optimization is performed is debugged in such a software debugging apparatus.

  First, an execution image program 46 is created from the C source file 41 by the compiler 43, assembler 44 and linker 45 of the code generation tool 42, and the execution image program 46 is stored together with debug information 47.

  Here, when the compiler 43 generates an assembly program from the C source program 41, as shown in FIG. 16, the pseudo instruction FUNCCALL (first pseudo instruction) indicating that there is a function call immediately before the branch instruction of the function call. An instruction) is arranged, and a TAILCALL pseudo instruction (second pseudo instruction) is arranged in a function call to which optimization of tail call is applied. These pseudo instructions are embedded in the execution image program 46 by the assembler 44 and the linker 45. On the other hand, the function call tree generator 13 performs a static analysis of the C source program 41 and outputs a function call tree.

  Next, as in the first embodiment, the debugger 11 downloads the program code from the execution image program 46 to the program memory 32 and extracts the function symbol table 22.

  At this time, the debugger control unit 21 investigates whether the program code in each function in the execution image program 46 has a TAILCALL pseudo instruction. In this investigation, when the TAILCALL pseudo-instruction is found, the debugger control unit 21 examines the function call tree 14 and detects a function that calls a function in which it exists.

  For the assembly code as shown in FIG. 16, the TAILCALL pseudo instruction is found in the program code of the func1 function. The function call tree 14 is searched for the function calling func1. In the example of FIG. 15, main2 corresponds to a function calling func1.

  Next, the debugger control unit 21 searches for the position (address) at which func1 is called in the program code of the main2 function that calls the func1 function having the TAILCALL pseudo instruction. This searches for a FUNCCALL pseudo-instruction representing a function call from main2, examines the operand (branch destination address) of the branch instruction immediately after that, and determines that the branch destination address is the address of func1 registered in the symbol table 22. If they match, it is understood that the branch instruction calls func1. If a branch instruction to func1 is found, the address immediately after that becomes the return address that should return from func1.

  However, since the tail call is optimized in practice, this return address can be interpreted as a return address from a function called by a branch instruction immediately after the TAILCALL pseudo instruction. In the example of FIG. 16, it is assumed that the return address is 0x1020. The function called by the branch instruction immediately after the TAILCALL pseudo-instruction is found to be a func2 function by searching the operand (branch destination address) of the branch instruction from the symbol table 22. Therefore, the return address 0x1020 is actually the return address from func2. Therefore, the debugger control unit 21 registers the address 0x1020, the actual return source function func2, and the function func1 for which tail call optimization has been performed, in the return address table 24. Accordingly, as shown in FIG. 17, the return address table registers the return address, the return source function func2, and the optimized func1.

  In this way, for all functions having the TAILCALL pseudo instruction, the function of the caller and the return address are registered in the return address table.

  After execution of the return address table creation, the debugger control unit 21 causes the program execution unit 33 to execute the program via the debug interface 31.

  For example, it is assumed that the program execution is interrupted (broken) by an operation on the debugger 11 during the execution of func2. Here, when displaying the call stack in response to the break, first, the debugger control unit 21 reads the return address from func2 from the link register lr as described in the section of the background art. Then, if the address stored in the link register lr is registered in the return address table 24 of FIG. 17, there has been a call to func1 before the func2 is called from the contents of the return address table 24. As can be seen, the debugger control unit 21 adds the call history of func1 to the call stack and obtains a display as shown in FIG. If the address stored in the link register lr is not registered in the return address table 24, the function in which function the return address is in the stack frame as shown in the background art section above. The function that was called is determined by examining.

  According to the second embodiment, since the function call tree generation unit 13 is added when the debug target 12 does not have the branch trace function as in the first embodiment, the tail call can be optimized. The call stack can be correctly displayed for the executed program. Further, the function call tree generation unit 13 is only added as software processing, and it is not necessary to provide dedicated hardware such as a trace memory inside the debug target 12, so that the cost of hardware can be reduced.

  When the debug target to be used has a branch trace function, the configuration of the first embodiment can be used. When the debug target has no branch trace function, the configuration of the second embodiment is selected and used. can do.

Claims (9)

A software debugging device for performing a debugging process of an execution image program generated by compiling a source program and debugging information,
Symbol table creating means for creating a function name and address information for each function in the execution image program according to the debug information as a symbol table;
Program execution means for executing program code instructions in the order of the program code of the execution image program;
Trace means for storing the program code of the branch instruction in the trace memory including the operand when the execution instruction by the program execution means is a branch instruction;
Call stack display means for creating a call stack indicating a function call hierarchy in accordance with the correspondence between the trace memory operant and the address information of the symbol table, and displaying the call stack. Debug device. The symbol table includes a function start address and an address size as the address information,
The call stack display means acquires the function name of the start address from the symbol table when the start address of the symbol table is the branch instruction used for the operand of the trace memory,
If a return instruction from a function is stored in the trace memory, the return destination address of the return instruction is included in the address range of the address size from the start address of the function included in the symbol table. 2. The software debug device according to claim 1, wherein the function name of the start address is obtained from the symbol table.   2. The software debugging apparatus according to claim 1, wherein the call stack display means creates the call stack when the execution operation of the program execution means is interrupted in accordance with an operation. A software debugging method for debugging an execution image program generated by compiling a source program and debugging information,
A symbol table creation step of creating a function name and address information for each function in the execution image program according to the debug information as a symbol table;
A program execution step of executing instructions of the program code in the order of the program code of the execution image program;
Trace means for storing the program code of the branch instruction in the trace memory including the operand when the execution instruction by the program execution step is a branch instruction;
A call stack display step for creating and displaying a call stack indicating a function call hierarchy in accordance with a correspondence relationship between the trace memory operant and the address information of the symbol table. How to debug. A source program is compiled and generated together with debug information. The first pseudo instruction indicating that there is a function call is placed immediately before the branch instruction of the function call, and the optimization of the tail call is applied among the function calls. A software debugging device for debugging an execution image program in which a second pseudo instruction is arranged instead of the first pseudo instruction,
Symbol table creating means for creating a function name and address information for each function in the execution image program according to the debug information as a symbol table;
Program execution means for executing program code instructions in the order of the program code of the execution image program;
A function call tree creating means for performing a static analysis on the source program and creating a function call tree indicating a function calling relationship;
The execution image program includes the first pseudo instruction and the second pseudo instruction, the function to which the tail call optimization is applied based on the function call tree and the symbol table, a return source function and a return address thereof. A return address table creating means for creating a return address table;
Call stack display means for creating a call stack indicating a function call hierarchy in accordance with a return address stored in a link register by instruction execution by the program execution means and the return address table and displaying the call stack. Software debugging device characterized by When there is a function in which the second pseudo instruction in the execution image program exists as a program code, the return address table creation unit calls the function in which the second pseudo instruction exists according to the call tree. Detect the function
If the first pseudo instruction is present in the program code of the function being called, the address indicated by the operand of the branch instruction immediately after that is used as the return address, and the symbol table is searched according to the return address. 6. The software debugging apparatus according to claim 5, wherein a function to which the return source function and the tail call optimization are applied is detected.   When the return address stored in the link register exists in the return address table, the call stack display means is a function of the function to which the optimization of the tail call for the return address is applied from the return address table. 6. The software debugging apparatus according to claim 5, wherein the call stack is created by reading a name.   8. The software debugging apparatus according to claim 5, wherein the call stack display means creates the call stack when the execution operation of the program execution means is interrupted according to an operation. A source program is compiled and generated together with debug information. The first pseudo instruction indicating that there is a function call is placed immediately before the branch instruction of the function call, and the optimization of the tail call is applied among the function calls. A software debugging method for debugging an execution image program in which a second pseudo instruction is arranged instead of the first pseudo instruction,
A symbol table creation step of creating a function name and address information for each function in the execution image program according to the debug information as a symbol table;
A program execution step of executing instructions of the program code in the order of the program code of the execution image program;
A function call tree creating step for creating a function call tree that performs a static analysis on the source program and indicates a function calling relationship;
The execution image program includes the first pseudo instruction and the second pseudo instruction, the function to which the tail call optimization is applied based on the function call tree and the symbol table, a return source function and a return address thereof. A return address table creation step for creating a return address table;
A call stack display step of creating and displaying a call stack indicating a hierarchy of function calls according to a return address stored in a link register by instruction execution by the program execution step and the return address table; A software debugging method characterized by the above.

Images