research-article

Open access

Refinement in object-sensitivity points-to analysis via slicing

Authors:

Girish Maskeri Rama,

Raghavan Komondoor,

Himanshu SharmaAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 2, Issue OOPSLA

Article No.: 142, Pages 1 - 27

https://doi.org/10.1145/3276512

Published: 24 October 2018 Publication History

Abstract

Object sensitivity analysis is a well-known form of context-sensitive points-to analysis. This analysis is parameterized by a bound on the names of symbolic objects associated with each allocation site. In this paper, we propose a novel approach based on object sensitivity analysis that takes as input a set of client queries, and tries to answer them using an initial round of inexpensive object sensitivity analysis that uses a low object-name length bound at all allocation sites. For the queries that are answered unsatisfactorily, the approach then pin points "bad" points-to facts, which are the ones that are responsible for the imprecision. It then employs a form of program slicing to identify allocation sites that are potentially causing these bad points-to facts to be generated. The approach then runs object sensitivity analysis once again, this time using longer names for just these allocation sites, with the objective of resolving the imprecision in this round. We describe our approach formally, prove its completeness, and describe a Datalog-based implementation of it on top of the Petablox framework. Our evaluation of our approach on a set of large Java benchmarks, using two separate clients, reveals that our approach is more precise than the baseline object sensitivity approach, by around 29% for one of the clients and by around 19% for the other client. Our approach is also more precise on most large benchmarks than a recently proposed approach that uses SAT solvers to identify allocation sites to refine.

Supplementary Material

WEBM File (a142-rama.webm)

Download
110.68 MB

References

[1]

Michael Burke, Paul Carini, Jong-Deok Choi, and Michael Hind. 1994. Flow-insensitive interprocedural alias analysis in the presence of pointers. In International Workshop on Languages and Compilers for Parallel Computing. Springer, 234–250.

Digital Library

[2]

G. Canfora, A. Cimitile, and A. De Lucia. 1998. Conditioned program slicing. Information and Software Technology 40, 11 (1998), 595–607.

[3]

Ramkrishna Chatterjee, Barbara G. Ryder, and William A. Landi. 1999. Relevant Context Inference. In Proc. ACM Symposium on Principles of Programming Languages (POPL ’99). ACM, 133–146.

Digital Library

[4]

Zhenqiang Chen and Baowen Xu. 2001. Slicing Object-oriented Java Programs. SIGPLAN Not. 36, 4 (April 2001), 33–40.

Digital Library

[5]

Maryam Emami, Rakesh Ghiya, and Laurie J. Hendren. 1994. Context-sensitive Interprocedural Points-to Analysis in the Presence of Function Pointers. In Proc. ACM Conference on Programming Language Design and Implementation (PLDI ’94). ACM, 242–256.

Digital Library

[6]

Jeanne Ferrante, Karl J Ottenstein, and Joe D Warren. 1987. The program dependence graph and its use in optimization. ACM Transactions on Programming Languages and Systems (TOPLAS) 9, 3 (1987), 319–349.

Digital Library

[7]

John Field, G. Ramalingam, and Frank Tip. 1995. Parametric Program Slicing. In Proc. Int. Symp. on Principles of Prog. Langs. (POPL). 379–392.

Digital Library

[8]

Samuel Z Guyer and Calvin Lin. 2003. Client-driven pointer analysis. In International Static Analysis Symposium (SAS). Springer, 214–236.

Digital Library

[9]

Christian Haack, Erik Poll, Jan Schäfer, and Aleksy Schubert. 2007. Immutable objects for a Java-like language. In European Symposium on Programming. Springer, 347–362.

Digital Library

[10]

Christian Hammer and Gregor Snelting. 2004. An Improved Slicer for Java. In Proc. 5th ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering (PASTE ’04). ACM, 17–22.

Digital Library

[11]

M. Harman, R. Hierons, C. Fox, S. Danicic, and J. Howroyd. 2001. Pre/post conditioned slicing. In Proc. Int. Conf. on Software Maintenance (ICSM). 138–147.

Digital Library

[12]

Susan Horwitz, Thomas Reps, and David Binkley. 1990. Interprocedural slicing using dependence graphs. ACM Transactions on Programming Languages and Systems (TOPLAS) 12, 1 (1990), 26–60.

Digital Library

[13]

Vini Kanvar and Uday P Khedker. 2016. Heap abstractions for static analysis. ACM Computing Surveys (CSUR) 49, 2 (2016), 29.

Digital Library

[14]

Ondřej Lhoták and Laurie Hendren. 2006. Context-sensitive points-to analysis: is it worth it?. In International Conference on Compiler Construction. Springer, 47–64.

Digital Library

[15]

Donglin Liang and Mary Jean Harrold. 1998. Slicing objects using system dependence graphs. In Proc. International Conference on Software Maintenance. IEEE, 358–367.

Digital Library

[16]

Percy Liang and Mayur Naik. 2011. Scaling Abstraction Refinement via Pruning. In Proc. ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’11). ACM, 590–601.

Digital Library

[17]

Ravichandhran Madhavan, Ganesan Ramalingam, and Kapil Vaswani. 2012. Modular heap analysis for higher-order programs. In International Static Analysis Symposium. Springer, 370–387.

Digital Library

[18]

D. Marinov and R. O’Callahan. 2003. Object equality profiling. In Proc. Conf. on Object-Oriented programing, Systems, languages, and applications.

Digital Library

[19]

R. K. Medicherla and R. Komondoor. 2015. Precision vs. scalability: Context sensitive analysis with prefix approximation. In 2015 IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER). 281–290.

[20]

Ana Milanova, Atanas Rountev, and Barbara G Ryder. 2005. Parameterized object sensitivity for points-to analysis for Java. ACM Transactions on Software Engineering and Methodology (TOSEM) 14, 1 (2005), 1–41.

Digital Library

[21]

Hakjoo Oh, Wonchan Lee, Kihong Heo, Hongseok Yang, and Kwangkeun Yi. 2014. Selective Context-sensitivity Guided by Impact Pre-analysis. In Proc. ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’14). ACM, 475–484.

Digital Library

[22]

Sara Porat, Marina Biberstein, Larry Koved, and Bilha Mendelson. 2000. Automatic Detection of Immutable Fields in Java. In Proc. of the 2000 Conference of the Centre for Advanced Studies on Collaborative Research (CASCON ’00). IBM Press, 10–.

Digital Library

[23]

Thomas W Reps. 1995. Demand interprocedural program analysis using logic databases. In Applications of Logic Databases. Springer, 163–196.

[24]

Yannis Smaragdakis and George Balatsouras. 2015. Pointer Analysis. Foundations and TrendsÂő in Programming Languages 2, 1 (2015), 1–69.

Digital Library

[25]

Yannis Smaragdakis, Martin Bravenboer, and Ondrej Lhoták. 2011. Pick Your Contexts Well: Understanding Object-sensitivity. In Proc. ACM Symposium on Principles of Programming Languages (POPL ’11). ACM, 17–30.

Digital Library

[26]

Yannis Smaragdakis, George Kastrinis, and George Balatsouras. 2014. Introspective Analysis: Context-sensitivity, Across the Board. In Proc. ACM Conference on Programming Language Design and Implementation (PLDI ’14). ACM, 485–495.

Digital Library

[27]

Manu Sridharan and Rastislav Bodík. 2006. Refinement-based Context-sensitive Points-to Analysis for Java. In Proc. ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’06). ACM, 387–400.

Digital Library

[28]

Manu Sridharan, Satish Chandra, Julian Dolby, Stephen J Fink, and Eran Yahav. 2013. Alias analysis for object-oriented programs. In Aliasing in Object-Oriented Programming. Types, Analysis and Verification. Springer, 196–232.

Digital Library

[29]

Manu Sridharan, Stephen J. Fink, and Rastislav Bodik. 2007. Thin slicing. In PLDI ’07: Proc. Conference on Programming Language Design and Implementation. 112–122.

Digital Library

[30]

Tian Tan, Yue Li, and Jingling Xue. 2016. Making k-object-sensitive pointer analysis more precise with still k-limiting. In International Static Analysis Symposium. Springer, 489–510.

[31]

Mark Weiser. 1981. Program slicing. In Proc. International Conference On Software Engineering. IEEE Press, 439–449.

Digital Library

[32]

John Whaley and Monica S Lam. 2004. Cloning-based context-sensitive pointer alias analysis using binary decision diagrams. In PLDI ’04: Proc. Conference on Programming Language Design and Implementation. ACM, 131–144.

Digital Library

[33]

Xin Zhang, Ravi Mangal, Radu Grigore, Mayur Naik, and Hongseok Yang. 2014. On Abstraction Refinement for Program Analyses in Datalog. In Proc. ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’14). ACM, 239–248.

Digital Library

Cited By

Halalingaiah SSundaresan VMaier DNandivada V(2024)The ART of Sharing Points-to Analysis: Reusing Points-to Analysis Results Safely and EfficientlyProceedings of the ACM on Programming Languages10.1145/36898038:OOPSLA2(2606-2632)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689803
Anand AThakur M(2024)Partial program analysis for staged compilation systemsFormal Methods in System Design10.1007/s10703-024-00458-xOnline publication date: 13-Jun-2024
https://doi.org/10.1007/s10703-024-00458-x
Anand AThakur M(2022)Principles of Staged Static+Dynamic Partial AnalysisStatic Analysis10.1007/978-3-031-22308-2_4(44-73)Online publication date: 2-Dec-2022
https://doi.org/10.1007/978-3-031-22308-2_4
Show More Cited By

Index Terms

Refinement in object-sensitivity points-to analysis via slicing
1. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language types
        Object oriented languages
  2. Software organization and properties
    1. Extra-functional properties
      1. Software safety
    2. Software functional properties
      1. Formal methods
        Automated static analysis
        Software verification

Recommendations

Precision-guided context sensitivity for pointer analysis

Context sensitivity is an essential technique for ensuring high precision in Java pointer analyses. It has been observed that applying context sensitivity partially, only on a select subset of the methods, can improve the balance between analysis ...
Demand-driven refinement of points-to analysis
ICSE '19: Proceedings of the 41st International Conference on Software Engineering: Companion Proceedings

We present DynaSens, a demand-driven approach to points-to analysis that uses slicing to automatically adjust the analysis' context-sensitivity. Within a points-to analysis, heap-carried data flows are composed of loads and stores, and these heap-...
Parameterized object sensitivity for points-to analysis for Java

The goal of points-to analysis for Java is to determine the set of objects pointed to by a reference variable or a reference object field. We present object sensitivity, a new form of context sensitivity for flow-insensitive points-to analysis for Java. ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 2, Issue OOPSLA

November 2018

1656 pages

EISSN:2475-1421

DOI:10.1145/3288538

Issue’s Table of Contents

Copyright © 2018 Owner/Author.

This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 24 October 2018

Published in PACMPL Volume 2, Issue OOPSLA

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

6
Total Citations
View Citations
588
Total Downloads

Downloads (Last 12 months)90
Downloads (Last 6 weeks)18

Reflects downloads up to 08 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

Halalingaiah SSundaresan VMaier DNandivada V(2024)The ART of Sharing Points-to Analysis: Reusing Points-to Analysis Results Safely and EfficientlyProceedings of the ACM on Programming Languages10.1145/36898038:OOPSLA2(2606-2632)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689803
Anand AThakur M(2024)Partial program analysis for staged compilation systemsFormal Methods in System Design10.1007/s10703-024-00458-xOnline publication date: 13-Jun-2024
https://doi.org/10.1007/s10703-024-00458-x
Anand AThakur M(2022)Principles of Staged Static+Dynamic Partial AnalysisStatic Analysis10.1007/978-3-031-22308-2_4(44-73)Online publication date: 2-Dec-2022
https://doi.org/10.1007/978-3-031-22308-2_4
Park JLee HRyu S(2021)A Survey of Parametric Static AnalysisACM Computing Surveys10.1145/346445754:7(1-37)Online publication date: 18-Jul-2021
https://dl.acm.org/doi/10.1145/3464457
Thakur MNandivada VPouchet LJimborean A(2020)Mix your contexts well: opportunities unleashed by recent advances in scaling context-sensitivityProceedings of the 29th International Conference on Compiler Construction10.1145/3377555.3377902(27-38)Online publication date: 22-Feb-2020
https://dl.acm.org/doi/10.1145/3377555.3377902
Vedurada JNandivada VZimmermann TLawall JMarinov D(2019)Batch alias analysisProceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering10.1109/ASE.2019.00091(936-948)Online publication date: 10-Nov-2019
https://dl.acm.org/doi/10.1109/ASE.2019.00091

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Figures

Tables

Media

View Issue’s Table of Contents