Abstract: One or more processors receive (a) first software written in a first computer language, (b) user input identifying a first name of a first method in a plurality of methods defined in the first software, and (c) user input identifying a location within a second software that is written in a second computer language different from the first computer language. In response, the one or more processors automatically prepare and store at the user-identified location in the second software, a new instruction formatted in a syntax of the second computer language that invokes the first method identified in the first software by the first name. The second software may be initially created with a first instruction to include at least a first additional name (e.g. “main”) used to invoke execution of the second software, and as a parameter thereof a second additional name identifying the first software.

Abstract: The present disclosure involves systems, software, and computer implemented methods for providing a scripting language for business applications. One process includes operations for providing a scripting language editor for generating software components for a business application, the scripting language editor configured to receive scripting language input. A scripting language file saved by the scripting language editor is identified. Metadata associated with at least one of a business object or a data type of a platform of the business application is retrieved. A business application language file is generated based on the scripting language file and the retrieved metadata.

Abstract: A tracing just-in-time (TJIT) compiler system is described for performing parallelization of code in a runtime phase in the execution of code. Upon detecting a hot loop during the execution of the code, the compiler system extracts trace information from sequentially recorded traces. In a first phase, the compiler system uses the trace information to identify at least one group of operation components that can be operated on in a parallel manner. In a second phase, the compiler system provides instructions which allocate the group of operation components to plural processing resources. A native code generator module carries out those instructions by recompiling native code that directs the operation of a native system to perform parallel processing. The compiler system terminates a group if it encounters program data in a loop iteration that is not consistent with previously encountered predicated information (upon which it records a new trace in a sequential manner).

Abstract: Embodiments of the present invention provide a method, system and computer program product for USING range validation during assembly of an assembly language program. In an embodiment of the invention, a method for USING range validation during assembly of an assembly language program has been provided. The method can include parsing assembler language source code loaded for assembly in an assembler executing in memory of a computer. The method also can include identifying a USING statement in the source code establishing a base address as the content of a register. Finally, in response to additionally identifying a subsequent statement in the source code that modifies the content of the register, a warning of an invalid USING range can be generated.

Abstract: One embodiment of the present invention sets forth a technique for partitioning a predecessor thread program into sub-programs and dynamically spawning a thread grid of the sub-programs based on the outcome of a conditional statement in the predecessor thread program. The programming instructions for the predecessor thread program are analyzed to assess the benefit of partitioning the thread program at a conditional statement into sub-programs. If the predecessor thread program is partitioned, then each branch of the conditional statement may be used to form a separate sub-program. Predicate tables are populated at the predecessor thread program run-time to establish which possible instances of the thread sub-programs should be spawned in subsequent execution phases.

Abstract: Techniques are described for unifying static and dynamic compiler optimizations in source code bases. In an embodiment, a first compiler compiles source code of a target function to generate ahead-of-time (AOT) compiled machine code. A second compiler compiles the source code to generate an intermediate representation (IR) of the target function. In response to determining that the target function should be just-in-time (JIT) compiled, the AOT-compiled machine code for the target function is linked to the IR of the target function. During runtime, a physical processor executes AOT-compiled machine code of an executable program. When the target function is encountered for the first time, a JIT compiler is invoked. The JIT compiler generates JIT-compiled machine code for the target function. The physical processor executes the JIT-compiled machine code in place of the AOT-compiled machine code for the target function.

Abstract: Hardware compilation and/or translation with fault detection and roll back functionality are disclosed. Compilation and/or translation logic receives programs encoded in one language, and encodes the programs into a second language including instructions to support processor features not encoded into the original language encoding of the programs. In one embodiment, an execution unit executes instructions of the second language including an operation-check instruction to perform a first operation and record the first operation result for a comparison, and an operation-test instruction to perform a second operation and a fault detection operation by comparing the second operation result to the recorded first operation result.

Abstract: Concepts and technologies are described herein for extending the behavior of a software development tool. An extension can be accessed and consumed by a software development tool to configure the software development tool to perform an operation in an extended mode. In one example, an extension can extend a compiler based on the input source code. In one configuration, the compiler extension can provide a compiler with one or more runtime semantics of various source code elements for a particular programming language. The compiler can access an extensions list to determine if the compiler is to perform a compilation operation on a particular source code element or logical unit in an extended mode.

Abstract: A static branch prediction method and code execution method for a pipeline processor, and a code compiling method for static branch prediction, are provided herein. The static branch prediction method includes predicting a conditional branch code as taken or not-taken, adding the prediction information, converting the conditional branch code into a jump target address setting (JTS) code including target address information, branch time information, and a test code, and scheduling codes in a block. The code may be scheduled into a last slot of the block, and the JTS code may be scheduled into an empty slot after all the other codes in the block are scheduled. When the conditional branch code is predicted as taken in the prediction operation, a target address indicated by the target address information may be fetched at a cycle time indicated by the branch time information.

Abstract: A system includes determination of first coordinates in a repository coordinate system associated with a seed component corresponding to a target build result of a first code building system, the seed component comprising a projection method between the repository coordinate system and a variant coordinate system of the first code building system, determination of second coordinates in the variant coordinate system, the second coordinates associated with an execution environment of the target build result, determination of third coordinates in the repository coordinate system based on the first coordinates, the second coordinates and the projection method, and association of the target build result with the third coordinates.

Abstract: An image detection program creating system comprise a parameter setting module, an image loading module, a programming module, and a program conversion module. The parameter setting module sets parameters of a Dimensional Measuring Interface Specification (DMIS). The image loading module loads a 3D image. The programming module programs the DMIS program according to the parameters of the DMIS and the 3D image. The program conversion module converts the compiled DMIS into an image detection program.

Abstract: Techniques provided herein facilitate just-in-time compilation of source code, such as a script, during execution. According to some embodiments, a tracelet is limited to a single basic block of code. The data types of variable values provided by one or more variables used in the single basic block of code are known by generalized categories, rather than only being known by specific data types. Accordingly, guard code associated with each tracelet, which ensures that variable values received by the tracelet though the variables are of the data types expected by the tracelet's associated code body, can use generalized data types. The tracelet can contain code body that can handle input values that meet those generalized data types. A generalized data type can be defined according to one or more common characteristics shared by two or more specific data types.

Abstract: The present invention relates to a method and an apparatus for generating an executable file of a multi-instance service. The method includes: performing compilation for a source file corresponding to a multi-instance service, to obtain a first-class object file, where the multi-instance service includes N instances, and N is a natural number greater than or equal to 2; performing an object copy of the first-class object file N?1 times, to obtain N?1 new first-class object files; and performing linking to the first-class object file and the N?1 new first-class object files, to generate an executable file. In the present invention, an executable file is generated by performing mirroring and linking processing for an object file obtained by compilation, thereby reducing a development cost and a maintenance cost of software source code.

Abstract: In one embodiment, the invention is a method and apparatus for failure recovery for stream processing applications. One embodiment of a method for providing a failure recovery mechanism for a stream processing application includes receiving source code for the stream processing application, wherein the source code defines a fault tolerance policy for each of the components of the stream processing application, and wherein respective fault tolerance policies defined for at least two of the plurality of components are different, generating a sequence of instructions for converting the state(s) of the component(s) into a checkpoint file comprising a sequence of storable bits on a periodic basis, according to a frequency defined in the fault tolerance policy, initiating execution of the stream processing application, and storing the checkpoint file, during execution of the stream processing application, at a location that is accessible after failure recovery.

Abstract: A system, method, and computer-readable medium for static analysis of large-scale computer programs that uses a compiler to shard the computer programs by source files. Original compilation information is received for one or more groups of source files that reference modules in module containers. The compiler is run to determine a set of modules in the module containers and other source files that are referenced by a source file of the groups of source files. The compilation information is modified on the basis of the source file, the set of modules and the referenced source files. Static analysis is performed on the source file using the modified compilation information. Static analysis is efficiently performed over large-scale computer programs.

Abstract: Methods for mapping a function pointer to the device code are presented. In one embodiment, a method includes identifying a function which is executable by processing devices. The method includes generating codes including a first code corresponds to a first processing device and a second code corresponds to a second processing device. The second processing device is architecturally different from the first processing device. The method further includes storing the second code in a byte string such that the second code is retrievable if the function will be executed by the second processing device.

Abstract: A system and method of dynamically generating software is provided. Applications are created in a set of workflow models which are tested in an interpretive test environment. The models are stored in a versioning repository and code generation templates created for the models. Source code is generated and compiled for the application. Modifications to the models are tested and incorporated into a modified version of the application after subsequent testing of the model and the modified, compiled application. The modified version of the application is returned to the test environment where it becomes the basis for testing future modifications.

Abstract: Systems, methods and articles of manufacture to in-line script dependencies are discussed herein. An embodiment includes extracting test resources addressed in language defining a test web page, placing markers identifying the location of each extracted test resource within the language defining the test page, iteratively loading external resources associated with a path of each test resource, analyzing each test resource to identify one or more dynamically added dependencies, and replacing each marker with external resources and dependencies that reference their respective marker to generate updated language defining an updated test web page. The embodiment further includes adding each identified dependency after or before a top level parent resource, performing the analyzing and the adding until no new dependencies are identified and providing each new dependency with a reference to a parent marker associated with the top level parent resource.

Abstract: A method, computer system, and computer program product for improving application programming interface naming. An alternate name is received for a target application programming interface feature from a consumer developer. In addition, an indirection to the application programming interface feature is generated based on the alternate name. Then, the indirection to the application programming interface feature is transmitted to an indirections repository.

Abstract: One embodiment of a method for constructing executable code for a component-based application includes receiving a request to compile source code for the component-based application, wherein the request identifies the source code, and wherein the source code comprises a plurality of source code components, each of the source code components implementing a different component of the application, and performing a series of steps for each source code component where the series of steps includes: deriving a signature for the source code component, retrieving a stored signature corresponding to a currently available instance of executable code for the source code component, comparing the derived signature with the stored signature, compiling the source code component into the executable code when the derived signature does not match the stored signature, and obtaining the executable code for the source code component from a repository when the derived signature matches the stored signature.

Abstract: A method for preventing the unauthorized modification of a software or unauthorized modification of runtime data. According to this method, a converter, which is capable of converting the software into a generalized machine code is provided. The converter is designed such that it cannot he reverse engineered, by using a conversion process that causes data loss. An interpreter, which the knowledge of its process method is kept restricted, is also provided. The interpreter interprets the general machine code into a specific machine code, while reconstructing the lost data during the interpretation process.

Abstract: A technique for compiling and running high-level program on heterogeneous computers may include partitioning a program code into two or more logical units, and compiling each of the logical units into one or more executable entities. At least some of the logical units are compiled into two or more executable entities, the two or more executable entities being different compilations of the same logical unit. The two or more executable entities are compatible to run on respective two or more platforms that have different architecture.

Abstract: A dynamic compiler program product, method, and device for sequentially compiling a partial computer program in a computer. The program product causes the computer to: acquire respective values of one or more pieces of current execution status information; read, from the shared pool, a list of the conditions associated with an executable instruction stream generated by compiling a partial program that is the same as a partial program to be compiled, and determine whether respective values of corresponding pieces of current execution status information satisfy the conditions. The program product causes the computer to further generate an executable instruction stream by compiling the partial program to be compiled on the condition that a result of determination made is negative.

Abstract: Systems for program analysis include a high-level scanning tool configured to perform a high-level analysis on a program using a processor to generate one or more high-level findings; one or more low-level scanning tools, each configured to perform a low-level analysis on the program using a processor to generate a low-level finding; and a mapping module configured to map the one or more low-level findings to the high-level findings to generate a concise combination report that categorizes each finding according to the highest-level analysis that produces the finding.

Abstract: An approach is provided in which a set of common instructions are each executed by at least two processor cores. Each of the processor cores queues values resulting from at least one of the common instructions (a critical section). The queued values are compared by a queued comparator. An exception is issued in response to the comparison revealing unequal values having been queued by the processor cores.

Abstract: Methods and an apparatus to form a resilient objective instruction construct are provided. An example method obtains a source instruction construct and forms a resilient objective instruction construct by compiling one or more resilient transactions.

Abstract: Embodiments of the invention relate to generating security permissions for applications. A static analysis on an application is carried out to determine security exceptions and to determine the application components responsible for the security exceptions. The determined security exceptions are analyzed to calculate permissions required for each component. A security policy file that includes a hierarchy of the required permissions suitable for the type of application is formatted and applied to the application to provide a security enabled application.

Abstract: A compiler generated static analysis of potential aliasing violations in a portion of code that is not in the current program view of the analysis. Source code in a current program view of the program code is processed to collect symbol definitions. The possible destinations of each symbol definition are computed. The set of symbol definitions in the current program view of the code that are accessible to the portion of the program code outside the current program view is evaluated. Each symbol definition is diagnosed based on the type of the symbol defined and the symbols which may be pointed-to by the symbol definitions.

Abstract: The present invention performs manipulations on the assembly file level. As a compiler outputs an assembly file, the assembly file may be inspected and modified before it is sent to the assembler. One or more of the following modifications may be made to the assembly file: rewrite certain symbols, scramble program symbols, reorganize declarations of global variables so that their layout and default values are known prior to linking, and identify initializer and de-initializer functions in order to make them callable through central initialization and de-initialization functions, respectively.

Abstract: A method for a compiler includes receiving, by the compiler and from an interpreter, a representation of a code section having a control path that changes the representation. The representation has profiling data, and the profiling data has a threshold. The method further includes performing, by the compiler and based on the threshold, a partial evaluation of the interpreter executing the representation, compiling, by the compiler, a machine code of the representation, with the control path replaced by a deoptimization point during the compilation of the machine code, triggering the deoptimization point during execution of the machine code, and returning execution to the interpreter based on the triggering.

Abstract: According to one embodiment of the present invention, a computer system is provided where the computer system includes a main processor, first and second active memory device. The computer system is configured to perform a method including receiving an executable module generated by a compiler, wherein the executable module includes a code section identified as executable by a first processing element in the first active memory device and a second processing element in the second active memory device. The method includes copying the code section to memory in the first device based on the code section being executable on the first device, copying the code section from the first active memory device to an instruction buffer of the first processing element and copying the code section from the first device to the second device based on the code section being executable on the second device.

Abstract: An automatic mutual exclusion computer programming system is disclosed which allows a programmer to produce concurrent programming code that is synchronized by default without the need to write any synchronization code. The programmer creates asynchronous methods which are not permitted make changes to shared memory that they cannot reverse, and can execute concurrently with other asynchronous methods. Changes to shared memory are committed if no other thread has accessed shared memory while the asynchronous method executed. Changes are reversed and the asynchronous method is re-executed if another thread has made changes to shared memory. The resulting program executes in a serialized order. A blocking system method is disclosed which causes the asynchronous method to re-execute until the blocking method's predicate results in an appropriate value. A yield system call is disclosed which divides asynchronous methods into atomic fragments.

Abstract: A computer-implemented method for initializing computer programming elements based on dependency graphs is provided. The method includes determining a dependency graph associated with a computer programming element to be initialized. The method also includes traversing the determined dependency graph, so as to obtain thread information associated with each of the one or more computer programming elements of the determined dependency graph, and determining, based on the obtained thread information associated with each of the computer programming elements, an aggregate thread information of all the computer programming elements of the determined dependency graph. The method further includes generating code which initializes the computer programming element to be initialized based at least on the determined aggregate thread information. Systems and machine-readable media are also provided.

Abstract: Techniques are provided for determining dependencies in a mainframe development environment. While executing a first build file to generate a first build of a software program from files in a file system, the activity in the file system is monitored to determine a plurality of files that are being accessed, and first information about the plurality of files is recorded. The first information is sent to a configuration management server. From the configuration management server, second information is received that indicates one or more dependencies which are determined among the plurality of files based on the first information. Based at least on the second information, a second build file is generated. The second build file is executed to generate a second build of the software program, where the second build is generated more efficiently by using less computing resources than the first build of the software program.

Abstract: A machine is disclosed in data communication with at least one remote computing device configured as a user interface, for example. The machine may include first logic to process non-compiled, non-linked rules providing desired functionality on a remote computing device upon the occurrence of an event. The machine may also include second logic to selectively implement an authorized rule change changing a non-compiled, non-linked rule and storing the changed rule in storage. Changing the non-compiled, non-linked rule may be accomplished in run-time and provide changed functionality on the remote computing device upon an event.

Abstract: Embodiments are directed to providing a generic software function for a plurality of data types in a distributed environment and to implementing type checking at compile time and at runtime. In one scenario, a computer system receives a portion of software code for a distributed software application, where the software code is written as a generic function in a computer programming language that supports reflection. The computer system presents a function signature at runtime to a just-in-time (JIT) compiler. The function signature describes which of multiple different input and output data types the generic function is configured to work with. The computer system also implements reflection at runtime to resolve each generic function to a function pointer after compilation by the JIT.

Abstract: A method is provided for compiling an HLL program. A command is input that indicates a set of HLL source files to be compiled and a set of functions in the HLL source files that are to be implemented on programmable circuitry of a programmable IC. For a source file including one of the set of functions, a respective netlist is generated from HLL code of each of the set of functions included therein. Interface code is also generated for communication with the netlist. HLL code of the set of functions in the HLL source file is replaced with the generated interface code. Each HLL source file is compiled to produce a respective object file. The object files are linked to generate a program executable on the programmable IC. A configuration data stream is generated that implements each generated netlist on the programmable IC.

Abstract: A method and an apparatus for receiving a first source code having a code block to update the first source code with multiple copies of the code block to protect against correlation attacks are described. The code block can perform one or more operations for execution based on the first source code. The operations can be performed via a random one of the copies of the code block. A second source code based on the updated first source code can be generated to be executed by a processor to produce an identical result as the first source code.

Abstract: The present invention extends to methods, systems, and computer program products for transforming source code to await execution of asynchronous operations. Embodiments of the invention simplify authoring and use of asynchronous methods, by generating statements that use well-defined awaitable objects to await completion of asynchronous operations. For example, a computer system can transform a statement that requests to await the completion of an asynchronous operation into a plurality of statements that use a predefined pattern of members of an awaitable object corresponding the asynchronous operation. The pattern can include one or more members configured to return a completion status of the asynchronous operation, one or more members configured to resume execution of the asynchronous method at a resumption point when the asynchronous operation completes, and one or more members configured to retrieve completion results.

Abstract: A system and method for compiling includes, for a parallelizable code portion of an application stored on a computer readable storage medium, determining one or more variables that are to be transferred to and/or from a coprocessor if the parallelizable code portion were to be offloaded. A start location and an end location are determined for at least one of the one or more variables as a size in memory. The parallelizable code portion is transformed by inserting an offload construct around the parallelizable code portion and passing the one or more variables and the size as arguments of the offload construct such that the parallelizable code portion is offloaded to a coprocessor at runtime.

Abstract: A computer implemented method optimizes a configuration of an information technology (IT) infrastructure. A processor establishes a technology rule set, which defines technology weights of an IT infrastructure by mapping capabilities of IT infrastructure components to IT infrastructure attributes needed to execute a specific workload. A candidate IT infrastructure for executing the specific workload is then configured. The processor then receives responses, provided by a customer, to an attribute questionnaire. Each question in the attribute questionnaire is mapped to an IT infrastructure attribute of the candidate IT infrastructure, and the responses define a customer's level of agreement/disagreement with the technology weights. In response to the processor determining that the candidate IT infrastructure fails to meet the customer's expectations, the candidate IT infrastructure is reconfigured until the customer's expectations are met.

Abstract: According to one embodiment, a method for a compiler to produce an executable module to be executed by a computer system including a main processor and active memory devices includes dividing source code into code sections, identifying a first code section to be executed by the active memory devices, wherein the first code section is one of the code sections and identifying data structures that are used by the first code section. The method also includes classifying the data structures based on pre-defined attributes, formulating, by the compiler, a storage mapping plan for the data structures based on the classifying and generating, by the compiler, mapping code that implements the storage mapping plan, wherein the mapping code is part of the executable module and wherein the mapping code maps storing of the data structures to storage locations in the active memory devices.

Abstract: According to one embodiment, a system including a compiler to produce an executable module to be executed by a computer system including a main processor and active memory devices is provided. The system configured to perform a method including dividing source code into code sections, identifying a first code section to be executed by the active memory devices and identifying data structures that are used by the first code section. The method also includes classifying the data structures based on pre-defined attributes, formulating, by the compiler, a storage mapping plan for the data structures based on the classifying and generating, by the compiler, mapping code that implements the storage mapping plan, wherein the mapping code is part of the executable module and wherein the mapping code maps storing of the data structures to storage locations in the active memory devices.

Abstract: A method of operation of a bundle management system includes: generating a resource bundle with client-based script code based on a client device condition of a potential client device; generating a condition map correlating the client device condition to the resource bundle; generating a bundle set including the resource bundle based on a developer version of the client-based script code; uploading the condition map to a web service system; and configuring the web service system to operate a web service corresponding to the developer version of the bundle set.

Abstract: A computing platform constructs an application from source code such that the application detects an attempt to access at least one secured entity of the application. Further, the at least one secured entity is registered with an authorization system by providing metadata that is descriptive of the at least one secured entity to the authorization system so that authorization metadata is generated based upon the metadata and a global unique identifier is assigned to the application and the metadata to identify the application and the metadata. The authorization metadata indicates an access policy to the at least one secured entity.

Abstract: A safety controller designed to control an automated installation having a plurality of sensors and a plurality of actuators. A method for generating a user program for the safety controller comprises the step of generating a source code having a number of control instructions for controlling the actuators and having a number of diagnosis instructions for producing diagnosis reports. Safety-related program variables are processed in failsafe fashion during execution of the control instructions. A machine code is generated on the basis of the source code. At least one checksum is determined for at least some of the machine code. The diagnosis instructions are ignored for the determination of the checksum.

Abstract: Runtime code hooking techniques are described in which a place holder instruction within a compiled module is used as an entry point to enable code hooking. A hook function to modify a target function is developed. At runtime, the target function to be modified is located. A place holder instruction within the target function is overwritten with instructions to cause execution of the hook function when the target function is called.

Abstract: Systems and methods for extending a programming language with a set of extensions using a strict meta-model are disclosed. Embodiments provide a set of interfaces that allow a schema to be synthesized. Syntax is introduced into an existing programming language to allow the construction of schematized data objects. A schema processor module translates a schema representation into new keywords. A document generator module receives the set of keywords and produces output in a selected form. When code comprising the keyword extensions is parsed, AST nodes represent keyword actions as a set of functions and implements those function calls with the original meta-data. A keyword definition comprises a name and an action to be taken at parse time and an action to be taken at runtime. The default action at parse time is to inject a function call into the code. The default action at runtime is to call the function.

Abstract: Abstract Syntax Trees (ASTs) are generated using the source code of a programming language that include information relating to the structure of the program. The generation of the ASTs may be performed in parallel. The types are split into a number of modules (e.g. configurable) that form an assembly. During the different stages of the compilation process, each module may be compiled in parallel. As the different modules are being compiled (e.g. in parallel), compiler metadata from the different modules may be written to a repository accessible by the different compilation processes. After flowing through the compilation pipeline, each of the enriched ASTs are used for code generation where they are transformed into the target language (e.g. a code stream that can be executed on hardware). The executable code is then stored as part of the assembly. The storage of the code may also be performed in parallel.

Abstract: Systems and methods are provided for converting Sequential Function Chart (SFC) logic to function block logic for execution by a programmable controller. In one embodiment, a method includes receiving Sequential Function Chart (SFC) logic comprising Steps and Transition on a physical computing device, converting the Steps and Transitions of the Sequential Function Chart logic to function block logic on the physical computing device, and uploading the function block logic from the physical computing device to a controller.