UNIX for Dummies Questions & Answers

I have searched and searched this topic but without looking at source code ; my next step maybe , I find the same ambiguous information.

My main question is how is the target code translated? It is stated that there are variables created that hold the data that the emulated CPU would hold in it's registers so I assume that an algorithm is run with this data to produce the binary that the CPU needs. Would these variables represent a dummy CPU and the algorithms convert the target CPU variables (registers) to what the host can execute?

Interpreted implies that the Emulator would just be substituting code for other code from a look-up table but then the program would actually be more or less ported at this point would it not?

Any help or direction will be appreciated.

consulting QEMU Documentation might help

It's hard to call something 'ported' when it can't run outside the emulator, no.

The exact approach may depend on the emulator in question. qemu, for instance, can use CPU virtualization features if you're emulating the same architecture you're on -- setting up a virtual environment in hardware. This lets programs run in the virtual environment mostly natively, just trapping a few higher-ring instructions and the like so software can take over and fill in the gaps. This was actually possible without hardware virtualization support, but it makes it much easier and more efficient -- I'm not too well read on the details but suspect it involves more direct/explicit ways for the client to talk to the host, for starters.

For emulators that run instructions that are completely alien to the native processor, the obvious way would be to make a data structure in memory that represents the registers of the native CPU, and use something like a big switch statement or look-up table to branch to the appropriate code for each instruction. If the emulated CPU has fewer registers than the native one I suppose you could stick everything in registers, use jump tables, self-modifying code, raw ASM and other dirty tricks to make it much faster but in the end it's the same idea.

Maybe this might help.

Why emulate the CPU if you have the instruction set? The data structure is Really the Emulated CPU is it not? The emulated CPU would be imaginary besides for its reprentation in a file the emulator would address so I could have registers of how many and what size I could dream up could I not?

Thanks again!

It's been found useful to break up one big server into many smaller, virtual ones. When you hear the term "virtual server" this is what they're talking about, a virtual environment inside a bigger server in which you can install pretty much whatever OS and software you want. Sometimes the host OS supports virtual environments natively, or it can be done through software like Qemu and VMware. Hardware virtualization has made this reasonably efficient now, but if they had to actually emulate all these environments instruction by instruction? It wouldn't be practical. Data is registers; they just sit there. The program has to decide what to do to them. In a real CPU, this would be decided in hardware. In a software emulator, it has to do it 'by hand' as it were, decoding which instruction it is with binary logic operations and finding it in a big look-up table or something, then doing operations on the "registers" as appropriate. Absolutely. I was just talking about optimization.

Okay, I write code that mimics a CPU in that it has memory assigned to registers and flags and such to document the entire state of the CPU. I can't find a way around that I believe that for every target CPU instruction my emulator basically looks up a routine in a table and this routine changes the state of my phony CPU that exists in memory. Now I would have the phony CPU run the data and this would just be saved in memory. What would the process or application be called that puts this data in a certain form so the O.S would then run it and how would it do it?

Any help will be appreciated!