68K, Mac

The Mac 68K emulator was a software emulator built into all versions of the Mac OS for PowerPC. This emulator permitted the running of applications and system code that were originally written for the 680x0 based Macintosh models. more...

Home
Apple Components
Apple Desktops
68K, Mac
Apple eMac
Apple iMac
Apple Mac Mini
Apple Power Mac
Apple Servers, Xserve
Apple Drives, Media
Apple Input Devices
Apple Laptops, Notebooks
Apple Monitors/Displays
Apple Networking
Apple Parts & Accessories
Other Apple Products
Printers, Scanners & Ink
Vintage Apple/Macintosh
Wholesale Lots

The emulator was completely seamless for users, and reasonably seamless for programmers. It is thought that this aspect of the Mac OS is the first time that such a dual hardware architecture operating system had ever been successfully implemented. It was primarily developed by Eric Traut, who later worked on successful emulation projects such as Connectix Virtual Game Station and Microsoft Virtual PC.

All versions of this emulator emulated the 68LC040 chip instruction set. Early versions emulated it in a simple fashion where each instruction was carried out by a series of equivalent PowerPC instructions. Later, a dynamic recompilation emulator was used, to boost performance. This worked by "recompiling" common sections of 680x0 code into faster sequences that were locally cached. The emulator could recognise the same sequence of 680x0 code, and run the previously cached code to avoid doing the translation again. This emulator was capable of emulating the 68LC040 faster than any real 68LC040 was capable of running.

One reason that this emulation was so successful is that many of the APIs for the Mac OS were originally implemented as traps on the 680x0 processor - calling an API actually was recognised by the 680x0 as an error condition, which would cause it to handle that error through one of its hardware vectors, which in turn would look up and run the operating system routine from ROM or RAM. In the emulator, such traps could be replaced by native PowerPC code, so the only code being emulated was the application itself - any system API it called could be accelerated with native PowerPC code. It also allowed Apple time to port the OS to the PowerPC - at first only time critical aspects were rewritten in native code, leaving much of the OS emulated. Gradually most of the OS was rewritten to be native, so the OS got faster over time.

For the programmer, the transition to the PowerPC was made fairly painless, as the emulator was started and stopped automatically. This was achieved using a new type of pointer called a Universal Procedure Pointer (UPP). For 68k code, this pointer was just an ordinary pointer - such code would already be running on the emulator so a call to another piece of 68k code via a pointer just continued as normal. This backwards compatibility with existing object code was vital to the success of the scheme. For PowerPC code, or 68k code calling PowerPC code, the pointer actually led to a special data structure, which contained a special trap instruction and flags indicating the instruction set architecture (ISA) of both the caller and called code, and could be passed to the CallUniversalProc() function to trigger actual execution. CallUniversalProc() then dealt with details such as presenting passed parameters in the right order for the ISA in question, as well as starting and stopping the emulator as required. The compilers for Mac OS created such UPPs automatically when the proper macros were used, and the PowerPC system libraries contained native stubs to transparently call through to native or still-68k functions as needed, so dealing with the dual architecture required very little work for the programmer. And just like the OS, applications themselves could mix and match 680x0 and PowerPC code fairly easily.

Read more at Wikipedia.org