libitm/alloc_cpp.cc

   1 /* Copyright (C) 2009, 2011 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson <rth@redhat.com>.
   3
   4    This file is part of the GNU Transactional Memory Library (libitm).
   5
   6    Libitm is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    Libitm is distributed in the hope that it will be useful, but WITHOUT ANY
  12    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14    more details.
  15
  16    Under Section 7 of GPL version 3, you are granted additional
  17    permissions described in the GCC Runtime Library Exception, version
  18    3.1, as published by the Free Software Foundation.
  19
  20    You should have received a copy of the GNU General Public License and
  21    a copy of the GCC Runtime Library Exception along with this program;
  22    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23    <http://www.gnu.org/licenses/>.  */
  24
  25 #include "libitm_i.h"
  26
  27 using namespace GTM;
  28
  29 /* Mangling the names by hand requires that we know how size_t is handled.
  30    We've gotten the letter from autoconf, now substitute it into the names.
  31    Everything below uses X as a placeholder for clarity.  */
  32
  33 #define S1(x,y)                 x##y
  34 #define S(x,y)                  S1(x,y)
  35
  36 #define _ZnwX                   S(_Znw,MANGLE_SIZE_T)
  37 #define _ZnaX                   S(_Zna,MANGLE_SIZE_T)
  38 #define _ZnwXRKSt9nothrow_t     S(S(_Znw,MANGLE_SIZE_T),RKSt9nothrow_t)
  39 #define _ZnaXRKSt9nothrow_t     S(S(_Zna,MANGLE_SIZE_T),RKSt9nothrow_t)
  40
  41 #define _ZGTtnwX                S(_ZGTtnw,MANGLE_SIZE_T)
  42 #define _ZGTtnaX                S(_ZGTtna,MANGLE_SIZE_T)
  43 #define _ZGTtnwXRKSt9nothrow_t  S(S(_ZGTtnw,MANGLE_SIZE_T),RKSt9nothrow_t)
  44 #define _ZGTtnaXRKSt9nothrow_t  S(S(_ZGTtna,MANGLE_SIZE_T),RKSt9nothrow_t)
  45
  46 /* Everything from libstdc++ is weak, to avoid requiring that library
  47    to be linked into plain C applications using libitm.so.  */
  48
  49 extern "C" {
  50
  51 extern void *_ZnwX (size_t) __attribute__((weak));
  52 extern void _ZdlPv (void *) __attribute__((weak));
  53 extern void *_ZnaX (size_t) __attribute__((weak));
  54 extern void _ZdaPv (void *) __attribute__((weak));
  55
  56 typedef const struct nothrow_t { } *c_nothrow_p;
  57
  58 extern void *_ZnwXRKSt9nothrow_t (size_t, c_nothrow_p) __attribute__((weak));
  59 extern void _ZdlPvRKSt9nothrow_t (void *, c_nothrow_p) __attribute__((weak));
  60 extern void *_ZnaXRKSt9nothrow_t (size_t, c_nothrow_p) __attribute__((weak));
  61 extern void _ZdaPvRKSt9nothrow_t (void *, c_nothrow_p) __attribute__((weak));
  62
  63 #ifdef __osf__ /* Really: !HAVE_WEAKDEF  */
  64 void *
  65 _ZnaXRKSt9nothrow_t (size_t, c_nothrow_p)
  66 {
  67   return NULL;
  68 }
  69 #endif /* __osf__ */
  70
  71 /* Wrap the delete nothrow symbols for usage with a single argument.
  72    Perhaps should have a configure type check for this, because the
  73    std::nothrow_t reference argument is unused (empty class), and most
  74    targets don't actually need that second argument.  So we _could_
  75    invoke these functions as if they were a single argument free.  */
  76 static void
  77 del_opnt (void *ptr)
  78 {
  79   _ZdlPvRKSt9nothrow_t (ptr, NULL);
  80 }
  81
  82 static void
  83 del_opvnt (void *ptr)
  84 {
  85   _ZdaPvRKSt9nothrow_t (ptr, NULL);
  86 }
  87
  88 /* Wrap: operator new (std::size_t sz)  */
  89 void *
  90 _ZGTtnwX (size_t sz)
  91 {
  92   void *r = _ZnwX (sz);
  93   if (r)
  94     gtm_thr()->record_allocation (r, _ZdlPv);
  95   return r;
  96 }
  97
  98 /* Wrap: operator new (std::size_t sz, const std::nothrow_t&)  */
  99 void *
 100 _ZGTtnwXRKSt9nothrow_t (size_t sz, c_nothrow_p nt)
 101 {
 102   void *r = _ZnwXRKSt9nothrow_t (sz, nt);
 103   if (r)
 104     gtm_thr()->record_allocation (r, del_opnt);
 105   return r;
 106 }
 107
 108 /* Wrap: operator new[] (std::size_t sz)  */
 109 void *
 110 _ZGTtnaX (size_t sz)
 111 {
 112   void *r = _ZnaX (sz);
 113   if (r)
 114     gtm_thr()->record_allocation (r, _ZdaPv);
 115   return r;
 116 }
 117
 118 /* Wrap: operator new[] (std::size_t sz, const std::nothrow_t& nothrow)  */
 119 void *
 120 _ZGTtnaXRKSt9nothrow_t (size_t sz, c_nothrow_p nt)
 121 {
 122   void *r = _ZnaXRKSt9nothrow_t (sz, nt);
 123   if (r)
 124     gtm_thr()->record_allocation (r, del_opvnt);
 125   return r;
 126 }
 127
 128 /* Wrap: operator delete(void* ptr)  */
 129 void
 130 _ZGTtdlPv (void *ptr)
 131 {
 132   if (ptr)
 133     gtm_thr()->forget_allocation (ptr, _ZdlPv);
 134 }
 135
 136 /* Wrap: operator delete (void *ptr, const std::nothrow_t&)  */
 137 void
 138 _ZGTtdlPvRKSt9nothrow_t (void *ptr, c_nothrow_p nt UNUSED)
 139 {
 140   if (ptr)
 141     gtm_thr()->forget_allocation (ptr, del_opnt);
 142 }
 143
 144 /* Wrap: operator delete[] (void *ptr)  */
 145 void
 146 _ZGTtdaPv (void *ptr)
 147 {
 148   if (ptr)
 149     gtm_thr()->forget_allocation (ptr, _ZdaPv);
 150 }
 151
 152 /* Wrap: operator delete[] (void *ptr, const std::nothrow_t&)  */
 153 void
 154 _ZGTtdaPvRKSt9nothrow_t (void *ptr, c_nothrow_p nt UNUSED)
 155 {
 156   if (ptr)
 157     gtm_thr()->forget_allocation (ptr, del_opvnt);
 158 }
 159
 160 } // extern "C"