skip to main content

Return of CFA: call-site sensitivity can be superior to object sensitivity even for object-oriented programs

Published:12 January 2022Publication History
Skip Abstract Section

Abstract

In this paper, we challenge the commonly-accepted wisdom in static analysis that object sensitivity is superior to call-site sensitivity for object-oriented programs. In static analysis of object-oriented programs, object sensitivity has been established as the dominant flavor of context sensitivity thanks to its outstanding precision. On the other hand, call-site sensitivity has been regarded as unsuitable and its use in practice has been constantly discouraged for object-oriented programs. In this paper, however, we claim that call-site sensitivity is generally a superior context abstraction because it is practically possible to transform object sensitivity into more precise call-site sensitivity. Our key insight is that the previously known superiority of object sensitivity holds only in the traditional k-limited setting, where the analysis is enforced to keep the most recent k context elements. However, it no longer holds in a recently-proposed, more general setting with context tunneling. With context tunneling, where the analysis is free to choose an arbitrary k-length subsequence of context strings, we show that call-site sensitivity can simulate object sensitivity almost completely, but not vice versa. To support the claim, we present a technique, called Obj2CFA, for transforming arbitrary context-tunneled object sensitivity into more precise, context-tunneled call-site-sensitivity. We implemented Obj2CFA in Doop and used it to derive a new call-site-sensitive analysis from a state-of-the-art object-sensitive pointer analysis. Experimental results confirm that the resulting call-site sensitivity outperforms object sensitivity in precision and scalability for real-world Java programs. Remarkably, our results show that even 1-call-site sensitivity can be more precise than the conventional 3-object-sensitive analysis.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

This is a teaser video of my talk at POPL 2022 on our paper "Return of CFA: Call-Site Sensitivity Can Be Superior to Object Sensitivity Even for Object-Oriented Programs" accepted in the research track. In this paper, we challenge the commonly-accepted wisdom in static analysis that object sensitivity is superior to call-site sensitivity for object-oriented programs.

References

  1. Pavol Bielik, Veselin Raychev, and Martin Vechev. 2017. Learning a Static Analyzer from Data. In Computer Aided Verification, Rupak Majumdar and Viktor Kunčak (Eds.). Springer International Publishing, Cham. 233–253. isbn:978-3-319-63387-9Google ScholarGoogle Scholar
  2. Stephen M. Blackburn, Robin Garner, Chris Hoffmann, Asjad M. Khang, Kathryn S. McKinley, Rotem Bentzur, Amer Diwan, Daniel Feinberg, Daniel Frampton, Samuel Z. Guyer, Martin Hirzel, Antony Hosking, Maria Jump, Han Lee, J. Eliot B. Moss, Aashish Phansalkar, Darko Stefanović, Thomas VanDrunen, Daniel von Dincklage, and Ben Wiedermann. 2006. The DaCapo Benchmarks: Java Benchmarking Development and Analysis. In Proceedings of the 21st Annual ACM SIGPLAN Conference on Object-oriented Programming Systems, Languages, and Applications (OOPSLA ’06). ACM, New York, NY, USA. 169–190. isbn:1-59593-348-4 https://doi.org/10.1145/1167473.1167488 Google ScholarGoogle ScholarDigital LibraryDigital Library
  3. Martin Bravenboer and Yannis Smaragdakis. 2009. Strictly Declarative Specification of Sophisticated Points-to Analyses. In Proceedings of the 24th ACM SIGPLAN Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA ’09). ACM, New York, NY, USA. 243–262. isbn:978-1-60558-766-0 https://doi.org/10.1145/1640089.1640108 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Andrei Marian Dan, Manu Sridharan, Satish Chandra, Jean-Baptiste Jeannin, and Martin Vechev. 2017. Finding Fix Locations for CFL-Reachability Analyses via Minimum Cuts. In Computer Aided Verification, Rupak Majumdar and Viktor Kunčak (Eds.). Springer International Publishing, Cham. 521–541. isbn:978-3-319-63390-9Google ScholarGoogle Scholar
  5. Yu Feng, Saswat Anand, Isil Dillig, and Alex Aiken. 2014. Apposcopy: Semantics-based Detection of Android Malware Through Static Analysis. In Proceedings of the 22Nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2014). ACM, New York, NY, USA. 576–587. isbn:978-1-4503-3056-5 https://doi.org/10.1145/2635868.2635869 Google ScholarGoogle ScholarDigital LibraryDigital Library
  6. Stephen J. Fink, Eran Yahav, Nurit Dor, G. Ramalingam, and Emmanuel Geay. 2008. Effective Typestate Verification in the Presence of Aliasing. ACM Trans. Softw. Eng. Methodol., 17, 2 (2008), Article 9, May, 34 pages. issn:1049-331X https://doi.org/10.1145/1348250.1348255 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Michael I. Gordon, Deokhwan Kim, Jeff H. Perkins, Limei Gilham, Nguyen Nguyen, and Martin C. Rinard. 2015. Information Flow Analysis of Android Applications in DroidSafe. In 22nd Annual Network and Distributed System Security Symposium, NDSS 2015, San Diego, California, USA, February 8-11, 2015. The Internet Society. https://www.ndss-symposium.org/ndss2015/information-flow-analysis-android-applications-droidsafeGoogle ScholarGoogle Scholar
  8. Radu Grigore and Hongseok Yang. 2016. Abstraction Refinement Guided by a Learnt Probabilistic Model. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’16). ACM, New York, NY, USA. 485–498. isbn:978-1-4503-3549-2 https://doi.org/10.1145/2837614.2837663 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Jingxuan He, Gagandeep Singh, Markus Püschel, and Martin Vechev. 2020. Learning Fast and Precise Numerical Analysis. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2020). Association for Computing Machinery, New York, NY, USA. 1112–1127. isbn:9781450376136 https://doi.org/10.1145/3385412.3386016 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Kihong Heo, Hakjoo Oh, and Hongseok Yang. 2019. Resource-aware Program Analysis via Online Abstraction Coarsening. In Proceedings of the 41st International Conference on Software Engineering (ICSE ’19). IEEE Press, Piscataway, NJ, USA. 94–104. https://doi.org/10.1109/ICSE.2019.00027 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Kihong Heo, Hakjoo Oh, and Kwangkeun Yi. 2017. Machine-learning-guided Selectively Unsound Static Analysis. In Proceedings of the 39th International Conference on Software Engineering (ICSE ’17). IEEE Press, Piscataway, NJ, USA. 519–529. isbn:978-1-5386-3868-2 https://doi.org/10.1109/ICSE.2017.54 Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Minseok Jeon, Sehun Jeong, Sungdeok Cha, and Hakjoo Oh. 2019. A Machine-Learning Algorithm with Disjunctive Model for Data-Driven Program Analysis. ACM Trans. Program. Lang. Syst., 41, 2 (2019), Article 13, June, 41 pages. issn:0164-0925 https://doi.org/10.1145/3293607 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Minseok Jeon, Sehun Jeong, and Hakjoo Oh. 2018. Precise and Scalable Points-to Analysis via Data-driven Context Tunneling. Proc. ACM Program. Lang., 2, OOPSLA (2018), Article 140, Oct., 29 pages. issn:2475-1421 https://doi.org/10.1145/3276510 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. Minseok Jeon, Myungho Lee, and Hakjoo Oh. 2020. Learning Graph-Based Heuristics for Pointer Analysis without Handcrafting Application-Specific Features. Proc. ACM Program. Lang., 4, OOPSLA (2020), Article 179, Nov., 30 pages. https://doi.org/10.1145/3428247 Google ScholarGoogle ScholarDigital LibraryDigital Library
  15. Sehun Jeong, Minseok Jeon, Sungdeok Cha, and Hakjoo Oh. 2017. Data-driven Context-sensitivity for Points-to Analysis. Proc. ACM Program. Lang., 1, OOPSLA (2017), Article 100, Oct., 28 pages. issn:2475-1421 https://doi.org/10.1145/3133924 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. George Kastrinis and Yannis Smaragdakis. 2013. Hybrid Context-sensitivity for Points-to Analysis. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’13). ACM, New York, NY, USA. 423–434. isbn:978-1-4503-2014-6 https://doi.org/10.1145/2491956.2462191 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Uday P. Khedker and Bageshri Karkare. 2008. Efficiency, Precision, Simplicity, and Generality in Interprocedural Data Flow Analysis: Resurrecting the Classical Call Strings Method. In Compiler Construction, Laurie Hendren (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg. 213–228. isbn:978-3-540-78791-4Google ScholarGoogle Scholar
  18. Uday P. Khedker, Alan Mycroft, and Prashant Singh Rawat. 2012. Liveness-Based Pointer Analysis. In Static Analysis, Antoine Miné and David Schmidt (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg. 265–282. isbn:978-3-642-33125-1Google ScholarGoogle Scholar
  19. Ondřej Lhoták and Laurie Hendren. 2006. Context-Sensitive Points-to Analysis: Is It Worth It? In Compiler Construction, Alan Mycroft and Andreas Zeller (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg. 47–64. isbn:978-3-540-33051-6Google ScholarGoogle Scholar
  20. Ondřej Lhoták and Laurie Hendren. 2008. Evaluating the Benefits of Context-sensitive Points-to Analysis Using a BDD-based Implementation. ACM Trans. Softw. Eng. Methodol., 18, 1 (2008), Article 3, Oct., 53 pages. issn:1049-331X https://doi.org/10.1145/1391984.1391987 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Yue Li, Tian Tan, Anders Møller, and Yannis Smaragdakis. 2018. Precision-guided Context Sensitivity for Pointer Analysis. Proc. ACM Program. Lang., 2, OOPSLA (2018), Article 141, Oct., 29 pages. issn:2475-1421 https://doi.org/10.1145/3276511 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Yue Li, Tian Tan, Anders Møller, and Yannis Smaragdakis. 2018. Scalability-first Pointer Analysis with Self-tuning Context-sensitivity. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2018). ACM, New York, NY, USA. 129–140. isbn:978-1-4503-5573-5 https://doi.org/10.1145/3236024.3236041 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Yue Li, Tian Tan, Anders Møller, and Yannis Smaragdakis. 2020. A Principled Approach to Selective Context Sensitivity for Pointer Analysis. ACM Trans. Program. Lang. Syst., 42, 2 (2020), Article 10, May, 40 pages. issn:0164-0925 https://doi.org/10.1145/3381915 Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Donglin Liang, Maikel Pennings, and Mary Jean Harrold. 2005. Evaluating the Impact of Context-sensitivity on Andersen’s Algorithm for Java Programs. In Proceedings of the 6th ACM SIGPLAN-SIGSOFT Workshop on Program Analysis for Software Tools and Engineering (PASTE ’05). ACM, New York, NY, USA. 6–12. isbn:1-59593-239-9 https://doi.org/10.1145/1108792.1108797 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. 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, USA. 590–601. isbn:978-1-4503-0663-8 https://doi.org/10.1145/1993498.1993567 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Percy Liang, Omer Tripp, and Mayur Naik. 2011. Learning Minimal Abstractions. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’11). ACM, New York, NY, USA. 31–42. isbn:978-1-4503-0490-0 https://doi.org/10.1145/1926385.1926391 Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Jingbo Lu and Jingling Xue. 2019. Precision-preserving Yet Fast Object-sensitive Pointer Analysis with Partial Context Sensitivity. Proc. ACM Program. Lang., 3, OOPSLA (2019), Article 148, Oct., 29 pages. issn:2475-1421 https://doi.org/10.1145/3360574 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Matthew Might, Yannis Smaragdakis, and David Van Horn. 2010. Resolving and Exploiting the k-CFA Paradox: Illuminating Functional vs. Object-Oriented Program Analysis. In Proceedings of the 31st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’10). Association for Computing Machinery, New York, NY, USA. 305–315. isbn:9781450300193 https://doi.org/10.1145/1806596.1806631 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Ana Milanova, Atanas Rountev, and Barbara G. Ryder. 2002. Parameterized Object Sensitivity for Points-to and Side-effect Analyses for Java. In Proceedings of the 2002 ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA ’02). ACM, New York, NY, USA. 1–11. isbn:1-58113-562-9 https://doi.org/10.1145/566172.566174 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Ana Milanova, Atanas Rountev, and Barbara G. Ryder. 2005. Parameterized Object Sensitivity for Points-to Analysis for Java. ACM Trans. Softw. Eng. Methodol., 14, 1 (2005), Jan., 1–41. issn:1049-331X https://doi.org/10.1145/1044834.1044835 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Mayur Naik, Alex Aiken, and John Whaley. 2006. Effective Static Race Detection for Java. In Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’06). ACM, New York, NY, USA. 308–319. isbn:1-59593-320-4 https://doi.org/10.1145/1133981.1134018 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Hakjoo Oh, Wonchan Lee, Kihong Heo, Hongseok Yang, and Kwangkeun Yi. 2014. Selective Context-sensitivity Guided by Impact Pre-analysis. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’14). ACM, New York, NY, USA. 475–484. isbn:978-1-4503-2784-8 https://doi.org/10.1145/2594291.2594318 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Hakjoo Oh, Hongseok Yang, and Kwangkeun Yi. 2015. Learning a Strategy for Adapting a Program Analysis via Bayesian Optimisation. In Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2015). ACM, New York, NY, USA. 572–588. isbn:978-1-4503-3689-5 https://doi.org/10.1145/2814270.2814309 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, Jake Vanderplas, Alexandre Passos, David Cournapeau, Matthieu Brucher, Matthieu Perrot, and Édouard Duchesnay. 2011. Scikit-learn: Machine Learning in Python. J. Mach. Learn. Res., 12 (2011), Nov., 2825–2830. issn:1532-4435 http://dl.acm.org/citation.cfm?id=1953048.2078195Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Hila Peleg, Sharon Shoham, and Eran Yahav. 2016. D^3: Data-Driven Disjunctive Abstraction. In Verification, Model Checking, and Abstract Interpretation, Barbara Jobstmann and K. Rustan M. Leino (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg. 185–205. isbn:978-3-662-49122-5Google ScholarGoogle Scholar
  36. Micha Sharir and Amir Pnueli. 1981. Two approaches to interprocedural data flow analysis. Prentice-Hall, Englewood Cliffs, NJ. 189–234.Google ScholarGoogle Scholar
  37. O. Shivers. 1988. Control Flow Analysis in Scheme. In Proceedings of the ACM SIGPLAN 1988 Conference on Programming Language Design and Implementation (PLDI ’88). ACM, New York, NY, USA. 164–174. isbn:0-89791-269-1 https://doi.org/10.1145/53990.54007 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Gagandeep Singh, Markus Püschel, and Martin Vechev. 2018. Fast Numerical Program Analysis with Reinforcement Learning. In Computer Aided Verification, Hana Chockler and Georg Weissenbacher (Eds.). Springer International Publishing, Cham. 211–229. isbn:978-3-319-96145-3Google ScholarGoogle Scholar
  39. Yannis Smaragdakis and George Balatsouras. 2015. Pointer Analysis. Foundations and Trends in Programming Languages, 2, 1 (2015), 1–69. https://doi.org/10.1561/2500000014 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Yannis Smaragdakis, Martin Bravenboer, and Ondrej 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, USA. 17–30. isbn:978-1-4503-0490-0 https://doi.org/10.1145/1926385.1926390 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Yannis Smaragdakis, George Kastrinis, and George Balatsouras. 2014. Introspective Analysis: Context-sensitivity, Across the Board. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’14). ACM, New York, NY, USA. 485–495. isbn:978-1-4503-2784-8 https://doi.org/10.1145/2594291.2594320 Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. Johannes Späth, Lisa Nguyen Quang Do, Karim Ali, and Eric Bodden. 2016. Boomerang: Demand-Driven Flow- and Context-Sensitive Pointer Analysis for Java. In 30th European Conference on Object-Oriented Programming (ECOOP 2016), Shriram Krishnamurthi and Benjamin S. Lerner (Eds.) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 56). Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik, Dagstuhl, Germany. 22:1–22:26. isbn:978-3-95977-014-9 issn:1868-8969 https://doi.org/10.4230/LIPIcs.ECOOP.2016.22 Google ScholarGoogle Scholar
  43. 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, USA. 387–400. isbn:1-59593-320-4 https://doi.org/10.1145/1133981.1134027 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Manu Sridharan, Julian Dolby, Satish Chandra, Max Schäfer, and Frank Tip. 2012. Correlation Tracking for Points-to Analysis of Javascript. In Proceedings of the 26th European Conference on Object-Oriented Programming (ECOOP’12). Springer-Verlag, Berlin, Heidelberg. 435–458. isbn:978-3-642-31056-0 https://doi.org/10.1007/978-3-642-31057-7_20 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Manu Sridharan, Denis Gopan, Lexin Shan, and Rastislav Bodík. 2005. Demand-driven Points-to Analysis for Java. In Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA ’05). ACM, New York, NY, USA. 59–76. isbn:1-59593-031-0 https://doi.org/10.1145/1094811.1094817 Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Tian Tan, Yue Li, and Jingling Xue. 2016. Making k-Object-Sensitive Pointer Analysis More Precise with Still k-Limiting. In Static Analysis, Xavier Rival (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg. 489–510. isbn:978-3-662-53413-7Google ScholarGoogle Scholar
  47. Tian Tan, Yue Li, and Jingling Xue. 2017. Efficient and Precise Points-to Analysis: Modeling the Heap by Merging Equivalent Automata. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM, New York, NY, USA. 278–291. isbn:978-1-4503-4988-8 https://doi.org/10.1145/3062341.3062360 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Manas Thakur and V. Krishna Nandivada. 2019. Compare Less, Defer More: Scaling Value-contexts Based Whole-program Heap Analyses. In Proceedings of the 28th International Conference on Compiler Construction (CC 2019). ACM, New York, NY, USA. 135–146. isbn:978-1-4503-6277-1 https://doi.org/10.1145/3302516.3307359 Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Rei Thiessen and Ondřej Lhoták. 2017. Context Transformations for Pointer Analysis. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM, New York, NY, USA. 263–277. isbn:978-1-4503-4988-8 https://doi.org/10.1145/3062341.3062359 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Omer Tripp, Marco Pistoia, Stephen J. Fink, Manu Sridharan, and Omri Weisman. 2009. TAJ: Effective Taint Analysis of Web Applications. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’09). ACM, New York, NY, USA. 87–97. isbn:978-1-60558-392-1 https://doi.org/10.1145/1542476.1542486 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Shiyi Wei and Barbara G. Ryder. 2015. Adaptive Context-sensitive Analysis for JavaScript. In 29th European Conference on Object-Oriented Programming (ECOOP 2015), John Tang Boyland (Ed.) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 37). Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik, Dagstuhl, Germany. 712–734. isbn:978-3-939897-86-6 issn:1868-8969 https://doi.org/10.4230/LIPIcs.ECOOP.2015.712 Google ScholarGoogle ScholarCross RefCross Ref
  52. 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, USA. 131–144. isbn:1-58113-807-5 https://doi.org/10.1145/996841.996859 Google ScholarGoogle ScholarDigital LibraryDigital Library
  53. 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, USA. 225–236. isbn:978-1-60558-050-0 https://doi.org/10.1145/1390630.1390658 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Guoqing Xu, Atanas Rountev, and Manu Sridharan. 2009. Scaling CFL-Reachability-Based Points-To Analysis Using Context-Sensitive Must-Not-Alias Analysis. In ECOOP 2009 – Object-Oriented Programming, Sophia Drossopoulou (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg. 98–122. isbn:978-3-642-03013-0Google ScholarGoogle Scholar
  55. X. Xu, Y. Sui, H. Yan, and J. Xue. 2019. VFix: Value-Flow-Guided Precise Program Repair for Null Pointer Dereferences. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). 512–523.Google ScholarGoogle Scholar
  56. Xin Zhang, Ravi Mangal, Radu Grigore, Mayur Naik, and Hongseok Yang. 2014. On Abstraction Refinement for Program Analyses in Datalog. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’14). ACM, New York, NY, USA. 239–248. isbn:978-1-4503-2784-8 https://doi.org/10.1145/2594291.2594327 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Return of CFA: call-site sensitivity can be superior to object sensitivity even for object-oriented programs

    Recommendations

    Comments

    Login options

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

    Sign in

    Full Access

    PDF Format

    View or Download as a PDF file.

    PDF

    eReader

    View online with eReader.

    eReader
    About Cookies On This Site

    We use cookies to ensure that we give you the best experience on our website.

    Learn more

    Got it!