No way that is possible, at least for the PS3 since it's so different than the PC. Xbox360 *could* be done like that but it would still be very very hard.
It's not as easy as just doing a 1-to-1 translation. All the consoles use a different architecture than your standard desktop, a difference that Wine doesn't compensate for. Even then, Wine only implements a very small portion of the Windows API, the actual code running is run pretty much unmodified. This wouldn't be the case for any console.
What you thought up is (essentially) what the most basic form of emulation is, called an 'interpreter'. It goes instruction by instruction and does whatever the necessary action is to emulate it; but is horrifically slow due to the large amount of overhead that must happen for every single instruction.
You may think to yourself "what if batches of instructions could be translated at once, then executed?" and after some thought you'd arrive at the solution that most every emulator uses, a technique that translates chunks of code on the fly and stores them away for later used. As long as the chunks aren't modified during execution, the large initial overhead is reduced significantly.
So even if you tried your idea, you'd still end up with all the basic parts of an emulator; they would just have different names. You'd still have to emulate the sound/graphics chipsets and I/O stuff because it's radically different than your PC's, so really it would be an emulator of sorts spread out over multiple independent parts.
"This thread should be closed immediately, it causes parallel imagination and multiprocess hallucination" --ardhi
I think this is what they are trying to do with Cxbx(Xbox emulator), but for now they don't get very far with it.
You will need at least DirectX 11 to Emulate Xbox 360s tesselation engine.
echosierra: Actually what he's thinking of is static translation -- parsing code statically and replacing hardware accesses and system calls with new code that invokes emulated layers and/or local PC hardware/system calls directly. That strategy is typically tried on systems that use PC architecture internally, like the original XBox. I'm not sure any emulator has really used it successfully though.
There is also a second form of static translation possible, where you can convert between architectures. It's doable on older ROM-cart-based systems (or most hand-helds). It works like a recompiler, except all code in the entire binary is recompiled right when the emulator loads. This works for ROMs because they can't use dynamic code modification (either dynamic libraries or self-modifying code). Unfortunately most modern consoles rely on at least the first one (PS2, PS3, Xbox360, etc. all have the potential to use DLLs and stuff).
Depending on how the architecture's CPU-based exception handling (or IRQ lines) works, even working static translation of that style won't really be any faster anyway.
The XBOX360 is a PowerPC architecture, much like the PS3. Neither can be translated into PC (Intel/AMD) architecture easily, and both have robust exception-handling CPUs that wouldn't really be any faster as static translation over dynamic translation anyway.
The best hope for PS3/XBOX360 emulation is HLE: High-level Emulation of the BIOS, Operating System, and common libraries provided by Sony, IBM, and Microsoft. That would be a massive undertaking, especially for what would essentially be re-coding much of the OS, but it's really the only way you could ever hope to have acceptable emulation speeds within the bulk of our lifetimes.
Jake Stine (Air) - Programmer - PCSX2 Dev Team