Editing Classic RISC pipeline (section)

==Exceptions==

Suppose a 32-bit RISC processes an ADD instruction that adds two large numbers, and the result does not fit in 32 bits.

The simplest solution, provided by most architectures, is wrapping arithmetic. Numbers greater than the maximum possible encoded value have their most significant bits chopped off until they fit.  In the usual integer number system, 3000000000+3000000000=6000000000.  With unsigned 32 bit wrapping arithmetic, 3000000000+3000000000=1705032704 (6000000000 mod 2^32). This may not seem terribly useful.  The largest benefit of wrapping arithmetic is that every operation has a well defined result.

But the programmer, especially if programming in a language supporting [[large numbers|large integers]] (e.g. [[Lisp (programming language)|Lisp]] or [[Scheme (programming language)|Scheme]]), may not want wrapping arithmetic.  Some architectures (e.g. MIPS), define special addition operations that branch to special locations on overflow, rather than wrapping the result.  Software at the target location is responsible for fixing the problem.  This special branch is called an exception.  Exceptions differ from regular branches in that the target address is not specified by the instruction itself, and the branch decision is dependent on the outcome of the instruction.

The most common kind of software-visible exception on one of the classic RISC machines is a [[Translation lookaside buffer#TLB-miss handling|''TLB miss'']].

Exceptions are different from branches and jumps, because those other control flow changes are resolved in the decode stage.  Exceptions are resolved in the writeback stage.  When an exception is detected, the following instructions (earlier in the pipeline) are marked as invalid, and as they flow to the end of the pipe their results are discarded. The program counter is set to the address of a special exception handler, and special registers are written with the exception location and cause.

To make it easy (and fast) for the software to fix the problem and restart the program, the CPU must take a precise exception.  A precise exception means that all instructions up to the excepting instruction have been executed, and the excepting instruction and everything afterwards have not been executed.

To take precise exceptions, the CPU must ''commit'' changes to the software visible state in the program order.  This in-order commit happens very naturally in the classic RISC pipeline.  Most instructions write their results to the register file in the writeback stage, and so those writes automatically happen in program order. Store instructions, however, write their results to the Store Data Queue in the access stage.  If the store instruction takes an exception, the Store Data Queue entry is invalidated so that it is not written to the cache data SRAM later.