Building a Bridge between Pointer Aliases and Program Dependences

In this paper we present a surprisingly simple reduction of the program dependence problem to the may-alias problem. While both problems are undecidable, providing a bridge between them has great practical importance. Program dependence information is used extensively in compiler optimizations, automatic program parallelizations, code scheduling in super-scalar machines, and in software engineering tools such as code slicers. When working with languages that support pointers and references, these systems are forced to make very conservative assumptions. This leads to many superfluous program dependences and limits compiler performance and the usability of software engineering tools. Fortunately, there are many algorithms for computing conservative approximations to the may-alias problem. The reduction has the important property of always computing conservative program dependences when used with a conservative may-alias algorithm. We believe that the simplicity of the reduction and the fact that it takes linear time may make it practical for realistic applications.

[1]  James R. Larus,et al.  Detecting conflicts between structure accesses , 1988, PLDI '88.

[2]  Olivier Danvy,et al.  Semantics-Based Compiling: A Case Study in Type-Directed Partial Evaluation , 1996, PLILP.

[3]  Scott A. Mahlke,et al.  Using profile information to assist classic code optimizations , 1991, Softw. Pract. Exp..

[4]  Ethan V. Munson,et al.  Proteus: an adaptable presentation system for a software development and multimedia document environment , 1995 .

[5]  John Banning,et al.  : An Efficient , 2022 .

[6]  Neil D. Jones,et al.  Flow analysis and optimization of LISP-like structures , 1979, POPL.

[7]  Barbara G. Ryder,et al.  Interprocedural modification side effect analysis with pointer aliasing , 1993, PLDI '93.

[8]  Thomas Ball,et al.  Software Visualization in the Large , 1996, Computer.

[9]  Joseph A. Fisher,et al.  Trace Scheduling: A Technique for Global Microcode Compaction , 1981, IEEE Transactions on Computers.

[10]  Peter D. Mosses.  An Introduction to Action Semantics , 1991 .

[11]  Reinhard Wilhelm,et al.  Solving shape-analysis problems in languages with destructive updating , 1998, TOPL.

[12]  Olivier Danvy,et al.  Type-directed partial evaluation , 1995, POPL '96.

[13]  Alain Deutsch,et al.  Semantic models and abstract interpretation techniques for inductive data structures and pointers , 1995, PEPM '95.

[14]  Donald E. Knuth,et al.  Breaking paragraphs into lines , 1981, Softw. Pract. Exp..

[15]  David A. Schmidt,et al.  Type Inference for Action Semantics , 1990, ESOP.

[16]  John J. Leggett,et al.  Viewing Dexter with open eyes , 1994, CACM.

[17]  Martin Alt,et al.  Generation of Efficient Interprocedural Analyzers with PAG , 1995, SAS.

[18]  Lance M. Berc,et al.  Continuous profiling: where have all the cycles gone? , 1997, ACM Trans. Comput. Syst..

[19]  Alain Deutsch,et al.  Interprocedural may-alias analysis for pointers: beyond k-limiting , 1994, PLDI '94.

[20]  David A. Padua,et al.  Dependence graphs and compiler optimizations , 1981, POPL '81.

[21]  William W. Pugh,et al.  A New Language Independent Prettyprinting Algorithm , 1987 .

[22]  Susan L. Graham,et al.  Incremental analysis of real programming languages , 1997, PLDI '97.

[23]  Thomas W. Reps,et al.  Pointer analysis for programs with structures and casting , 1999, PLDI '99.

[24]  David A. Watt,et al.  Sort Inference in the ACTRESS Compiler Generator , 1994 .

[25]  Hermano Moura,et al.  Action Transformations in the ACTRESS Compiler Generator , 1994, CC.

[26]  Michael L. Van de Vanter,et al.  Coherent User Interfaces for Language-Based Editing Systems , 1992, Int. J. Man Mach. Stud..

[27]  Barbara G. Ryder,et al.  Pointer-induced aliasing: a problem classification , 1991, POPL '91.

[28]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1984, TOPL.

[29]  Thomas W. Reps,et al.  Solving Demand Versions of Interprocedural Analysis Problems , 1994, CC.

[30]  William Harry Maddox,et al.  Incremental Static Semantic Analysis , 1998 .

[31]  Wen-mei W. Hwu,et al.  Trace Selection For Compiling Large C Application Programs To Microcode , 1988, [1988] Proceedings of the 21st Annual Workshop on Microprogramming and Microarchitecture - MICRO '21.

[32]  Joseph A. Fisher,et al.  Predicting conditional branch directions from previous runs of a program , 1992, ASPLOS V.

[33]  Susan Horwitz,et al.  Fast and accurate flow-insensitive points-to analysis , 1997, POPL '97.

[34]  Neil D. Jones,et al.  A flexible approach to interprocedural data flow analysis and programs with recursive data structures , 1982, POPL '82.

[35]  Laurie J. Hendren,et al.  Is it a tree, a DAG, or a cyclic graph? A shape analysis for heap-directed pointers in C , 1996, POPL '96.

[36]  Ethan V. Munson.  Toward and Operational Theory of Media , 1996, PODP.

[37]  Nesa L'abbe Wu,et al.  Linear programming and extensions , 1981 .

[38]  Bjarne Steensgaard,et al.  Points-to analysis in almost linear time , 1996, POPL '96.

[39]  Donald E. Knuth,et al.  Optimal measurement points for program frequency counts , 1973 .

[40]  Vincent Quint,et al.  Combining hypertext and structured documents in Grif , 1993, ECHT '92.

[41]  Marc J. Rochkind,et al.  The source code control system , 1975, IEEE Transactions on Software Engineering.

[42]  Kannan Muthukkaruppan.  SPINE A Synthesizer for Practical Incremental Evaluators , 1994 .

[43]  Michael A. Harrison,et al.  Presentation by tree transformation , 1997, Proceedings IEEE COMPCON 97. Digest of Papers.

[44]  Monica S. Lam,et al.  Efficient context-sensitive pointer analysis for C programs , 1995, PLDI '95.

[45]  Paul Hudak,et al.  Monad transformers and modular interpreters , 1995, POPL '95.

[46]  Karl J. Ottenstein,et al.  The program dependence graph in a software development environment , 1984 .

[47]  Ethan V. Munson.  A new presentation language for structured documents , 1996 .

[48]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1987, TOPL.

[49]  M. Mikelsons.  Prettyprinting in an interactive programming environment , 1981, SIGPLAN SIGOA Symposium on Text Manipulation.

[50]  Hausi A. Müller,et al.  A reverse engineering environment based on spatial and visual software interconnection models , 1992, SDE 5.

[51]  Michael Hind,et al.  Assessing the Effects of Flow-Sensitivity on Pointer Alias Analyses , 1998, SAS.

[52]  Stuart I. Feldman,et al.  Make — a program for maintaining computer programs , 1979, Softw. Pract. Exp..

[53]  Kenneth Slonneger,et al.  Formal syntax and semantics of programming languages , 1994 .

[54]  Samuel N. Kamin,et al.  Modular compilers based on monad transformers , 1998, Proceedings of the 1998 International Conference on Computer Languages (Cat. No.98CB36225).

[55]  David S. Johnson,et al.  Computers and Intractability: A Guide to the Theory of NP-Completeness , 1978 .

[56]  Thomas W. Reps,et al.  Demand interprocedural dataflow analysis , 1995, SIGSOFT FSE.

[57]  Joseph T. Rahmeh,et al.  Improving the accuracy of dynamic branch prediction using branch correlation , 1992, ASPLOS V.

[58]  GhiyaRakesh,et al.  Context-sensitive interprocedural points-to analysis in the presence of function pointers , 1994 .

[59]  Alan Jay Smith,et al.  Branch Prediction Strategies and Branch Target Buffer Design , 1995, Computer.

[60]  Boris Magnusson,et al.  Fine-grained revision control for collaborative software development , 1993, SIGSOFT '93.

[61]  Hermano Perrelli de Moura,et al.  Action notation transformations , 1993 .

[62]  Jong-Deok Choi,et al.  Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects , 1993, POPL '93.

[63]  Richard C. Waters.  XP: A Common Lisp Pretty Printing System , 1989 .

[64]  Alexandru Nicolau,et al.  Parallelizing Programs with Recursive Data Structures , 1989, IEEE Trans. Parallel Distributed Syst..

[65]  A. Deutsch,et al.  A storeless model of aliasing and its abstractions using finite representations of right-regular equivalence relations , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[66]  Phil Pfeiffer,et al.  Dependence analysis for pointer variables , 1989, PLDI '89.

[67]  Laurie J. Hendren,et al.  Putting pointer analysis to work , 1998, POPL '98.

[68]  Erik Ruf.  Partitioning dataflow analyses using types , 1997, POPL '97.

[69]  Susan L. Graham,et al.  Integrating Incremental Analysis with Version Management , 1995, ESEC.

[70]  M. Burke,et al.  Eecient Flow-sensitive Interprocedural Computation of Pointer-induced Aliases and Side Eeects , 1993 .

[71]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[72]  Joseph Robert Horgan,et al.  Dynamic program slicing , 1990, PLDI '90.

[73]  Stephen G. Eick,et al.  Graphical analysis of computer log files , 1994, CACM.