Every implementer of floating-point arithmetic, needs to think about how to signal overflow.
One possible way to do it is by raising an exception, though this creates the problem that 'exception' can end up getting interpreted as 'precise exception', and precise exceptions are a big headache to implement in the kind of heavily pipelined vector unit you want for high-performance floating point, so it's more common to do it by setting some bit(s) that the software can examine later, at some point where it doesn't mind a pipeline flush.
Also, there are occasions when you want to react to floating-point overflow by doing something other than terminating the program, e.g. you might implement logic along the lines of 'try this calculation, if it overflowed, then rescale the values and try again'. I don't know how common it is for this to be a useful thing to do. 50%, 5%, 0.5%?
Also, interactive programs like spreadsheets definitely want to react to overflow by e.g. printing asterisks in the overflowed cell, not by crashing and losing work.
Another way to do it is with an in-band marker, a special value that occupies the place of a floating-point value, but indicates 'this is not actually a valid value; overflow has occurred'.
A third way to do it is with an out-of-band marker, a sticky status flag. Clear it at the beginning of calculation, check it at the end; if it is set, that means overflow occurred at some point.
IEEE 754, which is what nearly everything implements nowadays, specifies all of the above plus the kitchen sink: signaling NaN, quiet NaN, multiple NaN values plus positive and negative infinity, overflow flag.
In the days before that standard, hardware typically implemented less of a profusion of ways to detect overflow. According to some of the answers to How did dusty deck Fortran handle overflow? some early machines signaled overflow by simply crashing the program.
Did any computers signal overflow purely with a sticky flag?