Extremely CISC instructions

[Dennis Boone]

 > I'm interested in collecting examples of single instructions for any CPU
 > architecture that are unusually prolific in one way or another.

The Prime 50 Series has a few candidates:

1.  The procedure call instruction allocates a stack frame, saves the
calling procedure's state, then calculates the effective address of the
called procedure's Entry Control Block, from which it loads various
register values.  It then follows a chain of argument pointer assembly
words following the instruction opcode to compute the locations of any
arguments, storing those into the stack frame.

In the process, it may follow chains of address indirection, perform
ring weakening, and extend the stack into a new segment.  The process
of transferring argument addresses is interruptible, and will be
resumed if necessary when the called procedure begins running.

2.  A series of semaphore instructions manage serialization.  A
semaphore consists of a count field and a list of PCB addresses.  The
wait instruction increments the count and adds the PCB address to the
list.  A notify decrements the count and schedules the next winner.

3.  Instructions related to interrupt handling and process exchange, and
stack management.  On 50 Series, the operating system sets up various
scheduling and process control structures, and then the microode is
responsible for selecting entries from scheduling queues, fetching
needed state from a process control block, and starting execution of the
new process.  A process PCB is "on" one queue at a time, whether it be
the idle list, or one of various priority level queues.

First level interrupt handlers are responsible for notifying second
level responders, which entails the microcode manipulating queues and
other process control structures.

4.  Register save and restore instructions may read or write up to 27
words from main RAM, depending on the save mask.

5.  Decimal arithmetic, numeric edit, character string copy / fill /
move / compare / translate / edit operations which may read or write up
to 64k words of memory.  The edit instructions run subprograms of
somewhat arbitrary length, and opcodes including conditional copy, fill,
insert, etc.

De