skip to main content
survey

Heap Abstractions for Static Analysis

Published: 30 June 2016 Publication History

Abstract

Heap data is potentially unbounded and seemingly arbitrary. Hence, unlike stack and static data, heap data cannot be abstracted in terms of a fixed set of program variables. This makes it an interesting topic of study and there is an abundance of literature employing heap abstractions. Although most studies have addressed similar concerns, insights gained in one description of heap abstraction may not directly carry over to some other description.
In our search of a unified theme, we view heap abstraction as consisting of two steps: (a) heap modelling, which is the process of representing a heap memory (i.e., an unbounded set of concrete locations) as a heap model (i.e., an unbounded set of abstract locations), and (b) summarization, which is the process of bounding the heap model by merging multiple abstract locations into summary locations. We classify the heap models as storeless, store based, and hybrid. We describe various summarization techniques based on k-limiting, allocation sites, patterns, variables, other generic instrumentation predicates, and higher-order logics. This approach allows us to compare the insights of a large number of seemingly dissimilar heap abstractions and also paves the way for creating new abstractions by mix and match of models and summarization techniques.

References

[1]
Alexander Aiken. 1999. Introduction to set constraint-based program analysis. Sci. Comput. Program. 35, 2--3 (Nov. 1999), 79--111.
[2]
L. O. Andersen. 1994. Program Analysis and Specialization for the C Programming Language. Ph.D. Dissertation. DIKU, University of Copenhagen.
[3]
Gilad Arnold, Roman Manevich, Mooly Sagiv, and Ran Shaham. 2006. Combining shape analyses by intersecting abstractions. In Proceedings of the 7th International Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI’06). Springer-Verlag, Berlin, 33--48.
[4]
Rahul Asati, Amitabha Sanyal, Amey Karkare, and Alan Mycroft. 2014. Liveness-based garbage collection. In Proceedings of the 23rd International Conference on Compiler Construction (CC’14). Springer-Verlag, Berlin, 85--106.
[5]
Uwe Aßmann and Markus Weinhardt. 1993. Interprocedural heap analysis for parallelizing imperative programs. In Proceedings of Programming Models for Massively Parallel Computers. IEEE Computer Society, Washington, DC, 74--82.
[6]
Gogul Balakrishnan and Thomas Reps. 2006. Recency-abstraction for heap-allocated storage. In Proceedings of the 13th International Conference on Static Analysis (SAS’06). Springer-Verlag, Berlin, 221--239.
[7]
Barnali Basak, Sandeep Dasgupta, and Amey Karkare. 2011. Heap dependence analysis for sequential programs. In Applications, Tools and Techniques on the Road to Exascale Computing, Proceedings of the Conference ParCo 2011, 31 August - 3 September 2011, Ghent, Belgium. IOS Press, Ghent, Belgium, 99--106.
[8]
Marc Berndl, Ondrej Lhoták, Feng Qian, Laurie Hendren, and Navindra Umanee. 2003. Points-to analysis using BDDs. In Proceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation (PLDI’03). ACM, New York, NY, 103--114.
[9]
Sam Blackshear, Bor-Yuh Evan Chang, and Manu Sridharan. 2013. Thresher: Precise refutations for heap reachability. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’13). ACM, New York, NY, 275--286.
[10]
Sam Blackshear, Bor-Yuh Evan Chang, and Manu Sridharan. 2015. Selective control-flow abstraction via jumping. In Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2015). ACM, New York, NY, 163--182.
[11]
Ahmed Bouajjani, Marius Bozga, Peter Habermehl, Radu Iosif, Pierre Moro, and Tomáš Vojnar. 2006. Programs with lists are counter automata. In Proceedings of the 18th International Conference on Computer Aided Verification (CAV’06). Springer-Verlag, Berlin, 517--531.
[12]
Marius Bozga, Radu Iosif, and Yassine Lakhnech. 2004. Static Analysis: 11th International Symposium, SAS 2004, Verona, Italy, August 26-28, 2004. Proceedings. Springer, Berlin, 344--360.
[13]
Marius Bozga, Radu Iosif, and Yassine Laknech. 2003. Storeless semantics and alias logic. SIGPLAN Not. 38, 10 (June 2003), 55--65.
[14]
Cristiano Calcagno, Dino Distefano, Peter W. O’Hearn, and Hongseok Yang. 2011. Compositional shape analysis by means of bi-abduction. J. ACM 58, 6, Article 26 (Dec. 2011), 66 pages.
[15]
R. Castillo, A. Tineo, F. Corbera, A. Navarro, R. Asenjo, and E. L. Zapata. 2006. Towards a versatile pointer analysis framework. In Proceedings of the 12th International Conference on Parallel Processing (Euro-Par’06). Springer-Verlag, Berlin, 323--333.
[16]
Venkatesan T. Chakaravarthy. 2003. New results on the computability and complexity of points--to analysis. In Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’03). ACM, New York, NY, 115--125.
[17]
Supratik Chakraborty. 2012. Reasoning about heap manipulating programs using automata techniques. In Modern Applications of Automata Theory, Deepak D’Souza and Priti Shankar (Eds.). IISc-World Scientific Review Volume, India, 193--228.
[18]
David R. Chase, Mark Wegman, and F. Kenneth Zadeck. 1990. Analysis of pointers and structures. In Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation (PLDI’90). ACM, New York, NY, 296--310.
[19]
Stephen Chong and Radu Rugina. 2003. Static Analysis: 10th International Symposium, SAS 2003 San Diego, CA, USA, June 11--13, 2003 Proceedings. Springer Berlin Heidelberg, Berlin, Heidelberg, Chapter Static Analysis of Accessed Regions in Recursive Data Structures, 463--482.
[20]
Arnab De and Deepak D’Souza. 2012. Scalable flow-sensitive pointer analysis for java with strong updates. In Proceedings of the 26th European Conference on Object-Oriented Programming (ECOOP’12). Springer-Verlag, Berlin, 665--687.
[21]
Alain Deutsch. 1994. Interprocedural may-alias analysis for pointers: Beyond k-limiting. In Proceedings of the ACM SIGPLAN 1994 Conference on Programming Language Design and Implementation (PLDI’94). ACM, New York, NY, USA, 230--241.
[22]
Dino Distefano, Peter W. O’Hearn, and Hongseok Yang. 2006. A local shape analysis based on separation logic. In Proceedings of the 12th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS’06). Springer-Verlag, Berlin, 287--302.
[23]
Amer Diwan, J. Eliot, B. Moss, and Kathryn S. McKinley. 1996. Simple and effective analysis of statically-typed object-oriented programs. In Proceedings of the 11th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’96). ACM, New York, NY, 292--305.
[24]
Nurit Dor, Michael Rodeh, and Mooly Sagiv. 1998. Detecting memory errors via static pointer analysis (preliminary experience). In Proceedings of the 1998 ACM Sigplan-Sigsoft Workshop on Program Analysis for Software Tools and Engineering (PASTE’98). ACM, New York, NY, 27--34.
[25]
Stephen J. Fink, Kathleen Knobe, and Vivek Sarkar. 2000. Unified analysis of array and object references in strongly typed languages. In Proceedings of the 7th International Symposium on Static Analysis (SAS’00). Springer-Verlag, London, 155--174. http://dl.acm.org/citation.cfm?id=647169.718147
[26]
Manuel Geffken, Hannes Saffrich, and Peter Thiemann. 2014. Precise interprocedural side-effect analysis. In Theoretical Aspects of Computing - ICTAC 2014-11th International Colloquium, Bucharest, Romania, September 17-19, 2014. Proceedings. Springer International Publishing, Cham, 188--205.
[27]
Pritam M. Gharat and Uday P. Khedker. 2016. Flow and context sensitive points-to analysis using higher order reachability. CoRR abs/1603.09597, Article 1603.09597 (2016), 43 pages. http://arxiv.org/abs/1603.09597
[28]
Rakesh Ghiya. 1998. Putting Pointer Analysis to Work. Ph.D. Dissertation. McGill University, Montreal.
[29]
Rakesh Ghiya and Laurie J. Hendren. 1996. Is it a tree, a DAG, or a cyclic graph? A shape analysis for heap-directed pointers in C. In Proceedings of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’96). ACM, New York, NY, 1--15.
[30]
Rakesh Ghiya and Laurie J. Hendren. 1998. Putting pointer analysis to work. In Proceedings of the 25th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’98). ACM, New York, NY, 121--133.
[31]
Alexey Gotsman, Josh Berdine, and Byron Cook. 2006. Interprocedural shape analysis with separated heap abstractions. In Proceedings of the 13th International Conference on Static Analysis (SAS’06). Springer-Verlag, Berlin, 240--260.
[32]
Samuel Z. Guyer and Calvin Lin. 2003. Client-driven pointer analysis. In Proceedings of the 10th International Conference on Static Analysis (SAS’03). Springer-Verlag, Berlin, 214--236. http://dl.acm.org/citation.cfm?id=1760267.1760284
[33]
Ben Hardekopf and Calvin Lin. 2009. Semi-sparse flow-sensitive pointer analysis. In Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’09). ACM, New York, NY, 226--238.
[34]
Ben Hardekopf and Calvin Lin. 2011. Flow-sensitive pointer analysis for millions of lines of code. In Proceedings of the 9th Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO’11). IEEE Computer Society, Washington, DC, 289--298. http://dl.acm.org/citation.cfm?id=2190025.2190075
[35]
L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan. 1993. Designing the McCAT compiler based on a family of structured intermediate representations. In Proceedings of the 5th International Workshop on Languages and Compilers for Parallel Computing, Utpal Banerjee, David Gelernter, Alex Nicolau, and David Padua (Eds.). Lecture Notes in Computer Science, Vol. 757. Springer, Berlin, 406--420.
[36]
Laurie J. Hendren. 1990. Parallelizing Programs with Recursive Data Structures. Ph.D. Dissertation. Cornell University.
[37]
Laurie J. Hendren and Alexandru Nicolau. 1989. Intererence analysis tools for parallelizing programs with recursive data structures. In Proceedings of the 3rd International Conference on Supercomputing (ICS’89). ACM, Heraklion, Crete, 205--214.
[38]
L. J. Hendren and A. Nicolau. 1990. Parallelizing programs with recursive data structures. IEEE Trans. Parallel Distrib. Syst. 1, 1 (Jan. 1990), 35--47.
[39]
Michael Hind. 2001. Pointer analysis: Haven’t we solved this problem yet? In Proceedings of the 2001 ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering (PASTE’01). ACM, New York, NY, 54--61.
[40]
Michael Hind, Michael Burke, Paul Carini, and Jong-Deok Choi. 1999. Interprocedural pointer alias analysis. ACM Trans. Program. Lang. Syst. 21, 4 (July 1999), 848--894.
[41]
Michael Hind and Anthony Pioli. 2000. Which pointer analysis should I use? SIGSOFT Softw. Eng. Notes 25, 5 (Aug. 2000), 113--123.
[42]
Martin Hirzel, Amer Diwan, and Johannes Henkel. 2002. On the usefulness of type and liveness accuracy for garbage collection and leak detection. ACM Trans. Program. Lang. Syst. 24, 6 (Nov. 2002), 593--624.
[43]
C. A. R. Hoare. 1969. An axiomatic basis for computer programming. Commun. ACM 12, 10 (Oct. 1969), 576--580.
[44]
Susan Horwitz. 1997. Precise flow-insensitive may-alias analysis is NP-hard. ACM Trans. Program. Lang. Syst. 19, 1 (Jan. 1997), 1--6.
[45]
David Hovemeyer, Jaime Spacco, and William Pugh. 2005. Evaluating and tuning a static analysis to find null pointer bugs. In Proceedings of the 6th ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering (PASTE’05). ACM, New York, NY, 13--19.
[46]
Katsuro Inoue, Hiroyuki Seki, and Hikaru Yagi. 1988. Analysis of functional programs to detect run-time garbage cells. ACM Trans. Program. Lang. Syst. 10, 4 (Oct. 1988), 555--578.
[47]
Jakob L. Jensen, Michael E. Jørgensen, Michael I. Schwartzbach, and Nils Klarlund. 1997. Automatic verification of pointer programs using monadic second-order logic. In Proceedings of the ACM SIGPLAN 1997 Conference on Programming Language Design and Implementation (PLDI’97). ACM, New York, NY, 226--234.
[48]
Shubhangi Khare, Sandeep Saraswat, and Shrawan Kumar. 2011. Static program analysis of large embedded code base: An experience. In Proceedings of the 4th India Software Engineering Conference (ISEC’11). ACM, New York, NY, 99--102.
[49]
Uday P. Khedker. 2013. The approximations vs. abstractions dilemma in pointer analysis. In Pointer Analysis (Dagstuhl Reports), Ondřej Lhoták, Yannis Smaragdakis, and Manu Sridharan (Eds.), Vol. 3. Schloss Dagstuhl -- Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany, 91--113. Issue 4.
[50]
Uday P. Khedker, Alan Mycroft, and Prashant Singh Rawat. 2012. Liveness-based pointer analysis. In Proceedings of the 19th International Conference on Static Analysis (SAS’12). Springer-Verlag, Deauville, 265--282.
[51]
Uday P. Khedker, Amitabha Sanyal, and Amey Karkare. 2007. Heap reference analysis using access graphs. ACM Trans. Program. Lang. Syst. 30, 1, Article 1 (Nov. 2007), 41 pages.
[52]
Nils Klarlund and Michael I. Schwartzbach. 1993. Graph types. In Proceedings of the 20th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’93). ACM, New York, NY, 196--205.
[53]
Raghavan Komondoor. 2013. Precise slicing in imperative programs via term-rewriting and abstract interpretation. In SAS. Springer Berlin Heidelberg, Seattle, WA, 259--282.
[54]
Thomas Kotzmann and Hanspeter Mössenböck. 2005. Escape analysis in the context of dynamic compilation and deoptimization. In Proceedings of the 1st ACM/USENIX International Conference on Virtual Execution Environments (VEE’05). ACM, New York, NY, 111--120.
[55]
Prasanna Kumar, Amitabha Sanyal, and Amey Karkare. 2016. Liveness-based garbage collection for lazy languages. In Proceedings of the 2016 International Symposium on Memory Management (ISMM’16). ACM, New York, NY.
[56]
Viktor Kuncak, Patrick Lam, Karen Zee, and Martin C. Rinard. 2006. Modular pluggable analyses for data structure consistency. IEEE Trans. Softw. Eng. 32, 12 (Dec. 2006), 988--1005.
[57]
Patrick Lam, Viktor Kuncak, and Martin Rinard. 2005a. Generalized typestate checking for data structure consistency. In Proceedings of the 6th International Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI’05). Springer-Verlag, Berlin, 430--447.
[58]
Patrick Lam, Viktor Kuncak, and Martin Rinard. 2005b. Hob: A tool for verifying data structure consistency. In Proceedings of the 14th International Conference on Compiler Construction (CC’05). Springer-Verlag, Berlin, 237--241.
[59]
William Landi and Barbara G. Ryder. 1992. A safe approximate algorithm for interprocedural aliasing. In Proceedings of the ACM SIGPLAN 1992 Conference on Programming Language Design and Implementation (PLDI’92). ACM, New York, NY, 235--248.
[60]
J. R. Larus and P. N. Hilfinger. 1988. Detecting conflicts between structure accesses. In Proceedings of the ACM SIGPLAN 1988 Conference on Programming Language Design and Implementation (PLDI’88). ACM, New York, NY, 24--31.
[61]
Chris Lattner and Vikram Adve. 2003. Data Structure Analysis: A Fast and Scalable Context-Sensitive Heap Analysis. Technical Report. University of Illinois at Urbana Champaign.
[62]
Chris Lattner, Andrew Lenharth, and Vikram Adve. 2007. Making context-sensitive points-to analysis with heap cloning practical for the real world. In Proceedings of the 2007 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’07). ACM, New York, NY, 278--289.
[63]
Tal Lev-Ami, Thomas Reps, Mooly Sagiv, and Reinhard Wilhelm. 2000. Putting static analysis to work for verification: A case study. In Proceedings of the 2000 ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’00). ACM, New York, NY, 26--38.
[64]
Ondřej Lhoták and Kwok-Chiang Andrew Chung. 2011. Points-to analysis with efficient strong updates. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’11). ACM, New York, NY, 3--16.
[65]
Ondřej Lhotak, Yannis Smaragdakis, and Manu Sridharan. 2013. Pointer analysis (Dagstuhl seminar 13162). Dagstuhl Rep. 3, 4 (2013), 91--113.
[66]
Percy Liang and Mayur Naik. 2011. Scaling abstraction refinement via pruning. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’11). ACM, New York, NY, 590--601.
[67]
Benjamin Livshits, Manu Sridharan, Yannis Smaragdakis, Ondřej Lhoták, J. Nelson Amaral, Bor-Yuh Evan Chang, Samuel Z. Guyer, Uday P. Khedker, Anders Møller, and Dimitrios Vardoulakis. 2015. In defense of soundiness: A manifesto. Commun. ACM 58, 2 (Jan. 2015), 44--46.
[68]
Ravichandhran Madhavan and Raghavan Komondoor. 2011. Null dereference verification via over-approximated weakest pre-conditions analysis. In Proceedings of the 2011 ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA’11). ACM, New York, NY, 1033--1052.
[69]
Ravichandhran Madhavan, Ganesan Ramalingam, and Kapil Vaswani. 2011. Purity analysis: An abstract interpretation formulation. In Proceedings of the 18th International Conference on Static Analysis (SAS’11). Springer-Verlag, Berlin, 7--24. http://dl.acm.org/citation.cfm?id=2041552.2041558
[70]
Mark Marron, Cesar Sanchez, Zhendong Su, and Manuel Fahndrich. 2013. Abstracting runtime heaps for program understanding. IEEE Trans. Softw. Eng. 39, 6 (June 2013), 774--786. 2012.69
[71]
Ivan Matosevic and Tarek S. Abdelrahman. 2012. Efficient bottom-up heap analysis for symbolic path-based data access summaries. In Proceedings of the Tenth International Symposium on Code Generation and Optimization (CGO’12). ACM, New York, NY, 252--263.
[72]
Ana Milanova, Atanas Rountev, and Barbara G. Ryder. 2002. Parameterized object sensitivity for points-to and side-effect analyses for java. SIGSOFT Softw. Eng. Notes 27, 4 (July 2002), 1--11.
[73]
Anders Møller. 2014. MONA project home page. (2014). www.brics.dk/mona.
[74]
Anders Møller and Michael I. Schwartzbach. 2001. The pointer assertion logic engine. In Proceedings of the ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation (PLDI’01). ACM, New York, NY, 221--231.
[75]
Rupesh Nasre. 2012. Scaling Context-Sensitive Points-to Analysis. Ph.D. Dissertation. Indian Institute of Science, Bangalore.
[76]
Flemming Nielson, Hanne R. Nielson, and Chris Hankin. 1999. Principles of Program Analysis. Springer-Verlag, New York.
[77]
Erik M. Nystrom, Hong-Seok Kim, and Wen-mei W. Hwu. 2004. Importance of heap specialization in pointer analysis. In Proceedings of the 5th ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering (PASTE’04). ACM, New York, NY, 43--48.
[78]
Rohan Padhye and Uday P. Khedker. 2013. Interprocedural data flow analysis in soot using value contexts. In Proceedings of the 2nd ACM SIGPLAN International Workshop on State Of the Art in Java Program Analysis (SOAP’13). ACM, New York, NY, 31--36.
[79]
Lawrence C. Paulson. 1994. Isabelle - A Generic Theorem Prover (with a contribution by T. Nipkow). Lecture Notes in Computer Science, Vol. 828. Springer, Berlin.
[80]
David J. Pearce, Paul H. J. Kelly, and Chris Hankin. 2007. Efficient field-sensitive pointer analysis of C. ACM Trans. Program. Lang. Syst. 30, 1, Article 4 (Nov. 2007), 42 pages.
[81]
G. Ramalingam. 1994. The undecidability of aliasing. ACM Trans. Program. Lang. Syst. 16, 5 (Sept. 1994), 1467--1471.
[82]
Thomas Reps. 1997. Program analysis via graph reachability. In Proceedings of the 1997 International Symposium on Logic Programming (ILPS’97). MIT Press, Cambridge, MA, 5--19. http://dl.acm.org/citation. cfm?id=271338.271343
[83]
John C. Reynolds. 2002. Separation logic: A logic for shared mutable data structures. In Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science (LICS’02). IEEE Computer Society, Washington, DC, 55--74. http://dl.acm.org/citation.cfm?id=645683.664578
[84]
H. G. Rice. 1953. Classes of recursively enumerable sets and their decision problems. Trans. Am. Math. Soc. 74, 2 (1953), 358--366. http://www.jstor.org/stable/1990888
[85]
Noam Rinetzky. 2008. Interprocedural and Modular Local Heap Shape Analysis. Ph.D. Dissertation. Tel Aviv University.
[86]
Noam Rinetzky, Jörg Bauer, Thomas Reps, Mooly Sagiv, and Reinhard Wilhelm. 2005. A semantics for procedure local heaps and its abstractions. In Proceedings of the 32nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’05). ACM, New York, NY, 296--309.
[87]
Atanas Rountev, Barbara G. Ryder, and William Landi. 1999. Data-flow analysis of program fragments. In Proceedings of the 7th European Software Engineering Conference Held Jointly with the 7th ACM SIGSOFT International Symposium on Foundations of Software Engineering (ESEC/FSE-7). Springer-Verlag, London, 235--252. http://dl.acm.org/citation.cfm?id=318773.318945
[88]
Barbara G. Ryder. 2003. Dimensions of precision in reference analysis of object-oriented programming languages. In Proceedings of the 12th International Conference on Compiler Construction (CC’03). Springer-Verlag, Berlin, 126--137. http://dl.acm.org/citation.cfm?id=1765931.1765945
[89]
Mooly Sagiv, Thomas Reps, and Reinhard Wilhelm. 1996. Solving shape-analysis problems in languages with destructive updating. In Proceedings of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’96). ACM, New York, NY, 16--31.
[90]
Mooly Sagiv, Thomas Reps, and Reinhard Wilhelm. 1998. Solving shape-analysis problems in languages with destructive updating. ACM Trans. Program. Lang. Syst. 20, 1 (Jan. 1998), 1--50.
[91]
Mooly Sagiv, Thomas Reps, and Reinhard Wilhelm. 1999. Parametric shape analysis via 3-valued logic. In Proceedings of the 26th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’99). ACM, New York, NY, 105--118.
[92]
Mooly Sagiv, Thomas Reps, and Reinhard Wilhelm. 2007. Shape analysis and applications. In Compiler Design Handbook: Optimizations and Machine Code Generation, Y. N. Srikant and P. Shankar (Eds.). CRC Press, Inc, Boca Raton, FL, Chapter 12, 1--44.
[93]
Damien Sereni. 2006. Termination Analysis of Higher-Order Functional Programs. Ph.D. Dissertation. Oxford University.
[94]
Ran Shaham, Eran Yahav, Elliot K. Kolodner, and Mooly Sagiv. 2003. Establishing local temporal heap safety properties with applications to compile-time memory management. In Proceedings of the 10th International Conference on Static Analysis (SAS’03). Springer-Verlag, Berlin, 483--503. http://dl.acm.org/citation.cfm?id=1760267.1760304
[95]
Marc Shapiro II and Susan Horwitz. 1997. The effects of the precision of pointer analysis. In Proceedings of the 4th International Symposium on Static Analysis (SAS’97). Springer-Verlag, London, 16--34. http://dl.acm.org/citation.cfm?id=647166.717860
[96]
Elodie-Jane Sims. 2007. Pointer Analysis and Separation Logic. Ph.D. Dissertation. Kansas State University.
[97]
Yannis Smaragdakis and George Balatsouras. 2015. Pointer analysis. Found. Trends Program. Lang. 2, 1 (April 2015), 1--69.
[98]
Yannis Smaragdakis, Martin Bravenboer, and Ondřej Lhoták. 2011. Pick your contexts well: Understanding object-sensitivity. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’11). ACM, New York, NY, 17--30.
[99]
Manu Sridharan and Rastislav Bodík. 2006. Refinement-based context-sensitive points-to analysis for java. In Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’06). ACM, New York, NY, 387--400.
[100]
Manu Sridharan, Satish Chandra, Julian Dolby, Stephen J. Fink, and Eran Yahav. 2013. Aliasing in object-oriented programming. In Alias Analysis for Object-oriented Programs, Dave Clarke, James Noble, and Tobias Wrigstad (Eds.). Springer-Verlag, Berlin, 196--232. http://dl.acm.org/citation. cfm?id=2554511.2554523
[101]
Y. N. Srikant and Priti Shankar. 2007. The Compiler Design Handbook: Optimizations and Machine Code Generation, Second Edition (2nd ed.). CRC Press, Inc., Boca Raton, FL.
[102]
Bjarne Steensgaard. 1996. Points-to analysis in almost linear time. In Proceedings of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’96). ACM, New York, NY, 32--41.
[103]
Vijay Sundaresan, Laurie Hendren, Chrislain Razafimahefa, Raja Vallée-Rai, Patrick Lam, Etienne Gagnon, and Charles Godin. 2000. Practical virtual method call resolution for java. In Proceedings of the 15th ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA’00). ACM, New York, NY, 264--280.
[104]
Frédéric Vivien and Martin Rinard. 2001. Incrementalized pointer and escape analysis. In Proceedings of the ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation (PLDI’01). ACM, New York, NY, 35--46.
[105]
John Whaley and Monica S. Lam. 2004. Cloning-based context-sensitive pointer alias analysis using binary decision diagrams. In Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation (PLDI’04). ACM, New York, NY, 131--144.
[106]
Reinhard Wilhelm, Shmuel Sagiv, and Thomas W. Reps. 2000. Shape analysis. In Proceedings of the 9th International Conference on Compiler Construction (CC’00). Springer-Verlag, London, 1--17. http://dl.acm.org/citation. cfm?id=647476.760384
[107]
Yichen Xie and Alex Aiken. 2007. Saturn: A scalable framework for error detection using boolean satisfiability. ACM Trans. Program. Lang. Syst. 29, 3, Article 16 (May 2007), 43 pages.
[108]
Guoqing Xu and Atanas Rountev. 2008. Merging equivalent contexts for scalable heap-cloning-based context-sensitive points-to analysis. In Proceedings of the 2008 International Symposium on Software Testing and Analysis (ISSTA’08). ACM, New York, NY, 225--236.
[109]
Xin Zhang, Ravi Mangal, Mayur Naik, and Hongseok Yang. 2014. Hybrid top-down and bottom-up interprocedural analysis. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’14). ACM, New York, NY, 249--258.
[110]
Jianwen Zhu. 2002. Symbolic pointer analysis. In Proceedings of the 2002 IEEE/ACM International Conference on Computer-aided Design (ICCAD’02). ACM, New York, NY, 150--157.

Cited By

View all

Index Terms

  1. Heap Abstractions for Static Analysis

    Recommendations

    Comments

    Information & Contributors

    Information

    Published In

    cover image ACM Computing Surveys
    ACM Computing Surveys  Volume 49, Issue 2
    June 2017
    747 pages
    ISSN:0360-0300
    EISSN:1557-7341
    DOI:10.1145/2966278
    • Editor:
    • Sartaj Sahni
    Issue’s Table of Contents
    © 2016 Association for Computing Machinery. ACM acknowledges that this contribution was authored or co-authored by an employee, contractor or affiliate of a national government. As such, the Government retains a nonexclusive, royalty-free right to publish or reproduce this article, or to allow others to do so, for Government purposes only.

    Publisher

    Association for Computing Machinery

    New York, NY, United States

    Publication History

    Published: 30 June 2016
    Accepted: 01 April 2016
    Revised: 01 February 2016
    Received: 01 April 2014
    Published in CSUR Volume 49, Issue 2

    Permissions

    Request permissions for this article.

    Check for updates

    Author Tags

    1. Abstraction
    2. heap
    3. pointers
    4. shape analysis
    5. static analysis
    6. store based
    7. storeless
    8. summarization

    Qualifiers

    • Survey
    • Research
    • Refereed

    Funding Sources

    • TCS Fellowship

    Contributors

    Other Metrics

    Bibliometrics & Citations

    Bibliometrics

    Article Metrics

    • Downloads (Last 12 months)126
    • Downloads (Last 6 weeks)9
    Reflects downloads up to 20 Jan 2025

    Other Metrics

    Citations

    Cited By

    View all

    View Options

    Login options

    Full Access

    View options

    PDF

    View or Download as a PDF file.

    PDF

    eReader

    View online with eReader.

    eReader

    Media

    Figures

    Other

    Tables

    Share

    Share

    Share this Publication link

    Share on social media