1485

Committed 17 Apr 2023 05:30PM UTC coverage: 76.519% (+0.02%) from 76.502%

Build # 1485

Build Type

push

travis-ci-com

Committed by

ivmai

Commit Message

Prevent 'function should return a value' BCC error in CMake script

* CMakeLists.txt [enable_werror && BORLAND && enable_threads]: Pass
"/w-rvl" to add_compile_options; add comment.

Run Details

7772 of 10157 relevant lines covered (76.52%)

8798128.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.62

/include/gc/gc_cpp.h

/*
 * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
 *
 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
 *
 * Permission is hereby granted to use or copy this program for any
 * purpose, provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is
 * granted, provided the above notices are retained, and a notice that
 * the code was modified is included with the above copyright notice.
 */

#ifndef GC_CPP_H
#define GC_CPP_H

/****************************************************************************
C++ Interface to the Boehm Collector

    John R. Ellis and Jesse Hull

This interface provides access to the Boehm collector.  It provides
basic facilities similar to those described in "Safe, Efficient
Garbage Collection for C++", by John R. Ellis and David L. Detlefs
(ftp://ftp.parc.xerox.com/pub/ellis/gc).

All heap-allocated objects are either "collectible" or
"uncollectible".  Programs must explicitly delete uncollectible
objects, whereas the garbage collector will automatically delete
collectible objects when it discovers them to be inaccessible.
Collectible objects may freely point at uncollectible objects and vice
versa.

Objects allocated with the built-in "::operator new" are uncollectible.

Objects derived from class "gc" are collectible.  For example:

    class A: public gc {...};
    A* a = new A;       // a is collectible.

Collectible instances of non-class types can be allocated using the GC
(or UseGC) placement:

    typedef int A[ 10 ];
    A* a = new (GC) A;

Uncollectible instances of classes derived from "gc" can be allocated
using the NoGC placement:

    class A: public gc {...};
    A* a = new (NoGC) A;   // a is uncollectible.

The new(PointerFreeGC) syntax allows the allocation of collectible
objects that are not scanned by the collector.  This useful if you
are allocating compressed data, bitmaps, or network packets.  (In
the latter case, it may remove danger of unfriendly network packets
intentionally containing values that cause spurious memory retention.)

Both uncollectible and collectible objects can be explicitly deleted
with "delete", which invokes an object's destructors and frees its
storage immediately.

A collectible object may have a clean-up function, which will be
invoked when the collector discovers the object to be inaccessible.
An object derived from "gc_cleanup" or containing a member derived
from "gc_cleanup" has a default clean-up function that invokes the
object's destructors.  Explicit clean-up functions may be specified as
an additional placement argument:

    A* a = ::new (GC, MyCleanup) A;

An object is considered "accessible" by the collector if it can be
reached by a path of pointers from static variables, automatic
variables of active functions, or from some object with clean-up
enabled; pointers from an object to itself are ignored.

Thus, if objects A and B both have clean-up functions, and A points at
B, B is considered accessible.  After A's clean-up is invoked and its
storage released, B will then become inaccessible and will have its
clean-up invoked.  If A points at B and B points to A, forming a
cycle, then that's considered a storage leak, and neither will be
collectible.  See the interface gc.h for low-level facilities for
handling such cycles of objects with clean-up.

The collector cannot guarantee that it will find all inaccessible
objects.  In practice, it finds almost all of them.

Cautions:

1. Be sure the collector is compiled with the C++ support
(e.g. --enable-cplusplus option is passed to make).

2. If the compiler does not support "operator new[]", beware that an
array of type T, where T is derived from "gc", may or may not be
allocated as a collectible object (it depends on the compiler).  Use
the explicit GC placement to make the array collectible.  For example:

    class A: public gc {...};
    A* a1 = new A[ 10 ];        // collectible or uncollectible?
    A* a2 = new (GC) A[ 10 ];   // collectible.

3. The destructors of collectible arrays of objects derived from
"gc_cleanup" will not be invoked properly.  For example:

    class A: public gc_cleanup {...};
    A* a = new (GC) A[ 10 ];    // destructors not invoked correctly

Typically, only the destructor for the first element of the array will
be invoked when the array is garbage-collected.  To get all the
destructors of any array executed, you must supply an explicit
clean-up function:

    A* a = new (GC, MyCleanUp) A[ 10 ];

(Implementing clean-up of arrays correctly, portably, and in a way
that preserves the correct exception semantics requires a language
extension, e.g. the "gc" keyword.)

4. GC name conflicts:

Many other systems seem to use the identifier "GC" as an abbreviation
for "Graphics Context".  Thus, GC placement has been replaced
by UseGC.  GC is an alias for UseGC, unless GC_NAME_CONFLICT is defined.

****************************************************************************/

#include "gc.h"

#ifdef GC_INCLUDE_NEW
# include <new> // for std, bad_alloc
# define GC_PTRDIFF_T std::ptrdiff_t
# define GC_SIZE_T std::size_t
#else
# define GC_PTRDIFF_T ptrdiff_t
# define GC_SIZE_T size_t
#endif

#ifdef GC_NAMESPACE
# define GC_NS_QUALIFY(T) boehmgc::T
#else
# define GC_NS_QUALIFY(T) T
#endif

#ifndef THINK_CPLUS
# define GC_cdecl GC_CALLBACK
#else
# define GC_cdecl _cdecl
#endif

#if !defined(GC_NO_OPERATOR_NEW_ARRAY) \
    && !defined(_ENABLE_ARRAYNEW) /* Digimars */ \
    && (defined(__BORLANDC__) && (__BORLANDC__ < 0x450) \
        || (defined(__GNUC__) && !GC_GNUC_PREREQ(2, 6)) \
        || (defined(_MSC_VER) && _MSC_VER <= 1020) \
        || (defined(__WATCOMC__) && __WATCOMC__ < 1050))
# define GC_NO_OPERATOR_NEW_ARRAY
#endif

#if !defined(GC_NO_OPERATOR_NEW_ARRAY) && !defined(GC_OPERATOR_NEW_ARRAY)
# define GC_OPERATOR_NEW_ARRAY
#endif

#if (!defined(__BORLANDC__) || __BORLANDC__ > 0x0620) \
    && !defined(__sgi) && !defined(__WATCOMC__) \
    && (!defined(_MSC_VER) || _MSC_VER > 1020)
# define GC_PLACEMENT_DELETE
#endif

#if !defined(GC_NEW_DELETE_THROW_NOT_NEEDED) \
    && !defined(GC_NEW_DELETE_NEED_THROW) && GC_GNUC_PREREQ(4, 2) \
    && (__cplusplus < 201103L || defined(__clang__))
# define GC_NEW_DELETE_NEED_THROW
#endif

#if defined(GC_NEW_ABORTS_ON_OOM) || defined(_LIBCPP_NO_EXCEPTIONS)
# define GC_OP_NEW_OOM_CHECK(obj) \
                do { if (!(obj)) GC_abort_on_oom(); } while (0)
#elif defined(GC_INCLUDE_NEW)
# define GC_OP_NEW_OOM_CHECK(obj) if (obj) {} else throw std::bad_alloc()
#else
  // "new" header is not included, so bad_alloc cannot be thrown directly.
  GC_API void GC_CALL GC_throw_bad_alloc();
# define GC_OP_NEW_OOM_CHECK(obj) if (obj) {} else GC_throw_bad_alloc()
#endif // !GC_NEW_ABORTS_ON_OOM && !GC_INCLUDE_NEW

#ifdef GC_NAMESPACE
namespace boehmgc
{
#endif

enum GCPlacement
{
  UseGC,
# ifndef GC_NAME_CONFLICT
    GC = UseGC,
# endif
  NoGC,
  PointerFreeGC
# ifdef GC_ATOMIC_UNCOLLECTABLE
    , PointerFreeNoGC
# endif
};

/**
 * Instances of classes derived from gc will be allocated in the collected
 * heap by default, unless an explicit NoGC placement is specified.
 */
class gc
{
public:
  inline void* operator new(GC_SIZE_T);
  inline void* operator new(GC_SIZE_T, GCPlacement);
  inline void* operator new(GC_SIZE_T, void*) GC_NOEXCEPT;
    // Must be redefined here, since the other overloadings hide
    // the global definition.
  inline void operator delete(void*) GC_NOEXCEPT;

# ifdef GC_PLACEMENT_DELETE
    inline void operator delete(void*, GCPlacement) GC_NOEXCEPT;
      // Called if construction fails.
    inline void operator delete(void*, void*) GC_NOEXCEPT;
# endif // GC_PLACEMENT_DELETE

# ifdef GC_OPERATOR_NEW_ARRAY
    inline void* operator new[](GC_SIZE_T);
    inline void* operator new[](GC_SIZE_T, GCPlacement);
    inline void* operator new[](GC_SIZE_T, void*) GC_NOEXCEPT;
    inline void operator delete[](void*) GC_NOEXCEPT;
#   ifdef GC_PLACEMENT_DELETE
      inline void operator delete[](void*, GCPlacement) GC_NOEXCEPT;
      inline void operator delete[](void*, void*) GC_NOEXCEPT;
#   endif
# endif // GC_OPERATOR_NEW_ARRAY
};

/**
 * Instances of classes derived from gc_cleanup will be allocated
 * in the collected heap by default.  When the collector discovers
 * an inaccessible object derived from gc_cleanup or containing
 * a member derived from gc_cleanup, its destructors will be invoked.
 */
class gc_cleanup: virtual public gc
{
public:
  inline gc_cleanup();
  inline virtual ~gc_cleanup();

private:
  inline static void GC_cdecl cleanup(void* obj, void* clientData);
};

extern "C" {
  typedef void (GC_CALLBACK * GCCleanUpFunc)(void* obj, void* clientData);
}

#ifdef GC_NAMESPACE
}
#endif

#ifdef _MSC_VER
  // Disable warning that "no matching operator delete found; memory will
  // not be freed if initialization throws an exception"
# pragma warning(disable:4291)
  // TODO: "non-member operator new or delete may not be declared inline"
  // warning is disabled for now.
# pragma warning(disable:4595)
#endif

inline void* operator new(GC_SIZE_T, GC_NS_QUALIFY(GCPlacement),
                          GC_NS_QUALIFY(GCCleanUpFunc) = 0,
                          void* /* clientData */ = 0);
    // Allocates a collectible or uncollectible object, according to the
    // value of gcp.
    //
    // For collectible objects, if cleanup is non-null, then when the
    // allocated object obj becomes inaccessible, the collector will
    // invoke cleanup(obj,clientData) but will not invoke the object's
    // destructors.  It is an error to explicitly delete an object
    // allocated with a non-null cleanup.
    //
    // It is an error to specify a non-null cleanup with NoGC or for
    // classes derived from gc_cleanup or containing members derived
    // from gc_cleanup.

#ifdef GC_PLACEMENT_DELETE
  inline void operator delete(void*, GC_NS_QUALIFY(GCPlacement),
                              GC_NS_QUALIFY(GCCleanUpFunc),
                              void*) GC_NOEXCEPT;
#endif

#ifndef GC_NO_INLINE_STD_NEW

# if defined(_MSC_VER) || defined(__DMC__) \
     || ((defined(__BORLANDC__) || defined(__CYGWIN__) \
          || defined(__CYGWIN32__) || defined(__MINGW32__) \
          || defined(__WATCOMC__)) \
         && !defined(GC_BUILD) && !defined(GC_NOT_DLL))
    // Inlining done to avoid mix up of new and delete operators by VC++ 9
    // (due to arbitrary ordering during linking).

#   if defined(GC_NEW_DELETE_NEED_THROW) && defined(GC_INCLUDE_NEW)
#     define GC_DECL_INLINE_NEW_THROW throw(std::bad_alloc)
#   else
#     define GC_DECL_INLINE_NEW_THROW /* empty */
#   endif

#   ifdef GC_OPERATOR_NEW_ARRAY
      inline void* operator new[](GC_SIZE_T size) GC_DECL_INLINE_NEW_THROW
      {
        void* obj = GC_MALLOC_UNCOLLECTABLE(size);
        GC_OP_NEW_OOM_CHECK(obj);
        return obj;
      }

      inline void operator delete[](void* obj) GC_NOEXCEPT
      {
        GC_FREE(obj);
      }
#   endif // GC_OPERATOR_NEW_ARRAY

    inline void* operator new(GC_SIZE_T size) GC_DECL_INLINE_NEW_THROW
    {
      void* obj = GC_MALLOC_UNCOLLECTABLE(size);
      GC_OP_NEW_OOM_CHECK(obj);
      return obj;
    }

    inline void operator delete(void* obj) GC_NOEXCEPT
    {
      GC_FREE(obj);
    }

#   if __cplusplus >= 201402L || _MSVC_LANG >= 201402L // C++14
      inline void operator delete(void* obj, GC_SIZE_T) GC_NOEXCEPT {
        GC_FREE(obj);
      }

#     if defined(GC_OPERATOR_NEW_ARRAY)
        inline void operator delete[](void* obj, GC_SIZE_T) GC_NOEXCEPT {
          GC_FREE(obj);
        }
#     endif
#   endif // C++14
# endif // _MSC_VER || __CYGWIN__ && !GC_BUILD && !GC_NOT_DLL

# ifdef _MSC_VER
    // This new operator is used by VC++ in case of Debug builds.
    inline void* operator new(GC_SIZE_T size, int /* nBlockUse */,
                              const char* szFileName, int nLine)
    {
#     ifdef GC_DEBUG
        void* obj = GC_debug_malloc_uncollectable(size, szFileName, nLine);
#     else
        void* obj = GC_MALLOC_UNCOLLECTABLE(size);
        (void)szFileName; (void)nLine;
#     endif
      GC_OP_NEW_OOM_CHECK(obj);
      return obj;
    }

#   ifdef GC_OPERATOR_NEW_ARRAY
      // This new operator is used by VC++ 7+ in Debug builds.
      inline void* operator new[](GC_SIZE_T size, int nBlockUse,
                                  const char* szFileName, int nLine)
      {
        return operator new(size, nBlockUse, szFileName, nLine);
      }
#   endif
# endif // _MSC_VER

#elif defined(_MSC_VER) /* && GC_NO_INLINE_STD_NEW */
  // The following ensures that the system default operator new[] does not
  // get undefined, which is what seems to happen on VC++ 6 for some reason
  // if we define a multi-argument operator new[].
  // There seems to be no way to redirect new in this environment without
  // including this everywhere.
# ifdef GC_OPERATOR_NEW_ARRAY
    void* operator new[](GC_SIZE_T);
    void operator delete[](void*);
# endif

  void* operator new(GC_SIZE_T);
  void operator delete(void*);

  void* operator new(GC_SIZE_T, int /* nBlockUse */,
                     const char* /* szFileName */, int /* nLine */);
#endif // GC_NO_INLINE_STD_NEW && _MSC_VER

#ifdef GC_OPERATOR_NEW_ARRAY
  // The operator new for arrays, identical to the above.
  inline void* operator new[](GC_SIZE_T, GC_NS_QUALIFY(GCPlacement),
                              GC_NS_QUALIFY(GCCleanUpFunc) = 0,
                              void* /* clientData */ = 0);
#endif // GC_OPERATOR_NEW_ARRAY

// Inline implementation.

#ifdef GC_NAMESPACE
namespace boehmgc
{
#endif

inline void* gc::operator new(GC_SIZE_T size)
{
  void* obj = GC_MALLOC(size);
  GC_OP_NEW_OOM_CHECK(obj);
  return obj;
}

inline void* gc::operator new(GC_SIZE_T size, GCPlacement gcp)
{
  void* obj;
  switch (gcp) {
  case UseGC:
    obj = GC_MALLOC(size);
    break;
  case PointerFreeGC:
    obj = GC_MALLOC_ATOMIC(size);
    break;
# ifdef GC_ATOMIC_UNCOLLECTABLE
    case PointerFreeNoGC:
      obj = GC_MALLOC_ATOMIC_UNCOLLECTABLE(size);
      break;
# endif
  case NoGC:
  default:
    obj = GC_MALLOC_UNCOLLECTABLE(size);
  }
  GC_OP_NEW_OOM_CHECK(obj);
  return obj;
}

inline void* gc::operator new(GC_SIZE_T, void* p) GC_NOEXCEPT
{
  return p;
}

inline void gc::operator delete(void* obj) GC_NOEXCEPT
{
  GC_FREE(obj);
}

#ifdef GC_PLACEMENT_DELETE
  inline void gc::operator delete(void*, void*) GC_NOEXCEPT {}

  inline void gc::operator delete(void* obj, GCPlacement) GC_NOEXCEPT
  {
    GC_FREE(obj);
  }
#endif // GC_PLACEMENT_DELETE

#ifdef GC_OPERATOR_NEW_ARRAY
  inline void* gc::operator new[](GC_SIZE_T size)
  {
    return gc::operator new(size);
  }

  inline void* gc::operator new[](GC_SIZE_T size, GCPlacement gcp)
  {
    return gc::operator new(size, gcp);
  }

  inline void* gc::operator new[](GC_SIZE_T, void* p) GC_NOEXCEPT
  {
    return p;
  }

  inline void gc::operator delete[](void* obj) GC_NOEXCEPT
  {
    gc::operator delete(obj);
  }

# ifdef GC_PLACEMENT_DELETE
    inline void gc::operator delete[](void*, void*) GC_NOEXCEPT {}

    inline void gc::operator delete[](void* p, GCPlacement) GC_NOEXCEPT
    {
      gc::operator delete(p);
    }
# endif
#endif // GC_OPERATOR_NEW_ARRAY

inline gc_cleanup::~gc_cleanup()
{
# ifndef GC_NO_FINALIZATION
    void* base = GC_base(this);
    if (0 == base) return; // Non-heap object.
    GC_register_finalizer_ignore_self(base, 0, 0, 0, 0);
# endif
}

inline void GC_CALLBACK gc_cleanup::cleanup(void* obj, void* displ)
{
  reinterpret_cast<gc_cleanup*>(reinterpret_cast<char*>(obj)
                + reinterpret_cast<GC_PTRDIFF_T>(displ))->~gc_cleanup();
}

inline gc_cleanup::gc_cleanup()
{
# ifndef GC_NO_FINALIZATION
    GC_finalization_proc oldProc = 0;
    void* oldData = 0; // to avoid "might be uninitialized" compiler warning
    void* this_ptr = reinterpret_cast<void*>(this);
    void* base = GC_base(this_ptr);
    if (base != 0) {
      // Don't call the debug version, since this is a real base address.
      GC_register_finalizer_ignore_self(base,
                reinterpret_cast<GC_finalization_proc>(cleanup),
                reinterpret_cast<void*>(reinterpret_cast<char*>(this_ptr) -
                                        reinterpret_cast<char*>(base)),
                &oldProc, &oldData);
      if (oldProc != 0) {
        GC_register_finalizer_ignore_self(base, oldProc, oldData, 0, 0);
      }
    }
# elif defined(CPPCHECK)
    (void)cleanup;
# endif
}

#ifdef GC_NAMESPACE
}
#endif

inline void* operator new(GC_SIZE_T size, GC_NS_QUALIFY(GCPlacement) gcp,
                          GC_NS_QUALIFY(GCCleanUpFunc) cleanup,
                          void* clientData)
{
  void* obj;
  switch (gcp) {
  case GC_NS_QUALIFY(UseGC):
    obj = GC_MALLOC(size);
#   ifndef GC_NO_FINALIZATION
      if (cleanup != 0 && obj != 0) {
        GC_REGISTER_FINALIZER_IGNORE_SELF(obj, cleanup, clientData, 0, 0);
      }
#   else
      (void)cleanup;
      (void)clientData;
#   endif
    break;
  case GC_NS_QUALIFY(PointerFreeGC):
    obj = GC_MALLOC_ATOMIC(size);
    break;
# ifdef GC_ATOMIC_UNCOLLECTABLE
    case GC_NS_QUALIFY(PointerFreeNoGC):
      obj = GC_MALLOC_ATOMIC_UNCOLLECTABLE(size);
      break;
# endif
  case GC_NS_QUALIFY(NoGC):
  default:
    obj = GC_MALLOC_UNCOLLECTABLE(size);
  }
  GC_OP_NEW_OOM_CHECK(obj);
  return obj;
}

#ifdef GC_PLACEMENT_DELETE
  inline void operator delete(void* obj, GC_NS_QUALIFY(GCPlacement),
                              GC_NS_QUALIFY(GCCleanUpFunc),
                              void* /* clientData */) GC_NOEXCEPT
  {
    GC_FREE(obj);
  }
#endif // GC_PLACEMENT_DELETE

#ifdef GC_OPERATOR_NEW_ARRAY
  inline void* operator new[](GC_SIZE_T size,
                              GC_NS_QUALIFY(GCPlacement) gcp,
                              GC_NS_QUALIFY(GCCleanUpFunc) cleanup,
                              void* clientData)
  {
    return ::operator new(size, gcp, cleanup, clientData);
  }
#endif // GC_OPERATOR_NEW_ARRAY

#endif /* GC_CPP_H */

1	/*
2	* Copyright (c) 1994 by Xerox Corporation. All rights reserved.
3	*
4	* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
5	* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
6	*
7	* Permission is hereby granted to use or copy this program for any
8	* purpose, provided the above notices are retained on all copies.
9	* Permission to modify the code and to distribute modified code is
10	* granted, provided the above notices are retained, and a notice that
11	* the code was modified is included with the above copyright notice.
12	*/
13
14	#ifndef GC_CPP_H
15	#define GC_CPP_H
16
17	/****************************************************************************
18	C++ Interface to the Boehm Collector
19
20	John R. Ellis and Jesse Hull
21
22	This interface provides access to the Boehm collector. It provides
23	basic facilities similar to those described in "Safe, Efficient
24	Garbage Collection for C++", by John R. Ellis and David L. Detlefs
25	(ftp://ftp.parc.xerox.com/pub/ellis/gc).
26
27	All heap-allocated objects are either "collectible" or
28	"uncollectible". Programs must explicitly delete uncollectible
29	objects, whereas the garbage collector will automatically delete
30	collectible objects when it discovers them to be inaccessible.
31	Collectible objects may freely point at uncollectible objects and vice
32	versa.
33
34	Objects allocated with the built-in "::operator new" are uncollectible.
35
36	Objects derived from class "gc" are collectible. For example:
37
38	class A: public gc {...};
39	A* a = new A; // a is collectible.
40
41	Collectible instances of non-class types can be allocated using the GC
42	(or UseGC) placement:
43
44	typedef int A[ 10 ];
45	A* a = new (GC) A;
46
47	Uncollectible instances of classes derived from "gc" can be allocated
48	using the NoGC placement:
49
50	class A: public gc {...};
51	A* a = new (NoGC) A; // a is uncollectible.
52
53	The new(PointerFreeGC) syntax allows the allocation of collectible
54	objects that are not scanned by the collector. This useful if you
55	are allocating compressed data, bitmaps, or network packets. (In
56	the latter case, it may remove danger of unfriendly network packets
57	intentionally containing values that cause spurious memory retention.)
58
59	Both uncollectible and collectible objects can be explicitly deleted
60	with "delete", which invokes an object's destructors and frees its
61	storage immediately.
62
63	A collectible object may have a clean-up function, which will be
64	invoked when the collector discovers the object to be inaccessible.
65	An object derived from "gc_cleanup" or containing a member derived
66	from "gc_cleanup" has a default clean-up function that invokes the
67	object's destructors. Explicit clean-up functions may be specified as
68	an additional placement argument:
69
70	A* a = ::new (GC, MyCleanup) A;
71
72	An object is considered "accessible" by the collector if it can be
73	reached by a path of pointers from static variables, automatic
74	variables of active functions, or from some object with clean-up
75	enabled; pointers from an object to itself are ignored.
76
77	Thus, if objects A and B both have clean-up functions, and A points at
78	B, B is considered accessible. After A's clean-up is invoked and its
79	storage released, B will then become inaccessible and will have its
80	clean-up invoked. If A points at B and B points to A, forming a
81	cycle, then that's considered a storage leak, and neither will be
82	collectible. See the interface gc.h for low-level facilities for
83	handling such cycles of objects with clean-up.
84
85	The collector cannot guarantee that it will find all inaccessible
86	objects. In practice, it finds almost all of them.
87
88	Cautions:
89
90	1. Be sure the collector is compiled with the C++ support
91	(e.g. --enable-cplusplus option is passed to make).
92
93	2. If the compiler does not support "operator new[]", beware that an
94	array of type T, where T is derived from "gc", may or may not be
95	allocated as a collectible object (it depends on the compiler). Use
96	the explicit GC placement to make the array collectible. For example:
97
98	class A: public gc {...};
99	A* a1 = new A[ 10 ]; // collectible or uncollectible?
100	A* a2 = new (GC) A[ 10 ]; // collectible.
101
102	3. The destructors of collectible arrays of objects derived from
103	"gc_cleanup" will not be invoked properly. For example:
104
105	class A: public gc_cleanup {...};
106	A* a = new (GC) A[ 10 ]; // destructors not invoked correctly
107
108	Typically, only the destructor for the first element of the array will
109	be invoked when the array is garbage-collected. To get all the
110	destructors of any array executed, you must supply an explicit
111	clean-up function:
112
113	A* a = new (GC, MyCleanUp) A[ 10 ];
114
115	(Implementing clean-up of arrays correctly, portably, and in a way
116	that preserves the correct exception semantics requires a language
117	extension, e.g. the "gc" keyword.)
118
119	4. GC name conflicts:
120
121	Many other systems seem to use the identifier "GC" as an abbreviation
122	for "Graphics Context". Thus, GC placement has been replaced
123	by UseGC. GC is an alias for UseGC, unless GC_NAME_CONFLICT is defined.
124
125	****************************************************************************/
126
127	#include "gc.h"
128
129	#ifdef GC_INCLUDE_NEW
130	# include <new> // for std, bad_alloc
131	# define GC_PTRDIFF_T std::ptrdiff_t
132	# define GC_SIZE_T std::size_t
133	#else
134	# define GC_PTRDIFF_T ptrdiff_t
135	# define GC_SIZE_T size_t
136	#endif
137
138	#ifdef GC_NAMESPACE
139	# define GC_NS_QUALIFY(T) boehmgc::T
140	#else
141	# define GC_NS_QUALIFY(T) T
142	#endif
143
144	#ifndef THINK_CPLUS
145	# define GC_cdecl GC_CALLBACK
146	#else
147	# define GC_cdecl _cdecl
148	#endif
149
150	#if !defined(GC_NO_OPERATOR_NEW_ARRAY) \
151	&& !defined(_ENABLE_ARRAYNEW) /* Digimars */ \
152	&& (defined(__BORLANDC__) && (__BORLANDC__ < 0x450) \
153	\|\| (defined(__GNUC__) && !GC_GNUC_PREREQ(2, 6)) \
154	\|\| (defined(_MSC_VER) && _MSC_VER <= 1020) \
155	\|\| (defined(__WATCOMC__) && __WATCOMC__ < 1050))
156	# define GC_NO_OPERATOR_NEW_ARRAY
157	#endif
158
159	#if !defined(GC_NO_OPERATOR_NEW_ARRAY) && !defined(GC_OPERATOR_NEW_ARRAY)
160	# define GC_OPERATOR_NEW_ARRAY
161	#endif
162
163	#if (!defined(__BORLANDC__) \|\| __BORLANDC__ > 0x0620) \
164	&& !defined(__sgi) && !defined(__WATCOMC__) \
165	&& (!defined(_MSC_VER) \|\| _MSC_VER > 1020)
166	# define GC_PLACEMENT_DELETE
167	#endif
168
169	#if !defined(GC_NEW_DELETE_THROW_NOT_NEEDED) \
170	&& !defined(GC_NEW_DELETE_NEED_THROW) && GC_GNUC_PREREQ(4, 2) \
171	&& (__cplusplus < 201103L \|\| defined(__clang__))
172	# define GC_NEW_DELETE_NEED_THROW
173	#endif
174
175	#if defined(GC_NEW_ABORTS_ON_OOM) \|\| defined(_LIBCPP_NO_EXCEPTIONS)
176	# define GC_OP_NEW_OOM_CHECK(obj) \
177	do { if (!(obj)) GC_abort_on_oom(); } while (0)
178	#elif defined(GC_INCLUDE_NEW)
179	# define GC_OP_NEW_OOM_CHECK(obj) if (obj) {} else throw std::bad_alloc()
180	#else
181	// "new" header is not included, so bad_alloc cannot be thrown directly.
182	GC_API void GC_CALL GC_throw_bad_alloc();
183	# define GC_OP_NEW_OOM_CHECK(obj) if (obj) {} else GC_throw_bad_alloc()
184	#endif // !GC_NEW_ABORTS_ON_OOM && !GC_INCLUDE_NEW
185
186	#ifdef GC_NAMESPACE
187	namespace boehmgc
188	{
189	#endif
190
191	enum GCPlacement
192	{
193	UseGC,
194	# ifndef GC_NAME_CONFLICT
195	GC = UseGC,
196	# endif
197	NoGC,
198	PointerFreeGC
199	# ifdef GC_ATOMIC_UNCOLLECTABLE
200	, PointerFreeNoGC
201	# endif
202	};
203
204	/**
205	* Instances of classes derived from gc will be allocated in the collected
206	* heap by default, unless an explicit NoGC placement is specified.
207	*/
208	class gc	28,252,000✔
209	{
210	public:
211	inline void* operator new(GC_SIZE_T);
212	inline void* operator new(GC_SIZE_T, GCPlacement);
213	inline void* operator new(GC_SIZE_T, void*) GC_NOEXCEPT;
214	// Must be redefined here, since the other overloadings hide
215	// the global definition.
216	inline void operator delete(void*) GC_NOEXCEPT;
217
218	# ifdef GC_PLACEMENT_DELETE
219	inline void operator delete(void*, GCPlacement) GC_NOEXCEPT;
220	// Called if construction fails.
221	inline void operator delete(void, void) GC_NOEXCEPT;
222	# endif // GC_PLACEMENT_DELETE
223
224	# ifdef GC_OPERATOR_NEW_ARRAY
225	inline void* operator new[](GC_SIZE_T);
226	inline void* operator new[](GC_SIZE_T, GCPlacement);
227	inline void* operator new[](GC_SIZE_T, void*) GC_NOEXCEPT;
228	inline void operator delete[](void*) GC_NOEXCEPT;
229	# ifdef GC_PLACEMENT_DELETE
230	inline void operator delete[](void*, GCPlacement) GC_NOEXCEPT;
231	inline void operator delete[](void, void) GC_NOEXCEPT;
232	# endif
233	# endif // GC_OPERATOR_NEW_ARRAY
234	};
235
236	/**
237	* Instances of classes derived from gc_cleanup will be allocated
238	* in the collected heap by default. When the collector discovers
239	* an inaccessible object derived from gc_cleanup or containing
240	* a member derived from gc_cleanup, its destructors will be invoked.
241	*/
242	class gc_cleanup: virtual public gc
243	{
244	public:
245	inline gc_cleanup();
246	inline virtual ~gc_cleanup();
247
248	private:
249	inline static void GC_cdecl cleanup(void* obj, void* clientData);
250	};
251
252	extern "C" {
253	typedef void (GC_CALLBACK * GCCleanUpFunc)(void* obj, void* clientData);
254	}
255
256	#ifdef GC_NAMESPACE
257	}
258	#endif
259
260	#ifdef _MSC_VER
261	// Disable warning that "no matching operator delete found; memory will
262	// not be freed if initialization throws an exception"
263	# pragma warning(disable:4291)
264	// TODO: "non-member operator new or delete may not be declared inline"
265	// warning is disabled for now.
266	# pragma warning(disable:4595)
267	#endif
268
269	inline void* operator new(GC_SIZE_T, GC_NS_QUALIFY(GCPlacement),
270	GC_NS_QUALIFY(GCCleanUpFunc) = 0,
271	void* /* clientData */ = 0);
272	// Allocates a collectible or uncollectible object, according to the
273	// value of gcp.
274	//
275	// For collectible objects, if cleanup is non-null, then when the
276	// allocated object obj becomes inaccessible, the collector will
277	// invoke cleanup(obj,clientData) but will not invoke the object's
278	// destructors. It is an error to explicitly delete an object
279	// allocated with a non-null cleanup.
280	//
281	// It is an error to specify a non-null cleanup with NoGC or for
282	// classes derived from gc_cleanup or containing members derived
283	// from gc_cleanup.
284
285	#ifdef GC_PLACEMENT_DELETE
286	inline void operator delete(void*, GC_NS_QUALIFY(GCPlacement),
287	GC_NS_QUALIFY(GCCleanUpFunc),
288	void*) GC_NOEXCEPT;
289	#endif
290
291	#ifndef GC_NO_INLINE_STD_NEW
292
293	# if defined(_MSC_VER) \|\| defined(__DMC__) \
294	\|\| ((defined(__BORLANDC__) \|\| defined(__CYGWIN__) \
295	\|\| defined(__CYGWIN32__) \|\| defined(__MINGW32__) \
296	\|\| defined(__WATCOMC__)) \
297	&& !defined(GC_BUILD) && !defined(GC_NOT_DLL))
298	// Inlining done to avoid mix up of new and delete operators by VC++ 9
299	// (due to arbitrary ordering during linking).
300
301	# if defined(GC_NEW_DELETE_NEED_THROW) && defined(GC_INCLUDE_NEW)
302	# define GC_DECL_INLINE_NEW_THROW throw(std::bad_alloc)
303	# else
304	# define GC_DECL_INLINE_NEW_THROW /* empty */
305	# endif
306
307	# ifdef GC_OPERATOR_NEW_ARRAY
308	inline void* operator new[](GC_SIZE_T size) GC_DECL_INLINE_NEW_THROW
309	{
310	void* obj = GC_MALLOC_UNCOLLECTABLE(size);
311	GC_OP_NEW_OOM_CHECK(obj);
312	return obj;
313	}
314
315	inline void operator delete[](void* obj) GC_NOEXCEPT
316	{
317	GC_FREE(obj);
318	}
319	# endif // GC_OPERATOR_NEW_ARRAY
320
321	inline void* operator new(GC_SIZE_T size) GC_DECL_INLINE_NEW_THROW
322	{
323	void* obj = GC_MALLOC_UNCOLLECTABLE(size);
324	GC_OP_NEW_OOM_CHECK(obj);
325	return obj;
326	}
327
328	inline void operator delete(void* obj) GC_NOEXCEPT
329	{
330	GC_FREE(obj);
331	}
332
333	# if __cplusplus >= 201402L \|\| _MSVC_LANG >= 201402L // C++14
334	inline void operator delete(void* obj, GC_SIZE_T) GC_NOEXCEPT {
335	GC_FREE(obj);
336	}
337
338	# if defined(GC_OPERATOR_NEW_ARRAY)
339	inline void operator delete[](void* obj, GC_SIZE_T) GC_NOEXCEPT {
340	GC_FREE(obj);
341	}
342	# endif
343	# endif // C++14
344	# endif // _MSC_VER \|\| __CYGWIN__ && !GC_BUILD && !GC_NOT_DLL
345
346	# ifdef _MSC_VER
347	// This new operator is used by VC++ in case of Debug builds.
348	inline void* operator new(GC_SIZE_T size, int /* nBlockUse */,
349	const char* szFileName, int nLine)
350	{
351	# ifdef GC_DEBUG
352	void* obj = GC_debug_malloc_uncollectable(size, szFileName, nLine);
353	# else
354	void* obj = GC_MALLOC_UNCOLLECTABLE(size);
355	(void)szFileName; (void)nLine;
356	# endif
357	GC_OP_NEW_OOM_CHECK(obj);
358	return obj;
359	}
360
361	# ifdef GC_OPERATOR_NEW_ARRAY
362	// This new operator is used by VC++ 7+ in Debug builds.
363	inline void* operator new[](GC_SIZE_T size, int nBlockUse,
364	const char* szFileName, int nLine)
365	{
366	return operator new(size, nBlockUse, szFileName, nLine);
367	}
368	# endif
369	# endif // _MSC_VER
370
371	#elif defined(_MSC_VER) /* && GC_NO_INLINE_STD_NEW */
372	// The following ensures that the system default operator new[] does not
373	// get undefined, which is what seems to happen on VC++ 6 for some reason
374	// if we define a multi-argument operator new[].
375	// There seems to be no way to redirect new in this environment without
376	// including this everywhere.
377	# ifdef GC_OPERATOR_NEW_ARRAY
378	void* operator new[](GC_SIZE_T);
379	void operator delete[](void*);
380	# endif
381
382	void* operator new(GC_SIZE_T);
383	void operator delete(void*);
384
385	void* operator new(GC_SIZE_T, int /* nBlockUse */,
386	const char* /* szFileName /, int / nLine */);
387	#endif // GC_NO_INLINE_STD_NEW && _MSC_VER
388
389	#ifdef GC_OPERATOR_NEW_ARRAY
390	// The operator new for arrays, identical to the above.
391	inline void* operator new[](GC_SIZE_T, GC_NS_QUALIFY(GCPlacement),
392	GC_NS_QUALIFY(GCCleanUpFunc) = 0,
393	void* /* clientData */ = 0);
394	#endif // GC_OPERATOR_NEW_ARRAY
395
396	// Inline implementation.
397
398	#ifdef GC_NAMESPACE
399	namespace boehmgc
400	{
401	#endif
402
403	inline void* gc::operator new(GC_SIZE_T size)	14,196,000✔
404	{
405	void* obj = GC_MALLOC(size);	14,196,000✔
406	GC_OP_NEW_OOM_CHECK(obj);	14,196,000✔
407	return obj;	14,196,000✔
408	}
409
410	inline void* gc::operator new(GC_SIZE_T size, GCPlacement gcp)	14,014,000✔
411	{
412	void* obj;
413	switch (gcp) {	14,014,000✔
414	case UseGC:
415	obj = GC_MALLOC(size);	14,000,000✔
416	break;	14,000,000✔
417	case PointerFreeGC:
418	obj = GC_MALLOC_ATOMIC(size);	×
419	break;	×
420	# ifdef GC_ATOMIC_UNCOLLECTABLE
421	case PointerFreeNoGC:
422	obj = GC_MALLOC_ATOMIC_UNCOLLECTABLE(size);	×
423	break;	×
424	# endif
425	case NoGC:
426	default:
427	obj = GC_MALLOC_UNCOLLECTABLE(size);	14,000✔
428	}
429	GC_OP_NEW_OOM_CHECK(obj);	14,014,000✔
430	return obj;	14,014,000✔
431	}
432
433	inline void* gc::operator new(GC_SIZE_T, void* p) GC_NOEXCEPT
434	{
435	return p;
436	}
437
438	inline void gc::operator delete(void* obj) GC_NOEXCEPT	1,415,400✔
439	{
440	GC_FREE(obj);	1,415,400✔
441	}	1,415,400✔
442
443	#ifdef GC_PLACEMENT_DELETE
444	inline void gc::operator delete(void, void) GC_NOEXCEPT {}
445
446	inline void gc::operator delete(void* obj, GCPlacement) GC_NOEXCEPT
447	{
448	GC_FREE(obj);
449	}
450	#endif // GC_PLACEMENT_DELETE
451
452	#ifdef GC_OPERATOR_NEW_ARRAY
453	inline void* gc::operator new[](GC_SIZE_T size)
454	{
455	return gc::operator new(size);
456	}
457
458	inline void* gc::operator new[](GC_SIZE_T size, GCPlacement gcp)
459	{
460	return gc::operator new(size, gcp);
461	}
462
463	inline void* gc::operator new[](GC_SIZE_T, void* p) GC_NOEXCEPT
464	{
465	return p;
466	}
467
468	inline void gc::operator delete[](void* obj) GC_NOEXCEPT
469	{
470	gc::operator delete(obj);
471	}
472
473	# ifdef GC_PLACEMENT_DELETE
474	inline void gc::operator delete[](void, void) GC_NOEXCEPT {}
475
476	inline void gc::operator delete[](void* p, GCPlacement) GC_NOEXCEPT
477	{
478	gc::operator delete(p);
479	}
480	# endif
481	#endif // GC_OPERATOR_NEW_ARRAY
482
483	inline gc_cleanup::~gc_cleanup()	433,964✔
484	{
485	# ifndef GC_NO_FINALIZATION
486	void* base = GC_base(this);	223,982✔
487	if (0 == base) return; // Non-heap object.	237,982✔
488	GC_register_finalizer_ignore_self(base, 0, 0, 0, 0);	209,982✔
489	# endif
490	}	223,982✔
491
492	inline void GC_CALLBACK gc_cleanup::cleanup(void* obj, void* displ)	194,584✔
493	{
494	reinterpret_cast<gc_cleanup>(reinterpret_cast<char>(obj)
495	+ reinterpret_cast<GC_PTRDIFF_T>(displ))->~gc_cleanup();	194,584✔
496	}	194,584✔
497
498	inline gc_cleanup::gc_cleanup()	224,000✔
499	{
500	# ifndef GC_NO_FINALIZATION
501	GC_finalization_proc oldProc = 0;	224,000✔
502	void* oldData = 0; // to avoid "might be uninitialized" compiler warning	224,000✔
503	void* this_ptr = reinterpret_cast<void*>(this);	224,000✔
504	void* base = GC_base(this_ptr);	224,000✔
505	if (base != 0) {	224,000✔
506	// Don't call the debug version, since this is a real base address.
507	GC_register_finalizer_ignore_self(base,	210,000✔
508	reinterpret_cast<GC_finalization_proc>(cleanup),
509	reinterpret_cast<void>(reinterpret_cast<char>(this_ptr) -	210,000✔
510	reinterpret_cast<char*>(base)),
511	&oldProc, &oldData);	210,000✔
512	if (oldProc != 0) {	210,000✔
513	GC_register_finalizer_ignore_self(base, oldProc, oldData, 0, 0);	14,000✔
514	}
515	}
516	# elif defined(CPPCHECK)
517	(void)cleanup;
518	# endif
519	}	224,000✔
520
521	#ifdef GC_NAMESPACE
522	}
523	#endif
524
525	inline void* operator new(GC_SIZE_T size, GC_NS_QUALIFY(GCPlacement) gcp,	14,028,000✔
526	GC_NS_QUALIFY(GCCleanUpFunc) cleanup,
527	void* clientData)
528	{
529	void* obj;
530	switch (gcp) {	14,028,000✔
531	case GC_NS_QUALIFY(UseGC):
532	obj = GC_MALLOC(size);	14,014,000✔
533	# ifndef GC_NO_FINALIZATION
534	if (cleanup != 0 && obj != 0) {	14,014,000✔
535	GC_REGISTER_FINALIZER_IGNORE_SELF(obj, cleanup, clientData, 0, 0);	14,000✔
536	}
537	# else
538	(void)cleanup;
539	(void)clientData;
540	# endif
541	break;	14,014,000✔
542	case GC_NS_QUALIFY(PointerFreeGC):
543	obj = GC_MALLOC_ATOMIC(size);	×
544	break;	×
545	# ifdef GC_ATOMIC_UNCOLLECTABLE
546	case GC_NS_QUALIFY(PointerFreeNoGC):
547	obj = GC_MALLOC_ATOMIC_UNCOLLECTABLE(size);	×
548	break;	×
549	# endif
550	case GC_NS_QUALIFY(NoGC):
551	default:
552	obj = GC_MALLOC_UNCOLLECTABLE(size);	14,000✔
553	}
554	GC_OP_NEW_OOM_CHECK(obj);	14,028,000✔
555	return obj;	14,028,000✔
556	}
557
558	#ifdef GC_PLACEMENT_DELETE
559	inline void operator delete(void* obj, GC_NS_QUALIFY(GCPlacement),
560	GC_NS_QUALIFY(GCCleanUpFunc),
561	void* /* clientData */) GC_NOEXCEPT
562	{
563	GC_FREE(obj);
564	}
565	#endif // GC_PLACEMENT_DELETE
566
567	#ifdef GC_OPERATOR_NEW_ARRAY
568	inline void* operator new[](GC_SIZE_T size,
569	GC_NS_QUALIFY(GCPlacement) gcp,
570	GC_NS_QUALIFY(GCCleanUpFunc) cleanup,
571	void* clientData)
572	{
573	return ::operator new(size, gcp, cleanup, clientData);
574	}
575	#endif // GC_OPERATOR_NEW_ARRAY
576
577	#endif /* GC_CPP_H */

ivmai / bdwgc / 1485

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous