Abstract: Methods for embedding codes executable in a first system having a first microprocessor into codes executable in a second system having a second microprocessor are described herein. In one aspect of the invention, an exemplary method includes providing first codes having a routine, the first codes being compilable to be executed in the first system, and compiling the first codes, resulting in second codes; the second codes comprising opcodes of the routine executable by the first system, which convert the second codes into third codes automatically, the third codes being compilable to be executed by the second system; this is followed by compiling the third codes, resulting in the fourth codes being executable in the second system, and linking the fourth codes, generating an executable image and executing the executable image in the second system. Other methods and apparatuses are also described.

Abstract: The claimed subject matter provides a system and/or method that facilitates creating executable code for an industrial environment. A language editor can enable a programming of a portion of data within a programming language. A compiler can compile the portion of data within the programming language. An assembler component can utilize an intermediate language to convert the portion of data into a portion of assembly object code, wherein the assembly object code is target independent. A linker can create a binary file from the portion of assembly object code, wherein the binary file is target independent. A loader can specifically tailor the binary file to a target resource by leveraging at least one PLC definition, wherein the loader creates a target executable code (TEC) program at runtime or at development time.

Abstract: A representation of types, type-checker, method and compiler are provided for checking consistency in various forms of an intermediate language. Specifically, the typed intermediate language is suitable for use in representing programs written in multiple (heterogeneous) source languages including typed and untyped languages, loosely and strongly typed languages, and languages with and without garbage collection. An unknown type representation indicates that an element of the intermediate language is associated with an unknown type. A method of type-checking a code segment written in a programming language is provided using a rule set that contains rules for type-checking an unknown type. The unknown type allows for selectively retaining type information as the compilation process continues and allows multiple programming languages to be type-checked by the same type system.

Abstract: One embodiment of the present invention provides a system that facilitates locked prefetch scheduling in general cyclic regions of a computer program. The system operates by first receiving a source code for the computer program and compiling the source code into intermediate code. The system then performs a trace detection on the intermediate code. Next, the system inserts prefetch instructions and corresponding locks into the intermediate code. Finally, the system generates executable code from the intermediate code, wherein a lock for a given prefetch instruction prevents subsequent prefetches from being issued until the data value returns for the given prefetch instruction.

Abstract: Dynamic binary translators enable binaries of a source platform to execute on a target platform without recompilation. This is achieved by runtime (on-the-fly) translation of source machine instructions into equivalent target machine instructions. Typically dynamic binary translators are used for migrating from an older platform to a newer one, implementing complex instruction set architectures, speeding up simulators and in profiling tools. In all these applications, the speed of translation is critical to ensure that the overheads incurred by the translator do not outweigh the advantages of dynamic translation. One such overhead is created by the analysis required when code is translated for execution in a parallel processing environment.

Abstract: A method for analyzing a program is provided. The method includes, determining an object type that may exist at an execution point of the program, wherein this enables determination of possible virtual functions that may be called; creating a call graph at a main entry point of the program; and recording an outgoing function call within a main function. The method also includes analyzing possible object types that may occur at any given instruction from any call path for virtual calls, wherein possible object types are determined by tracking object types as they pass through plural constructs; and calling into functions generically for handling specialized native runtime type information.

Abstract: The invention provides a method and system for creating a single, common installation file for multiple target device types. In one approach, the method comprises providing a base engine, compiling the engine into an intermediate language code, and just-in-time compiling the intermediate code into executable code. The latter code is executed to gather the appropriate data sets and concatenate the data sets with the engine to form the installation file. The present invention also provides a method and system for utilizing the installation file to retrieve the appropriate data set(s) for the identified target device type, and to install the retrieved data set(s) onto the target device.

Abstract: Generating parallelized executable code from input code includes statically analyzing the input code to determine aspects of data flow and control flow of the input code; dynamically analyzing the input code to determine additional aspects of data flow and control flow of the input code; generating an intermediate representation of the input code based at least in part on the aspects of data flow and control flow of the input code identified by the static analysis and the additional aspects of data and control flow of the input code identified by the dynamic analysis; and processing the intermediate representation to determine portions of the intermediate representation that are eligible for parallel execution; and generating parallelized executable code from the processed intermediate representation

Abstract: A system and method are provided for inlining across protection domain boundaries with a system virtual machine. A protection domain comprises a unique combination of a privilege level and a memory address space. The system virtual machine interprets or dynamically compiles not only application code executing under guest operating systems, but also the guest operating systems. For a program call that crosses a protection domain boundary, the virtual machine assembles an intermediate representation (IR) graph that spans the boundary. Region nodes corresponding to code on both sides of the call are enhanced with information identifying the applicable protection domains. The IR is optimized and used to generate instructions in a native ISA (Instruction Set Architecture) of the virtual machine. Individual instructions reveal the protection domain in which they are to operate, and instructions corresponding to different domains may be interleaved.

Abstract: A method of offloading compilation includes transmitting compilation information from a first subsystem to a second subsystem. The method also includes compiling computer program code into machine-executable code on the second subsystem based on the compilation information received from the first subsystem. The method further includes receiving the machine-executable code from the second subsystem into the first subsystem.

Abstract: A system to enables Rapid Application Development (“RAD”) is provided. The system provides an object model of an ERP application, which enables software developers to customize the ERP applications. The object model provides a base class that is inherited by each object class. The base class provides an invoke function that is implemented by each object class. During compilation, the RAD system compiles each invocation of a function of an object into a call to a dynamic component passing an identifier of the object, an identifier of the function to be invoked, and the parameters to be passed to the function. The RAD system dynamically compiles, assembles, and instantiates object classes as needed. Because objects are bound at runtime, rather than at compile time, when the source code of an object is modified, the entire ERP application does not need to be recompiled into monolithic IL code and the compilation of object classes is deferred until an object of that class is needed during runtime.

Abstract: Embodiments of the invention enable application programs running across multiple compute nodes of a highly-parallel system to compile source code into native instructions, and subsequently share the optimizations used to compile the source code with other nodes. For example, determining what optimizations to use may consume significant processing power and memory on a node. In cases where multiple nodes exhibit similar characteristics, it is possible that these nodes may use the same set of optimizations when compiling similar pieces of code. Therefore, when one node compiles source code into native instructions, it may share the optimizations used with other similar nodes, thereby removing the burden for the other nodes to figure out which optimizations to use. Thus, while one node may suffer a performance hit for determining the necessary optimizations, other nodes may be saved from this burden by simply using the optimizations provided to them.

Abstract: To provide for multi-language compilation, a protocol is established for compilers. Each of at least two compilers implements the protocol. A framework is developed which discovers compilers which have implemented the protocol. The framework allows multi-language compilation using and coordinating the compliant compilers. The framework is extensible. When a new protocol-compliant compiler is discovered, the language compiled by the new compiler can be compiled using the framework and the capabilities of the protocol-compliant compilers. Similarly, a multi-language extensible design tool may be created using protocol-compliant design tools.

Abstract: A typed intermediate representation of source code written in a language that supports multiple inheritance is presented. The typed intermediate representation uses paths to represent objects embedded in other objects. For each class, an exact record type represents layout of complete objects of that class. An approximated record type describes layout of inner objects when the runtime types of the objects are statically unknown. Address arithmetic is represented by special instructions and type-checked to ensure proper pointer adjustment. Types are also given to “this” pointers of methods within classes. These “this” pointer types refer to the paths associated with the object.

Abstract: A typed intermediate representation of source code written in a language that supports multiple inheritance is presented. The typed intermediate representation uses paths to represent objects embedded in other objects. For each class, an exact record type represents layout of complete objects of that class. An approximated record type describes layout of inner objects when the runtime types of the objects are statically unknown. Address arithmetic is represented by special instructions and type-checked to ensure proper pointer adjustment. Types are also given to “this” pointers of methods within classes. These “this” pointer types refer to the paths associated with the object.

Abstract: An approach to hiding memory latency in a multi-thread environment is presented. Branch Indirect and Set Link (BISL) and/or Branch Indirect and Set Link if External Data (BISLED) instructions are placed in thread code during compilation at instances that correspond to a prolonged instruction. A prolonged instruction is an instruction that instigates latency in a computer system, such as a DMA instruction. When a first thread encounters a BISL or a BISLED instruction, the first thread passes control to a second thread while the first thread's prolonged instruction executes. In turn, the computer system masks the latency of the first thread's prolonged instruction. The system can be optimized based on the memory latency by creating more threads and further dividing a register pool amongst the threads to further hide memory latency in operations that are highly memory bound.

Abstract: Intermediate code is executable on a virtual machine. Hence, source code that is compiled on a first computing device can be distributed to a second computing device in an intermediate form as long as the second computing device has the appropriate virtual machine. In this way, the compilation can be done without regard to the underlying native processor on the second computing device. However, the intermediate code loses the original type information defined in the source code. By determining the variable types in the intermediate code, the intermediate code can be converted to a different intermediate language.

Abstract: A compiling method for compiling software which is adapted to output an intermediate result at a given timing, the compiling method includes extracting, by a computer, a process block related to parallel processing and conditional branch from a processing sequence included in a source code of a software which is processed time-sequentially, and generating, by the computer, an execution code by restructuring the process block that is extracted.

Abstract: A configuration management system for use with a P2P CE network includes a configuration management language (CML) describing devices and functions of a NetCE Environment. A P2P configuration monitor uses a P2P presence service to monitor current presence of devices in the CE Network. A configuration management mechanism takes as input a model of a target function or functions and, using the CML, finds a mapping between the function or functions and present devices in the CE Network, as reported by the configuration monitor.

Abstract: Managed code, including applications, runtime, and driver, have a priori knowledge of the client's exact hardware configuration, just as the JIT compiler has a priori knowledge of the microprocessor type on the target computer system. At compile time, the compiler knows the effective version various system drivers, so that the compiler can emit an executable tuned for a particular driver version and target system.

Abstract: A method for protecting a computer program against manipulation and for shielding its communication with other programs against eavesdropping and modification is presented. The method comprises the creation of individualized program copies to different groups of users, the insertion of or the derivation of individual cryptographic keys from the program code, the obfuscation of the program code, and the self-authentication of the program towards other programs. The method is suitable for the protection of online banking, online investment, online entertainment, digital rights management, and other electronic commerce applications.

Abstract: Methods and apparatus to implement annotation based thunking are disclosed. An example method comprises locating a parameter of a function, the parameter to be passed as a pointer if a size of the parameter is greater than a threshold and to be passed as data if the size of the parameter is not greater than the threshold, and adding an annotation record for the parameter to a byte code image file containing byte code for the function.

Abstract: A method of translating binary code instructions from a source format to a target format for processing by a target processor includes converting a source instruction into a source intermediate data structure having a plurality of members, mapping the members in the source intermediate data structure to corresponding members in a target intermediate data structure according to a template, and converting the target intermediate data structure into a target instruction.

Abstract: A system and method for converting on a computer environment a first code into a second code to improve performance or lower energy consumption on a targeted programmable platform is disclosed. The codes represent an application. In one aspect, the method includes loading on the computer environment the first code and for at least part of the variables within the code the bit width required to have the precision and overflow behavior as demanded by the application. The method further includes converting the first code into the second code by grouping operations of the same type on the variables for joint execution on a functional unit of the targeted programmable platform, the grouping operations using the required bit width, wherein the functional unit supports one or more bit widths, the grouping operation being selected to use at least partially one of the supported bit widths.

Abstract: A method for off loading resource intensive compilations is disclosed. The method may include enabling a user of a wireless handheld device to request a platform independent application. The wireless handheld device may be enabled to assess a resource on the wireless handheld device and to determine whether to request native code for the platform independent application. The method may also include enabling the requested platform independent application to be routed to a trusted server. The trusted server may compile the platform independent application into native code for the wireless handheld device and may transport the native code to the wireless handheld device for execution.

Abstract: A method of compiling code includes assigning an endian type to data. An endian flip operation is performed based on the endian type of the data and a target system. Other embodiments are described and claimed.

Abstract: A system and method is provided for efficiently pinning references to the managed heap. The system and method allow for references to managed objects to be declared as pinned during a call to unmanaged code. The references are then reported as pinned to a garbage collector in response to invocation of a garbage collection service. The reference can be declared as pinned by a programmer within the source code or automatically invoked at run-time based on an unsafe condition. The garbage collection service will not move or relocate objects that are referenced by the active pinned local variables. If a garbage collection does not occur, the fact that the local variables are declared pinned is ignored.

Abstract: A method for analyzing a target system that includes obtaining a plurality of characteristics from the target system using a characteristics extractor and at least one selected from the group consisting of a software build project associated with the target system and a modified software build project associated with the target system, wherein the plurality of characteristics is associated with a characteristics model, storing each of the plurality of characteristics in a characteristics store, and analyzing the target system by issuing at least one query to the characteristics store to obtain an analysis result.

Abstract: A method and apparatus for superword register value numbering includes hashing an operation code and the value numbers of a plurality of sources to generate a flint hash value. The method and apparatus further includes retrieving an operation value number from the first hash table based on the first hash value. The method and apparatus further includes generating a result value number based on a previous bit hash value and the operation value number. The result value number is a combination of the operation value numbers for each component having a live indicator (e.g., a false write mask value) and a previous value numbers for the components without the live indicator (e.g., a true write mask value). Thereupon, the method and apparatus includes searching a second hash table using the result value number. As such, the method and apparatus provides using two separate hash tables for value numbering with superword instructions.

Abstract: Aspects of the subject matter described herein relate to creating and using deltas to modify existing computer code. In aspects, computer code may be translated into a higher level language to make it easier for a software developer to modify the computer code. The translated computer code may be presented by an editing tool that presents a user interface that allows changes to be made to the translated computer code. A delta engine may then determine a delta that indicates the changes to perform on the existing computer code to create computer code that would result from compiling the translated computer code as changed via the editing tool. Later, this delta may be used to change the existing computer code after it has been loaded to add or change debugging hooks or other features of the computer code.

Abstract: Inter-procedural strength reduction is provided by a mechanism of the present invention to improve data cache performance. During a forward pass, the present invention collects information of global variables and analyzes the usage pattern of global objects to select candidate computations for optimization. During a backward pass, the present invention remaps global objects into smaller size new global objects and generates more cache efficient code by replacing candidate computations with indirect or indexed reference of smaller global objects and inserting store operations to the new global objects for each computation that references the candidate global objects.

Abstract: The present invention uses annotations and SQL to retrieve and/or persist POJO data from/to a database, respectively. Using SQL will enable developers to unleash the full querying power of their chosen Database Management Systems (DBMS) and will remove the requirement that they learn a new query language. A minimal amount of annotations will be associated in the same Java® source file where each class of POJO to be persisted to the database is defined. An enhanced compiler is capable of analyzing the annotated source file and automatically generate the bytecode required to create, deploy, and manage the persistence of POJOs without requiring knowledge of specific details of the persistence to corresponding data entities in the underlining database. Therefore, such an approach decreases the time, knowledge, skill and ultimately cost required to persist POJOs to an underlying database. This description is not intended to be a complete description of, or limit the scope of, the invention.

Abstract: Embodiments of the invention provide a method for reducing stack space consumption via a head-call optimization. When compiling the source code of a computer application, a compiler application may be configured to analyze program flow to identify a “head-call” within any functions included in the program source code. Once identified, the “head-call” may be removed during program compilation. Doing so may reduce the number of elements pushed onto a program's stack space during program execution.

Abstract: A method and system of adaptive dynamic compiler resolution. At least some of the illustrative embodiments are a computer-implemented method comprising compiling a source file containing an application program (the application program comprising a method, and wherein the compiling creates a destination file containing a compiled version of the application program), and inserting in the compiled version of the application program a series of commands that (when executed at run time of the application program) generate a first optimized version of the method using a first value available at run time, and generate a second optimized version of the method using a second value available at run time.

Abstract: A method includes receiving a portion of JAVA™ language software having a declaration of an instance of a generic class, parsing the declaration into a token corresponding to the generic class, and generating an intermediate language code block corresponding to the parsed declaration. The intermediate language code block is executable by a runtime engine. A system for compiling includes a parser receiving JAVA™ language source code having an instruction referencing a generic class and specifying a type of the generic class, and a code generator generating intermediate language code representing the source code.

Abstract: A compiler that forms an intermediate representation of a program using a flow graph with less than all possible edges used to model asynchronous transfers within the program. The flow graph is formed in multiple phases. In one phase, the flow graph is formed without modeling asynchronous transfers. In later phases, representations of the effects of the asynchronous transfers are selectively added. As part of the later phases, edges modeling a possible asynchronous transfer are added to the flow graph following definitions in protected regions of variables that are live outside the protected region. A modified definition of live-ness of a variable is used to incorporate use of the variable in any region, including the protected region, following an asynchronous transfer. Edges from the protected region are also added to the model if the only use of the defined variable is in a handler.

Abstract: A platform independent binary object (PIBO) operable on disparate computing environments that have a selected hardware architecture without requiring rebuilding or reloading is provided. The PIBO can be parsed to generate source-code stub file. The PIBO can be loaded and linked with a cooperating computing application by an exemplary linker/loader employing the stub file. Also, the PIBO can be used in various contexts, including but not limited to, as a mechanism for dynamically linking shared objects on platforms that do not offer such native facility; in utilizing pre-written code components on platforms that otherwise would be incompatible due to a violation of platform constraints within particular code; as a mechanism for loading non object-oriented code that circumvents restrictions of multiple execution instances and repeat execution inherent in the code; and as mechanism that allows for the use of a binary object to add on functionality on a closed platform.

Abstract: A machine code computer program may comprise machine code directed to a main task and may contain no operations (NOPs). Some or all of the NOPs may be replaced with auxiliary code. Alternatively, the machine code computer program may be generated with auxiliary code where the NOPs would otherwise be. In some implementations, additional auxiliary code may also be provided in the machine code computer program. The auxiliary code and additional auxiliary code may comprise instructions that provide additional information about the machine code computer program in which they reside and its execution, but otherwise may act as NOPs with regard to the functionality of the machine code computer program.

Abstract: Described herein are typed intermediate representations of object-oriented source code that preserve notions of class names, as well as add structure-based information related to classes in the source code. Types in the intermediate representation are divided into corresponding class name-based types and associated structure-based record types. The structure-based record type comprises a layout of objects that are instances of the corresponding class name-based types, where the object comprises one or more data fields and one or more virtual method members. Dynamic types can be abstracted in the form of existential types with sub-classing bounded quantifications. This makes type checking decidable. Existential types bind type variables with sub-classing bounds to represent dynamic types of objects. The layout of those objects can be approximated by structure-based record types.

Abstract: Methods and apparatus, including computer systems and program products, that relate to diversification of computer code. The methods feature a machine-implemented method that includes receiving input computer code, and automatically generating multiple versions of diversified computer code, where each version of the diversified computer code is distinct from but functionally equivalent to the input computer code. The input computer code can include source code or binary code and automatically generating multiple versions of diversified computer code can include automatically generating multiple versions of diversified source and/or binary code. Automatically generating diversified computer code can include applying multiple diversification operations.

Abstract: A system and method for stable transitions in the presence of conditionals for an advanced dual-representation polyhedral loop transformation framework are provided. The mechanisms of the illustrative embodiments address the weaknesses of the known polyhedral loop transformation based approaches by providing mechanisms for performing code generation transformations on individual statement instances in an intermediate representation generated by the polyhedral loop transformation optimization of the source code. These code generation transformations have the important property that they do not change program order of the statements in the intermediate representation. This property allows the result of the code generation transformations to be provided back to the polyhedral loop transformation mechanisms in a program statement view, via a new re-entrance path of the illustrative embodiments, for additional optimization.

Abstract: The present comparison technique operates on objects having the same type, similar types, or different types. Multiple comparison objects may be compared against one or more reference objects. The comparison objects may be obtained from a prior cmdlet in a pipeline of cmdlets operating in an object-based environment. The reference object and comparison object may be compared in an order-based manner or in a key-based manner. In addition, specific properties may be specified which will identify which properties of the reference object and the comparison object to compare during the comparison. The comparison may generate an output that identifies the difference and/or similarities. The output may be pipelined to another cmdlet for further processing.

Abstract: Disclosed are a method, a software product and a system for machine-executable information processing, representing information in a hierarchical data structure consisting of at least two hierarchy levels, where the structural configuration can be modeled by input means and the contents of an element can either: a) be manipulated by input means; or b) be determined by machine-evaluating an expression, which can be manipulated by input means, said expression being able to contain a reference to at least one other element. Preferred embodiments involve separate modeling in an object hierarchy and a class hierarchy, manipulatable parameters for activating different representation modes and operation modes, and involve distributed parallel processing in conjunction with user-controlled and/or machine-controlled interaction. The method serves to create and execute complex information systems without resorting to programming, such systems being used, in particular, for administrative tasks (e.g.

Abstract: A method for concern-based processing of a directed acyclic graph (DAG) using aspect-oriented programming includes instantiating a plurality of aspects, each aspect associated with one concern for processing one or more DAGs, each DAG comprising a plurality of nodes. One of the DAGs is selected for processing and processed based on at least a portion of the instantiated aspects.

Abstract: The present invention discloses a software development tool that includes a model development interface, an aspect design tool, and a model transformation engine. The model development interface can permit a developer to graphically design at least one software model. The aspect design tool for the model development interface can be configured to permit a user to specify at least one aspect to be applied to a model of the model development interface. The model transformation engine can transform a model of the model development interface having at least one aspect defined via the aspect design tool into automatically generated aspect code integrated with base language code.

Abstract: An improved architecture for a program code conversion apparatus and method for generating intermediate representations for program code conversion. The program code conversion apparatus determines which types of IR nodes to generate in an intermediate representation (IR) of subject code (10) to be translated. Depending upon the particular subject and target computing environments involved in the conversion, the program code conversion apparatus utilizes either base nodes, complex nodes, polymorphic nodes, and architecture specific nodes, or some combination thereof, in generating the intermediate representation.

Abstract: Metrics may be determined from intermediate computer code by reading and analyzing an entire application using intermediate code, including any linked portions. The metrics may include cyclomatic complexity, estimated or actual number of lines of code, depth of inheritance, type coupling, and other metrics. The metrics may be combined into a quantifiable metric for the code.

Abstract: The compilation method, which allows a programmer to perform programming without minding about pass-by-reference, and offers efficiency in generating codes even in the case of using “pass by value”, includes the following: generating intermediate codes from a source program; optimizing the intermediate codes by converting a procedure that calls a procedure with pass-by-value argument into a procedure that calls a procedure with pass-by-reference argument, in the case where there is no procedure that may indirectly call the procedure with pass-by-value argument, and the pass-by-value is not updated within the definition according to the procedure with pass-by-value argument; and converting the optimized intermediate codes into object codes.

Abstract: A mechanism for securely decompiling representations of objects into copies of the objects is described. A virtual machine may include extensions for decompiling data representation language representations of objects into objects. The decompiler API may accept a data stream, which includes a representation of the object, and output a copy of the object. In one embodiment, during the decompilation of the representation of objects on a client, each message may be checked to verify that the user has access rights to the object. Access right information for the object may be embedded in the message(s) containing the representation of the object. In one embodiment, when the user is done using the client, the user may log off or otherwise signal the user is finished with the client. The client may detect that the user is finished, and may then proceed to delete objects created by decompilation of representations.

Abstract: A method and an apparatus that optimally compile a source code for a data transformation operation in response to a request from a run-time application are described. A current state of the run-time application is included in the request. The application executes a non-optimized library routine for the data transformation operation while a separate worker thread performs optimized code compilation on the source code for the data transformation operation based on the request at the same time. The request includes a current state of the run-time application. The non-optimized library routine has been pre-built during build time.