Abstract:
A method of porting a video game or other application from one platform to another involves decompiling the game executable to develop source code in a high level programming language such as C. The (re)generated source code is re-linked using target native libraries to handle hardware functions (e.g., video, audio, etc.) for the target platform. The resulting “trans-compiled” executable is able to efficiently run on the target platform, potentially providing orders of magnitude speed performance boost over other traditional techniques.

Description:
CROSS-REFERENCES TO RELATED APPLICATIONS 
     This application claims priority from commonly-assigned provisional application No. 60/572,112 filed 19 May 2004 entitled “System and Method for Trans-Compiling Video Games” and from commonly-assigned provisional application No. 60/655,895 filed 25 Feb. 2005 entitled “System and Method for Trans-Compiling Video Games”, the entire disclosures including the drawings of which are hereby fully incorporated herein by reference as if expressly set forth. 
    
    
     STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT 
     Not applicable. 
     FIELD 
     The technology herein relates to video games, and more particularly to techniques for allowing video games to run on various different platforms. The technology herein also relates to solutions for the controlled translation of game object code to new and/or different platforms, and to translation utility tools, systems and techniques for providing such solutions. In still more detail, the technology herein relates to systems and methods for trans-compiling video game and other software so it can run efficiently on a platform other than the one it was originally intended and/or written for. 
     BACKGROUND AND SUMMARY 
     Nintendo&#39;s GAME BOY® hand-held and home video game platforms have been extraordinarily successful. Nintendo released its first Nintendo Entertainment System home video game console in the early 1980&#39;s and released the first GAME BOY® in the late 1980s. Since then, this product and its successors (Super Nintendo Entertainment System, Nintendo 64, Nintendo GameCube System, GAME BOY COLOR®, GAME BOY ADVANCE®, Nintendo DS, and other systems) have captured the imaginations of millions of video game players throughout the world. 
     A wide number of different software applications (including but not limited to video games) have been designed to run on these various platforms. People throughout the world enjoy these applications every day. One can see them being used at home, on subways, at sports arenas, after school, and in a number of other contexts. See  FIG. 1A  to see someone playing an exemplary handheld Nintendo video game platform. 
     Nintendo&#39;s gaming platforms are examples of platforms having specialized hardware that is optimized for low cost, excellent performance and good graphics. In general, these devices are not really general purpose computers—they are special-purpose devices with specialized capabilities particularly adapted and often optimized to video game play. These special capabilities provide low cost and exciting video game play action with great graphics and sound to enhance the game playing experience. 
     More recently, handheld and portable computing devices are exploding in popularity. Cellular telephones now come with color displays and powerful processors and graphics accelerators that can perform complex imaging and computing functions including video game play. Handheld personal digital assistants (PDAs) have become increasingly sophisticated and capable with powerful processors, substantial amounts of memory resources, and some interesting graphics and display capabilities (some now even have graphics processors). Portable pocket personal computers provide as much hardware horsepower and computer graphics capabilities as desktop computers of only a few years ago. Gaming platforms such as home consoles and handheld video game systems are also being increasingly sophisticated, flexible and capable, and include additional capabilities such as touch screen (Nintendo DS), wireless communications (Nintendo DS, Nintendo Revolution), networked gaming, downloadable FLASH memory (Nintendo Revolution) and other features. 
     Convergence of these various technologies has led to multipurpose devices that can perform a variety of different functions. For example, cellular telephones can also perform functions of the type that pocket PCs and/or personal digital assistants have been performing for some time. The wireless networking capabilities of such convergence platforms offer interesting possibilities for networked, head-to-head or other video game play. 
     All of these hardware and platform innovations demonstrate that software content is perhaps the most important indicia of success. Just as television viewers are likely to be more interested in the particular TV programs they watch than in the type of television they watch them on, many video game players are likely to be more interested in the particular games they wish to play than in the hardware platforms and technology used to play those games. These market forces create an increasing need for efficient, cost-effective ways to take video games and other software written for one platform and permit them to be played on other platforms. 
     While the GAME BOY® platforms are inexpensive and have long battery life, there may be situations in which it would be desirable to play or use applications developed for one platform (e.g., GAME BOY®, NES, SNES, AGB, etc.) on such other platforms such as:
         other, non-native video game platforms   cell phones   personal digital assistants (PDAs)   pocket PCs   set top boxes   personal computers, laptop computers, workstations   automobile-mounted entertainment systems   airline, train and boat entertainment systems   smart telephones   portable music players   portable radios, stereos, etc.   wearable electronic appliances   credit card sized computers   any electronic appliance with a microprocessor and a display   any other computing systems with or without specialized graphics hardware.       

     As one example, an airline, train or other vehicle passenger might want to play video games during a long journey. As shown in  FIG. 1B , airlines are installing seat-back computer displays into the backs of airline seats. Such seat-back displays often provide a low cost personal computer including a processor, random access memory, liquid crystal display and input device(s). Similar displays could be installed in other vehicles (e.g., trains, ships, vans, cars, etc.) or in other contexts (e.g., at walk-up kiosks, in hotel rooms, etc.). It would be desirable under certain circumstances to allow users to execute all sorts of different applications including GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® video games and other applications using the general-purpose computer capabilities of such seat-back or similar display devices. 
     Personal computers (desktop, laptop and portable) have proliferated throughout the world and are now available at relatively low cost. One trend has shifted some entertainment from the home television set to the home personal computer, where children and adults can view interesting web pages and play downloaded video games, music, videos and other content. In some circumstances, it may be desirable to allow users to play GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® video games on their personal computers (see  FIG. 1C ). 
     A wide variety of so-called personal digital assistants (PDA&#39;s) have become available in recent years (see  FIG. 1D ). Such devices now comprise an entire miniature computer within a package small enough to fit into your pocket. Mobile cellular telephones are also becoming increasingly computationally-intensive and have better displays so they can access the World Wide Web and perform a variety of downloaded applications. Such devices as cell phones, PDAs, pocket PCs and the like may, for example, include a processor  50 , a display  52 , user input device(s)  54 , sound generation  56 , memory  58 , input/output  60 , and other capabilities including wireless communications. In some circumstances, it may be desirable to allow people to play GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® video games and other GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® applications on a personal digital assistant, cellular telephone or other such device. 
     It may also be desirable to allow video games written for one video game platform to play on another video game platform. For example, games written for the Nintendo Entertainment System, the Super Nintendo Entertainment System and the Nintendo 64 are fun and continue to have a very wide following. It might be desirable to play such games on newer video game hardware platforms such as for example the Nintendo Revolution system or the Nintendo GameCube System. 
     In one particular illustrative non-limiting example, the same special-purpose sound and graphics circuitry provided by the GAME BOY® and other video game platforms is not generally found in the various other platforms. Providing these missing capabilities is one of the challenges to running a GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® video game (or other GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® application) or other video game platform software on these other target platforms. 
     Another challenge relates to instruction set compatibility. For example, in one particular illustrative context, Nintendo&#39;s GAME BOY® is based on an older, relatively inexpensive microprocessor (the Zilog Z80) that is no longer being used in most modern general purpose computer systems such as personal computers, seat-back displays, cell phones and personal digital assistants. The Z80 instruction set (the language in which all GAME BOY® games and other GAME BOY® applications are written in) is not directly understood by modern Intel microprocessors (e.g., the 8086, 80286, 80386, Pentium and other processors in the Intel family) that are now widely used and found in most personal computers, seat-back displays, personal digital assistants, cell phones, and the like. Similarly, the ARM processor that the GAME BOY ADVANCE® product uses is not universally used. Other video game platforms use other processors that may not be widely available in cross-platform contexts. These compatibility issues provide challenges that it would be desirable to overcome in developing successful cross-platform gaming experiences. 
     One way to provide a cross-platform capability is to provide a software “emulator” on the target platform. See for example U.S. Pat. No. 6,672,963. Generally, a software emulator is a computer program that executes on a desired target platform (e.g., a seat-back display device, a personal computer, a personal digital assistant, a cell phone, a different video game platform, etc. as shown in  FIGS. 1B-1D ). The emulator software supplies at least some capabilities needed to run the game but which are missing from the target platform. As one non-limiting example, a software emulator may perform some or all of GAME BOY®&#39;s specialized graphics functions in software, and may interface with whatever graphics resources are available on the target platform to display resulting images. A software emulator may translate or interpret ARM instructions so the microprocessor of the target platform can perform the functions that GAME BOY ADVANCE® would perform if presented with the same instructions. The software emulator may include software code that emulates or simulates hardware capabilities within the GAME BOY ADVANCE® circuitry (e.g., audio and/or graphics processing) and/or translate associated GAME BOY ADVANCE® application requests into requests that can be handled by the hardware resources available on the target platform. For example, the target platform may include a graphics adapter and associated display that is incompatible with GAME BOY ADVANCE®&#39;s graphics hardware but which can perform some of the basic graphics functions required to display GAME BOY ADVANCE® graphics on a display. Emulators, in general, do not exactly emulate or duplicate the functionality of the original platform, but the functionality they provide is often “close enough” to provide a satisfying end user game playing experience. 
     A number of GAME BOY® and GAME BOY ADVANCE® emulators have been written for a variety of different platforms ranging from personal digital assistants to cell phones to personal computers. However, one area of needed improvement relates to obtaining acceptable speed performance and high quality sound and graphics on a lower-capability platform. A lower-capability platform (e.g., a seat-back display, a personal digital assistant or a cell phone) may not have enough processing power to readily provide acceptable speed performance. The target platform generally needs to run the emulator software as well as the game software, meaning that it has to, in a sense, do “double duty.” Unless the software emulator is carefully designed and carefully optimized, it may not be able to maintain real time speed performance when running on a slower or less highly capable processor. Slow-downs in game performance are generally unacceptable if the average user can notice them since they immediately affect and degrade the fun and excitement of the game playing experience. 
     Performance problems are exacerbated by the penchant of some video game developers to squeeze the last bit of performance out of the video game platform. Performance tricks and optimizations within a game application may place additional demands on any emulator running the application. Some emulators provide acceptable results when running certain games but unacceptable results (or do not work at all) for other games. An ideal solution provides acceptable results across a wide range of different games and other applications such that the target platform can run many games or other applications developed for the original platform. 
     Another challenge to good design relates to maintaining excellent image and sound quality. Ideally, the target platform should be able to produce graphic displays that are nearly the same quality as those that would be seen on the original platform. Additionally, the color rendition and other aspects of the image should be nearly if not exactly the same. Sounds (e.g., music and speech) should have at least the same quality as would be heard on the original platform. All of these capabilities should be relatively closely matched even on platforms with radically different sound and graphics hardware capabilities. 
     “Porting” is another common approach to provide cross-platform game playing capabilities. Many or most third party video game software developers are intensely interested in porting since it allows their games to run a variety of different platforms and thus increases potential sales. Video game hardware platform developers may also be interested in porting technology because porting can increase the library of games that are able to run on any particular platform. For example, if a particular game has become a hit on one platform, there may be interest in porting that game to other platforms as well. End users can benefit in some cases because they are able to play a particular game on the platform they have invested in without having to buy or borrow a different platform to play that game. 
     The technology herein provides new “porting” and/or other techniques for “trans-compiling” a video game written for one platform so that the resulting code can run on a different platform. 
     In one exemplary illustrative non-limiting implementation, a video game originally written for a portable dedicated video game hardware platform such as for example Nintendo&#39;s GAME BOY ADVANCE® platform can be “trans-compiled” so that it can be stored on a storage medium and played on a different platform such as a Palm Operating System based mobile and/or wireless computing device, a computing or video game device with a different (e.g., Intel-based) microprocessor or some other platform. 
     Briefly, in one exemplary illustrative non-limiting implementation, the binary executable code for the video game (i.e., the so-called “ROM” in Internet parlance) is decompiled to (re)generate source code. Such decompilation in one exemplary illustrative non-limiting implementation (re)generates the source code in a high level language such as C. The decompiled source code is then processed to eliminate unnecessary (e.g., hardware specific) libraries and functionality. The resulting modified source code is then recompiled and re-linked with libraries native to the target platform that are used to handle hardware functions such as video, audio, input, output, etc. 
     In one exemplary illustrative non-limiting implementation, the recompilation process links in libraries that remap hardware functions supplied by the original platform to new function calls for the specific target platform. The resulting recompiled game or other application can run at very high speed on the desired target platform (e.g., personal computer, Palm OS, other video game platform, or any other computing platform). 
     The techniques may, under some circumstances, provide well over an order of magnitude speed performance boost (e.g., ten to one hundred times faster performance) over prior traditional emulator approaches. The technology may allow games to be played on much lower cost/performance platforms than has generally previously been possible. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       These and other features and advantages will be better and more completely understood by referring to the following detailed description of exemplary non-limiting illustrative embodiments in conjunction with the drawings of which: 
         FIG. 1A  shows someone playing a Nintendo GAME BOY® portable video game platform; 
         FIGS. 1B-1D  show various different target platforms that could be used to emulate the  FIG. 1  GAME BOY®; 
         FIG. 1E  shows an example platform block diagram; 
         FIG. 2  shows exemplary illustrative non-limiting flowchart; 
         FIG. 3  shows exemplary illustrative non-limiting software components; 
         FIG. 4  shows exemplary illustrative non-limiting software module relationships; 
         FIG. 5  shows an example storage medium; 
         FIG. 6  shows an exemplary additional data flow illustration; 
         FIG. 7  shows an exemplary illustrative non-limiting tool chain component implementation; 
         FIG. 8  shows an exemplary illustrative non-limiting compiler statement translation; 
         FIG. 9  shows an exemplary illustrative non-limiting compiler statement translation; 
         FIG. 10  shows an exemplary illustrative non-limiting more detailed data flow; 
         FIG. 11  shows an exemplary illustrative non-limiting high level view of exemplary translation; 
         FIG. 12  shows an exemplary illustrative flow graph of an illustrative application before optimization; and 
         FIG. 13  shows an exemplary illustrative flow graph of the illustrative  FIG. 12  application after code optimization. 
     
    
    
     DETAILED DESCRIPTION 
       FIGS. 2 and 6  show an exemplary illustrative non-limiting implementations of trans-compilation systems and methods. In these exemplary illustrative non-limiting implementations, a software executable  502  (e.g., a “source file”) such as a video game file (“ROM”) in binary format executable on one platform is “trans-compiled” so it can run on a different platform. A trans-compiler tool  504  is used in the exemplary illustrative non-limiting example to decompile the binary executable to provide source code in a convenient higher level language such as C, C++, JAVA, etc. The (re)generated C source file  506  is then compiled and linked using libraries and headers and a standard conventional optimizing compiler/linker  508  to provide a new executable “target object” for the target platform. 
     The illustrative non-limiting implementation shown in  FIGS. 2 and 6  can be used to translate existing game objects to new target platforms. The tool  504  reads standard game ROM files and produces a standard “C” language file representation of the original game code. This C file is then compiled and linked using GCC with header, standard library and special abstraction layer files to create a new executable object for a target platform. Tool  504  extends traditional compiler technology to support object code translation, thus for example providing a system that can execute on very restricted target platforms without any loss in performance. Unlike at least some emulator contexts, exemplary illustrative tool  504  creates one new executable object for each original executable object. 
     The C compiler and linker  508  may compile and/or link the source code with hardware emulation/mapping library routines  510  designed or written for the particular target platform. Such library routines  510  may, for example, simulate, emulate and/or “stub” certain functions available on the original platform that are not available on the new target platform (e.g., graphics capabilities such as 3D effects, rotation, scaling, texture mapping, blending, or any of a variety of other graphics related functionality, audio functionality such as sound generation based on proprietary sound formats, etc.). The resulting trans-compiled object file  512  is stored in some type of storage medium (e.g., an SDRAM card, memory stick, internal RAM, Flash memory, etc.) to be efficiently run on the target platform to provide a satisfying and interesting game play experience. 
       FIG. 3  shows a view of exemplary software components of library routines  510 . Such software components may include, for example:
         CPU libraries  510   a,      memory management unit libraries  510   b,      interrupt libraries  510   c,      video library  510   d,      sound library  510   e,      I/O library  510   f , and   other libraries  510   g.          
     In the exemplary illustrative non-limiting example shown, the CPU library  510   a  provides functionality needed to allow the target CPU (which may be different from the original CPU) to run the game software or other application. In some cases, the target platform may have the same CPU as the original platform. In such cases, the CPU library  510   a  may not need to include detailed CPU cross-platform functionality. In other cases, where the CPU of the target platform is different than the CPU from the source platform, the CPU library  510   a  may need to provide certain functionality to allow the decompiled source code once recompiled and linked to run on the target platform. CPU library  510   a  may also contain a variety of different functions that the target platform uses to support the game application (e.g., original platform CPU runtime libraries that have been (re)written to optimize performance on the target platform). 
     The exemplary memory management unit library  510   b  shown in  FIG. 3  includes functions used to manage the actual, virtual and/or emulated memory provided by the target platform. The original platform for which the game or other application was written may include a particular memory architecture that the game or other application expects, takes advantage of and/or is otherwise customized for. In some cases, such memory management functionality may need to be emulated or simulated on the target platform. In other cases, the memory management functionality may be stripped out from the (re)generated source code and replaced with new memory management functionality optimized specifically for the target platform while still meeting requirements of the game. 
     In the exemplary illustrative non-limiting implementation, interrupt library  510   c  may be used to provide interrupt capabilities and support (see also discussion below on software interrupt capabilities). The original platform in general is likely to contain some type of interrupt structure and functionality (e.g., interrupt vectors, interrupt handlers, interrupt registers and associated priority, etc.) that may need to be emulated or otherwise provided on the target platform. Additionally, the target platform in general may contain an interrupt capability that the trans-compilation process desirably takes advantage of to provide high efficiency operation. As is well know, such interrupt capabilities allow for efficient handling of input, output, timing and other events without the need for extensive polling and other associated functionality. 
     In the exemplary illustrative non-limiting implementation, video library  510   d  is used to provide graphics support on the target platform. For example, video library  510   d  may support color graphics generation including 2D and 3D effects such as for example rotation, scaling, character-based or bit mapped graphics, hidden surface removal, foreground/background prioritization, texture mapping, shading, etc. Sound library  510   e  similarly provides sound generation functionality such as for example playback of .WAV, MIDI or other sound file formats, sound generation based on proprietary sound representation formats, etc. In the exemplary illustrative non-limiting implementation, video library  510   d  and sound library  510   e  may provide functionality specific to the target platform based upon the target platform&#39;s graphics and sound generation capabilities. Necessary functionality provided by the original platform that is not available on the target platform may be emulated, simulated or otherwise handled to provide acceptable video game and/or other application execution. 
     The I/O library  510   f  in the exemplary illustrative non-limiting implementation handles input and output functionality on the target platform. Typically, the user input devices available on the original platform are not identical to those present on the target platform, so I/O library  510   f  provides input control remapping (which may be user customizable in some instances) to take differences into account. The I/O library  510   f  may allow the trans-compiled video game or other application to communicate with a variety of other devices including for example memory cards, wireless adapters, infrared communication, head-to-head “game link” wired communication between devices, etc. 
     Other libraries  510   g  may be included to provide any additional functionality desired on the target platform. 
       FIG. 6  provides an additional, more detailed exemplary view of the exemplary tool&#39;s software components and architecture (in this diagram, “NATSU” may refer to tool  504 ). In the example shown, main or principal components include: 
     a tool chain for generating the transcompiler; 
     the transcompiler  504  itself; 
     abstraction layer libraries; 
     standard C libraries and headers; and 
     GCC built for the target tool environment. 
     In one exemplary illustrative implementation, the components used to generate the tool  504  include a compiler (“GCC”) built for the target tool environment (e.g., x86), the New Jersey Machine Code Toolkit; the Syntax description OCHA file in SLED format; the NJMCT generated parser C code file; and an open-source or other “decompiler” tool for controlled translation of object code into a C representation of that object code. 
     In the exemplary implementation shown, the tool  504  uses the original object ROM file (e.g., as previously prepared for distribution and execution on original native target platforms). The tool  504  generates various files including a decompiled C or other high level source file representing the original object code; a symbol file; and error/log file; and various header files. 
     The exemplary GCC compiler takes as its input the C or other decompiled high level source file generated by tool  504  representing the original object code. It may also use the tool-generated symbol file, the too-generated header files, and other convention input files such as UMAI Peripheral Abstraction Layer libraries, standard C libraries and standard C headers for the target CPU/OS of the target platform. 
     As shown in  FIG. 4 , the different software modules shown in  FIG. 2  may interact with one another in complex ways. For example, the CPU and/or MMU libraries  510   a ,  510   b  may each or both interact with the sound functionality provided by sound library  510   e , the video functionality provided by video library  510   d , and the user input or other (e.g., wired or wireless “game link” networking) functionality provided by I/O library  510   f.    
       FIG. 5  shows an example non-limiting storage medium  600  compatible with the target platform. The storage medium stores trans-compiled game code  610  and linked run-time libraries  612  native to the target platform. 
     Exemplary Compilation and Linking Process 
     In more detail,  FIGS. 8 and 9  show that an exemplary compilation process performed by compiler/linker  508  may use many of the same strategies as modern compilers. Such exemplary techniques include for example lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization, code generation, etc. The compilation/linking process may for example use a symbol table manager and an error handler as shown in  FIG. 8 .  FIG. 9  shows an exemplary compiler statement translation through these various phases of compilation and linking. 
     Exemplary Decompilation Process 
     One exemplary illustrative trans-compiler tool  504  implementation is based on a conventional open-source tool such as “Boomerang” for the controlled translation of object code into a C representation of that object code. Such a tool can work by the iterative abstraction of machine code to an internal abstract register transfer language and then into a C code representation of the original object code. The final C code is intended to be Turning Equivalent to the original C source code that the programmer originally created the original object code from. See for example http://boomerang.sourceforge.net/ (website incorporated herein by reference) for additional information 
     Note that source code output of transcompiler tool  504  is generally not identical to the original source code written by the software developer. For example, any comments the original programmer wrote will not be present in the decompiled output of tool  504 . In addition, a very large number of different variations of a hypothetical source code may all upon compilation produce the same object code. This is why the transcompiler tool  504  output is considered to be a Turning Equivalent (but not necessarily identical to) the original source code. We have found that there are advantages to conducting this process without using the actual original source code. Often, the original source code is no longer available or may not be available to the developers of the transcompiled code. In addition, there may be some advantage to working from decompiled source code as opposed to original source code even if the original source code is available. 
     Tables 1-3 below show exemplary comparisons between original source codes and decompiled source codes using tool  504 . These examples show that the resulting source codes are fairly readable and compile with no fatal errors and run correctly. For example, Table I illustrates features such as conversion of stack locations to local variables; detection, declaration use and initialization of arrays, correct handling of C strings through rough use of the string as a parameter to a library function, and replacement of a pretested “while” loop with a post-tested “do while” loop that are functionally equivalent. 
     
       
         
               
             
               
               
             
           
               
                 TABLE 1 
               
             
             
               
                   
               
               
                 test/pentium/summary: 
               
             
          
           
               
                 Original source code 
                 Decompiled source code 
               
               
                   
               
               
                 #include &lt;stdio.h&gt; 
                   
               
               
                 int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 
                 int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 
               
               
                 9, 10}; 
                 }; 
               
               
                   
                 char* global1 = “Sum is %d\n”; 
               
               
                 int main( ) { 
                 int main(int argc, char** argv, char** 
               
               
                 int sum = 0; 
                 envp) 
               
               
                 int i; 
                 { 
               
               
                   
                 int local1; // m[r28{0} − 8] // sum 
               
               
                   
                 int local2; // m[r28{0} − 12] // i 
               
               
                   
                 local1 = 0; 
               
               
                 for (i=0; i &lt; 10; i++) { 
                 local2 = 0; 
               
               
                 sum += a[i]; 
                 while (local2 &lt;= 9) { 
               
               
                   
                 local1 += a[local2]; // sum += a[i] 
               
               
                   
                 local2++; // i++ 
               
               
                 } 
                 L3: 
               
               
                 printf(“Sum is %d\n”, sum); 
                 } 
               
               
                 return 0; 
                 printf(“Sum is %d\n”, local1); 
               
               
                 } 
                 return 0; 
               
               
                   
                 } 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 test/pentium/fibo-O4: 
               
             
          
           
               
                 Original source code 
                 Decompiled source code 
               
               
                   
               
               
                 #include &lt;stdio.h&gt; 
                 char* global0 = “Input number: ”; 
               
               
                   
                 char global1[0]; 
               
               
                   
                 char* global2 = “fibonacci(%d) = 
               
               
                   
                 %d\n”; 
               
               
                 int main (void) 
                 int main(int argc, char** argv, char** envp) 
               
               
                 { int number, value; 
                 { 
               
               
                   
                 int local10; // r24 // value 
               
               
                   
                 int local7; // m[r28{0} − 8] // Local7 
               
               
                   
                 int local8; // r24{39} 
               
               
                   
                 int local9; // r28 
               
               
                 printf (“Input number: ”); 
                 printf(“Input number: ”); 
               
               
                 scanf (“%d”, &amp;number); 
                 scanf(“%d”, local9 − 8); // Error: should be 
               
               
                 value = fib(number); 
                 &amp;local7 
               
               
                   
                 // The compiler inlined the call to fib 
               
               
                   
                 if (local7 &lt;= 1) { 
               
               
                   
                 local10 = local7; 
               
               
                   
                 } else { 
               
               
                   
                 local8 = fib(local7 − 1); 
               
               
                   
                 local10 = fib(local7 − 2); 
               
               
                   
                 local10 = local10 + local8; 
               
               
                 printf(“fibonacci(%d) = 
                 } 
               
               
                 %d\n”, number, 
                 printf(“fibonacci(%d) = %d\n”, local7, 
               
               
                 value); 
                 local10); 
               
               
                 return (0); 
               
               
                 } 
                 return 0; 
               
               
                   
                 } 
               
               
                 int fib (int x) 
               
               
                 { 
                 int fib(int param1) 
               
               
                 if (x &gt; 1) 
                 { 
               
               
                 return (fib(x − 1) + 
                 int local6; // r24{18} 
               
               
                 fib(x − 2)); 
                 int local7; // r24 // Return value (was eax) 
               
               
                 else return (x); 
                 if (param1 &lt;= 1) { 
               
               
                 } 
                 local7 = param1; // ret = x 
               
               
                   
                 } else { 
               
               
                   
                 local6 = fib(param1 − 1); // temp1 = fib(x−1) 
               
               
                   
                 local7 = fib(param1 − 2); // temp2 = fib(x−2) 
               
               
                   
                 local7 = local7 + local6; // ret = 
               
               
                   
                 temp1+temp2 
               
               
                   
                 } 
               
               
                   
                 return local7: 
               
               
                   
                 } 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 test/pentium/fromssa2 (as of 24/Sep/04): 
               
             
          
           
               
                 Original source code 
                 Decompiled source code 
               
               
                   
               
               
                 void main( ) { 
                 int main(int argc, char** argv, char** envp) 
               
               
                   
                 { 
               
               
                 int a, x; 
                 int local8; // r27 // a 
               
               
                 a = 0; 
                 local8 = 0; 
               
               
                 do { 
                 do { 
               
               
                  a = a+1; 
                 local8++; 
               
               
                  x = a; 
                 %pc = %pc − 209; // x not assigned; error with 
               
               
                  printf(“%d ”, a); 
                 %pc 
               
               
                 } while (a &lt; 10); 
                 printf(“%d ”, local8); 
               
               
                 printf(“a is %d, x is 
                 } while (local8 &lt;= 9); // Minor change 
               
               
                 %d\n”, 
               
               
                 a, x); 
                 printf(“a is %d, x is %d\n”, 10, 10); // Note 
               
               
                 return 0; 
                 10,10 
               
               
                 } 
                 return 0; 
               
               
                   
                 } 
               
               
                   
               
             
          
         
       
     
     Exemplary Tool “Front End” 
     The exemplary illustrative implementation uses a “front end” consisting of a series of modules that transform the source input into a high-level representation. The front end may comprise the following modules illustrated in  FIG. 10 : 
     binary file decoder 
     instruction decoder 
     semantic mapper 
     original RTM to HRTL translator 
     The exemplary illustrative implementation may not require a true lexical analyzer. Due to the highly regular nature of machine code, there may not be a need for a complex lexical analysis. Of course, one could be provided if desired. In the exemplary illustrative implementation, however, the lexical analyzer is replaced with a binary file decoder to read in the original source object code (see  FIG. 10 ). 

 
     Exemplary Trans-Compiler Tool Back End 
     The exemplary illustrative implementation transcompiler tool  504  provides target support for the C programming language. Other implementations could use other target source code support such as for example Javascript, Pascal, Visual Basic, Assembler or any desired source code format. The exemplary illustrative code generation C compiler and linker  508  may be very similar to traditional conventional compiler back ends. In one exemplary illustrative implementation, the HRTL is reduced to C code and the generated C code is provided to a GCC compiler/linker along with headers and libraries such as for example hardware libraries to create a final executable program. Retargeting the original object code to execute on a different target platform may use a Hardware Abstraction Layer. The interface between the Hardware Abstraction Layer and the application may be for example the registers and interrupts used by the original program on the original platform. The back-end of the Hardware Abstraction Layer may back-end interface to the target hardware. In one exemplary implementation the Hardware Abstraction Layer may be âεestubbed outâε to the original hardware so as to allow the original platform to be the new target. This can provide speed and performance optimization (i.e., in some instances the transcompiled version runs more efficiently than the original version). 
     Exemplary Software Interrupts 
     Software Interrupt instructions (SWIs) are used by the ARM and Thumb processors to emulate complex instruction sequences (i.e.: integer division, square root calculation, etc). The processor then changes mode to execute a series of instructions from ROM (Read-Only Memory). The instructions use a separate set of registers, so the original state of the processor remains undisturbed during this time. The instruction includes a 24-bit field in ARM mode and a 8-bit field in Thumb mode to distinguish the individual ROM sequences. 
     The GameBoy Advance (GBA) extended the capacity of the SWI instruction by adding several operations that are specific to the GBA. These operations include a decompression algorithm (LZ77), a Huffman decompression algorithm, several sequencing operations (Interrupt Wait), and graphics processing algorithms (BgAffineSet and ObjAffineSet). In our efforts to create a system that behaves in the same manner, we have translated these algorithms to C and compiled them as a separate library. 
     A Unified Machine Abstraction Interface library including sound, graphics, buttons, non-volatile memory, interrupts etc. may be used to provide the Hardware Abstraction Layer. Each Hardware Abstraction Layer should be customized to the particular target platform being used (i.e., there will be different Hardware Abstraction Layer libraries for different platforms). 
     Where original C source libraries are available, they may be included as standard C files. Otherwise, they will be generated from the original object files. ROM libraries may be translated in the normal manner and then linked as needed. The standard C headers for the target platform may be used by the compiler and linker to tie the application to the target platform. Standard C libraries may be linked as needed. 
     Traditional emulators may also be created using the libraries and techniques described above. Such emulators can be used for example to detect and identify hard to understand data objects such as those loaded at run time into the WRAM space. An Interrupt Replacement Unit may be used to replace C code in the recovered source to improve target hardware performance to avoid spin-locks for example. It is also possible to optimize performance by detecting wait times and recode waits into native calls, thereby avoiding spinlock waiting conditions. For example, one may want to recode virtual blanking wait tests into native function calls that do all the hardware events that happen up until the vertical blanking stage and then start the vertical blanking stage where the program resumes execution. It is also possible to take advantage of source platform detection of only a small subset of available software interrupt function calls to extend the software interrupt call set to include a wide array of hardware related stalls and code them into native calls. A common example would be a program waiting for a given horizontal blanking cycle to occur, which we can recode into different software interrupt calls depending on which registers are available. Since the tool generates a single C source code file in the exemplary illustrative implementation and it is typical for developers to use many C source code files, a higher level of optimization may be possible using the compiler techniques described herein due to the fact that the optimizing compiler will optimize over the entire (larger, common) source code file. Developers could achieve this same result by combining their source files into a single common file before final compilation. As compiler technology advances the recovered source can be recompiled with more advanced compilers. 
     Exemplary SWI Instructions and GBA Emulation 
     In our exemplary illustrative implementation, the GBA system should act in the same manner as the existing GameBoy Advance platform. To do this, we created a library for the existing set of software interrupt (SWI) instructions used in the GBA games. This library was written in C, so that it would be portable to other target platforms. The entry points to this new library in the exemplary illustrative implementation are compiled using SWI values that were not used in the original GBA ROM design. 
     Prior to the year 2000, a flaw was discovered in the ROM implementation of the GameBoy Advance sound routines. These functions were bypassed by adding the MusicPlayer 2000 music library to the GBA Sofware Development Kit (SDK). 
     While improving performance, we discovered that the MusicPlayer 2000 library was used repeatedly, generating several hundred ARM/Thumb instructions for every function call. We then analyzed the code in the MusicPlayer 2000 library, and replaced the entry points to the library functions with SWI instructions, calling target-independent C library functions. We then scanned each of the GBA games that we are deploying with our system, replacing the MusicPlayer 2000 libraries with SWI instructions. 
     We have continued to refine and extend this replacement process, substituting many complex series of instructions with a single SWI instruction, and creating a C library that executes the same operation. We have automated the process of identifying existing library entry points in our GBA games, and insert our SWI instructions prior to the deployment of the game. 
     Software development houses often use the same “engine” or the same set of libraries and algorithms between multiple games. We are exploiting this tendency by replacing these sections of common code with calls to our C libraries. 
     Since the number of sections of code will quickly exceed the number of available SWI instructions, we have modified our implementation. We now use an SWI instruction with the same value for any SWI in a particular game, and the OCHA system figures out which C library function to execute based on the current value of the program counter. This allows us to arbitrarily extend the list of known ARM/Thumb instructions that can be replaced by portable C library calls. 
     While the technology herein has been described in connection with exemplary illustrative non-limiting embodiments, the invention is not to be limited by the disclosure. For example, while Nintendo GAME BOY®, GAME BOY COLOR® and GAME BOY ADVANCE® platforms are used herein as examples, the technology herein could be used advantageously with any sort of computing, game or other platform. The invention is intended to be defined by the claims and to cover all corresponding and equivalent arrangements whether or not specifically disclosed herein.