There are counterpoints as well: The complex instructions in heavily microcoded implementations may not take much extra machine resources, except for microcode space. For example, the same ALU is often used to calculate an effective address and to compute the result from the operands, e.g., the original Z80, 8086, and others. The simpler non-RISC instructions (i.e., involving direct memory operands) are frequently used by modern compilers. Even immediate to stack (i.e., memory result) arithmetic operations are commonly employed. Although such memory operations, often with varying length encodings, are more difficult to pipeline, it is still fully feasible to do so - clearly exemplified by the i486, AMD K5, Cyrix 6x86, Motorola 68040, etc. Non-RISC instructions inherently perform more work per instruction (on average), and are also normally highly encoded, so they enable smaller overall size of the same program, and thus better use of limited cache memories.
There are counterpoints as well The complex instructions in heavily microcoded implementations may not take much extra machine resources except for microcode space For example the same ALU is often used to calculate an effective address and to compute the result from the operands eg the original Z80 8086 and others The simpler non-RISC instructions (ie involving direct memory operands) are frequently used by modern compilers Even immediate to stack (ie memory result) arithmetic operations are commonly employed Although such memory operations often with varying length encodings are more difficult to pipeline it is still fully feasible to do so - clearly exemplified by the i486 AMD K5 Cyrix 6x86 Motorola 68040 etc Non-RISC instructions inherently perform more work per instruction (on average) and are also normally highly encoded so they enable smaller overall size of the same program and thus better use of limited cache memories