ARM ISA overview

In most respects, ARM is a RISC architecture. Like all RISC architectures, the ARM
ISA is a load-store one, that is, instructions that process data operate only on
registers and are separate from instructions that access memory. All ARM
instructions are 32-bit long and most of them have a regular three-operand
encoding. Finally, the ARM architecture features a large register file with 16
general-purpose registers. All of the above features facilitate pipelining of the ARM
architecture.
However, the desire to keep the architecture and its implementation as simple as
possible prompted several design decisions that deviated from the original RISC
architecture. First, the original Berkeley RISC design used register windows to
speedup procedure invocations. ARM designers rejected this feature as one that
would increase size and complexity of the processor. In retrospect, this appears to
be a wise decision, as register windows did not prove to be a particularly useful
feature and are not used in the majority of modern RISC processors.
Second, the classical RISC approach requires the execution stage of any
instruction to complete in one cycle. This is essential for building an efficient 3stage fetch-decode-execute pipeline. While most ARM data processing instructions
do complete in one cycle, data transfer instructions are one important exception.
Completing a simple store or load instruction in one cycle would require
performing two memory accesses in a single cycle: one to fetch the next
instruction from memory, and the other to perform the actual data transfer.
Performing two memory accesses in one cycle would, in its turn, requires a
Harvard architecture with separate instruction and data memories, which was
considered too expensive by the designers of the first ARM processor. However, in
order to achieve better utilisation of the pipeline during 2-cycle instruction
executions, they introduced an auto-indexing addressing mode, where the value
of an index register is incremented or decremented while a load or store is in
progress. While all modern ARM implementations have separate instruction and
data caches and can complete a memory transfer in one cycle, they still support
the auto-indexing mode that proved to improve performance and code size of
ARM programs.
Third, ARM supports multiple-register-transfer instructions that allow to load or
store up to 16 registers at once. While violating the one cycle per instruction
principle, they significantly speedup performance-critical operations, such as
procedure invocation and bulk data transfers, and lead to more compact code.
In summary, the ARM architecture offers all the benefits of the RISC approach,
such as pipeline-friendlyness and simplicity, while deviating from it in few aspects,
which makes it even more appealing to embedded systems developers.