Abstract: The present invention is directed at a virtual machine environment operating on portable devices with limited resources. The virtual machine environment includes a method for compiling an intermediate language into native code wherein the native code is stored in a directly addressable and executable storage medium, such as flash memory. A portion of the native code is written to a cache resident in volatile memory during compiling. The cache is written to the directly addressable and executable storage medium. The cache may be sized in relation to a block size associated with the directly addressable and executable storage medium. A metadata map is maintained and associates a physical address at which the native code is stored in the storage medium with the method. The native code is persisted by storing the metadata map in the storage medium and associating the metadata map with the method.

Abstract: Techniques for representing core files generated by a computer operating system upon crash of a computer program in a generic format are disclosed. A generic representation of the core file can be generated and analyzed to help in determining errors in code that occurred which the operating system is unable to handle. The generic representation of core files can be represented in a platform-independent format, for example, generic representation of core files may be represented in an extensible data format.

Abstract: Techniques for generation of Java macro instructions suitable for use in Java computing environments are disclosed. As such, the techniques can be implemented in a Java virtual machine to efficiently execute Java instructions. As will be appreciated, a Java macro instruction can be substituted for two or more Java Bytecode instructions. This, in turn, reduces the number of Java instructions that are executed by the interpreter. As a result, the performance of virtual machines, especially those operating with limited resources, is improved. A Java macro instruction can be generated for conventional Java instruction sequences or sequences of Java instruction that are provided in a reduced set of instruction. In any case, sequences that are frequently encountered can be replaced by a Java macro instruction. These sequences are typically encountered when Java objects are instantiated, during programming loops, and when a local variables are assigned a value.

Abstract: One embodiment of the present invention provides a system that facilitates code verification and garbage collection in a platform-independent virtual machine. The system operates by first receiving a code module written in a platform-independent language. Next, the system examines the code module to locate calls to program methods within the code module. The system then transforms the code module so that all operands remaining on the evaluation stack only relate to the called method when the method is called, thereby simplifying verification and garbage collection of the code module.

Abstract: To perform conformance checking of a software implementation with a (possibly non-deterministic) specification, a software implementation and a software specification are applied to produce a CT enabled implementation. Nondeterministic choices of the software specification result in assigning a corresponding choice of the CT enabled implementation to a variable. The CT enabled implementation includes a test that the variable then comprises one of the nondeterministic choices of the software specification. To perform conformance testing where the software specification includes ordered steps, and calls to methods of other classes (mandatory calls), a software object is produced and organized such that each step of the software specification has a corresponding code section in the software object.

Abstract: Interoperability of a first framework or platform (e.g., COM) and a second different framework or platform (e.g., .NET) is provided via an attribute mechanism. The attribute mechanism is provided in a non-COM based platform (e.g., .NET) to expose classes to COM. In this manner, a compiler (e.g., the .NET compiler) creates class and events interfaces and adds attributes to the class and interfaces as appropriate for correct interoperability and marshaling. By adding this attribute mechanism to a class in .NET, the .NET compiler is able to use the class declarations (such as public methods, properties, and events) to automatically generate a class interface and an events interface, including appropriate dispatch IDs and GUIDs. Validation is performed on the class being mapped to provide an indication, such as an error message or warning, to the user that the underlying framework marshaling layer cannot marshal certain data types as desired or expected.

Abstract: In the present invention, global information is passed from a first execution environment to a second execution environment, wherein both the first and second processor units comprise separate memories. The global variable is transferred through the invocation of a memory flow controller by a stub function. The global descriptor has a plurality of field indicia that allow a binder to link separate object files bound to the first and second execution environments.

Abstract: A computer-implemented method for compiling ASL (ACPI Source Language) code into AML (ACPI machine language) code. The method includes accessing an ASL program. A preprocessor is executed to process the ASL program and to insert support for at least one non-native programming construct. The ASL program is then processed using an ASL compiler to compile the ASL program into a resulting AML program.

Abstract: A method for extending a first application class includes integrating a first data buffer within the first application class for holding extended properties, and utilizing a rule based engine to determine the values to associate with one or more of the extended properties of the first application class.

Abstract: An application infa operating system (AIOS) is provided. The AIOS provides an operating platform for integrating, embedding, managing and controlling an application program, wherein a main function thereof is to integrate different application programs which are developed from different information companies and different program designers via different developing languages and tools (e.g., C, C++, database, or Java, etc.) for mutually conversing and swapping data at different space-times through the integration of the present invention, so as to benefit an update, an upgrade and an integration of the application programs, shorten a developing time of integrating a new and a old systems, and save a cost of developing a system for improving a re-use rate of the application programs.

Abstract: A method, computer program product and data processing system for identifying non-externalized strings that are not hard-coded. In one embodiment, a method comprises the step of scanning a code, e.g., Java, line by line until a pair of string delimiters is identified. Once a pair of string delimiters is identified, the method further comprises the step of determining whether the string within the pair of string delimiters identified is a path name to a resource file, e.g., resource bundle. If the string is a path name to the resource file, then the string is a non-externalized string that is not hard-coded. If the string is not a path name to the resource file, then the string may be identified as a possible hard-coded string.

Abstract: A rapid GUI refacing system can include one or more display grids, each display grid mapping sections in a legacy application with selected GUI elements in a refaced GUI. The system also can include one or more smart masters, each smart master specifying an arrangement of content and presentation elements in the refaced GUI. The system yet further can include a GUI transformation template generator configured to generate GUI transformation templates from individual combinations of individual ones of the display grids and individual ones of the smart masters. Finally, the system can include a GUI refacing service configured both to select individual matching ones of the generated GUI transformation templates, and also to transform content in the sections in the legacy application into the refaced GUI using the mapped GUI elements according to transformation instructions contained in the selected individual matching ones of the generated GUI transformation templates.

Abstract: As described herein, an intermediate representation of a source code file may be used to explicitly express exception handling control flow prior to generating object code for the source code. As further described herein, a single uniform set of instructions of the intermediate representation may be used for expressing multiple different exception handling mechanisms related to multiple different programming languages. The intermediate form of the exception handling instructions may be generated by translating an intermediate language representation of the source code file. Representations of the source code in multiple different intermediate languages may be translated to a single uniform set of instructions of the intermediate representation. The intermediate form of the exception handling instructions may then be used by software development tools for such tasks as code generation, code optimization, code analysis etc.

Abstract: To meet the current trend in computer programming, a multi-programming-language compiler system is designed to include a compiler framework which creates a general environment in which to carry out compilation and language modules to encapsulate the details of various programming languages. Such a system makes it easy for tool vendors and end users to adapt to a world where computer programs are written in multiple languages. New language modules may be written that add support for new languages to the compiler framework. It may also be possible to extend existing language modules so that a variant on an existing language may be added to the compiler framework. Such a system may also be adapted to permit several different clients to access detailed language information from the compiler framework. These clients may include a standard command-line shell or a sophisticated multi-language integrated development environment.

Abstract: Techniques for generation of Java macro instructions suitable for use in Java computing environments are disclosed. As such, the techniques can be implemented in a Java virtual machine to efficiently execute Java instructions. As will be appreciated, a Java macro instruction can be substituted for two or more Java Bytecode instructions. This, in turn, reduces the number of Java instructions that are executed by the interpreter. As a result, the performance of virtual machines, especially those operating with limited resources, is improved. A Java macro instruction can be generated for conventional Java instruction sequences or sequences of Java instruction that are provided in a reduced set of instruction. In any case, sequences that are frequently encountered can be replaced by a Java macro instruction. These sequences are typically encountered when Java objects are instantiated, during programming loops, and when a local variables are assigned a value.

Abstract: Techniques for generation of Java macro instructions suitable for use in Java computing environments are disclosed. As such, the techniques can be implemented in a Java virtual machine to efficiently execute Java instructions. As will be appreciated, a Java macro instruction can be substituted for two or more Java Bytecode instructions. This, in turn, reduces the number of Java instructions that are executed by the interpreter. As a result, the performance of virtual machines, especially those operating with limited resources, is improved. A Java macro instruction can be generated for conventional Java instruction sequences or sequences of Java instruction that are provided in a reduced set of instruction. In any case, sequences that are frequently encountered can be replaced by a Java macro instruction. These sequences are typically encountered when Java objects are instantiated, during programming loops, and when a local variables are assigned a value.

Abstract: The caching of heterogeneous bean sets has been improved from requiring each bean to have its own cache instance to caching the beans in a single cache. The beans can be identified by generating a unique identifier that is a combination of the bean's primary key and a self-reference identifier of the bean manager associated with that bean. The average size of a bean set associated with a bean manager can be specified such that the cache allocates memory for that set based on the average size. A callback interface can also be used to shift knowledge of a bean life cycle back to the bean manager. This description is not intended to be a complete description of, or limit the scope of, the invention. Other features, aspects, and objects of the invention can be obtained from a review of the specification, the figures, and the claims.

Abstract: A supervising server (2) is connected to a communication network. The communication network includes a plurality of clients (3) and facsimile servers (1). The supervising server (2) has recipient information such as facsimile numbers of recipients, and the clients (3) can refer to the recipient information under predetermined constraint. All the information about recipients is administered by the supervising server (2). The facsimile servers and clients communicate with each other via the supervising server.

Abstract: The invention concerns a data compaction method and system for an intermediate program. The method consists in searching the program (1000) for identical sequences (Si) and counting Ni number of occurrences of each sequence (Si), a comparison test (1001) to find the superiority of a function f(Ni) to a reference value enables to generate (1003) a specific instruction of a specific code (Ci) with which the sequence (Si) is associated, replacing (1004) each occurrence in the sequence (Si) by the specific code (Ci) in the intermediate program to create a compacted intermediate program (FCC) with which an executing file (FEX) is associated. The invention is applicable to multiple application portable objects such as microprocessor cards, onboard systems of the like.

Abstract: When a program transmission apparatus divides a program into a plurality of partial programs before transmission, a program reception execution apparatus executes a partial program when the partial program has already been received, and, when the execution needs to proceed to from a present partial program to a next partial program, executes the other partial program when the next partial program has been received.

Abstract: On the occasion of returning an error code to an application program to be executed under different execution environments of a computing system, it is requested to fully utilize a system of the existing instruction set to improve the ROM efficiency in the implementation of its common code and to eliminate useless insertion of instruction. For this purpose, in the present invention, a common error code to be returned, from the program to be used to be independent on different OS, to the execution program corresponding to the application program is determined as a value in the range of numerical value to be set with the instruction set of CPU and the defined instruction to load immediate value and thereby the common error code is held within the instruction code of the instruction to load immediate value. Particularly, a value of common error code is determined within the range where the MSB of the setting part of the instruction to load immediate value becomes zero (0).

Abstract: A system and method are disclosed for a host platform interface (HPI), which defines a common set of functions implementing the native methods of Component Peer classes within the Java AWT. This allows the diverse native method implementations currently used in different versions of the AWT to be combined into a single body of source code, greatly improving code maintainability. Since the same source code defines a Component Peer class for each supported platform, changes or bug fixes need only be made in one body of code.

Abstract: A software wrapper for interfacing to pre-existing software code is provided. The software wrapper is capable of inheriting from a first application program interface (API) and a second API. For calls to the first API, the software wrapper delegates to a pre-existing enumeration of objects. The wrapper creates a vector identifying elements of the enumeration. Iterators provided by the wrapper maintain positional cursors for calls to the second API. A comparison is made between each of the positional cursors and the vector. If a positional cursor exceeds the size of the vector, additional elements are extracted from the enumeration, placed in the vector, and returned on the second API. Otherwise, if the positional cursor is smaller than the vector size, the wrapper delegates directly to the vector. The first API can be a java-based enumeration API and the second API can be a java-based collection API.

Abstract: A Java accelerator includes a hardware unit associated with the CPU portion, the hardware unit converting stack-based instructions, such as Java bytecodes, into register-based instructions such as the instructions which are native to the CPU. A thread lifetime unit in the hardware unit is used to maintain a count of the number of bytecodes to be executed while an active thread is loaded into the system. Once this count reaches zero or below, the operation of a/the thread in the system is stopped and the Java Virtual Machine loaded into the CPU portion in order to implement its thread manager. Additionally, a single step unit in the hardware unit allows the production of debugger indications after each stack-based instruction.

Abstract: The invention automatically executes, in a single execution medium, a number of programs written in source languages to which respective execution media are dedicated, without constraining a programmer to a single source language for a respective execution medium type. Each program is compiled into a program expressed in an intermediate language representing a minimum subset of the source languages. In a data processing means such as a smart card, an execution medium is dedicated to the intermediate language. The intermediate language program is loaded with a respective programming library adapting the respective source language to the intermediate language in order to execute the intermediate language program in the execution medium.

Abstract: Each component binary in a heterogeneous program is translated from a platform-specific instruction set into a set of intermediate representation (IR) instructions that are platform-neutral. The IR instructions are grouped into IR code blocks, the IR code blocks into IR procedures, and the IR procedures into IR components to create an intermediate representation hierarchy for the program. An application program interface is provided that permits user access to the IR hierarchy for instrumentation, optimization, navigation, and manipulation of the IR hierarchy. The transformed IR hierarchy is then translated into platform-specific instructions and output as a modified binary. The user can designate a different platform for the output translation of a code block than the platform for which the code block was originally written. Prologue and epilog code is added to contiguous blocks that are translated into different architectures.

Abstract: A proxy component system having dispatch proxies and object proxies is disclosed. The computerized system includes an operating system supporting component interfaces. In addition, the system includes a first interface to a target component, with the first interface having an early bound method. The system further includes a second interface to a proxy component, with the second interface having a late bound method. Also included in the system is a dispatch proxy operative to invoke the early bound method of the first interface from an invocation of the late bound method of the second interface.

Abstract: A system and method are disclosed for a common set of Component Peer classes for the Java abstract windowing toolkit (AWT). The native methods employed by the various platform-specific versions of a Peer class are similar in operation, but contain differences in the source code of the C/C++ functions that implement them. Consequently, they represent distinct bodies of software, which must be supported and maintained separately. The present invention provides a basis for replacing the diverse versions of the Component Peers with a single set, employing a standardized set of native methods. This results in a unique codebase for the Component Peers, across all the supported operating systems, thereby reducing the effort required to maintain and upgrade the software.

Abstract: A method and apparatus for using a single computer program code base to provide a program that is operable in either a client-server mode or a standalone mode are provided. In one embodiment, a client logic element has one or more proxy objects, each of which implement an interface that is neutral with respect to the client-server mode and the standalone mode. A server logic element has one or more service objects. Each of the service objects implements the interface. The interface implementations are not bound to any code that is specific to the client-server version or the standalone version. In the stand-alone version, the client side logic invokes the server side logic directly through the interfaces, as implemented by the service objects. In the client-server version, the client side logic invokes the server side logic through the same set of Java interfaces.

Abstract: The first process provides a context sensitive editor to create, modify and display hierarchically structured control information. The editor provides action choices appropriate to the immediately current context, thereby simplifying the manipulation protocol of the user. Because the editor understands the relationships and multiplicity between the contexts, its editor and display represents the repetition and conditionality of the blocks without resorting to a scripting language. The editor displays the control information according to the display rules of the associated context. The presentation clearly differentiates between the bulk text, the structure in which the text resides, and parameterized elements. The editor effectively manipulates what is meta control information in a way that displays it as information. The second process provides a method to systematically transform the control information into a machine-understandable format, such as code generator script data.

Abstract: A system and method are disclosed for enabling injection of non-native code into a JAVA environment. The method provides a software hook for detecting the loading of a JAVA interpreter, and then creates a connection that communicates with an executing JAVA application. A method is also provided that loads in a customized CLASSLOADER module, wherein the customized CLASSLOADER module identifies a location of non-native code, and then loads in the non-native code identified by the customized CLASSLOADER module.

Abstract: A data processing system and method for managing the storage of compiled instructions used in interpretive programming language applications is implemented. As the applications are implemented in an interpreted programming language, the instructions are compiled into byte-codes to be used by a virtual machine and are subsequently stored in a memory. The data processing system and method recognize that a same application may be used repeatedly and periodically. Thus, the data processing system and method diminish the time required to compile the instructions of an interpretive programming language application, while preserving the compilation of interpretive programming code across sessions accessing the code. Additionally, the data processing system and method diminish the time required to download a Java application and, therefore, allow a user to more efficiently access Internet operations.

Abstract: Digital data is preserved by archiving on a removable medium. In the long term, the save data bit stream must be correctly interpreted. For a computer program or system to be archived, the bit stream constituting the program must be archived and the code must be executable at restore time. The program that restores the data does not “see” the contents of the data itself, but accesses it by issuing a function call to an executor. A description of which methods are available to restore the information hidden in the data is always available. A text tells the client which functions are available and what their purposes are. The archiving method is based on using a virtual computer instruction set and saving the algorithm as a program written int hat virtual machine language. For machine instructions to be executed many years later, for example 100 years, an emulator of the original machine would be written on the future hardware.

Abstract: A method of translating object-oriented computer programs into native code includes a two-step translation process, first by a jcode translator (212) into a machine-independent virtual processor code (213), and then by a native translator (214) into native code (230). In a heterogeneous multiprocessor environment, the machine-independent part of the translation can be carried out at the central server, with machine-independent virtual processor code being distributed as required to the individual clients. Each client then needs to carry just a small processor-dependent native translator (214) with which it completes the conversion into native code. The invention finds particular application in embedded systems, and particularly in heterogeneous-processor systems such as mobile phone networks.

Abstract: A system and computer program product are provided for allowing an application to be integrated with any one of a plurality of distinct types of programmable platforms. First included is a platform-independent application and a platform-independent interface. The platform-independent interface is capable of interfacing the platform-independent application with any one of the distinct types of programmable platform. The programmable platform is further equipped with a platform-dependent interface. This platform-dependent interface serves in conjunction with the platform-independent interface in providing the interface between the platform-independent application and the programmable platform. As such, a versatile framework is provided that allows the reuse of the platform-independent application on numerous different types of programmable platforms.

Abstract: A system and method improves a process of creating software programs for a variety of existing computing platforms. In particular, a developer receives an input file. The developer generates a formatted data file as a function of the input file. If the input file includes data, then the data contained within the formatted data file is stored in a predetermined format compatible with each of a plurality of computing platforms. Then the developer generates a common generation file using a predetermined programming language which is a lowest common denominator language utilized by each of the plurality of computing platforms. The common generation file is capable of creating a predefined output file compatible with each of the plurality of computing platforms. The formatted data file is modified to create a modified formatted data file. Finally, the common generation file is compiled with the modified data file to generate the predefined output file for the corresponding platform.

Abstract: Techniques for representing core files generated by a computer operating system upon crash of a computer program in a generic format are disclosed. A generic representation of the core file can be generated and analyzed to help in determining errors in code that occurred which the operating system is unable to handle. The generic representation of core files can be represented in a platform-independent format, for example, generic representation of core files may be represented in an extensible data format.

Abstract: A computer (100) and a method (200) are provided for automatically generating source code (132) readily operable in a fault-tolerant system or a distributed system, from source code (130) non-operable in either a fault-tolerant system or a distributed system. The computer (100) preferably includes a programmer's computer system including a CPU (104), storage media (108-118), I/O interface 142, input device (144), output device (146). The computer (100) analyzes the source code (130), and automatically generates source code (132), which is then stored in the storage medium (132). The source code (132) contains additional lines of code for marshaling, unmarshaling, and marking modified data objects.

Abstract: An MDES extractor automatically extracts a machine description (MDES) for re-targeting a compiler from a structural representation of a datapath of an explicitly parallel instruction computing (EPIC) processor. The datapath is a machine readable data structure that specifies the functional unit instances and an interconnect of the functional unit instances to registers. The MDES extractor structurally traverses the interconnect, identifying resource conflicts among the operations in the processor's opcode repertoire. Latencies and internal resources of the opcodes associated with the functional unit instances are obtained from a macrocell library. The MDES extractor then identifies external resource conflicts by preparing reservation tables for the functional units.

Abstract: A method and system for providing an intelligent intermediate form of an object-oriented database. The intermediate form is derived from a grammatical form of an object-oriented database through the process of compilation. The grammatical form is a persistent form of an object-oriented database expressed in a human-readable and human-editable textual form according to a grammar. The intermediate form comprises an array of intelligent entry objects which encapsulate data with methods for manipulating that data. The methods include creating a database entry, creating a property associated with an entry, creating an attribute associated with an entry or property, querying the last entry, property, or attribute created, and finalizing entry storage. The intermediate form lacks the infrastructure of the database, but the intermediate form can be used to populate the object-oriented database with entries.

Abstract: A method and system for customizing the transformation of an object-oriented database to and from a grammatical form. A grammatical form is an expression of an object-oriented database in a textual form according to a grammar. The transformation customizer is a plug-in which provides translation of primitive data types to and from complex data types for compilation and serialization processes. A complex data type is defined in terms of one or more primitive data types. One or more values in the object-oriented database are expressed in terms of the complex data type. During serialization, the plug-in module is invoked. The plug-in understands both the complex data type and the primitive data types. The values from the object-oriented database are translated from the complex data type to the primitive data types. For customizing compilation, one or more values expressed in terms of the primitive data types are translated to the complex data type when the plug-in is invoked.

Abstract: An output translator provides for cross module representations of components within a heterogeneous program by translating modifying a platform-neutral intermediate representation (IR) of the program into platform-specific instructions for different architectures. The intermediate representation is hierarchy of base elements that correspond to instructions, code blocks, procedures and components within the program. Blocks of instructions that were originally written for one architecture can be translated from the intermediate representation into platform-specific instructions for a different architecture. The output translator provides any necessary code to interface contiguous code blocks that are emitted in different instruction sets.

Abstract: A method and system for serializing a transient object-oriented database into a persistent form. The persistent form is a grammatical form, an expression of an object-oriented database in a textual form according to a grammar. The grammatical form is human-readable and human-editable. The grammar is designed to be platform-independent and programming-language-independent and therefore descriptive of any hierarchical object-oriented database. An object-oriented database is expressed as a plurality of entries in a transient, hierarchical, object-oriented form. The tree of entries is navigated and each entry is written to the persistent form as text according to the grammar. The serialized form stores only the key state of the database, not a “snapshot” of memory. Therefore, the persistent, serialized form is smaller than the in-memory, transient form of the object-oriented database.

Abstract: A system, method and article of manufacture are provided for program data transfer reporting. A source program is compiled to a platform-independent bytecode. The program is executed. Note that the program passes data implicitly using pointers. Accesses to memory are traced for generating a trace. The trace is analyzed. Memory use profile data is generated based on the trace.

Abstract: A method and system for compiling a grammatical form of an object-oriented database into an intermediate form of that database. The grammatical form is a persistent form of an object-oriented database expressed in a human-readable and human-editable textual form according to a grammar. The textual form is parsed into a series of tokens. The tokens are compiled into a plurality of entries. The plurality of entries are expressed in an intermediate form. The intermediate form comprises an array of intelligent entry objects which encapsulate data with methods for manipulating that data. The methods include creating a database entry, creating a property associated with an entry, creating an attribute associated with an entry or property, querying the last entry, property, or attribute created, and finalizing entry storage. The intermediate form lacks the infrastructure of the database, but the intermediate form can be used to populate the object-oriented database with entries.

Abstract: A system for creating a custom environment for executing application programs in a target device. The system broadens the applicability of software environments like Java by providing custom pre-loaded classes for application programs and by customizing the procedures for class loading to the available resources in the target device. The system includes tools for generating a pre-load class list that specifies a set of classes needed to support the application program. The tools build the custom environment including a set of code for a virtual machine and a set of code for each of a set of pre-loaded classes specified in the pre-load class list. The virtual machine loads classes from the pre-loaded classes, a file system class library, and/or a networked class library using widely available network protocols.

Abstract: A process for transforming an original source code containing a description of a stub method employed in an object interaction into another source code corresponding to an environment on which a program is executed. The original source code is described with a predetermined programming language and contains information concerning the stub method to be used in the object interaction. The information is described in a format which is common to a plurality of different program execution environments. The transformation is conducted with reference to a registered information corresponding to the program execution environment on which stub method is to be executed into another source code described with the same programming language as the original source code in a predetermined format corresponding to the program execution environment on which the stub method is to be executed.

Abstract: A grammar to represent a hierarchical object-oriented database. The grammar comprises a set of keywords and a syntax. The keywords include “tree”, “entry”, “properties”, and “attributes”. Properties and attributes are defined by name-value pairs. The grammar is designed to be platform-independent and programming-language-independent and therefore descriptive of any hierarchical object-oriented database. A grammatical form, a description of an object-oriented database in a textual form according to the grammar, may be stored in a persistent form such as one or more files on disk. The grammatical form is human-readable and human-editable. The grammatical form can be created by hand, or it can be created from an object-oriented database in transient form through the process of serialization. The grammatical form can be transformed into an object-oriented database through the process of compilation.

Abstract: Systems and methods for building a platform specific compiler in a multi-platform environment are provided. A set of user defined platform dependent compiler architecture descriptors that describe corresponding architectural features of a particular hardware platform dependent compiler are provided. The descriptors are converted into the platform dependent compiler source code which is compiled into platform dependent compiler object code. The platform specific compiler is formed from the platform dependent compiler object code and platform independent compiler object code already provide. During compiler run time an interface mediates the flow of information between the platform dependent compiler object code and the platform independent compiler object code.

Abstract: A method and several variants are provided for analyzing and transforming a computer program such that instructions may be reordered even across instructions that may throw an exception, while strictly preserving the precise exception semantics of the original program. The method uses program analysis to identify the subset of program state that needs to be preserved if an exception is thrown. Furthermore, the method performs a program transformation that allows dependence constraints among potentially excepting instructions to be completely ignored while applying program optimizations. This transformation does not require any special hardware support, and requires a compensation code to be executed only if an exception is thrown, i.e., no additional instructions need to be executed if an exception is not thrown. Variants of the method show how one or several of the features of the method may be performed.