Instruction set architecture

Instruction set architecture, instruction architecture or also programming model, English Instruction Set Architecture or as an acronym ISA, is understood to be the entire externally visible architecture of a processor. As the interface between software and hardware, it allows a complete abstraction of the hardware, since it is limited to the functionality of the processor. While the microarchitecture defines the implementation in hardware, the ISA specifies the behavior of the processor for the software.

The instruction sets implemented by processor architectures are understood to be part of the architecture and are therefore usually given its name, e.g., the x86 instruction set. Instruction set architectures evolve with the processor architecture. If the innovations are implemented as instruction set extensions without changing the previous instruction set, the ISA remains backward compatible, as is the case with x86, for example: with IA-32, the 32-bit extension of the original 16-bit ISA is defined, and with x64, a 64-bit instruction set and a 64-bit operating mode have been added.

Because the instruction set architecture is specified as a formal description, it gives assembly language programmers in particular the ability to trace the uniform behavior of machine code for different implementations of a particular ISA (microarchitectures or virtual machines) in terms of registers, data types, etc. This allows them to create binary-compatible programs for different processors when they use the same instruction set architecture. This allows him or her to create binary-compatible programs for different processors when using the same instruction set architecture.

Formal specification

The formal specification of an instruction set architecture includes the description of the instruction set and its binary coding as well as a description of the behavior of the CPU during certain operating states and when certain events occur: In this context, the behavior of the CPU during an interrupt request, the start address of the instruction processing and the initialization of the registers after a reset, but also the structure of important data structures (e.g., the various descriptor tables in the protected mode of the x86 processors) should be mentioned, for example. This list makes no claim to completeness and is only intended to make clear that the specification of an instruction set architecture is more than the description of the individual instructions of its instruction set.

Forms of implementation

Microprocessor

A microprocessor is said to implement or support an instruction set architecture if it can execute all valid programs in the sense of the rules of this instruction set architecture in the intended manner. However, many real instruction set architectures have grown historically and have never been formally specified. This is often undesirable, since an exact specification would possibly enable a competitor to build CPUs with this instruction set architecture himself and relieve him of the task of finding out for himself which properties of an only vaguely described instruction set architecture it is that allow, for example, the preservation of backward compatibility with a historically grown stock of software. The history of x86-compatible CPUs shows this very impressively: In particular, the new developments of Intel competitors in the first half of the 1990s repeatedly showed more or less significant incompatibilities to the Intel model. In practice, therefore, some properties not documented in the data sheets or supposedly insignificant details of a concrete CPU often become part of an instruction set architecture.

Virtual machine

Since an instruction set architecture is merely a formal definition, it does not have to be implemented necessarily or even exclusively as a processor. It can also be implemented in software as a so-called virtual machine. This is also referred to as emulation. In this way, software for an instruction set architecture can be executed and tested before the associated CPU has even been built. For example, large parts of the IA-64 support for the Linux operating system kernel were programmed before the first Itanium left Intel's factories. This is also the reason why Linux was already running on the Itanium CPU shortly after the first test samples became available.