JPH01273144A - Software development supporting device - Google Patents

Abstract

PURPOSE:To improve the debug efficiency and the debug accuracy by obtaining a registered symbol and a real address corresponding to the symbol from information at the time of a link processing and generating them as a symbol file of each separate emulator of a decodable format by the emulator. CONSTITUTION:A symbol and a symbol address which have been fetched by a symbol extracting means 16 and a symbol address extracting means 17 are brought to data conversion to a symbol format of a decodable format of each emulator by a format conversion means 18a-18n. Thereafter, this symbol format data which has been brought to format conversion is registered in its corresponding emulator symbol file 14 by a symbol file registering means 19. Subsequently, the symbol file corresponding to the emulator which is used at the time of using the emulator is selected from the registered symbol file 14 and given to the emulator EMU, so that the symbol can be used instead of the real address. In such a way, the program development can be executed efficiently.

Description

[Detailed Description of the Invention] [Object of the Invention] (Industrial Application Field) The present invention provides a software development support device that can automatically collect necessary symbol addresses in a program and generate a symbol file in a desired format. It is related to.

(Conventional technology) In recent years, with the remarkable progress of semiconductor technology and advancement of microcomputer technology, not only electronic devices but also
In various types of industrial equipment, there is a growing tendency to computerize the control center and implement it using software. By the way, in order to develop software for such devices, it is necessary to program edit (create and edit a source program) using an editor etc., assemble or compile the created program, and create an object file generated by assembling or compiling. This process is repeated based on the execution result of this executable file (debugging the problem area).

By the way, when debugging the program, an emulator is used to debug the program. Here, an emulator has a built-in MPU and memory of the same type as the target microprocessor (hereinafter referred to as MPU), and the MPU is removed from the prototype of the system to be developed and an emulator plug is inserted in its place. This is to confirm the operation by having the MPU and memory operate on behalf of the prototype system. An emulator is often used by being connected as an adapter outside a software development support device, and under the control of the monitor of the software development support device, it can track stop and jump instructions using breakpoints set in hardware registers. You can perform jump tracing, memory lending, measuring elapsed time, etc.

An example of how to use it is to divide a developed program into small sections, set a breakpoint at the end of each divided program, and run each divided program on an emulator. Check the operation of the hardware, make adjustments to obtain the desired results, and debug the program if there are problems with the program. Then, we will gradually integrate programs and hardware that have been confirmed to work,
Get closer to the target system. Programs that have been confirmed to work in the emulator's memory are sequentially moved to the prototype system's memory and their operations are reconfirmed.Once all programs have been moved to the prototype system's memory and their operation has been confirmed, the emulator is removed from the prototype system. The original MPU was then installed, and this time the prototype system was operated independently.

Target system development using an emulator is performed in this way. By the way, in general, it is common to use symbolic or debugger at the stage of debugging. With this symbolic debugger, when using various commands, you can use symbols (names) to indicate the jump destination address, the start address of a program module, etc. instead of the actual address. This is very convenient because you don't have to think about addresses.

In this way, in the symbolic debugger, the command given to the debugger can be specified using this symbol, so that elementary errors such as input errors in real addresses can be prevented. However, when performing this symbol debugging, the only symbols that can be used are common reference symbols (that is, names declared as public (PUBKIC)). That is, in order to use symbols, a symbol file in which common reference symbols are registered is required, and it is a prerequisite that the debugger itself can decode this symbol file.

On the other hand, if the emulator is used in a symbol-based format, it is possible to input commands using symbols, but it was originally designed so that the link loader (linker) and debugger used could commonly use the symbol files used by these tools. If an emulator is developed with a software relationship between the two, it is possible to give commands using symbols from the software development support device to the emulator and have it execute. In this case, you cannot enter commands using symbols.

In this way, if a software development tool such as a link loader or assembler and the emulator used are not designed from the beginning to be able to use common symbol files, symbols may be used from the software development support device during debugging. Even if you try to perform debugging, the symbol files generated by the link loader etc. and the symbol files that can be decoded by the emulator are of different formats, so of course you cannot use them. It is necessary to find the symbol address or program address necessary for debugging while looking at the generated symbol file and symbol list. In such a case, a development engineer can use, for example, a link map (information about the symbol used and the real address of the symbol determined as a result of link processing) that is output during linking and a calculator (electronic desktop calculator). However, there is a problem in that not only the efficiency of debugging is greatly reduced, but also the precision of debugging is reduced due to calculation errors and the like.

To solve this problem, it is necessary to be able to debug using symbols in the program, and in order to do so, you need to use an assembler, linker,
It is possible to purchase an emulator (debugger), but since these are expensive, the development cost increases, and the problem remains that the development system that has been used up until now is completely wasted.

(Problems to be Solved by the Invention) As mentioned above, when developing software for devices using an MPU, an emulator is used.

It would be convenient if symbols could be used when debugging programs on the target system. but,
In order to operate an emulator using these symbols, the emulator must be able to decode the symbols used. To do this, a symbol file is required in which the common reference symbols used as symbols are registered, and it is a prerequisite that the emulator can decode this symbol fist file.

On the other hand, emulators can also input commands using symbols, but emulators were developed from the beginning so that the symbol files used by development tools such as link loaders and debuggers could be used in common. If the software development support device had a software development support device, it would be possible to give a command using symbols to the emulator and have it execute it, but such an emulator with no software relationship cannot input commands using symbols. Therefore, in such cases, the address indicated by the target symbol was calculated by hand while referring to the link map file generated by the link loader, and was then given to the emulator along with a command to be executed while debugging.

As a result, efficiency is low, and debugging accuracy is low due to errors in calculation of address values, resulting in poor productivity.

In this way, in traditional program development, the language used for development, software such as link loaders, etc.
Unless a tool and an emulator have been developed and manufactured as a set, it is not possible to create the symbol files required for debugging in a format that the emulator can read, so the address that is commanded to the emulator must be set by the software tool. There was a problem with referring to what was used on the side. Additionally, equipment that is provided as a set from the beginning to be able to decode the same symbols and files as an assembler or linker is expensive, and the system currently in use, including hardware and software, is wasted. However, there is a problem in that development costs are rising.

Therefore, the purpose of this invention is to provide software that can create symbol files that can be read by various emulators so that symbols in programs can be used without purchasing new emulators or other devices. Our goal is to provide development support equipment.

[Structure of the invention]

(Means for solving problems) In order to achieve the above object, the present invention is configured as follows.

That is, a target program created using symbols instead of real addresses is converted into an executable program through link processing, and this executable program is given to an emulator, which requires various commands for debugging from input means. In a development support device that develops a program to be used in a target system using a processor by emulating it by providing address information etc. according to the program, symbols in the program that are necessary when debugging the program are inputted from the input means. A means for manually registering symbols in a symbol table; a symbol extracting means for sequentially extracting symbols registered in the symbol table; and symbols used, which are link map information of each program outputted during program link processing, and link processing. A symbol address extracting means for extracting the symbol address of the symbol extracted by the symbol extracting means from this link map information when information consisting of the real address taken by each determined symbol is given, and the symbol extracting means and the symbol address extracting means Solution of extracted symbols and symbol addresses for each emulator.

The system includes a format conversion means for converting data into a readable symbol format, and a symbol file registration means for registering the converted symbol format data in a symbol file corresponding to each emulator.

(Function) In such a configuration, the registration means registers symbols in the program, which are necessary when debugging the program, into the symbol table by inputting them manually from the input means. The symbol extraction means sequentially extracts the symbols registered in this symbol table, and the symbol address extraction means extracts the symbols extracted by the symbol extraction means based on the link map information of each program output during program link processing. Extract the corresponding address. The symbols and symbol addresses extracted by the symbol extracting means and the symbol address extracting means are data-converted by the format converting means into a symbol format that can be read by each emulator, and then the converted symbols are sent to the symbol file registering means. The format data is registered in the corresponding emulator symbol file. Then, when an emulator is used, a symbol file corresponding to the emulator to be used is selected from the registered symbol files and given to the emulator, thereby enabling the symbol to be used in place of the real address.

By doing this, it is possible to create symbol files that can be decoded by various emulators at the same time during the link process, and give the created symbol files to the emulator used to execute various commands using the symbols. This makes it possible to perform symbol debugging using symbols used in the program development process instead of real addresses during debugging, without having to buy a new emulator etc. Moreover, it becomes possible to develop programs efficiently.

(Example) Hereinafter, an example of the present invention will be described with reference to the drawings.

FIG. 1 is a system configuration diagram showing an embodiment of the present invention. In the figure, reference numeral 11 denotes a console device of a software development support device, and 14 includes a keyboard, a display device, and the like.

12 is a symbol table, 13 is a link map file, and 14 is a symbol file, which are stored in, for example, an external storage device. Reference numeral 20 denotes a control unit that is responsible for controlling the software development support device. The control unit 20 performs various basic controls of the device, executes loaded assemblers, compilers, editors, link loaders, debuggers, etc., sends and receives various commands and data to the emulator, reads and writes memory contents to the emulator, In addition to the monitor function, symbol registration means 15 has the function of registering symbols input from the console device 11 in the symbol table 12, symbol extraction means 16 has the function of extracting symbols using the symbol table 12, symbol Symbol address extraction means 1F, which has a function of extracting the address corresponding to the symbol extracted by the extraction means 16 from the link map file 13;
Format conversion means 18 that generates a symbol file in which the symbols and their addresses extracted by the symbol address extraction means 17 are converted into data in a format usable by the emulator used, and this generated symbol file is registered in the symbol file 14. The symbol file registration means 19 has a symbol file registration means 19.

Here, the format conversion means 18 has format conversion sections 18a to 18n corresponding to each emulator used.
has. Further, the EMU is an emulator connected to the control unit 20, and when the emulator EMU is given a symbol file in a predetermined format, it decodes the contents and converts it into the real address pointed to by the input symbol. It shall have at least a function that can accept commands using symbols, and therefore it shall be possible to input commands using symbols.

FIGS. 2 to 4 show examples of files used and created in the present invention.

Figure 2 is a diagram showing an example of a symbol table in which necessary symbols are registered, Figure 3 is an example of a symbol file created in an embodiment of the present invention, and Figure 4 is a symbol generated by the link loader when linking. An example of a link map file from which to extract addresses is shown.

The operation of this device configured as above will be explained.

FIG. 5 shows a symbol registration procedure using the symbol registration means 15.

First, a symbol required for debugging is inputted from the console device 11 by specifying a file name (Sl). As a result, the control unit 20 sequentially registers the symbols input from the console device 11 in the locations of the corresponding file names in the symbol table 12 (s2). Based on the input from the console device 11, the control unit 20 checks whether it is a symbol input or an end command (s3). If the symbol input is completed, this routine is ended, and if a new symbol is input, the control section 20 returns to Sl. and repeat the above operation. In this way, all necessary symbols are registered for each file.

When performing this work, the control unit 20 also displays the registered contents and input contents on the display of the console device 11 for the operator's convenience.

The symbol table created by the above operations only needs to be created once, and is always referenced when creating symbol files thereafter.

FIG. 6 shows the procedure for creating symbol files for each emulator. That is, when this routine is activated, the control unit 20 sequentially extracts symbols from the symbol table having the file name for the emulator n from the symbol table 12 described above (sll). Next, a symbol address is searched and extracted from the link map file 13 corresponding to the symbol (s12). If the symbol address is not found in step s12, the process moves on to searching for the next symbol. And then step sll.

The symbol and symbol address extracted in s12 are converted into a format for emulator n (s13a).

Similarly, symbols and symbol addresses are converted into a format for emulator n (s13b). Thereafter, format data for emulator n is created in the same manner (s13n).

The format data corresponding to each emulator created in this way is sequentially registered in the symbol file 2b prepared for each emulator EMU, and the line <
(s14). It is checked whether the above procedure has been performed for all the designated symbols, and if it has been performed, the process is terminated, and if it has not been completed for all symbols, the process returns to "all" and the above operation is repeated.

Each symbol file created in this way that is compatible with various emulators and in a format that can be decoded by the emulator is stored in the console device 11 when the emulator is used.
give commands to the emulator, enable command input using symbols, and proceed with debugging by giving commands to the emulator through command input operations using symbols from the console device 11; You will be able to do it.

Therefore, according to this embodiment, it is possible to create a symbol file in a format that is compatible with various emulators required in the debugging process during program development and in a format that can be decoded by the emulator, and to give it to the emulator when the emulator is used. Even when using an emulator, debugging using symbols can be performed with a new emulator simply by adding a format conversion means for the emulator.

As explained above, until now it was not possible to create symbol files compatible with each emulator during program development, which worsened debugging efficiency and debugging accuracy, but with this device described above, symbol files are required when debugging programs. By inputting symbols in the program through the input means, the registration means registers them in the symbol table, the symbol extraction means sequentially extracts the symbols registered in this symbol table, and the symbol address extraction means outputs the symbols during program link processing. Based on the link map file of each program, addresses corresponding to the symbols extracted by the symbol extracting means are extracted, and the symbols and symbol addresses extracted by the symbol extracting means and the symbol address extracting means are converted into respective addresses by the format converting means. After converting the data into a symbol format that can be read by the emulator, the symbol file registration means registers the converted symbol format data in the symbol file for the corresponding emulator, and when the emulator is used, it is compatible with the emulator being used. By selecting a symbol file from the registered symbol files and giving it to the emulator, the symbol can be used in place of a real address. Therefore, each symbol file that can be read by various emulators is created at the same time during link processing. It is now possible to give this created symbol file to the emulator used to execute various commands using symbols, and it can be used in the program development process instead of real addresses during debugging. It becomes possible to perform symbol debugging using the existing symbols, and it becomes possible to efficiently develop programs for the target system without purchasing a new emulator or the like. Also, when developing a large program, by registering the necessary symbols in advance, symbol files can be created for the symbols within the range of registration, allowing effective debugging within the emulator's limited number of symbols. There are advantages. Furthermore, by being able to create symbol files for multiple emulators, existing emulators can be used effectively, making it possible to use resources more effectively, and there is the advantage that there is no need to introduce new emulators. .

Furthermore, even if a new emulator is introduced, it can be handled simply by adding a format conversion means compatible with the new emulator, making it highly versatile.

Note that the present invention is not limited to the embodiments described above and shown in the drawings, and can be implemented with appropriate modifications within the scope of the gist thereof, and the present invention is applicable not only to emulators but also to debuggers, It can also be applied to creating symbol files for field monitors.

〔Effect of the invention〕

As described in detail above, according to the present invention, when symbols are registered, the registered symbols and the real addresses corresponding to the symbols used in the process of program development can be used during link processing. It takes this information and generates it as an emulator-specific symbol file in a format that the emulator can read, so you can give commands to each emulator using the symbols you are using in the program you are developing, and therefore the logic Thus, it is possible to provide a software development support device that can dramatically improve debugging efficiency and debugging accuracy.

[Brief explanation of the drawing]

FIG. 1 is a system configuration block diagram showing an embodiment of the present invention, FIG. 2 is a diagram showing an example of a symbol table, and FIG. 3 is a diagram showing an example of a symbol file created in an embodiment of the present invention. FIG. 4 is a diagram showing an example of a link map file, and FIGS. 5 and 6 are flowcharts for explaining the operation of the apparatus of the present invention. 11... Console device of software development support device, 12... Symbol number table, 13... Link map file, 14... Symbol file, 15...
・Symbol registration means, 1B...Symbol extraction means, 1
7... Symbol address extraction means, 18... Format conversion means, 18a-18n... Format conversion unit, 19... Symbol file registration means, 20...
・Control unit, EMU...emulator. Figure 3 Figure 5

Claims (1)

[Claims] A target program created using symbols instead of real addresses is converted into an executable program through link processing, and this executable program is given to the emulator to input various commands for debugging as needed from input means. In a development support device for developing a program to be emulated and used in a target system using a processor by giving address information including address information, etc., symbols in the program necessary for debugging the program are inputted from the input means. symbol extracting means for sequentially extracting the symbols registered in the symbol table; symbols used which are link map information of each program output during program link processing; and symbols determined by link processing. Symbol address extraction means extracts the symbol address of the symbol extracted by the symbol extraction means from this link map information when information consisting of the real address taken by each symbol is given; It has a format conversion means for converting symbols and symbol addresses into a symbol format that can be read by each emulator, and a symbol file registration means for registering the converted symbol format data in a symbol file compatible with each emulator. A software development support device characterized in that, when an emulator is used, a symbol file compatible with the emulator to be used is selected from the registered symbol files and provided to the emulator, thereby making it possible to use symbols in place of real addresses.