skip to main content
research-article
Open Access

The fine-grained and parallel complexity of andersen’s pointer analysis

Published:04 January 2021Publication History
Skip Abstract Section

Abstract

Pointer analysis is one of the fundamental problems in static program analysis. Given a set of pointers, the task is to produce a useful over-approximation of the memory locations that each pointer may point-to at runtime. The most common formulation is Andersen’s Pointer Analysis (APA), defined as an inclusion-based set of m pointer constraints over a set of n pointers. Scalability is extremely important, as points-to information is a prerequisite to many other components in the static-analysis pipeline. Existing algorithms solve APA in O(n2· m) time, while it has been conjectured that the problem has no truly sub-cubic algorithm, with a proof so far having remained elusive. It is also well-known that APA can be solved in O(n2) time under certain sparsity conditions that hold naturally in some settings. Besides these simple bounds, the complexity of the problem has remained poorly understood.

In this work we draw a rich fine-grained and parallel complexity landscape of APA, and present upper and lower bounds. First, we establish an O(n3) upper-bound for general APA, improving over O(n2· m) as n=O(m). Second, we show that even on-demand APA (“may a specific pointer a point to a specific location b?”) has an Ω(n3) (combinatorial) lower bound under standard complexity-theoretic hypotheses. This formally establishes the long-conjectured “cubic bottleneck” of APA, and shows that our O(n3)-time algorithm is optimal. Third, we show that under mild restrictions, APA is solvable in Õ(nω) time, where ω<2.373 is the matrix-multiplication exponent. It is believed that ω=2+o(1), in which case this bound becomes quadratic. Fourth, we show that even under such restrictions, even the on-demand problem has an Ω(n2) lower bound under standard complexity-theoretic hypotheses, and hence our algorithm is optimal when ω=2+o(1). Fifth, we study the parallelizability of APA and establish lower and upper bounds: (i) in general, the problem is P-complete and hence unlikely parallelizable, whereas (ii) under mild restrictions, the problem is parallelizable. Our theoretical treatment formalizes several insights that can lead to practical improvements in the future.

References

  1. 2003. T. J. Watson Libraries for Analysis (WALA). https://github.com. ( 2003 ).Google ScholarGoogle Scholar
  2. Amir Abboud and Virginia Vassilevska Williams. 2014. Popular Conjectures Imply Strong Lower Bounds for Dynamic Problems. In FOCS. 434-443.Google ScholarGoogle Scholar
  3. Alexander Aiken, Manuel Fahndrich, and Jefrey S Foster. 1997. Flow-Insensitive Points-to Analysis with Term and Set Constraints. Technical Report. EECS UC Berkeley.Google ScholarGoogle Scholar
  4. Noga Alon, Zvi Galil, and Oded Margalit. 1997. On the Exponent of the All Pairs Shortest Path Problem. J. Comput. System Sci. 54, 2 ( 1997 ), 255-262. https://doi.org/10.1006/jcss. 1997.1388 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Lars Ole Andersen. 1994. Program Analysis and Specialization for the C Programming Language. Ph.D. Dissertation.Google ScholarGoogle Scholar
  6. N. Bansal and R. Williams. 2009. Regularity Lemmas and Combinatorial Algorithms. In 2009 50th Annual IEEE Symposium on Foundations of Computer Science. 745-754.Google ScholarGoogle Scholar
  7. Marc Berndl, Ondrej Lhoták, Feng Qian, Laurie Hendren, and Navindra Umanee. 2003. Points-to Analysis Using BDDs. SIGPLAN Not. 38, 5 (May 2003 ), 103-114. https://doi.org/10.1145/780822.781144 Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. Sam Blackshear, Bor-Yuh Evan Chang, Sriram Sankaranarayanan, and Manu Sridharan. 2011. The Flow-Insensitive Precision of Andersen's Analysis in Practice. In Proceedings of the 18th International Conference on Static Analysis (SAS'11). SpringerVerlag, Berlin, Heidelberg, 60-76.Google ScholarGoogle ScholarCross RefCross Ref
  9. Thorsten Blaß and Michael Philippsen. 2019. GPU-Accelerated Fixpoint Algorithms for Faster Compiler Analyses. In Proceedings of the 28th International Conference on Compiler Construction (CC 2019 ). Association for Computing Machinery, New York, NY, USA, 122-134. https://doi.org/10.1145/3302516.3307352 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Mark Boddy. 1991. Anytime Problem Solving Using Dynamic Programming. In Proceedings of the Ninth National Conference on Artificial Intelligence-Volume 2 ( AAAI ' 91 ). AAAI Press, 738-743.Google ScholarGoogle Scholar
  11. Phillip G. Bradford. 2018. Eficient Exact Paths For Dyck and semi-Dyck Labeled Path Reachability. ( 2018 ). arXiv:cs.DS/ 1802.05239Google ScholarGoogle Scholar
  12. 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). Association for Computing Machinery, New York, NY, USA, 115-125. https://doi.org/10.1145/604131.604142 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Krishnendu Chatterjee, Bhavya Choudhary, and Andreas Pavlogiannis. 2018. Optimal Dyck Reachability for DataDependence and Alias Analysis. Proc. ACM Program. Lang. 2, POPL, Article Article 30 (Dec. 2018 ), 30 pages.Google ScholarGoogle Scholar
  14. Krishnendu Chatterjee, Wolfgang Dvorák, Monika Henzinger, and Veronika Loitzenbauer. 2016. Conditionally Optimal Algorithms for Generalized Büchi Games. In 41st International Symposium on Mathematical Foundations of Computer Science (MFCS 2016 ) (Leibniz International Proceedings in Informatics (LIPIcs)), Piotr Faliszewski, Anca Muscholl, and Rolf Niedermeier (Eds.), Vol. 58. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, Dagstuhl, Germany, 25 : 1-25 : 15.Google ScholarGoogle Scholar
  15. Krishnendu Chatterjee, Andreas Pavlogiannis, and Yaron Velner. 2015. Quantitative Interprocedural Analysis. SIGPLAN Not. 50, 1 (Jan. 2015 ), 539-551. https://doi.org/10.1145/2775051.2676968 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Manuvir Das. 2000. Unification-Based Pointer Analysis with Directional Assignments. SIGPLAN Not. 35, 5 (May 2000 ), 35-46. https://doi.org/10.1145/358438.349309 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Manuvir Das, Ben Liblit, Manuel Fähndrich, and Jakob Rehof. 2001. Estimating the Impact of Scalable Pointer Analysis on Optimization. In Static Analysis, Patrick Cousot (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 260-278.Google ScholarGoogle Scholar
  18. Nirav Dave, Kermin Fleming, Myron King, Michael Pellauer, and Muralidaran Vijayaraghavan. 2007. Hardware Acceleration of Matrix Multiplication on a Xilinx FPGA. In Proceedings of the 5th IEEE/ACM International Conference on Formal Methods and Models for Codesign (MEMOCODE '07). IEEE Computer Society, USA, 97-100.Google ScholarGoogle ScholarDigital LibraryDigital Library
  19. Jean-Luc Deleage and Laurent Pierre. 1986. The Rational Index of the Dyck Language D1. Theor. Comput. Sci. 47, 3 (Nov. 1986 ), 335-343.Google ScholarGoogle ScholarCross RefCross Ref
  20. Jens Dietrich, Nicholas Hollingum, and Bernhard Scholz. 2015. Giga-Scale Exhaustive Points-to Analysis for Java in under a Minute. SIGPLAN Not. 50, 10 (Oct. 2015 ), 535-551. https://doi.org/10.1145/2858965.2814307 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Manuel Fähndrich, Jefrey S. Foster, Zhendong Su, and Alexander Aiken. 1998. Partial Online Cycle Elimination in Inclusion Constraint Graphs. SIGPLAN Not. 33, 5 (May 1998 ), 85-96. https://doi.org/10.1145/277652.277667 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Rakesh Ghiya, Daniel Lavery, and David Sehr. 2001. On the Importance of Points-to Analysis and Other Memory Disambiguation Methods for C Programs. SIGPLAN Not. 36, 5 (May 2001 ), 47-58. https://doi.org/10.1145/381694.378806 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Raymond Greenlaw, H. James Hoover, and Walter L. Ruzzo. 1995. Limits to Parallel Computation: P-Completeness Theory. Oxford University Press, Inc., USA.Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Ben Hardekopf and Calvin Lin. 2007. The Ant and the Grasshopper: Fast and Accurate Pointer Analysis for Millions of Lines of Code. SIGPLAN Not. 42, 6 ( June 2007 ), 290-299. https://doi.org/10.1145/1273442.1250767 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. 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, USA, 289-298.Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Nevin Heintze and David McAllester. 1997. On the Cubic Bottleneck in Subtyping and Flow Analysis. In Proceedings of the 12th Annual IEEE Symposium on Logic in Computer Science (LICS '97). IEEE Computer Society, Washington, DC, USA, 342-. http://dl.acm.org/citation.cfm?id= 788019. 788876Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Nevin Heintze and Olivier Tardieu. 2001a. Demand-Driven Pointer Analysis. In Proceedings of the ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation (PLDI '01). Association for Computing Machinery, New York, NY, USA, 24-34. https://doi.org/10.1145/378795.378802 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Nevin Heintze and Olivier Tardieu. 2001b. Ultra-Fast Aliasing Analysis Using CLA: A Million Lines of C Code in a Second. In Proceedings of the ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation (PLDI '01). Association for Computing Machinery, New York, NY, USA, 254-263. https://doi.org/10.1145/378795.378855 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Nevin Charles Heintze. 1992. Set Based Program Analysis. Ph.D. Dissertation. USA.Google ScholarGoogle Scholar
  30. Michael Hind. 2001. Pointer Analysis: Haven'T We Solved This Problem Yet?. In Proceedings of the 2001 ACM SIGPLANSIGSOFT Workshop on Program Analysis for Software Tools and Engineering (PASTE '01). ACM, 54-61.Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Martin Hirzel, Amer Diwan, and Michael Hind. 2004. Pointer Analysis in the Presence of Dynamic Class Loading. In ECOOP 2004-Object-Oriented Programming, Martin Odersky (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 96-122.Google ScholarGoogle Scholar
  32. Susan Horwitz. 1997. Precise Flow-Insensitive May-Alias Analysis is NP-Hard. ACM Trans. Program. Lang. Syst. 19, 1 (Jan. 1997 ), 1-6. https://doi.org/10.1145/239912.239913 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Jianyu Huang, Tyler M. Smith, Greg M. Henry, and Robert A. van de Geijn. 2016. Strassen's Algorithm Reloaded. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC '16). IEEE Press, Article Article 59, 12 pages.Google ScholarGoogle Scholar
  34. Steven Huss-Lederman, Elaine M. Jacobson, Anna Tsao, Thomas Turnbull, and Jeremy R. Johnson. 1996. Implementation of Strassen's Algorithm for Matrix Multiplication. In Proceedings of the 1996 ACM/IEEE Conference on Supercomputing (Supercomputing '96). IEEE Computer Society, USA, 32-es. https://doi.org/10.1145/369028.369096 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Dongseok Jang and Kwang-Moo Choe. 2009. Points-to Analysis for JavaScript. In Proceedings of the 2009 ACM Symposium on Applied Computing (SAC '09). Association for Computing Machinery, New York, NY, USA, 1930-1937.Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Igor Kaporin. 1999. A practical algorithm for faster matrix multiplication. Numerical Linear Algebra with Applications 6, 8 ( 1999 ), 687-700.Google ScholarGoogle Scholar
  37. John Kodumal and Alex Aiken. 2004. The Set Constraint/CFL Reachability Connection in Practice. In Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation (PLDI '04). Association for Computing Machinery, New York, NY, USA, 207-218. https://doi.org/10.1145/996841.996867 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Julian Laderman, Victor Pan, and Xuan-He Sha. 1992. On practical algorithms for accelerated matrix multiplication. Linear Algebra Appl. 162-164 ( 1992 ), 557-588. https://doi.org/10.1016/ 0024-3795 ( 92 ) 90393-O Google ScholarGoogle ScholarCross RefCross Ref
  39. William Landi and Barbara G. Ryder. 1991. Pointer-induced Aliasing: A Problem Classification. In POPL. ACM.Google ScholarGoogle Scholar
  40. François Le Gall. 2014. Powers of Tensors and Fast Matrix Multiplication. In Proceedings of the 39th International Symposium on Symbolic and Algebraic Computation (ISSAC). 296-303.Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Ondřej Lhoták and Laurie Hendren. 2003. Scaling Java Points-to Analysis Using SPARK. In Proceedings of the 12th International Conference on Compiler Construction (CC'03). Springer-Verlag, Berlin, Heidelberg, 153-169.Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. Bozhen Liu, Jef Huang, and Lawrence Rauchwerger. 2019. Rethinking Incremental and Parallel Pointer Analysis. ACM Trans. Program. Lang. Syst. 41, 1, Article Article 6 (March 2019 ), 31 pages. https://doi.org/10.1145/3293606 Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Yi Lu, Lei Shang, Xinwei Xie, and Jingling Xue. 2013. An Incremental Points-to Analysis with CFL-Reachability. In Proceedings of the 22nd International Conference on Compiler Construction (CC'13). Springer-Verlag, Berlin, Heidelberg, 61-81. https://doi.org/10.1007/978-3-642-37051-9_4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Steven Lyde, William E. Byrd, and Matthew Might. 2015. Control-Flow Analysis of Dynamic Languages via Pointer Analysis. SIGPLAN Not. 51, 2 (Oct. 2015 ), 54-62. https://doi.org/10.1145/2936313.2816712 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Anders Alnor Mathiasen and Andreas Pavlogiannis. 2020. The Fine-Grained and Parallel Complexity of Andersen's Pointer Analysis. ( 2020 ). arXiv:cs.PL/ 2006.01491Google ScholarGoogle Scholar
  46. David McAllester. 1999. On the Complexity Analysis of Static Analyses. In Static Analysis, Agostino Cortesi and Gilberto Filé (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 312-329.Google ScholarGoogle Scholar
  47. David Melski and Thomas Reps. 2000. Interconvertibility of a Class of Set Constraints and Context-free-language Reachability. Theor. Comput. Sci. 248, 1-2 (Oct. 2000 ), 29-98. https://doi.org/10.1016/S0304-3975 ( 00 ) 00049-9 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Mario Mendez-Lojo, Martin Burtscher, and Keshav Pingali. 2012. A GPU Implementation of Inclusion-Based Points-to Analysis. SIGPLAN Not. 47, 8 (Feb. 2012 ), 107-116. https://doi.org/10.1145/2370036.2145831 Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Mario Méndez-Lojo, Augustine Mathew, and Keshav Pingali. 2010. Parallel Inclusion-Based Points-to Analysis. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA '10). Association for Computing Machinery, New York, NY, USA, 428-443. https://doi.org/10.1145/1869459.1869495 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Anders Møller and Michael I. Schwartzbach. 2018. Static Program Analysis. Technical Report. Department of Computer Science, Aarhus University. http://cs.au.dk/~amoeller/spa/Google ScholarGoogle Scholar
  51. Ian Munro. 1971. Eficient determination of the transitive closure of a directed graph. Inform. Process. Lett. 1, 2 ( 1971 ), 56-58.Google ScholarGoogle ScholarDigital LibraryDigital Library
  52. Christos H. Papadimitriou. 1993. Computational Complexity. Addison-Wesley.Google ScholarGoogle Scholar
  53. David J. Pearce, Paul H. J. Kelly, and Chris Hankin. 2004. Online Cycle Detection and Diference Propagation: Applications to Pointer Analysis. Software Quality Journal 12, 4 ( 2004 ), 311-337. https://doi.org/10.1023/B:SQJO. 0000039791.93071.a2 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Edgar Pek and P. Madhusudan. 2014. Explicit and Symbolic Techniques for Fast and Scalable Points-to Analysis. In Proceedings of the 3rd ACM SIGPLAN International Workshop on the State of the Art in Java Program Analysis (SOAP '14). Association for Computing Machinery, New York, NY, USA, 1-6. https://doi.org/10.1145/2614628.2614632 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. G. Ramalingam. 1994. The Undecidability of Aliasing. ACM Trans. Program. Lang. Syst. 16, 5 (Sept. 1994 ), 1467-1471.Google ScholarGoogle ScholarDigital LibraryDigital Library
  56. Thomas Reps. 1996. On the sequential nature of interprocedural program-analysis problems. Acta Informatica 33, 5 ( 01 Aug 1996 ), 739-757. https://doi.org/10.1007/BF03036473 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Atanas Rountev and Satish Chandra. 2000. Of-Line Variable Substitution for Scaling Points-to Analysis. SIGPLAN Not. 35, 5 (May 2000 ), 47-56. https://doi.org/10.1145/358438.349310 Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Marc Shapiro and Susan Horwitz. 1997. Fast and Accurate Flow-Insensitive Points-to Analysis. In Proceedings of the 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL '97). Association for Computing Machinery, New York, NY, USA, 1-14. https://doi.org/10.1145/263699.263703 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Yannis Smaragdakis and George Balatsouras. 2015. Pointer Analysis. Found. Trends Program. Lang. 2, 1 (April 2015 ), 1-69. https://doi.org/10.1561/2500000014 Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Manu Sridharan and Stephen J. Fink. 2009. The Complexity of Andersen's Analysis in Practice. In Proceedings of the 16th International Symposium on Static Analysis (SAS '09). Springer-Verlag, Berlin, Heidelberg, 205-221.Google ScholarGoogle Scholar
  61. Manu Sridharan, Denis Gopan, Lexin Shan, and Rastislav Bodík. 2005. Demand-driven Points-to Analysis for Java. In OOPSLA.Google ScholarGoogle Scholar
  62. 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). Association for Computing Machinery, New York, NY, USA, 32-41. https://doi.org/10.1145/237721.237727 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Volker Strassen. 1969. Gaussian Elimination is Not Optimal. Numer. Math. 13, 4 ( 1969 ), 354-356.Google ScholarGoogle Scholar
  64. Yu Su, Ding Ye, and Jingling Xue. 2014. Parallel Pointer Analysis with CFL-Reachability. In Proceedings of the 2014 Brazilian Conference on Intelligent Systems (BRACIS '14). IEEE Computer Society, USA, 451-460. https://doi.org/10.1109/ICPP. 2014.54 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Zhendong Su, Manuel Fähndrich, and Alexander Aiken. 2000. Projection Merging: Reducing Redundancies in Inclusion Constraint Graphs. In Proceedings of the 27th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL '00). Association for Computing Machinery, New York, NY, USA, 81-95. https://doi.org/10.1145/325694.325706 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. 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 ). Association for Computing Machinery, New York, NY, USA, 460-473. https://doi.org/10.1145/2950290.2950296 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Raja Vallée-Rai, Phong Co, Etienne Gagnon, Laurie Hendren, Patrick Lam, and Vijay Sundaresan. 1999. Soot-a Java bytecode optimization framework. In CASCON '99. IBM Press.Google ScholarGoogle Scholar
  68. J. Vedurada and V. K. Nandivada. 2019. Batch Alias Analysis. In 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). 936-948.Google ScholarGoogle Scholar
  69. 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). Association for Computing Machinery, New York, NY, USA, 389-404. https://doi.org/10.1145/3037697.3037744 Google ScholarGoogle ScholarDigital LibraryDigital Library
  70. John Whaley and Monica S. Lam. 2002. An Eficient Inclusion-Based Points-To Analysis for Strictly-Typed Languages. In Static Analysis, Manuel V. Hermenegildo and Germán Puebla (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 180-195.Google ScholarGoogle ScholarDigital LibraryDigital Library
  71. Ryan Williams. 2005. A New Algorithm for Optimal 2-Constraint Satisfaction and Its Implications. Theor. Comput. Sci. 348, 2 (Dec. 2005 ), 357-365. https://doi.org/10.1016/j.tcs. 2005. 09.023 Google ScholarGoogle ScholarDigital LibraryDigital Library
  72. Virginia Vassilevska Williams. 2019. On some fine-grained questions in algorithms and complexity. Technical Report.Google ScholarGoogle Scholar
  73. Virginia Vassilevska Williams and R. Ryan Williams. 2018. Subcubic Equivalences Between Path, Matrix, and Triangle Problems. J. ACM 65, 5, Article Article 27 ( Aug. 2018 ), 38 pages. https://doi.org/10.1145/3186893 Google ScholarGoogle ScholarDigital LibraryDigital Library
  74. Guoqing Xu, Atanas Rountev, and Manu Sridharan. 2009. Scaling CFL-Reachability-Based Points-To Analysis Using ContextSensitive Must-Not-Alias Analysis. In Proceedings of the 23rd European Conference on ECOOP 2009-Object-Oriented Programming (Genoa). 98-122.Google ScholarGoogle ScholarDigital LibraryDigital Library
  75. Qirun Zhang. 2020. Conditional Lower Bound for Inclusion-Based Points-to Analysis. arXiv preprint arXiv: 2007. 05569 ( 2020 ).Google ScholarGoogle Scholar
  76. Qirun Zhang, Michael R. Lyu, Hao Yuan, and Zhendong Su. 2013. Fast Algorithms for Dyck-CFL-reachability with Applications to Alias Analysis (PLDI). ACM.Google ScholarGoogle Scholar
  77. Xin Zheng and Radu Rugina. 2008. Demand-driven Alias Analysis for C. In Proceedings of the 35th Annual ACM SIGPLANSIGACT Symposium on Principles of Programming Languages (POPL '08). ACM, 197-208.Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. The fine-grained and parallel complexity of andersen’s pointer analysis

        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!