skip to main content
research-article
Open Access

Sound garbage collection for C using pointer provenance

Published:13 November 2020Publication History
Skip Abstract Section

Abstract

Garbage collection (GC) support for unmanaged languages can reduce programming burden in reasoning about liveness of dynamic objects. It also avoids temporal memory safety violations and memory leaks. Sound GC for weakly-typed languages such as C/C++, however, remains an unsolved problem. Current value-based GC solutions examine values of memory locations to discover the pointers, and the objects they point to. The approach is inherently unsound in the presence of arbitrary type casts and pointer manipulations, which are legal in C/C++. Such language features are regularly used, especially in low-level systems code.

In this paper, we propose Dynamic Pointer Provenance Tracking to realize sound GC. We observe that pointers cannot be created out-of-thin-air, and they must have provenance to at least one valid allocation. Therefore, by tracking pointer provenance from the source (e.g., malloc) through both explicit data-flow and implicit control-flow, our GC has sound and precise information to compute the set of all reachable objects at any program state. We discuss several static analysis optimizations, that can be employed during compilation aided with profiling, to significantly reduce the overhead of dynamic provenance tracking from nearly 8× to 16% for well-behaved programs that adhere to the C standards. Pointer provenance based sound GC invocation is also 13% faster and reclaims 6% more memory on average, compared to an unsound value-based GC.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

This talk presents "Sound Garbage Collection for C Using Pointer Provenance" at OOPSLA 2020. Prior Garbage Collectors for C identify pointers during runtime using their values. This is unsound, and can incorrectly free reachable objects. The paper introduces Dynamic Pointer Provenance Tracking to explicitly track pointer information at runtime, which provides a way to realize a sound Garbage Collector for C, and realizes efficient tracking using several static analysis optimizations.

References

  1. . The Tile38 geolocation information systems. http://tile38.com.Google ScholarGoogle Scholar
  2. 2004. A Memory-Eficient Doubly Linked List. https://www.linuxjournal.com/article/6828.Google ScholarGoogle Scholar
  3. Sarita V. Adve and Mark D. Hill. 1990. Weak Ordering-A New Definition. In Proceedings of the 17th Annual International Symposium on Computer Architecture, Seattle, WA, USA, June 1990, Jean-Loup Baer, Larry Snyder, and James R. Goodman (Eds.). ACM, 2-14. https://doi.org/10.1145/325164.325100 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Alfred V. Aho, Monica S. Lam, Ravi Sethi, and Jefrey D. Ullman. 2006. Compilers: Principles, Techniques, and Tools (2Nd Edition). Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA.Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Periklis Akritidis, Manuel Costa, Miguel Castro, and Steven Hand. 2009. Baggy Bounds Checking: An Eficient and Backwards-Compatible Defense against Out-of-Bounds Errors. In 18th USENIX Security Symposium, Montreal, Canada, August 10-14, 2009, Proceedings, Fabian Monrose (Ed.). USENIX Association, 51-66. http://www.usenix.org/events/sec09/ tech/full_papers/akritidis.pdfGoogle ScholarGoogle Scholar
  6. Bowen Alpern, Mark N. Wegman, and F. Kenneth Zadeck. 1988. Detecting Equality of Variables in Programs. In Conference Record of the Fifteenth Annual ACM Symposium on Principles of Programming Languages, San Diego, California, USA, January 10-13, 1988, Jeanne Ferrante and P. Mager (Eds.). ACM Press, 1-11. https://doi.org/10.1145/73560.73561 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Apple. 2013. Transitioning to ARC release notes. https://developer.apple.com/library/archive/releasenotes/ObjectiveC/RNTransitioningToARC.Google ScholarGoogle Scholar
  8. Thomas H. Austin and Cormac Flanagan. 2009. Eficient purely-dynamic information flow analysis. In Proceedings of the 2009 Workshop on Programming Languages and Analysis for Security, PLAS 2009, Dublin, Ireland, 15-21 June, 2009, Stephen Chong and David A. Naumann (Eds.). ACM, 113-124. https://doi.org/10.1145/1554339.1554353 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Todd M. Austin, Scott E. Breach, and Gurindar S. Sohi. 1994. Eficient Detection of All Pointer and Array Access Errors. In Proceedings of the ACM SIGPLAN'94 Conference on Programming Language Design and Implementation (PLDI), Orlando, Florida, USA, June 20-24, 1994, Vivek Sarkar, Barbara G. Ryder, and Mary Lou Sofa (Eds.). ACM, 290-301. https: //doi.org/10.1145/178243.178446 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. David F. Bacon, C. Richard Attanasio, Han Bok Lee, V. T. Rajan, and Stephen E. Smith. 2001. Java without the Cofee Breaks: A Nonintrusive Multiprocessor Garbage Collector. In Proceedings of the 2001 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Snowbird, Utah, USA, June 20-22, 2001, Michael Burke and Mary Lou Sofa (Eds.). ACM, 92-103. https://doi.org/10.1145/378795.378819 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. David F. Bacon and V. T. Rajan. 2001. Concurrent Cycle Collection in Reference Counted Systems. In ECOOP 2001-ObjectOriented Programming, 15th European Conference, Budapest, Hungary, June 18-22, 2001, Proceedings (Lecture Notes in Computer Science, Vol. 2072 ), Jørgen Lindskov Knudsen (Ed.). Springer, 207-235. https://doi.org/10.1007/3-540-45337-7_12 Google ScholarGoogle ScholarCross RefCross Ref
  12. Henry G. Baker and Carl Hewitt. 1977. The incremental garbage collection of processes. SIGART Newsl. 64 ( 1977 ), 55-59. https://doi.org/10.1145/872736.806932 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Jason Baker, Antonio Cunei, Filip Pizlo, and Jan Vitek. 2007. Accurate Garbage Collection in Uncooperative Environments with Lazy Pointer Stacks. In Compiler Construction, 16th International Conference, CC 2007, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2007, Braga, Portugal, March 26-30, 2007, Proceedings (Lecture Notes in Computer Science, Vol. 4420 ), Shriram Krishnamurthi and Martin Odersky (Eds.). Springer, 64-79. https://doi.org/10.1007/978-3-540-71229-9_5 Google ScholarGoogle ScholarCross RefCross Ref
  14. Subarno Banerjee, David Devecsery, Peter M. Chen, and Satish Narayanasamy. 2019. Iodine: Fast Dynamic Taint Tracking Using Rollback-free Optimistic Hybrid Analysis. In 2019 IEEE Symposium on Security and Privacy, SP 2019, San Francisco, CA, USA, May 19-23, 2019. IEEE, 490-504. https://doi.org/10.1109/SP. 2019.00043 Google ScholarGoogle ScholarCross RefCross Ref
  15. Joel F. Bartlett. 1988. Compacting Garbage Collection with Ambiguous Roots. 1, 6 (April 1988 ), 3-12. https://doi.org/10. 1145/1317224.1317225 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Joel F. Bartlett. 1989. Mostly-copying garbage collection picks up generations and C++. Technical Report TN. 12. Western Research Laboratory, Digital Equipment Corporation, Palo Alto, CA.Google ScholarGoogle Scholar
  17. Emery D. Berger and Benjamin G. Zorn. 2006. DieHard: probabilistic memory safety for unsafe languages. In Proceedings of the ACM SIGPLAN 2006 Conference on Programming Language Design and Implementation, Ottawa, Ontario, Canada, June 11-14, 2006, Michael I. Schwartzbach and Thomas Ball (Eds.). ACM, 158-168. https://doi.org/10.1145/1133981.1134000 Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. Stephen M. Blackburn and Kathryn S. McKinley. 2008. Immix: a mark-region garbage collector with space eficiency, fast collection, and mutator performance. In Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation, Tucson, AZ, USA, June 7-13, 2008, Rajiv Gupta and Saman P. Amarasinghe (Eds.). ACM, 22-32. https://doi.org/10.1145/1375581.1375586 Google ScholarGoogle ScholarDigital LibraryDigital Library
  19. Rastislav Bodík, Rajiv Gupta, and Vivek Sarkar. 2000. ABCD: eliminating array bounds checks on demand. In Proceedings of the 2000 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Vancouver, Britith Columbia, Canada, June 18-21, 2000, Monica S. Lam (Ed.). ACM, 321-333. https://doi.org/10.1145/349299.349342 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Hans-Juergen Boehm. 1993. Space Eficient Conservative Garbage Collection. In Proceedings of the ACM SIGPLAN'93 Conference on Programming Language Design and Implementation (PLDI), Albuquerque, New Mexico, USA, June 23-25, 1993, Robert Cartwright (Ed.). ACM, 197-206. https://doi.org/10.1145/155090.155109 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Hans-Juergen Boehm. 1996. Simple Garbage-Collector-Safety. In Proceedings of the ACM SIGPLAN'96 Conference on Programming Language Design and Implementation (PLDI), Philadephia, Pennsylvania, USA, May 21-24, 1996, Charles N. Fischer (Ed.). ACM, 89-98. https://doi.org/10.1145/231379.231394 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Hans-Juergen Boehm and David Chase. 1992. A Proposal for Garbage-Collector-Safe C Compilation. The Journal of C Language Translation 4, 2 ( December 1992 ), 126-141. https://www.hboehm.info/gc/papers/boecha.ps.gzGoogle ScholarGoogle Scholar
  23. Hans-Juergen Boehm, Alan J. Demers, and Scott Shenker. 1991. Mostly Parallel Garbage Collection. In Proceedings of the ACM SIGPLAN'91 Conference on Programming Language Design and Implementation (PLDI), Toronto, Ontario, Canada, June 26-28, 1991, David S. Wise (Ed.). ACM, 157-164. https://doi.org/10.1145/113445.113459 Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Hans J. Boehm. 2004. Space Eficient Conservative Garbage Collection. SIGPLAN Notices 39, 4 (April 2004 ), 490-501. https://doi.org/10.1145/989393.989442 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. Michael D. Bond and Kathryn S. McKinley. 2006. Bell: bit-encoding online memory leak detection. In Proceedings of the 12th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2006, San Jose, CA, USA, October 21-25, 2006, John Paul Shen and Margaret Martonosi (Eds.). ACM, 61-72. https: //doi.org/10.1145/1168857.1168866 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Michael Burrows, Stephen N. Freund, and Janet L. Wiener. 2003. Run-Time Type Checking for Binary Programs. In Compiler Construction, 12th International Conference, CC 2003, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2003, Warsaw, Poland, April 7-11, 2003, Proceedings (Lecture Notes in Computer Science, Vol. 2622 ), Görel Hedin (Ed.). Springer, 90-105. https://doi.org/10.1007/3-540-36579-6_7 Google ScholarGoogle ScholarCross RefCross Ref
  27. Juan Caballero, Gustavo Grieco, Mark Marron, and Antonio Nappa. 2012. Undangle: early detection of dangling pointers in use-after-free and double-free vulnerabilities. In International Symposium on Software Testing and Analysis, ISSTA 2012, Minneapolis, MN, USA, July 15-20, 2012, Mats Per Erik Heimdahl and Zhendong Su (Eds.). ACM, 133-143. https: //doi.org/10.1145/2338965.2336769 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Juan Caballero and Zhiqiang Lin. 2016. Type Inference on Executables. ACM Comput. Surv. 48, 4 ( 2016 ), 65 : 1-65 : 35. https://doi.org/10.1145/2896499 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. David Chisnall, Colin Rothwell, Robert N. M. Watson, Jonathan Woodruf, Munraj Vadera, Simon W. Moore, Michael Roe, Brooks Davis, and Peter G. Neumann. 2015. Beyond the PDP-11: Architectural Support for a Memory-Safe C Abstract Machine. In Proceedings of the Twentieth International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS ' 15, Istanbul, Turkey, March 14-18, 2015, Özcan Özturk, Kemal Ebcioglu, and Sandhya Dwarkadas (Eds.). ACM, 117-130. https://doi.org/10.1145/2694344.2694367 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Ravi Chugh, Jan Wen Voung, Ranjit Jhala, and Sorin Lerner. 2008. Dataflow analysis for concurrent programs using datarace detection. In Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation, Tucson, AZ, USA, June 7-13, 2008, Rajiv Gupta and Saman P. Amarasinghe (Eds.). ACM, 316-326. https://doi.org/10.1145/ 1375581.1375620 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. James A. Clause, Wanchun Li, and Alessandro Orso. 2007. Dytan: a generic dynamic taint analysis framework. In Proceedings of the ACM/SIGSOFT International Symposium on Software Testing and Analysis, ISSTA 2007, London, UK, July 9-12, 2007, David S. Rosenblum and Sebastian G. Elbaum (Eds.). ACM, 196-206. https://doi.org/10.1145/1273463.1273490 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. James A. Clause and Alessandro Orso. 2010. LEAKPOINT: pinpointing the causes of memory leaks. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 1, ICSE 2010, Cape Town, South Africa, 1-8 May 2010, Jef Kramer, Judith Bishop, Premkumar T. Devanbu, and Sebastián Uchitel (Eds.). ACM, 515-524. https: //doi.org/10.1145/1806799.1806874 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Jacques Cohen. 1981. Garbage Collection of Linked Data Structures. Comput. Surveys 13, 3 ( 1981 ), 341-367. https: //doi.org/10.1145/356850.356854 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. George E. Collins. 1960. A method for overlapping and erasure of lists. Commun. ACM 3, 12 ( 1960 ), 655-657. https: //doi.org/10.1145/367487.367501 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. L. Peter Deutsch and Daniel G. Bobrow. 1976. An Eficient, Incremental, Automatic Garbage Collector. Commun. ACM 19, 9 ( 1976 ), 522-526. https://doi.org/10.1145/360336.360345 Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. David Devecsery, Peter M. Chen, Jason Flinn, and Satish Narayanasamy. 2018. Optimistic Hybrid Analysis: Accelerating Dynamic Analysis through Predicated Static Analysis. In Proceedings of the Twenty-Third International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2018, Williamsburg, VA, USA, March 24-28, 2018, Xipeng Shen, James Tuck, Ricardo Bianchini, and Vivek Sarkar (Eds.). ACM, 348-362. https: //doi.org/10.1145/3173162.3177153 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Dinakar Dhurjati and Vikram S. Adve. 2006. Eficiently Detecting All Dangling Pointer Uses in Production Servers. In 2006 International Conference on Dependable Systems and Networks (DSN 2006 ), 25-28 June 2006, Philadelphia, Pennsylvania, USA, Proceedings. IEEE Computer Society, 269-280. https://doi.org/10.1109/DSN. 2006.31 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Dinakar Dhurjati, Sumant Kowshik, Vikram S. Adve, and Chris Lattner. 2003. Memory safety without runtime checks or garbage collection. In Proceedings of the 2003 Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES'03). San Diego, California, USA, June 11-13, 2003, Frank Mueller and Ulrich Kremer (Eds.). ACM, 69-80. https: //doi.org/10.1145/780732.780743 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Chen Ding and Yutao Zhong. 2002. Compiler-directed run-time monitoring of program data access. In Proceedings of The Workshop on Memory Systems Performance (MSP 2002 ), June 16, 2002 and The International Symposium on Memory Management (ISMM 2002 ), June 20-21, 2002, Berlin, Germany, Hans-Juergen Boehm and David Detlefs (Eds.). ACM, 1-12. https://doi.org/10.1145/773039.773040 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Nurit Dor, Michael Rodeh, and Shmuel Sagiv. 1998. Detecting Memory Errors via Static Pointer Analysis (Preliminary Experience). In Proceedings of the SIGPLAN/SIGSOFT Workshop on Program Analysis For Software Tools and Engineering, PASTE ' 98, Montreal, Canada, June 16, 1998, Thomas Ball, Frank Tip, and A. Michael Berman (Eds.). ACM, 27-34. https://doi.org/10.1145/277631.277637 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Daniel Ross Edelson. 1990. Dynamic storage reclamation in C++. Technical Report UCSC-CRL-90-19. University of California at Santa Cruz.Google ScholarGoogle Scholar
  42. Daniel R. Edelson and Ira Pohl. 1991. A Copying Collector for C++. In Proceedings of the C++ Conference. Washington, D.C., USA, April 1991. USENIX Association, 85-102.Google ScholarGoogle Scholar
  43. Laura Efinger-Dean, Hans-Juergen Boehm, Dhruva R. Chakrabarti, and Pramod G. Joisha. 2011. Extended sequential reasoning for data-race-free programs. In Proceedings of the 2011 ACM SIGPLAN workshop on Memory Systems Performance and Correctness: held in conjunction with PLDI '11, San Jose, CA, USA, June 5, 2011, Jefrey S. Vetter, Madanlal Musuvathi, and Xipeng Shen (Eds.). ACM, 22-29. https://doi.org/10.1145/1988915.1988922 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Archibald Samuel Elliott, Andrew Ruef, Michael Hicks, and David Tarditi. 2018. Checked C: Making C Safe by Extension. In 2018 IEEE Cybersecurity Development, SecDev 2018, Cambridge, MA, USA, September 30-October 2, 2018. IEEE Computer Society, 53-60. https://doi.org/10.1109/SecDev. 2018.00015 Google ScholarGoogle ScholarCross RefCross Ref
  45. Khaled Elwazeer, Kapil Anand, Aparna Kotha, Matthew Smithson, and Rajeev Barua. 2013. Scalable variable and data type detection in a binary rewriter. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '13, Seattle, WA, USA, June 16-19, 2013, Hans-Juergen Boehm and Cormac Flanagan (Eds.). ACM, 51-60. https: //doi.org/10.1145/2491956.2462165 Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Toshio Endo, Kenjiro Taura, and Akinori Yonezawa. 1997. A Scalable Mark-Sweep Garbage Collector on Large-Scale Shared-Memory Machines. In Proceedings of the ACM/IEEE Conference on Supercomputing, SC 1997, November 15-21, 1997, San Jose, CA, USA. ACM, 48. https://doi.org/10.1145/509593.509641 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. David E. Evans. 1996. Static Detection of Dynamic Memory Errors. In Proceedings of the ACM SIGPLAN'96 Conference on Programming Language Design and Implementation (PLDI), Philadephia, Pennsylvania, USA, May 21-24, 1996, Charles N. Fischer (Ed.). ACM, 44-53. https://doi.org/10.1145/231379.231389 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Reed Hastings and Bob Joyce. 1991. Purify: Fast detection of memory leaks and access errors. In In Proc. of the Winter 1992 USENIX Conference. 125-138.Google ScholarGoogle Scholar
  49. Matthias Hauswirth and Trishul M. Chilimbi. 2004. Low-overhead memory leak detection using adaptive statistical profiling. In Proceedings of the 11th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2004, Boston, MA, USA, October 7-13, 2004, Shubu Mukherjee and Kathryn S. McKinley (Eds.). ACM, 156-164. https://doi.org/10.1145/1024393.1024412 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. David L. Heine and Monica S. Lam. 2003. A practical flow-sensitive and context-sensitive C and C++ memory leak detector. In Proceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation 2003, San Diego, California, USA, June 9-11, 2003, Ron Cytron and Rajiv Gupta (Eds.). ACM, 168-181. https://doi.org/10.1145/781131.781150 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Fergus Henderson. 2002. Accurate garbage collection in an uncooperative environment. In Proceedings of The Workshop on Memory Systems Performance (MSP 2002 ), June 16, 2002 and The International Symposium on Memory Management (ISMM 2002 ), June 20-21, 2002, Berlin, Germany, Hans-Juergen Boehm and David Detlefs (Eds.). ACM, 256-263. https: //doi.org/10.1145/773039.512449 Google ScholarGoogle ScholarDigital LibraryDigital Library
  52. Fergus Henderson, Zoltan Somogyi, and Thomas Conway. 1995. Compiling logic programs to C using GNU C as a portable assembler. In Proceedings of The ILPSâĂŹ95 Postconference Workshop on Sequential Implementation Technologies for Logic Programming Languages, Portland, Oregon.Google ScholarGoogle Scholar
  53. John L. Henning. 2006. SPEC CPU2006 benchmark descriptions. SIGARCH Comput. Archit. News 34, 4 ( 2006 ), 1-17. https://doi.org/10.1145/1186736.1186737 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Martin Hirzel, Amer Diwan, and Johannes Henkel. 2002. On the usefulness of type and liveness accuracy for garbage collection and leak detection. ACM Trans. Program. Lang. Syst. 24, 6 ( 2002 ), 593-624. https://doi.org/10.1145/586088.586089 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Antony L. Hosking. 2006. Portable, mostly-concurrent, mostly-copying garbage collection for multi-processors. In Proceedings of the 5th International Symposium on Memory Management, ISMM 2006, Ottawa, Ontario, Canada, June 10-11, 2006, Erez Petrank and J. Eliot B. Moss (Eds.). ACM, 40-51. https://doi.org/10.1145/1133956.1133963 Google ScholarGoogle ScholarDigital LibraryDigital Library
  56. ISO. 2018. Programming languages-C (ISO/IEC 9899:201x). Technical Report N2310. International Organization for Standardization, Geneva, Switzerland. http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2310.pdfGoogle ScholarGoogle Scholar
  57. Trevor Jim, J. Gregory Morrisett, Dan Grossman, Michael W. Hicks, James Cheney, and Yanling Wang. 2002. Cyclone: A Safe Dialect of C. In Proceedings of the General Track: 2002 USENIX Annual Technical Conference, June 10-15, 2002, Monterey, California, USA, Carla Schlatter Ellis (Ed.). USENIX, 275-288. http://www.usenix.org/publications/library/proceedings/ usenix02/jim.htmlGoogle ScholarGoogle ScholarDigital LibraryDigital Library
  58. Richard W. M. Jones and Paul H. J. Kelly. 1997. Backwards-Compatible Bounds Checking for Arrays and Pointers in C Programs. In Proceedings of the Third International Workshop on Automated Debugging, AADEBUG 1997, Linköping, Sweden, May 26-27, 1997 (Linköping Electronic Articles in Computer and Information Science, Vol. 2 ), Mariam Kamkar (Ed.). Linköping University Electronic Press, 13-26. http://www.ep.liu.se/ecp/article.asp?issue=001&article= 002Google ScholarGoogle Scholar
  59. Simon L. Peyton Jones, Norman Ramsey, and Fermin Reig. 1999. C-: A Portable Assembly Language that Supports Garbage Collection. In Principles and Practice of Declarative Programming, International Conference PPDP'99, Paris, France, September 29-October 1, 1999, Proceedings (Lecture Notes in Computer Science, Vol. 1702 ), Gopalan Nadathur (Ed.). Springer, 1-28. https://doi.org/10.1007/10704567_1 Google ScholarGoogle ScholarCross RefCross Ref
  60. Maria Jump and Kathryn S. McKinley. 2007. Cork: dynamic memory leak detection for garbage-collected languages. In Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2007, Nice, France, January 17-19, 2007, Martin Hofmann and Matthias Felleisen (Eds.). ACM, 31-38. https://doi.org/10.1145/1190216.1190224 Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Dong-Heon Jung, Sung-Hwan Bae, Jaemok Lee, Soo-Mook Moon, and Jong Kuk Park. 2006. Supporting precise garbage collection in Java Bytecode-to-C ahead-of-time compiler for embedded systems. In Proceedings of the 2006 International Conference on Compilers, Architecture, and Synthesis for Embedded Systems, CASES 2006, Seoul, Korea, October 22-25, 2006, Seongsoo Hong, Wayne H. Wolf, Krisztián Flautner, and Taewhan Kim (Eds.). ACM, 35-42. https://doi.org/10.1145/ 1176760.1176767 Google ScholarGoogle ScholarDigital LibraryDigital Library
  62. Chris Lattner and Vikram S. Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In 2nd IEEE / ACM International Symposium on Code Generation and Optimization (CGO 2004 ), 20-24 March 2004, San Jose, CA, USA. IEEE Computer Society, 75-88. https://doi.org/10.1109/CGO. 2004.1281665 Google ScholarGoogle ScholarCross RefCross Ref
  63. JongHyup Lee, Thanassis Avgerinos, and David Brumley. 2011. TIE: Principled Reverse Engineering of Types in Binary Programs. In Proceedings of the Network and Distributed System Security Symposium, NDSS 2011, San Diego, California, USA, 6th February-9th February 2011. The Internet Society. https://www.ndss-symposium.org/ndss2011/tie-principledreverse-engineering-of-types-in-binary-programsGoogle ScholarGoogle Scholar
  64. Rafael Dueire Lins. 1992. Cyclic Reference Counting with Lazy Mark-Scan. Inform. Process. Lett. 44, 4 ( 1992 ), 215-220. https://doi.org/10.1016/ 0020-0190 ( 92 ) 90088-D Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Kayvan Memarian, Victor B. F. Gomes, Brooks Davis, Stephen Kell, Alexander Richardson, Robert N. M. Watson, and Peter Sewell. 2019. Exploring C semantics and pointer provenance. Proceedings of the ACM on Programming Languages 3, POPL ( 2019 ), 67 : 1-67 : 32. https://doi.org/10.1145/3290380 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Kayvan Memarian, Justus Matthiesen, James Lingard, Kyndylan Nienhuis, David Chisnall, Robert N. M. Watson, and Peter Sewell. 2016. Into the depths of C: elaborating the de facto standards. In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2016, Santa Barbara, CA, USA, June 13-17, 2016, Chandra Krintz and Emery Berger (Eds.). ACM, 1-15. https://doi.org/10.1145/2908080.2908081 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Microsoft. 2004. Managed Extensions for C++. https://docs.microsoft.com/en-us/cpp/build/reference/microsoft-extensionsto-c-and-cpp.Google ScholarGoogle Scholar
  68. Santosh Nagarakatte, Jianzhou Zhao, Milo M. K. Martin, and Steve Zdancewic. 2009. SoftBound: highly compatible and complete spatial memory safety for c. In Proceedings of the 2009 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2009, Dublin, Ireland, June 15-21, 2009, Michael Hind and Amer Diwan (Eds.). ACM, 245-258. https://doi.org/10.1145/1542476.1542504 Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. Santosh Nagarakatte, Jianzhou Zhao, Milo M. K. Martin, and Steve Zdancewic. 2010. CETS: compiler enforced temporal safety for C. In Proceedings of the 9th International Symposium on Memory Management, ISMM 2010, Toronto, Ontario, Canada, June 5-6, 2010, Jan Vitek and Doug Lea (Eds.). ACM, 31-40. https://doi.org/10.1145/1806651.1806657 Google ScholarGoogle ScholarDigital LibraryDigital Library
  70. George C. Necula, Scott McPeak, and Westley Weimer. 2002. CCured: type-safe retrofitting of legacy code. In Conference Record of POPL 2002 : The 29th SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Portland, OR, USA, January 16-18, 2002, John Launchbury and John C. Mitchell (Eds.). ACM, 128-139. https://doi.org/10.1145/503272.503286 Google ScholarGoogle ScholarDigital LibraryDigital Library
  71. James Newsome and Dawn Xiaodong Song. 2005. Dynamic Taint Analysis for Automatic Detection, Analysis, and SignatureGeneration of Exploits on Commodity Software. In Proceedings of the Network and Distributed System Security Symposium, NDSS 2005, San Diego, California, USA. The Internet Society. https://www.ndss-symposium.org/ndss2005/ dynamic-taint-analysis-automatic-detection-analysis-and-signaturegeneration-exploits-commodity/Google ScholarGoogle Scholar
  72. Gene Novark, Emery D. Berger, and Benjamin G. Zorn. 2009. Eficiently and precisely locating memory leaks and bloat. In Proceedings of the 2009 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2009, Dublin, Ireland, June 15-21, 2009, Michael Hind and Amer Diwan (Eds.). ACM, 397-407. https://doi.org/10.1145/1542476.1542521 Google ScholarGoogle ScholarDigital LibraryDigital Library
  73. Oleksii Oleksenko, Dmitrii Kuvaiskii, Pramod Bhatotia, Pascal Felber, and Christof Fetzer. 2018. Intel MPX Explained: A Cross-layer Analysis of the Intel MPX System Stack. Proceedings of the ACM on Measurement and Analysis of Computing Systems 2, 2 ( 2018 ), 28 : 1-28 : 30. https://doi.org/10.1145/3224423 Google ScholarGoogle ScholarDigital LibraryDigital Library
  74. Simon L. Peyton Jones, Cordy Hall, Kevin Hammond, Will Partain, and Phil Wadler. 1993. The Glasgow Haskell Compiler: a technical overview. In Proceedings of UK Joint Framework for Information Technology (JFIT) Technical Conference, Keele. 249-257.Google ScholarGoogle Scholar
  75. Jon Rafkind, Adam Wick, John Regehr, and Matthew Flatt. 2009. Precise garbage collection for C. In Proceedings of the 8th International Symposium on Memory Management, ISMM 2009, Dublin, Ireland, June 19-20, 2009, Hillel Kolodner and Guy L. Steele Jr. (Eds.). ACM, 39-48. https://doi.org/10.1145/1542431.1542438 Google ScholarGoogle ScholarDigital LibraryDigital Library
  76. Masoomeh Rudafshani and Paul A. S. Ward. 2017. LeakSpot: detection and diagnosis of memory leaks in JavaScript applications. Software: Practice and Experience 47, 1 ( 2017 ), 97-123. https://doi.org/10.1002/spe.2406 Google ScholarGoogle ScholarDigital LibraryDigital Library
  77. Olatunji Ruwase and Monica S. Lam. 2004. A Practical Dynamic Bufer Overflow Detector. In Proceedings of the Network and Distributed System Security Symposium, NDSS 2004, San Diego, California, USA. The Internet Society. https://www.ndsssymposium.org/ndss2004/practical-dynamic-bufer-overflow-detector/Google ScholarGoogle Scholar
  78. Andrei Sabelfeld and Andrew C. Myers. 2003. Language-based information-flow security. IEEE Journal on Selected Areas in Communications 21, 1 ( 2003 ), 5-19. https://doi.org/10.1109/JSAC. 2002.806121 Google ScholarGoogle ScholarDigital LibraryDigital Library
  79. Wolfgang Schreiner. 1996. RT++-higher order threads for C++, tutorial and reference manual. Technical Report 96-9. RISC-Linz. https://www3.risc.jku.at/software/rt++/Google ScholarGoogle Scholar
  80. Edward J. Schwartz, Thanassis Avgerinos, and David Brumley. 2010. All You Ever Wanted to Know about Dynamic Taint Analysis and Forward Symbolic Execution (but Might Have Been Afraid to Ask). In 31st IEEE Symposium on Security and Privacy, S&P 2010, 16-19 May 2010, Berleley/Oakland, California, USA. IEEE Computer Society, 317-331. https://doi.org/10.1109/SP. 2010.26 Google ScholarGoogle ScholarCross RefCross Ref
  81. Rifat Shahriyar, Stephen M. Blackburn, and Daniel Frampton. 2012. Down for the count? Getting reference counting back in the ring. In International Symposium on Memory Management, ISMM '12, Beijing, China, June 15-16, 2012, Martin T. Vechev and Kathryn S. McKinley (Eds.). ACM, 73-84. https://doi.org/10.1145/2258996.2259008 Google ScholarGoogle ScholarDigital LibraryDigital Library
  82. Rifat Shahriyar, Stephen M. Blackburn, and Kathryn S. McKinley. 2014. Fast conservative garbage collection. In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications, OOPSLA 2014, part of SPLASH 2014, Portland, OR, USA, October 20-24, 2014, Andrew P. Black and Todd D. Millstein (Eds.). ACM, 121-139. https://doi.org/10.1145/2660193.2660198 Google ScholarGoogle ScholarDigital LibraryDigital Library
  83. Rifat Shahriyar, Stephen M. Blackburn, Xi Yang, and Kathryn S. McKinley. 2013. Taking of the gloves with reference counting Immix. In Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages & Applications, OOPSLA 2013, part of SPLASH 2013, Indianapolis, IN, USA, October 26-31, 2013, Antony L. Hosking, Patrick Th. Eugster, and Cristina V. Lopes (Eds.). ACM, 93-110. https://doi.org/10.1145/2509136.2509527 Google ScholarGoogle ScholarDigital LibraryDigital Library
  84. Matthew S. Simpson and Rajeev Barua. 2013. MemSafe: ensuring the spatial and temporal memory safety of C at runtime. Software: Practice and Experience 43, 1 ( 2013 ), 93-128. https://doi.org/10.1002/spe.2105 Google ScholarGoogle ScholarDigital LibraryDigital Library
  85. Daniel Dominic Sleator and Robert Endre Tarjan. 1985. Self-Adjusting Binary Search Trees. J. ACM 32, 3 ( 1985 ), 652-686. https://doi.org/10.1145/3828.3835 Google ScholarGoogle ScholarDigital LibraryDigital Library
  86. Frederick Smith and J. Gregory Morrisett. 1998. Comparing Mostly-Copying and Mark-Sweep Conservative Collection. In International Symposium on Memory Management, ISMM '98, Vancouver, British Columbia, Canada, 17-19 October, 1998, Conference Proceedings, Simon L. Peyton Jones and Richard E. Jones (Eds.). ACM, 68-78. https://doi.org/10.1145/286860. 286868 Google ScholarGoogle ScholarDigital LibraryDigital Library
  87. Jan Sparud. 1993. Fixing Some Space Leaks without a Garbage Collector. In Proceedings of the conference on Functional programming languages and computer architecture, FPCA 1993, Copenhagen, Denmark, June 9-11, 1993, John Williams (Ed.). ACM, 117-124. https://doi.org/10.1145/165180.165196 Google ScholarGoogle ScholarDigital LibraryDigital Library
  88. David Tarditi, Peter Lee, and Anurag Acharya. 1992. No Assembly Required: Compiling Standard ML to C. LOPLAS 1, 2 ( 1992 ), 161-177. https://doi.org/10.1145/151333.151343 Google ScholarGoogle ScholarDigital LibraryDigital Library
  89. David M. Ungar. 1984. Generation Scavenging: A Non-Disruptive High Performance Storage Reclamation Algorithm. In Proceedings of the ACM SIGSOFT/SIGPLAN Software Engineering Symposium on Practical Software Development Environments, Pittsburgh, Pennsylvania, USA, April 23-25, 1984, William E. Riddle and Peter B. Henderson (Eds.). ACM, 157-167. https://doi.org/10.1145/800020.808261 Google ScholarGoogle ScholarDigital LibraryDigital Library
  90. John Vilk and Emery D. Berger. 2018. BLeak: automatically debugging memory leaks in web applications. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2018, Philadelphia, PA, USA, June 18-22, 2018, Jefrey S. Foster and Dan Grossman (Eds.). ACM, 15-29. https://doi.org/10.1145/3192366.3192376 Google ScholarGoogle ScholarDigital LibraryDigital Library
  91. Guoqing (Harry) Xu, Michael D. Bond, Feng Qin, and Atanas Rountev. 2011. LeakChaser: helping programmers narrow down causes of memory leaks. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2011, San Jose, CA, USA, June 4-8, 2011, Mary W. Hall and David A. Padua (Eds.). ACM, 270-282. https://doi.org/10.1145/1993498.1993530 Google ScholarGoogle ScholarDigital LibraryDigital Library
  92. G. May Yip. 1991. Incremental, generational mostly-copying garbage collection in uncooperative environment. Technical Report 91/8. Western Research Laboratory, Digital Equipment Corporation, Palo Alto, CA. https://www.hpl.hp.com/ techreports/Compaq-DEC/WRL-91-8.pdfGoogle ScholarGoogle Scholar
  93. Tong Zhang, Dongyoon Lee, and Changhee Jung. 2019. BOGO: Buy Spatial Memory Safety, Get Temporal Memory Safety (Almost) Free. In Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2019, Providence, RI, USA, April 13-17, 2019, Iris Bahar, Maurice Herlihy, Emmett Witchel, and Alvin R. Lebeck (Eds.). ACM, 631-644. https://doi.org/10.1145/3297858.3304017 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Sound garbage collection for C using pointer provenance

    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!