JP2888242B2 - Microprocessor program development system - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Outline] Regarding a program development system for a microprocessor in a device to be developed, a program using standard input / output functions generally performed in a cross development environment and also in a self development environment. The purpose is to enable the evaluation to be carried out even in the system evaluation of the microprocessor in the device under development. At least a system for controlling the operating system and the emulator is built in, and the development of the microprocessor program in the device under development is executed. Of a development target device in a cross development environment comprising a development machine to be developed, an emulator controlled by the development machine, and a development device connected to the emulator and having a microprocessor whose program is controlled by the emulator. Microprocessor processor Means for previously including information for controlling the microprocessor of the device under development and standard input / output information for executing the standard input / output function in an object file output by a compiler loaded in the development machine, Means for storing the control information of the microprocessor of the developed device in the memory of the emulator when the object file is loaded into the system, and storing the standard input / output information including a subroutine for executing the standard input / output function. Means for storing in the memory of the development machine, and means for storing the standard input / output symbol table and the standard input / output interrupt table relating to the standard input / output information in either the memory of the development machine or the memory of the emulator; At the same time, the microprocessor A means for comparing and detecting the execution information of the ram and the information of the standard input / output interrupt table is provided in the emulator, and when the emulator controls and executes the program of the microprocessor of the developed device, the emulator executes the program for each instruction. The execution information of the program is read by the emulator, and the comparison and detection means compares the execution information with the information of the interrupt table. If the two match, the emulator executes the program of the microprocessor of the developing device. A stop instruction is given, function information relating to the standard input / output is selected from the standard input / output symbol table and sent to the development machine, and the standard input / output subroutine corresponding to the standard input / output function information is executed by the development machine. The configuration is as follows.

[Industrial applications]

The present invention is directed to improving a man-machine interface for making it easier to use a cross-compiler using, for example, a high-level language when developing control software for a microcomputer. It is used.

More specifically, a development machine incorporating a microprocessor (hereinafter referred to as a development machine) is used to execute development of a microprocessor program in a device to be developed. In a cross development environment where the processor and the microprocessor in the device under development operate in different machine languages that are incompatible (hereinafter simply referred to as a cross development environment), the program of the microcomputer such as the microprocessor of the device under development is executed. The present invention also relates to a system capable of performing development and evaluation using a cross-compiler such as a high-level language in the same manner as in a self-development environment when developing and evaluating.

[Conventional technology]

Developed devices with built-in microcomputers, such as hot air heaters and air conditioners, can test and evaluate whether the built-in microprocessor computer program works properly before these products are shipped. Generally done.

In the past, the control software development environment for such microcomputers was all about assemblers. However, in recent years, the number of programmers using high-level languages, also C language, has increased.
Along with this, software simulators that support high-level language debugging have emerged.

Conventionally, such a program of the microprocessor of the device under development is conventionally executed under a self-development environment. The self-development environment refers to the case where the microprocessor of the device to be developed and the development machine, for example, the microprocessor of a personal computer, operate in the same type of machine language. Generally, the microprocessor of the personal computer controls the microprocessor of the device to be developed. The evaluation is performed while the machine language and 1
It was executed in a one-to-one correspondence. However, as an actual task, in order to check whether the program in the microprocessor is operating correctly, it is necessary to break the operation of the microprocessor one by one and check the value of the variable for the value to be checked each time except for the memory. There is. Such an approach is quite patient. In other words, in this system, it was required to specify the address where the change of the variable is expected in advance, stop the execution there, check it by using another command in the memory, and then proceed to another execution. .

As a method of solving such complexity, debugging using a compiler, that is, a high-level language such as C language, has become popular, and it has become possible to develop a microprocessor program in a device to be developed without knowing an assembler. . Further, the microprocessor of the personal computer is made to control the microprocessor of the developed device,
For example, when the above development is performed using a C language compiler, a standard input / output function, for example, a “printf” statement is inserted in the middle of the program to check whether the high-level language is correct in executing the program. This is done by displaying the variables requested by the “printf” statement on the CRT screen of the personal computer and checking them, and is often used as a simple method. In this method, the microprocessor of the device to be developed and the microprocessor of the development machine that operate because the device is self-developed operate in the same type of machine language. Therefore, the operation of the microprocessor of the device to be developed is controlled by the microprocessor of the personal computer. It is possible for the processor to do it for you.

In addition, those who deal with such high-level languages can use CR and
It is common to be used to the method of displaying and confirming on the T.

On the other hand, in such an evaluation system, unlike the self-development environment, a microprocessor for a personal computer for examining a program to be debugged and a microprocessor of the device under development operate in different types of machine language to develop a program. In such a case, it cannot be performed by the microprocessor of the personal computer.

Therefore, as described above, the control of the system of the developed device is directly performed by the microprocessor of the developed device.
The microprocessor on the personal computer side must indirectly control the system of the developing device by stopping or running the microprocessor of the developing device via the emulator.

In that case, for example, "prin
Even if a tf "statement is inserted and executed, the result cannot be displayed immediately because the microprocessor does not have a normal display function.

However, as described above, there is also a request from a person who is accustomed to evaluation in a high-level language, and it has been desired that an evaluation system similar to a self-development environment be established under a cross development environment.

[Problems to be solved by the invention]

Accordingly, an object of the present invention is to provide a method capable of developing a microprocessor program of a device under development using a standard input / output function generally performed in a self-development environment even in a cross development environment. Things.

[Means for solving the problem]

In order to achieve the above objectives, it is necessary to use an emulator to evaluate the actual microprocessor system, and to prepare a cross-compiler that supports high-level languages and an emulator corresponding to it, It is necessary to make it possible to use the same debugging technique as that of the self-development environment for the evaluation. In order to realize such a technical problem, the following technical posterity is adopted. That is, a development machine (hereinafter, simply referred to as a development machine) that at least includes a system for controlling an operating system and an emulator and executes the development of a microprocessor program in a device to be developed, an emulator controlled by the development machine, A development device connected to the emulator and having a microprocessor whose program is controlled by the emulator, wherein the microprocessor of the development machine and the microprocessor of the development device are in different machine languages. In a program development system of a microprocessor in a device under development in an operating cross development environment (hereinafter simply referred to as a cross development environment), the device under development is previously stored in an object file output by a compiler loaded on the development machine. Means for including the microprocessor control information and the standard input / output information for executing the standard input / output function. When the object file is loaded into the system, the control information of the microprocessor of the developed device is stored in the emulator. Means for storing the standard input / output information including a subroutine for executing the standard input / output function in the memory of the development machine; and an information input / output symbol table and a standard input / output symbol table relating to the standard input / output information. Means for storing the output interrupt table in either the memory of the development machine or the memory of the emulator; and execution information of a program of a microprocessor of the device under development and information of the standard input / output interrupt table. The emulator is provided with means for comparing and detecting When the emulator controls and executes the program of the microprocessor of the developed device, the execution information of the program is read by the emulator for each instruction, and the comparison and detection means compares the execution information with the information of the interrupt table. If they match, the emulator instructs the microprocessor of the developed device to stop executing the program, and selects the function information related to the standard input / output from the standard input / output symbol table and sends it to the development machine. , A program development system for a microprocessor of a device under development for causing the development machine to execute a standard input / output subroutine corresponding to the standard input / output function information.

In other words, the basic technical idea of the present invention is that when developing a microprocessor program in a cross development environment consisting of a development machine, a microprocessor and an emulator of a device to be developed, the object file output by the compiler in the development machine is The emulator includes the native code of the microprocessor of the device to be developed and information for executing the standard input / output function generally prepared in the self-developing environment, and the emulator identifies the output of the information to identify the output of the development machine. This is a system for developing and evaluating a microprocessor of a device under development, which is configured to substitute the standard input / output function for the input / output function.

Here, the above-mentioned development machine refers to a device mainly composed of a microprocessor and configured to include a keyboard, a display device, and the like in order to execute development of a microprocessor program in a device to be developed.

[Action]

According to the present invention, in a program development system for a microprocessor of a device under development in a cross development environment comprising a device to be developed having a development machine, a microprocessor, and an emulator, the program is loaded into a development machine output by a compiler. In the object file, native control information of the microprocessor of the device under development and standard input / output information for executing the standard input / output function are included, and the native control information of the microprocessor of the device under development is included in the object file. The emulator executes the program of the microprocessor of the device under development via the base emulator, compares the execution information with the standard input / output information in the emulator, and when the information matches, the emulator activates the microprocessor of the device under development. Stop execution of processor program At the same time, the information about the standard input / output is sent to the development machine to execute the standard input / output function on behalf of the standard input / output function of the development machine. Similarly, it is possible to execute debugging on the program of the microprocessor of the developed device while looking at the CRT of the personal computer.

〔Example〕

 Hereinafter, the present invention will be described in detail with reference to examples.

First, in a cross development environment as in the present invention, when developing and evaluating a microprocessor program of a device under development using the same standard input / output functions as in the self development environment, for example, as shown in FIG. Data (“Var”) that is aaa while the cross-development program configured from address to FFF is being executed
If you want to see how has changed, insert a statement below “printf” (eg, “printf” (“a =% d”, Var) and set the value of the variable Var in decimal as “a = 1234”. (Instruction to display) In executing this, the microprocessor of the development target device cannot display this information, so that the information is displayed on the screen using the microprocessor of the personal computer of the development machine. Therefore, the microprocessor on the system of the developed device is always running, but when it encounters the place where the “printf” statement is inserted, the microprocessor on the personal computer detects it and displays the “Var” data for screen display. Through an emulator, and the data is displayed on a CRT by a personal computer, for example, "a = 1234".

FIG. 1 shows a basic configuration diagram for executing such a system. An emulator 2 is interposed between a development machine 1 and a development target device 3 such as a hot air heater or an air conditioner. 1 includes the operating system 4 and the emulator control software 6 as a matter of course. In the system of the present invention, the native information code of the microprocessor 13 of the device under development 3 and the standard input / output described in the source program of the compiler are stored in the object file 7 output by the compiler 5 including the basic software related to the development machine. Information, for example, in the case of the C language, getc, putc, printf, fprintf, scanf ₂ , f
Standard input / output function data such as scanf is included as debug information.

In this case, both can be included using different object record types.

In addition, the object file 7 can include symbol information of native information and symbol information of standard input / output information.

Thereafter, in the present invention, when developing and evaluating the program via an emulator as shown in FIG. 1, the native information, standard input / output information, symbol information of native information, and standard information included in the loadable object file 7 are included. Of the symbol information of the input / output information, the native code is loaded into the memory 12 of the emulator, and the others are loaded into the memory 8 of the development machine or the memory 9 of the emulator in various formats described later.

When the program is executed, the emulator 2 is provided with a function of determining whether to execute the emulation memory or substitute for the standard input / output based on the type of the symbol specified by the breakpoint, and separating the execution. In FIG. 1, reference numeral 7 denotes a loadable object file, and reference numeral 7 'denotes a record format of an absolute format object program output by the cross compiler. Reference numeral 8 denotes a host machine memory, and reference numerals 9 and 12 denote emulator memories, each of which indicates a type of data to be loaded therein.

Incidentally, the data in the emulator memory can be included in the memory 8 of the development machine.

The emulator used in the present invention has a function of controlling a program of a microprocessor of a device under development, and has a function of substituting the microprocessor and its peripheral resources when necessary by using the hardware of the emulator. I just need.

Usually, once the program of the microprocessor of the device under development starts, it is executed in the device under development and cannot be stopped at a desired address. Therefore, the emulator stops or advances the operation of the microprocessor of the device under development. Specifically, a socket attached to the end of a lead wire drawn out of an emulator main body (hardware), which is generally called a probe, is inserted into a trace where the microprocessor has been removed from the device to be developed, and the microcontroller of the emulator receives the socket. It controls the program of the development device (that is, runs or stops the program, to which address it is executed, etc.), and the hardware itself does not have to be so complicated. Next, in the present invention,
It is necessary to prepare a cross compiler including the basic software for operating this system.

 Such a cross compiler is, for example, MS-DOS (Microsoft
Ft operating system ) Control under the environment
A microcontroller cross compiler
You. This cross compiler uses print f_Two C words such as scan f
If the standard input / output function of the word is described in the source program,
Output standard input / output records. In the present invention,
Corresponding to the standard input / output function from the standard input / output record
Transfer the host machine code to the microprocessor
Memo in the form of a subroutine at the host computer
Load it during Re8.

On the other hand, the emulator 2 has a standard input / output interrupt table corresponding to the standard input / output record when the program is loaded.
11 and a standard input / output symbol table 10
Store in.

As described above, the standard input / output interrupt table
Although the data 11 and the standard input / output symbol table 10 can be stored in the memory 8 of the development machine, it is not advisable to provide the table on the development machine because the speed of data processing is reduced.

The execution procedure of the system according to the present invention will be described below with reference to the flowchart of FIG. 3. The emulator transfers the execution address to the emulator during the execution of the program of the device under development (step a) (step b). Whether the address matches the interrupt address of the standard input / output interrupt table created in the memory (RAM) on the emulator (hardware) is compared for each instruction (step c), and if it matches one of the addresses in the table For example, if the current address matches the address 200h (“printf” statement) in the table, the emulator stops the program execution of the developed device based on the information (step d) and selects function information (step e). Is sent to the microprocessor of the development machine (step f) and the standard input / output function (print or
(CRT display etc.) is interrupted (step g).

When the program is executed, the standard I / O interrupt address is considered as a software breakpoint, and an interrupt is generated. At that point, the emulator holds the microprocessor of the device under development, and refers to the information in the standard I / O interrupt table to determine the standard I / O interrupt table. Judge whether to execute the input / output function part and transfer control to the host machine. The host machine executes standard input / output processing and returns control to the emulator when finished.

After this processing is completed, the emulator resumes the execution of the system of the developed device (step h).

As another specific example, the standard input / output interrupt table is created in the microprocessor of the development machine, and the execution state is transmitted to the microprocessor of the development machine via the emulator during execution of the system of the development target device. Therefore, the same comparison processing as described above may be performed, and if the execution address matches one of the interrupt addresses on the table, the information may be returned to the emulator and the same processing as described above may be performed. According to the present invention, while controlling the emulator with the program of the microprocessor of the host machine, an instruction is sent to the hardware of the emulator, the information of the microprocessor of the device to be developed is read by the emulator, and the information is transferred to the development machine. The information is read and compared to confirm how the data has changed.

Next, the data structure of the loadable object file and the data structure of the standard input / output function, the same symbol table or the same interrupt table used in the present invention will be described.

As shown in FIG. 4, this object file is created from a unit (a) in the form of a record, so that this file is composed of a collection of this data block (a).

The data block will be described below using a simple example. The configuration is made up of a record identification number, a record length, and the contents of a record. This record is roughly classified into a data record and a debug information record, and details thereof will be described below, but the above description is omitted.

First, the contents of the data record have a unit configuration (b) as shown in FIG. 5, a program load address indicating from which address the data is to be loaded, and a data length indicating the byte length of the data of the following part. And the content of the data to be loaded into the memory.
Is loaded into the memory.

When this data record is read by the emulator and loaded into the emulation memory, the loading result is as shown in FIG. For example, if the address is 200h, the data length is 16 bytes, and the content of the data is 010203..., This is loaded into the hatched portion of the emulation memory 15.

Looking at the debug information record, on the other hand, debug information is mainly symbol information prepared for smooth emulation, for example, consisting of numerical values, variables, and jump destination symbols, which are output by a compiler or assembler. It is.

The unit configuration (c) of this record is composed of a symbol type, symbol data and a symbol definition number as shown in FIG.

Here, the symbol type generally includes a numerical symbol, a variable, and a branch destination label (a jump destination label).

The symbol data is the data held by the symbol. If it is a numerical symbol, the numerical value itself, a variable, or, if it is a label, the address is stored therein.

The symbol definition number is a serial number assigned to the symbol in the order defined by the compiler or assembler.

The emulator stores this record in the memory of the microprocessor of the development machine or in the memory (RA
M), the symbol table 16 shown in FIG. 8 is stored in the memory (host machine memory) of the microprocessor.
8 or on a memory 9 (RAM) of the emulator. If the label 1 (16-1) in FIG. 8 is "Var" (variable), for example, Sym1- (1) (corresponding to the symbol type) is 1, and Sym1- (2) is equivalent to the symbol data.
200h, Sym1- (3) (corresponding to the symbol definition number) is formed as 1. Sym at label n (16-3)
The same applies to n- (1), Sym n- (2), and Sym n- (3).

Next, the configuration of the standard input / output record used in the present invention will be described. For example, printf, fputc ₂ fgetc, fprintf, fscanf, etc., which are standard input / output functions using high-level languages, can be generally considered as console input / output functions.Input indicates input by keyboard, output indicates display on TV etc. I have. Then, when the standard input / output function is described in the source program, the compiler outputs a standard input / output record (d) as shown in FIG.

The configuration of the record (d) includes a part for numbering a standard input / output function identification number, a standard input / output function interrupt address part for storing an address where the standard input / output function is described, and standard input / output function information. The standard input / output function identification number is assigned in advance as, for example, 1: printf 2: fputc 3: fgetc 4: fprintf 5: fscanf, and any one of these is stored in this part. . The standard input / output-related interrupt address is, for example, the function. If “printf” is at address 200h, this portion will be 200h, and if the program tries to execute the processing at this address, an interrupt will occur and “printf”
An instruction is issued to perform the processing of "f". Further, the function information part contains information specific to the built-in function, and this field differs depending on each function. Since the structure of this data is enormous, "print The case where f "is used will be described as an example.

 Now, the format of "print f" is expressed as follows in C language.

print f (format, arg1, arg2,... argn) where arg1... argn is data to be displayed, and the data configuration is as shown in FIG.

In the figure, the content of format is entered as a character string. That is, an instruction sentence indicating what form should be displayed is inserted. For example, if you set print f (“AB =% d”, Var), Var
Indicates that the value of this variable is to be displayed in decimal, and if the value of Var is now 12, AB = 12 is displayed on the CRT.

Then the parameter -1 ₂ -2 add symbol definition number defined in the symbol information described above. This corresponds to arg1, arg2, ... argn, respectively. If the symbol definition number is known, the actual address where the value is stored can be found by referring to the table. That is, 1 of the symbol 1- (3) of the label 16-1 or N of the symbol n- (3) of the label 16-3 in FIG. 8 is a symbol definition number, and is a memory on the microprocessor of the development machine or the emulator. By referring to the symbol table created in (1), the stored value can be determined from the stored real address.

When this record is loaded by the emulator, a standard input / output interrupt table 17 as shown in FIG. 11 is created once each time it is loaded on the memory of the microprocessor of the development machine or on the RAM of the emulator.

As shown in FIG. 11, this table includes a standard input / output interrupt address, a standard input / output function identification number, and a function information storage address.

The standard input / output interrupt address corresponds to, for example, the address 200h corresponding to the second data record, that is, indicates where in the program the standard input / output is to be interrupted and executed. Also, as the standard input / output function identification number, for example, 1 is entered in the case of "print f". Further, the function information storage address contains the function information shown in FIG. 9 described above. However, since it is complicated to store all the function information, this information is created in another table, and only the address is stored. It may be stored. The standard input / output interrupt table 17 may be provided on the microprocessor (so-called personal computer) of the development machine. However, the processing speed can be increased by adding a memory to the emulator and providing the table.

There are several standard input / output interrupt addresses in the standard input / output interrupt table 17, all of which are considered software breakpoints, and each execution of one instruction is compared, that is, whether the breakpoint matches the current address. The emulator instructs the host computer (personal computer) of the development machine to execute the standard input / output processing if they match. When the processing is completed, the control is returned to the original program. Conventionally, it is important to evaluate such a program in real time and check it without slowing down the microprocessor speed.Therefore, hardware breakpoints are usually provided and programs are compared by hardware. At most four hardware breakpoints are provided to keep the program from slowing down. On the other hand, the method of examining a program by a software breakpoint is not suitable for real-time processing because the speed of the emulator is reduced because it is examined for each instruction. However, in the present invention, processing using the standard input / output function is to display on the screen and to stop the execution of the program during that time, so that the problem of real-time processing is eliminated, and software is only used for logic check. You can use breakpoints.

Therefore, the comparator on the microprocessor or emulator of the development machine compares the interrupt address as a software breakpoint with the current address, and if the interrupt address matches, the emulator recognizes it and what standard I / O interrupt function is used The function information is determined by referring to the function information, and is instructed to the microprocessor of the development machine. Also, for example, a subroutine group for standard input / output processing prepared in advance is used for the microprocessor, and the processing result is displayed on a CRT screen.

When the display is completed, the emulator returns to the original control of the system of the developed device and executes the next program.
Since the emulator looks at the program of the microprocessor of the development target device, the address of the process being executed at that time can be confirmed, and the address information is transmitted to the microprocessor of the development machine. Since this communication time is considerably long, it is preferable to provide the table in the emulator as described above. This address is compared with the address of each frame in the standard input / output interrupt table. If all the addresses do not match, the process proceeds to the next step. If there is a match, the above processing is executed.

In the present invention, it is not always necessary to provide a hard breakpoint, but it is necessary to provide a hard breakpoint for real-time processing.

〔The invention's effect〕

As described above, according to the present invention, even in a cross development environment using an emulator, high-level language-specific debugging that is the same as in a self-development environment can be performed, and a large number of printf statements called stubs are placed in the middle of a source program. Debugging techniques can be used.

In addition, even a person who is accustomed to a large-scale general-purpose programming environment can enter a microcomputer control program without any discomfort.

[Brief description of the drawings]

FIG. 1 is a basic configuration diagram of a microprocessor program development system according to the present invention. FIG. 2 is a diagram showing an example of a program used in the present invention. FIG. 3 is an execution flowchart of the system according to the present invention. FIG. 4 is a diagram showing a data structure of an object file used in the present invention. FIG. 5 is a diagram showing the structure of a data record used in the present invention. FIG. 6 is a diagram showing a file state when a data record is loaded into the memory of the emulator. FIG. 7 is a diagram showing a configuration of a debug information record used in the present invention. FIG. 8 is a diagram showing an example of a symbol table used in the present invention. FIG. 9 is a diagram showing the structure of a standard input / output record used in the present invention. FIG. 10 is a diagram showing the structure of fields relating to function information in the standard input / output record of FIG. FIG. 11 is a diagram showing an example of a standard input / output interrupt table. 1 Development machine 2 Emulator 3 Developed device 7 Cross compiler 7 'Record format of object program in absolute format output by cross compiler 8 Memory of development machine 9, 12 ... Emulator memory 10 ... Standard input / output data symbol table 11 ... Standard input / output interrupt table 13 ... Microprocessor

──────────────────────────────────────────────────続 き Continued on the front page (58) Field surveyed (Int.Cl. ⁶ , DB name) G06F 9 / 44,9 / 45 G06F 11/28

Claims (1)

(57) [Claims] 1. A development machine which incorporates at least an operating system and a system for controlling an emulator and executes development of a microprocessor program in a device under development, an emulator controlled by the development machine, and an emulator connected to the emulator. A cross-development environment comprising a development device having a microprocessor whose program is controlled by the emulator, wherein the microprocessor of the development machine and the microprocessor of the development device operate in different machine languages In a system for developing a program of a microprocessor in a device under development, the object file output by the compiler loaded on the development machine contains information for controlling the microprocessor of the device under development and program development in advance. Means for storing the standard input / output information for executing the required standard input / output function, storing the control information of the microprocessor of the developed device in the memory of the emulator when the object file is loaded into the system. Means for storing standard input / output information including a subroutine for executing the standard input / output function in a memory of the development machine; and a standard input / output symbol table and a standard input / output interrupt table for the standard input / output information. And a means for storing in the memory of the development machine in any of the memories of the emulator, and comparing and detecting execution information of a microprocessor program of the development target device and information of the standard input / output interrupt table. Means are provided in the emulator, and the emulator is Reads the execution information of the program at emulator 1 each instruction upon to perform controls Lee black processor program,
The comparison and detection means compares the execution information with the information in the interrupt table. If the two match, the emulator instructs to halt the execution of the program of the microprocessor of the device under development, A microprocessor for a device under development, wherein function information is selected from the standard input / output symbol table and sent to the development machine, and the standard input / output subroutine corresponding to the standard input / output function information is executed by the development machine. Program development system.