Interprocedural data-flow analysis that supports recursion while only performing one flow-sensitive analysis of each procedure

In a computer processor executing a computer compiler, a computer implemented method for performing interprocedural data flow analysis over a program call graph (PCG) that supports recursion, while performing only one flow-sensitive analysis of each routine, comprising the steps of:

• a. constructing the PCG of a computer application program, the PCG having a plurality of PCG nodes and PCG edges, each PCG node representing a procedure P in the computer application program and each PCG edge representing a procedure call site and connecting two nodes, a procedure call site being a statement in a program that invokes a procedure, a source node being a calling PCG node and a target node being a called PCG node and a PCG edge having a direction from the calling node to the called node, and some of the edges possibly being back edges;
• b. identifying any back edges of the PCG;
• c. performing a flow-insensitive interprocedural data flow analysis if there are back edges of the PCG;
• d. for each call site represented by a back edge, initializing a set representing a data flow value to the results of the flow-insensitive interprocedural data flow analysis solution of step c;
• e. for each procedure P in the PCG, performing the following steps in a forward topological traversal of the PCG:
• e1. for each call site that invokes P, examining the set of data flow values and propagating the result to an entry of P, and
• e2. performing a flow-sensitive intraprocedural data flow analysis of P and recording data flow values of the result at each call site within P;
• f. when the forward topological traversal of the PCG is completed, then for each procedure P, performing the following steps in a reverse topological traversal of the PCG:
• f1. propagating the data flow values at an exit of each procedure that is called from within P to the corresponding call site within P, and
• f2. performing a flow-sensitive intraprocedural data flow analysis of P and recording the data flow values of the result at the exit of P.

In a computer processor executing a computer compiler, a computer implemented method for determining upward exposed use (USE) for a computer program application which comprises the steps of:

• a. constructing a Program Call Graph (PCG) of the computer program application, the PCG having a plurality of PCG nodes and edges, each PCG node representing a procedure P in the computer program and each PCG edge representing a procedure call site and connecting two PCG nodes, a procedure call site being a statement in a program that invokes a procedure, a source node being a calling PCG node and a target node being a called PCG node and a PCG edge having direction from the calling node to the called node, and some of the edges possibly being back edges;
• b. computing a set of variables that are in a Reference set (REF) for each procedure through a flow-insensitive interprocedural REF analysis of the program application;
• c. computing the upward exposed use (USE) of a procedure for each procedure, P, in a reverse topological order with the following steps:
• c1. computing the USE set for P by performing an introprocedural flow-sensitive def-use analysis of procedure P, providing for each call site within P either the previously computes USE set for the called procedure or the REF set computed in step b for the called procedure where the USE set of the called procedure has not yet been computed;
• and
• c2. noting that the USE set has been computed for procedure P and recording the computed USE set for P so that it is available during the flow-sensitive intraprocedural def-use analysis of each call site where procedure P is called.

In a computer processor executing a computer compiler, a computer implemented for determining interprocedural constants for a computer program application which comprises the steps of:

• a. constructing a Program Call Graph (PCG) of the computer program application, the PCG having a plurality of PCG nodes and edges, each PCG node representing a procedure P in the computer program and each PCG edge representing a procedure call site and connecting two PCG nodes, a procedure call site being a statement in a program that invokes a procedure, a source node being a calling PCG node and a target node being a called PCG node and a PCG edge having a direction from the calling node to the called node, and some of the edges possibly being back edges;
• b. initializing a set of arguments and a set of global variables that are constant at each call site within the program with results of a flow-insensitive interprocedural constant propagation analysis;
• c. computing constant formal parameters and global variables for each procedure, P, in topological order, by
• c1. examining the set of constant arguments and constant global variables for each call site that invokes P with the following steps using sets initialized by the flow-insensitive solution for back edges when a flow-sensitive solution is not available:
• c11. if all of the arguments that are passed to a particular formal parameter P have the same constant value at each call site that invokes P, propagate the constant to the formal parameter at the entry of procedure P;
• c12. if a global variable has the same constant value at each call site that invokes P, propagate the global constant to the entry of procedure P;
• c2. performing a flow-sensitive intraprocedural constant propagation of P, with the following steps, updating the sets of constant arguments and global variables that were initialized with the flow-insensitive solution:
• c21. if a constant is used as an argument, record the argument as constant in the set of constant arguments for this call site within procedure P;
• c22. if a global constant at a call site is in the Reference set for the called procedure, then record the global constant as constant in the set of constant global variables for this call site within procedure P.

In a computer processor executing a computer compiler, a computer implemented method for determining interprocedural constants for a computer program application which comprises the steps of:

• a. constructing a Program Call Graph (PCG) of the computer application, the PCG having a plurality of PCG nodes and PCG edges, each PCG node representing a procedure P in the computer program and each PCG edge representing a procedure call site and connecting two PCG nodes, a procedure call site being a statement in a program that invokes a procedure, a source node being a calling PCG node and a target node being a called PCG node and a PCG edge having a direction form the calling node to the called node, and some of the edges possibly being back edges;
• b. initializing a set of arguments and a set of global variables that are constant at each call site within the program with results of a flow-insensitive interprocedural constant propagation analysis;
• c. initializing the set of returned constants to the flow-insensitive solution;
• d. computing the constant formal parameters and global variables for each procedure, P, in topological order by
• d1. examining the set of constant arguments and constant global variables for each call site that invokes P with the following steps using sets initialized by the flow-insensitive solution for back edges when a flow-sensitive solution is not available:
• d11. if all of the arguments that are passed to a particular formal parameter of P have the same constant value at each call site that invokes P, propagate the constant to the formal parameter at the entry of procedure P;
• d12. if a global variable has the same constant value at each call site that invokes P, propagate the global constant to the entry of procedure P;
• d2. performing a flow-sensitive intraprocedural constant propagation of P with the following steps, updating the sets of constant arguments and global variables that were initialized with the flow-insensitive solution:
• d21. if a constant is used as an argument, record the argument as constant in the set of constant arguments for this call site with procedure P;
• d22. if a global constant at a call site is in a Reference set (REF) for the called procedure, then record the global as constant in the set of constant global variables for this call site within procedure P;
• e. computing the set of returned constant parameters and global variables for each procedure, P, in a reverse topological order with the following steps:
• e1. propagating the returned constant set of each procedure that is called from P to the return point of the call site;
• e2. performing a flow-sensitive intraprocedural constant propagation of P, adding each formal parameter and global variable that is constant at the exit of procedure P and is in the union of the REF of the procedures that call P to the returned constant set of P.