Abstract: A method and apparatus for debugging computer programs that provides means for inserting breakpoints at program logic decision points that may have caused an event to occur. Such an event may be an unexpected halt, the execution of unexpected program statements, or the assignment to a variable of an unexpected value. A Control Flow Graph (CFG) is provided that represents the possible flows through the computer program as a sequence of basic blocks. A Control Dependence Graph (CDG) is provided that maps each basic block in the computer program to those other blocks that may determine whether the first block will be executed. The information in the CFG and CDG is used to determine where the breakpoints should be set.

Abstract: Debugger impact reduction through motion of an induction variable based breakpoint (“IV-breakpoint”) set within a program loop, where the IV-breakpoint and the loop are controlled by an induction variable having an induction rate, may include extracting, from program code within the program loop, the induction rate; extracting, from the IV-breakpoint, a final value of the induction variable for which the IV-breakpoint would be satisfied; and if the IV-breakpoint is satisfied and the induction variable has a present value that would be beyond the final value upon a next iteration of the loop based on the induction rate, removing the IV-breakpoint. Debugger impact reduction may further include setting, at one or more loop exit program positions, a reset breakpoint; and if one of the reset breakpoints is satisfied, removing the reset breakpoints and/or reestablishing the IV-breakpoint.

Abstract: Method, system and article of manufacture for monitoring variables. In one embodiment, information generated by a compiler is used to determine which variables need to be updated when performing a step, a “run to cursor” operation, and when a breakpoint is hit. This may be accomplished by providing as debugger data which variables may be affected at each statement of a program and a control flow graph for the program or procedure. The information about which variables may be affected can be stored as individual variables or sets of variables. When execution of the program being debugged is halted, only those variables whose values may have changed are refreshed in a variables window of a user interface.

Abstract: A method, apparatus and article of manufacture for displaying computer program variables on a display device when debugging the computer program. In general, the executable status of variables is determined. The variables are then displayed on a display device in manner to differentiate the different executable statuses of the variables. In one embodiment, a first executable status indicates that a variable can change value when the computer program is executing. In another embodiment, a second executable status indicates that a current value of a variable may have a use.

Abstract: A first type of debugger impact reduction includes removing, from within a loop, an initial conditional breakpoint (“ICB”); extracting a first Boolean expression (“BE_1”) therefrom; setting a special conditional breakpoint (“SCB”) including the BE_1; and reestablishing the ICB if the SCB is satisfied. Optionally, the first type may further include extracting, from code within the loop, a second Boolean expression (“BE_2”); disjunctively including its complement in the SCB; and setting a reset breakpoint at loop exit program positions to remove reset breakpoints and/or the ICB. A second type includes setting the SCB with the complement of BE_1; and removing the ICB when the SCB is satisfied. Optionally, the second type may further include conjunctively including the BE_2 in the SCB; and setting a reset breakpoint to remove reset breakpoints and/or reestablish the ICB. The above may be embodied in a method, a program debugger and an article of manufacture.

Abstract: An object oriented mechanism and method allow allocating a greater number of objects on a method's invocation stack. Each instruction that creates an object (i.e., allocation instruction) is first analyzed to determine whether it is one of the following three types: no escape, global escape, and arg escape. If an allocation instruction is global escape, the object must be allocated from the heap. If an allocation instruction is no escape, it can be allocated on the method's invocation stack frame. If an allocation instruction is arg escape, further analysis is required to determine whether the object can be allocated on an invoking method's stack or must be allocated from the heap. If the method that contains an arg escape allocation instruction can be inlined into a method from which the lifetime of the object does not escape, the object can be allocated on the invoking method's stack. This inlining can be done for several layers up, if needed and possible.

Abstract: Method and system for a software debugger tool. Breakpoints are submitted, as breakpoint data, by a user. A breakpoint manager stores the breakpoint data and inserts the breakpoints into the software program code. The breakpoint manager gains control of the program when a breakpoint is processed associated with a particular job. After the breakpoint manager completes an interrupt routine to process the breakpoint, using instructions stored in the breakpoint data, the method removes breakpoints associated with the particular job. When control is to be returned to the program, only those breakpoints that are found to be useful are set.

Abstract: An object oriented mechanism and method allow allocating Java objects on a method's invocation stack in a partial compilation environment under certain conditions. Only the classes that are visible are taken into account when performing escape analysis in accordance with the preferred embodiments. In a first aspect of the invention, conservative assumptions are made to assure that objects are only allocated on an invocation stack when this can be proven safe by examining only those classes in the compilation unit. In a second aspect of the invention, the concept of visible classes is extended to include other classes that may be found from a user-defined classpath that matches the anticipated run-time classpath used to find classes during program execution. When stack allocation decisions for a method depends on such classes that are outside the compilation unit, two versions of run time code for that method are created.

Abstract: In an object-oriented or object-based computer system, a compiler mechanism allows a compiler to automatically select among multiple implementations of an object to optimize the performance of the compiled code. The selection may be made by assigning a weighted cost to each of the implementations, and selecting the implementation with the lowest weighted cost, where the weighted cost represents estimates of execution frequencies for each of the object's functions. In the alternative, for implementations that have different interfaces, the selection may be made based on an evaluation of the functions used in the program compared to the functions provided by the different implementations, and selecting an implementation that contains all functions issued against the object with a minimum of functions that are not issued against the object.

Abstract: The data cache management mechanism of the present invention is created by an optimizing compiler. The optimizing compiler intelligently places non-blocking preload instructions into the instruction stream of the computer system so as to minimize both the frequency and detrimental effect of cache misses. The non-blocking preload instructions are placed into the instruction stream based on the existence of predictor constructs that foretell what information the processor will need and when it will need it. As a result, cache misses are either avoided entirely or reduced in severity.

Abstract: A profiler that operates in a multi-stage environment is disclosed. As program code undergoes a series of transformations, branches of interest are selected and tracked. Regardless of how many transformations are involved only a single instrumentation/data gathering phase is required. The gathered profile data is then used to perform various optimizations at the differing transformation stages.

Abstract: An instruction scheduler in an optimizing compiler schedules instructions in a computer program by determining the lifetimes of fixed registers in the computer program. By determining the lifetimes of fixed registers, the instruction scheduler can achieve a schedule that has a higher degree of parallelism by relaxing dependences between instructions in independent lifetimes of a fixed register so that instructions can be scheduled earlier than would otherwise be possible if those dependences were precisely honored.

Abstract: A compiler system and method is provided that can 1) generate a second instruction stream from a first instruction stream, 2) read in and process predetermined external information regarding the basic blocks that makes up the second instruction stream and 3) place certain of the basic blocks on cache line boundaries based on predicted execution frequencies. In particular, the compiler system and method utilize profile information containing predicted block execution or edge-weight execution frequencies to determine which of the basic blocks to align on cache line boundaries. One method for obtaining profile information includes precompiling the source code, creating an executable program, executing the program with test inputs, and outputting a profile containing execution frequency information. Once the profile information is obtained, the source code can then be recompiled using the profile information. The compiler can then selectively cache align those blocks identified as important.

Abstract: A method and computer program product are provided for implementing adaptive inlining in a computer system. Call sites in a call multigraph are identified for possible inlining. A first approximation of initial call sites of the identified possible call sites are identified for inlining. Procedures in the call multigraph are processed in a determined order where a first procedure is only processed after all second procedures called by the first procedure are processed. The processing of the first procedure comprises the steps of determining whether any call site within the first procedure has been selected for inlining, and whether the second procedure called from the call site contains confirmed inlined call sites. If true, it is determined whether to confirm or reject the first approximation to inline the second procedure into the first procedure at the call site utilizing at least one predetermined criterion.

Abstract: A computer implemented method and computer program compiler product are provided for implementing method calls in a computer system. Virtual method calls are identified in an intermediate instruction stream representation. Responsive to an identified virtual method call, profile data for the identified call site are read. A most frequently called procedure for the identified call site is compared with a first threshold value. Responsive to the most frequently called procedure being called less than the first threshold value, the virtual method call is maintained in a revised instruction stream representation. Responsive to the most frequently called procedure being called greater than or equal to the first threshold value, a guarded call to the most frequently called procedure is inserted at the identified call site in the revised instruction stream representation.

Abstract: A compiler and method of compiling provide enhanced performance by utilizing a skip list data structure to store various properties of a program at points of interest in the procedure, for example, the properties of the statements in each block in the control flow graph. A special procedure is used to initialize the skip list, prior to performing data flow analysis, to ensure that the skip list structure is not used in an inefficient manner as a result of initialization. Furthermore, special procedures are used to simultaneously scan and compare two skip lists as part of solving dataflow equations.

Abstract: A compiler and method of compiling provide enhanced performance by inlining one or more frequently executed paths through a child procedure into a parent procedure without inlining the entire child procedure. Accordingly, a substantial improvement in speed of execution of the program can be achieved by reducing procedure call overhead, with reduced expense in terms of program size as compared to traditional inlining. Various criteria for determining whether to inline particular child procedures are also described.

Abstract: An apparatus and method reorder portions of a computer program in a way that achieves both enhanced performance and maintainability of the computer program. A global call graph is initially constructed that includes profile data. From the information in the global call graph, an intramodular call graph is generated for each module. Reordering techniques are used to reorder the procedures in each module according to the profile data in each intramodular call graph. An intermodular call graph is generated from the information in the global call graph. Reordering techniques are used to reorder the modules in the computer program. By reordering procedures within modules, then reordering the modules, enhanced performance is achieved without reordering procedures across module boundaries.

Abstract: An apparatus and method provide more complete profile data by instrumenting indirect procedure calls in a computer program. Indirect procedure calls have a number of counters allocated in a table at each indirect call site. The counters are divided into counters in a low volatility area and counters in a high volatility area. The counters in the high volatility area have a pointer that identifies the next procedure to be replaced. As the instrumented code executes, a call to a procedure that is in the table increments the count of the counter in the table. A call to a procedure not in the table is placed in the high volatility area, displacing the procedure at the pointer, and moves the pointer to a new location. The displaced procedure is either promoted to the low volatility area, or is discarded. If promoted, the procedure that it displaces in the low volatility area is demoted to the high volatility area, displacing a procedure there at the pointer (and moving the pointer to a new location).

Abstract: Historically, graphics editors, text editors, presentation editors, and word processors provide a number of special processing functions that operate on a presented object as a whole. For word processors, these special functions might include: spelling checks, style (grammar) checks, hyphenation, and pagination. The present invention provides a transparent mechanism for making these special processing functions incremental, in the sense that the mechanisms re-process only those portions of presented objects that have changed since the last time the function was performed.