JPH03225532A - Code generation system of compiler for tracing variable of debugger - Google Patents

Abstract

PURPOSE:To obtain the system which inspects variables before and after varia tion, in a trace handler when respective flags corresponding to the variables are set, varies the variable values on a memory, and traces the variables by the debugger. CONSTITUTION:When the trace flag of a variable is set in a writing operation routine 2 which writes the value of the variable on a memory, the process is passed to the trace handler of the debugger through 1. The name of the traced variable is used to obtain the current value and the old value before the variation is displayed on a display. Then the new value of the traced variable is displayed. The new values of the variable is set on the memory from the processing of the debugger handler through a route (m) according to program codes. Thus, the flag added to each variable before the variable is written on the memory is checked and the value is written after a return from the debugger when the flag 1 or as usual when 0.

Description

[Detailed Description of the Invention] [Summary] This invention relates to a compiler code generation method for easily tracing changes in variables without special hardware changes. In a compiler that converts a source program into object code, a flag generating means inserts a flag indicating whether or not a debugger traces variables along with each variable; In a storage means that stores flags for each variable, and in a debugging trace handler, if the flag corresponding to each variable is set, the previous value and new value of that variable are stored before changing that variable. and inspection means for inspecting the program code, and after the inspection by the inspection means, the program code is returned to the program code, and thereafter, the value of the variable is changed on the memory.

[Industrial application field]

The present invention relates to a compiler code generation method for easily tracing changes in variables without special changes to hardware.

In order to provide a new debugging system, it is important to be able to trace variables in the direction of execution. It is also important to selectively search the execution history, replace data, or execute partial programs. When building such a new debugging system, there is no point in making major changes to the original operating system or incurring costs. Furthermore, modern systems, particularly workstations, are provided with graphical interfaces that facilitate multi-window and menu operation, and debuggers should also be compatible with such interfaces. It is important to be able to change the flow of execution by setting appropriate breakpoints and to be able to trace appropriate areas of the program.

[Problems to be solved by conventional techniques and inventions] Conventionally,
Tracing variables required a compiler that included a wide variety of high-level language statements for the debugger in the source code.

Therefore, the conventional method has the disadvantage that the compiler becomes complicated.

An object of the present invention is to provide a method for easily tracing variables using a debugger without using special hardware.

[Means to solve the problem]

The present invention is based on a compiler that converts a source program into object code.

First, it has a flag generating means that inserts a flag accompanying each variable indicating whether or not the debugger traces the variable.

Next, it has storage means for storing flags for each variable.

Furthermore, in the debug trace handler, if the flags corresponding to the variables are set,
and checking means for checking the previous value and the new value of the variable before changing the variable.

[Created for]

Insert flags called hooks into the target code for the compiler and debugger. This hook requires one extra word of memory per variable.

The debugger treats this extra memory as a flag when tracing variables. If tracing is to be performed, set the l flag; otherwise, set O flag.

Each variable is checked for flags associated with it before being written to memory. If the flag is 1, debugger processing is executed to inspect the variable without writing a value, and the value is written after the debugger returns. If the flag is 0, the value will be written as normal.

〔Example〕

FIG. 1 is a conceptual diagram of the principle of the present invention.

The whole figure shows the memory space of variables used in a program compiled from a source program created by a user.

In Figure 1, when each variable such as x, y, z, etc. is stored in the data area of memory, in the present invention, the compiler inserts a flag on the target code to indicate whether or not to trace it for debugging. . This flag is called a hook,
The hook requires one word of extra memory per variable. For example, if the hook of X is 0, it means that X is a non-trace variable. Similarly, if the hook of variable Y is also O, variable Y also becomes a non-trace variable. Furthermore, if the hook value of variable Z is 1, this means that variable Z is a variable that the debugger should trace. The same applies below.

FIG. 2 is a conceptual diagram of the compiler and debugger of the present invention, and shows a comparison with a conventional method.

In FIG. 2, 1 indicates that memory allocation of variables is a routine. In the conventional method, the amount of memory is simply allocated according to the size of each variable used in the program, and the allocated memory space is only for variables. However, in the present invention, not only the memory space depending on the size of each variable but also the flag indicating whether to trace during debugging is allocated as extra memory, so the allocated memory space is used not only for variables but also for debugging flags. Requires space to store. However, each flag only requires one word of extra memory for one variable.

2 in Figure 2 is a write operation routine that writes the value of the variable to memory. In the conventional method, the value of the variable was simply written to memory. However, in the present invention, the trace flag of the variable is ), the processing routine moves to the debugger's trace handler, and the value of the trace variable is written for the first time when the debugger's trace handler returns.

FIG. 3 shows a change in the debugger, and 3 is a routine that can be traced by the debugger and shows the variable registration method.

In the present invention, when registering variables to be traced,
First, the trace flag for that variable is set to "1", and then information related to the name and address of the variable is saved in the trace table. In each area of the trace table, a name, an address, or an attribute related to that variable is saved for each variable.

4 in FIG. 3 is a processing routine of the trace handler of the debugger of the present invention.

In 2 of Figure 2, when the trace flag of a variable is set, when processing moves to the trace handler of the debugger via a, the variable specified from the trace table, that is, the name of the traced variable retrieves the current value and displays it on the display. This is still the old value before the change, not the new value of the variable.

Then print the new value of that traced variable. Then, based on the program code, new variable values are transferred to memory for each operation from the debugger handler process via route 2. Thus, in the present invention, each variable is checked for its associated flag before being written to memory. If the flag is 1, debugger processing is executed to inspect the variable without writing a value, and the value is written after the debugger returns. If the flag is 0, the value will be written as usual.

In the present invention, a flag indicating whether or not to trace each variable is simply added to the memory, so compiler code generation (flag generation) for debugger variable tracing can be easily performed even on machines with different operating systems. In other words, the compiler can easily add a flag when generating code to indicate whether or not the debugger should trace variables.

〔Effect of the invention〕

According to the present invention, although the program becomes slower, variables can be easily traced on any machine.

[Brief explanation of drawings]

FIG. 1 is a block diagram of a user program memory according to the present invention, FIG. 2 is a block diagram showing changes to the compiler, and FIG. 3 is a program diagram showing changes to the debugger. 1... Routine for memory allocation of variables, 2... Routine for write operation to write variable values to memory, routine showing variable registration method, processing routine for debugger trace handler, Z... Variable. Y. X.

Claims (1)

[Claims] In a compiler that converts a source program into object code, a flag generating means inserts a flag indicating whether or not a debugger traces the variable along with each variable, and stores the flag for each variable. a storage means, and a checking means for checking a previous value and a new value of the variable before changing the variable if the flag corresponding to each variable is set in the debugging trace handler; A code generation method for a compiler for variable tracing in a debugger, characterized in that the code is returned to the program code after being inspected by the inspection means, and then the value of the variable is changed in memory.