Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
research-article
Open access

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

Published: 04 January 2021 Publication History

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 ).
[2]
Amir Abboud and Virginia Vassilevska Williams. 2014. Popular Conjectures Imply Strong Lower Bounds for Dynamic Problems. In FOCS. 434-443.
[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.
[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
[5]
Lars Ole Andersen. 1994. Program Analysis and Specialization for the C Programming Language. Ph.D. Dissertation.
[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.
[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
[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.
[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
[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.
[11]
Phillip G. Bradford. 2018. Eficient Exact Paths For Dyck and semi-Dyck Labeled Path Reachability. ( 2018 ). arXiv:cs.DS/ 1802.05239
[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
[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.
[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.
[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
[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
[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.
[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.
[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.
[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
[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
[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
[23]
Raymond Greenlaw, H. James Hoover, and Walter L. Ruzzo. 1995. Limits to Parallel Computation: P-Completeness Theory. Oxford University Press, Inc., USA.
[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
[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.
[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. 788876
[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
[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
[29]
Nevin Charles Heintze. 1992. Set Based Program Analysis. Ph.D. Dissertation. USA.
[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.
[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.
[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
[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.
[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
[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.
[36]
Igor Kaporin. 1999. A practical algorithm for faster matrix multiplication. Numerical Linear Algebra with Applications 6, 8 ( 1999 ), 687-700.
[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
[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
[39]
William Landi and Barbara G. Ryder. 1991. Pointer-induced Aliasing: A Problem Classification. In POPL. ACM.
[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.
[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.
[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
[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
[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
[45]
Anders Alnor Mathiasen and Andreas Pavlogiannis. 2020. The Fine-Grained and Parallel Complexity of Andersen's Pointer Analysis. ( 2020 ). arXiv:cs.PL/ 2006.01491
[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.
[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
[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
[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
[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/
[51]
Ian Munro. 1971. Eficient determination of the transitive closure of a directed graph. Inform. Process. Lett. 1, 2 ( 1971 ), 56-58.
[52]
Christos H. Papadimitriou. 1993. Computational Complexity. Addison-Wesley.
[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
[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
[55]
G. Ramalingam. 1994. The Undecidability of Aliasing. ACM Trans. Program. Lang. Syst. 16, 5 (Sept. 1994 ), 1467-1471.
[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
[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
[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
[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
[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.
[61]
Manu Sridharan, Denis Gopan, Lexin Shan, and Rastislav Bodík. 2005. Demand-driven Points-to Analysis for Java. In OOPSLA.
[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
[63]
Volker Strassen. 1969. Gaussian Elimination is Not Optimal. Numer. Math. 13, 4 ( 1969 ), 354-356.
[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
[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
[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
[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.
[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.
[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
[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.
[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
[72]
Virginia Vassilevska Williams. 2019. On some fine-grained questions in algorithms and complexity. Technical Report.
[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
[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.
[75]
Qirun Zhang. 2020. Conditional Lower Bound for Inclusion-Based Points-to Analysis. arXiv preprint arXiv: 2007. 05569 ( 2020 ).
[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.
[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.

Cited By

View all
  • (2025)Program Analysis via Multiple Context Free Language ReachabilityProceedings of the ACM on Programming Languages10.1145/37048549:POPL(509-538)Online publication date: 9-Jan-2025
  • (2024)Exploring Scalability of Value-Flow Graph ConstructionProceedings of the 2024 4th International Conference on Artificial Intelligence, Automation and High Performance Computing10.1145/3690931.3690951(112-117)Online publication date: 19-Jul-2024
  • (2024)Evaluating Datalog over Semirings: A Grounding-based ApproachProceedings of the ACM on Management of Data10.1145/36515912:2(1-26)Online publication date: 14-May-2024
  • Show More Cited By

Recommendations

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages
Proceedings of the ACM on Programming Languages  Volume 5, Issue POPL
January 2021
1789 pages
EISSN:2475-1421
DOI:10.1145/3445980
Issue’s Table of Contents
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: 04 January 2021
Published in PACMPL Volume 5, Issue POPL

Permissions

Request permissions for this article.

Check for updates

Author Tags

  1. Dyck reachability
  2. fine-grained complexity
  3. inclusion-based pointer analysis
  4. static pointer analysis

Qualifiers

  • Research-article

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)189
  • Downloads (Last 6 weeks)20
Reflects downloads up to 06 Feb 2025

Other Metrics

Citations

Cited By

View all
  • (2025)Program Analysis via Multiple Context Free Language ReachabilityProceedings of the ACM on Programming Languages10.1145/37048549:POPL(509-538)Online publication date: 9-Jan-2025
  • (2024)Exploring Scalability of Value-Flow Graph ConstructionProceedings of the 2024 4th International Conference on Artificial Intelligence, Automation and High Performance Computing10.1145/3690931.3690951(112-117)Online publication date: 19-Jul-2024
  • (2024)Evaluating Datalog over Semirings: A Grounding-based ApproachProceedings of the ACM on Management of Data10.1145/36515912:2(1-26)Online publication date: 14-May-2024
  • (2024)Dynamic Transitive Closure-based Static Analysis through the Lens of Quantum SearchACM Transactions on Software Engineering and Methodology10.1145/364438933:5(1-29)Online publication date: 4-Jun-2024
  • (2024)On-the-Fly Static Analysis via Dynamic Bidirected Dyck ReachabilityProceedings of the ACM on Programming Languages10.1145/36328848:POPL(1239-1268)Online publication date: 5-Jan-2024
  • (2024) Octopus: Scaling Value-Flow Analysis via Parallel Collection of Realizable Path ConditionsACM Transactions on Software Engineering and Methodology10.1145/363274333:3(1-33)Online publication date: 24-Jan-2024
  • (2023)A Container-Usage-Pattern-Based Context Debloating Approach for Object-Sensitive Pointer AnalysisProceedings of the ACM on Programming Languages10.1145/36228327:OOPSLA2(971-1000)Online publication date: 16-Oct-2023
  • (2023)The Fine-Grained Complexity of CFL ReachabilityProceedings of the ACM on Programming Languages10.1145/35712527:POPL(1713-1739)Online publication date: 9-Jan-2023
  • (2023)Improving AFLGo's Directed Fuzzing by Considering Indirect Function Calls2023 38th IEEE/ACM International Conference on Automated Software Engineering Workshops (ASEW)10.1109/ASEW60602.2023.00024(143-150)Online publication date: 11-Sep-2023
  • (2022)CFL/Dyck ReachabilityACM SIGLOG News10.1145/3583660.35836649:4(5-25)Online publication date: 1-Oct-2022
  • Show More Cited By

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Login options

Full Access

Figures

Tables

Media

Share

Share

Share this Publication link

Share on social media