Brief Introduction

ARMware, like VMware or Bochs, is an emulator for a hardware platform. Opposite to the x86 platform which VMware or Bochs want to emulate, ARMware provides an emulation environment for the ARM platform. It can emulate Intel StrongARM SA-1110 as the core for now (The support for Intel Xscale is been developping). The whole emulated environment which ARMware provides is like HP iPaq H3600 (The future emulation environment for the Intel Xscale will be like HP iPaq H5500).

The hardware components that ARMware can emulate for now are:


Execuation flow paths

  1. If ARMware meets with an EBB which it didn’t execuate before, ARMware will use the build-in interpreter to interpret that block of ARM codes.
  2. Through the build-in profiler, ARMware will decide which block should be optimized by the build-in threaded-code engine. Then the build-in threaded-code engine will translate that EBB into threaded codes.
  3. If ARMware meets that threaded-coded EBB again, it will use the threaded codes to execute that block of ARM codes. In the execuating, however, if it jumps to an un-threaded-coded EBB, ARMware will fall back to the interpreter mode to interpret it.
  4. Again, through the build-in profiler, ARMware will further decide which block should be dynamically compiled. Then the build-in dynamic compiler will compile that block into x86 machine codes.
  5. If ARMware meets that dynamically-compiled EBB again, it will use the x86 machine codes to execuating that block of ARM codes. In the execuating, however, if it jumps to an un-dynamically compiled EBB, ARMware will fall back to the interpreter or threaded-code mode to execuate it.


  1. Doesn’t support network.
  2. Doesn’t support audio.

Architecture Graph

Packet Content

ARMware includes a main program, several libraries, and several pictures which ARMware needs, and 2 traditional chinese translation files.

System Requirement

NOTE: Because of the incompatibility between the C++ ABI of gcc-3.3 and gcc-4.0, all of the above 4 libraries (gtkmm, glibmm, libsigc++, libxml++) should be compiled by gcc-4.0 or above. (The C++ ABI of gcc-3.4 and gcc-4.0 are the same, so you can use gcc-3.4 to compile these 4 libraries, too)

As far as I know, debian stable, testing, and unstable release, and ubuntu hoary are still using gcc-3.3 as their default compiler. However, ubuntu breezy has already switched to the gcc-4.0. Thus you can get packages for these 4 libraries from the breezy directly, or you can get the source codes for these 4 libraries, and compile them by gcc-4.0.

Linux Kernel Patch

Because of the quality of the touch panel in iPaq is not good, linux kernel will discard the user input axis data at first time. However, because ARMware is a software emulator, linux kernel doesn’t need this strange behavior. Thus, I modify parts of the linux kernel source, including touch panel revising and increasing the console log level such that every kernel messages will be printed to the serial console.

If you want to execute ARMware and compile your own linux kernel, you have to download this kernel patch.

Note: This kernel patch is for kernel version 2.4.19-rmk6-pxa1-hh30.


All of the following files can be downloaded from the download area at the bottom.

  1. Install ARMware.
  2. Download bootldr.bin and root.bin, and put them into a directory.
  3. Execute armware.
  4. In the “Machine Name” window at the right hand side, press the mouse right button and select “New”.
  5. Enter the machine name you wanted in the “Basic Information” tab.
  6. In the “Flash ROM” tab, click the “Flash ROM Image” button to select the final ROM file you wanted. Enter 16 Mbyte in the “Flash ROM Size” field. Enter 0 in the “Starting Address” field at the bottom, and enter 256 Kbyte in the “Partition Size” field, and click “Partition Image” button to select the bootldr.bin you just downloaded. Click “Add” button. Then following the same steps to add root.bin. Its parameters are: “Starting Address”: 0x40000, “Partition Size”: 16128 Kbyte, “Partition Image”: root.bin. When you done, click “Start Burning” button at the left bottom corner to create the final ROM file you selected.
  7. Enter 240 as the screen width and 320 as the screen height in the “Screen Size” tab. Press “Ok” to finish the settings.
  8. Click the “Power On” button on the menu bar, then you can now start to execute the ARM version linux.


Users can modify the memory size for the emulated environment

After the DRAM size modifying, ARM linux kernel indeed detects larger memory size

Users can choose their favorite font, text color, and background color used for the serial console

The new version serial console can support the ANSI color codes

ARMware can use GNU dbm (gdbm) as its machine database

ARMware can use xml as its machine database

Using Qt as its user interface

Using Gtk as its user interface

About the designer (Gtk interface)

Configuration menu (Gtk interface)

Burning Flash ROM (Gtk interface)

Burning done (Gtk interface)

Booting to boot loader (Gtk interface)

Linux kernel is loaded, and un-compressed (Gtk interface)

Execuating kernel, and starting to run /sbin/init (Gtk interface)

Entering GUI, calibrate touch panel (Gtk interface)

gpe initialization screen 1

gpe initialization screen 2

gpe welcome screen

Tetris game

Maze game



Booting process (Enabled the threaded code engine & dynamic compiler) (divx4)
Input commands to serial console (Enable the threaded code engine & dynamic compiler) (divx4)
Calibrate the touch panel (Disabled the threaded code engine & dynamic compiler) (divx4)
Input personal information (Disabled the threaded code engine & dynamic compiler) (divx4)
Tetris game (Disabled the threaded code engine & dynamic compiler) (divx4)