This paper reports on the design, implementation, and empirical results of a new method for dealing with the aliasing problem in C. The method is based on approximating the points-to relationships between accessible stack locations, and can be used to generate alias pairs, or used directly for other analyses and transformations. Our method provides context-sensitive interprocedural information based on analysis over invocation graphs that capture all calling contexts including recursive and mutually-recursive calling contexts. Furthermore, the method allows the smooth integration for handling general function pointers in C. We illustrate the effectiveness of the method with empirical results from an implementation in the McCAT optimizing/parallelizing C compiler.

No abstract

No abstract

This manuscript has been reproduced from the microfilm master. UMI films the text directly from the original or copy submitted. Thus, some thesis and dissertation copies are in typewriter face, while others may be from any type of computer printer.The quality of this reproduction is dependent upon the quality of the copy submitted. Broken or indistinct print, colored or poor quality illustrations and photographs, print bleedthrough, substandard margins, and improper alignment can adversely affect reproduction.In the unlikely event that the author did not send UMI a complete manuscript and there are missing pages, these will be noted. Also, if unauthorized copyright material had to be removed, a note will indicate the deletion.Oversize materials (e.g., maps, drawings, charts) are reproduced by sectioning the original, beginning at the upper left-hand corner and continuing from Left to right in equal sections with small overlaps.Photographs included in Uie original manuscript have been reproduced xerographically in this copy. Higher quality 8" x 9" black and white photographic prints are available for any photographs or illustrations appearing in this copy for an additional charge. Contact UMI directly to order. The author retains ownership of the L'auteur conserve la propriete du copyright in this thesis. Neither the droit d'auteur qui protege cette these. thesis nor substantial extracts fiom it Ni la these ni des extraits substantiels may be printed or otherwise de celle-ci ne doivent Etre imprimes reproduced without the author's ou autrement reproduits sans son permission.autorisation. AbstractPointer analysis has recently been a subject of active research. The focus of most techniques is on: (1) estimating the targets for stack-directed pointers, (2) computing relationships between heap-directed pointers, or (3) developing faster or more space-efficient algorithms. However, little at tention has been paid to actually using the results of pointer analysis for compiler optimizations. This thesis addresses the problem of how to apply pointer analysis information to a wide variety of compiler applications. That is, once the pointer relationships are computed, what can we do with this information? How do we put pointer analysis to work?We have used the pointer andyses implemented in the framework of the McCAT C compiler as the basis of our study. These analyses include, points-to analysis for stackdirected pointers, and connection and shape analyses for heap-directed pointers. We demonstrate that the fundamental problem is that one must be able to compare the memory locations readlwritten via pointer indirections, at different programs points, and one must also be able to summarize the effect of pointer references over regions in the program. It is straightforward to compute readlwrite sets for indirections involving stack-directed pointers using points-to information. However, for heapdirected pointers we show that one needs to introduce the notion of anchor handles into the connection analysis and then compute re...

Abstract. In this paper we present techniques to detect three common patterns of parallelism in C programs that use recursive data structures. These patterns include, function calls that access disjoint sub-pieces of tree-like data structures, pointer-chasing loops that traverse list-like data structures, and array-based loops which operate on an array of pointers pointing to disjoint data structures. We design dependence tests using a family of three existing pointer analyses, namely points-to, connection and shape analyses, with special emphasis on shape analysis. To identify loop parallelism, we introduce special tests for detecting loop-carried dependences in the context of recursive data structures. We have implemented the tests in the framework of our McCAT C compiler, and we present some prehminary experimental results. I n t r o d u c t i o n a n d M o t i v a t i o nThis paper focuses on detecting three common patterns for parallel computations that use recursive data structures: (1) function-call parallelism including parallel recursive calls on tree-like structures; (2) forall parallelism for loops traversing arrays of list/tree-like structures; and (3) foreach parallelism for loops traversing list/tree-like structures, which is similar to doacross parallelism.In order to safely detect these patterns of parallelism in C programs, one must deal with dependences due to scalars, dependences due to pointers to stackallocated objects (stack-directed pointers), and dependences due to pointers to heap-allocated objects (heap-directed pointers). Thus, our approach uses the results of the family of pointer analyses that have been implemented in the McCAT optimizing/parallelizing C compiler: points-to analysis [l], connection analysis [2] and shape analysis [3]. Points-to analysis is used to detect dependences due to scalars and stack-directed pointers, while connection and shape analysis are used to detect dependences due to heap-directed pointers.The main focus of this paper is not the pointer analyses themselves, but rather how we can use the results of the analyses to detect parallelism. The remainder of the paper is structured as follows. In Section 2 we introduce the three parallelism patterns in more detail. In Section 3 we describe the overall setting of our approach, and present the rules to detect function call parallelism. * This research supported in part by NSERC and FCAR.