CSC448: Code Generation Revisited: Exceptions [126/133]

The traditional solution to dealing with exceptional cases is to distinguish normal values from exceptional values, and to require every piece of code to check for exceptional values. However, this is neither robust nor manageable, even in modestly sized systems, nor is it appropriate for processing asynchronous errors.

Exceptions provide a control-flow mechanism that is quite different from other control-flow constructs found in common languages.

Exceptions provide a form of non-local jump where the destination is unknown: we must provide an exception name and the runtime system will jump to the most recent exception handler block that we are currently inside.

In addition, the runtime system may:

• Pass information with the jump, e.g., passing a subclass of Throwable in Java.
• Execute code in between throwing the exception and catching it in the exception handler, e.g., executing finally blocks in Java.

Some examples:

• Pass through many activation records and reach the top-level exception handler, as well as checked vs unchecked exceptions: file:Test1.java, file:E1.java, file:E2.java
• More complex control flow: file:Test2.java
• Finally blocks always executed: file:Test3.java
• Finally blocks always executed, even in odd situations: file:Test4.java

There are many tricky details:

• Java forces you to declare checked exceptions. The unchecked exceptions are subclasses of RuntimeException or Error, e.g., you need need not declare ArrayStoreException or SecurityException everywhere.
• What happens if we evaluate f (e1, e2), e2 has a side-effect, and e1 throws an exception? Is there a guaranteed order of evaluation?
• Java exceptions are heap-allocated objects and can contain arbitrary information. In particular, a stack trace is extremely useful.
• APIs with possible exceptions in the method signatures is handy for static analysis, but it can be restrictive for implementations. For this reason, Java has added "cause" exceptions, where one exception wraps another.