Re: is Vax addressing sane today

Let's look at how you might want to handle overflows when they happen:
>
1) Your language supports seemlessly transitioning to BigInts on
overflow.  Then each operation that could overflow needs to call
a special bit of code to change to BigInt and then continue the
calculation.  This code must exist, even if a trapping
instruction doesn't need an explicit branch to it.  Some
mechanism is needed to call this code.

IOW, this is the case where the program thinks it's manipulating some
"mathematical number ∈ Z" or something like it.

2) You need to call an exception handler, and the routine with the overflow
is ended.  We need to know which exception handler to call.

Not sure when that would be useful, other than for low-level coding.

3) You want to clamp the value to a reasonable range and continue.  The
reasonable values need to be looked up somewhere.

Here overflow detection can be useful only to the extent that the
wrap-around may hide the range-error (or confuse its nature between
over<->under).

I'm not familiar with code needing this, but I heard such needs are
common in some fields.

4) You just want to crash the program.  If a debugger is attached, it can
say where the overflow occurred.

Beside debugging, this corresponds to the case where the code thinks
it's manipulating some "mathematical number ∈ Z" or something like it
yet we have a good reason to think that this number will "never"
overflow, so we never want to switch to bigint because an overflow means
our "good reason" was crap and we we're in trouble anyway.

IME, this shows up typically for integers related to the size of some
data-structure, where the limited address space "guarantees" that we'll
never go beyond some limit.  They're *very* common (think array indices
and things like that) and using overflow-trapping operations for them
would make sense.  At the same time, they *should* never overflow, and
if some error somewhere means one of them can overflow (e.g. mistakenly
using (u)int32 for array indices in a 64bit system), there's a good
chance that the error will cause other trouble which may prevent us from
even reaching the overflowing operation.


        Stefan