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.
Supplemental Material
- . The Tile38 geolocation information systems. http://tile38.com.Google Scholar
- 2004. A Memory-Eficient Doubly Linked List. https://www.linuxjournal.com/article/6828.Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- Apple. 2013. Transitioning to ARC release notes. https://developer.apple.com/library/archive/releasenotes/ObjectiveC/RNTransitioningToARC.Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- Joel F. Bartlett. 1988. Compacting Garbage Collection with Ambiguous Roots. 1, 6 (April 1988 ), 3-12. https://doi.org/10. 1145/1317224.1317225 Google Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Jacques Cohen. 1981. Garbage Collection of Linked Data Structures. Comput. Surveys 13, 3 ( 1981 ), 341-367. https: //doi.org/10.1145/356850.356854 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Daniel Ross Edelson. 1990. Dynamic storage reclamation in C++. Technical Report UCSC-CRL-90-19. University of California at Santa Cruz.Google Scholar
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Microsoft. 2004. Managed Extensions for C++. https://docs.microsoft.com/en-us/cpp/build/reference/microsoft-extensionsto-c-and-cpp.Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
Index Terms
Sound garbage collection for C using pointer provenance
Recommendations
Age-based garbage collection
Modern generational garbage collectors look for garbage among the young objects, because they have high mortality; however, these objects include the very youngest objects, which clearly are still live. We introduce new garbage collection algorithms, ...
Garbage collection hints
HiPEAC'05: Proceedings of the First international conference on High Performance Embedded Architectures and CompilersThis paper shows that Appel-style garbage collectors often make suboptimal decisions both in terms of when and how to collect. We argue that garbage collection should be done when the amount of live bytes is low (in order to minimize the collection cost)...
Age-based garbage collection
OOPSLA '99: Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applicationsModern generational garbage collectors look for garbage among the young objects, because they have high mortality; however, these objects include the very youngest objects, which clearly are still live. We introduce new garbage collection algorithms, ...






Comments