JP3088286B2 - Program runaway detection circuit, detection method, detection software development apparatus, and software generation method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program runaway detection circuit, a detection method, a detection software development apparatus, and a software generation method thereof, and more particularly to a program runaway detection circuit for detecting whether a program executed by a microcomputer has runaway. The present invention relates to a software development apparatus for generating a runaway detection object program for a microcomputer with a built-in program runaway detection circuit, and a detection software generation method therefor.

[0002]

2. Description of the Related Art Referring to FIG. 6, which shows a configuration example of a conventional runaway detection using a watchdog timer, a watchdog timer 15 is generally constituted by a free running counter. , The free running counter is cleared.

When the free running counter overflows, a reset signal RESET bar is output.

As a function of a free running counter, there is a method using a charge / discharge of a capacitance element and a resistance element in addition to a function using a digital counter.

The general microcomputer 16 has a reset signal RESET bar input and a port output, and only the main part is shown inside. The ROM 162 includes an address latch 164, an address decoder 165, a ROM cell array 166, a sense amplifier 167, and an output buffer 168. The reset input terminal of the microcomputer 16 is connected to the reset output terminal of the watchdog timer 15, and the cancel pulse output terminal of the microcomputer 16 is connected to the cancel pulse input terminal of the watchdog timer 15.

FIG. 7A showing a flowchart of a method of detecting runaway of the microcomputer 16 using the watchdog timer 15 and FIG. 7B showing an operation timing chart thereof will be described. ,
After initialization (S3)
At the time of the normal operation of 1), it is determined whether or not the timing detection time has elapsed (S32), and when a predetermined time, that is, the main cycle has elapsed, the watchdog timer 1 is set for each main cycle.
5 was output from the general-purpose port (S3
3) Later, the main processing is executed (S34).

If the microcomputer 1 runs away during the execution of the main cycle (for example, when the microcomputer 1 enters an infinite loop during the main cycle), the microcomputer 1 does not output the cancel pulse thereafter.

When the cancel pulse is no longer input, the watchdog timer 15 outputs a reset signal after a runaway detection time has elapsed.

When the reset signal RESET bar is input, the microcomputer 16 is reset and normally executes the program from address 0.

Further, an example of a conventional runaway detection method is described in Japanese Patent Application Laid-Open No. 5-257746. Referring to FIG. 8, which shows a configuration of a runaway detection circuit and a software development device using the same, the runaway detection circuit is provided for detecting a program runaway state without being affected by a program structure. In the runaway detection operation, the program counter 20 is divided into an upper part 21 and a lower part 22, and the content of the upper part 21 is incremented by 1 in the increment unit 23 and stored in the latch 26. The counter 20 is incremented, and the comparator 25 compares whether the lower part 22 is equal to the value of the constant storage part 24, and when it is equal, or when a carry occurs from the lower part 22 to the upper part 21. , Upper part 21 of program counter 20 and latch 26
Are determined by runaway determination section 28 as to whether or not the contents are equal.

Further, when the branch instruction is executed, the latched contents do not always match the contents of the program counter upper part 21 after the branch even if the normal operation is continued. The flag 29 is set so that comparison is not performed immediately after the branch instruction.

[0012]

The above-described runaway detection circuit and runaway detection method using the watchdog timer according to the above-mentioned conventional method runaway when a program runs away and enters an infinite loop including a cancel pulse output process. Runaway cannot be detected because the cancel pulse continues to be generated despite the presence.

[0013] If the program runaway has just jumped to the ground and the program execution has not been significantly changed, the cancel pulse does not stop and runaway cannot be detected.

Further, the conventional runaway detection circuit and runaway detection method shown in FIG. 8 only confirm whether or not the contents of the upper part 21 of the program counter 20 are correct, and the lower part 22 incorrectly counts. In other words, when the program runs out of control, the error cannot be detected.

When a branch instruction is executed, the flag 2
Set 9 to make sure the comparison result is normal (no runaway)
Is output, and it is not possible to detect whether or not the branch has been performed normally when the branch instruction is executed.

An object of the present invention has been made in view of the above-mentioned drawbacks, and is intended to execute the normal execution of a program by accumulatively adding the value of a program counter at the time of program execution and comparing it with a checksum incorporated in an object program. , A runaway detection circuit and a runaway detection method for detecting runaway, a software development device for generating an object program of a microcomputer incorporating the runaway detection circuit, and a checksum for calculating the checksum in the device. It is to provide a software generation method.

A feature of the program runaway detection method of the present invention is that a program counter for counting program execution addresses is provided.
And the contents of the program counter are temporarily stored.
Address latch and respond to this address latch output
Address decoder that selects the address to be executed
And the opcode storage for object program instructions
ROM cell array consisting of
ROM cell array output opcodes and operands
・ Output buffer for inputting data via sense amplifier
Built into a single microcomputer with
In the program runaway detection circuit for detecting a runaway existence of a program the microcomputer to execute the said output
When decoding the opcode output by the force buffer,
Runaway for instructing the output of the operand data to
An instruction decoder for detecting a detection check instruction, an adder for cumulatively adding the contents of said program counter every time the program counter is incremented, and checksum buffer for holding the addition result, the of <br/> object professional project program instructions Ru stored
The runaway inspection previously arranged at an arbitrary position in the gram area
The checksum data stored in the operand part of the output check instruction and the checksum buffer output
And a comparator for comparing the cumulative execution value of the program execution address with
And the mismatch output signal of this comparator is
The microcontroller simultaneously with the detection of runaway of the program.
It is also about resetting the internal circuit of the computer itself .

Further, the comparator includes the object processor.
The object program in which program instructions are stored
The runaway detection check previously arranged at the end of the area
Checksum data stored in the operand part of the instruction
And the output data from the checksum buffer.
To compare the program execution address with the cumulative addition value.
Ru can be a comparator.

[0019] Further, the comparator may be arranged so that the object
The object program in which program instructions are stored;
Runaway detection that is pre-arranged immediately before a branch instruction
Check stored in the operand part of the check command
Sum data and the output data from the checksum buffer
The program execution address, which is the data
Ru can also be a comparator for.

Another feature of the program runaway circuit of the present invention
Is a program runaway by a microcomputer
A program runaway detection circuit that detects the presence or absence
A program counter for counting program execution addresses,
Each time the program counter is incremented
Adder for cumulatively adding the contents of the program counter
And a checksum buffer for holding the addition result,
Checks previously stored in object program instructions
Sum data and the output data from the checksum buffer
Program runaway detection consisting of a comparator that compares
In road, at the time of execution of the branch instruction of the program is to clear the checksum buffer.

The program runaway detecting method according to the present invention is characterized in that a program counting means for counting a program execution address, and an adding means for accumulatively adding the contents counted by the program counting means every time the program counting means is incremented. Checksum buffer means for holding the addition result of the addition means, and comparison means for comparing checksum data stored in advance in an object program instruction with output data from the checksum buffer means, Clearing the program counting means, clearing the checksum buffer means, reading one instruction specified by the program counting means, and determining whether the read instruction is a branch instruction or any other instruction Step to do If the instruction is a branch instruction, the checksum data is cleared; if the instruction is not a branch instruction, the address value of the instruction is added to the contents of the checksum buffer means. Determining whether or not the instruction is a check instruction for instructing the comparing means to output; if the result of the determination is not the check instruction, returning to the step of reading one instruction and reading the next instruction; If the result is the check instruction, comparing the checksum data with the operand value of the check instruction. If the comparison results in a mismatch, the microcomputer detects a runaway of the program executed by the mismatch signal. It is in.

The features of the apparatus for developing software for detecting program runaway of the present invention include a program counter for counting a program execution address, and an adder for accumulatively adding the contents of the program counter every time the program counter is incremented. A program runaway detection circuit including a checksum buffer for holding the addition result and a comparator for comparing checksum data previously stored in an object program instruction with output data from the checksum buffer. A software development apparatus for generating the object program of a computer, analyzing an input source program instruction, calculating checksum data of an execution address in program execution, and using the calculated checksum data as an Lies in comprising instructions incorporation unit that incorporates the object program instructions.

In addition, the check instruction incorporated in the object program and the checksum data serving as an operand of the check instruction are obtained by mapping the object program into an absolute address space when converting the source program into an object. The operand section is generated.

The program generating method for detecting a program runaway according to the present invention is characterized by a program counting means for counting a program execution address, and an adding means for accumulating and adding the contents of the program counter every time the program counting means is incremented. Program runaway detection, comprising: checksum buffer means for holding the addition result of the addition means; and comparison means for comparing the checksum data stored in advance in the object program instruction with the output data from the checksum buffer means. A software development method for generating an object program of a microcomputer using the means, wherein the step of clearing the checksum data and the step of reading one source program instruction to determine whether the instruction is a branch instruction. If the result of the determination is negative, a step of adding the assigned absolute address to the checksum data; and a step of determining whether or not the instruction is the check instruction. Returning to the step of reading the instructions, storing the value of the checksum data added and accumulated in the operand part of the check instruction if the result of the determination is the check instruction; and determining whether the instruction is the branch instruction. If it is determined that the instruction is a branch instruction, the step of clearing the checksum data is performed.

[0025]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, a program runaway detection circuit, a runaway detection and detection software development apparatus and a software generation method of the present invention will be described with reference to the drawings.

First, referring to FIG. 1 which shows a block diagram of the first embodiment, a ROM address currently being executed or a ROM address to be executed next is stored, and increment (1 is added) every time an instruction is executed. The program counter 1 to be executed, the contents of the program counter 1 are fetched, temporarily held, an address latch 2 to be output to the address decoder 3, and an address to be executed based on input data from the address latch 2 are selected. , Address decoder 3 for activating address lines of ROM cell array 4
And an operation code storage unit 5 and an operand storage unit 6 for storing instruction data groups converted from a program in advance and sensing the operation code and operand data stored at the address activated by the address decoder 3. The ROM cell array 4 to be output to the amplifier 7, the operation code storage unit 5 for storing the instruction code of the program, the operand storage unit 6 for storing the operand of the instruction, and the operation code and the operand data output from the ROM cell array 4 are input. , Output buffer 8
, An output buffer 8 which receives and amplifies an opcode and operand data output from the sense amplifier 7 and outputs the amplified data to an instruction decoder 9.
An instruction (hereinafter referred to as a check instruction) for instructing input of the operand data output from the output buffer 8 to the comparator 12 as a result of interpreting the operation code input from the output buffer 8 and further interpreting the operation code. , An adder 10 that inputs the contents of the program counter 1 and the checksum buffer 11, adds the contents, and outputs the addition result to the checksum buffer 11. A checksum buffer 11 for storing the contents as needed and outputting the stored contents to a comparator 12, an instruction operand portion of an output buffer 8 and data of the checksum buffer 11 are input via switches 13 and 14, respectively, and a comparison result is output. And a comparator 12.

Here, the number of bits of the adder 10 is arbitrary, but is desirably equal to or more than the number of bits of the program counter 1. The number of bits of the checksum buffer 11 is arbitrary. It is desirable that the number of bits be equal to or more than the number of bits.

In the runaway detection circuit having the above-described configuration, the contents of the program counter 1 are updated with the execution of the program, the updated contents are added, the addition result is stored in the checksum buffer 11 as needed, and the check instruction is sent. When the instruction decoder 9 detects, the checksum buffer 1
The program runaway state is detected by comparing the content of 1 with the operand data of the check instruction by the comparator 12.

A specific operation using such a runaway detection circuit will be described using a simple program example.
Referring to FIG. 2 showing a program for explaining the runaway circuit and FIG. 3 showing a flowchart of the program runaway detection method, after the microcomputer is reset, the contents of the program counter 1 and the checksum buffer 11 are “0000h”. (S1, S2).

The program counter 1 stores an instruction that does not branch afterwards, such as a NOP instruction or a transfer instruction.
It is incremented each time a command is read and executed (S3, S4). When the program counter 1 is "0000"
When "h", the checksum buffer becomes "0000h".

That is, if the program counter 1 is "00"
While address 0 is being executed at "00h", the content "0000h" of the program counter 1 and the content "0000h" of the checksum buffer 11 are added by the adder 10, and the result "0000h" is stored in the checksum buffer 11. (S5).

Next, the program counter 1 is incremented to "0001h".

When the program counter 1 is "0001h", the checksum buffer 11 is "0001h".

That is, if the program counter 1 is "00"
While address 1 is being executed at 01h, the content "0001h" of the program counter 1 and the content "0000h" of the checksum buffer 11 are added by the adder 10, and the added result "0001h" is stored in the checksum buffer 11. .

Further, the program counter 1 is incremented to "0002h". When the program counter 1 is “0002h”, the checksum buffer 1
1 is “0003h”.

That is, if the program counter 1 is "00"
While address 2 is being executed at 02h, the content "0002h" of the program counter 1 and the content "0001h" of the checksum buffer 11 are added by the adder 10, and the added result "0003h" is stored in the checksum buffer 11. .

Further, the program counter 1 is incremented to "0003h". At address 3, a check command and checksum data are stored. When the program counter 1 is "0003h", the checksum buffer 11 is "0006h".

That is, the program counter 1 is set to "00".
While address 2 is being executed at 02h, the content "0002h" of the program counter 1 and the content "0001h" of the checksum buffer 11 are added by the adder 10, and the added result "0006h" is stored in the checksum buffer 11. I do.

Simultaneously (program counter = “0003”
h)), when the instruction decoder 9 interprets that the instruction is a check instruction (S6), the contents of the checksum buffer 11 (= "0006h") are compared with the value of the operand part of the check instruction (= "0006h"). The container 12 compares (S
7).

Since the contents of the checksum buffer 11 and the value of the operand portion of the check instruction are the same, a match signal is output from the comparator 12 (S8).

After the execution of the check command, the contents of the checksum buffer 11 are automatically set (cleared) to "0000h" (S10), the program counter is incremented by 1 (S11), and thereafter, the above-described operation is performed. The same operation as the operation is repeated.

The above operation is performed by the program counter 1
But 0000h → 0001h → 0002h → 0003h
And the case where it changed normally.

Next, when the program counter 1 does not change normally, for example, 0000h → 0002h → 00
The operation changed to 03h (when 0001h is skipped) will be described.

When the microcomputer is reset, the contents of the program counter 1 and the checksum buffer 11 become "0000h" (S1, S2) as described above.

Next, it is assumed that the place where the program counter 1 should be incremented to "0001h" is suddenly changed to "0002h" due to disturbance such as noise.

At this time, the program counter 1 is set to "00".
During execution of address 2 at "02h", the content "0002h" of the program counter 1 and the content "0000h" of the checksum buffer 11 are added by the adder 10, and the added result "0002h" is stored in the checksum buffer 11 ( S5).

Further, the program counter 1 is incremented to "0003h". At address 3, a check command and checksum data are stored. While the program counter 1 is executing address 3 at "0003h", the content "0003h" of the program counter 1 and the content "0002h" of the checksum buffer 11 are added by the adder 12, and the added result "0005h" is checked. The data is stored in the buffer 11 (S5).

Simultaneously (program counter = “0003”
h ”), when the instruction decoder 9 interprets that the instruction is a check instruction (S6), the comparator 12 compares the contents of the checksum buffer 11 (=“ 0005h ”) and the value of the operand part of the check instruction (=“ 0006h ”). Compare (S
7).

Since the contents of the checksum buffer and the value of the operand portion of the check instruction do not match, the comparator 12 outputs a mismatch signal (reset signal) (S).
9).

As described above, when the value of the program counter 1 changes to an unintended abnormal value due to disturbance such as noise, it is possible to detect the abnormality and output a mismatch signal from the comparator 12. .

Further, if the output of the comparator 12 is used as a reset signal of the microcomputer, the microcomputer can be automatically reset simultaneously with the detection of the abnormality.

In the first embodiment described above, the operation in the case of executing an instruction that does not branch an address, for example, a NOP instruction or a transfer instruction has been described. Usually, of course, the program also contains a branch instruction, so the second
In the embodiment, the operation at the time of executing the branch instruction will be described.

Referring to FIG. 4 showing an example of a program including a branch instruction, the checksum buffer 11 is cleared when the branch instruction is executed. The branch destination of a normal program branch should be the start address of each program module.

For example, the module A conditional branch instruction points to the head address of module C as indicated by the arrow in the figure. Therefore, if a check instruction is executed at the end of each of the program modules A, B, and C, a runaway from the beginning of the program module can be detected.

When an abnormal program branch is taken as indicated by an arrow in the figure, that is, when a conditional branch instruction of the program module A branches to an address in the middle of the program module C, the last check of the program module C is performed. Runaway can be detected by an instruction.
Similarly, if a check instruction is executed at the end of each of the program modules A, B, and C, a runaway from the middle of the program module can be detected.

Next, a software development apparatus for generating an object program stored in the ROM cell array 4 according to the first and second embodiments will be described.

In the above-described first and second embodiments, a dedicated instruction for detecting runaway (check instruction and checksum data corresponding to the operand of the check instruction)
Is incorporated in the object program, and it is assumed that the object program is stored in the ROM cell array 4 in advance.

An object program incorporating this dedicated instruction is generated by a general software development device (not shown). This software development device is generally software that generates a personal computer and an object program that operates on the personal computer.

When converting the source program described in the assembler language shown in FIG. 2 into an object program or mapping the object program to an absolute address, the software for generating the object program operates the operand of the check instruction. (Checksum data) and automatically generate an operand value.

Alternatively, an object program other than the checksum data may be once created by the assembler and the linker, and then the checksum data may be generated by dedicated software.

Referring to FIG. 5, which is a flowchart showing an example of the algorithm for generating the checksum data, first, the checksum data is set to 0 (S11).

The source program is read for one instruction (S
12) It is determined whether the instruction is a branch instruction (S13). If it is not a branch instruction, the assigned absolute address is added to the checksum data (S14). This operation is performed until the check command is read (S15).

When the check instruction is read, the value of the checksum data that has been cumulatively added is stored in the check instruction operand section (S16).

Thereafter, the checksum data is set to 0, and the same processing is repeated until the check command is read again.

When a branch instruction is read, the checksum data is set to 0.

In order to effectively use the runaway detection method, a check instruction is arranged immediately before a branch instruction. This makes it possible to detect runaway of the program up to immediately before the branch instruction, and to detect whether or not the branch has taken place normally at the time of branching (whether or not a branch has taken place at the beginning of the program module).

[0067]

The program runaway detection circuit, detection method, detection software development apparatus and software generation method of the present invention described above provide a program counter for counting the program execution address, and a program for each time the program counter is incremented. It has addition data obtained by accumulatively adding the contents of the counter, checksum data that is accumulatively added to the program execution address and stored in advance in the object program instruction, and a comparator that compares the added data with the checksum data. There is a method to detect runaway by comparing the added data with the checksum data.By accumulating the value of the program counter at the time of program execution and comparing it with the checksum built into the object program, the normal execution of the program is improved. Details It can be monitored. Furthermore, a microcomputer software development device having a built-in runaway detection circuit, which analyzes an input source program instruction, calculates a checksum of a program execution address,
The provision of the instruction incorporation means for incorporation into the object program instruction makes it possible to easily create checksum data, thereby contributing to an improvement in microcomputer software development efficiency.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a program runaway detection circuit according to a first embodiment of the present invention.

FIG. 2 is a diagram showing a simple program for explaining a program runaway detection circuit.

FIG. 3 is a flowchart of a program runaway detection method.

FIG. 4 is a diagram showing an example of a program including a branch instruction.

FIG. 5 is a diagram showing a software generation algorithm incorporated in a software device for generating a program for a program runaway detection circuit.

FIG. 6 is a configuration diagram of a conventional runaway detection using a conventional watchdog timer.

FIG. 7 is a flowchart of a conventional method for detecting runaway of a microcomputer using a watchdog timer.

FIG. 8 is a diagram showing a configuration of a conventional runaway detection circuit and a software development device using the same.

[Explanation of symbols]

 1, 20, 161 Program counter (PC) 2, 164 Address latch 3, 165 Address decoder 4, 166 ROM cell array 5 Opcode storage unit 6, Operand storage unit 7, 167 Sense amplifier 8, 168 Output buffer 9, 163 Instruction decoder DESCRIPTION OF SYMBOLS 10 Adder 11 Checksum buffer 12, 25, 27 Comparator 13, 14 Switch 15 Watchdog timer 16 Microcomputer 21 Upper part 22 Lower part 23 Increment part 24 Constant storage part 26 Latch 28 Runaway judgment part 29 Flag 162 ROM part

Continuation of the front page (58) Field surveyed (Int.Cl. ⁷ , DB name) G06F 11/28-11/34 G06F 9/45 G06F 11/00 350

Claims (8)

(57) [Claims] 1. A program for counting a program execution address.
Gram counter and the contents of the program counter.
The address latch to hold and the address latch
Address that selects the address to be executed in response to the output
.Decoder and operation code of object program instruction
ROM cell storage consisting of a memory storage unit and an operand storage unit.
Ray, the opcode of this ROM cell array output, and
Operand data input via sense amplifier
In a single microcomputer with a power buffer
It is built, the program runaway detection circuit for detecting a runaway existence of a program which the microcomputer executes, decrypting the opcode said output buffer outputs
And output of the operand data
Instruction decoder for detecting runaway detection check instruction
When the adder contents of said program counter accumulatively adds each time the program counter is incremented, and checksum buffer for holding the addition result, the object program instructions Ru stored of
Is located beforehand at any position in the project program area.
Stored in the operand section of the runaway detection check instruction
Out the checksum buffer with the checksum data
And a comparator for comparing the output of the comparator with the cumulative addition value of the program execution address.
As a set signal, at the same time
Program runaway detection circuit, wherein a reset to Rukoto the operation of the microcomputer itself. 2. The checksum data stored in an operand portion of the runaway detection check instruction which is preliminarily arranged at the end of the object program area where the object program instruction is stored, and the checksum 2. The program runaway detection circuit according to claim 1, wherein the comparator is a comparator for comparing the output data from the buffer with a cumulative sum of program execution addresses. 3. The method according to claim 1, wherein the comparator is configured to execute a check sum data stored in an operand portion of the runaway detection check instruction which is arranged in advance immediately before a branch instruction in the object program area in which the object program instruction is stored. 2. The program runaway detection circuit according to claim 1, wherein the comparator is a comparator for comparing the output data from the checksum buffer with a cumulative addition value of a program execution address. 4. A program executed by a microcomputer.
This is a program runaway detection circuit that detects the runaway of the ram.
The program module that counts program execution addresses
Counter and the program counter are incremented.
Each time the program counter is added
Adder, and a checksum buffer that holds the addition result.
And stored in the object program instruction in advance.
Checksum data and the data from the checksum buffer
A program including a comparator for comparing with output data
In run detection circuit, when a branch instruction execution programs characterized by clearing the checksum buffer
Program runaway detection circuit to be. 5. A program counting means for counting a program execution address, an adding means for accumulatively adding the contents counted by the program counting means each time the program counting means is incremented, and a result of the addition by the adding means. Clearing the program counting means by using a held checksum buffer means, and comparing means for comparing checksum data previously stored in an object program instruction with output data from the checksum buffer means,
Clearing the checksum buffer means, reading one instruction specified by the program counting means, determining whether the read instruction is a branch instruction or any other instruction, Clearing the checksum data and adding the address value of the instruction to the contents of the checksum buffer means if it is any other instruction; and instructing the comparison means to output the operation code of the read instruction to the comparison means. Determining whether or not the instruction is a check instruction to execute;
Returning to the step of reading instructions and reading the next instruction; and if the result of the determination is the check instruction, comparing the checksum data with the operand value of the check instruction. Then, a program runaway detection method characterized by detecting runaway of a program executed by the microcomputer based on the mismatch signal. 6. A program counter for counting a program execution address, an adder for cumulatively adding the contents of the program counter each time the program counter is incremented, a checksum buffer for holding the addition result, A software development device for generating the object program of a microcomputer having a built-in program runaway detection circuit including a comparator for comparing checksum data stored in a program instruction and output data from the checksum buffer, And an instruction embedding means for analyzing input source program instructions, calculating checksum data of an execution address in program execution, and incorporating the calculated checksum data into an object program instruction. Software development equipment for detecting program runaway. 7. A check instruction to be incorporated in the object program and the checksum data serving as an operand part of the check instruction, the object program is mapped to an absolute address space when the source program is converted into an object, and the check 7. The software development apparatus according to claim 6, wherein the operand section is generated. 8. A program counting means for counting a program execution address, an adding means for accumulatively adding the contents of the program counter each time the program counting means is incremented, and a checksum for holding an addition result of the adding means. Software for generating an object program of a microcomputer using a program runaway detecting means comprising buffer means and comparing means for comparing checksum data previously stored in an object program instruction with output data from the checksum buffer means A step of clearing the checksum data; reading one source program instruction to determine whether the instruction is a branch instruction; if the determination result is negative, the assigned absolute address is checked. Adding to the sum data, determining whether the instruction is the check instruction, and if the determination result is negative, returning to reading the source program for one instruction, and determining that the instruction is the check instruction. Storing the value of the checksum data that has been cumulatively added in the operand portion of the check instruction; and determining whether or not the instruction is a branch instruction. A method for generating software for detecting program runaway, comprising a step of clearing.