JP2011181100A - Processor and debugging apparatus corresponding to parallel instruction performance - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To solve the problem wherein a processor adopting VLIW architecture can not convert only optional instructions in a program instruction strings into a debugging instruction for debugging so as to perform parallel execution and perform only one instruction in a step. <P>SOLUTION: The processor adopting the VLIW architecture is provided with: an instruction analysis means having a plurality of debugging instruction detection means of the same number as that of instructions allowed to be performed in parallel; and an instruction canceling means for canceling the performance of an instruction included in the same performance unit as a debugging instruction and arranged on an address of a higher rank than the debugging instruction when the debugging instruction is detected. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a processor, and more particularly to a debugging method in a processor that executes a plurality of instructions in parallel.

  In the conventional technology, when displaying an instruction string in a debugging device of a processor having an architecture that determines instructions that can be executed statically in parallel, it indicates where the instruction string delimiter that can be executed logically or physically in parallel is displayed. We were able to.

  In addition, it was possible to set a breakpoint at the beginning of an instruction sequence that can be executed in parallel or at the beginning of a container obtained by dividing a part of the instruction sequence into fixed lengths.

JP 11-194957 A

Jonathan B. Rosenberg, Kunio Yoshikawa, “Theory and Implementation of Debuggers”, ISBN 4-7561-1745-7

  In the conventional technology, in a debugging device of a processor having an architecture that determines instructions that can be executed statically in parallel, it is impossible to set a breakpoint at any instruction in an instruction sequence that can be executed in parallel due to any of the following problems: It was.

  The first problem is a case where the boundary of instructions that can be executed logically in parallel (hereinafter abbreviated as a parallel boundary) is fixedly divided, for example, in units of 128-bit length, due to limitations of the processor architecture. In this case, even if any instruction in this instruction sequence is replaced with a debug instruction that generates a debug interrupt, other instructions in the same division unit as that instruction are also executed in parallel. For example, assume that the machine language code shown in FIG. 10 is generated for the source program shown in FIG. || means that the instruction in the next line can be logically executed in parallel. Here, if a break is set for the instruction of line number 10 in FIG. 9, the address 0x80000000 is obtained from the debug information, and the MOV R1,1 || instruction at the address 0x80000000 as shown in FIG. Replaced. Here, since || is added to the BRK instruction, the following MOV R2,2 and MOV R3,3 instructions may be logically executed at the same time as the break is established. In the original source program, In spite of setting a break at the line number 10, there is a problem that the instructions on the 11th and 12th lines may stop in a state of being executed.

  The second issue is when the parallel boundary is not fixed due to the limitations of the processor architecture, but it is limited to some patterns and cannot be specified by any instruction. In this case as well, as with the first problem, if any instruction in the instruction sequence is replaced with a debug instruction that generates a debug interrupt, the position to be replaced with the debug instruction cannot be set as a parallel boundary due to pattern restrictions. Other instructions in the same division unit as that instruction are also executed in parallel.

Here, a specific example will be described using the same example. In the case of a processor in which the parallel boundary can be set only every two or three instructions, even if an attempt is made to remove ||| However, since it is one instruction, a parallel boundary cannot be set, and a problem that cannot be solved has occurred.

  In order to solve the above-described problem, a debugging method of the present invention uses a debugging device to program a program that operates on a processor capable of executing instructions in parallel and having a specific bit pattern that represents a parallel execution boundary in a bit area of each instruction. A breakpoint control method for setting a breakpoint at any instruction in an instruction sequence delimited by a parallel execution boundary, wherein the breakpoint is changed by changing the bit pattern when setting the breakpoint. A breakpoint setting step for adding a parallel execution boundary so that the setting target instruction and the subsequent instruction are not executed in parallel, the program is executed, execution is stopped at the setting target instruction, and the setting target instruction and the subsequent instruction are With an execution / stop control step for controlling the system from being executed in parallel. It is.

  According to the present invention, a breakpoint can be set with an arbitrary instruction when debugging is performed in a processor using a program device that determines an instruction that can be logically executed in parallel when converting a source program into a machine language program. .

Data flow combining program converter and debug device Example of debugging device Control components of prior art debug devices Constituent elements for controlling a debugging device that supports parallel instruction execution Example of bit pattern configuration for 32-bit instructions Configuration example of 16-bit instruction bit pattern Example of bit pattern that synthesizes parallel boundary of 32-bit instruction Example of bit pattern that synthesizes parallel boundaries of 16-bit instructions Source program example An example in which the source program of FIG. 9 is converted into an execution program including parallel execution instructions Example of replacing the first instruction of the execution program in FIG. 10 with a debug instruction using conventional technology Example of replacing the first instruction of the execution program of FIG. 10 with a debug instruction in the processing flow of FIG. Example of replacing the first instruction of the execution program of FIG. 10 with a debug instruction in the processing flow of FIG. Example of replacing the first instruction of the execution program of FIG. 10 with a debug instruction in the processing flow of FIG. An example in which the order is changed to the position of the second instruction in the execution program of FIG. 10 and replaced with a debug instruction in the processing flow of FIG. An example in which the debug instruction is corrected and replaced at the position of the second instruction in the execution program of FIG. 10 in the processing flow of FIG. An example in which the first instruction of the execution program in FIG. 10 is replaced with step execution in the processing flow of FIG. An example in which the instruction at the head of the execution program in FIG. 10 is replaced with step execution in the process flow of FIG. An example in which the second instruction of the execution program of FIG. 10 is replaced with step execution in the processing flow of FIG. An example in which the second instruction of the execution program of FIG. 10 is added to the processing flow of FIG. The figure which shows the flow of the instruction substitution processing in the prior art Diagram showing the flow of instruction replacement processing when the parallel boundary can be changed and the instruction after replacement can be executed in parallel Diagram showing the flow of instruction replacement processing when the parallel boundary cannot be changed Diagram showing the flow of instruction replacement processing when the parallel boundary can be changed but the instruction after replacement cannot be executed in parallel Diagram showing the flow of instruction replacement processing when the order of instructions that can be executed in parallel can be changed Figure showing the flow of instruction replacement processing when using software simulation The figure which showed the flow of processing of step execution The figure which showed the flow in case S2003 of FIG. 27 can change a parallel boundary. The figure which showed the flow when S2003 of FIG. 27 cannot change a parallel boundary The block diagram regarding the processor in this invention Block diagram of instruction execution pipeline of VLIW processor in the prior art Block diagram of the instruction execution pipeline in the first embodiment of the processor of the present invention Block diagram of the instruction execution pipeline in the second embodiment of the processor of the present invention The block diagram of the cancellation signal production | generation part in 1st Example of the processor in this invention The block diagram of the instruction execution control part in 1st Example of the processor in this invention Example of instruction bit pattern in the second embodiment of the processor of the present invention Example of bit pattern of debug instruction in the second embodiment of the processor of the present invention

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

  FIG. 30 is a block diagram showing the relationship between the processor and the memory in the present invention. The processor 901 is connected to the instruction memory 902 and the data memory 903. The processor 901 fetches an instruction from the instruction memory 902, executes the fetched instruction, and changes the internal state of the processor 901 such as a register and the contents of the data memory 903.

The processor 901 has a VLIW (Very Long Instruction Word) architecture configuration that simultaneously executes a plurality of instructions as one instruction packet. Hereinafter, a processor having a VLIW architecture configuration is referred to as a VLIW processor.
<Conventional processor configuration>
Here, in order to clarify the difference from the present invention, the configuration of a conventional VLIW processor will be described.

  The block diagram shown in FIG. 31 is an example of an instruction execution pipeline configuration in a conventional VLIW processor that can execute three instructions in parallel as one instruction packet. However, parts that are not important in the present invention are omitted.

  A conventional processor includes an instruction fetch unit 1001 that fetches an instruction from an instruction memory, an instruction decoding unit 1011 to 1013 that decodes the fetched instruction, a multiplexer 1021 that selects an arithmetic unit according to the decoded instruction, And an ALU (Arithmetic and Logic unit) 1031 that performs a logical operation, a memory access unit 1032 that accesses a data memory, and a branch unit 1033 that changes an instruction fetch destination.

Each instruction included in the instruction packet fetched by the instruction fetch unit 1001 is individually decoded in parallel by the instruction decoding units 1011 to 1013. At this time, the instruction arranged at the lowest address in the instruction packet is the instruction decoding unit 1011, the instruction arranged at the next lowest address is the instruction decoding unit 1012, and the instruction arranged at the highest address is Instruction decoding unit 101
Decrypted in 3.

  The multiplexer 1021 selects an arithmetic unit necessary for executing the instruction decoded by the instruction decoding units 1011 to 1913 and sends each instruction to the arithmetic unit. In the VLIW processor, the instructions in the instruction packet are arranged on the assumption that they are executed in parallel. For this reason, there is no duplication of operator resources to be used or data dependency among instructions existing in the same instruction packet. Therefore, a feature of the VLIW processor is that the multiplexer 1021 can have a very simple configuration.

  The ALU 1031, the memory access unit 1032, and the branch unit 1033 individually execute instructions sent from the multiplexer 1021 in parallel.

  When a debug instruction is executed in the branch unit 1033, a debug interrupt signal 1041 is sent to the instruction fetch unit 1001. When the instruction fetch unit 1001 receives the debug interrupt signal 1041, the instruction fetch unit 1001 fetches an instruction from an address designated as a debug interrupt handler.

  As described above, the VLIW processor does not have a complicated instruction scheduling function, but effectively uses limited arithmetic unit resources and executes instructions in parallel.

However, since the debug instruction is executed in the branch unit, it cannot be placed in the same instruction packet as the instruction using the branch unit. For this reason, when setting a breakpoint for stopping the program at an arbitrary position, an arbitrary instruction cannot be replaced with a debug instruction.
<First Embodiment of Processor in the Present Invention>
A first embodiment of the processor 901 in the present invention will be described.

  FIG. 32 shows an example of an instruction execution pipeline configuration in the VLIW processor of the present invention. However, parts that are not important in the present invention are omitted.

  In the first embodiment of the processor according to the present invention, the processor 901 includes an instruction fetch unit 1001, an instruction decoding unit 1011 to 1013, a multiplexer 1021, an ALU 1031, a memory access unit 1032 and a branch unit 1033. Has the same configuration as a conventional processor.

  In the first embodiment of the processor according to the present invention, the processor 901 further includes a debug interrupt decoding unit 2081 including a debug interrupt detection unit 2051 to 2053 for detecting whether or not an arbitrary instruction generates a debug interrupt, and instruction execution Cancel signal generation unit 2061 that generates cancel signals 2111 to 2113 for canceling, instruction execution control unit 2071 that cancels instruction execution by invalidating instructions, and debug interrupts sent from debug interrupt detection units 2051 to 2053 A logical sum circuit 2091 that performs a logical sum of the signals 2101 to 2103 is provided.

  The debug interrupt detection units 2051 to 2053 acquire the instruction signals 2121 to 2123 from the instruction decoding units 1011 to 1013 and determine whether or not the decoded instruction is a debug instruction. When the decoded instruction is a debug instruction, debug interrupt signals 2101 to 2103 corresponding to the debug interrupt detection units 2051 to 2053 are asserted.

The debug interrupt signals 2101 to 2103 asserted by the debug interrupt detection units 2051 to 2053 are merged by the OR circuit 2091 and the debug interrupt signal 1041 is merged.
Is input to the instruction fetch unit 1001. As a result, a debug interrupt can be generated as in the conventional processor.

  The cancel signal generation unit 2061 receives the debug interrupt signals 2101 to 2103, and when the debug interrupt signal of the instruction arranged at the lower address is asserted, the instruction for which the debug interrupt signal is asserted and the higher order than the instruction. The corresponding cancel signals 2111 to 2113 are asserted so as to cancel the execution of the instruction arranged at the address.

  The instruction execution control unit 2071 converts instruction signals 2121 to 2123 of instructions corresponding to the asserted cancellation signals 2111 to 2113 into instruction signals corresponding to NOP (No Operation), and ALU 1031 as instruction signals 2131 to 2133. The instruction execution is invalidated by sending it to the memory access unit 1032 and the branch unit 1033.

  Further, the configuration of the cancellation signal generation unit 2061 and the instruction execution control unit 2071 will be described below.

  FIG. 34 shows the configuration of the cancellation signal generation unit 2061 in more detail.

  The cancellation signal generation unit 2061 includes logical sum circuits 4001 to 4002.

  The cancel signal generation unit 2061 receives the debug interrupt signals 2101 to 2103 as inputs.

  The debug interrupt signal 2101 corresponds to the instruction placed at the lowest address in the instruction packet.

  The debug interrupt signal 2102 corresponds to the instruction placed at the second lowest address in the instruction packet.

  The debug interrupt signal 2103 corresponds to the instruction placed at the third lowest address in the instruction packet.

  The cancellation signal generation unit 2061 outputs cancellation signals 2111 to 2113.

  Cancel signal 2111 corresponds to the instruction placed at the lowest address in the instruction packet.

  Cancel signal 2112 corresponds to the instruction placed at the second lowest address in the instruction packet.

  Cancel signal 2113 corresponds to the instruction placed at the third lowest address in the instruction packet.

  Cancel signal 2111 is generated from debug interrupt signal 2101.

  The cancel signal 2112 is generated from the logical sum of the debug interrupt signal 2102 and the debug interrupt signal 2102 input to the logical sum circuit 4001.

The cancel signal 2112 is generated from the logical sum of the debug interrupt signal 2102, the debug interrupt signal 2102, and the debug interrupt signal 2103 input to the logical sum circuit 4002.

  With the above configuration, when a debug interrupt occurs at any instruction in the instruction packet, the cancellation signal corresponding to the instruction at the address higher than the instruction at which the debug interrupt occurred and the instruction at which the debug interrupt occurred is asserted Is done.

  FIG. 35 shows the configuration of the instruction execution control unit 2071 in more detail.

  The instruction execution control unit 2071 includes multiplexers 5001 to 5003.

  The command execution control unit 2071 receives command signals 2121 to 2123 and cancel signals 2111 to 2113 as inputs.

  The instruction execution control unit 2071 outputs the instruction signals 2131 to 2133.

  The multiplexers 5001 to 5003 receive the command signals 2131 to 2133 and 0 which is a command signal corresponding to NOP. This input is selected by cancel signals 2111 to 2113.

  The multiplexers 5001 to 5003 select and output the command signals 2131 to 2133 when the cancellation signals 2111 to 2113 are 0, and select 0 when the cancellation signals are 1.

  The outputs of the multiplexers 5001 to 5003 are directly used as instruction signals 2131 to 2133, and are sent to the ALU 1031, the memory access unit 1032 and the branch unit 1033.

  With the above configuration, when the cancel signals 2111 to 2113 corresponding to an arbitrary command are asserted, the arbitrary corresponding command signals 2131 to 2133 are converted into NOP equivalent command signals. Thus, a specific instruction can be invalidated based on the asserted cancellation signal.

  With the configuration described above, in the processor 901 in the first embodiment of the processor of the present invention, when the debug instruction is decoded, the decoded debug instruction and the instruction arranged at a higher address than the decoded debug instruction are invalidated. Thus, no shortage of instruction execution resources such as an arithmetic unit occurs wherever debug instructions are placed in the instruction packet. That is, there is no restriction on the execution of the debug instruction, and the debug instruction can be arranged at an arbitrary position in the instruction packet. Thereby, when setting a breakpoint for stopping the program at an arbitrary position, an arbitrary instruction can be replaced with a debug instruction. Also, since the execution of the instruction following the debug instruction in the instruction packet is canceled, when a debug interrupt occurs and the program stops at the breakpoint, the instruction placed at the address higher than the breakpoint is executed. The relationship between breakpoints and instruction execution is more intuitive.

In the above embodiment, the number of simultaneously executed instructions is set to 3 for the sake of simplicity of explanation. However, the same configuration can be applied to a VLIW processor having 2 or more simultaneously executed instructions and the same effect can be obtained. That is obvious.
<Second Embodiment of Processor in the Present Invention>
A second embodiment of the processor 901 in the present invention will be described.

FIG. 33 shows an example of an instruction execution pipeline configuration in the VLIW processor of the present invention. However, parts that are not important in the present invention are omitted.

  In the second embodiment of the processor according to the present invention, the processor 901 includes an instruction fetch unit 1001, a multiplexer 1021, an ALU 1031, a memory access unit 1032, a branch unit 1033, and a debug having a debug interrupt detection unit 2051 to 2053. An instruction decoding unit 2081 and an OR circuit 2091 are provided, which have the same configuration as that of the first embodiment of the processor 901 in the present invention.

  In the second embodiment of the processor according to the present invention, the processor 901 further includes an instruction invalidating unit for invalidating an instruction arranged at a higher address than an instruction in which a specific bit pattern is detected among fetched instructions. 3151, an instruction issuing unit 3161 for issuing only valid instructions to the instruction decoding unit, and instruction decoding units 2011-2013 for decoding issued instructions.

  The instruction invalidation unit 3151 determines whether a part of each instruction in the fetched instruction packet has a specific bit pattern. In the second embodiment of the processor according to the present invention, the specific bit pattern is a pattern in which the most significant bit is 1 in a 16-bit instruction as shown in FIG. It does not matter whether the other bits are 0 or 1.

  If the instruction invalidation unit 3151 determines that an arbitrary instruction has a specific bit pattern, it sends a signal indicating that the instruction is invalid to the instruction issuing unit 3161.

  The instruction issuing unit 3151 selects an instruction to be issued to the instruction decoding unit 2081 based on a signal indicating that the instruction is invalid from the instruction invalidating unit 3151.

  The instruction issuing unit 3151 regards all instructions in the instruction packet arranged at an address higher than the invalid instruction as invalid, and does not issue the instruction to the instruction decoding unit.

  When the instruction is not issued from the instruction issuing unit 3151, the instruction decoding units 2011 to 2013 send an instruction signal corresponding to the NOP instruction to the multiplexer 1021 without decoding the instruction.

  When the instruction decoding unit 2011-2013 decodes the debug instruction, the instruction decoding unit 2011-2013 outputs a signal indicating that no arithmetic unit is used to the multiplexer 1021 as an instruction signal.

  FIG. 37 shows a bit pattern of a debug instruction in the second embodiment of the processor according to the present invention.

  In the debug instruction, bit0, bit4, bit8, and bit12 are 0, and other bits are 1s. Since the most significant bit is 1, the instruction invalidation unit 3151 invalidates all instructions arranged at higher addresses than the debug instruction in the instruction packet and is not issued to the instruction decoding units 2011 to 2013. As a result, an instruction placed at an address higher than the debug instruction is not executed.

With the configuration described above, the processor 901 in the second embodiment of the processor according to the present invention interprets that the debug instruction does not use any arithmetic unit resources, so that it is possible to calculate where to place the debug instruction in the instruction packet. Insufficient instruction execution resources such as a container will not occur. That is, there is no restriction on the execution of the debug instruction, and the debug instruction can be arranged at an arbitrary position in the instruction packet. Thereby, when setting a breakpoint for stopping the program at an arbitrary position, an arbitrary instruction can be replaced with a debug instruction. Also, since the execution of the instruction following the debug instruction in the instruction packet is canceled, when a debug interrupt occurs and the program stops at the breakpoint, the instruction placed at the address higher than the breakpoint is executed. The relationship between breakpoints and instruction execution is more intuitive.

In the above embodiment, the number of simultaneously executed instructions is set to 3 for the sake of simplicity of explanation. However, the same configuration can be applied to a VLIW processor having 2 or more simultaneously executed instructions and the same effect can be obtained. That is obvious.
<Example of Debugging Method in the Present Invention>
Hereinafter, an embodiment of a debugging method according to the present invention will be described with reference to FIGS.

  FIG. 1 shows a data flow in which a general program conversion device and a debugging device are combined. The source program 101 is converted into an execution program 103 a by the program conversion device 102 in accordance with a user instruction from the input / output device 105. At this time, the correspondence between the source program 101 and the execution program 103a can be output as debug information 103b.

  In response to a user instruction from the input / output device 105, the debug device 104 refers to the source program 101 and debug information 103b when there is an execution program 103a, and controls various debug operations such as program execution, stop, and status reference. .

  FIG. 2 shows a more specific example of a debugging device.

  A host computer 201 executes the host-side software of the program conversion device and the debugging device. Reference numeral 204 denotes a target processor evaluation board, which is connected by a connection cable 205. When the target processor is simulated on the host computer, 204 and 205 are not necessary. Reference numeral 201 denotes an output device display connected to the host computer, and 203 denotes an input device keyboard and mouse. Reference numeral 206 denotes a display screen output by the debugging device.

  FIG. 3 shows control components of a conventional debugging apparatus. An input / output unit 501, an execution program / debug information reading unit 502, an instruction reference / change unit 503, an execution / stop control unit 504, and a debug information search unit 505 are configured.

  FIG. 4 shows control components of the debugging device according to the embodiment of the present invention. Reference numerals 601 to 605 are the same as 501 to 505, respectively. The parallel execution instruction sequence boundary subdividing means 606 is a means for decomposing the parallel boundaries of logically executable instruction sequences into subdivided instruction sequences and additionally setting parallel boundaries there. The parallel execution instruction sequence reconfiguring means is means for replacing a plurality of instructions in the instruction sequence that is logically executable in parallel without changing the parallel boundary.

  FIG. 5 shows an example of a bit pattern configuration in a 32-bit length instruction of a variable-length instruction and a logically executable processor. len is a bit for distinguishing the instruction length, and end is a bit indicating a parallel boundary.

  FIG. 6 shows an example of a bit pattern configuration in a 16-bit instruction of a variable-length instruction and a logically executable processor. The meanings of len and end are the same as in FIG.

FIG. 7 is a logical sum for setting a parallel boundary for the bit pattern of FIG. 41, and FIG. 8 is also for FIG.

  FIG. 9 is an example showing a part of the source program 101. FIG. 10 shows an example of an execution program after compiling the source program of FIG.

  FIG. 11 shows an example in which the head instruction of the execution program of FIG. 10 is replaced with a debug instruction by the conventional technique.

  FIG. 12 shows an example in which the first instruction of the execution program of FIG. 10 is replaced with a debug instruction in the processing flow of FIG.

  FIG. 13 shows an example in which the first instruction of the execution program of FIG. 10 is replaced with a debug instruction in the processing flow of FIG.

  FIG. 14 shows an example in which the first instruction of the execution program of FIG. 10 is replaced with a debug instruction in the processing flow of FIG.

  FIG. 15 shows an example in which the order is changed to the position of the second instruction in the execution program of FIG. 10 and replaced with a debug instruction in the processing flow of FIG.

  FIG. 16 shows an example in which the debug instruction is corrected and replaced at the position of the second instruction in the execution program of FIG. 10 by the processing flow of FIG.

  FIG. 17 shows an example in which the top instruction of the execution program of FIG. 10 is replaced in a step-executable manner by the processing flow of FIG.

  FIG. 18 shows an example in which the top instruction of the execution program of FIG. 10 is replaced in a step-executable manner by the processing flow of FIG.

  FIG. 19 shows an example in which the second instruction of the execution program of FIG. 10 is replaced with step execution in the processing flow of FIG.

  FIG. 20 shows an example in which the second instruction of the execution program of FIG. 10 is added to the processing flow of FIG.

  FIG. 21 shows a flowchart of instruction replacement processing in the prior art.

  FIG. 22 shows a flowchart of the instruction replacement process when the parallel boundary can be changed and the replaced instruction can be executed in parallel.

  FIG. 23 shows a flowchart of instruction replacement processing when the parallel boundary cannot be changed.

  FIG. 24 shows a flowchart of instruction replacement processing when the parallel boundary can be changed but the instruction after replacement cannot be executed in parallel.

  FIG. 25 shows a flowchart of instruction replacement processing when the order of instructions that can be executed in parallel can be changed.

  FIG. 26 shows a flowchart of instruction replacement processing when software simulation is used.

  FIG. 27 shows a flowchart of the step execution process.

  FIG. 28 shows a flowchart when S2003 in FIG. 27 can change the parallel boundary.

  FIG. 29 shows a flow chart when S2003 of FIG. 27 cannot change the parallel boundary.

  Hereinafter, it demonstrates in detail using these figures.

  When debugging a program of a processor capable of executing parallel instructions using a debugging device, the user loads the debugging information 103b when the execution device 103a exists in the debugging device 104 according to the flow described in FIG. To do.

  Here, description will be made assuming that a part of the source program 101 is as shown in FIG. As a result of compiling FIG. 71, a code as shown in FIG. 10 is generated as a part of the execution program. In the figure, the address indicates the position where the instruction is stored. For convenience of explanation, the group is a serial number for distinguishing a group of instruction sequences that can be logically executed in parallel, and the actual machine language code does not include the number itself. The mnemonic replaces the machine language code with a combination of English words and symbols that are simplified for the user to understand. Here, MOV R1,1 means transferring 1 to the R1 register, and CALL sub means calling a function sub. The symbol || at the end of the mnemonic indicates that the instruction can be executed logically in parallel with the instruction at the next address. A debug instruction that generates a debug interrupt is a BRK instruction, and an instruction that advances the program counter is a NOP instruction.

  When the user of the debugging device tries to set a breakpoint at line number 10 in FIG. 9, the address of the corresponding machine language code can be converted from the debug information to 0x80000000 using the conventional technology. If this is replaced with a debug instruction as it is without changing the instruction boundary in the conventional technique, the MOV R1,1 || instruction in FIG. 81 is replaced with the BRK || instruction in FIG. The flow of processing in the conventional technique is as shown in FIG.

  In step S1001, the instruction replacement process is started, and the original instruction is saved in step S1002 and the address and the original instruction are stored in 1020 in preparation for when a breakpoint is deleted. In S1003, the instruction after replacement, that is, the break setting is replaced with the BRK instruction. In step S1004, the instruction replacement process ends. When deleting a breakpoint, instruction restoration processing is started in S1010, and the corresponding instruction stored in 1020 and the original instruction are used to replace the original instruction in S1011. In step S1012, the instruction restoration process is completed.

  In the present invention, this processing flow is solved by using any one of the methods shown in FIGS. 22 and 24 correspond to the third embodiment. FIG. 23 corresponds to the embodiment of claim 5.

In the case of an architecture in which the processor can set a parallel boundary for an arbitrary instruction, the method of FIG. 22 can be used. In step S1101, instruction replacement processing is started. In step S1102, the original instruction is stored in 1120. So far, it is the same as that of the prior art. Next, in S1103, a bit pattern on the parallel boundary is synthesized with the BRK instruction in the case of setting a replacement instruction, that is, a break. In the case of a break, we want to make a break with the corresponding instruction, so we will compose it as a parallel boundary. Taking the architecture having two types of instruction lengths of 32 and 16 bits in FIGS. 5 and 6 as an example, len indicating the instruction length.
First, the instruction length is determined by the bit. xxx. . . Since this part is a bit pattern indicating the instruction itself, this part becomes the pattern of the BRK instruction. The end bit indicates a parallel boundary, and if it is 0, it is not a boundary, and if it is 1, it is a boundary. This is realized by taking the logical sum of the bit patterns that set the parallel boundary in FIG. 7 or FIG. 8 in accordance with the pattern and instruction length of the BRK instruction. Finally, the bit pattern is replaced with the synthesized bit pattern in S1104, and the instruction replacement process is terminated in S1105. When deleting a break, the processing from S1110 to S1112 is performed in exactly the same way as the conventional S1010 to S1012.

  When a break is set at line number 10 corresponding to the source program of FIG. 9 according to the processing flow of FIG. 22, the state is replaced in the debug device as shown in FIG.

  The method shown in FIG. 24 can be used in the case of an architecture having a restriction that the processor can set a parallel boundary in units of 1 or 3 instructions but cannot set in units of 2 instructions. In step S1301, instruction replacement processing is started. In step S1302, the original instruction sequence of an instruction group that can be executed logically simultaneously with the self instruction to set a break is stored as 1320, and the address and the original instruction sequence are stored as a set. In S1303, the instructions in the same group as the self instruction are decomposed into another group within the scope of the processor. The group decomposition is performed by setting parallel boundaries in the same manner as described above with reference to FIG. In step S1304, the instruction is replaced with a post-substitution instruction, that is, a BRK instruction. In step S1305, the instruction replacement process is terminated. When deleting a break, the processing from S1310 to S1312 is performed in the same manner as the conventional S1010 to S1012. The difference is that in S1311, not the single instruction but the instruction group of the same group is restored.

  When a break is set at line number 10 corresponding to the source program of FIG. 9 according to the processing flow of FIG. 24, the state is replaced in the debug device as shown in FIG. If the break setting position can be decomposed into parallel boundaries within the processor constraints, the above can be solved.

  If the above method is too difficult for the processor, the method shown in FIG. 23 can be used.

In step S1201, instruction replacement processing is started. S1202 is the same as the previous S1302. In step S1203, the instruction at the position where the break is to be set is replaced with an instruction after replacement, that is, a BRK instruction. In step S1204, the subsequent instructions in the same group are replaced with NOP instructions that only advance the program counter. In step S1205, the instruction replacement process ends.
When deleting a break, the process of S1210 to S1212 is performed similarly to S1310 to S1312.

  When a break is set at line number 10 corresponding to the source program of FIG. 9 according to the processing flow of FIG. 23, the state is replaced in the debug device as shown in FIG. In this case, there is a possibility that the actual stop will be after the execution of the NOP instruction of 0x80000008, but the debug device uses the address in the information of 1320 to correct the stop at 0x80000000.

Next, a case will be described as an example where one debug statement (not an instruction) is stepped from the position of line number 10 of the source program in FIG. Assume that the machine language code corresponding to this source program is generated as shown in FIG.
When the processor is instructed to execute a step, the machine language code corresponding to the line number 10 can be logically executed in parallel with the machine language code corresponding to the line numbers 11 and 12, and may be executed simultaneously. is there.

FIG. 27 shows a basic control flow of step execution corresponding to the parallel execution of the present invention. In step S2001, step execution processing is started. In S2002, it is determined whether or not the instruction to be step-executed is a parallel execution instruction. In the case of the instruction format as shown in FIGS. 5 and 6 described above, if the end bit is 0, it can be determined as a parallel execution instruction. If it is determined that the instruction is not a parallel execution instruction, only the own instruction is unit-executed in S2006 and the step execution process is ended in S2007, as in the case of a conventional processor that is not parallel execution. If it is determined that the instruction is a parallel execution instruction, in S2003, the parallel execution instruction sequence is reconfigured so that it can be executed in units. At this time, the original instruction is saved. Details will be described later with reference to FIGS. The parallel execution instruction sequence reconstructed in S2004 is unit-executed, and the instruction sequence reconstructed in S2005 is restored to the original instruction sequence saved in S2003. In step S2007, the step execution process ends.

  Details of S2003 will be described.

  FIG. 28 corresponds to the embodiment of claim 4. In S2101, the instruction replacement process is started. In S2102, the address of the position to be step-executed and the original instruction are stored in 2120. In step S2103, the self-instruction and the parallel boundary bit pattern are synthesized. The method of synthesizing the bit pattern at the parallel boundary is the same as that described in S1103 of FIG. The bit pattern is replaced with the synthesized bit pattern in step S2104, and the instruction replacement process ends in step S2105. Step execution is performed in this state, and when it is stopped, instruction restoration processing is started in S2110. The address and the original instruction stored in 2120 in S2111 are replaced with the original instruction, and the instruction restoration process is terminated in S2112.

  With these processes, it is possible to perform the replacement as shown in FIG. 17 only during the step execution and execute only the instruction of 0x80000000 as a single group. Thereby, it is possible to distinguish and execute only the instruction sequence corresponding to one executable statement in line number 10.

  If the parallel boundary cannot be changed due to processor restrictions, the method of FIG. 29 is used. FIG. 29 corresponds to an embodiment of the sixth aspect.

  In step S2201, the instruction replacement process is started. In step S2202, the address of the same instruction group as the local instruction at the position to be step-executed and the original instruction string are stored as 2220. In 293, instructions other than the self instruction in the same instruction group as the self instruction are replaced with the NOP instruction. In step S2204, the instruction replacement process ends. In this state, step execution is performed, and when execution is stopped, instruction restoration processing is started in S2210. In S2211, the original instruction sequence is replaced with the information of 2220. In step S2212, the instruction restoration process ends.

  By these processes, replacement is performed as shown in FIG. 18 only during step execution, and step execution is performed from 0x80000000. In this case, there is a possibility that the actual stop will be after the execution of the NOP instruction of 0x80000008, but the debug device uses the address in the information of 2220 to correct that it stopped at 0x80000004 advanced by one instruction. Do. Similarly, when further step execution is performed, the instructions of 0x80000000 and 0x80000008 are replaced with NOP instructions, and are replaced as shown in FIG. 19, so that the same result as when only the instruction of 0x80000004 is executed is obtained.

  Here, if the processor has a restriction such that the NOP instruction can be placed only at the end of the instruction group, it can be avoided by replacing the NOP instruction with the head of the instruction other than the NOP instruction as shown in FIG. This method corresponds to the embodiment of claim 8.

  In the case of a processor with restrictions such as the need to describe the debug instruction at the end of the instruction group, the position of the debug instruction is moved to the end according to the restriction, and the position from where it was originally set to the moved position Replace with NOP instruction. The processing at this time is the same as in FIG. Then, the debugging apparatus corrects that the stop position is the place where the break was originally intended to be set.

In the case of a processor with restrictions such as where the debug instruction must be written at the beginning of the instruction group, the position of the debug instruction is inserted at the beginning according to the restrictions, and the instructions up to the originally set position are debugged. It avoids by moving by the amount of the inserted instruction.
For example, if it is desired to set a break in the second instruction in FIG. 10, instruction replacement processing is started in S1401 as shown in FIG. 25, and the original instruction in the same instruction group as the own instruction is set in S1402 with the address and the original instruction string in S1402. Save as 1420. In S1403, instructions in the same instruction group as the instruction itself are replaced after replacement, that is, in the case of this example, since it can only be arranged at the beginning, the instruction is moved to the beginning, and the instruction from the position of the instruction that was originally at the beginning Moves the command to the position where was originally in order. In step S1404, the self-instruction after the change of order is not subject to post-replacement instruction placement restrictions, so the post-replacement instruction is replaced. In step S1405, the instruction replacement process ends. As a result, the instruction sequence as shown in FIG. 15 is replaced. This method corresponds to the embodiment of claim 7.

  In the case of a processor that has restrictions such as where the debug instruction must be written at the beginning of the instruction group, the debug instruction position is moved to the beginning according to the restrictions, and the instructions up to the position where the break originally wanted to be set by software Avoid by simulation. For example, when it is desired to set a break for the second instruction in FIG. 10, instruction replacement processing is started in S1501 in FIG. In step S1502, an instruction string of the same instruction group as the self instruction is stored as 1520 with the address and the original instruction string set. In the same manner as S1303 in FIG. 24, instructions in the same instruction group as the own instruction are decomposed into different groups in S1503. In step S1504, the first instruction in the same instruction group as that of the own instruction is replaced with the replaced instruction in accordance with the instruction arrangement constraint. In step S1505, the instruction replacement process is terminated. Up to this point, the state is as shown in FIG. When execution of the program is started and a break is detected by the BRK instruction, instruction restoration processing is started in S1510, and the original instruction sequence is restored from the address saved in 1520 in S1511. In step S1512, the instruction restoration process ends. Software simulation is performed one instruction at a time from the position where the break was detected to the instruction that originally wanted to set the break. In the case of MOV R1,1, software simulation is performed by setting 1 in the R1 register. When the position where the break was originally intended to be reached is reached, the flow from S1501 is processed again to return to the instruction-replaced state. The place where the break was detected is replaced with the place where the break was originally intended to be set, and the break detection of the debugging device is completed. This method corresponds to the embodiment of claim 9.

  When it is desired to execute a step in a processor having a constraint that the parallel boundary cannot be changed and there is no NOP instruction, neither of the above-described methods shown in FIGS. 28 and 29 can be solved. For example, when it is desired to step-execute the first executable statement in FIG. 9, the instruction sequence corresponding to the executable statement is searched for from 103b in the debug information. If the machine language code as shown in FIG. 10 has been generated, only the instruction at the address 0x80000000 is extracted at this point. Here, since the corresponding instruction is MOV R1,1, by performing software emulation so that the R1 register is set to 1 in the debugging device, the same result is obtained as if the processor apparently executed only the corresponding instruction in steps. be able to. This method corresponds to the embodiment using claim 10 in claim 11.

  The processor capable of executing parallel instructions according to the present invention can be applied to electronic devices that require high execution performance, such as various control devices and signal processing devices.

  The feature of the processor of the present invention in which debug instructions can be freely arranged is useful in software development of electronic devices.

The debugging apparatus for parallel instruction execution according to the present invention can freely break a parallel execution instruction sequence generated by a program conversion apparatus in the same manner as a debugging apparatus in a processor that executes in units of instructions for a sequence of instructions that can be executed in parallel. This is useful when using unit execution operations such as point setting and step execution.
It can also be applied to non-embedded processors such as host computers.

DESCRIPTION OF SYMBOLS 101 Source program 102 Program conversion apparatus 103a Execution program 103b Debug information 104 Debug apparatus 105 Input / output apparatus 201 Host computer 202 Display 203 Input apparatus 204 Evaluation board 205 Connection cable 206 Display screen 501 Input / output means 502 Execution program / debug information reading means 503 Instruction reference / change means 504 Execution / stop control means 505 Debug information search means 601 Input / output means 602 Execution program / debug information reading means 603 Instruction reference / change means 604 Execution / stop control means 605 Debug information search means 606 Conditional instructions Combining means 607 Conditional execution position detecting means 1001 Instruction fetch unit 1011 Instruction decoding unit 1012 Instruction decoding unit 1013 Instruction decoding unit 021 multiplexer 1031 ALU
1032 Memory access unit 1033 Branch unit 1041 Debug interrupt signal 2051 Debug interrupt detection unit 2052 Debug interrupt detection unit 2053 Debug interrupt detection unit 2061 Cancel signal generation unit 2071 Instruction execution control unit 2081 Debug instruction decoding unit 2091 OR circuit 2101 Debug interrupt signal 2102 Debug interrupt signal 2103 Debug interrupt signal 2111 Cancel signal 2112 Cancel signal 2113 Cancel signal 2121 Command signal 2122 Command signal 2123 Command signal 2131 Command signal 2132 Command signal 2133 Command signal 3011 Command decode unit 3012 Command decode unit 3013 Command decode unit 3151 Command invalidation Section 3161 Instruction issuing section 4001 OR circuit 4002 OR circuit 5001 Multiplex Grasses 5002 multiplexer 5003 multiplexer

Claims (3)

Any one of the instruction sequences delimited by the parallel execution boundary in a program that runs on a processor that can execute instructions in parallel with a specific bit pattern that means a parallel execution boundary in the bit area of each instruction using a debugging device A breakpoint control method for setting a breakpoint in the instruction of
When setting a breakpoint, by changing the bit pattern, a breakpoint setting step for adding a parallel execution boundary so that a breakpoint setting target instruction and a subsequent instruction are not executed in parallel is executed, and the program is executed. A breakpoint control method comprising: an execution / stop control step for stopping execution at the setting target instruction and controlling the setting target instruction and a subsequent instruction not to be executed in parallel. Instructions that have a specific bit pattern that means a parallel execution boundary in the bit area of each instruction In a program that runs on a processor that can be executed in parallel, a breakpoint is set at any instruction in the instruction sequence delimited by the parallel execution boundary A breakpoint control program for setting a computer to function as a debugging device,
When setting a breakpoint, by changing the bit pattern, a breakpoint setting step for adding a parallel execution boundary so that a breakpoint setting target instruction and a subsequent instruction are not executed in parallel is executed, and the program is executed. A breakpoint control program comprising: an execution / stop control step for stopping execution at the setting target instruction and controlling the setting target instruction and a subsequent instruction not to be executed in parallel. Instructions that have a specific bit pattern that means a parallel execution boundary in the bit area of each instruction In a program that runs on a processor that can be executed in parallel, a breakpoint is set at any instruction in the instruction sequence delimited by the parallel execution boundary A debugging device to be configured,
A parallel execution instruction string boundary subdivision means for adding a parallel execution boundary so that a breakpoint setting target instruction and a subsequent instruction are not executed in parallel by changing the bit pattern when setting the breakpoint; A debugging apparatus comprising: an execution / stop control unit that executes a program, stops execution at the setting target instruction, and controls the setting target instruction and a subsequent instruction not to be executed in parallel.