JPH05303497A - Object code output system for language processing program - Google Patents

Abstract

PURPOSE:To prevent the generation of operation counter to a program designer's purpose when a microcomputer system adopting a memory inhibited to read out the same data again once reading out data by prereading executes an object program. CONSTITUTION:When an instruction for reading memory exists (step 110) in a source program and an interruption enabled state is held (step 111) in a system for reading out a source program and converting the read program into an object code for loading the program to a microcomputer, after an interruption inhibiting object code is outputted, then the object code of the (memory reading) instruction is outputted.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an object code output system for a language processing program, and more particularly to an object code output system used to obtain an instruction set of an object code to be mounted on a microcomputer system.

[0002]

2. Description of the Related Art FIG. 3 is a block diagram of a host machine on which a language processing program runs, which is used when developing a program to be mounted on a microcomputer system. The host machine 301 receives the operation command of the language processing program input by the user, and displays the processing result on the console 302. The arithmetic unit 303 inputs the source program created by the user and stored in the external storage device 304, analyzes the source program, generates an object code, and stores the generated object code in the external storage device 304. To store. The object code thus obtained is burned in a ROM incorporated in a microcomputer, for example, and is used in a user's application device.

FIG. 4 is a flow chart showing an object code output method of a conventional language processing program executed by the host machine of FIG. First, the source program is opened (step 401), and 0 is assigned to the variable n as an initial value in order to manage the lines of the source program (step 402). When the value of n is increased (step 403), n becomes 1. The first command is input (step 404) and the object code is output (step 405).

Next, it is determined whether the source program is the last (step 406). If the source program is the last one, the source program is closed (step 407). If the source program is not the last, the value of n is set to 1 until the end of the source program is reached.
The number is incremented (step 403), the next command is input (step 404), and the object code is output (step 405).

[0005]

In the object code output by the above-mentioned conventional method, the microcomputer system in which this object code is implemented performs prefetching of data, and once the memory read is performed. If a memory that cannot read the same data is used, the following problems will occur. Figure 5
FIG. 4 is a diagram showing a memory state of a FIFO memory as a memory in which data that has been read once cannot be read again. The memory is in the state shown in (a), assuming that data A, B, C, and D are input in this order. Here, if the contents of the memory are read once, A is read and the contents of the memory become the state shown in (b).

It is assumed that there is an instruction for reading a memory in a state where the microcomputer is in an interruptable state during execution of a program, and an interrupt occurs immediately before this instruction. In a microcomputer system in which a microcomputer prefetches an instruction, data in the memory is prefetched in accordance with the instruction for memory read before executing the instruction for memory read. In the case of the memory shown in FIG. 5, the first read data A is read. Next, since an interrupt has occurred, the memory read instruction is not executed, the interrupt process is performed, and then the operation returns to the memory read instruction. The data A in the memory that has been read in advance before the interrupt occurs is erased, but the data in the memory is read again in order to execute the instruction for memory read. Originally, the data A should be read, but in the example of FIG. 5, the data B is read from the contents of the memory. Therefore, it causes a program operation contrary to the intention of the program creator.

Further, for example, when the applied device is a FAX, if an interrupt is raised during reception, the receiver malfunctions due to the above reason and sends an error message to the transmitter side. Upon receiving the error message, the transmitter side enters a transmission waiting state in order to retransmit the data to the receiver side. Since the above operation is repeated, it takes a long time for transmission and reception, and the FAX line is occupied during that time, which causes a problem that another FAX cannot transmit even if it tries to transmit.

[0008]

According to the object code output method of a language processing program of the present invention, a source program is read and analyzed to output an object code for a microcomputer system. In the source program, if there is an instruction to read data in the interrupt enable state, insert an interrupt prohibition instruction before the instruction to read data and output it to the object code. Is characterized by.

[0009]

Embodiments of the present invention will now be described with reference to the drawings. FIG. 1 is a flow chart showing an object code output system of a language processing program according to a first embodiment of the present invention. The host on which this language processing program runs
The configuration of the machine is shown in FIG. That is, the source program created by the user is stored in the external storage device 304, and the arithmetic device 303 reads and analyzes it.
Generate object code. The generated object code is temporarily stored in the arithmetic unit 303,
It is later transferred to the external storage device 304.

As shown in FIG. 1, first, a source program is opened (step 101), and an initial value 0 is assigned to a variable n for managing the lines of the source program to determine whether an interrupt is prohibited. Variable ei for managing
The initial value 1 is substituted into (step 102). When ei is 1, interrupts are enabled, and when ei is 0, interrupts are disabled. Also, in the source program, EI
If there is an instruction, the interrupt is enabled, and if there is a DI instruction, the interrupt is disabled. When neither the EI instruction nor the DI instruction is specified in the source program, it is considered as an interruptable state.

Next, the value of n is incremented by 1 (step 10
3) Input n (1) th instruction (n becomes 1) (step 104). It is determined whether or not the nth instruction is a DI instruction (step 106). If it is a DI instruction, e
i = 0 (step 107), and the nth instruction is E
It is judged whether or not it is the I command (step 108), and if it is the EI command, ei = 1 is set (step 109).

Next, it is judged whether or not the nth instruction is a memory read instruction (step 110), and ei
It is determined whether or not = 1 (step 111). The nth object code is output when the nth instruction is not a memory read instruction and when the memory read instruction is not ei = 1 (that is, in the interrupt disabled state). .. (Step 114).
The n-th instruction is a memory read instruction and ei =
When it is 1 (that is, in the interrupt enable state), the object code of the DI instruction is output (step 112),
Output the nth object code (step 11
3) output the object code of the EI instruction (step 115), and ei to manage the interrupt enable state.
Is returned to 1 (step 116).

Next, it is judged whether or not the source program is the last (step 117). If it is the end of the source program, the source program is closed (step 118). When the last output of the source program is not made, the process returns to step 103 and the above operation is repeated until the end of the source program.

In the microcomputer system in which the object code thus obtained is mounted,
When a memory read instruction is executed, interrupts are disabled, so a microcomputer system that prefetches an instruction cannot read the same data again after reading the same data. Even if O is adopted, the interrupt is not executed immediately before the data read instruction, and there is no inconvenience that the prefetched data is erased.
Malfunctions caused by reading erroneous data are prevented.

FIG. 2 is a flow chart showing the second embodiment of the present invention. The present embodiment relates to an example of outputting an assemble list. Normally, a line number, a source code, and an object code corresponding to the source code are output to the assemble list as a set of data. The assemble list is output to the console or printer and used for debugging and maintenance.

The difference of this embodiment from the previous embodiment shown in FIG. 1 is that in step 212 to step 215 corresponding to step 112 to step 115, the object code and the source code paired therewith are stored. Output points and step 212 and step 215
The point is that the mark is added to the output.

"With mark" means that a symbol such as * is added to the head of the line number, for example. By adding a symbol, it can be understood that the instruction is the instruction inserted by the language processing program when the assemble list is output to a printer or the like, which facilitates debugging and maintenance.

[0018]

As described above, in the microcomputer system in which the object code obtained by the object code output method of the language processing program of the present invention is mounted, the interrupt is performed immediately before the execution of the memory read instruction. Will not occur, so even if a microcomputer system that reads data in advance reads data once and the memory and I / O that cannot read the same data again are used, the data read in advance will disappear. It is possible to prevent malfunction of the program processing that is caused.

[Brief description of drawings]

FIG. 1 is a flowchart showing a first embodiment of the present invention.

FIG. 2 is a flow chart showing a second embodiment of the present invention.

FIG. 3 is a configuration diagram of a host machine on which a language processing program according to an embodiment of the present invention and a conventional example run.

FIG. 4 is a flowchart of a conventional example.

FIG. 5 is a diagram showing a state of a FIFO memory.

Claims (1)

[Claims] 1. In an object code output method of a language processing program, which inputs a source program, analyzes it, and outputs an object code to a microcomputer system, in a source program, data in an interruptible state in a source program. If there is an instruction to read, insert an interrupt disable instruction before the instruction to read the data, and
An object code output method for language processing programs characterized by outputting a code.