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