Execute instruction
{{Short description|Computer instruction executing another instruction}}
{{Machine code}}
In a computer instruction set architecture (ISA), an execute instruction is a machine language instruction which treats data as a machine instruction and executes it.
It can be considered a fourth mode of instruction sequencing after ordinary sequential execution, branching, and interrupting.{{cite journal|first=F.P.|last=Brooks|author-link=Fred Brooks|title=The execute operations—a fourth mode of instruction sequencing|journal=Communications of the ACM|volume=3|issue=3|pages=168–170|date=March 1960|doi=10.1145/367149.367168|s2cid=37725430|doi-access=free}} Since it is an instruction that operates on other instructions like the repeat instruction, it has also been classified as a meta-instruction.{{cite journal|first=George E.|last=Rossman|title=A Course of Study in Computer Hardware Architecture|journal=IEEE Computer|volume=8|issue=12|pages=44–63|date=December 1975|doi=10.1109/C-M.1975.218835|s2cid=977792}}, p. 50
Computer models
Many computer families introduced in the 1950s and 1960s include execute instructions: the IBM 709 and IBM 7090 (op code mnemonic: {{mono|XEC}}),{{cite manual|publisher=IBM|title=Reference Manual, IBM 7090 Data Processing System|date=March 1962|page=36|url=http://www.bitsavers.org/pdf/ibm/7090/22-6528-4_7090Manual.pdf}} the IBM 7030 Stretch ({{mono|EX}}, {{mono|EXIC}}),{{cite manual|publisher=IBM|title=Reference Manual, 7030 Data Processing System|date=August 1961|page=50|url=http://bitsavers.org/pdf/ibm/7030/22-6530-2_7030RefMan.pdf}} the PDP-1/-4/-7/-9/-15 ({{mono|XCT}}),{{cite manual|publisher=Digital Equipment Corporation|title=Programmed Data Processor-1 Manual|date=1961|page=14|url=http://gordonbell.azurewebsites.net/digital/pdp%201%20manual%201961.pdf}}{{cite web|first=Bob|last=Supnik|title=Architectural Evolution in DEC's 18b Computers|page=8 (page numbers not shown)|url=http://simh.trailing-edge.com/docs/architecture18b.pdf}} the UNIVAC 1100/2200 ({{mono|EXRI}}),{{cite manual
|url=http://www.bitsavers.org/pdf/univac/1107/UT-2463_CPU_Nov61.pdf
|title=Univac 1107 Central Computer |date=November 1961|page=12{{hyphen}}1}} the CDC 924 ({{mono|XEC}}),{{cite manual
|url=http://bitsavers.informatik.uni-stuttgart.de/pdf/cdc/924/168B_CDC_924_Reference_Manual_Oct62.pdf
|title=Control Data 924 Computer Reference Manual |date=October 1962|page=2{{hyphen}}41}} the PDP-6/-10 ({{mono|XCT}}), the IBM System/360 ({{mono|EX}}),{{cite manual|publisher=IBM|title=IBM System/360 Principles of Operation|id=A22-6821-0|date=1964|page=65|url=http://bitsavers.trailing-edge.com/pdf/ibm/360/princOps/A22-6821-0_360PrincOps.pdf}} the GE-600/Honeywell 6000 ({{mono|XEC}}, {{mono|XED}}),{{cite manual|publisher=General Electric Computer Department|title=GE-635 System Manual|date=July 1964|page=A{{hyphen}}5|url=http://www.bitsavers.org/pdf/ge/GE-6xx/CPB-371A_GE-635_System_Man_196407.pdf}} the SDS-9xx ({{mono|EXU}}),{{cite manual|publisher=Scientific Data Systems|title=SDS 940 Theory of Operation|id=SDS-98-01-26A|date=March 1967|page=2{{hyphen}}12|url=https://doc.lagout.org/science/0_Computer%20Science/0_Computer%20History/old-hardware/sds/9xx/940/980126A_940_TheoryOfOperation_Mar67.pdf}} the SDS 92 ({{mono|EXU}}),{{cite manual|publisher=Scientific Data Systems|title=SDS 92 Computer|date=June 1965|page=2{{hyphen}}6|url=https://usermanual.wiki/Document/900505CSDS92ReferenceJun65.3199204510/view}} and the SDS Sigma series ({{mono|EXU}}).{{Cite book |url=http://www.bitsavers.org/pdf/sds/sigma/sigma7/900950J_Sigma7_RefMan_Oct73.pdf |title=Xerox SIGMA 7 Computer: Reference Manual |date=October 1973 |publisher=Xerox Corporation |others=90 09 5J; XG46, File No: 1X03 |edition=0 |pages=70–71}}
Fewer 1970s designs include execute instructions: the Nuclear Data 812 minicomputer (1971) ({{mono|XCT}}),{{cite manual|publisher=Nuclear Data, Inc.|title=Principles of Programming the ND812 Computer|date=1971|page=4{{hyphen}}4|url=http://bitsavers.trailing-edge.com/pdf/nd/ND812/ND812_Prog.pdf}} the HP 3000 (1972) ({{mono|XEQ}}),{{cite manual|publisher=Hewlett-Packard|title=HP 3000 Computer System: Machine Instruction Set Reference Manual|date=1980|page=2{{hyphen}}31|url=http://www.bitsavers.org/pdf/hp/3000/instrSet/30000-90022_InsSetRef_Feb80.pdf}} and the Texas Instruments TI-990 (1975){{cite manual|publisher=Texas Instruments|title=990 Computer Family Systems Handbook|page=3{{hyphen}}28|url=http://www.bitsavers.org/pdf/ti/990/945250-9701_990_Computer_Family_Systems_Handbook_3ed_May76.pdf}} and its microprocessor version, the TMS9900 (1976) ({{mono|X}}).{{cite manual|publisher=Texas Instruments|title=TMS 9900 Microprocessor Data Manual|date=December 1976|page=24|url=http://datasheets.chipdb.org/TI/9900/TMS9900_DataManual.pdf}} The Signetics 8X300 (1976) is a rare microprocessor design with an execute instruction. XEC executes one instruction from a table of 1 to 255 instructions. Most instructions act as single instruction subroutines but branches are used to implement jump tables.{{cite web|title=SL8X305 Microcontroller
|url=http://lansdale.com/datasheets/sl8x305_rev0.pdf|publisher=Lansdale Semiconductor Inc.|accessdate=20 June 2017}} An execute instruction was proposed for the PDP-11 in 1970,{{cite web |last=van de Goor |first=Ad |date=September 21, 1970 |title=The Execute Instruction |url=http://bitsavers.informatik.uni-stuttgart.de/pdf/dec/pdp11/memos/700921_The_Execute_Instruction.pdf |id=PDP-11/40 Technical Memorandum 18}} but never implemented for it{{cite manual |url=http://bitsavers.org/pdf/dec/pdp11/handbooks/PDP11_Handbook1979.pdf |title=PDP11 Processor Handbook: PDP11/04/34a/44/60/60 |date=1979 |publisher=Digital Equipment Corporation}} or its successor, the VAX.{{cite manual |url=https://www.ece.lsu.edu/ee4720/doc/vax.pdf |title=VAX MACRO and Instruction Set Reference Manual |date=April 2001 |publisher=Compaq Computer Corporation |id=AA-PS6GD-TE}}
Modern instruction sets do not include execute instructions because they interfere with pipelining, prefetching, and other optimizations.{{citation needed|date=July 2021}}
Semantics
The instruction to be executed, the target instruction, may be in a register or fetched from memory. Some architectures allow the target instruction to itself be an execute instruction; others do not.
The target instruction is executed as if it were in the memory location of the execute instruction. If, for example, it is a subroutine call instruction, execution is transferred to the subroutine, with the return location being the location after the execute instruction. However, some architectures implement variants of the execute instruction which inhibit branches.
The System/360 supports variable-length target instructions. It also supports modifying the target instruction before executing it. The target instruction must start on an even-numbered byte.
The GE-600 series supports execution of two-instruction sequences, which must be doubleword-aligned.
Some architectures support an execute instruction which operates in a different protection and address relocation mode. For example, the ITS PDP-10 paging device supports a privileged-mode {{mono|XCTR}} 'execute relocated' instruction which allows memory reads, writes, or both to use the user-mode page mappings.{{cite web|first=J.|last=Holloway|title=Hardware Memo 2 - PDP-10 Paging Device|publisher=MIT AI Lab|date=February 20, 1970|page=11|url=http://www.bitsavers.org/pdf/mit/ai/ai_600dpi/HW_Memo_2_PDP-10_Paging_Device_Feb1970.pdf}} Similarly, the KL10 variant of the PDP-10 supports the privileged instruction {{mono|PXCT}} 'previous context XCT'.{{cite manual|publisher=Digital Equipment Corporation|title=DECsystem-10, DECSYSTEM-20 Processor Reference Manual|id=AA-H391A-TK, AD-H391A-T1|date=June 1982|page=2{{hyphen}}63|url=https://www.livingcomputers.org/UI/UserDocs/Tops-10-v7-04/3_DECsystem-10_DECSYSTEM-20_Processor_Reference.pdf}}
The execute instruction can cause several problems when one execute instruction points to another one and so on:
- the processor may be uninterruptible for multiple clock cycles if the execute instruction cannot be interrupted in the middle of execution;
- similarly, the processor may go into an infinite loop if the series of execute instructions is circular and uninterruptible;
- if the execute instructions are on different swap pages, all of the pages need to be swapped in for the instruction to complete, which can cause thrashing.
Similar issues arise with multilevel indirect addressing modes.
Applications
The execute instruction has several applications:
- Functioning as a single-instruction subroutine without the usual overhead of subroutine calls; that instruction may call a full subroutine if necessary.
- Late binding
- Implementation of call by name and other thunks.
- A table of execute targets may be used for dynamic dispatch of the methods or virtual functions of an object or class, especially when the method or function may often be implementable as a single instruction.
- An execute target may contain a hook for adding functionality or for debugging; it is normally initialized as a NOP which may be overridden dynamically.
- An execute target may change between a fast version of an operation and a fully traced version.{{cite book|first=Richard P.|last=Gabriel|author-link=Richard P. Gabriel|title=Performance and Evaluation of Lisp Systems|date=August 1985|isbn=9780262070935|page=32|publisher=MIT Press |url=https://www.dreamsongs.com/Files/Timrep.pdf}}{{cite manual|first=Kent M.|last=Pitman|author-link=Kent Pitman|title=The Revised Maclisp Manual, Sunday Morning Edition|url=https://www.maclisp.info/pitmanual/|section-url=https://www.maclisp.info/pitmanual/system.html#PURE|section=PURE}}{{cite manual|first=David A.|last=Moon|author-link=David A. Moon|title=Maclisp Reference Manual|version=Revision 0|date=April 1974|page=181|url=http://www.softwarepreservation.com/projects/LISP/MIT/Moon-MACLISP_Reference_Manual-Apr_08_1974.pdf}}
- Tracing, monitoring, and emulation
- This may maintain a pseudo-program counter, leaving the normal program counter unchanged.
- Executing dynamically generated code, especially when memory protection prevents executable code from being writable.
- Emulating self-modifying code, especially when it must be reentrant or read-only.
- In the IBM System/360, the execute instruction can modify bits 8-15 of the target instruction, effectively turning an instruction with a fixed argument (e.g., a length field) into an instruction with a variable argument.
- Privileged-mode execute instructions as on the KL10 are used by operating system kernels to execute operations such as block copies within the virtual space of user processes.