|
Introduction
Porting tools
Mimic/68K
Mimic Pricing
Services
Downloads
|
Aimed at embedded applications, Mimic/68K is a program which allows
software written for a 68000, 68010 or 68020 processor to run
unchanged on PowerPC and other RISC processors. It does this by
reading the 680x0 code, interpreting the meaning of each instruction,
and carrying out an equivalent series of RISC instructions. Mimic/68K
is a very faithful emulator of the 68000 architecture, including both
user- and supervisor-mode instructions. It can be used to run whole
operating systems designed for the 680x0, or to run applications
which interface (through a mechanism which you can customize) to a
native RISC operating system, real-time kernel, or to native RISC
application code.
C source code to the Mimic/68K front-end is supplied with the
development kit, allowing the developer to customize the interface
very easily. 680x0 programs running under Mimic/68K can call out to
native code using unassigned 68K opcodes or TRAP instructions, and
native code can call 680x0 code by making calls into Mimic/68K. These
mechanisms can be used both to allow the 680x0 program access to the
facilities of the native environment, and to divide up processing
between speed-critical native code, and non-critical emulated code.
Recommended applications
Mimic/68K is recommended for porting 680x0 code which cannot be
recompiled (using a native RISC compiler) or translated (using
PortAsm/68K or Relogix), or for which it is not cost-effective to produce a
native version. For example, it would be appropriate where:
- The original source code is not available, or the code was
written in a language for which no suitable compiler is available;
- The code is large, rarely run, and performance is not
critical. In such cases - particularly if code size is a key
constraint - running it under Mimic/68K may be the most
cost-effective option;
- 68K object code is held on removable media (such as diskettes
or CD-ROM), or in plug-in modules which must still be supported.
Features
- Fully supports all 68000 and 68010 instructions. 68020 instructions
are also fully supported in the PowerPC, POWER and MIPS versions
of Mimic/68K.
- User mode and supervisor mode both fully supported.
- Fully customizable by changing the supplied C front-end source
code.
- 680x0 interrupts can be simulated by calling into Mimic/68K
from an asynchronous task or interrupt service routine.
- Exceptions can be handled either in native or emulated code.
- Runs in less than 100KB.
- Very easy integration with native C or other high-level code.
- Includes loaders for 68K ELF, COFF, S-record and raw binary
object files.
- Includes 68K debugger for debugging emulated code.
- Supplied with source-code to the front-end loaders and
debugger.
- Automatic integration with code translated using PortAsm/68K.
- Supplied with pre-built sample executables for AIX, MacOS,
PowerPC Linux and Wind River VxWorks, for immediate out-of-the-box
operation.
Supported Processsor Architectures
- PowerPC
- POWER
- MIPS
- M·CORE
Supported Runtime Environments
PowerPC:
- EABI/ELF standard for embedded applications (big-endian only)
- XCOFF-format (AIX, MacOS, and PowerOpen compatible)
POWER:
MIPS:
M·CORE:
- Freescale M·CORE standard ABI
Supported Development Environments
- IBM RISC System/6000 under AIX
- Windows 95/98/Me/NT/2000/XP
- Sun SPARC under Solaris and SunOS
- Linux on x86 and PowerPC
- Wind River Tornado
On-Line Manual
Electronic versions of the Mimic/68K manual are available on-line:
|
