J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the 20th Annual ACM Symposium on Principles of Programming Languages (POPL'93), pages 232--245. ACM, 1993.  Home/Search   Document Details and Download   Summary   Related Articles   Check

....describing its calling context and information out of a procedure describing its side effects. Three basic strategies have been used to avoid propagating information along unrealizable paths: 1) data flow sets are tagged with path history information that describes the path taken to derive a set [14, 45, 48, 30]; 2) data flow sets are tagged with some other identifying information related to a specific calling context [38] or (3) a side effect computation is performed, ignoring calling context [10] The third alternative avoids the unrealizable path problem entirely but cannot be applied to every ....

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the Twentieth Annual Symposium on Principles of Programming Languages. ACM, Jan. 1993.

....4 Y: Pl.Int Pointer; 5 begin 6 if False then 7 Y : X; 8 end if; 9 P1.Do It (X) 10 P1.Do It (P1.V access) 11 end Main; Fig. 3. Procedure Body Main the False condition 3 in line 6. This fact is handled correctly by our data flow framework. For that reason we differ from e.g. [6] where the above case would introduce a so called may alias. It is shown in [3] how our framework can be exploited for reaching definition analysis where we can detect if Y was referenced somewhere in the code. Do It XExit X 1 = xE.tr I (A,A ( P, P, p(A, P) 1) V, V) 1) I, ....

J. D. Choi, M. Burke, and P. Carini. Efficient Flow-Sensitive Interprocedural Computation of Pointer-Induced Aliases and Side Effects. ACM PoPL, 1/93:232- 245, 1993.

....internal model is able to capture information related to the computational elements present in an imperative, possibly objectoriented, specification and the relationship between them. Such a model, called Procedural Interaction Graph (PIG) is based on the Procedural Call Graph (PCG, [5]) Moreover, to enhance generality, the exchange format of the model is based on the VCG format [4] a third party format that can be managed and visualized with open source tools. 2.2. Co analysis and Co estimation The first step of the flow aims at obtaining as much information as possible on ....

J. Choi, M. Burke, P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In proceedings of the 20th Annual ACM Symposium on Principles of Programming languages, pp. 233-245, January 1993.

....are a useful and powerful feature, they also make programs hard to understand, and often prevent an optimizing compiler from making code improving transformations. In an attempt to compensate for these negative effects, many pointer analysis algorithms have been devised over the past decade [1,3,4,6,7,10,11,16,18,19,20]. These algorithms try to give a conservative approximation of the possible sets of variables, data structures, or functions a particular pointer could point to at a specific program point; these are referred to as points to sets. These sets can be used, for instance, by an optimizing compiler to ....

. D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 2oth Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages, pages 232-245, Jan. 1993.

....uses the term intra procedural to mean context insensitive and the term inter procedural to mean context sensitive . is the size of the program s . In contrast, the size of the solution of our algorithm is O(N) Choi et al. present both flow sensitive and flow insensitive analyses [CBC93]. The flow insensitive analysis algorithm is described in more detail in [BCCH95] Their algorithm computes alias information rather than points to information but uses a representation that shares many properties with the storage shape graph. The rep resentation allows abstract locations to be ....

Jong-Deok Choi, Michael Burke, and Paul Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Proceedings of the Twentieth Annual ACM S1GPLAN-S1GACT Symposium on Principles of Programming Languages, pages 232 245, Charleston, South Carolina, January 1993.

....relationship between any two variables. Although a knowledge of variable scope can cut down the number of dependency pairs, the assumption is still too strong for dependency analysis to derive an accurate relationship. Several methods of alias analysis and point to analysis have been proposed [12, 6, 19, 2, 20]. By using these methods, one can compute a points to set for each variable. The points to analysis is beyond the scope of this paper, and we assume that a points to set for each variables could be obtained via this analysis. The main concern of this paper is how to use the points to sets to build ....

J. Choi, M. Burke, P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In ACM-20th PoPL, 1993.

....and Practice in Information Technology, Vol. 4. Michael Oudshoom, Ed. Reproduction for academic, not for profit purposes permitted provided this text is included. Andrew L Wendelborn Department of Computer Science University of Adelaide, SA 5005 andrew as .adelaide. edu. au Some research [BCC97, CBC93, CR97, CS95, EGH94, PR94, PR95, WWG00] has analyzed aliases statically for high performance computing such as parallelizing compiler as well as compiler optimization. Those works proposed alias analyses for C C by representing the alias relation with pointers and pointer to pointer objects. However, the representation of alias ....

....5 AHas Analysis Algorithm Our alias analysis algorithm in Figure 6 visit all nodes of a CG until Lxed data status and nodes are achieved. The algorithm traverses each node ofa CG in a topological and a reverse topological order in order to possibly shorten the execution time for the Lxed point [CBC93, CS95, BCC97]. The set TYPES represents the possible class types for a callee to build a safe CG. TYPESuu(r) is a set of dynamic types of a reference variable r in a type table. While processing the algorithm, resolved methods with the possible class types of each reference make the CG grow. Each node in our ....

[Article contains additional citation context not shown here]

J. Choi, M. Burke, and P. Carini. Efficient Flow-Sensitive Interprocedural Computation of Pointer-Induced Aliases and Side Effects. The 20th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, 232-245, January 1993.

....int p2,a2; called( p2, a2) void called(int pp,int p) Figure 5 Pointer mixing 3 Related Work The literature contains a number of papers on pointer analysis that are related to our own work. We will consider work by five specific groups: Landi and Ryder[15, 16] Choi t a . [5], Hendren t a . 9] Wilson and Lam[22] and Ruf[20] The following sections summarize their individual approaches and describe their position relative to the issues raised in the previous section. Both Landi and Ryder, and Choi analyze alias pairs. Landi and Ryder simplify their analyzer by ....

Jong-Deok Choi, Michael Burke, and Paul Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. Conference Record of the Twentieth Annual A CM 'ymposium on Principles of Programming Languages, 19(6):232 245, January 1993.

....and dependence analysis are fundamental components of optimizing and parallelizing compilers. Although traditionally studied in the context of Fortran or block structured languages [1, 2, 8, 9] there has been increasing interest in providing accurate alias and side effect analysis for C programs [7, 31]. Solving these problems for C rather than Fortran leads to many interesting and difficult problems including the treatment of the address of operator (i.e. a) which can create new pointer relationships at any program point, multi level pointer references (i.e. a) which enable the called ....

.... One traditional solution to this problem has been to include some context information in the abstraction being calculated [27] Typical examples of this approach include: memory components [34] procedure strings [18, 19] assumed alias sets [30] and source alias sets with the last call site [7]. Rather than embedding the context in the abstraction being estimated, we have chosen to follow a different strategy where we explicitly represent all invocation paths in an invocation graph. In the case of programs without recursion, the invocation graph is built by a simple depth first ....

[Article contains additional citation context not shown here]

J. D. Choi, M. G. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Conference Record of the Twentieth Annual ACM Symposium on Principles of Programming Languages, pages 232--245, January 1993.

....subscript. For an explictly named array (say, e t ) the base expression is an address of the variable ( e ) while for an array accessed through a pointer, it represents the value of the pointer. The compiler performs flow sensitive, context sensitive, interprocedural pointer analysis [3], which is used to provide aliasing information to array section analysis. If an array is aliased with another variable, an access to that aliased variable is regarded as potentially touching any part of the given array. The subscript information for a multidimensional array, which appears to the ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages, pages 232--245, January 1993.

....statement order, they trivially model all of the interleavings of the parallel executions. 10.1. 1 Flow Sensitive Analyses Flow sensitive analyses take the statement ordering into account, typically using a dataflow analysis to produce a pointsto graph or set of alias pairs for each program point [25, 22, 28, 18, 10, 20]. One approach analyzes the program in a topdown fashion starting from the main procedure, reanalyzing each potentially invoked procedure in each new calling context [28, 18] This approach exposes the compiler to the possibility of spending significant amounts of time reanalyzing procedures. It ....

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Conference Record of the Twentieth Annual Symposium on Principles of Programming Languages, Charleston, SC, January 1993. ACM.

....optimized for that access pattern [9] 6 Related Work We discuss two areas of related work: pointer analysis for sequential programs, and the analysis of multithreaded programs. 6. 1 Pointer Analysis for Sequential Programs Pointer analysis for sequential programs is a relatively mature field [22, 23, 19, 25, 1, 8, 6, 15]. We classify analyses with respect to two properties: flow sensitivity and context sensitivity. Flow sensitive analyses take the statement ordering into account, and typically use dataflow analysis to produce a points to graph or set of alias pairs for each program point [19, 25, 8, 6, 15] ....

....23, 19, 25, 1, 8, 6, 15] We classify analyses with respect to two properties: flow sensitivity and context sensitivity. Flow sensitive analyses take the statement ordering into account, and typically use dataflow analysis to produce a points to graph or set of alias pairs for each program point [19, 25, 8, 6, 15]. Flow insensitive analyses, as the name suggests, do not take statement ordering into account, and typically use some form of constraint based analysis to produce a single points to graph that is valid across an entire analysis unit [1, 23, 22, 17] The analysis unit is typically the entire ....

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Conference Record of the Twentieth Annual Symposium on Principles of Programming Languages, Charleston, SC, January 1993. ACM.

....unless the dataflow information accounts for the effects of aliases 1 caused by reference parameters and pointer variables. Some techniques for interprocedural analysis[3] represent all invocation paths in the program, causing them to be potentially exponential in time and space. Other techniques[1, 2, 6, 7] use some type of summary information to avoid potential exponential growth, but with some loss of precision. However, all of these techniques require a complete program on which to perform the analysis, which for large systems may be prohibitive in both time and space. Software engineering ....

.... execution of N declare G : an interprocedural control flow graph (ICFG) CondMayAlias : set of [ N; AA) PA] where PA may be aliased at the end of N if AA is aliased at the entry to the procedure containing N W orklist : list of [ N; AA) PA] initially empty begin [1] Construct ICFG G [2] foreach N in G do compute conditional may alias introductions [3] if N is a call statement or an assignment to a pointer then [4] add conditional may aliases introduced by N to W orklist and CondMayAlias [5] while W orklist is not empty do compute conditional may aliases [6] ....

[Article contains additional citation context not shown here]

J-D. Choi, M. Burke, and P. Carini. Efficient flowsensitive interprocedural computation of pointerinduced aliases and side effects. Proceedings of the 20th Annual ACM Symposium on Principles of Programming Languages, pages 232--245, January 1993.

....variable that can be accessed from another procedure in a call or return. Techniques have been developed to analyze pointers both intra procedurally and inter procedurally to provide more accurate information on what is affected by them so as to limit their ill effects on program optimizations [CWZ90, CBC93, Ruf95, WL95]. To characterize the effects of aliasing, we distinguish between two types of definitions of a variable: MustDef and MayDef. 2 Since a MustDef must redefine the variable, it blocks the references of previous definitions from that point on. A MayDef only potentially redefines the variable, and ....

Choi, J., Burke, M. and Carini, P. Efficient Flow-Sensitive Interprocedural Computation of Pointer-Induced Aliases and Side Effects. Conference Record of the 20th ACM Symposium on the Principles of Programming Languages, Jan. 1993.

....we have: DataMembers(P 2) j f x; y; z g VirtualMethods(P 2) j f f; g g 2.3 Points to analysis We will need for each pointer to class typed variable a conservative approximation of the set of class typed variables that it may point to in some execution of P . Any of several existing algorithms [7, 6, 16, 21, 19]) can be used to compute this information, and we do not make assumptions about the particular algorithm used to compute points to information. Definition 2.4 uses the information supplied by some points to analysis algorithm to construct a set PointsTo(P) which contains a pair hp; vi for each ....

CHOI, J.-D., BURKE, M., AND CARINI, P. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In ConferenceRecord of the Twentieth ACM Symposiumon Principles of Programming Languages (1993), ACM, pp. 232--245.

....understanding, particularly for programmers reading code which they did not write. Our focus in this paper is on the efficient and practical solution of the pointer aliasing problem to facilitate these applications. Many techniques for compile time pointer aliasing analysis have been proposed [3, 4, 6, 7, 8, 9, 11, 14, 15, 22, 26, 27, 32, 36, 37, 39, 40]. Some of them are more appropriate for aliases involving accesses to heap locations [6, 8, 11, 14, 15, 26, 36] others for aliases involving accesses to stack locations [9, 39] Still others handle both in a similar fashion [3, 4, 7, 22, 27, 32, 37, 40] All of these methods vary in the precision ....

.... proposed [3, 4, 6, 7, 8, 9, 11, 14, 15, 22, 26, 27, 32, 36, 37, 39, 40] Some of them are more appropriate for aliases involving accesses to heap locations [6, 8, 11, 14, 15, 26, 36] others for aliases involving accesses to stack locations [9, 39] Still others handle both in a similar fashion [3, 4, 7, 22, 27, 32, 37, 40]. All of these methods vary in the precision of the aliasing information calculated and their cost. For compile time pointer aliasing analysis, a program can be considered a sequence of assignments having effects on pointer aliasing; we call them pointer related assignments. In this paper, we ....

[Article contains additional citation context not shown here]

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of te 20th ACM Symposium on Principles of Programming Languages, pages 232--245, January 1993.

....for variables, since it must deal not only with an unbounded number of paths through the program, like traditional data flow analyses, but it must handle an unbounded number of paths through an unbounded collection of data. Many algorithms for alias analysis have been suggested in the literature [9, 14, 26, 29, 25, 45, 62, 68, 69, 72, 96, 111, 112] , and the key difference between the algorithms stem from where and how they approximate the unbounded control paths and data (Chapter 9) The approximation determines the precision and efficiency of the algorithm. Indeed, alias analyses proposed in the literature range from precise ....

....the algorithm. Indeed, alias analyses proposed in the literature range from precise exponential time algorithms to less precise nearly linear time algorithms. Despite the plethora of available alias analysis algorithms, the tradeoffs between the different techniques are not understood. Prior work [9, 14, 26, 29, 25, 45, 68, 69, 72, 96, 111] , with two exception [62, 112] uses static metrics (if anything at all) to evaluate alias analysis. Static metrics are insufficient for evaluating an analysis since they do not measure the impact of the analysis on performance. Also, the evaluation in prior work does not measure if there is room ....

[Article contains additional citation context not shown here]

Choi, J.-D., Burke, M., and Carini, P. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the Twentieth Annual ACM SIGACT/SIGPLAN Symposium on Principles of Programming Languages, pages 232--245, Charleston, SC, Jan. 1993.

....which avoids the code growth, but is limited by the program s original calling structure, in particular, making conservative assumptions at the convergence of paths in the call graph. 2.3. 1 Interprocedural Data Flow Analysis There exists much research on interprocedural data flow analysis [9, 11, 13, 18, 30, 33, 37, 43, 44, 63] for aliasing, side effect analysis, constant propagation, program slicing, and other uses. These techniques involve performing an analysis of the whole program code, gathering information about conditions across procedural boundaries. For example, variable definitions and uses may be tracked as ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In ACM SIGPLAN Symposium on the Principles of Programming Languages, pages 232--245, Charleston, South Carolina, Jan. 1993. 31

....can prove to itself that there are no data dependences (and of course no control dependences) then the operations can be executed in parallel. Significant progress has been made on well defined sub problems: Array based data dependence analysis [29, 239] and pointer or alias analysis techniques [30, 76, 142, 149] are used in various phases of compiler optimizations and to parallelize sequential code: target architectures are parallel machines, vector computers, and processors with instruction level parallelism. A good survey of the relevant techniques can be found in [23] Everybody can convince himself ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Proc. of the 20th ACM Symp. on Principles of Programming Languages, pages 232--245, Charleston, SC, January 1993.

....compiler (Section 5.4) 5.1 Metrics We evaluate TBAA with respect to RLE and method resolution using static and dynamic metrics, and a limit analysis. The majority of previous work on alias analysis [Banning 1979; Burke et al. 1994; Hind et al. 1999; Chatterjee et al. 1999; Chase et al. 1990; Choi et al. 1993; Cooper and Kennedy 1989; Deutsch 1994; Emami et al. 1994; Landi and Ryder 1991; 1992; Larus and Hilfinger 1988; Shapiro and Horwitz 1997b; Steensgaard 1996; Weihl 1980] uses only static properties, such as the size of the may alias and pointsto sets. A few researchers recently have used dynamic ....

....must consider an unbounded number of paths through an unbounded collection of data, and is therefore harder than traditional data flow analyses. The literature contains many algorithms for alias analysis [Banning 1979; Burke et al. 1994; Hind et al. 1999; Chatterjee et al. 1999; Chase et al. 1990; Choi et al. 1993; Cooper and Kennedy 1989; Deutsch 1994; Emami et al. 1994; Landi and Ryder 1991; 1992; Larus and Hilfinger 1988; Shapiro and Horwitz 1997b; Steensgaard 1996; Weihl 1980; Cooper and Kennedy 1989; Hummel et al. 1994; Cooper and Lu 1997; Larus and Hilfinger 1988; Wilson and Lam 1995] The key ....

[Article contains additional citation context not shown here]

CHOI, J.-D., BURKE, M., AND CARINI, P. 1993. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Conference Record of the Twentieth Annual ACM SIGACT/SIGPLAN Symposium on Principles of Programming Languages. Charleston, SC, 232--245.

....information for rle. 4. RESULTS This section evaluates type based alias analysis and method resolution analyses using static and dynamic metrics, and a limit analysis. The majority of previous work on alias analysis [Banning 1979; Burke et al. 1994; Chatterjee et al. 1999; Chase et al. 1990; Choi et al. 1993; Cooper and Kennedy 1989; Deutsch 1994; Emami et al. 1994; Landi and Ryder 1991; 1992; Larus and Hilfinger 1988; Shapiro and Horwitz 1997b; Steensgaard 1996; Weihl 1980] evaluates alias analysis using only static properties, such as the sizes of the may alias and points to sets. A few researchers ....

....Alias analysis must consider an unbounded number of paths through an unbounded collection of data, and is therefore harder than traditional data flow analyses. The literature contains many algorithms for alias analysis [Banning 1979; Burke et al. 1994; Chatterjee et al. 1999; Chase et al. 1990; Choi et al. 1993; Cooper and 7 Only virtual functions may be overridden in subtypes. Using Types to Analyze and Optimize Object Oriented Programs Delta 35 Kennedy 1989; Deutsch 1994; Emami et al. 1994; Landi and Ryder 1991; 1992; Larus and Hilfinger 1988; Shapiro and Horwitz 1997b; Steensgaard 1996; Weihl ....

[Article contains additional citation context not shown here]

Choi, J.-D., Burke, M., and Carini, P. 1993. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the Twentieth Annual ACM SIGACT/SIGPLAN Symposium on Principles of Programming Languages. Charleston, SC, 232--245.

....decomposition [2] All of this work targeted the programming model of Fortran and related languages with no pointer usage. Choi, Burke, and Carini mention an interprocedural modificationside effects algorithm for languages with pointers based on their flow sensitive pointer aliasing technique [3, 12]; it is difficult to compare this work to theirs, because they gave no description of their algorithm and offered no implementation results. Another approach to side effect analysis is to perform an interprocedural pointer aliasing algorithm and then identify all variables experiencing side ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the Twentieth Annual ACM SIGACT/SIGPLAN Symposium on Principles of Programming Languages, pages 232-- 245, Jan. 1993.

....if either reference is a write. This assumption is true for Fortran 90 and Fortran 77 programs, but may be false for C programs. Before performing array data flow analysis on C programs, alias analysis must first be performed. Alias analysis has been studied extensively in recent literature [8, 11, 14, 27, 28, 39, 44, 45]. 16 5 Effectiveness and Efficiency In this section, we first discuss how GAR s are used for array privatization and loop parallelization. We then present experimental results to show the effectiveness and efficiency of array data flow analysis. 5.1 Array Privatization and Loop ....

J.-D. Choi, M. Burke and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. Proc. of the 20th Annual ACM Symposium on Principles of Programming languages, pp. 232--245, January 1993.

....4 Y: P1.Int Pointer; 5 begin 6 if False then 7 Y : X; 8 end if ; 9 P1.Do It(X) 10 P1.Do It(P1.V access) 11 end Main; Fig. 3. Procedure Body Main the False condition 3 in line 6. This fact is handled correctly by our data flow framework. For that reason we differ from e.g. [6] where the above case would introduce a so called may alias. It is shown in [3] how our framework can be exploited for reaching definition analysis where we can detect if Y was referenced somewhere in the code. Do It XExit = X 1 = XEntry j f(A; A Phi ( P; P; ae(A; P ) 1) Phi (V; V; ae(A; ....

J. D. Choi, M. Burke, and P. Carini. Efficient Flow-Sensitive Interprocedural Computation of Pointer-Induced Aliases and Side Effects. ACM PoPL, 1/93:232-- 245, 1993.

.... of this paper are the following: ffl empirical results that measure the precision and efficiency of five pointer alias analysis algorithms with varying degrees of flow sensitivity and alias data structures: Address taken, Steensgaard [34] Andersen [1] Burke et al. 4, 12] Choi et al. [5, 12]; ffl empirical data on how the pointer analyses solutions affect the precision and efficiency of the following client analyses: Mod Ref, live variable analysis and dead assignment identification, reaching definition analysis, dependence analysis, and interprocedural conditional constant ....

....q both point to the same storage location, we say p and q are aliases, written as hp; q i. A pointsto analysis attempts to determine what storage location a pointer can point to. This information can then be used to determine the aliases in the program. This works uses the compact representation [5, 12] of alias information, which shares the property of the points to representation [8] in that it captures the edge characteristic of alias relations. 1 For example, if variable a points to b, and b points to c, the compact representation records only the following alias set: fha; bi; hb; cig, ....

[Article contains additional citation context not shown here]

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages, pages 232--245, Jan. 1993.

....the linearized subscript. For an explictly named array (say, A[ the base expression is an address of the variable (A) while for an array accessed through a pointer, it represents the value of the pointer. The compiler performs flow sensitive, context sensitive, interprocedural pointer analysis [3], which is used to provide aliasing information to array section analysis. If an array is aliased with another variable, an access to that aliased variable is regarded as potentially touching any part of the given array. The subscript information for a multidimensional array, which appears to the ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages, pages 232--245, January 1993.

....at each program point in a language that does not contain pointers. However, finding a precise solution for a language that includes pointers is an NP complete problem [Landi and Ryder 1991] Approximate algorithms that handle pointers have been developed and prototyped [Landi et al. 1993; Choi et al. 1993]. The two algorithms have different complexities that are not directly comparable; in different circumstances one or the other may be more efficient or more precise [Marlowe et al. 1993] All forms of alias analysis depend on building up some sort of abstract representation of the structures ....

Choi, J.-D., Burke, M., and Carini, P. 1993. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Proceedings of the Twentieth Annual ACM Symposium on Principles of Programming Languages, (Charleston, South Carolina, Jan.). ACM Press, New York, pp. 232-- 245.

....statement order, they trivially model all of the interleavings of the parallel executions. 9.1. 1 Flow Sensitive Analyses Flow sensitive analyses take the statement ordering into account, typically using a dataflow analysis to produce a pointsto graph or set of alias pairs for each program point [25, 22, 28, 18, 10, 20]. One approach analyzes the program in a topdown fashion starting from the main procedure, reanalyzing each potentially invoked procedure in each new calling context [28, 18] This approach exposes the compiler to the possibility of spending significant amounts of time reanalyzing procedures. It ....

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Conference Record of the Twentieth Annual Symposium on Principles of Programming Languages, Charleston, SC, January 1993. ACM.

....The ideal solution would be to use RTA first, and only employ alias analysis when RTA fails to resolve a large number of monomorphic calls. In a similar vein as Pande and Ryder, Carini et al. 7] have also devised an alias analysis algorithm for C based on an algorithm for C and Fortran [10, 5]. We are currently collaborating with them on an implementation of their algorithm within our analysis framework. This will allow a direct comparison of both the precision and the efficiency of alias analysis. 4.3 Other Work in C Porat et al. 21] implemented the Unique Name optimization in ....

Choi, J.-D., Burke, M., and Carini, P. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the Twentieth ACM Symposium on Principles of Programming Languages (Charleston, South Carolina, Jan. 1993), ACM Press, New York, N.Y., pp. 232--245.

....analyses typically formulate the entire analysis problem as a single collection of set inclusion constraints. Flow sensitive analyses take the statement ordering into account, typically using a dataflow analysis to produce a points to graph or set of alias pairs for each program point [38, 35, 42, 23, 14, 30]. One approach analyzes the program in a top down fashion starting from the main procedure, reanalyzing each potentially invoked procedure in each new calling context [42, 23] Another approach analyzes the program in a bottom up fashion, extracting a single analysis result for each procedure. The ....

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Conference Record of the Twentieth Annual Symposium on Principles of Programming Languages, Charleston, SC, January 1993. ACM.

....large programs. Static cleanness checking, when being conservative, can detect all errors. 1.3 Motivation In this thesis I investigated ways to conservatively discover cleanness violations with minimal false alarms. Rather than developing new algorithms, we exploit pointer analysis techniques [31, 32, 37, 5, 24, 26, 34, 11, 52, 35, 6, 42, 12, 14, 20, 21, 51, 46, 49, 47] to build a conservative algorithm for checking pointer dereferencing. Being interested in static analysis, we do not restrict ourselves to linear time algorithms. We are aware of the scalability problem of these algorithms. One 6 way to achieve scalability is by using global procedure ....

....for programming languages with pointer expressions. Such compilers, in order to be conservative, collect information about the possible value of a pointer expression. It is undecidable to determine what a pointer can pointto, therefore many approximation methods have been developed, among them are [31, 32, 37, 5, 24, 26, 34, 11, 52, 35, 6, 42, 12, 14, 20, 21, 51, 46, 49, 47]. These algorithms differ in precision and complexity; unfortunately, they are difficult to compare. One of the common approaches is to compute aliasing information. A pointer expression p is said to be may alias to pointer expression q at a point pt in the program if there exits a path in the ....

[Article contains additional citation context not shown here]

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side-effects. In the ACM Symposium on Principles of Programming Languages, pages 232--245, New York, NY, 1993. ACM Press.

....of pointers and the unknown side effects of function calls. Even though many interprocedural pointer analysis algorithms have been proposed to solve the aliasing problem, most of them either lack the scalability to handle large programs or the ability to handle the complete C language constructs [1, 2, 3, 4, 5]. As an alternative to load reuse optimizations, code scheduling can hide the load latency that would have be observed by dependent instructions. Without extra software and hardware supports [6] the compiler needs the definite knowledge of independence between a load and an earlier store. This ....

....domains: pointer analysis, compiletime memory optimizations and run time memory optimizations, since they are the key components of the study in this paper. Pointer analysis Pointer analysis plays the key role in enabling aggressive memory access optimizations. Landi and Ryder [1] Choi et al. [2], Emami et al. 3] and Wilson and Lam [15] proposed flow and context sensitive interprocedural pointer analysis algorithms to recover pointers targets at each execution point of the program. Andersen [16] Steengaard [17] and Shapiro and Horwitz [4] took another angle to tackle the intra and ....

[Article contains additional citation context not shown here]

J. D. Choi, M. G. Burke, and P. Carini, "Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects," in Proceedings of the 20th ACM Symposium on Principles of Programming Languages, pp. 232--245, January 1993.

....analysis is not complete if it cannot resolve all function pointers. Due to either simplified assumptions or high complexity in the algorithm, recent work in interprocedural pointer analysis has not demonstrated the ability to construct the complete call graph for significant benchmarks like SPEC [11, 12, 13, 14, 15, 16]. In this paper, we provide a comprehensive study of function pointers using SPEC benchmarks. SPEC benchmarks were selected for this study because of their size, wide acceptance, and realistic function pointer manipulation. Benchmarks included in this paper are li, sc, eqntott, espresso, m88ksim, ....

....to a new procedure, the new procedure will be included in the call graph. Spillman [22] and Weihl [23] enable call graph construction in the presence of aliases. 5 The accuracy of such analysis is further improved by several flow and context sensitive interprocedural pointer analysis algorithms [11, 12, 13, 14]. However, a complete solution scalable to the class of SPEC programs has not been found in the literature. Murphy et al. 24] evaluate nine call graph extractor tools using three software systems (mapmaker, mosaic, and gcc) All of the tools generate false negative call graphs: calls that can in ....

J. D. Choi, M. G. Burke, and P. Carini, "Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects," in Proceedings of the 20th ACM Symposium on Principles of Programming Languages, pp. 232--245, January 1993.

....conservative assumptions about memory dependence have to be made, leaving the code optimized in a dissatisfied way. Many researchers have proposed various techniques for interprocedural pointer analysis to disambiguate memory accesses. The analysis result is represented either by alias pairs [3][4], which specify the dependence of two memory accesses, or by points to relations [5] 6] 7] 8] which model the storage shape graph [9] When performing optimizations, what the compiler really needs is the alias information, which can be derived from the points to relations [5] Besides the above ....

....relations [5] Besides the above distinction, the interprocedural pointer analysis can be further classified by its flow and context sensitivity. In a flow sensitive analysis the relative orders of statements are considered, which provides the disambiguation information at every program point [3][4][5] 6] On the other hand, a flow insensitive analysis generates a single result containing all possible aliases for the whole program [7] 10] 11] In a context sensitive analysis, different calling contexts to a function are separated so that the alias information binded from one context will not ....

[Article contains additional citation context not shown here]

J. D. Choi, M. G. Burke, and P. Carini, "Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects," in Proceedings of the 20th ACM Symposium on Principles of Programming Languages, pp. 232--245, January 1993.

....LH88, CWZ90, Str92, PCK93] Previous to this paper, it was an open question whether such precision could ever be obtained by any method that uses graphs to model storage usage. Furthermore, as far as we know, no other shape analysis type checking method (whether based on graphs or other principles [HN90, Hen90, LR91, Deu92, CBC93, Deu94]) has the ability to determine that circular list ness is preserved by the list insert program. What does our method do that allows it to obtain such qualitatively better results on the above mentioned programs than previous methods A detailed examination of the differences between our ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side-effects. In ACM Symposium on Principles of Programming Languages, pages 232-- 245, 1993.

....to accurately handle heap allocated recursive data structures. In some special cases it can help detect completely unaliased data structures (lists and trees) built by a program, but neither empirical nor theoretical evidence is available to draw any general conclusions. Choi, Burke and Carini [CBC93] also compute aliases of pairs of access paths. Their access paths are similar to object names [LR92] However, they do not use access paths to name heap objects. They use the place (statement) in the program, where an anonymous heap object is created, to name it, as in [CWZ90] To avoid giving ....

....thesis. This approach of decoupling the stack and heap analyses might incur some imprecision, when pointer fields in heap cells point to locations on the stack. However, the authors provide empirical evidence that it does not commonly happen in real programs. The techniques proposed by [LR92, CBC93, EGH94] handle procedure calls in a context sensitive manner i.e. the effect of a procedure call is estimated specific to a calling context, and not just summarized for all possible calling contexts. They use different strategies to abstract calling contexts: assumed alias sets [LR92] last call ....

[Article contains additional citation context not shown here]

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side-effects. In Proceedings of the ACM 20th Symposium on Principles of Programming Languages, pages 232--245, January 1993.

....static analysis, Type determination, Aliasing, Virtual functions, Pointers. 1 Introduction In the past decade, significant research by the static analysis community has concentrated on expanding compile time analysis to include interprocedural information [BCC 94, Bur90, Cal88, CBC93, CK88, CK89, HS94, HRB90, LRZ93, MLR 93, Mey81] Historically, compile time analysis has been used in intraprocedural context for code optimizations. The emphasis is shifting towards the use of interprocedural static analysis in compiling as well as all phases of software life cycle including ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In Proceedings of the Twentieth Annual ACM Symposium on Principles of Programming Languages, January 1993.

....it practical for realistic applications. 1 Introduction It is well known that programs with pointers are hard to understand, debug, and optimize. In recent years many interesting algorithms that conservatively analyze programs with pointers have been published. Roughly speaking, these algorithms [19, 20, 25, 5, 16, 17, 23, 8, 6, 9, 14, 27, 13, 28] conservatively solve the mayalias problem, i.e. the algorithms are sometimes able to show that two pointer access paths never refer to the same memory location at a given program point. However, may alias information is insufficient for compiler optimizations, automatic code parallelizations, ....

....and the instrumented program semantics and the instrumentation properties. In contrast, we show that the instrumented program simulates the original program and the properties of the instrumentation. Finally, program dependences can also be conservatively computed by combining side effect analysis [4, 7, 22, 6] with reaching definitions [2] or by combining conflict analysis [25] with reaching definitions as done in [24] However, these techniques are extremely imprecise when recursive data structures are manipulated. The main reason is that it is hard to distinguish between occurrences of the same heap ....

J.D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side-effects. In ACM Symposium on Principles of Programming Languages, pages 232--245, New York, NY, 1993. ACM Press.

....storage (e.g. JM81] HPR89] Hen90] Deu90] CWZ90] Deu94] GH96] SRW96] while others have concentrated on stack based storage. The latter can be further classified as flow sensitive or flow insensitive, and as context sensitive or contextinsensitive. Flow sensitive analysis (e.g. LR92] [CBC93] [EGH94] takes into account the order in which statements are executed, while flow insensitive analysis (e.g. Wei80] MCCH94] And94] Ste96b] ZRL96] assumes that statements can be executed in any order. Similarly, context sensitive analysis takes into account the fact that a function must ....

J.-D. Choi, M. Burke, and P. Carini. Efficient flowsensitive interprocedural computation of pointerinduced aliases and side-effects. In ACM Symposium on Principles of Programming Languages, pages 232-- 245, 1993.

.... analyses of varying precision to achieve appropriate cost benefit goals This question can be considered, for example, in the field of pointer analysis[Zhang et al. 1996] Recently, there have been significant advances in the approximate analyses of difficult program constructs such as pointers[Choi et al. 1993; Marlowe et al. 1993; Burke et al. 1994; Landi and Ryder 1992; Steensgaard 1996] These approximate analysis methods are difficult to compare in terms of accuracy and efficiency, but are necessarily approximate because of the provable difficulty of the problem they address. Before reasonable ....

Choi, J.-D., Burke, M., and Carini, P. 1993. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Proceedings of the ACM SIGACT/SIGPLAN Symposium on the Principles of Programming Languages (January 1993), pp. 232--245.

....into 2 distinct subproblems: 1) disambiguating pointers that point to objects on the stack, and (2) disambiguating pointers that point to objects on the heap. There has been a considerable amount of work in both of these areas [JM81, JM82, LH88, Lar91, Gua88, HPR89, Har89, CWZ90, HN90, LR92, CBC93, Deu92, Deu94, PCK93, EGH94, WL95, Ruf95] although more attention has been paid to actually implementing methods that work well for stack allocated objects [LR92, CBC93, EGH94, Ruf95, WL95] A complete discussion and comparison of these methods can be found in [Ghi95] Stack directed pointers ....

.... has been a considerable amount of work in both of these areas [JM81, JM82, LH88, Lar91, Gua88, HPR89, Har89, CWZ90, HN90, LR92, CBC93, Deu92, Deu94, PCK93, EGH94, WL95, Ruf95] although more attention has been paid to actually implementing methods that work well for stack allocated objects [LR92, CBC93, EGH94, Ruf95, WL95] A complete discussion and comparison of these methods can be found in [Ghi95] Stack directed pointers exhibit the important property that their targets always possess a name (the name of the variable allocated to that location on the stack) Using this property, pointer ....

[Article contains additional citation context not shown here]

J. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side-effects. In Conf. Rec. of the Twentieth Ann. ACM SIGPLAN-SIGACT Symp. on Principles of Programming Languages, pages 232--245, Charleston, South Carolina, Jan. 1993.

No context found.

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointerinduced aliases and side effects. In 20th Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages, pages 232--245, Jan. 1993.

.... scheme to limit the level of indirection; Techniques that improve the precision of alias analysis with respect to the unrealizable path problem and the non distributive combining problem; A technique for improving the precision of alias information for compact alias representations [Choi et al. 1993; Emami et al. 1994] and graph based represen 2 Delta Interprocedural Pointer Alias Analysis tations [Jones and Muchnick 1981; 1982; Larus and Hilfinger 1988; Ruggieri and Murtagh 1988; Horwitz et al. 1989; Chase et al. 1990] An interprocedural naming technique for dynamically allocated ....

....information because pointer aliasing information, unlike reference parameter aliasing, can change within a routine. In order to correctly perform side effect analysis in the presence of pointers, alias information must be present and factored in when immediate MOD and USE information is collected [Choi et al. 1993; Horwitz et al. 1989; Landi et al. 1993] During alias analysis we compute the side effects of a procedure using alias information by introducing a representative parameter r i for each variable local to the caller whose address is passed as the ith actual parameter to a pointer in the called ....

[Article contains additional citation context not shown here]

Choi, J.-D., Burke, M., and Carini, P. 1993. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages. 232--245.

....information because pointer aliasing information, unlike reference parameter aliasing, can change within a routine. In order to correctly perform side effect analysis in the presence of pointers, alias information must be present and factored in when immediate MOD and USE information is collected [Choi et al. 1993; Horwitz et al. 1989; Landi et al. 1993; 1998] We describe various alias analysis techniques for features occurring in common imperative pointer languages such as C, C , and Fortran 90. Our analysis supports such language features as the address operator, pointer assignment, pointer ....

.... examples that illustrate how the compact representation and the explicit representation are incomparable each can be more precise than the other and characterizes the trade offs in precision between the two representations [Marlowe et al. 1993] The compact representation, introduced in Choi et al. 1993], is highly similar to the points to representation [Emami et al. 1994; Ghiya 1992] The major difference 1 The implementation described in Section 4 names objects based on their allocation site [Chase et al. 1990; Horwitz et al. 1989; Hudak 1986; Jones and Muchnick 1981; Ruggieri and Murtagh ....

[Article contains additional citation context not shown here]

Choi, J.-D., Burke, M., and Carini, P. 1993. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th Annual ACM SIGACT-SIGPLAN Symposium on the Principles of Programming Languages. 232--245.

No context found.

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In Conference Record of the 20th Annual ACM Symposium on Principles of Programming Languages (POPL'93), pages 232--245. ACM, 1993.

No context found.

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In ACM, editor, Conference record of the Twentieth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages: papers presented at the symposium, Charleston, South Carolina, January 10--13, 1993.

No context found.

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 232--245, Charleston, South Carolina, 1993.

No context found.

J.-D. Choi, M. Burke, and P. Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In ACM, editor, Twentieth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 232--245, 1993.

No context found.

Jong-Deok Choi, Michael Burke, and Paul Carini. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. In 20th Annual ACM Symposium on Principles of Programming Languages, pages 232--245, 1993.

No context found.

Choi J-D, Burke M, Carini P. Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects. Conference Record of the ACM Symposium on Principles of Programming Languages, Charleston, South Carolina, January 1993; 232--245.

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC