Почему эмуляция процессора медленная

Different CPU (IA-32, ARM9 etc.) operations should be equivalent in their nature (move, read, write data etc.).

They should be but they are not. A CPU architecture implements these basic operation according to how its designers envisioned - and this can be very different depending on what the designers are trying to accomplish. Things that may be done in one instruction on some CPUs may require many, many instructions on others.

Could we simply convert an executable file, then execute it? Why it's so resource dependent anyway (why do I need a powerful CPU to emulate other CPU)?

If all you want to do is emulate the CPU, then this can be done and done relatively easily. "Converting" an executable file on the fly is called "dyamic recompliation" and many emulators do that already. Typically though, one wants to emulate an entire platform. This includes hardware other than the CPU, and sometimes that hardware is difficult to emulate (the Atari 2600 TIA, for example) or poorly documented (the NES PPU video hardware or even current GPU hardware) or both. CPUs always function in the context of a platform and usually software expects the CPU + platform together to work in a certain way. The requirements for emulating a platform, and doing so with the strict timing requirements often required, is what's the hard and resource intensive part.

First, although there certainly are instructions that are very similar, it's not the case that there is some set of instructions that always behaves the same way on different CPU architectures. For accurate emulation it's (usually) not enough to translate each instruction - you have to handle memory accesses, timing, interrupts... and that's just for the CPU.

It seems that what you're thinking of is static recompilation, but it's very difficult to do (in fact, I think it boils down to the halting problem, making it actually impossible in theory). In practice we can sometimes do it for a subset of programs, but you can't write a general purpose compiler that takes object code for one architecture as input and outputs perfectly equivalent code for another. For example, it would be hard to handle self-modifying code using this method.

Dynamic recompilation (which generates code on-the-fly as the program executes) is more successful (still non-trivial to do right). The specific issues will depend on the architecture, though. In many cases emulating the CPU is not the problem, but emulating various peripheral devices, maintaining accurate timing, is (see e.g. byuu's article on emulating the SNES).

Sometimes you can ignore a lot of these constraints and still emulate hardware well enough to get a subset of the software working, but it's never possible (as far as I know) to have 100% accuracy with zero overhead unless you have the actual hardware.