Abstract: Embodiments describe a computer implemented method of compiling application source code into application object code. A compiler generates application object code having a plurality of table of contents TOC placeholder locations for a potential TOC pointer value command within a calling function. A first function call site of the calling function is corresponded to a first TOC placeholder location. A second function call site of the calling function is corresponded to a second TOC placeholder location.

Abstract: A compiler identifies a function call in computer code. A linker directive associates the function call with a single table of contents (TOC) pointer value save placeholder. This single placeholder is the only TOC pointer value save placeholder associated with the function call. When a TOC pointer value save instruction occupies the placeholder, it ensures that the TOC pointer value is saved before the function call. The linker directive is then modified to associate the function call with two or more TOC pointer value save placeholders. When a TOC pointer value save instruction occupies at least one of the placeholders, it ensures that the TOC pointer value is saved before the function call. Under some circumstances, two or more of the placeholders must be occupied by a TOC pointer value save instruction to ensure that the TOC pointer value is saved before the function call.

Abstract: Embodiments relate to usage of a table of contents (TOC) register as an application register. An aspect includes receiving, by a computer system, application object code comprising a first function call from a calling function to a first callee function, and a symbol table entry in a symbol table comprising a first TOC register usage indicator that is associated with the first callee function. Another aspect includes determining that the first callee function of the first function call does not require a TOC pointer based on the first TOC register usage indicator that is associated with the first callee function in the symbol table. Another aspect includes based on determining that the first callee function of the first function call does not require a TOC pointer, inserting a TOC save command and a TOC restore command corresponding to the first local function call into the application object code.

Abstract: A compiler identifies a first function call site in a calling function that requires an unconditional Table of Contents (TOC) save of the TOC pointer value. The compiler identifies a first location for the unconditional TOC save that dominates the first function call site. The compiler also identifies a second function call site in the calling function that requires a conditional or unconditional TOC save, and determines that the first location also dominates the second function call site. The compiler emits a TOC save instruction at the first location that satisfies both the unconditional TOC save requirement for the first function call site and the conditional or unconditional TOC save requirement for the second function call site. The compiler then indicates that the emitted TOC save instruction satisfies the TOC save requirement for the second function call site, thus suppressing further TOC save actions for the second function call site.

Abstract: A compiler identifies a function call in computer code. A linker directive associates the function call with a single table of contents (TOC) pointer value save placeholder. This single placeholder is the only TOC pointer value save placeholder associated with the function call. When a TOC pointer value save instruction occupies the placeholder, it ensures that the TOC pointer value is saved before the function call. The linker directive is then modified to associate the function call with two or more TOC pointer value save placeholders. When a TOC pointer value save instruction occupies at least one of the placeholders, it ensures that the TOC pointer value is saved before the function call. Under some circumstances, two or more of the placeholders must be occupied by a TOC pointer value save instruction to ensure that the TOC pointer value is saved before the function call.

Abstract: A memory architecture includes a non-volatile, application memory block having first application code for application functions capable of being called by first application, a non-volatile launcher memory block having second application code for application functions capable of being called by a second application, a non-volatile, shared memory block having shared code for shared functions, and a fixed memory locations dedicated within the shared memory block to store shared function pointers, and a volatile memory storing callback pointers. The second application code is launcher code that is operable to initialize the first application code. At least one volatile memory storing callback pointer is associated with each one of the shared functions. The callback pointers point to callback function code when the first application is executing and to callback function code when the second application is executing.

Abstract: Certain example embodiments relate to a highly-concurrent, predictable, fast, self-managed, in-process space for storing data that is hidden away from the garbage collector and its related pauses. More particularly, certain example embodiments relate to improved memory management techniques for computer systems that leverage an off-heap direct-memory data store that is massively scalable and highly efficient. The off-heap store may be provided in connection with a Java-based environment, and garbage collection may be completely or nearly completely avoided for the off-heap store. The off-heap store may be integrated into a tiered storage solution in certain example embodiments.

Abstract: A program file may include code blocks, such as properties and methods blocks. An assistant module may provide a contextual information tool, a class diagram tool, and a template tool. The assistant module may monitor the location of a user interface element as it is moved about the program file. The assistant may provide information regarding the current location of the user interface element through the contextual information tool. The assistant module also may track the construction of the program, and provide information through the class diagram tool regarding program elements, such as properties and methods, defined so far in the program file. The assistant module may present design information, such as a class construction template, in the template tool, and may dynamically update this information during the creation of the program file.

Abstract: A compiler identifies a first function call site in a calling function that requires an unconditional Table of Contents (TOC) save of the TOC pointer value. The compiler identifies a first location for the unconditional TOC save that dominates the first function call site. The compiler also identifies a second function call site in the calling function that requires a conditional or unconditional TOC save, and determines that the first location also dominates the second function call site. The compiler emits a TOC save instruction at the first location that satisfies both the unconditional TOC save requirement for the first function call site and the conditional or unconditional TOC save requirement for the second function call site. The compiler then indicates that the emitted TOC save instruction satisfies the TOC save requirement for the second function call site, thus suppressing further TOC save actions for the second function call site.

Abstract: An apparatus and method for enhancing security and stability in a heterogeneous computing environment that supports an open standard parallel program are provided. A method of enhancing security in a heterogeneous computing environment may include loading a source code kernel corresponding to an application program to be installed in a host system, determining whether the source code kernel is targeted for integrity check, based on a security policy of the host system, prior to cross-compiling the source code kernel, requesting a security engine of a computing device to check an integrity of the source code kernel, when the source code kernel is determined to be targeted for the integrity check, and controlling an operation of a runtime compiler based on a check result received from the security engine.

Abstract: A system and method are described for delivering to a member of an audience supplemental information related to presented media content. Media content is associated with media metadata that identifies active content elements in the media content and supported intents associated with those content elements. A member of an audience may submit input related to an active content element. The audience input is compared to media metadata to determine whether supplemental information can be identified that would be appropriate to deliver to the audience member based on that person's input. In some implementations, audience input includes audio data of an audience's spoken input regarding the media content.

Abstract: Techniques are described herein for performing a dictionary-based dependency determination. For example, when a package is selected to be imported from a store (e.g., a database), a dictionary-based dependency operation may be performed to determine which elements of the package are dependent on other elements of the package. A dictionary includes indexes, each of which has at least one value. The indexes correspond to respective resources, and each value indicates an element of the package that produces the resource that corresponds to the respective index. If an element of the package consumes a resource, the indexes and corresponding values in the dictionary may be reviewed to determine which element(s) of the package produce that resource.

Abstract: Embodiments relate to runtime management of table of contents (TOC) pointer save and restore commands. An aspect includes receiving, by a computer system, application object code comprising a first function call. Another aspect includes determining, at runtime of the application object code, that the first function call comprises an external function call from a calling function in the application object code to a callee function that is external to the application object code. Yet another aspect includes, based on determining that the first function call comprises the external function call, inserting a TOC save command and a TOC restore command corresponding to the first function call into the application object code.

Abstract: Embodiments relate to runtime management of table of contents (TOC) pointer save and restore commands. An aspect includes receiving, by a computer system, application object code comprising a first function call. Another aspect includes determining, at runtime of the application object code, that the first function call comprises an external function call from a calling function in the application object code to a callee function that is external to the application object code. Yet another aspect includes, based on determining that the first function call comprises the external function call, inserting a TOC save command and a TOC restore command corresponding to the first function call into the application object code.

Abstract: An enhanced binder provides flexibility and certainty when selecting a version of a software library to load, and an enhanced loader prevents a library version vulnerable to a security flaw from being loaded. The binder can perform unification, implicit override, and/or redirection. Implicit override searches assembly-specific locations for an implicit_version, and override the previously chosen unification or other version with the implicit_version when the implicit_version is greater. The implicit_version gets updated with the individual assembly, whereas the unification_version gets updated with the framework. Redirection may override the implicit_version. Unlike redirection, an implicit_version does not recite an explicit range and is found outside application configuration files. The implicit_version is specified implicitly by the assembly without an XML declaration.

Abstract: Techniques for replacing ROM-based (Read-Only Memory) DLLs (Dynamic Link Libraries) in a Windows CE type embedded operating system such that the target DLL is replaceable by the hook DLL, and the target DLL is callable by the hook DLL but not callable directly by any other applications after loading of the hook DLL. The techniques enable replacement irrespective whether the hook DLL and the target DLL have the same name and irrespective of which DLL is loaded first. The techniques change the file name of the target DLL in a list of loaded DLL modules by a trusted program that executes in the full kernel mode.

Abstract: A loader application and an associated dynamic link library are installed on a client system. Upon a first execution of the loader application, a user authorization to communicate with locations external to the client via a communications network is received. The dynamic link library and not the loader application is auto-updated without requiring additional user authorization. The auto-updating is repeated during one or more executions of the loader application subsequent to the first execution.

Abstract: A method and system for creating a library method stub in source code form corresponding to an original library call in machine-executable form. The library method stub is created in a predefined programming language by use of a library method signature associated with the original library call, at least one idiom sentence, and a call invoking the original library call. Creating the library method stub includes composing source code of the library method stub by matching the at least one idiom sentence with idiom-stub mappings predefined for each basic idiom of at least one basic idiom. The original library call appears in sequential code. The library method signature specifies formal arguments of the original library call. The at least one idiom sentence summarizes memory operations performed by the original library call on the formal arguments. The created library method stub is stored in a database.

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 method and apparatus for building a source code based on a project object model (POM) from a source control and for tracking a build environment of the source code is described. Plugins to complete the build as configured in the POM are downloaded from an external plugin repository. A local plugin repository is scanned to determine which plugins have already been downloaded. The local plugin repository is rescanned to determine whether any additional plugins and associated plugins POM files were downloaded during the build as build dependencies. Information of one or more referenced files is inserted into a database wherein the referenced files are identified as build dependencies. Information about the newly-built plugins and associated plugins POM files in the output directory are extracted and added to the database for use by subsequent builds.

Abstract: Particular embodiments optimize a C++ function comprising one or more loops for symbolic execution, comprising for each loop, if there is a branching condition within the loop, then rewrite the loop to move the branching condition outside the loop. Particular embodiments may further optimize the C++ function through simplified symbolic expressions and adding constructs forcing delayed interpretation of symbolic expressions during the symbolic execution.

Abstract: The present invention relates to a method for transferring content to a device, the method including the steps of: receiving a request for content from the device; delivering a uniquely identifiable, ephemeral player to the device; and transferring content to the device, for presentation on the device by the player. The invention has particular application to digital rights management in respect of the distribution of audiovisual content such as film and television programs, advertisements and live event broadcasts over communication networks such as the Internet.

Abstract: A system and associated method for creating a library method stub in source code form corresponding to an original library call in machine-executable form. Sequential code subject to pipeline-parallelization includes the original library call of which source code is not available for profiling. The original library call is annotated for a library method signature to specify formal arguments and parameters accessible to the formal arguments. Memory operations of the original library call are summarized with on one or more idiom sentences, which are mapped to a respective code stub that simulates the original library call. The library method stub is created for profiling of the original library call in source code level such that the sequential code is parallelized via the created library method stub.

Abstract: An illustrative embodiment of a computer-implemented process for interdependent task management selects a task from an execution task dependency chain to form a selected task, wherein a type selected from a set of types including “forAll,” “runOnce” and none is associated with the selected task and determines whether there is a “forAll” task. Responsive to a determination that there is no “forAll” task, determines whether there is a “runOnce” task and responsive to a determination that there is a “runOnce” task further determines whether there is a semaphore for the selected task. Responsive to a determination that there is a semaphore for the selected task, the computer-implemented process determines whether the semaphore is “on” for the selected task and responsive to a determination that the semaphore is “on,” sets the semaphore “off” and executes the selected task.

Abstract: An illustrative embodiment of an apparatus for interdependent task management selects a task from an execution task dependency chain to form a selected task, wherein a type selected from a set of types including “forAll,” “runOnce” and none is associated with the selected task and determines whether there is a “forAll” task. Responsive to a determination that there is no “forAll” task, determines whether there is a “runOnce” task and responsive to a determination that there is a “runOnce” task further determines whether there is a semaphore for the selected task. Responsive to a determination that there is a semaphore for the selected task, the computer-implemented process determines whether the semaphore is “on” for the selected task and responsive to a determination that the semaphore is “on,” sets the semaphore “off” and executes the selected task.

Abstract: Systems and methods for adding services to an application platform via an extension platform coupled to the application platform. The application platform runs in a first operation system process and provides a number of resources. The extension platform is implemented in a second operation system process and communicates with the application platforms via standard inter-process communication protocols. The extension platform provides an environment to dynamically model and host application services. A resource abstraction layer provides the extension platform with access to the resources provided at the application platform. The resources are utilized by the extension platform to design and to execute the application services. The application services hosted in the extension platform are centrally managed and administered from the application platform via exposed interfaces.

Abstract: Methods, apparatuses, and systems for file migration in distributed systems. A data structure definition is added to a programming language source code and initialized. Initialization values include contents of a first data file that is external to the source code file. The source code file is compiled with one or more other source code files to create an executable program that includes the initialization values as part of the program's image. During execution, the executable program creates a different second data file external to the executable program by reading the initialization values from the initialized data structure and writing the values to the second data file. This second data file is accessible by a library linked to the executable program.

Abstract: An enhanced binder provides flexibility and certainty when selecting a version of a software library to load, and an enhanced loader prevents a library version vulnerable to a security flaw from being loaded. The binder can perform unification, implicit override, and/or redirection. Implicit override searches assembly-specific locations for an implicit_version, and override the previously chosen unification or other version with the implicit_version when the implicit_version is greater. The implicit_version gets updated with the individual assembly, whereas the unification_version gets updated with the framework. Redirection may override the implicit_version. Unlike redirection, an implicit_version does not recite an explicit range and is found outside application configuration files. The implicit_version is specified implicitly by the assembly without an XML declaration.

Abstract: A system, method, and medium are disclosed for implementing an application component container. The container is configured to detect that a component managed by the container is dependent on an interface that is implemented by a dynamic module provided by a dynamic module system. The container uses a dependency injection framework to inject the implementation into the dependent component in a type-safe manner.

Abstract: Certain example embodiments relate to a highly-concurrent, predictable, fast, self-managed, in-process space for storing data that is hidden away from the garbage collector and its related pauses. More particularly, certain example embodiments relate to improved memory management techniques for computer systems that leverage an off-heap direct-memory data store that is massively scalable and highly efficient. The off-heap store may be provided in connection with a Java-based environment, and garbage collection may be completely or nearly completely avoided for the off-heap store. The off-heap store may be integrated into a tiered storage solution in certain example embodiments.

Abstract: Disclosed is a method of automatically customizing a computer executable application, such as a test automation harness, based on currently installed modules. The functionality of the application can be split in multiple modules. At runtime, the application can automatically detect the presence or absence of a module. If a module is available, it can automatically be integrated with the application such that the functionality, such as language-level features and constructs, provided by the module is active and/or exposed. If the module is absent, the application can continue executing without the functionality provided by the module.

Abstract: A field device management apparatus may include a plurality of COM in-process servers, each of which acquires and manages device data related to a corresponding one of field devices, and a launch-program COM in-process server that stores a launch-program, the launch-program activating an instance in each of the plurality of COM in-process servers, the launch-program preventing four different functions from being executed directly by an OS in the plurality of COM in-process servers. The plurality of COM in-process servers may be initialized on the Microsoft Windows operating system to generate COM objects in different memory spaces.

Abstract: A method and system for dynamically identifying and loading a version of a runtime for custom code of a host application without modifying the host application is provided. A loading system dynamically identifies the version of the runtime during execution of the host application. The loading system is also dynamically linked into the host application so that its algorithm for identifying the version of the runtime can be modified without modifying the host application. When requested by the host application to load custom code, the loading system identifies a version of the runtime to load, loads the identified version of the runtime, and then requests a load component of the loaded version of the runtime to load the custom code.

Abstract: An executable program compiled according to a source instruction set architecture (source ISA) is loaded for execution by a target instruction set architecture (target ISA)-based hardware execution unit, wherein the source and target ISA's are different. The loading includes mapping a compiler built-in helper function in the executable program to a target ISA machine instruction. The loaded program is then executed. As part of the execution, the helper function is replaced with the target ISA machine instruction to which the helper function was mapped, and the target ISA machine instruction is executed rather than the helper function.

Abstract: A mechanism for determining support criteria for shared libraries based on their priority levels is described. A method of embodiments of the invention includes extracting interface provisioning detail relating to interfaces associated with shared libraries provided by an operating system running on a computer system. The interfaces include application binary interfaces (ABIs). The method further includes detecting interface usage detail associated with the interfaces. The interface usage detail is based on a frequency at which one or more interfaces are used by one or more third-party software programs running on the operating system. The method further includes comparing the interface provisioning detail with the interface usage detail to determine an importance level of each shared library, and analyzing comparison results obtained from the comparison. The analyzing includes assigning a priority level to each shared library based on its importance level.

Abstract: An integrated development environment (IDE)-based approach for processing/analyzing proposed program code libraries as a replacement for existing program code libraries in a networked computing environment is provided. A set of annotations associated with a set of program code files and a proposed (e.g., new, modified, etc.) program code library are received in an integrated development environment (IDE). It may then be determined whether the proposed program code library is an excluded program code library based on the set of annotations. It may also be determined whether the proposed program code library meets one or more thresholds for replacing an existing program code library. If the proposed program code library is not excluded and meets the threshold(s), the proposed program code library may then be provided to a computer device hosting the IDE (e.g., for implementation).

Abstract: A hybrid system is provided. The system includes a computing device implementing a first application execution environment (AEE) and a second AEE. The first AEE is configured to be isolated from the second AEE. The first software application associated with the first AEE is configured to be processed on the first AEE such that the first software application is denied direct access to the second AEE. A second software application associated with the second AEE is configured to be processed on the second AEE such that the second software application is denied direct access to the first AEE.

Abstract: A method and system for the online promotion of intellectual property includes providing an Internet host station with at least one database that is connectable via the Internet to consumer stations and industry stations. The database includes a plurality of intellectual property items and a description of each intellectual property item. At least one of the intellectual property items is selected by a consumer station and the description associated with the selected intellectual property item is viewed at the consumer station. Portions of the description may be confidential and therefore not normally viewed at the consumer station. Feedback data is sent from the consumer station to the host station. The feedback data includes consumer opinion information of the selected intellectual property item based at least in part on the description of the selected intellectual property item.

Abstract: Provided is a computer-readable, non-transitory medium storing an algorithm selection program for selecting one of algorithm among of a plurality of algorithms included in an extension program for executing a predetermined function when a call-out source program calls out the extension program, the algorithm selection program causing an information processing device including a storage device to execute:acquiring, from the storage device, selection information in which a command for calling out the extension program in the call-out source program and the one of algorithm are correlated; and selecting an algorithm for executing the predetermined function based on the acquired selection information.

Abstract: The disclosure provides a system, a method and a computer program product that facilitate access to one or more applications by a computing device. The disclosure includes a step of determining one or more contexts associated with the computing device or a user of the computing device, such that the one or more contexts describe environment or activity of the user or the computing device. The disclosure also includes a step of generating at least one contextual tag corresponding to the one or more contexts, after which the one or more applications associated with the at least one contextual tag are identified and the computing device is enabled to access the one or more applications.

Abstract: A user experience (“UX”) customization framework is provided that enables the customization of the UX provided by an operating system (“OS”) and application programs executing on the OS. The UX customization framework includes a UX platform engine that processes UX markup language files to create a customized UX. UX markup language files include data that is formatted according to a UX markup language. The UX markup language is a superset of the hypertext markup language that defines additional markup language tags for use in creating a customized UX, such as tags through which the functionality provided by an OS component or an application program that is exposed through an application programming interface may be utilized within the UX.

Abstract: Methods of development and compilation of cross-platform software are provided. Through the use of platform-specific libraries, software can be written using only platform-independent instructions and then compiled for one or more different platform targets. In the compilation process, a compiler can obtain a target platform. Then, the compiler can select a platform-specific library associated with that target platform. A platform-independent instruction can then be obtained by parsing source code, for example. The compiler can then link the platform-independent instruction with a platform-specific instruction of the selected platform-specific library. This can allow cross-platform software to be written using only platform-independent instructions, and platform-specific instructions can be linked automatically when compiling the software for a specific target platform.

Abstract: Approaches for customizing a unified extensible firmware interface (UEFI) compatible firmware component to support multiple hardware components. The UEFI compatible firmware component may be implemented by linking one or more executive drivers created in an executive module of the firmware component. The executive drivers, instead of platform drivers, are executed by UEFI dispatchers. The platform module, rather than being a collection of drivers, functions as a platform library that links to the executive drivers. One or more programs for providing one or more library functions to the one or more executive drivers are also linked into the firmware component. Call outs to board library functions provided by a board module are implemented in the executive drivers, instead of drivers of the platform module. The board library functions replace the one or more library functions provided to the executive drivers and reflect a change in a customer reference board (CRB).

Abstract: A software development application determines whether routine name and version number parameters have been identified (33). If so, the application determines whether the specified version of the routine can be accessed (35). If the specified version cannot be accessed, the application locates a substitute version of the routine (37) and compiles and links the routines and a source file to produce an executable file (39).

Abstract: A parallel processing method and apparatus for initializing libraries is disclosed. Libraries for an application are identified, an initialization order for the libraries is determined, and the libraries are initialized in asynchronous stages. The initialization order is determined by forming a library tree of the libraries' references and determining a load order for the references according to the levels of the references in the library tree. The asynchronous stages comprise a loading stage that includes a load queue, a snapping stage that includes a snap queue, and an initializing stage that includes an initialize queue.

Abstract: Techniques are described herein for performing a dictionary-based dependency determination. For example, when a package is selected to be imported from a store (e.g., a database), a dictionary-based dependency operation may be performed to determine which elements of the package are dependent on other elements of the package. A dictionary includes indexes, each of which has at least one value. The indexes correspond to respective resources, and each value indicates an element of the package that produces the resource that corresponds to the respective index. If an element of the package consumes a resource, the indexes and corresponding values in the dictionary may be reviewed to determine which element(s) of the package produce that resource.

Abstract: A method of automatically creating functionally and structurally diverse equivalent copies of software executables using return oriented programming for the purpose of passing through a filter and other purposes includes starting with a program and a target runtime environment, creating a return oriented instruction library having a plurality of code fragments which end in a ‘return’ instruction from the program and chaining fragments together to automatically form diverse equivalent copies of software executables using return oriented programming.

Abstract: There is provided an information processing apparatus including a message storage unit for storing a message sent to a component, and an execution processing unit for loading the component body into a computer in response to receiving an execution instruction on the component to execute the component body and process the message stored in the message storage unit prior to the execution instruction.

Abstract: A lock-clustering compiler is configured to compile program code for a software transactional memory system. The compiler determines that a group of data structures are accessed together within one or more atomic memory transactions defined in the program code. In response to determining that the group is accessed together, the compiler creates an executable version of the program code that includes clustering code, which is executable to associate the data structures of the group with the same software transactional memory lock. The lock is usable by the software transactional memory system to coordinate concurrent transactional access to the group of data structures by multiple concurrent threads.

Abstract: Disclosed herein are representative embodiments of tools and techniques for installing, executing, and/or updating managed applications through generation of native code from code in an intermediate language. According to one exemplary technique, a computing device receives machine dependent intermediate language code (MDIL code) generated by an online provider for an application. Additionally, the computing device installs the application on the computing device by generating a native image for the application, which includes binding a portion of the MDIL code with one or more libraries on the computing device. Also, the native image is stored on the computing device for use in loading the application for execution.