• Halalingaiah S, Sundaresan V, Maier D and Nandivada V. (2024). The ART of Sharing Points-to Analysis: Reusing Points-to Analysis Results Safely and Efficiently. Proceedings of the ACM on Programming Languages. 8:OOPSLA2. (2606-2632). Online publication date: 8-Oct-2024.

    https://doi.org/10.1145/3689803

  • Blumschein C, Niephaus F, Stancu C, Wimmer C, Lincke J and Hirschfeld R. Finding Cuts in Static Analysis Graphs to Debloat Software. Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. (603-614).

    https://doi.org/10.1145/3650212.3680306

  • Laursen M, Xu W and Møller A. (2024). Reducing Static Analysis Unsoundness with Approximate Interpretation. Proceedings of the ACM on Programming Languages. 8:PLDI. (1165-1188). Online publication date: 20-Jun-2024.

    https://doi.org/10.1145/3656424

  • Wimmer C, Stancu C, Kozak D and Würthinger T. (2024). Scaling Type-Based Points-to Analysis with Saturation. Proceedings of the ACM on Programming Languages. 8:PLDI. (990-1013). Online publication date: 20-Jun-2024.

    https://doi.org/10.1145/3656417

  • Erhard J, Schinabeck J, Schwarz M and Seidl H. When to Stop Going Down the Rabbit Hole: Taming Context-Sensitivity on the Fly. Proceedings of the 13th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. (35-44).

    https://doi.org/10.1145/3652588.3663321

  • Bao Y, Zhang C and Su K. Call-Graph-Based Context-Sensitive Points-to Analysis for Java. IEEE Transactions on Reliability. 10.1109/TR.2023.3236990. 73:2. (851-860).

    https://ieeexplore.ieee.org/document/10032837/

  • Zhang Y, Shi Y and Zhang X. (2024). Learning Abstraction Selection for Bayesian Program Analysis. Proceedings of the ACM on Programming Languages. 8:OOPSLA1. (954-982). Online publication date: 29-Apr-2024.

    https://doi.org/10.1145/3649845

  • Gumarac M. (2024). Extent of spending behavior, problems encountered, and financial knowledge across generational cohorts among state universities and colleges employees. International Journal of ADVANCED AND APPLIED SCIENCES. 10.21833/ijaas.2024.02.024. 11:2. (230-237). Online publication date: 1-Feb-2024.

    https://www.science-gate.com/IJAAS/2024/V11I2/1021833ijaas202402024.html

  • He D, Lu J and Xue J. (2023). IFDS-based Context Debloating for Object-Sensitive Pointer Analysis. ACM Transactions on Software Engineering and Methodology. 32:4. (1-44). Online publication date: 31-Jul-2023.

    https://doi.org/10.1145/3579641

  • Tan T and Li Y. Tai-e: A Developer-Friendly Static Analysis Framework for Java by Harnessing the Good Designs of Classics. Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis. (1093-1105).

    https://doi.org/10.1145/3597926.3598120

  • Ma W, Yang S, Tan T, Ma X, Xu C and Li Y. (2023). Context Sensitivity without Contexts: A Cut-Shortcut Approach to Fast and Precise Pointer Analysis. Proceedings of the ACM on Programming Languages. 7:PLDI. (539-564). Online publication date: 6-Jun-2023.

    https://doi.org/10.1145/3591242

  • Ko Y and Oh H. Learning to Boost Disjunctive Static Bug-Finders. Proceedings of the 45th International Conference on Software Engineering. (1097-1109).

    https://doi.org/10.1109/ICSE48619.2023.00099

  • Emre M, Boyland P, Parekh A, Schroeder R, Dewey K and Hardekopf B. (2023). Aliasing Limits on Translating C to Safe Rust. Proceedings of the ACM on Programming Languages. 7:OOPSLA1. (551-579). Online publication date: 6-Apr-2023.

    https://doi.org/10.1145/3586046

  • He D, Lu J, Gao Y and Xue J. Selecting Context-Sensitivity Modularly for Accelerating Object-Sensitive Pointer Analysis. IEEE Transactions on Software Engineering. 10.1109/TSE.2022.3162236. 49:2. (719-742).

    https://ieeexplore.ieee.org/document/9741339/

  • Albert E, Correas J, Gordillo P, Román-Díez G and Rubio A. (2023). Inferring Needless Write Memory Accesses on Ethereum Bytecode. Tools and Algorithms for the Construction and Analysis of Systems. 10.1007/978-3-031-30823-9_23. (448-466).

    https://link.springer.com/10.1007/978-3-031-30823-9_23

  • Shi Q, Wang Y, Yao P and Zhang C. (2022). Indexing the extended Dyck-CFL reachability for context-sensitive program analysis. Proceedings of the ACM on Programming Languages. 6:OOPSLA2. (1438-1468). Online publication date: 31-Oct-2022.

    https://doi.org/10.1145/3563339

  • Park J, Lee H and Ryu S. (2021). A Survey of Parametric Static Analysis. ACM Computing Surveys. 54:7. (1-37). Online publication date: 30-Sep-2022.

    https://doi.org/10.1145/3464457

  • Jaiswal S, Khedker U and Mycroft A. (2021). A Unified Model for Context-Sensitive Program Analyses:. ACM Computing Surveys. 54:6. (1-37). Online publication date: 31-Jul-2022.

    https://doi.org/10.1145/3456563

  • Liu B and Huang J. (2022). SHARP: fast incremental context-sensitive pointer analysis for Java. Proceedings of the ACM on Programming Languages. 6:OOPSLA1. (1-28). Online publication date: 29-Apr-2022.

    https://doi.org/10.1145/3527332

  • Bao Y, Zhang C, Zhuo X and Wang Y. (2022). Parameter Sensitive Pointer Analysis for Java 2022 26th International Conference on Engineering of Complex Computer Systems (ICECCS). 10.1109/ICECCS54210.2022.00027. 978-1-6654-0162-3. (162-167).

    https://ieeexplore.ieee.org/document/9763824/

  • Jeon M and Oh H. (2022). Return of CFA: call-site sensitivity can be superior to object sensitivity even for object-oriented programs. Proceedings of the ACM on Programming Languages. 6:POPL. (1-29). Online publication date: 16-Jan-2022.

    https://doi.org/10.1145/3498720

  • He D, Lu J and Xue J. (2021). Context Debloating for Object-Sensitive Pointer Analysis 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). 10.1109/ASE51524.2021.9678880. 978-1-6654-0337-5. (79-91).

    https://ieeexplore.ieee.org/document/9678880/

  • Zuo Z, Zhang Y, Pan Q, Lu S, Li Y, Wang L, Li X and Xu G. Chianina: an evolving graph system for flow- and context-sensitive analyses of million lines of C code. Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. (914-929).

    https://doi.org/10.1145/3453483.3454085

  • Gilray T, Kumar S and Micinski K. Compiling data-parallel Datalog. Proceedings of the 30th ACM SIGPLAN International Conference on Compiler Construction. (23-35).

    https://doi.org/10.1145/3446804.3446855

  • Madsen M and Lhoták O. (2020). Fixpoints for the masses: programming with first-class Datalog constraints. Proceedings of the ACM on Programming Languages. 4:OOPSLA. (1-28). Online publication date: 13-Nov-2020.

    https://doi.org/10.1145/3428193

  • Helm D, Kübler F, Reif M, Eichberg M and Mezini M. Modular collaborative program analysis in OPAL. Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. (184-196).

    https://doi.org/10.1145/3368089.3409765

  • Sui Y and Xue J. Value-Flow-Based Demand-Driven Pointer Analysis for C and C++. IEEE Transactions on Software Engineering. 10.1109/TSE.2018.2869336. 46:8. (812-835).

    https://ieeexplore.ieee.org/document/8457263/

  • Li Y, Tan T, Møller A and Smaragdakis Y. (2020). A Principled Approach to Selective Context Sensitivity for Pointer Analysis. ACM Transactions on Programming Languages and Systems. 42:2. (1-40). Online publication date: 30-Jun-2020.

    https://doi.org/10.1145/3381915

  • Thakur M and Nandivada V. Mix your contexts well: opportunities unleashed by recent advances in scaling context-sensitivity. Proceedings of the 29th International Conference on Compiler Construction. (27-38).

    https://doi.org/10.1145/3377555.3377902

  • Jeon M, Jeong S, Cha S and Oh H. (2019). A Machine-Learning Algorithm with Disjunctive Model for Data-Driven Program Analysis. ACM Transactions on Programming Languages and Systems. 41:2. (1-41). Online publication date: 30-Jun-2019.

    https://doi.org/10.1145/3293607

  • Li Y, Tan T and Xue J. (2019). Understanding and Analyzing Java Reflection. ACM Transactions on Software Engineering and Methodology. 28:2. (1-50). Online publication date: 30-Apr-2019.

    https://doi.org/10.1145/3295739

  • Liu B, Huang J and Rauchwerger L. (2019). Rethinking Incremental and Parallel Pointer Analysis. ACM Transactions on Programming Languages and Systems. 41:1. (1-31). Online publication date: 31-Mar-2019.

    https://doi.org/10.1145/3293606

  • Zhuo X and Zhang C. (2019). A Relational Static Semantics for Call Graph Construction. Formal Methods and Software Engineering. 10.1007/978-3-030-32409-4_20. (322-335).

    http://link.springer.com/10.1007/978-3-030-32409-4_20

  • Li Y, Tan T, Møller A and Smaragdakis Y. Scalability-first pointer analysis with self-tuning context-sensitivity. Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. (129-140).

    https://doi.org/10.1145/3236024.3236041

  • Li Y, Tan T, Møller A and Smaragdakis Y. (2018). Precision-guided context sensitivity for pointer analysis. Proceedings of the ACM on Programming Languages. 2:OOPSLA. (1-29). Online publication date: 24-Oct-2018.

    https://doi.org/10.1145/3276511

  • Jeon M, Jeong S and Oh H. (2018). Precise and scalable points-to analysis via data-driven context tunneling. Proceedings of the ACM on Programming Languages. 2:OOPSLA. (1-29). Online publication date: 24-Oct-2018.

    https://doi.org/10.1145/3276510

  • Fourtounis G, Kastrinis G and Smaragdakis Y. Static analysis of Java dynamic proxies. Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis. (209-220).

    https://doi.org/10.1145/3213846.3213864

  • Grech N, Fourtounis G, Francalanza A and Smaragdakis Y. Shooting from the heap: ultra-scalable static analysis with heap snapshots. Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis. (198-208).

    https://doi.org/10.1145/3213846.3213860

  • Zhang Y, Sui Y and Xue J. Launch-mode-aware context-sensitive activity transition analysis. Proceedings of the 40th International Conference on Software Engineering. (598-608).

    https://doi.org/10.1145/3180155.3180188

  • GILRAY T, ADAMS M and MIGHT M. (2018). Abstract allocation as a unified approach to polyvariance in control-flow analyses. Journal of Functional Programming. 10.1017/S0956796818000138. 28.

    https://www.cambridge.org/core/product/identifier/S0956796818000138/type/journal_article

  • Grech N and Smaragdakis Y. (2017). P/Taint: unified points-to and taint analysis. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-28). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133926

  • Chae K, Oh H, Heo K and Yang H. (2017). Automatically generating features for learning program analysis heuristics for C-like languages. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-25). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133925

  • Jeong S, Jeon M, Cha S and Oh H. (2017). Data-driven context-sensitivity for points-to analysis. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-28). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133924

  • Grech N, Fourtounis G, Francalanza A and Smaragdakis Y. (2017). Heaps don't lie: countering unsoundness with heap snapshots. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-27). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133892

  • Tan T, Li Y and Xue J. (2017). Efficient and precise points-to analysis: modeling the heap by merging equivalent automata. ACM SIGPLAN Notices. 52:6. (278-291). Online publication date: 14-Sep-2017.

    https://doi.org/10.1145/3140587.3062360

  • Thiessen R and Lhoták O. (2017). Context transformations for pointer analysis. ACM SIGPLAN Notices. 52:6. (263-277). Online publication date: 14-Sep-2017.

    https://doi.org/10.1145/3140587.3062359

  • Antoniadis T, Triantafyllou K and Smaragdakis Y. Porting doop to Soufflé. Proceedings of the 6th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis. (25-30).

    https://doi.org/10.1145/3088515.3088522

  • Balatsouras G, Ferles K, Kastrinis G and Smaragdakis Y. A Datalog model of must-alias analysis. Proceedings of the 6th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis. (7-12).

    https://doi.org/10.1145/3088515.3088517

  • Tan T, Li Y and Xue J. Efficient and precise points-to analysis: modeling the heap by merging equivalent automata. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. (278-291).

    https://doi.org/10.1145/3062341.3062360

  • Thiessen R and Lhoták O. Context transformations for pointer analysis. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. (263-277).

    https://doi.org/10.1145/3062341.3062359

  • Wang K, Hussain A, Zuo Z, Xu G and Amiri Sani A. (2017). Graspan. ACM SIGPLAN Notices. 52:4. (389-404). Online publication date: 12-May-2017.

    https://doi.org/10.1145/3093336.3037744

  • Wang K, Hussain A, Zuo Z, Xu G and Amiri Sani A. (2017). Graspan. ACM SIGARCH Computer Architecture News. 45:1. (389-404). Online publication date: 11-May-2017.

    https://doi.org/10.1145/3093337.3037744

  • Wang K, Hussain A, Zuo Z, Xu G and Amiri Sani A. (2017). Graspan. ACM SIGOPS Operating Systems Review. 10.1145/3093315.3037744. 51:2. (389-404). Online publication date: 4-Apr-2017.

    http://dl.acm.org/citation.cfm?doid=3093315.3037744

  • Wang K, Hussain A, Zuo Z, Xu G and Amiri Sani A. Graspan. Proceedings of the Twenty-Second International Conference on Architectural Support for Programming Languages and Operating Systems. (389-404).

    https://doi.org/10.1145/3037697.3037744

  • Si X, Zhang X, Grigore R and Naik M. (2017). Maximum Satisfiability in Software Analysis: Applications and Techniques. Computer Aided Verification. 10.1007/978-3-319-63387-9_4. (68-94).

    https://link.springer.com/10.1007/978-3-319-63387-9_4

  • Kulkarni S, Mangal R, Zhang X and Naik M. (2016). Accelerating program analyses by cross-program training. ACM SIGPLAN Notices. 51:10. (359-377). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984023

  • Bhandari K, Chakrabarti D and Boehm H. (2016). Makalu: fast recoverable allocation of non-volatile memory. ACM SIGPLAN Notices. 51:10. (677-694). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984019

  • De Rosso S and Jackson D. (2016). Purposes, concepts, misfits, and a redesign of git. ACM SIGPLAN Notices. 51:10. (292-310). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984018

  • Chandra S, Gordon C, Jeannin J, Schlesinger C, Sridharan M, Tip F and Choi Y. (2016). Type inference for static compilation of JavaScript. ACM SIGPLAN Notices. 51:10. (410-429). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984017

  • Treichler S, Bauer M, Sharma R, Slaughter E and Aiken A. (2016). Dependent partitioning. ACM SIGPLAN Notices. 51:10. (344-358). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984016

  • Shan Z, Azim T and Neamtiu I. (2016). Finding resume and restart errors in Android applications. ACM SIGPLAN Notices. 51:10. (864-880). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984011

  • Panchekha P and Torlak E. (2016). Automated reasoning for web page layout. ACM SIGPLAN Notices. 51:10. (181-194). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984010

  • Daloze B, Marr S, Bonetta D and Mössenböck H. (2016). Efficient and thread-safe objects for dynamically-typed languages. ACM SIGPLAN Notices. 51:10. (642-659). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2984001

  • Petrashko D, Ureche V, Lhoták O and Odersky M. (2016). Call graphs for languages with parametric polymorphism. ACM SIGPLAN Notices. 51:10. (394-409). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022671.2983991

  • Gilray T, Adams M and Might M. (2016). Allocation characterizes polyvariance: a unified methodology for polyvariant control-flow analysis. ACM SIGPLAN Notices. 51:9. (407-420). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022670.2951936

  • Sui Y, Ye D, Su Y and Xue J. Eliminating Redundant Bounds Checks in Dynamic Buffer Overflow Detection Using Weakest Preconditions. IEEE Transactions on Reliability. 10.1109/TR.2016.2570538. 65:4. (1682-1699).

    http://ieeexplore.ieee.org/document/7515160/

  • Zhan S and Huang J. ECHO: instantaneous in situ race detection in the IDE. Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. (775-786).

    https://doi.org/10.1145/2950290.2950332

  • Sui Y and Xue J. On-demand strong update analysis via value-flow refinement. Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. (460-473).

    https://doi.org/10.1145/2950290.2950296

  • Kulkarni S, Mangal R, Zhang X and Naik M. Accelerating program analyses by cross-program training. Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications. (359-377).

    https://doi.org/10.1145/2983990.2984023

  • Petrashko D, Ureche V, Lhoták O and Odersky M. Call graphs for languages with parametric polymorphism. Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications. (394-409).

    https://doi.org/10.1145/2983990.2983991

  • Gilray T, Adams M and Might M. Allocation characterizes polyvariance: a unified methodology for polyvariant control-flow analysis. Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming. (407-420).

    https://doi.org/10.1145/2951913.2951936

  • Samrit S and Nasre R. EagerMerge: an optimistic technique for efficient points-to analysis. Proceedings of the 25th International Symposium on Software Testing and Analysis. (47-58).

    https://doi.org/10.1145/2931037.2931045

  • Scholz B, Jordan H, Subotić P and Westmann T. On fast large-scale program analysis in Datalog. Proceedings of the 25th International Conference on Compiler Construction. (196-206).

    https://doi.org/10.1145/2892208.2892226

  • Stancu C, Wimmer C, Brunthaler S, Larsen P and Franz M. (2015). Safe and efficient hybrid memory management for Java. ACM SIGPLAN Notices. 50:11. (81-92). Online publication date: 28-Jan-2016.

    https://doi.org/10.1145/2887746.2754185

  • Oh H, Lee W, Heo K, Yang H and Yi K. (2015). Selective X-Sensitive Analysis Guided by Impact Pre-Analysis. ACM Transactions on Programming Languages and Systems. 38:2. (1-45). Online publication date: 4-Jan-2016.

    https://doi.org/10.1145/2821504

  • Tan T, Li Y and Xue J. (2016). Making k-Object-Sensitive Pointer Analysis More Precise with Still k-Limiting. Static Analysis. 10.1007/978-3-662-53413-7_24. (489-510).

    http://link.springer.com/10.1007/978-3-662-53413-7_24

  • Darais D, Might M and Van Horn D. (2015). Galois transformers and modular abstract interpreters: reusable metatheory for program analysis. ACM SIGPLAN Notices. 50:10. (552-571). Online publication date: 18-Dec-2015.

    https://doi.org/10.1145/2858965.2814308

  • Darais D, Might M and Van Horn D. Galois transformers and modular abstract interpreters: reusable metatheory for program analysis. Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications. (552-571).

    https://doi.org/10.1145/2814270.2814308

  • Stancu C, Wimmer C, Brunthaler S, Larsen P and Franz M. Safe and efficient hybrid memory management for Java. Proceedings of the 2015 International Symposium on Memory Management. (81-92).

    https://doi.org/10.1145/2754169.2754185

  • Weiss C, Rubio-González C and Liblit B. Database-backed program analysis for scalable error propagation. Proceedings of the 37th International Conference on Software Engineering - Volume 1. (586-597).

    /doi/10.5555/2818754.2818827

  • Weiss C, Rubio-Gonzalez C and Liblit B. (2015). Database-Backed Program Analysis for Scalable Error Propagation 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering (ICSE). 10.1109/ICSE.2015.75. 978-1-4799-1934-5. (586-597).

    http://ieeexplore.ieee.org/document/7194608/

  • Smaragdakis Y and Balatsouras G. (2015). Pointer Analysis. Foundations and Trends in Programming Languages. 2:1. (1-69). Online publication date: 1-Apr-2015.

    https://doi.org/10.1561/2500000014

  • Van der Hoek H and Hage J. Object-sensitive Type Analysis of PHP. Proceedings of the 2015 Workshop on Partial Evaluation and Program Manipulation. (9-20).

    https://doi.org/10.1145/2678015.2682535

  • Smaragdakis Y, Balatsouras G, Kastrinis G and Bravenboer M. (2015). More Sound Static Handling of Java Reflection. Programming Languages and Systems. 10.1007/978-3-319-26529-2_26. (485-503).

    http://link.springer.com/10.1007/978-3-319-26529-2_26

  • Andreasen E and Møller A. (2014). Determinacy in static analysis for jQuery. ACM SIGPLAN Notices. 49:10. (17-31). Online publication date: 31-Dec-2015.

    https://doi.org/10.1145/2714064.2660214

  • Kashyap V, Dewey K, Kuefner E, Wagner J, Gibbons K, Sarracino J, Wiedermann B and Hardekopf B. JSAI: a static analysis platform for JavaScript. Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. (121-132).

    https://doi.org/10.1145/2635868.2635904

  • Feng Y, Anand S, Dillig I and Aiken A. Apposcopy: semantics-based detection of Android malware through static analysis. Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. (576-587).

    https://doi.org/10.1145/2635868.2635869

  • Ye D, Su Y, Sui Y and Xue J. WPBOUND. Proceedings of the 2014 IEEE 25th International Symposium on Software Reliability Engineering. (88-99).

    https://doi.org/10.1109/ISSRE.2014.20

  • Andreasen E and Møller A. Determinacy in static analysis for jQuery. Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications. (17-31).

    https://doi.org/10.1145/2660193.2660214

  • Liang S, Sun W, Might M, Keep A and Horn D. Pruning, Pushdown Exception-Flow Analysis. Proceedings of the 2014 IEEE 14th International Working Conference on Source Code Analysis and Manipulation. (265-274).

    https://doi.org/10.1109/SCAM.2014.44

  • Stancu C, Wimmer C, Brunthaler S, Larsen P and Franz M. Comparing points-to static analysis with runtime recorded profiling data. Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java platform: Virtual machines, Languages, and Tools. (157-168).

    https://doi.org/10.1145/2647508.2647524

  • Li Y, Tan T, Sui Y and Xue J. Self-inferencing Reflection Resolution for Java. Proceedings of the 28th European Conference on ECOOP 2014 --- Object-Oriented Programming - Volume 8586. (27-53).

    https://doi.org/10.1007/978-3-662-44202-9_2

  • Wei S and Ryder B. State-Sensitive Points-to Analysis for the Dynamic Behavior of JavaScript Objects. Proceedings of the 28th European Conference on ECOOP 2014 --- Object-Oriented Programming - Volume 8586. (1-26).

    https://doi.org/10.1007/978-3-662-44202-9_1

  • Wang H, Chan W and Tse T. (2014). Improving the Effectiveness of Testing Pervasive Software via Context Diversity. ACM Transactions on Autonomous and Adaptive Systems. 9:2. (1-28). Online publication date: 1-Jul-2014.

    https://doi.org/10.1145/2620000

  • Zhang X, Mangal R, Grigore R, Naik M and Yang H. On abstraction refinement for program analyses in Datalog. Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. (239-248).

    https://doi.org/10.1145/2594291.2594327

  • Smaragdakis Y, Kastrinis G and Balatsouras G. Introspective analysis. Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. (485-495).

    https://doi.org/10.1145/2594291.2594320

  • Oh H, Lee W, Heo K, Yang H and Yi K. Selective context-sensitivity guided by impact pre-analysis. Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. (475-484).

    https://doi.org/10.1145/2594291.2594318

  • Zhang X, Mangal R, Grigore R, Naik M and Yang H. (2014). On abstraction refinement for program analyses in Datalog. ACM SIGPLAN Notices. 49:6. (239-248). Online publication date: 5-Jun-2014.

    https://doi.org/10.1145/2666356.2594327

  • Smaragdakis Y, Kastrinis G and Balatsouras G. (2014). Introspective analysis. ACM SIGPLAN Notices. 49:6. (485-495). Online publication date: 5-Jun-2014.

    https://doi.org/10.1145/2666356.2594320

  • Oh H, Lee W, Heo K, Yang H and Yi K. (2014). Selective context-sensitivity guided by impact pre-analysis. ACM SIGPLAN Notices. 49:6. (475-484). Online publication date: 5-Jun-2014.

    https://doi.org/10.1145/2666356.2594318

  • Balatsouras G and Smaragdakis Y. (2013). Class hierarchy complementation. ACM SIGPLAN Notices. 48:10. (515-532). Online publication date: 12-Nov-2013.

    https://doi.org/10.1145/2544173.2509530

  • Smaragdakis Y, Balatsouras G and Kastrinis G. (2013). Set-based pre-processing for points-to analysis. ACM SIGPLAN Notices. 48:10. (253-270). Online publication date: 12-Nov-2013.

    https://doi.org/10.1145/2544173.2509524

  • Balatsouras G and Smaragdakis Y. Class hierarchy complementation. Proceedings of the 2013 ACM SIGPLAN international conference on Object oriented programming systems languages & applications. (515-532).

    https://doi.org/10.1145/2509136.2509530

  • Smaragdakis Y, Balatsouras G and Kastrinis G. Set-based pre-processing for points-to analysis. Proceedings of the 2013 ACM SIGPLAN international conference on Object oriented programming systems languages & applications. (253-270).

    https://doi.org/10.1145/2509136.2509524

  • Lepori A, Calotoiu A and Hoefler T. Iterating Pointers: Enabling Static Analysis for Loop-based Pointers. ACM Transactions on Architecture and Code Optimization. 0:0.

    https://doi.org/10.1145/3701993

  • Oh W and Oh H. Towards Effective Static Type-Error Detection for Python. Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. (1808-1820).

    https://doi.org/10.1145/3691620.3695545

  • Jin W, Xu S, Chen D, He J, Zhong D, Fan M, Chen H, Zhang H and Liu T. PyAnalyzer: An Effective and Practical Approach for Dependency Extraction from Python Code. Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. (1-12).

    https://doi.org/10.1145/3597503.3640325

  • Li H, Tan T, Li Y, Lu J, Meng H, Cao L, Huang Y, Li L, Gao L, Di P, Lin L and Cui C. (2024). Generic Sensitivity: Generics-Guided Context Sensitivity for Pointer Analysis. IEEE Transactions on Software Engineering. 50:5. (1144-1162). Online publication date: 1-May-2024.

    https://doi.org/10.1109/TSE.2024.3377645

  • Santos J, Mirakhorli M and Shokri A. (2024). Seneca: Taint-Based Call Graph Construction for Java Object Deserialization. Proceedings of the ACM on Programming Languages. 8:OOPSLA1. (1125-1153). Online publication date: 29-Apr-2024.

    https://doi.org/10.1145/3649851

  • Yue G, Xiao H and Chen J. Backdoor Detection Based on Static Code Analysis and Software Component Analysis. Proceedings of the 2023 3rd International Conference on Big Data, Artificial Intelligence and Risk Management. (1120-1124).

    https://doi.org/10.1145/3656766.3656967

  • He D, Gui Y, Li W, Tao Y, Zou C, Sui Y and Xue J. (2023). A Container-Usage-Pattern-Based Context Debloating Approach for Object-Sensitive Pointer Analysis. Proceedings of the ACM on Programming Languages. 7:OOPSLA2. (971-1000). Online publication date: 16-Oct-2023.

    https://doi.org/10.1145/3622832

  • Li H, Lu J, Meng H, Cao L, Huang Y, Li L and Gao L. Generic sensitivity: customizing context-sensitive pointer analysis for generics. Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. (1110-1121).

    https://doi.org/10.1145/3540250.3549122

  • Hedenborg M, Lundberg J, Löwe W and Trapp M. (2022). A Framework for Memory Efficient Context-Sensitive Program Analysis. Theory of Computing Systems. 66:5. (911-956). Online publication date: 1-Oct-2022.

    https://doi.org/10.1007/s00224-022-10093-w

  • Kim S, Zeng D, Sun C and Tan G. BinPointer: towards precise, sound, and scalable binary-level pointer analysis. Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. (169-180).

    https://doi.org/10.1145/3497776.3517776

  • Schulz S, Herrendorf E and Bockisch C. (2021). Thread-Sensitive Data Race Detection for Java 2021 28th Asia-Pacific Software Engineering Conference (APSEC). 10.1109/APSEC53868.2021.00011. 978-1-6654-3784-4. (32-42).

    https://ieeexplore.ieee.org/document/9712153/

  • Tan T, Li Y, Ma X, Xu C and Smaragdakis Y. (2021). Making pointer analysis more precise by unleashing the power of selective context sensitivity. Proceedings of the ACM on Programming Languages. 5:OOPSLA. (1-27). Online publication date: 20-Oct-2021.

    https://doi.org/10.1145/3485524

  • Santos J, Jones R, Ashiogwu C and Mirakhorli M. Serialization-aware call graph construction. Proceedings of the 10th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. (37-42).

    https://doi.org/10.1145/3460946.3464319

  • Palit T, Firose Moon J, Monrose F and Polychronakis M. (2021). DynPTA: Combining Static and Dynamic Analysis for Practical Selective Data Protection 2021 IEEE Symposium on Security and Privacy (SP). 10.1109/SP40001.2021.00082. 978-1-7281-8934-5. (1919-1937).

    https://ieeexplore.ieee.org/document/9519446/

  • Gilray T, Kumar S and Micinski K. Compiling data-parallel Datalog. Proceedings of the 30th ACM SIGPLAN International Conference on Compiler Construction. (23-35).

    https://doi.org/10.1145/3446804.3446855

  • Votipka D, Rabin S, Micinski K, Foster J and Mazurek M. An observational investigation of reverse engineers' processes. Proceedings of the 29th USENIX Conference on Security Symposium. (1875-1892).

    /doi/10.5555/3489212.3489318

  • Santos J, Jones R and Mirakhorli M. Salsa: static analysis of serialization features. Proceedings of the 22nd ACM SIGPLAN International Workshop on Formal Techniques for Java-Like Programs. (18-25).

    https://doi.org/10.1145/3427761.3428343

  • Zuo Z, Wang K, Hussain A, Sani A, Zhang Y, Lu S, Dou W, Wang L, Li X, Wang C and Xu G. (2021). Systemizing Interprocedural Static Analysis of Large-scale Systems Code with Graspan. ACM Transactions on Computer Systems. 38:1-2. (1-39). Online publication date: 31-May-2020.

    https://doi.org/10.1145/3466820

  • Wang Y, Zhou M, Gu M and Sun J. (2019). Necessity and Capability of Flow, Context, Field and Quasi Path Sensitive Points-to Analysis 2019 26th Asia-Pacific Software Engineering Conference (APSEC). 10.1109/APSEC48747.2019.00044. 978-1-7281-4648-5. (268-275).

    https://ieeexplore.ieee.org/document/8945737/

  • Wang Y, Chen G, Zhou M, Gu M and Sun J. TsmartGP. Proceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering. (1170-1173).

    https://doi.org/10.1109/ASE.2019.00129

  • Yan H, Chen S, Sui Y, Zhang Y, Zou C and Xue J. Per-Dereference Verification of Temporal Heap Safety via Adaptive Context-Sensitive Analysis. Static Analysis. (48-72).

    https://doi.org/10.1007/978-3-030-32304-2_4

  • Calzavara S, Grishchenko I, Koutsos A and Maffei M. (2017). A Sound Flow-Sensitive Heap Abstraction for the Static Analysis of Android Applications 2017 IEEE 30th Computer Security Foundations Symposium (CSF). 10.1109/CSF.2017.19. 978-1-5386-3217-8. (22-36).

    http://ieeexplore.ieee.org/document/8049649/

  • Wang K, Hussain A, Zuo Z, Xu G and Amiri Sani A. Graspan. Proceedings of the Twenty-Second International Conference on Architectural Support for Programming Languages and Operating Systems. (389-404).

    https://doi.org/10.1145/3037697.3037744

  • Gilray T, Adams M and Might M. (2016). Allocation characterizes polyvariance: a unified methodology for polyvariant control-flow analysis. ACM SIGPLAN Notices. 51:9. (407-420). Online publication date: 5-Dec-2016.

    https://doi.org/10.1145/3022670.2951936

  • Gilray T, Adams M and Might M. Allocation characterizes polyvariance: a unified methodology for polyvariant control-flow analysis. Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming. (407-420).

    https://doi.org/10.1145/2951913.2951936

  • KASHIMA Y, ISHIO T and INOUE K. (2015). Comparison of Backward Slicing Techniques for Java. IEICE Transactions on Information and Systems. 10.1587/transinf.2014EDP7310. E98.D:1. (119-130).

    https://www.jstage.jst.go.jp/article/transinf/E98.D/1/E98.D_2014EDP7310/_article

  • Feng Y, Wang X, Dillig I and Dillig T. (2015). Bottom-Up Context-Sensitive Pointer Analysis for Java. Programming Languages and Systems. 10.1007/978-3-319-26529-2_25. (465-484).

    http://link.springer.com/10.1007/978-3-319-26529-2_25

  • Feng Y, Anand S, Dillig I and Aiken A. Apposcopy: semantics-based detection of Android malware through static analysis. Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. (576-587).

    https://doi.org/10.1145/2635868.2635869

  • Li Y, Tan T, Sui Y and Xue J. Self-inferencing Reflection Resolution for Java. Proceedings of the 28th European Conference on ECOOP 2014 --- Object-Oriented Programming - Volume 8586. (27-53).

    https://doi.org/10.1007/978-3-662-44202-9_2

  • Ye S, Sui Y and Xue J. (2014). Region-Based Selective Flow-Sensitive Pointer Analysis. Static Analysis. 10.1007/978-3-319-10936-7_20. (319-336).

    http://link.springer.com/10.1007/978-3-319-10936-7_20