Abstract: This disclosure describes techniques to compile source code corresponding to a portion of a software program. The techniques include generating first object code by processing the source code. Based at least in part on processing the source code, generating second object code, wherein the second object code, when executed by one or more processors, causes the one or more processors to perform an operation unconditionally bound to a unique identifier of the operation. The described techniques further include generating an indication of a mapping of the unique identifier to the portion of the software program.

Abstract: A computing system includes a processor and a memory storing instructions for a compiler that, when executed by the processor, cause the processor to generate a control flow graph of program source code by receiving the program source code in the compiler, in the compiler, generating a structure point representation based on the received program source code by inserting into the program source code a set of structure points including an anchor structure point and a join structure point associated with the anchor structure point, and based on the structure point representation, generating the control flow graph including a plurality of blocks each representing a portion of the program source code. In the control flow graph, a block A between the anchor structure point and the join structure point post-dominates each of the one or more divergent branches between the anchor structure point and the join structure point.

Abstract: In one general aspect, a system includes an abstract machine instruction stream, a virtual machine coprocessor configured to receive an instruction from the abstract machine instruction stream and to generate one or more native machine instructions in response to the received instruction, and a processor coupled to the virtual machine coprocessor and operable to execute the native machine instructions generated by the virtual machine coprocessor. The virtual machine coprocessor is operable to generate one or more native machine instructions to explicitly control the virtual machine coprocessor.

Abstract: A system, apparatus and method for ordering a sequence of processing transactions. The method includes accessing, from a memory, a program sequence of operations that are to be executed. Instructions are received, some of them having an identifier, or mnemonic, that is used to distinguish those identified operations from other operations that do not have an identifier, or mnemonic. The mnemonic indicates a distribution of the execution of the program sequence of operations. The program sequence of operations is grouped based on the mnemonic such that certain operations are separated from other operations.

Abstract: Processor trace systems and methods are described. For example, one embodiment comprises executing instrumented code by a compiler, the instrumented code including at least one call to un-instrumented code. The compiler can determine the at least one call to un-instrumented code is a next call to be executed. A resume tracing instruction can be inserted into the instrumented code prior to the at least one call to the un-instrumented code. The resume tracing instruction can be executed to selectively add processor tracing to the at least one call to the un-instrumented code, and the at least one call to the un-instrumented code can be executed.

Abstract: A script debugging method, a device, and a computer storage medium. The method includes: obtaining, by a device, a debugging instruction, where the debugging instruction carries a to-be-debugged target line breakpoint, and the target line breakpoint includes at least line information used to indicate a line of code in which a breakpoint location is located in a script file requested to be debugged; and displaying a debugging result when determining that a breakpoint debugging condition is met, where the debugging result includes information obtained by the debugger when the device performs breakpoint processing on the line of code corresponding to the target line breakpoint, and the breakpoint debugging condition includes at least that identification information corresponding to a target interface breakpoint is consistent with identification information corresponding to a target local variable.

Abstract: A method for detecting an intrusion (i.e. hacking) of an electronic device includes determining an expected activity value associated with one or more software applications executing on a processor, monitoring the one or more software applications executing on the processor to determine a current activity value associated with the one or more software applications, determining whether the current activity value exceeds a threshold associated with the expected activity value, and in response to determining that the current activity value exceeds the threshold, initiating one or more security actions associated with the one or more software applications. A system for detecting an intrusion of an electronic device includes an intrusion detection module configured to perform the steps of the method.

Abstract: A method and system of checkpointing single process application groups and multi-process application groups. In an exemplary embodiment, the method may include creating at least one full checkpoint for each application in an application group, and creating at least one incremental application checkpoint for each application in the application group. Further, each of the at least one incremental application checkpoint may be automatically merged against a corresponding full application checkpoint. Further, checkpointing may be synchronized across all applications in the application group. In the exemplary embodiment, each application may use both fork( ) and exec( ) in any combination.

Abstract: Memory reclamation includes executing a process that has a plurality of objects, the objects being accessible via a plurality of references, at least some of the plurality of references being transient references, at least some of the plurality of references being persistent references; reaching a reclamation point at which a process state has no transient references, or has transient references only at known locations; and at the reclamation point, destructing objects that have no persistent references and no transient references.

Abstract: Operations include (a) identifying bounds corresponding to two or more inference variables corresponding to a nested method invocation context, (b) determining that resolution of a first inference variable can be determined as a function of a resolution of a second inference variable, (c) propagating bounds corresponding to the second inference variable from the nested method invocation context to an outer method invocation context without propagating bounds corresponding to the first inference variable, (d) resolving a constraint set to resolve the second inference variable, and (e) resolving the first inference variable based on the resolution of the second inference variable.

Abstract: Training data identifying a plurality of pairs is received. Each pair identifies one or more separate code snippets known to resolve a respective issue of a plurality of issues. For each pair of the plurality of pairs, a respective issue representation of core content of the respective issue and a linear expression of the one or more separate code snippets in a respective code representation is constructed and a model to correlate the respective code representation as resolving the respective issue representation is trained. The model is queried with a new issue and a selected one of the one or more separate code snippets. The model returns a classification indicating whether the selected one of the one or more separate code snippets is likely to resolve the new issue.

Abstract: Systems, methods, and computer-readable media for intercepting telemetry events obtained during operation of an application and analyzing the telemetry events are provided. The telemetry events are intercepted at the library level by interposing on application calls to a native library. The telemetry events are collected and transmitted to a platform that analyzes the collected events and presents information based on the analysis.

Abstract: Techniques are described for detecting the presence of regressions in software, such as software that is being developed and tested in a development environment. Compiled code can be instrumented to introduce annotations to the compiled code. For example, the annotations can be added at the start and end of a code section, where a code section can be specified at any suitable degree of specificity (e.g., a line of code, a function, a component, multiple components, and so forth). When the instrumented code is executed, the annotations generate timing information that describes the execution times of the various annotated code sections. The timing information can be analyzed and compared to previously generated timing information for the code base, and detected differences may trigger actions such as reports, alerts, denied requests to pull code from the source repository, rejected code check-ins, bug reports, and so forth.

Abstract: Systems, methods, and computer-executable instructions for guiding program synthesis includes receiving a specification that includes an input and output example. Programs are synthesized that meet the specification. During synthesizing each of the programs includes branching decisions. Each branching decision includes a plurality of paths. Synthesizing the programs comprises includes selecting a first score model, for a first branching decision. Each of the programs is scored using the first score model. The paths of the first branching decision are pared based on the score. One the paths is selected. A synthesized program that meets the specification is returned. The synthesized program includes the one of the paths.

Abstract: A computer-implemented method includes: collecting, by a processor of a computer, analysis information from a source code of a computer program; tracing, by the processor of the computer, program behavior starting with a main entry point to produce trace data; and visualizing, by the processor of the computer, the trace data as a sequence diagram, wherein the trace data comprises a representation corresponding to a sequence diagram.

Abstract: A computer-implemented method includes: collecting, by a processor of a computer, analysis information from a source code of a computer program; tracing, by the processor of the computer, program behavior starting with a main entry point to produce trace data; and visualizing, by the processor of the computer, the trace data as a sequence diagram, wherein the trace data comprises a representation corresponding to a sequence diagram.

Abstract: The exemplary embodiments may provide an approach to finding and identifying the correlation between the invoking code and the invoked code by correlating the timestamps of contextual information of code in the invoking code and invoked code. As a result, developers have information during investigating the programs and can use the information to identify a region of interest to narrow down a performance problem in the invoking code efficiently. As a result, development productivity can be improved.

Abstract: A computer implemented method comprises receiving code coverage analysis data in respect of a code coverage analysis performed in respect of a particular version of a particular source code base and a test suite, wherein the particular source code base is maintained in a source code repository of a version control system; identifying a code coverage result repository of the version control system, wherein the code coverage result repository is associated with the particular version of the particular source code base; generating a new storage version based on the code coverage analysis data; obtaining a delta between the new storage version and a previous storage version of the code coverage analysis data; and committing the delta to the code coverage result repository of the version control system as a new version to de-duplicate code coverage analysis data.

Abstract: A method for redirecting indirect calls to direct calls on a per-process basis includes accessing a memory code region of an operating system kernel that has a different mapping for each of one or more user processes running on the operating system kernel. The memory code region stores a first trampoline that refers directly to a second trampoline, which is an inline or outline trampoline that is correlated with a particular user process. Executing the first trampoline invokes the second trampoline, as a result of which the indirect calls are redirected to direct calls.

Abstract: A monitoring system monitors processing of incoming messages by an application, and logs data related to performance of the application. The application includes a plurality of checkpoints, and the monitoring system logs data upon each message traversing the checkpoints in the application. The monitoring system is configured to dynamically modify checkpoints within the application based on latency detection of portions of the application, resulting in improved granularity/resolution of the data collected from congested portions of the application, and reducing the performance penalty of the monitoring system from portions of the application that are not congested.

Abstract: Techniques facilitating using flow graphs to represent a data analysis program in a cloud based system for open science collaboration and discovery are provided. In an example, a system can represent a data analysis execution as a flow graph where vertices of the flow graph represent function calls made during the data analysis program and edges between the vertices represent objects passed between the functions. In another example, the flow graph can then be annotated using an annotation database to label the recognized function calls and objects. In another example, the system can then semantically label the annotated flow graph by aligning the annotated graph with a knowledge base of data analysis concepts to provide context for the operations being performed by the data analysis program.

Abstract: The life cycle of an application can be shortened by initiating the creation of a mock-up test script before the development of an application is complete. The concurrent creation of the mock-up test script and the application can reduce a time associated with the life cycle of an application. Mock-up test script creation is based on the user interface (UI) specification and a mock-up graphical user interface (GUI) without business logic. Test script creation can include associating a functional specification and a UI specification with a proposed application and creating a mock-up GUI for testing based on the UI specification. Test script creation can include developing an application based on the proposed application that includes a logic based on the functional specification and a GUI based on the UI specification and creating a mock-up test script based on the mock-up GUI and not based on the logic, the functional specification, and the GUI.

Abstract: This disclosure relates generally to method and system for verifying properties of source code. Verifying sufficient subset of properties by identifying implication relations between their verification outcomes is time consuming because of increased size of source code with large number of properties. The proposed disclosure processes the received source code for verifying properties by analyzing the source code to merge the plurality of properties into a plurality of groups based on a grouping technique. Then, slice for each group among the plurality of groups are created. Further, each slice created for each group is verified; verification for the one or more properties within each group is performed simultaneously. The system groups the properties thereby providing efficient and scalable system for verifying properties which reduces cost with increased efficiency and improved performance.

Abstract: It is determined, if a simulated hardware signal of a design for an electronic circuit has an influence on a checker for simulation errors. To achieve this, a checker control flow database is generated for a static code description containing checkers and concerned simulated signals. Further, a database based on the output of instrumented verification code is generated, thus gaining dynamic information about the verification code. Herein, the hardware signal values will be associated with colored values or, alternatively, attributed values. For the checkers in the checker control flow database, a list of attributes is generated and stored. Based on the above operations, a hardware signal database is generated, wherein hardware signals are mapped to a list of checkers, based on determining, for each checker in the checker database, the associated hardware signals from its list of attributed values.

Abstract: Automatic detection of software program regression points enables developers to more quickly and accurately diagnose and solve issues in changes to software. Traces of instructions are collected from before and after a change to a program or settings thereto on a computing device and are compared to identify differences between the two traces. Areas of differences are ranked and returned to identify the point(s) of regression in the traces to alert a user of programs of behaviors to avoid and/or a developer a point to focus efforts on to patch the responsible program or update other programs around the responsible application.

Abstract: Systems and techniques for crowd sourced online application management are described herein. A received application and an application cache policy may be identified. Execution of the application may be monitored to determine a behavior characteristic for a subset of application components. A cache policy may be determined for the subset of application components based on the monitoring. A cache improvement plan for the application may be provided based on the cache policy for the subset of application components.

Abstract: Operations may include identifying an edit that corresponds to a fault of a program. The edit may be identified based on a difference between the program and an improved program. The operations may include obtaining an AST that represents the program and includes defect nodes that correspond to a fault location and include an edit node. The operations may include classifying a particular node as a primary node that operates as a starting point for the edit. The operations may include identifying a path from the primary node to the edit node. The operations may include generating a fix pattern based on the path and the edit. The operations may include performing repairs with respect to an identified fault of code. The repairs may be performed using the fix pattern and based on the identified fault of the code being the same type as the fault of the program.

Abstract: A method for measuring code coverage of runtime generated code is provided that can be used for unit testing. In some implementations, the method may include performing unit testing of one or more lines of code of an application by at least: executing during runtime the one or more lines of code, generating, from the executed one or more lines of code, additional code including generated code including instructions to increment at least one counter in a map, the map mapping one or more frames to the at least one counter, compiling the generated code, incrementing, each time the compiled generated code is executed during runtime, the at least one counter in the map, and providing the at least one counter to enable verification of the unit testing of the generated code. Related methods and articles of manufacture are also described.

Abstract: A class description file describing a class associated with an application (APP) is generated based on an original file of the APP. The class description file is added to an installation package associated with the APP. Prior to execution of the APP, the installation package is downloaded. During the execution of the APP, the class description file is obtained from the installation package. The class associated with the APP is generated based on the class description file.

Abstract: Optimization of computer program code can be performed during compilation of the computer program code. During the compilation of the computer program code, at least a first location in the computer program code that performs a calculation on at least one parameter value that affects a user experience provided by the computer program code can be automatically determined. During the optimization, a first implicit sequence point can be inserted into the computer program code at the automatically determined first location, wherein the first implicit sequence point is configured to provide a virtual read of at least a first symbol contained in the computer program code when the first implicit sequence point is reached during execution of the computer program code during a debug operation performed on the computer program code after the computer program code is optimized and compiled.

Abstract: Indications of a plurality of events whose occurrence is detected in a particular execution of a program are obtained. One or more partitions of a trace object corresponding to the execution are constructed, including a first partition corresponding to a first subset of the events. The first partition comprises a header portion which includes a compressed representation of one or more event chains, and a data portion comprising a compressed events record indicating an occurrence, during the execution, of a particular sequence of events indicated by an event chain. The trace object is stored.

Abstract: Metadata tables can provide the link between the instrumentation information collected and the location in the source code of the programming language construct that was instrumented. The metadata tables enable the relationship between the programming construct in the source code and the dynamic analysis information collected to be exact rather than an estimate. During compilation information is collected that enables a mapping between document table and analysis table to occur.

Abstract: Various methods and systems for generating an idempotent workflow are described herein. In one example, a method includes detecting distributed code and identifying a boundary function in the distributed code. The method can also include separating the boundary function into a transition function, a non-idempotent function, and a reversion function. Additionally, the method can include transforming the non-idempotent function into an idempotent function by generating a flag corresponding to the non-idempotent function, wherein the flag indicates if the non-idempotent function has been executed. Furthermore, the method can include combining the transition function, the idempotent function, and the reversion function to form the idempotent workflow.

Abstract: A class description file describing a class associated with an application (APP) is generated based on an original file of the APP. The class description file is added to an installation package associated with the APP. Prior to execution of the APP, the installation package is downloaded. During the execution of the APP, the class description file is obtained from the installation package. The class associated with the APP is generated based on the class description file.

Abstract: Systems, methods, and computer program products to perform an operation comprising non-blocking runtime debugging of an application executing in a single threaded server environment by obtaining a first request from a head of a request queue, processing the first request based on server application code under debugging, triggering, in response to the first request, a debugging procedure, pausing processing of the first request based on the debugging procedure, tagging the first request with an indication that the first request is in debugging, placing the first request back on the request queue in a position behind the head of the queue, storing debug information related to the first request, and executing at least a second request from the request queue while processing of the first request is paused.

Abstract: A method of increasing utilization of a computer program product having a plurality of features usable by multiple user groups. The method comprises: accessing a database storing multiple scenarios each defining a course of action characterised by usage of a respective subset of the features; via a network interface, receiving logs of past usage of some or all of these features by a target user group; based on the received logs, identifying one or more of the features that are unused or less frequently used by the target user group, and selecting one or more of the scenarios for the target entity which make use of the one or more unused or less frequently features. An indication of the one or more selected scenarios is output via a network interface, thereby causing the target entity to follow the course of action defined in at least one of the selected scenarios.

Abstract: Techniques for facilitating conversion of an application from a block-based persistence model to a byte-based persistence model are provided. In one embodiment, a computer system can receive source code of the application and automatically identify data structures in the source code that are part of the application's semantic persistent state. The computer system can then output a list of data types corresponding to the identified data structures.

Abstract: Techniques are provided for redundant execution by a better processor for intensive dynamic profiling after initial execution by a constrained processor. In an embodiment, a system of computer(s) receives a request to profile particular runtime aspects of an original binary executable. Based on the particular runtime aspects and without accessing source logic, the system statically rewrites the original binary executable into a rewritten binary executable that invokes telemetry instrumentation that makes observations of the particular runtime aspects and emits traces of those observations. A first processing core having low power (capacity) performs a first execution of the rewritten binary executable to make first observations and emit first traces of the first observations. Afterwards, a second processing core performs a second (redundant) execution of the original binary executable based on the first traces.

Abstract: A collection of techniques is disclosed to allow for the detection of malware that leverages pattern recognition and machine learning to effectively provide “content-less” malware detection, i.e., detecting a process as being an ‘anomaly’ not based on its particular content, but instead based on comparisons of its behavior to known (and characterized) ‘trusted’ application behaviors, i.e., the trusted applications' “phenotypes” and/or the phenotypes of known malware applications. By analyzing the patterns of normal behavior performed by trusted applications as well as malware applications, one can build a set of sophisticated, content-agnostic behavioral models (i.e.

Abstract: Systems and methods are described for providing code completion features for code modules that have been incorporated into a source code document being edited by a user of a source code editor. Embodiment dynamically load and apply partial code evaluation to code modules referenced in the source code document (and any code modules referenced directly or indirectly by such code modules) while the user is editing it. The partial code evaluation is performed on a background thread that is separate from a main thread used to execute the user interface for the source code editor. The results of such partial code evaluation are cached and used to provide code completion information for the code modules.

Abstract: Methods, systems and non-transitory computer readable media involves receiving information of a new library from a patch management repository. A symbolic link to the new shared library is created and a request to an application process to replace a shared library is communicated. To replace the shared library, the application process periodically checks reference state of the shared library till it reaches a free-state. When the shared library reaches the free-state, the application process unloads the shared library from memory space and loads the new shared library to the memory space. The application process continues performing one or more pre-define functions during the replacement of the shared library.

Abstract: Implementing a design for a heterogeneous computing platform can include storing, using a processor, profile data in a memory, wherein the profile data is generated from running the design for the heterogeneous computing platform and wherein the design includes a kernel adapted for hardware acceleration. Compliance of the design with a profile rule may be determined by comparing, using the processor, the profile data accessed from the memory with the profile rule. The profile rule can specify a design requirement for a hardware accelerated implementation of the kernel. Compliance of the design with the profile rule can be indicated, using the processor, based upon the comparing.

Abstract: Managing sets of parameter values includes: receiving a plurality of sets of parameter values for a generic computer program, and processing log entries associated with executions of instances of the generic computer program, each instance associated with one or more parameter values. The processing includes: analyzing the generic computer program to classify each of one or more parameters associated with the generic computer program as a member of either a first class or a second class; processing a log entry associated with an execution of a first instance of the generic computer program to form a particular set of parameter values; and determining whether to add the particular set of parameter values to the plurality of sets of parameter values based on a comparison of a first identifier for the particular set of parameter values to identifiers for at least some of the sets of parameter values.

Abstract: A method for simulating a program modeled as one or more blocks of a block diagram in a technical computing environment. A block diagram is opened in a model editor. Source code is generated for the one or more blocks of the block diagram using the code generator. The program is configured from the source code using a predefined compiler in order to generate a binary executable file, and the program is simulated, which comprises running at least one function in the auxiliary file in order to determine at least the width of a basic data type corresponding to the enumeration variable in the binary executable file, and allocating one or more variables based on the determined byte width in order to log the simulation results.

Abstract: A method (and structure) for enforcing a security policy includes retrieving from a memory a program to be verified against a security policy and a security specification defining the security policy. A static program analysis is performed on the program, using a processor on a computer, to determine whether the program is compatible with the security specification. The program is rejected if the program is determined by the static program analysis as being incompatible with the security specification. If the program is determined during the static program analysis as compatible with the security specification under static analysis criteria, then building a call-graph representation of the program for use to evaluate any dynamically-loaded code during an execution of the program. Any paths, if any, of the call-graph representation that reach at least one policy-relevant operation is marked.

Abstract: In an example, a request is received from a runtime platform to run an instance of a software function. In response, instance code and instance data corresponding to the instance are loaded from a persistent storage, the instance code and instance data being stored together in the persistent storage. It is determined whether there is an indication that the instance code should be executed in a debug mode. In response to a determination that the instance code should be executed in the debug mode, source code is generated for the instance, based on the instance code, in a debug folder in the persistent storage; a runtime cache for the instance is invalidated; the source code for the instance is compiled into an executable file, the compiling including adding one or more breakpoints to the executable file; and the executable file is sent to the runtime platform for execution.

Abstract: A system and method can support compatibility checking in a programming language environment. The programming language environment can check whether a target type associated with an expression in the programming language environment is functional, wherein the target type is functional when it has exactly one method meeting one or more criteria that define that method as relevant in a counting system. Then, the programming language environment can derive a function descriptor from the target type, which is context-dependent. Furthermore, the programming language environment can type-check the expression with the function descriptor associated with the target type.

Abstract: Recovering structure from binaries is disclosed. A binary file having components including a plurality of linker objects is received. A cross reference map of linker objects is created. The linker objects are associated based on calls. An address space distance for each call is determined. Boundaries are defined in the cross reference map based on the address space distance. Subsets are defined as portions of the file that are separated by the boundaries.

Abstract: Enabling breakpoints on entire data structures include methods, systems, and computer program products for setting breakpoints on a plurality of memory addresses covered by a data structure. One embodiment includes receiving a reference to a data structure for which breakpoints are requested and then, based on this reference, identifying a data structure layout of the data structure. Based on the data structure layout of the data structure, a plurality of memory addresses that are covered by the data structure are identified, and the plurality of memory addresses are added to a list of breakpoints.

Abstract: A malware detection system for evaluating sample programs for malware incorporates an evasion code detector. The evasion code detector includes semantic patterns for identifying conditional statements and other features employed by evasion code. The system inserts breakpoints at conditional statements, compares expected and actual evaluated values of conditional variables of the conditional statements, and changes the execution path of the sample program based on the comparison. Changing the execution path of the sample program to an expected execution path counteracts the evasion code, allowing for the true nature of the sample program to be revealed during runtime.