Hewlett-packard Development Company, L.p.

Google Inc.

Vinodha Ramasamy

Robert Hundt

Umesh Krishnaswamy

Jenn-Yuan Tsai

Eric Gouriou

Dehao Chen

Jose German Rivera

Peng Yuan

David John Babcock

Brian Fahs

Thomas Lofgren

Tara Krishnaswamy

Tom Lofgren

While optimizing executable code, compilers traditionally make static determinations about whether or not to inline functions. Embodiments of the invention convert dynamic hardware-event sampling information into context-specific edge frequencies, which can be used to make inlining decisions for functions.

Methods for handling inlined functions using sample profiles

Traditional feedback-directed optimization (FDO) is not widely used due to the significant computational overhead involved in using instrumented binaries. The described embodiments provide methods that eliminate the need for instrumented binaries by permitting the conversion of hardware-event sampling information into edge frequencies usable by FDO compilers. Some advantages include: the ability to collect feedback data on production systems; the ability to perform FDO on the OS kernel; and the ability to avoid disrupting timing paths from instrumented binaries.

Compile-time feedback-directed optimizations using estimated edge profiles from hardware-event sampling

A method and a system for examining an inlined function using a performance analysis tool are described. An inlined function is identified in computer code. Upon identification of the inlined function, and for example in response to executing a breakpoint associated with the inlined function, a performance analysis tool is used to perform desired task on the inlined function.

Method and system to analyze inlined functions

Method and apparatus for handling call stack unwinding when execution of an instrumented program is stopped in a first function of the instrumented program. When unwinding is initiated and a call to a second function of unwind software is made, the call to the second function is intercepted. The second function returns a reference to unwind information associated with the first function of the instrumented program. The unwind information includes references to locations of selected instructions in the function. If the first function of the instrumented program is instrumented with instrumentation code, then updated unwind information is created. The updated unwind information includes updated references to the locations of the selected instructions in the first function as offset by the instrumentation code. A reference to the updated unwind information is returned.

Unwinding instrumented program code

Method and apparatus for preserving program context when causing execution of a probe routine from a target routine of an executable computer program code. Executable code for the probe routine is created such that the probe routine does not reference a first set of registers that are usable by the target routine. A modified version of the target routine is created to cause execution of the probe routine. The modified version of the target routine is performed instead of the original version when the target routine is called during program execution. A second set of registers on the processor register stack is allocated when the probe routine is invoked. The second set of registers is not manipulated by the probe routine so as to avoid changing contents of registers of the register stack that are used by the target routine.

Preserving program context when adding probe routine calls for program instrumentation

The present invention, in various embodiments, is directed to techniques for providing debugging capability for program code instrumentation. In one embodiment, an instrumentor inserts an instrumentation breakpoint at the beginning of a block of original code. When this breakpoint is reached during execution of the application program that includes the block of original code, the instrumenator, from the block of original code, generates a block of instrumented code. This block of instrumented code may include debugging breakpoints that are carried from the block of original code or are inserted into the block of instrumented code during debugging. After generating the instrumented code, the instrumentor executes the instrumented code until debugging breakpoints are reached that stop the program flow, thereby allowing a programmer to perform debugging functions at these debugging breakpoints.

Providing debugging capability for program instrumented code

Method and apparatus for optimization of an executable program that calls procedures in a shared library. Code segments that read procedure address information from a linkage table are first identified. Each linkage code segment is associated with a call to a procedure in the shared library, and the address information in the linkage table is associated with the procedures in the shared library. During program execution, the address information is read from the linkage table and substitute code segments are generated for the linkage code segments. Each substitute code segment has direct loads of the address information for calling the associated procedure instead of the original references to the linkage table. Thereafter, the substitute code segments are executed instead of the linkage code segments.

Optimization of control transfers to dynamically loaded modules

Method and apparatus for instrumentation of an executable computer program that includes a predicated branch-call instruction followed by a call-shadow instruction. The predicated branch-call instruction and the call-shadow instruction is stored in a first bundle of instructions, which is followed by a second bundle. The predicated branch-call instruction is changed to a predicated branch instruction that targets a fifth bundle of instructions, and the predicate of the predicated branch instruction is the same as the predicate of the predicated branch-call instruction. Third, fourth, and fifth bundles are created to preserve program semantics. The third bundle is inserted following the first bundle and includes the call-shadow instruction. The fourth bundle is inserted following the third bundle and includes a branch instruction that targets the second bundle. The fifth bundle is inserted following the fourth bundle and includes a branch-call instruction that has a target address equal to the target address of the predicated branch-call instruction. Instrumentation instructions are then inserted.

Instrumentation of code having predicated branch-call and shadow instructions

Method and apparatus for dynamic instrumentation of an executable application program. The application program includes a plurality of functions, each function having an entry point and an endpoint. When the application is executed, a shared memory segment is created for an instrumentation program and the application program. Upon initial invocation of the original functions in the application program, corresponding substitute functions are created in the shared memory segment, the substitute versions including instrumentation code. Thereafter, the substitute functions are executed in lieu of the original functions in the application program.

Dynamic instrumentation of an executable program by means of causing a breakpoint at the entry point of a function and providing instrumentation code

Method and apparatus for handling calls from relocated instrumented functions to functions that expect a return pointer value in an original address space. In various embodiments of the invention, instrumented versions of selected functions of an executable program are generated and stored in a relocation address space. When a function is called by a function in the relocation address space, a return pointer register stores a first return-pointer value that is an address in the relocation address space. The address in the original address space that corresponds (logically) to the first return-pointer value is identified as an original return-pointer value. The first return-pointer value is associated with the original return-pointer value, references to the original return-pointer value are substituted for references to the first return-pointer value, and the instruction at the address indicated by the original return-pointer value is replaced with a breakpoint. When the breakpoint is encountered upon return of control at the original return-pointer value, the first return-pointer value that is associated with the original return-pointer value is obtained, and control is transferred to the instruction at the address referenced by the first return-pointer value.

Handling calls from relocated instrumented functions to functions that expect a return pointer value in an original address space

Method and apparatus for optimizing an executable computer program having address-bridging code segments. Various embodiments are described for optimizing an executable computer program that occupies a first address space and has address-bridging code segments. Address-bridging code segments, target code segments referenced by the address-bridging segments, and calling code segments that reference the address-bridging segments are identified during execution of the program. A second address space is allocated for storage of relocated functions. The calling code segments and the target code segments are relocated to the second address space, and references to the address-bridging code segments are replaced with references to the target code segments in the second address space. For references to the calling code segments in the first address space, control is directed to the calling code segments in the second address space.

Optimizing an executable computer program having address-bridging code segments

Method and apparatus for analysis of executable program code. The executable program includes segments of code that correspond to callable functions in the source code from which the executable code was generated. Compiler-generated checkpoint descriptors are included in the executable and include pairs of entry points and endpoints. Each pair of entry points and endpoints is associated with a callable function in the source code. The pairs of entry points and endpoints are read from the executable program code and used to generate analysis data for the associated functions. In other embodiments, pairs of entry points and endpoints are additionally assembled from dynamic load modules and symbol tables.

Analysis of executable program code using compiler-generated function entry points and endpoints with other sources of function entry points and endpoints

Techniques are disclosed for preserving first content in a first register. In one embodiment, the first register is a general register, a second register is a UNaT register, and each general register is associated with a NaT bit. To preserve the content of the UNaT register while saving the content of a general register and its associated NaT bit, the content of the general register is saved to a floating-point register, and the NaT bit associated with the general register is also saved. If the NaT bit is set, then only the NaT bit is restored. Conversely, if the NaT bit is not set, then both the content of the general register and the NaT bit are restored.

Preserving the content of a first register without affecting the content of a second register

Method and apparatus for profiling edges that pass through stub code segments in executable program code. The compilation and linking of a computer program sometimes generates stub code segments that implement the transfer of control to functions that are external to a local segment of code. Branches through the stub code segments hinder the analysis of edges relative to the source code. In various embodiments of the invention, edges are created to represent respective branch instructions in the executable program code. Each edge has a source attribute, a target attribute, and an edge-taken count attribute. During execution, the numbers of times edges are taken are counted, and stub entry points and stub targets are identified. For each edge having a target that matches an entry point of a stub code segment, the edge target is changed to the stub target associated with the matching entry point. By identifying edges that target stub code segments, edges that target stub code segments can be combined with other edges for correlation with the source code.

Growing community of inventors

Campbell, CA, United States of America

Vinodha Ramasamy