1. In a computer processor executing a computer compiler, a compile-time method for interprocedurally distinguishing dynamically allocated storage locations within a computer application that is implemented within the computer compiler, comprising the steps of: a. constructing a Program Call Graph of the computer application, the Program Call Graph having a plurality of Program Call Graph nodes and edges, each Program Call Graph node representing a procedure in the computer application, the procedure having one or more statements, and each Program Call Graph edge connecting two Program Call Graph nodes, a source node being a calling Program Call Graph node and a target node being a called Program Call Graph node and a Program Call Graph edge having a forward direction from the calling Program Call Graph node to the called Program Call Graph node, each of the Program Call Graph edges having an edge name; b. constructing a representation of each procedure in the computer application, each of the procedures having a representation with an entry node, an exit node, and zero or more call site nodes, zero or more of the procedures being a calling procedure with one or more call site nodes, each call site node of the calling procedure designating a called procedure and each call site node of the calling procedure having a return point, the return point indicating a point of return of a control flow of the called procedure back to the calling procedure; c. for each procedure in the computer application, initializing an entry alias solution with an entry alias solution value for the entry node and an exit alias solution with an with alias solution value for the exit node, the entry alias solution value and the exit alias solution value capable of having zero or more names, zero or more of the names being dynamically allocated object names, each dynamically allocated object name identifying a dynamically allocated storage location; d. during an interprocedural alias analysis, performing the following steps: d1. adding all procedures in the computer application to a visit list; d2. removing one of the procedures, being a visited procedure, from the visit list; d3. identifying each statement in the visited procedure which allocates one or more of the dynamically allocated storage locations and associating each dynamically allocated storage location with a root name, the root name being all or part of the dynamically allocated object name of the respective dynamically allocated storage location; d4. performing an intraprocedural alias analysis on the visited procedure using the entry alias solution value to compute a call site alias solution value at each call site of the visited procedure and a new exit alias solution value; d5. propagating, in the forward direction, the call site alias solution value from each call site within the visited procedure to the entry node of the called procedure being called by the respective call site of the visited procedure, the call site alias solution value including zero or more of the dynamically allocated object names, the dynamically allocated object names being unchanged during this step; d6. propagating the new exit alias solution value from the exit node of the visited procedure in a backward direction to the return points of the procedures calling the visited procedure and adding the edge name of the Program Call Graph edge to each dynamically allocated object name being propagated in the backward direction; d7. repeating steps d2 through d6 while the visit list is not empty; e. repeating steps d1 through d7 until all the entry alias solution values and all the exit alias solution values do not change; f. identifying a first and a second dynamically allocated object name as identical if the first dynamically allocated object name is a substring of the second dynamically allocated object name and distinguishing a first and a second dynamically allocated storage location if the first and the second dynamically allocated object names of the respective dynamically allocated storage locations are not identical.