JPS6292032A - Test method for program - Google Patents

Abstract

PURPOSE:To test the execution of a single program by executing this program then an instruction including an address allocated automatically to display them, and making the instruction accessible to the corresponding program. CONSTITUTION:A debugging system comprises a work station 11, a terminal equipment 12 and a debug executing device 13. When an operation test is executed for the debug, etc. after a source program is compiled, an address set previously is automatically allocated to an instruction containing an unfixed address to be substituted even in case such instruction is included in a machine word program owing to a fact that the source program includes an undefined part. Thus the machine word program can be executed singly. If the instruction having its executed, this executed instruction is displayed on a display device 27 and a direct access is possible to the program via an emulator 29. Thus an execution test can be carried out with a single program.

Description

DETAILED DESCRIPTION OF THE INVENTION Technical Field of the Invention The present invention relates to a method for testing a program, and particularly to a method for individually testing a program including an undefined portion.

<Summary of the Invention> The invention provides that when a source program is compiled and an operation test is performed for debugging etc., an address to be assigned is in an undefined state due to the existence of an undefined part in the source program. Even if an instruction is included in a machine language program, a preset address is automatically assigned to the instruction so that it can be executed independently, while the address is automatically assigned during the execution of the program. By displaying the assigned instructions when they are executed and making the program directly accessible, you can improve the program's Ji
This allows execution tests to be performed on the j-body.

<Background of the invention> Conventionally, when executing a program written in a high-level language, what happens? Linkage edit the source program consisting of Wj+ files to create a low)/°module, and download it onto the debugged wY.
Because of this, it was common to debug a program while running it under the control of a simple computer.

However, in the above debugging system, if the program to be debugged contains undefined parts such as undefined functions or undefined external transformations, an error may occur during linkage editing or undefined parts may occur. A meaningless value is assigned to the definition part, and a proper load module is not formed.

Therefore, when trying to test a program, it was necessary to wait until all the pY-cograms were completed, or to code a stub function to eliminate undefined functions, or to separately define undefined external variables. However, the task of eliminating such undefined parts is likely to take more time than actually creating the program, and this becomes an obstacle when debugging functions in the text field, leading to a decrease in work efficiency. was there.

<First aspect of the invention> The present invention has been made in view of the above-mentioned problems, and is capable of compiling a source program as is even if it contains an undefined part, and solving unresolved issues caused by the undefined part. By automatically assigning a predetermined address υj to a given external label, we provide a method that allows you to test the execution of a single program without performing any special processing on the source program in advance. The purpose is to

<Configuration and Effects of the Invention> In order to achieve the above object, the program testing method of the present invention includes a step of compiling an undefined portion of a source program in an undefined state, and a step of compiling an undefined portion of a source program in an undefined state. A step of automatically assigning a preset address to an instruction for which the address to be assigned is undetermined, thereby making it independently executable;
The method consists of the steps of executing a program, executing an instruction including an automatically assigned address, and displaying it to make the program accessible.

With the above-described configuration, the present invention eliminates the need to code stub functions and undefined external variables only for unit debugging, facilitates execution testing of individual programs, and has the effect of improving program development efficiency.

<Description of Examples> The present invention will be specifically described below based on examples shown in the drawings.

In the embodiment, an example will be shown in which the present invention is implemented in a C language debugging system that uses a general-purpose computer and expands the scope of application by replacing peripheral devices and software depending on the test purpose, but the present invention is not limited to this. It goes without saying that the present invention can be implemented in substantially the same manner on a dedicated program test machine that operates independently, and the language for the program to be debugged can also be changed to various high-level languages other than rCJ.

A debugging system embodying the present invention includes an engineering workstation 11 using a general-purpose computer, a terminal device 12 that allows an operator to directly access the workstation 11, and a workstation as shown in FIG. 11 under the control from the workstation 11 side, and a Depa-Nobu execution device 13 that enables debugging at an assembler level.

The workstation 11 has an arithmetic control unit 21 using a microprocessor as its center, an internal storage device 22 consisting of RAM, an external storage device 23 such as a tote disk drive, and an input/output system equipped with an interface circuit for peripheral devices. A device 24 is connected to the workstation 11 via various buses 25, and an O:1 terminal device 12 and a debug execution device 13 are further connected to the workstation 11 through an input/output device 24.

The terminal device 12 consists of a keyboard 26 that allows direct access to the workstation 11, and a display device 27 such as C or RT that displays the data processing status within the workstation 11 in a visible manner. By manually inputting commands from the keyboard 26, the execution programs 37, source programs 34, etc., such as the compiler 3 linkage editor 32 and symbolic debugger 33 shown in FIG. 4, stored in the external storage device 23 in advance are executed.
After appropriately loading the data consisting of the object file 35, load module 36, etc. into the internal storage device 22,
Programs 31, 32, 33 in the arithmetic and control unit 21
By sequentially executing the steps, the workstation 11 operates as a debug system as a whole while controlling the debug execution device 13.

The debug execution device 13 is located between a device to be debugged 28 such as an electronic cash register using a microprocessor as a control unit capable of running a program to be debugged, and the device to be debugged 28 and the leak station 11. The debugged device 28 replaces the CPU of the debugging device 28.
and an emulator 29 that directly controls the. The emulator 29 can perform debugging at the assembler level by itself, but in this embodiment, it responds to commands given from the workstation 11 through the input/output device 24 and debugs the source program 34J. −
Display or update the memory contents of the debugged devices 28, . By sending the data back to the workstation 11 side, debugging processing at the level of the source program 34 in a high-level language can be performed on the workstation 11 side.

The present invention is characterized by a method for testing the execution of J-loop programs in the debugging system.

Figure 4 shows a source program 34 written in C language that has been translated into machine language and is completely non-polymorphic.

This figure schematically shows the flow of processing, mainly performed by software, up to the point where it is debugged.

First of all, a source program 34 containing calls to undefined functions and references to undefined external variables is compiled by the compiler 31 inside the workstation 11, and then processed by the relocator 7'. Object file 3
5 is formed. The object file 35 includes, in addition to the machine language corresponding to the source progera J, 34, line number information indicating the correspondence between the address of the machine language and the line number of the source program 34, and information written on the source program 34. It contains symbol information consisting of information such as variable types, sizes, addresses, etc., and its file format is, for example, the operating system UNIX SYSTE.
M V COF F (Common 0bject
File Format).

However, at this stage, since the machine language is written in a rogutable format, the absolute "?" address cannot be determined, so instead of the machine language address for line number ↑n,
The offset value from the first machine language in the object file 35 is substituted, and the address value in the file information is in an undetermined state. Furthermore, since there are undefined portions in the source program 34, for example, the jump destination address in a function call, the address of an external variable, etc. remain unresolved.

Next, the linkage editor 32 creates a load module 36 using the 7-file 35 as input data. The load module 36 is a device to be debugged 2.
In addition to the machine language written using absolute addresses that can be executed by 8, line number end (
Contains U and symbol information, object file 35
It consists of almost the same file format as .

By the way, in the process of creating the load module 36, contrary to the above, unresolved external errors are not left as they are. So, in this example,
If the external Rahel with 〒1zlJu <, unresolved l↓1 in Figure 1 is the address of the jump destination for a function call such as the BSR instruction 42, then the aff BSR instruction 42's operand 41 is always Set a constant address 8 to the address.

On the other hand, if the undefined external Rahel is an address related to referencing an external variable such as in the MOVE (data transfer from memory to register) instruction 44, the address B of the specific address area 45 is specified for the operand 43 of the instruction 44. ,
B2... are sequentially allocated starting from the start address B by the size of the variable in the order of appearance of the undefined external Rahel. The above specific address A and address area, 45
is specified by the user when starting up the linkage editor 32, and furthermore, by setting the hardware breakpoint HBP of the two emulators at address A, when the address A is executed, the program is automatically executed by hardware. Set it so that it will break automatically.

When the load module 36 processed as described above is used as input data to operate the simple debanoga 33 and a predetermined command is input from the keyboard 1-26 of the terminal device 12, the emulator command necessary to process the command is activated. is sent to the emulator 29. The emulator 29 interprets and executes this emulator command, and then sends the result back to the debugger 33.

The simple debugger 33 has the same functions as those for conventional high-level languages (i.e., the function of specifying variable names in the source program 34 and displaying/updating their contents, and the function of executing/stopping the program in the debugged device 28). In addition to having
As detailed below, ■ When address A is executed by calling an undefined function, the line number of the program that called the undefined function is displayed, and the program of the device to be debugged 28 is displayed. ■A function that displays the contents of the arguments by manually specifying the argument type of an undefined function using a command.■A function that allows you to define the return value of an undefined function using a command and then run the debugged program. It has a re-execution function. Note that the debugger 33
On its internal memory, a row number table is created based on the row number information of the load module 36, which is a record group consisting of a machine language address, a corresponding file name, a function name, and a row number. has been created in advance, and the debugger 3:3 edits the processing results returned from the emulator 29 while referring to the line number table, so that it can be displayed as information on the source program 34 on the display device 27 of the terminal device 12. do.

Next, a procedure for using the simple debugger 33 to execute and debug the single module 70 that has undergone the above processing will be described.

When the simple debugger 33 is activated and the program execution command 51 "GO" is input from the terminal device 12 as shown in FIG. 2, the program to be debugged starts execution. If a MOVE instruction 44 that quotes an undefined external variable is executed during the execution of the program, as shown in FIG. Continue executing the program while sequentially importing the files.

However, when an undefined function is called, the operand 41 of the BSR instruction 42 corresponding to the call is set to a specific address A, so program execution is forcibly branched to address A, and the program execution is forcibly branched to address A. In A,
Emulator 29 hardware breakpoint HB
Since P is set in advance, when this address A is accessed, the emulator 29 stops execution of the program to be debugged and notifies the sympolink debugger 33 of the occurrence of a break.

FIG. 5 shows the stack area 61 and various registers 5 related to the function call after the debugged program has stopped due to the undefined function being called as described above.
0 is shown. In other words, in the stack area 61, if an address branch occurs due to a call to an undefined function, the arguments 63 passed to the undefined function are sequentially stacked on the area 62 used by the calling function. , and furthermore a return address 64 to the caller.
After storing the return address 64, the address where the return address 64 is stored is set in the stack pointer 65. Therefore, as an offset value from the value of the stack pointer 65, the address where the return address 64 and the argument 63 are stored is uniquely set. Desired.

The illustrated example shows that the address 64 for returning to the original function that called the undefined function is stored at the address pointed to by the stack pointer 65, and the argument 63 is stored further after the address +2. The simple software developer 33 searches the line number table based on the return address 64, and finds the position in the source program 34 where the undefined function was called, using the file name 52, as shown in FIG.
It is displayed on the screen 55 in the format of function name 53 and line number 54 to inform the user that an undefined function has been called.

Here, disparg'', which is the command 56 for displaying the argument 63 passed to the undefined function, is sent to the terminal device 1.
2, the values of the arguments 63 stored in the stack area 61 are sequentially read out and displayed on the screen 55 according to the type specification in the operand 57 of the command 56, and are correctly applied to the external function. A check is made to see if argument 63 has been passed.

In the illustrated example, the undefined function is 12 of the function main of source 10 file name sample, c, h of file L34.
It is called from line 63, and there are three arguments 63, the first
It can be seen that the argument is an integer type (r123J for il, the second argument is character type (C) and raJ, and the third argument is a double precision floating point type (rl for dl, 23e12J).

Next, when the undefined function is called and stopped as described above, if you execute the command 58 "return" to restart program execution, the table definition function side will call the caller using the procedure described below. Control is returned to , the next undefined function is called, and the debugged program continues processing.

That is, as shown in FIG. 6, an RTS instruction, which is an instruction for returning from a subroutine, is placed in a part of the address area of the debugged device 28 that is not used by the debugged program. 66 is stored in advance by the simple storage device 33.Furthermore, the terminal device 12
When the operator specifies a return value 60 as the operand of the "return" instruction 58 that is input during the call, the return value 6o that is passed to a caller is stored in the data register 67. In the illustrated example, the sorting type (1) indicates that "123 items have been designated as the return value Go."

As above, return instruction 5 with return value 60 specified
In conjunction with input 8, the simple debugger 33 sets the value of the program counter 68 to the address storing the RTS instruction 66, and then moves the program to be debugged to R[
JN letter is a lie. Then, RTS instruction 66 is executed,
Take in the return value 60 stored in the zeta register 67, return to the calling function, and run the program execution test.
F: Continue.

[Brief explanation of drawings]

FIG. 1 is an explanatory diagram showing the relationship between program addresses and memory during program testing according to the present invention;
Fig. 2 is a front view of a display screen for explaining the operating procedure, Fig. 3 is a block diagram showing an example of a dehasog system for implementing the present invention, and Fig. 4 is a process in the system of Fig. 3. FIG. 5 is an explanatory diagram showing the relationship between the stack area and the stack area when a program break occurs, and FIG. 6 is an explanatory diagram showing the procedure for restarting program execution. 11...Workstation 12...Terminal device 27...Display device 31...Compiler 32...Linkage editor 33...Simporinokudehanoga 34...Source program 36...Load module patent application Person: Tateishi Electric Co., Ltd. Dimension 3 > 3 DoJg L Ha dimension 5 > B Mushinuno Odorihon'A, i: L / j Te) Guaku tip t〒145 [

Claims (2)

[Claims] (1) The process of compiling the undefined part of the source program in an undefined state, and automatically assigning a preset address to an instruction whose address to be assigned is undefined due to the undefined part of the source program. a step of making the program executable on its own by allocating automatically; and a step of executing the above single program and displaying it when an instruction including an automatically assigned address is executed, making the program accessible. A program testing method comprising a process. (2) Among the instructions for which the address to be assigned is undetermined, the same address is assigned to all instructions that branch the execution address, and a breakpoint is set at the address. program testing method.