Continuations

Has there ever been a hardware architecture that managed the flow of
control via “continuations”?

That is, you do away with the hardware concept of a stack. Instead, you
have call frames that, while defined to some extent by the architecture,
can be located anywhere in memory (allocation managed by the OS, runtime
etc as part of the ABI). A call frame has a current program counter, and
maybe some other context like local variables and a static link for
lexical binding. Instead of a “return from subroutine” instruction, you
have a “load new call frame” instruction.

You might have a location defined in a call frame for a “pointer to parent
call frame” field, in which case “return from subroutine” just loads this
pointer into the current-call-frame register. But you could just as easily
have pointers to other call frames defining other kinds of
interrelationships between them. And note that transferring to a different
call frame does not automatically invalidate the previous one. If it stays
valid, then there is no reason why you couldn’t, at some point, come back
to it and resume execution from where it left off.

The beauty of continuations is that they are a single generalized control
construct that can be used to implement specific language features like
regular routine calls, loops, exceptions and coroutines, all built from
the same common abstraction. One thing that is difficult to do with them
is arbitrary gotos. (I consider that a feature, not a bug.)

Very few high-level languages (outside of the Lisp family, anyway) seem to
have implemented continuations as an explicit language concept. This is an
integral part of Scheme, not so much it seems of non-Scheme Lisps. I
implemented it in my PostScript revival language
<https://bitbucket.org/ldo17/gxscript/>, and I am still trying to come up
with a useful example, like for instance an implementation of coroutines,
that doesn’t do my head in. ;)