1 // Compatibility symbols for previous versions -*- C++ -*-
2
3 // Copyright (C) 2005-2021 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for 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 #define _GLIBCXX_USE_CXX11_ABI 0
26 #include <bits/c++config.h>
27
28 #if defined(_GLIBCXX_SYMVER_GNU) && defined(_GLIBCXX_SHARED) \
29 && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE)\
30 && defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
31 #define istreambuf_iterator istreambuf_iteratorXX
32 #define basic_fstream basic_fstreamXX
33 #define basic_ifstream basic_ifstreamXX
34 #define basic_ofstream basic_ofstreamXX
35 #define _M_copy(a, b, c) _M_copyXX(a, b, c)
36 #define _M_move(a, b, c) _M_moveXX(a, b, c)
37 #define _M_assign(a, b, c) _M_assignXX(a, b, c)
38 #define _M_disjunct(a) _M_disjunctXX(a)
39 #define _M_check_length(a, b, c) _M_check_lengthXX(a, b, c)
40 #define _M_set_length_and_sharable(a) _M_set_length_and_sharableXX(a)
41 #define ignore ignoreXX
42 #define eq eqXX
43 #define _List_node_base _List_node_baseXX
44 #endif
45
46 #include <string>
47 #include <istream>
48 #include <fstream>
49 #include <sstream>
50 #include <cmath>
51 #include <ext/numeric_traits.h>
52
53 namespace std _GLIBCXX_VISIBILITY(default)
54 {
55 _GLIBCXX_BEGIN_NAMESPACE_VERSION
56
57 // std::istream ignore explicit specializations.
58 template<>
59 basic_istream<char>&
60 basic_istream<char>::
ignore(streamsize __n)61 ignore(streamsize __n)
62 {
63 if (__n == 1)
64 return ignore();
65
66 _M_gcount = 0;
67 sentry __cerb(*this, true);
68 if ( __n > 0 && __cerb)
69 {
70 ios_base::iostate __err = ios_base::goodbit;
71 __try
72 {
73 const int_type __eof = traits_type::eof();
74 __streambuf_type* __sb = this->rdbuf();
75 int_type __c = __sb->sgetc();
76
77 // See comment in istream.tcc.
78 bool __large_ignore = false;
79 while (true)
80 {
81 while (_M_gcount < __n
82 && !traits_type::eq_int_type(__c, __eof))
83 {
84 streamsize __size = std::min(streamsize(__sb->egptr()
85 - __sb->gptr()),
86 streamsize(__n - _M_gcount));
87 if (__size > 1)
88 {
89 __sb->__safe_gbump(__size);
90 _M_gcount += __size;
91 __c = __sb->sgetc();
92 }
93 else
94 {
95 ++_M_gcount;
96 __c = __sb->snextc();
97 }
98 }
99 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
100 && !traits_type::eq_int_type(__c, __eof))
101 {
102 _M_gcount =
103 __gnu_cxx::__numeric_traits<streamsize>::__min;
104 __large_ignore = true;
105 }
106 else
107 break;
108 }
109
110 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
111 {
112 if (__large_ignore)
113 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
114
115 if (traits_type::eq_int_type(__c, __eof))
116 __err |= ios_base::eofbit;
117 }
118 else if (_M_gcount < __n)
119 {
120 if (traits_type::eq_int_type(__c, __eof))
121 __err |= ios_base::eofbit;
122 }
123 }
124 __catch(__cxxabiv1::__forced_unwind&)
125 {
126 this->_M_setstate(ios_base::badbit);
127 __throw_exception_again;
128 }
129 __catch(...)
130 { this->_M_setstate(ios_base::badbit); }
131 if (__err)
132 this->setstate(__err);
133 }
134 return *this;
135 }
136
137 #ifdef _GLIBCXX_USE_WCHAR_T
138 template<>
139 basic_istream<wchar_t>&
140 basic_istream<wchar_t>::
ignore(streamsize __n)141 ignore(streamsize __n)
142 {
143 if (__n == 1)
144 return ignore();
145
146 _M_gcount = 0;
147 sentry __cerb(*this, true);
148 if (__n > 0 && __cerb)
149 {
150 ios_base::iostate __err = ios_base::goodbit;
151 __try
152 {
153 const int_type __eof = traits_type::eof();
154 __streambuf_type* __sb = this->rdbuf();
155 int_type __c = __sb->sgetc();
156
157 bool __large_ignore = false;
158 while (true)
159 {
160 while (_M_gcount < __n
161 && !traits_type::eq_int_type(__c, __eof))
162 {
163 streamsize __size = std::min(streamsize(__sb->egptr()
164 - __sb->gptr()),
165 streamsize(__n - _M_gcount));
166 if (__size > 1)
167 {
168 __sb->__safe_gbump(__size);
169 _M_gcount += __size;
170 __c = __sb->sgetc();
171 }
172 else
173 {
174 ++_M_gcount;
175 __c = __sb->snextc();
176 }
177 }
178 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
179 && !traits_type::eq_int_type(__c, __eof))
180 {
181 _M_gcount =
182 __gnu_cxx::__numeric_traits<streamsize>::__min;
183 __large_ignore = true;
184 }
185 else
186 break;
187 }
188
189 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
190 {
191 if (__large_ignore)
192 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
193
194 if (traits_type::eq_int_type(__c, __eof))
195 __err |= ios_base::eofbit;
196 }
197 else if (_M_gcount < __n)
198 {
199 if (traits_type::eq_int_type(__c, __eof))
200 __err |= ios_base::eofbit;
201 }
202 }
203 __catch(__cxxabiv1::__forced_unwind&)
204 {
205 this->_M_setstate(ios_base::badbit);
206 __throw_exception_again;
207 }
208 __catch(...)
209 { this->_M_setstate(ios_base::badbit); }
210 if (__err)
211 this->setstate(__err);
212 }
213 return *this;
214 }
215 #endif
216
217 _GLIBCXX_END_NAMESPACE_VERSION
218 } // namespace std
219
220
221 // NB: These symbols renames should go into the shared library only,
222 // and only those shared libraries that support versioning.
223 #if defined(_GLIBCXX_SYMVER_GNU) && defined(_GLIBCXX_SHARED) \
224 && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE) \
225 && defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
226
227 /* gcc-3.4.4
228 _ZNSt19istreambuf_iteratorIcSt11char_traitsIcEEppEv
229 _ZNSt19istreambuf_iteratorIwSt11char_traitsIwEEppEv
230 */
231
232 namespace std _GLIBCXX_VISIBILITY(default)
233 {
234 _GLIBCXX_BEGIN_NAMESPACE_VERSION
235
236 template
237 istreambuf_iterator<char>&
238 istreambuf_iterator<char>::operator++();
239
240 #ifdef _GLIBCXX_USE_WCHAR_T
241 template
242 istreambuf_iterator<wchar_t>&
243 istreambuf_iterator<wchar_t>::operator++();
244 #endif
245
246 _GLIBCXX_END_NAMESPACE_VERSION
247 } // namespace std
248
249
250 /* gcc-4.0.0
251 _ZNSs4_Rep26_M_set_length_and_sharableEj
252 _ZNSs7_M_copyEPcPKcj
253 _ZNSs7_M_moveEPcPKcj
254 _ZNSs9_M_assignEPcjc
255 _ZNKSs11_M_disjunctEPKc
256 _ZNKSs15_M_check_lengthEjjPKc
257 _ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableEj
258 _ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKwj
259 _ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKwj
260 _ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPwjw
261 _ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw
262 _ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthEjjPKc
263
264 _ZNKSt13basic_fstreamIcSt11char_traitsIcEE7is_openEv
265 _ZNKSt13basic_fstreamIwSt11char_traitsIwEE7is_openEv
266 _ZNKSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv
267 _ZNKSt14basic_ifstreamIwSt11char_traitsIwEE7is_openEv
268 _ZNKSt14basic_ofstreamIcSt11char_traitsIcEE7is_openEv
269 _ZNKSt14basic_ofstreamIwSt11char_traitsIwEE7is_openEv
270
271 _ZNSi6ignoreEi
272 _ZNSi6ignoreEv
273 _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEi
274 _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEv
275
276 _ZNSt11char_traitsIcE2eqERKcS2_
277 _ZNSt11char_traitsIwE2eqERKwS2_
278 */
279 namespace std _GLIBCXX_VISIBILITY(default)
280 {
281 _GLIBCXX_BEGIN_NAMESPACE_VERSION
282
283 // std::char_traits is explicitly specialized
284 bool (* __p1)(const char&, const char&) = &char_traits<char>::eq;
285
286 // std::string
287 template
288 void
289 basic_string<char>::_M_copy(char*, const char*, size_t);
290
291 template
292 void
293 basic_string<char>::_M_move(char*, const char*, size_t);
294
295 template
296 void
297 basic_string<char>::_M_assign(char*, size_t, char);
298
299 template
300 bool
301 basic_string<char>::_M_disjunct(const char*) const;
302
303 template
304 void
305 basic_string<char>::_M_check_length(size_t, size_t, const char*) const;
306
307 template
308 void
309 basic_string<char>::_Rep::_M_set_length_and_sharable(size_t);
310
311
312 // std::istream
313 template
314 basic_istream<char>&
315 basic_istream<char>::ignore();
316
317 template
318 bool
319 basic_fstream<char>::is_open() const;
320
321 template
322 bool
323 basic_ifstream<char>::is_open() const;
324
325 template
326 bool
327 basic_ofstream<char>::is_open() const;
328
329 #ifdef _GLIBCXX_USE_WCHAR_T
330 bool (* __p2)(const wchar_t&, const wchar_t&) = &char_traits<wchar_t>::eq;
331
332 // std::wstring
333 template
334 void
335 basic_string<wchar_t>::_M_copy(wchar_t*, const wchar_t*, size_t);
336
337 template
338 void
339 basic_string<wchar_t>::_M_move(wchar_t*, const wchar_t*, size_t);
340
341 template
342 void
343 basic_string<wchar_t>::_M_assign(wchar_t*, size_t, wchar_t);
344
345 template
346 bool
347 basic_string<wchar_t>::_M_disjunct(const wchar_t*) const;
348
349 template
350 void
351 basic_string<wchar_t>::_M_check_length(size_t, size_t,
352 const char*) const;
353
354 template
355 void
356 basic_string<wchar_t>::_Rep::_M_set_length_and_sharable(size_t);
357
358 template
359 basic_istream<wchar_t>&
360 basic_istream<wchar_t>::ignore();
361
362 template
363 bool
364 basic_fstream<wchar_t>::is_open() const;
365
366 template
367 bool
368 basic_ifstream<wchar_t>::is_open() const;
369
370 template
371 bool
372 basic_ofstream<wchar_t>::is_open() const;
373 #endif
374
375 _GLIBCXX_END_NAMESPACE_VERSION
376 } // namespace std
377
378 // The rename syntax for default exported names is
379 // asm (".symver name1,exportedname@GLIBCXX_3.4")
380 // asm (".symver name2,exportedname@@GLIBCXX_3.4.5")
381 // In the future, GLIBCXX_ABI > 6 should remove all uses of
382 // _GLIBCXX_*_SYMVER macros in this file.
383
384 #define _GLIBCXX_3_4_SYMVER(XXname, name) \
385 extern "C" void \
386 _X##name(...) \
387 __attribute__ ((alias(#XXname))); \
388 asm (".symver " "_X" #name "," #name "@GLIBCXX_3.4");
389
390 #define _GLIBCXX_3_4_5_SYMVER(XXname, name) \
391 extern "C" void \
392 _Y##name(...) \
393 __attribute__ ((alias(#XXname))); \
394 asm (".symver " "_Y" #name "," #name "@@GLIBCXX_3.4.5");
395
396 #define _GLIBCXX_ASM_SYMVER(cur, old, version) \
397 asm (".symver " #cur "," #old "@@" #version);
398
399 #define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_SYMVER
400 #include <bits/compatibility.h>
401 #undef _GLIBCXX_APPLY_SYMVER
402
403 #define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_5_SYMVER
404 #include <bits/compatibility.h>
405 #undef _GLIBCXX_APPLY_SYMVER
406
407
408 /* gcc-3.4.0
409 _ZN10__gnu_norm15_List_node_base4hookEPS0_;
410 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_;
411 _ZN10__gnu_norm15_List_node_base6unhookEv;
412 _ZN10__gnu_norm15_List_node_base7reverseEv;
413 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_;
414 */
415 #include "list.cc"
416 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX7_M_hookEPS0_, \
417 _ZN10__gnu_norm15_List_node_base4hookEPS0_, \
418 GLIBCXX_3.4)
419
420 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX4swapERS0_S1_, \
421 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \
422 GLIBCXX_3.4)
423
424 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX9_M_unhookEv, \
425 _ZN10__gnu_norm15_List_node_base6unhookEv, \
426 GLIBCXX_3.4)
427
428 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX10_M_reverseEv, \
429 _ZN10__gnu_norm15_List_node_base7reverseEv, \
430 GLIBCXX_3.4)
431
432 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX11_M_transferEPS0_S1_, \
433 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \
434 GLIBCXX_3.4)
435 #undef _List_node_base
436
437 // gcc-4.1.0
438 // Long double versions of "C" math functions.
439 #if defined (_GLIBCXX_LONG_DOUBLE_COMPAT) \
440 || (defined (__arm__) && defined (__linux__) && defined (__ARM_EABI__)) \
441 || (defined (__hppa__) && defined (__linux__)) \
442 || (defined (__m68k__) && defined (__mcoldfire__) && defined (__linux__)) \
443 || (defined (__mips__) && defined (_ABIO32) && defined (__linux__)) \
444 || (defined (__sh__) && defined (__linux__) && __SIZEOF_SIZE_T__ == 4) \
445
446 #define _GLIBCXX_MATHL_WRAPPER(name, argdecl, args, ver) \
447 extern "C" double \
448 __ ## name ## l_wrapper argdecl \
449 { \
450 return name args; \
451 } \
452 asm (".symver __" #name "l_wrapper, " #name "l@" #ver)
453
454 #define _GLIBCXX_MATHL_WRAPPER1(name, ver) \
455 _GLIBCXX_MATHL_WRAPPER (name, (double x), (x), ver)
456
457 #define _GLIBCXX_MATHL_WRAPPER2(name, ver) \
458 _GLIBCXX_MATHL_WRAPPER (name, (double x, double y), (x, y), ver)
459
460 #ifdef _GLIBCXX_HAVE_ACOSL
461 _GLIBCXX_MATHL_WRAPPER1 (acos, GLIBCXX_3.4.3);
462 #endif
463 #ifdef _GLIBCXX_HAVE_ASINL
464 _GLIBCXX_MATHL_WRAPPER1 (asin, GLIBCXX_3.4.3);
465 #endif
466 #ifdef _GLIBCXX_HAVE_ATAN2L
467 _GLIBCXX_MATHL_WRAPPER2 (atan2, GLIBCXX_3.4);
468 #endif
469 #ifdef _GLIBCXX_HAVE_ATANL
470 _GLIBCXX_MATHL_WRAPPER1 (atan, GLIBCXX_3.4.3);
471 #endif
472 #ifdef _GLIBCXX_HAVE_CEILL
473 _GLIBCXX_MATHL_WRAPPER1 (ceil, GLIBCXX_3.4.3);
474 #endif
475 #ifdef _GLIBCXX_HAVE_COSHL
476 _GLIBCXX_MATHL_WRAPPER1 (cosh, GLIBCXX_3.4);
477 #endif
478 #ifdef _GLIBCXX_HAVE_COSL
479 _GLIBCXX_MATHL_WRAPPER1 (cos, GLIBCXX_3.4);
480 #endif
481 #ifdef _GLIBCXX_HAVE_EXPL
482 _GLIBCXX_MATHL_WRAPPER1 (exp, GLIBCXX_3.4);
483 #endif
484 #ifdef _GLIBCXX_HAVE_FLOORL
485 _GLIBCXX_MATHL_WRAPPER1 (floor, GLIBCXX_3.4.3);
486 #endif
487 #ifdef _GLIBCXX_HAVE_FMODL
488 _GLIBCXX_MATHL_WRAPPER2 (fmod, GLIBCXX_3.4.3);
489 #endif
490 #ifdef _GLIBCXX_HAVE_FREXPL
491 _GLIBCXX_MATHL_WRAPPER (frexp, (double x, int *y), (x, y), GLIBCXX_3.4.3);
492 #endif
493 #ifdef _GLIBCXX_HAVE_HYPOTL
494 _GLIBCXX_MATHL_WRAPPER2 (hypot, GLIBCXX_3.4);
495 #endif
496 #ifdef _GLIBCXX_HAVE_LDEXPL
497 _GLIBCXX_MATHL_WRAPPER (ldexp, (double x, int y), (x, y), GLIBCXX_3.4.3);
498 #endif
499 #ifdef _GLIBCXX_HAVE_LOG10L
500 _GLIBCXX_MATHL_WRAPPER1 (log10, GLIBCXX_3.4);
501 #endif
502 #ifdef _GLIBCXX_HAVE_LOGL
503 _GLIBCXX_MATHL_WRAPPER1 (log, GLIBCXX_3.4);
504 #endif
505 #ifdef _GLIBCXX_HAVE_MODFL
506 _GLIBCXX_MATHL_WRAPPER (modf, (double x, double *y), (x, y), GLIBCXX_3.4.3);
507 #endif
508 #ifdef _GLIBCXX_HAVE_POWL
509 _GLIBCXX_MATHL_WRAPPER2 (pow, GLIBCXX_3.4);
510 #endif
511 #ifdef _GLIBCXX_HAVE_SINHL
512 _GLIBCXX_MATHL_WRAPPER1 (sinh, GLIBCXX_3.4);
513 #endif
514 #ifdef _GLIBCXX_HAVE_SINL
515 _GLIBCXX_MATHL_WRAPPER1 (sin, GLIBCXX_3.4);
516 #endif
517 #ifdef _GLIBCXX_HAVE_SQRTL
518 _GLIBCXX_MATHL_WRAPPER1 (sqrt, GLIBCXX_3.4);
519 #endif
520 #ifdef _GLIBCXX_HAVE_TANHL
521 _GLIBCXX_MATHL_WRAPPER1 (tanh, GLIBCXX_3.4);
522 #endif
523 #ifdef _GLIBCXX_HAVE_TANL
524 _GLIBCXX_MATHL_WRAPPER1 (tan, GLIBCXX_3.4);
525 #endif
526 #endif // _GLIBCXX_LONG_DOUBLE_COMPAT
527
528 #endif
529
530 #ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
531 extern void *_ZTVN10__cxxabiv123__fundamental_type_infoE[];
532 extern void *_ZTVN10__cxxabiv119__pointer_type_infoE[];
533 extern __attribute__((used, weak)) const char _ZTSe[2] = "e";
534 extern __attribute__((used, weak)) const char _ZTSPe[3] = "Pe";
535 extern __attribute__((used, weak)) const char _ZTSPKe[4] = "PKe";
536 extern __attribute__((used, weak)) const void * const _ZTIe[2]
537 = { reinterpret_cast<const void *>
538 (&_ZTVN10__cxxabiv123__fundamental_type_infoE[2]),
539 reinterpret_cast<const void *>(_ZTSe) };
540 extern __attribute__((used, weak)) const void * const _ZTIPe[4]
541 = { reinterpret_cast<const void *>
542 (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]),
543 reinterpret_cast<const void *>(_ZTSPe),
544 reinterpret_cast<const void *>(0L),
545 reinterpret_cast<const void *>(_ZTIe) };
546 extern __attribute__((used, weak)) const void * const _ZTIPKe[4]
547 = { reinterpret_cast<const void *>
548 (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]),
549 reinterpret_cast<const void *>(_ZTSPKe),
550 reinterpret_cast<const void *>(1L),
551 reinterpret_cast<const void *>(_ZTIe) };
552 #endif // _GLIBCXX_LONG_DOUBLE_COMPAT
553
554 #ifdef _GLIBCXX_SYMVER_DARWIN
555 #if (defined(__ppc__) || defined(__ppc64__)) && defined(_GLIBCXX_SHARED)
556 /* __eprintf shouldn't have been made visible from libstdc++, or
557 anywhere, but on Mac OS X 10.4 it was defined in
558 libstdc++.6.0.3.dylib; so on that platform we have to keep defining
559 it to keep binary compatibility. We can't just put the libgcc
560 version in the export list, because that doesn't work; once a
561 symbol is marked as hidden, it stays that way. */
562
563 #include <cstdio>
564 #include <cstdlib>
565
566 using namespace std;
567
568 extern "C" void
__eprintf(const char * string,const char * expression,unsigned int line,const char * filename)569 __eprintf(const char *string, const char *expression,
570 unsigned int line, const char *filename)
571 {
572 fprintf(stderr, string, expression, line, filename);
573 fflush(stderr);
574 abort();
575 }
576 #endif
577 #endif
578