Document Open Access Logo

Lossless, Persisted Summarization of Static Callgraph, Points-To and Data-Flow Analysis

Authors Philipp Dominik Schubert , Ben Hermann , Eric Bodden

PDF
Thumbnail PDF

File

LIPIcs.ECOOP.2021.2.pdf
  • Filesize: 1 MB
  • 31 pages

Document Identifiers

Author Details

Philipp Dominik Schubert
  • Heinz Nixdorf Institute, Paderborn, Germany
Ben Hermann
  • Technische Universität Dortmund, Germany
Eric Bodden
  • Heinz Nixdorf Institute, Paderborn, Germany
  • Fraunhofer IEM, Paderborn, Germany

Funding

This work was partially supported by the German Research Foundation (DFG) within the Collaborative Research Centre 901 "On-The-Fly Computing" under the project number 160364472-SFB901/3 and the Heinz Nixdorf Foundation.

Cite AsGet BibTex

Philipp Dominik Schubert, Ben Hermann, and Eric Bodden. Lossless, Persisted Summarization of Static Callgraph, Points-To and Data-Flow Analysis. In 35th European Conference on Object-Oriented Programming (ECOOP 2021). Leibniz International Proceedings in Informatics (LIPIcs), Volume 194, pp. 2:1-2:31, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)
https://doi.org/10.4230/LIPIcs.ECOOP.2021.2

Abstract

Static analysis is used to automatically detect bugs and security breaches, and aids compiler optimization. Whole-program analysis (WPA) can yield high precision, however causes long analysis times and thus does not match common software-development workflows, making it often impractical to use for large, real-world applications. This paper thus presents the design and implementation of ModAlyzer, a novel static-analysis approach that aims at accelerating whole-program analysis by making the analysis modular and compositional. It shows how to compute lossless, persisted summaries for callgraph, points-to and data-flow information, and it reports under which circumstances this function-level compositional analysis outperforms WPA. We implemented ModAlyzer as an extension to LLVM and PhASAR, and applied it to 12 real-world C and C++ applications. At analysis time, ModAlyzer modularly and losslessly summarizes the analysis effect of the library code those applications share, hence avoiding its repeated re-analysis. The experimental results show that the reuse of these summaries can save, on average, 72% of analysis time over WPA. Moreover, because it is lossless, the module-wise analysis fully retains precision and recall. Surprisingly, as our results show, it sometimes even yields precision superior to WPA. The initial summary generation, on average, takes about 3.67 times as long as WPA.

Subject Classification

ACM Subject Classification
  • Software and its engineering → Automated static analysis
Keywords
  • Inter-procedural static analysis
  • compositional analysis
  • LLVM
  • C/C++

Metrics

  • Access Statistics
  • Total Accesses (updated on a weekly basis)
    0
    PDF Downloads
    0
    Metadata Views

References

  1. C++ applications, December 2018. URL: http://www.stroustrup.com/applications.html/.
  2. clang-tidy, August 2018. URL: http://clang.llvm.org/extra/clang-tidy/.
  3. coreutils, July 2018. URL: https://www.gnu.org/software/coreutils/coreutils.html.
  4. Coverity static application security testing (sast), December 2018. URL: https://www.synopsys.com/software-integrity/security-testing/static-analysis-sast.html.
  5. Cppcheck, August 2018. URL: http://cppcheck.sourceforge.net/.
  6. Gcc optimize options, December 2018. URL: https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html.
  7. Grammatech codesonar, 2018. URL: https://www.grammatech.com/products/codesonar.
  8. Intel® c++ compiler 19.0 developer guide and reference: Interprocedural optimization (ipo), December 2018. URL: https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-interprocedural-optimization-ipo.
  9. Java virtual machine specification: The constant pool, December 2018. URL: https://docs.oracle.com/javase/specs/jvms/se10/html/jvms-4.html#jvms-4.4.
  10. Phasar, July 2018. URL: https://phasar.org.
  11. The programming languages beacon, December 2018. URL: http://www.lextrait.com/vincent/implementations.html/.
  12. The state of open source security, December 2018. URL: https://snyk.io/stateofossecurity/.
  13. Thinlto: Scalable and incremental lto, July 2018. URL: http://blog.llvm.org/2016/06/thinlto-scalable-and-incremental-lto.html.
  14. Boost.serialization, August 2019. URL: https://www.boost.org/doc/libs/1_70_0/libs/serialization/doc/.
  15. Graphviz, August 2019. URL: https://www.graphviz.org/.
  16. Supplementary material, 2019. URL: https://drive.google.com/drive/folders/1uLHDkmdWdjQ-aeZjyRizhy9zwrX4VWVo?usp=sharing.
  17. Gerald Aigner and Urs Hölzle. Eliminating virtual function calls in c++ programs. In Pierre Cointe, editor, ECOOP '96 - Object-Oriented Programming, pages 142-166, Berlin, Heidelberg, 1996. Springer Berlin Heidelberg. Google Scholar
  18. Karim Ali and Ondřej Lhoták. Averroes: Whole-program analysis without the whole program. In Proceedings of the 27th European Conference on Object-Oriented Programming, ECOOP'13, pages 378-400, Berlin, Heidelberg, 2013. Springer-Verlag. URL: https://doi.org/10.1007/978-3-642-39038-8_16.
  19. Lars Ole Andersen. Program Analysis and Specialization for the C Programming Language. Datalogisk Institut, Københavns Universitet, 1994. Google Scholar
  20. Steven Arzt and Eric Bodden. Reviser: Efficiently updating ide-/ifds-based data-flow analyses in response to incremental program changes. In Proceedings of the 36th International Conference on Software Engineering, ICSE 2014, pages 288-298, New York, NY, USA, 2014. ACM. URL: https://doi.org/10.1145/2568225.2568243.
  21. Steven Arzt and Eric Bodden. Stubdroid: Automatic inference of precise data-flow summaries for the android framework. In Proceedings of the 38th International Conference on Software Engineering, ICSE '16, pages 725-735, New York, NY, USA, 2016. ACM. URL: https://doi.org/10.1145/2884781.2884816.
  22. Steven Arzt, Siegfried Rasthofer, Christian Fritz, Eric Bodden, Alexandre Bartel, Jacques Klein, Yves Le Traon, Damien Octeau, and Patrick McDaniel. Flowdroid: Precise context, flow, field, object-sensitive and lifecycle-aware taint analysis for android apps. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '14, pages 259-269, New York, NY, USA, 2014. ACM. URL: https://doi.org/10.1145/2594291.2594299.
  23. Al Bessey, Ken Block, Ben Chelf, Andy Chou, Bryan Fulton, Seth Hallem, Charles Henri-Gros, Asya Kamsky, Scott McPeak, and Dawson Engler. A few billion lines of code later: Using static analysis to find bugs in the real world. Commun. ACM, 53(2):66-75, 2010. URL: https://doi.org/10.1145/1646353.1646374.
  24. Dirk Beyer, Sumit Gulwani, and David A Schmidt. Combining model checking and data-flow analysis. In Handbook of Model Checking, pages 493-540. Springer, 2018. Google Scholar
  25. Eric Bodden. Inter-procedural data-flow analysis with ifds/ide and soot. In Proceedings of the ACM SIGPLAN International Workshop on State of the Art in Java Program Analysis, SOAP '12, pages 3-8, New York, NY, USA, 2012. ACM. URL: https://doi.org/10.1145/2259051.2259052.
  26. Eric Bodden. The secret sauce in efficient and precise static analysis. In Proceedings of the 7th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, SOAP 2018, 2018. To appear. Google Scholar
  27. Cristiano Calcagno and Dino Distefano. Infer: An automatic program verifier for memory safety of c programs. In NASA Formal Methods Symposium, pages 459-465. Springer, 2011. Google Scholar
  28. Cristiano Calcagno, Dino Distefano, Peter O'Hearn, and Hongseok Yang. Compositional shape analysis by means of bi-abduction. In Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '09, pages 289-300, New York, NY, USA, 2009. ACM. URL: https://doi.org/10.1145/1480881.1480917.
  29. Brad Calder and Dirk Grunwald. Reducing indirect function call overhead in c++ programs. In Proceedings of the 21st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’94, page 397–408, New York, NY, USA, 1994. Association for Computing Machinery. URL: https://doi.org/10.1145/174675.177973.
  30. Krishnendu Chatterjee, Bhavya Choudhary, and Andreas Pavlogiannis. Optimal dyck reachability for data-dependence and alias analysis. Proc. ACM Program. Lang., 2(POPL):30:1-30:30, 2017. URL: https://doi.org/10.1145/3158118.
  31. Michael Codish, Saumya K. Debray, and Roberto Giacobazzi. Compositional analysis of modular logic programs. In Proceedings of the 20th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '93, pages 451-464, New York, NY, USA, 1993. ACM. URL: https://doi.org/10.1145/158511.158703.
  32. Karel Driesen and Urs Hölzle. The direct cost of virtual function calls in c++. In Proceedings of the 11th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA ’96, page 306–323, New York, NY, USA, 1996. Association for Computing Machinery. URL: https://doi.org/10.1145/236337.236369.
  33. M. B. Dwyer. Modular flow analysis for concurrent software. In Proceedings of the 12th International Conference on Automated Software Engineering (Formerly: KBSE), ASE '97, pages 264-, Washington, DC, USA, 1997. IEEE Computer Society. URL: http://dl.acm.org/citation.cfm?id=786767.786816.
  34. Michael Eichberg, Ben Hermann, Mira Mezini, and Leonid Glanz. Hidden truths in dead software paths. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, ESEC/FSE 2015, pages 474-484, New York, NY, USA, 2015. ACM. URL: https://doi.org/10.1145/2786805.2786865.
  35. Jon Eyolfson and Patrick Lam. C++ const and Immutability: An Empirical Study of Writes-Through-const. In Shriram Krishnamurthi and Benjamin S. Lerner, editors, 30th European Conference on Object-Oriented Programming (ECOOP 2016), volume 56 of Leibniz International Proceedings in Informatics (LIPIcs), pages 8:1-8:25, Dagstuhl, Germany, 2016. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik. URL: https://doi.org/10.4230/LIPIcs.ECOOP.2016.8.
  36. Sanjay Ghemawat, Keith H. Randall, and Daniel J. Scales. Field analysis: Getting useful and low-cost interprocedural information. In Proceedings of the ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation, PLDI '00, pages 334-344, New York, NY, USA, 2000. ACM. URL: https://doi.org/10.1145/349299.349343.
  37. Mark Harman and Peter O'Hearn. From start-ups to scale-ups: Opportunities and open problems for static and dynamic program analysis. In 2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM), pages 1-23. IEEE, 2018. Google Scholar
  38. Mary Jean Harrold and Gregg Rothermel. Separate computation of alias information for reuse. IEEE Trans. Softw. Eng., 22(7):442-460, July 1996. URL: https://doi.org/10.1109/32.538603.
  39. Ben Hermann, Michael Reif, Michael Eichberg, and Mira Mezini. Getting to know you: Towards a capability model for java. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, ESEC/FSE 2015, pages 758-769, New York, NY, USA, 2015. ACM. URL: https://doi.org/10.1145/2786805.2786829.
  40. P. Holzinger, B. Hermann, J. Lerch, E. Bodden, and M. Mezini. Hardening java’s access control by abolishing implicit privilege elevation. In 2017 IEEE Symposium on Security and Privacy (SP), pages 1027-1040, May 2017. URL: https://doi.org/10.1109/SP.2017.16.
  41. John B Kam and Jeffrey D Ullman. Monotone data flow analysis frameworks. Acta Informatica, 7(3):305-317, 1977. Google Scholar
  42. Gary A. Kildall. A unified approach to global program optimization. In Proceedings of the 1st Annual ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL '73, pages 194-206, New York, NY, USA, 1973. ACM. URL: https://doi.org/10.1145/512927.512945.
  43. Karsten Klohs. A summary function model for the validation of interprocedural analysis results. In Proceedings of the 7th International Workshop on Compiler Optimization meets Compiler Verification, COCV'08, 2008. Google Scholar
  44. Stefan Krüger, Sarah Nadi, Michael Reif, Karim Ali, Mira Mezini, Eric Bodden, Florian Göpfert, Felix Günther, Christian Weinert, Daniel Demmler, and Ram Kamath. Cognicrypt: Supporting developers in using cryptography. In Proceedings of the 32Nd IEEE/ACM International Conference on Automated Software Engineering, ASE 2017, pages 931-936, Piscataway, NJ, USA, 2017. IEEE Press. URL: http://dl.acm.org/citation.cfm?id=3155562.3155681.
  45. Chris Lattner and Vikram Adve. Llvm: A compilation framework for lifelong program analysis & transformation. In Proceedings of the International Symposium on Code Generation and Optimization: Feedback-directed and Runtime Optimization, CGO '04, pages 75-, Washington, DC, USA, 2004. IEEE Computer Society. URL: http://dl.acm.org/citation.cfm?id=977395.977673.
  46. Yue Li, Tian Tan, Anders Møller, and Yannis Smaragdakis. Scalability-first pointer analysis with self-tuning context-sensitivity. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/FSE 2018, pages 129-140, New York, NY, USA, 2018. ACM. URL: https://doi.org/10.1145/3236024.3236041.
  47. V. Benjamin Livshits and Monica S. Lam. Finding security vulnerabilities in java applications with static analysis. In Proceedings of the 14th Conference on USENIX Security Symposium - Volume 14, SSYM'05, pages 18-18, Berkeley, CA, USA, 2005. USENIX Association. URL: http://dl.acm.org/citation.cfm?id=1251398.1251416.
  48. Yi Lu, Lei Shang, Xinwei Xie, and Jingling Xue. An incremental points-to analysis with cfl-reachability. In Proceedings of the 22Nd International Conference on Compiler Construction, CC'13, pages 61-81, Berlin, Heidelberg, 2013. Springer-Verlag. URL: https://doi.org/10.1007/978-3-642-37051-9_4.
  49. Scott Meyers. Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition). Addison-Wesley Professional, 2005. Google Scholar
  50. Scott Meyers. Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14. O'Reilly Media, Inc., 1st edition, 2014. Google Scholar
  51. Nomair A. Naeem, Ondřej Lhoták, and Jonathan Rodriguez. Practical extensions to the ifds algorithm. In Proceedings of the 19th Joint European Conference on Theory and Practice of Software, International Conference on Compiler Construction, CC'10/ETAPS'10, pages 124-144, Berlin, Heidelberg, 2010. Springer-Verlag. URL: https://doi.org/10.1007/978-3-642-11970-5_8.
  52. Nicholas Oxhøj, Jens Palsberg, and Michael I. Schwartzbach. Making type inference practical. In Ole Lehrmann Madsen, editor, ECOOP '92 European Conference on Object-Oriented Programming, pages 329-349, Berlin, Heidelberg, 1992. Springer Berlin Heidelberg. Google Scholar
  53. Santanu Saha Ray. Graph Theory with Algorithms and Its Applications: In Applied Science and Technology. Springer Publishing Company, Incorporated, 2014. Google Scholar
  54. Michael Reif, Michael Eichberg, Ben Hermann, Johannes Lerch, and Mira Mezini. Call graph construction for java libraries. In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, FSE 2016, pages 474-486, New York, NY, USA, 2016. ACM. URL: https://doi.org/10.1145/2950290.2950312.
  55. Thomas Reps, Susan Horwitz, and Mooly Sagiv. Precise interprocedural dataflow analysis via graph reachability. In Proceedings of the 22Nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '95, pages 49-61, New York, NY, USA, 1995. ACM. URL: https://doi.org/10.1145/199448.199462.
  56. Thomas Reps, Stefan Schwoon, and Somesh Jha. Weighted pushdown systems and their application to interprocedural dataflow analysis. In Proceedings of the 10th International Conference on Static Analysis, SAS'03, pages 189-213, Berlin, Heidelberg, 2003. Springer-Verlag. URL: http://dl.acm.org/citation.cfm?id=1760267.1760283.
  57. H. G. Rice. Classes of recursively enumerable sets and their decision problems. Transactions of the American Mathematical Society, 1953, 74, 2, 358, 1953. Google Scholar
  58. Personal communication with atanas (nasko) rountev, 2014. Google Scholar
  59. A. Rountev, A. Milanova, and B. G. Ryder. Fragment class analysis for testing of polymorphism in java software. IEEE Transactions on Software Engineering, 30(6):372-387, June 2004. URL: https://doi.org/10.1109/TSE.2004.20.
  60. Atanas Rountev and Barbara G. Ryder. Points-to and side-effect analyses for programs built with precompiled libraries. In Reinhard Wilhelm, editor, Compiler Construction, pages 20-36, Berlin, Heidelberg, 2001. Springer Berlin Heidelberg. Google Scholar
  61. Atanas Rountev, Barbara G. Ryder, and William Landi. Data-flow analysis of program fragments. In Oscar Nierstrasz and Michel Lemoine, editors, Software Engineering - ESEC/FSE '99, pages 235-252, Berlin, Heidelberg, 1999. Springer Berlin Heidelberg. Google Scholar
  62. Atanas Rountev, Mariana Sharp, and Guoqing Xu. Ide dataflow analysis in the presence of large object-oriented libraries. In Proceedings of the Joint European Conferences on Theory and Practice of Software 17th International Conference on Compiler Construction, CC'08/ETAPS'08, pages 53-68, Berlin, Heidelberg, 2008. Springer-Verlag. URL: http://dl.acm.org/citation.cfm?id=1788374.1788380.
  63. Mooly Sagiv, Thomas Reps, and Susan Horwitz. Precise interprocedural dataflow analysis with applications to constant propagation. Theor. Comput. Sci., 167(1-2):131-170, 1996. URL: https://doi.org/10.1016/0304-3975(96)00072-2.
  64. Philipp Dominik Schubert, Ben Hermann, and Eric Bodden. Phasar: An inter-procedural static analysis framework for c/c++. In Tomáš Vojnar and Lijun Zhang, editors, Tools and Algorithms for the Construction and Analysis of Systems, pages 393-410, Cham, 2019. Springer International Publishing. Google Scholar
  65. Lei Shang, Xinwei Xie, and Jingling Xue. On-demand dynamic summary-based points-to analysis. In Proceedings of the Tenth International Symposium on Code Generation and Optimization, CGO '12, pages 264-274, New York, NY, USA, 2012. ACM. URL: https://doi.org/10.1145/2259016.2259050.
  66. M Sharir and A Pnueli. Two approaches to interprocedural data flow analysis. New York Univ. Comput. Sci. Dept., New York, NY, 1978. URL: https://cds.cern.ch/record/120118.
  67. Jeremy G. Siek, Lie-Quan Lee, and Andrew Lumsdaine. The Boost Graph Library - User Guide and Reference Manual. C++ in-depth series. Pearson / Prentice Hall, 2002. Google Scholar
  68. Yannis Smaragdakis, Martin Bravenboer, and Ondrej Lhoták. Pick your contexts well: Understanding object-sensitivity. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '11, pages 17-30, New York, NY, USA, 2011. ACM. URL: https://doi.org/10.1145/1926385.1926390.
  69. Yannis Smaragdakis, George Kastrinis, and George Balatsouras. Introspective analysis: Context-sensitivity, across the board. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '14, pages 485-495, New York, NY, USA, 2014. ACM. URL: https://doi.org/10.1145/2594291.2594320.
  70. Black Duck Software. 2018 open source security and risk analysis. https://www.synopsys.com/content/dam/synopsys/sig-assets/reports/2018-ossra.pdf, 2018.
  71. Johannes Späth, Karim Ali, and Eric Bodden. Ideal: Efficient and precise alias-aware dataflow analysis. Proc. ACM Program. Lang., 1(OOPSLA), October 2017. URL: https://doi.org/10.1145/3133923.
  72. Johannes Späth, Lisa Nguyen, Karim Ali, and Eric Bodden. Boomerang: Demand-driven flow- and context-sensitive pointer analysis for java. In European Conference on Object-Oriented Programming (ECOOP), 17 - 22 July 2016. Google Scholar
  73. Bjarne Steensgaard. Points-to analysis in almost linear time. In Proceedings of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '96, pages 32-41, New York, NY, USA, 1996. ACM. URL: https://doi.org/10.1145/237721.237727.
  74. R E Strom and S Yemini. Typestate: A programming language concept for enhancing software reliability. IEEE Trans. Softw. Eng., 12(1):157-171, 1986. URL: https://doi.org/10.1109/TSE.1986.6312929.
  75. Robert E. Strom. Mechanisms for compile-time enforcement of security. In Proceedings of the 10th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL '83, pages 276-284, New York, NY, USA, 1983. ACM. URL: https://doi.org/10.1145/567067.567093.
  76. Yulei Sui and Jingling Xue. 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, pages 460-473, New York, NY, USA, 2016. ACM. URL: https://doi.org/10.1145/2950290.2950296.
  77. Yulei Sui and Jingling Xue. Svf: Interprocedural static value-flow analysis in llvm. In Proceedings of the 25th International Conference on Compiler Construction, CC 2016, pages 265-266, New York, NY, USA, 2016. ACM. URL: https://doi.org/10.1145/2892208.2892235.
  78. Hao Tang, Di Wang, Yingfei Xiong, Lingming Zhang, Xiaoyin Wang, and Lu Zhang. Conditional dyck-cfl reachability analysis for complete and efficient library summarization. In Hongseok Yang, editor, Programming Languages and Systems, pages 880-908, Berlin, Heidelberg, 2017. Springer Berlin Heidelberg. Google Scholar
  79. Hao Tang, Xiaoyin Wang, Lingming Zhang, Bing Xie, Lu Zhang, and Hong Mei. Summary-based context-sensitive data-dependence analysis in presence of callbacks. In Proceedings of the 42Nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '15, pages 83-95, New York, NY, USA, 2015. ACM. URL: https://doi.org/10.1145/2676726.2676997.
  80. John Toman and Dan Grossman. Taming the Static Analysis Beast. In Benjamin S. Lerner, Rastislav Bodík, and Shriram Krishnamurthi, editors, 2nd Summit on Advances in Programming Languages (SNAPL 2017), volume 71 of Leibniz International Proceedings in Informatics (LIPIcs), pages 18:1-18:14, Dagstuhl, Germany, 2017. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik. URL: https://doi.org/10.4230/LIPIcs.SNAPL.2017.18.
  81. John Whaley and Martin Rinard. Compositional pointer and escape analysis for java programs. In Proceedings of the 14th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA ’99, page 187–206, New York, NY, USA, 1999. Association for Computing Machinery. URL: https://doi.org/10.1145/320384.320400.
  82. Reinhard Wilhelm, Shmuel Sagiv, and Thomas W. Reps. Shape analysis. In Proceedings of the 9th International Conference on Compiler Construction, CC '00, pages 1-17, London, UK, UK, 2000. Springer-Verlag. URL: http://dl.acm.org/citation.cfm?id=647476.760384.
  83. Jingling Xue and Phung Hua Nguyen. Completeness analysis for incomplete object-oriented programs. In International Conference on Compiler Construction, volume 3443, pages 271-286, April 2005. URL: https://doi.org/10.1007/978-3-540-31985-6_21.
Questions / Remarks / Feedback
X

Feedback for Dagstuhl Publishing


Thanks for your feedback!

Feedback submitted

Could not send message

Please try again later or send an E-mail
© 2023-2024 Schloss Dagstuhl – LZI GmbH Imprint Privacy Contact