1 /* Copyright (C) 2009-2021 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 _ZdlPvX S(_ZdlPv,MANGLE_SIZE_T)
39 #define _ZnwXRKSt9nothrow_t S(S(_Znw,MANGLE_SIZE_T),RKSt9nothrow_t)
40 #define _ZnaXRKSt9nothrow_t S(S(_Zna,MANGLE_SIZE_T),RKSt9nothrow_t)
41 #define _ZdlPvXRKSt9nothrow_t S(S(_ZdlPv,MANGLE_SIZE_T),RKSt9nothrow_t)
42
43 #define _ZGTtnwX S(_ZGTtnw,MANGLE_SIZE_T)
44 #define _ZGTtnaX S(_ZGTtna,MANGLE_SIZE_T)
45 #define _ZGTtdlPvX S(_ZGTtdlPv,MANGLE_SIZE_T)
46 #define _ZGTtnwXRKSt9nothrow_t S(S(_ZGTtnw,MANGLE_SIZE_T),RKSt9nothrow_t)
47 #define _ZGTtnaXRKSt9nothrow_t S(S(_ZGTtna,MANGLE_SIZE_T),RKSt9nothrow_t)
48 #define _ZGTtdlPvXRKSt9nothrow_t S(S(_ZGTtdlPv,MANGLE_SIZE_T),RKSt9nothrow_t)
49
50 /* Everything from libstdc++ is weak, to avoid requiring that library
51 to be linked into plain C applications using libitm.so. */
52
53 extern "C" {
54
55 extern void *_ZnwX (size_t) __attribute__((weak));
56 extern void _ZdlPv (void *) __attribute__((weak));
57 extern void _ZdlPvX (void *, size_t) __attribute__((weak));
58 extern void *_ZnaX (size_t) __attribute__((weak));
59 extern void _ZdaPv (void *) __attribute__((weak));
60
61 typedef const struct nothrow_t { } *c_nothrow_p;
62
63 extern void *_ZnwXRKSt9nothrow_t (size_t, c_nothrow_p) __attribute__((weak));
64 extern void _ZdlPvRKSt9nothrow_t (void *, c_nothrow_p) __attribute__((weak));
65 extern void _ZdlPvXRKSt9nothrow_t
66 (void *, size_t, c_nothrow_p) __attribute__((weak));
67 extern void *_ZnaXRKSt9nothrow_t (size_t, c_nothrow_p) __attribute__((weak));
68 extern void _ZdaPvRKSt9nothrow_t (void *, c_nothrow_p) __attribute__((weak));
69
70 #if !defined (HAVE_ELF_STYLE_WEAKREF)
_ZnwX(size_t)71 void *_ZnwX (size_t) { return NULL; }
_ZdlPv(void *)72 void _ZdlPv (void *) { return; }
_ZdlPvX(void *,size_t)73 void _ZdlPvX (void *, size_t) { return; }
_ZnaX(size_t)74 void *_ZnaX (size_t) { return NULL; }
_ZdaPv(void *)75 void _ZdaPv (void *) { return; }
76
_ZnwXRKSt9nothrow_t(size_t,c_nothrow_p)77 void *_ZnwXRKSt9nothrow_t (size_t, c_nothrow_p) { return NULL; }
_ZdlPvRKSt9nothrow_t(void *,c_nothrow_p)78 void _ZdlPvRKSt9nothrow_t (void *, c_nothrow_p) { return; }
_ZdlPvXRKSt9nothrow_t(void *,size_t,c_nothrow_p)79 void _ZdlPvXRKSt9nothrow_t (void *, size_t, c_nothrow_p) { return; }
_ZnaXRKSt9nothrow_t(size_t,c_nothrow_p)80 void *_ZnaXRKSt9nothrow_t (size_t, c_nothrow_p) { return NULL; }
_ZdaPvRKSt9nothrow_t(void *,c_nothrow_p)81 void _ZdaPvRKSt9nothrow_t (void *, c_nothrow_p) { return; }
82 #endif /* HAVE_ELF_STYLE_WEAKREF */
83
84 /* Wrap the delete nothrow symbols for usage with a single argument.
85 Perhaps should have a configure type check for this, because the
86 std::nothrow_t reference argument is unused (empty class), and most
87 targets don't actually need that second argument. So we _could_
88 invoke these functions as if they were a single argument free. */
89 static void
del_opnt(void * ptr)90 del_opnt (void *ptr)
91 {
92 _ZdlPvRKSt9nothrow_t (ptr, NULL);
93 }
94
95 static void
del_opvnt(void * ptr)96 del_opvnt (void *ptr)
97 {
98 _ZdaPvRKSt9nothrow_t (ptr, NULL);
99 }
100
101 static void
delsz_opnt(void * ptr,size_t sz)102 delsz_opnt (void *ptr, size_t sz)
103 {
104 _ZdlPvXRKSt9nothrow_t (ptr, sz, NULL);
105 }
106
107 /* Wrap: operator new (std::size_t sz) */
108 void *
_ZGTtnwX(size_t sz)109 _ZGTtnwX (size_t sz)
110 {
111 void *r = _ZnwX (sz);
112 if (r)
113 gtm_thr()->record_allocation (r, _ZdlPv);
114 return r;
115 }
116
117 /* Wrap: operator new (std::size_t sz, const std::nothrow_t&) */
118 void *
_ZGTtnwXRKSt9nothrow_t(size_t sz,c_nothrow_p nt)119 _ZGTtnwXRKSt9nothrow_t (size_t sz, c_nothrow_p nt)
120 {
121 void *r = _ZnwXRKSt9nothrow_t (sz, nt);
122 if (r)
123 gtm_thr()->record_allocation (r, del_opnt);
124 return r;
125 }
126
127 /* Wrap: operator new[] (std::size_t sz) */
128 void *
_ZGTtnaX(size_t sz)129 _ZGTtnaX (size_t sz)
130 {
131 void *r = _ZnaX (sz);
132 if (r)
133 gtm_thr()->record_allocation (r, _ZdaPv);
134 return r;
135 }
136
137 /* Wrap: operator new[] (std::size_t sz, const std::nothrow_t& nothrow) */
138 void *
_ZGTtnaXRKSt9nothrow_t(size_t sz,c_nothrow_p nt)139 _ZGTtnaXRKSt9nothrow_t (size_t sz, c_nothrow_p nt)
140 {
141 void *r = _ZnaXRKSt9nothrow_t (sz, nt);
142 if (r)
143 gtm_thr()->record_allocation (r, del_opvnt);
144 return r;
145 }
146
147 /* Wrap: operator delete(void* ptr) */
148 void
_ZGTtdlPv(void * ptr)149 _ZGTtdlPv (void *ptr)
150 {
151 if (ptr)
152 gtm_thr()->forget_allocation (ptr, _ZdlPv);
153 }
154
155 /* Wrap: operator delete (void *ptr, const std::nothrow_t&) */
156 void
_ZGTtdlPvRKSt9nothrow_t(void * ptr,c_nothrow_p nt UNUSED)157 _ZGTtdlPvRKSt9nothrow_t (void *ptr, c_nothrow_p nt UNUSED)
158 {
159 if (ptr)
160 gtm_thr()->forget_allocation (ptr, del_opnt);
161 }
162
163 /* Wrap: operator delete[] (void *ptr) */
164 void
_ZGTtdaPv(void * ptr)165 _ZGTtdaPv (void *ptr)
166 {
167 if (ptr)
168 gtm_thr()->forget_allocation (ptr, _ZdaPv);
169 }
170
171 /* Wrap: operator delete[] (void *ptr, const std::nothrow_t&) */
172 void
_ZGTtdaPvRKSt9nothrow_t(void * ptr,c_nothrow_p nt UNUSED)173 _ZGTtdaPvRKSt9nothrow_t (void *ptr, c_nothrow_p nt UNUSED)
174 {
175 if (ptr)
176 gtm_thr()->forget_allocation (ptr, del_opvnt);
177 }
178
179 /* Wrap: operator delete(void* ptr, std::size_t sz) */
180 void
_ZGTtdlPvX(void * ptr,size_t sz)181 _ZGTtdlPvX (void *ptr, size_t sz)
182 {
183 if (ptr)
184 gtm_thr()->forget_allocation (ptr, sz, _ZdlPvX);
185 }
186
187 /* Wrap: operator delete (void *ptr, std::size_t sz, const std::nothrow_t&) */
188 void
_ZGTtdlPvXRKSt9nothrow_t(void * ptr,size_t sz,c_nothrow_p nt UNUSED)189 _ZGTtdlPvXRKSt9nothrow_t (void *ptr, size_t sz, c_nothrow_p nt UNUSED)
190 {
191 if (ptr)
192 gtm_thr()->forget_allocation (ptr, sz, delsz_opnt);
193 }
194
195 } // extern "C"
196