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