What an Exception Is
An Exception (sometimes also called an Interrupt depending on its source) is an unexpected event during instruction execution that the normal flow of a program cannot handle on its own, such as attempting to execute an instruction with an invalid opcode, an arithmetic overflow, or an attempt to access a memory address the program is not permitted to touch.
Why Exceptions Cannot Simply Be Ignored
Continuing normal execution after an exceptional condition would produce incorrect or undefined behavior. Instead, the processor must stop the offending instruction, preserve enough information about what was happening at the time, and transfer control to a special piece of software called an Exception Handler, which decides how to respond, whether that means terminating the offending program or attempting some form of recovery.
Detecting Exceptions in a Pipelined Design
In a pipelined processor, several instructions are in flight simultaneously, and different instructions can trigger exceptions at different pipeline stages. An invalid opcode is typically detected during decode, while an arithmetic overflow is only detected during the execute stage, and a memory access violation might only be detected during the memory access stage.
Because of this, the pipeline must track, alongside each instruction as it moves forward, whether it has triggered any exception condition, without immediately interrupting the entire pipeline the moment the condition is first detected.
Similarities to Control Hazards
Handling an exception shares a strong resemblance to handling a mispredicted branch, covered earlier in this series: instructions that were fetched after the excepting instruction, but should not actually execute, must be flushed from the pipeline, and control must jump to a different location, in this case, the address of the exception handler rather than a branch target.
Excepting instruction: IF ID EX MEM WB
Later instructions: IF ID [flushed once exception detected]
Exception handler: IF [fetched instead]Preserving Enough Information to Recover
Before transferring control to the exception handler, the processor must record what instruction caused the problem, typically by saving its address in a dedicated register, so that the handler, or the operating system relying on it, can decide what to do next: terminate the program, retry the instruction after fixing the underlying issue, or take some other corrective action.
Why Correct Exception Handling Matters
An operating system's ability to catch programming errors, enforce memory protection between different running programs, and support features like virtual memory all depend directly on the processor correctly detecting exceptional conditions and reliably transferring control to handling software, rather than silently producing incorrect results or crashing without a controlled recovery path.