skip to main content

Making pointer analysis more precise by unleashing the power of selective context sensitivity

Published:15 October 2021Publication History
Skip Abstract Section

Abstract

Traditional context-sensitive pointer analysis is hard to scale for large and complex Java programs. To address this issue, a series of selective context-sensitivity approaches have been proposed and exhibit promising results. In this work, we move one step further towards producing highly-precise pointer analyses for hard-to-analyze Java programs by presenting the Unity-Relay framework, which takes selective context sensitivity to the next level. Briefly, Unity-Relay is a one-two punch: given a set of different selective context-sensitivity approaches, say S = S1, . . . , Sn, Unity-Relay first provides a mechanism (called Unity)to combine and maximize the precision of all components of S. When Unity fails to scale, Unity-Relay offers a scheme (called Relay) to pass and accumulate the precision from one approach Si in S to the next, Si+1, leading to an analysis that is more precise than all approaches in S. As a proof-of-concept, we instantiate Unity-Relay into a tool called Baton and extensively evaluate it on a set of hard-to-analyze Java programs, using general precision metrics and popular clients. Compared with the state of the art, Baton achieves the best precision for all metrics and clients for all evaluated programs. The difference in precision is often dramatic — up to 71% of alias pairs reported by previously-best algorithms are found to be spurious and eliminated.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

This is a presentation video of the talk at OOPSLA 2021 on our paper accepted in the research track. In this paper, we present the Unity-Relay framework for systematically exploiting a set, S, of selective context-sensitivity approaches, to produce highly-precise pointer analysis results for hard-to-analyze Java programs. Briefly, Unity-Relay is a one-two punch: its first punch, Unity, fully unleashes the precision potential of all approaches in S with good scalability. When Unity fails, the second punch, Relay, can be confidently relied upon to reap precision in a stable and accumulative way. As a proof-of-concept, we instantiate Unity-Relay into a tool called Baton and extensively evaluate it on a set of hard-to-analyze Java programs, using general precision metrics and popular clients. Compared with the state of the art, Baton achieves the best precision for all metrics and clients for all evaluated programs, and the difference in precision is often dramatic.

References

  1. Steven Arzt, Siegfried Rasthofer, Christian Fritz, Eric Bodden, Alexandre Bartel, Jacques Klein, Yves Le Traon, Damien Octeau, and Patrick D. McDaniel. 2014. FlowDroid: precise context, flow, field, object-sensitive and lifecycle-aware taint analysis for Android apps. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’14, Edinburgh, United Kingdom - June 09 - 11, 2014, Michael F. P. O’Boyle and Keshav Pingali (Eds.). ACM, 259–269. https://doi.org/10.1145/2594291.2594299 Google ScholarGoogle ScholarDigital LibraryDigital Library
  2. Stephen M. Blackburn, Robin Garner, Chris Hoffmann, Asjad M. Khan, Kathryn S. McKinley, Rotem Bentzur, Amer Diwan, Daniel Feinberg, Daniel Frampton, Samuel Z. Guyer, Martin Hirzel, Antony L. Hosking, Maria Jump, Han Bok Lee, J. Eliot B. Moss, Aashish Phansalkar, Darko Stefanovic, Thomas VanDrunen, Daniel von Dincklage, and Ben Wiedermann. 2006. The DaCapo benchmarks: Java benchmarking development and analysis. In Proceedings of the 21th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2006, October 22-26, 2006, Portland, Oregon, USA, Peri L. Tarr and William R. Cook (Eds.). ACM, 169–190. https://doi.org/10.1145/1167473.1167488 Google ScholarGoogle ScholarDigital LibraryDigital Library
  3. Eric Bodden, Andreas Sewe, Jan Sinschek, Hela Oueslati, and Mira Mezini. 2011. Taming reflection: Aiding static analysis in the presence of reflection and custom class loaders. In Proceedings of the 33rd International Conference on Software Engineering, ICSE 2011, Waikiki, Honolulu, HI, USA, May 21-28, 2011. 241–250. https://doi.org/10.1145/1985793.1985827 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Martin Bravenboer and Yannis Smaragdakis. 2009. Strictly declarative specification of sophisticated points-to analyses. In Proceedings of the 24th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2009, October 25-29, 2009, Orlando, Florida, USA, Shail Arora and Gary T. Leavens (Eds.). ACM, 243–262. https://doi.org/10.1145/1640089.1640108 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Satish Chandra, Stephen J. Fink, and Manu Sridharan. 2009. Snugglebug: a powerful approach to weakest preconditions. In Proceedings of the 2009 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2009, Dublin, Ireland, June 15-21, 2009, Michael Hind and Amer Diwan (Eds.). ACM, 363–374. https://doi.org/10.1145/1542476.1542517 Google ScholarGoogle ScholarDigital LibraryDigital Library
  6. Maria Christakis and Christian Bird. 2016. What developers want and need from program analysis: an empirical study. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, ASE 2016, Singapore, September 3-7, 2016, David Lo, Sven Apel, and Sarfraz Khurshid (Eds.). ACM, 332–343. https://doi.org/10.1145/2970276.2970347 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Patrick Cousot and Radhia Cousot. 1979. Systematic Design of Program Analysis Frameworks. In Proceedings of the 6th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages (POPL ’79). Association for Computing Machinery, New York, NY, USA. 269–282. isbn:9781450373579 https://doi.org/10.1145/567752.567778 Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. Pratik Fegade and Christian Wimmer. 2020. Scalable Pointer Analysis of Data Structures Using Semantic Models. In Proceedings of the 29th International Conference on Compiler Construction (CC 2020). Association for Computing Machinery, New York, NY, USA. 39–50. isbn:9781450371209 https://doi.org/10.1145/3377555.3377885 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Yu Feng, Xinyu Wang, Isil Dillig, and Thomas Dillig. 2015. Bottom-Up Context-Sensitive Pointer Analysis for Java. In Programming Languages and Systems, Xinyu Feng and Sungwoo Park (Eds.). Springer International Publishing, Cham. 465–484. isbn:978-3-319-26529-2Google ScholarGoogle Scholar
  10. 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
  11. 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, Heidelberg. 214–236. isbn:3540403256 Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Behnaz Hassanshahi, Raghavendra Kagalavadi Ramesh, Padmanabhan Krishnan, Bernhard Scholz, and Yi Lu. 2017. An efficient tunable selective points-to analysis for large codebases. In Proceedings of the 6th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, [email protected] 2017, Barcelona, Spain, June 18, 2017, Karim Ali and Cristina Cifuentes (Eds.). ACM, 13–18. https://doi.org/10.1145/3088515.3088519 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. 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), 13:1–13:41. https://doi.org/10.1145/3293607 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. 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
  15. Sehun Jeong, Minseok Jeon, Sung Deok Cha, and Hakjoo Oh. 2017. Data-driven context-sensitivity for points-to analysis. PACMPL, 1, OOPSLA (2017), 100:1–100:28. https://doi.org/10.1145/3133924 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Vini Kanvar and Uday P. Khedker. 2016. Heap Abstractions for Static Analysis. ACM Comput. Surv., 49, 2 (2016), Article 29, June, 47 pages. issn:0360-0300 https://doi.org/10.1145/2931098 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. George Kastrinis and Yannis Smaragdakis. 2013. Hybrid context-sensitivity for points-to analysis. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13, Seattle, WA, USA, June 16-19, 2013, Hans-Juergen Boehm and Cormac Flanagan (Eds.). ACM, 423–434. https://doi.org/10.1145/2491956.2462191 Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. 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
  19. Ondrej Lhoták and Laurie J. Hendren. 2006. Context-Sensitive Points-to Analysis: Is It Worth It? In Compiler Construction, 15th International Conference, CC 2006, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2006, Vienna, Austria, March 30-31, 2006, Proceedings, Alan Mycroft and Andreas Zeller (Eds.) (Lecture Notes in Computer Science, Vol. 3923). Springer, 47–64. https://doi.org/10.1007/11688839_5 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. 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
  21. Yue Li, Tian Tan, Anders Møller, and Yannis Smaragdakis. 2018. Scalability-First Pointer Analysis with Self-Tuning Context-Sensitivity. In Proc. 12th joint meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, 129–140. https://doi.org/10.1145/3236024.3236041 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. 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
  23. Yue Li, Tian Tan, Yifei Zhang, and Jingling Xue. 2016. Program Tailoring: Slicing by Sequential Criteria. In 30th European Conference on Object-Oriented Programming, ECOOP 2016, July 18-22, 2016, Rome, Italy, Shriram Krishnamurthi and Benjamin S. Lerner (Eds.) (LIPIcs, Vol. 56). Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 15:1–15:27. https://doi.org/10.4230/LIPIcs.ECOOP.2016.15 Google ScholarGoogle Scholar
  24. Percy Liang and Mayur Naik. 2011. Scaling Abstraction Refinement via Pruning. SIGPLAN Not., 46, 6 (2011), June, 590–601. issn:0362-1340 https://doi.org/10.1145/1993316.1993567 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. Bozhen Liu, Jeff Huang, and Lawrence Rauchwerger. 2019. Rethinking Incremental and Parallel Pointer Analysis. ACM Trans. Program. Lang. Syst., 41, 1 (2019), Article 6, March, 31 pages. issn:0164-0925 https://doi.org/10.1145/3293606 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Benjamin Livshits and Monica S. Lam. 2005. Finding Security Vulnerabilities in Java Applications with Static Analysis. In Proceedings of the 14th USENIX Security Symposium, Baltimore, MD, USA, July 31 - August 5, 2005, Patrick D. McDaniel (Ed.). USENIX Association. 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. https://doi.org/10.1145/3360574 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. 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 International Symposium on Software Testing and Analysis, ISSTA 2002, Roma, Italy, July 22-24, 2002, Phyllis G. Frankl (Ed.). ACM, 1–11. https://doi.org/10.1145/566172.566174 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. 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), 1–41. https://doi.org/10.1145/1044834.1044835 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Myungho Lee Minseok Jeon and Hakjoo Oh. 2020. Learning Graph-based Heuristics for Pointer Analysis without Handcrafting Application-Specific Features. Proc. ACM Program. Lang..Google ScholarGoogle Scholar
  31. Mayur Naik, Alex Aiken, and aley. 2006. Effective static race detection for Java. In Proceedings of the ACM SIGPLAN 2006 Conference on Programming Language Design and Implementation, Ottawa, Ontario, Canada, June 11-14, 2006, Michael I. Schwartzbach and Thomas Ball (Eds.). ACM, 308–319. 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, Wonchan Lee, Kihong Heo, Hongseok Yang, and Kwangkeun Yi. 2015. Selective X-Sensitive Analysis Guided by Impact Pre-Analysis. ACM Trans. Program. Lang. Syst., 38, 2 (2015), Article 6, Dec., 45 pages. issn:0164-0925 https://doi.org/10.1145/2821504 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Matthai Philipose, Craig Chambers, and Susan J. Eggers. 2002. Towards Automatic Construction of Staged Compilers. In Proceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’02). Association for Computing Machinery, New York, NY, USA. 113–125. isbn:1581134509 https://doi.org/10.1145/503272.503284 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Michael Pradel, Ciera Jaspan, Jonathan Aldrich, and Thomas R. Gross. 2012. Statically checking API protocol conformance with mined multi-object specifications. In 34th International Conference on Software Engineering, ICSE 2012, June 2-9, 2012, Zurich, Switzerland, Martin Glinz, Gail C. Murphy, and Mauro Pezzè (Eds.). IEEE Computer Society, 925–935. https://doi.org/10.1109/ICSE.2012.6227127 Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Thomas Reps. 1997. Program Analysis via Graph Reachability. In Proceedings of the 1997 International Symposium on Logic Programming (ILPS ’97). MIT Press, Cambridge, MA, USA. 5–19. isbn:0262631806 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. 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
  38. Yannis Smaragdakis, Martin Bravenboer, and Ondrej Lhoták. 2011. Pick your contexts well: understanding object-sensitivity. In Proceedings of the 38th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2011, Austin, TX, USA, January 26-28, 2011, Thomas Ball and Mooly Sagiv (Eds.). ACM, 17–30. https://doi.org/10.1145/1926385.1926390 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Yannis Smaragdakis, George Kastrinis, and George Balatsouras. 2014. Introspective analysis: context-sensitivity, across the board. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’14, Edinburgh, United Kingdom - June 09 - 11, 2014, Michael F. P. O’Boyle and Keshav Pingali (Eds.). ACM, 485–495. https://doi.org/10.1145/2594291.2594320 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Johannes Späth, Karim Ali, and Eric Bodden. 2019. Context-, Flow-, and Field-Sensitive Data-Flow Analysis Using Synchronized Pushdown Systems. Proc. ACM Program. Lang., 3, POPL (2019), Article 48, Jan., 29 pages. https://doi.org/10.1145/3290361 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. 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
  42. Manu Sridharan and Rastislav Bodík. 2006. Refinement-based context-sensitive points-to analysis for Java. In Proceedings of the ACM SIGPLAN 2006 Conference on Programming Language Design and Implementation, Ottawa, Ontario, Canada, June 11-14, 2006, Michael I. Schwartzbach and Thomas Ball (Eds.). ACM, 387–400. https://doi.org/10.1145/1133981.1134027 Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. 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, Dave Clarke, James Noble, and Tobias Wrigstad (Eds.) (Lecture Notes in Computer Science, Vol. 7850). Springer, 196–232. https://doi.org/10.1007/978-3-642-36946-9_8 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Manu Sridharan, Stephen J. Fink, and Rastislav Bodík. 2007. Thin slicing. In Proceedings of the ACM SIGPLAN 2007 Conference on Programming Language Design and Implementation, San Diego, California, USA, June 10-13, 2007, Jeanne Ferrante and Kathryn S. McKinley (Eds.). ACM, 112–122. https://doi.org/10.1145/1250734.1250748 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 2005, October 16-20, 2005, San Diego, CA, USA, Ralph E. Johnson and Richard P. Gabriel (Eds.). ACM, 59–76. https://doi.org/10.1145/1094811.1094817 Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Yulei Sui and Jingling Xue. 2016. On-demand Strong Update Analysis via Value-flow Refinement. In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE 2016). ACM, New York, NY, USA. 460–473. isbn:978-1-4503-4218-6 https://doi.org/10.1145/2950290.2950296 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Tian Tan, Yue Li, Xiaoxing Ma, Chang Xu, and Yannis Smaragdakis. 2021. Making Pointer Analysis More Precise by Unleashing the Power of Selective Context Sensitivity (Artifact). https://doi.org/10.5281/zenodo.5491895 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Tian Tan, Yue Li, and Jingling Xue. 2016. Making k-Object-Sensitive Pointer Analysis More Precise with Still k-Limiting. In Static Analysis - 23rd International Symposium, SAS 2016, Edinburgh, UK, September 8-10, 2016, Proceedings, Xavier Rival (Ed.) (Lecture Notes in Computer Science, Vol. 9837). Springer, 489–510. https://doi.org/10.1007/978-3-662-53413-7_24 Google ScholarGoogle Scholar
  49. 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, Barcelona, Spain, June 18-23, 2017, Albert Cohen and Martin T. Vechev (Eds.). ACM, 278–291. https://doi.org/10.1145/3062341.3062360 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. 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
  51. Manas Thakur and V. Krishna Nandivada. 2020. Mix Your Contexts Well: Opportunities Unleashed by Recent Advances in Scaling Context-Sensitivity. CC 2020. Association for Computing Machinery, New York, NY, USA. 27–38. isbn:9781450371209 https://doi.org/10.1145/3377555.3377902 Google ScholarGoogle ScholarDigital LibraryDigital Library
  52. 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
  53. WALA. 2018. Watson Libraries for Analysis. http://wala.sf.netGoogle ScholarGoogle Scholar
  54. Kai Wang, Aftab Hussain, Zhiqiang Zuo, Guoqing Xu, and Ardalan Amiri Sani. 2017. Graspan: A Single-machine Disk-based Graph System for Interprocedural Static Analyses of Large-scale Systems Code. In Proceedings of the Twenty-Second International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’17). ACM, New York, NY, USA. 389–404. isbn:978-1-4503-4465-4 https://doi.org/10.1145/3037697.3037744 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Shiyi Wei and Barbara G. Ryder. 2015. Adaptive Context-sensitive Analysis for JavaScript. In 29th European Conference on Object-Oriented Programming, ECOOP 2015, July 5-10, 2015, Prague, Czech Republic, John Tang Boyland (Ed.) (LIPIcs, Vol. 37). Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 712–734. https://doi.org/10.4230/LIPIcs.ECOOP.2015.712 Google ScholarGoogle ScholarCross RefCross Ref
  56. John Whaley and Monica S. Lam. 2004. Cloning-Based Context-Sensitive Pointer Alias Analysis Using Binary Decision Diagrams. SIGPLAN Not., 39, 6 (2004), June, 131–144. issn:0362-1340 https://doi.org/10.1145/996893.996859 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. 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
  58. 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). Association for Computing Machinery, New York, NY, USA. 239–248. isbn:9781450327848 https://doi.org/10.1145/2594291.2594327 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Making pointer analysis more precise by unleashing the power of selective context sensitivity

    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!