What about fundamental types like int? I can think of four valid uses for
volatile, all more or less related to the idea that volatile suppresses
optimizations and forces the compiler to go to memory for each read and
write to a volatile object.

1. On amenable hardware like x86, this idiom can work, and it requires
volatile to prevent the compiler from caching x in a register in the loop:

// The variable x is accessible to multiple threads, one or more of
// which change it and indirectly stop the loop below, which is
// executing in another thread. Note that x must always be accessed
// atomically for this sort of thing to work in general.
volatile bool x = true;

while (x)
   whatever;

// Assuming everyone observes the locking protocol, this approach
// would work on all hardware, even weird architectures like Sparc
// and others which require memory barriers:

bool x = true; // As above, just non-volatile

for (;;)
{
   lock(mx);
   bool y = x;
   unlock(mx);
   if (!y)
      break;
   whatever;

3. You can use volatile, say, to declare a pointer to a volatile int, which
represents a memory location updated at the interrupt level, something you
can't synchronize with, and which is outside the compiler's knowledge of the
program.

4. You can use volatile to prevent the compiler from optimizing away
operations which, as far as the compiler is concerned, seem to have no
purpose, because it can't see that the results are used or that the side
effects of computing the results are important. (This one fits your division
by zero example.)