1276630Skib// Compatibility symbols for previous versions -*- C++ -*- 2276630Skib 3276630Skib// Copyright (C) 2005-2020 Free Software Foundation, Inc. 4276630Skib// 5276630Skib// This file is part of the GNU ISO C++ Library. This library is free 6276630Skib// software; you can redistribute it and/or modify it under the 7276630Skib// terms of the GNU General Public License as published by the 8276630Skib// Free Software Foundation; either version 3, or (at your option) 9276630Skib// any later version. 10276630Skib 11276630Skib// This library is distributed in the hope that it will be useful, 12276630Skib// but WITHOUT ANY WARRANTY; without even the implied warranty of 13276630Skib// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14276630Skib// GNU General Public License for more details. 15276630Skib 16276630Skib// Under Section 7 of GPL version 3, you are granted additional 17276630Skib// permissions described in the GCC Runtime Library Exception, version 18276630Skib// 3.1, as published by the Free Software Foundation. 19276630Skib 20276630Skib// You should have received a copy of the GNU General Public License and 21276630Skib// a copy of the GCC Runtime Library Exception along with this program; 22276630Skib// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23276630Skib// <http://www.gnu.org/licenses/>. 24276630Skib 25276630Skib#define _GLIBCXX_USE_CXX11_ABI 0 26276630Skib#include <bits/c++config.h> 27276630Skib 28276630Skib#if defined(_GLIBCXX_SYMVER_GNU) && defined(_GLIBCXX_SHARED) \ 29276630Skib && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE)\ 30276630Skib && defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT) 31276630Skib#define istreambuf_iterator istreambuf_iteratorXX 32276630Skib#define basic_fstream basic_fstreamXX 33276630Skib#define basic_ifstream basic_ifstreamXX 34276630Skib#define basic_ofstream basic_ofstreamXX 35276630Skib#define _M_copy(a, b, c) _M_copyXX(a, b, c) 36276630Skib#define _M_move(a, b, c) _M_moveXX(a, b, c) 37276630Skib#define _M_assign(a, b, c) _M_assignXX(a, b, c) 38276630Skib#define _M_disjunct(a) _M_disjunctXX(a) 39276630Skib#define _M_check_length(a, b, c) _M_check_lengthXX(a, b, c) 40276630Skib#define _M_set_length_and_sharable(a) _M_set_length_and_sharableXX(a) 41276630Skib#define ignore ignoreXX 42276630Skib#define eq eqXX 43276630Skib#define _List_node_base _List_node_baseXX 44276630Skib#endif 45276630Skib 46276630Skib#include <string> 47276630Skib#include <istream> 48276630Skib#include <fstream> 49276630Skib#include <sstream> 50276630Skib#include <cmath> 51#include <ext/numeric_traits.h> 52 53namespace 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>:: 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>:: 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 216namespace 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 */ 263namespace 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#ifdef _GLIBCXX_COMPAT_ 369#define _GLIBCXX_3_4_SYMVER(XXname, name) \ 370 extern "C" void \ 371 _X##name(...) \ 372 __attribute__ ((alias(#XXname))); \ 373 asm (".symver " "_X" #name "," #name "@GLIBCXX_3.4"); 374 375#define _GLIBCXX_3_4_5_SYMVER(XXname, name) \ 376 extern "C" void \ 377 _Y##name(...) \ 378 __attribute__ ((alias(#XXname))); \ 379 asm (".symver " "_Y" #name "," #name "@@GLIBCXX_3.4.5"); 380 381#define _GLIBCXX_ASM_SYMVER(cur, old, version) \ 382 asm (".symver " #cur "," #old "@@" #version); 383#else 384#define _GLIBCXX_3_4_SYMVER(XXname, name) 385#define _GLIBCXX_3_4_5_SYMVER(XXname, name) 386#define _GLIBCXX_ASM_SYMVER(cur, old, version) 387#endif 388 389#define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_SYMVER 390#include <abi/compatibility.h> 391#undef _GLIBCXX_APPLY_SYMVER 392 393#define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_5_SYMVER 394#include <abi/compatibility.h> 395#undef _GLIBCXX_APPLY_SYMVER 396 397 398/* gcc-3.4.0 399_ZN10__gnu_norm15_List_node_base4hookEPS0_; 400_ZN10__gnu_norm15_List_node_base4swapERS0_S1_; 401_ZN10__gnu_norm15_List_node_base6unhookEv; 402_ZN10__gnu_norm15_List_node_base7reverseEv; 403_ZN10__gnu_norm15_List_node_base8transferEPS0_S1_; 404*/ 405#include "list.cc" 406_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX7_M_hookEPS0_, \ 407_ZN10__gnu_norm15_List_node_base4hookEPS0_, \ 408GLIBCXX_3.4) 409 410_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX4swapERS0_S1_, \ 411_ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \ 412GLIBCXX_3.4) 413 414_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX9_M_unhookEv, \ 415_ZN10__gnu_norm15_List_node_base6unhookEv, \ 416GLIBCXX_3.4) 417 418_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX10_M_reverseEv, \ 419_ZN10__gnu_norm15_List_node_base7reverseEv, \ 420GLIBCXX_3.4) 421 422_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX11_M_transferEPS0_S1_, \ 423_ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \ 424GLIBCXX_3.4) 425#undef _List_node_base 426 427// gcc-4.1.0 428// Long double versions of "C" math functions. 429#if defined (_GLIBCXX_LONG_DOUBLE_COMPAT) \ 430 || (defined (__arm__) && defined (__linux__) && defined (__ARM_EABI__)) \ 431 || (defined (__hppa__) && defined (__linux__)) \ 432 || (defined (__m68k__) && defined (__mcoldfire__) && defined (__linux__)) \ 433 || (defined (__mips__) && defined (_ABIO32) && defined (__linux__)) \ 434 || (defined (__sh__) && defined (__linux__) && __SIZEOF_SIZE_T__ == 4) \ 435 436#define _GLIBCXX_MATHL_WRAPPER(name, argdecl, args, ver) \ 437extern "C" double \ 438__ ## name ## l_wrapper argdecl \ 439{ \ 440 return name args; \ 441} \ 442asm (".symver __" #name "l_wrapper, " #name "l@" #ver) 443 444#define _GLIBCXX_MATHL_WRAPPER1(name, ver) \ 445 _GLIBCXX_MATHL_WRAPPER (name, (double x), (x), ver) 446 447#define _GLIBCXX_MATHL_WRAPPER2(name, ver) \ 448 _GLIBCXX_MATHL_WRAPPER (name, (double x, double y), (x, y), ver) 449 450#ifdef _GLIBCXX_HAVE_ACOSL 451_GLIBCXX_MATHL_WRAPPER1 (acos, GLIBCXX_3.4.3); 452#endif 453#ifdef _GLIBCXX_HAVE_ASINL 454_GLIBCXX_MATHL_WRAPPER1 (asin, GLIBCXX_3.4.3); 455#endif 456#ifdef _GLIBCXX_HAVE_ATAN2L 457_GLIBCXX_MATHL_WRAPPER2 (atan2, GLIBCXX_3.4); 458#endif 459#ifdef _GLIBCXX_HAVE_ATANL 460_GLIBCXX_MATHL_WRAPPER1 (atan, GLIBCXX_3.4.3); 461#endif 462#ifdef _GLIBCXX_HAVE_CEILL 463_GLIBCXX_MATHL_WRAPPER1 (ceil, GLIBCXX_3.4.3); 464#endif 465#ifdef _GLIBCXX_HAVE_COSHL 466_GLIBCXX_MATHL_WRAPPER1 (cosh, GLIBCXX_3.4); 467#endif 468#ifdef _GLIBCXX_HAVE_COSL 469_GLIBCXX_MATHL_WRAPPER1 (cos, GLIBCXX_3.4); 470#endif 471#ifdef _GLIBCXX_HAVE_EXPL 472_GLIBCXX_MATHL_WRAPPER1 (exp, GLIBCXX_3.4); 473#endif 474#ifdef _GLIBCXX_HAVE_FLOORL 475_GLIBCXX_MATHL_WRAPPER1 (floor, GLIBCXX_3.4.3); 476#endif 477#ifdef _GLIBCXX_HAVE_FMODL 478_GLIBCXX_MATHL_WRAPPER2 (fmod, GLIBCXX_3.4.3); 479#endif 480#ifdef _GLIBCXX_HAVE_FREXPL 481_GLIBCXX_MATHL_WRAPPER (frexp, (double x, int *y), (x, y), GLIBCXX_3.4.3); 482#endif 483#ifdef _GLIBCXX_HAVE_HYPOTL 484_GLIBCXX_MATHL_WRAPPER2 (hypot, GLIBCXX_3.4); 485#endif 486#ifdef _GLIBCXX_HAVE_LDEXPL 487_GLIBCXX_MATHL_WRAPPER (ldexp, (double x, int y), (x, y), GLIBCXX_3.4.3); 488#endif 489#ifdef _GLIBCXX_HAVE_LOG10L 490_GLIBCXX_MATHL_WRAPPER1 (log10, GLIBCXX_3.4); 491#endif 492#ifdef _GLIBCXX_HAVE_LOGL 493_GLIBCXX_MATHL_WRAPPER1 (log, GLIBCXX_3.4); 494#endif 495#ifdef _GLIBCXX_HAVE_MODFL 496_GLIBCXX_MATHL_WRAPPER (modf, (double x, double *y), (x, y), GLIBCXX_3.4.3); 497#endif 498#ifdef _GLIBCXX_HAVE_POWL 499_GLIBCXX_MATHL_WRAPPER2 (pow, GLIBCXX_3.4); 500#endif 501#ifdef _GLIBCXX_HAVE_SINHL 502_GLIBCXX_MATHL_WRAPPER1 (sinh, GLIBCXX_3.4); 503#endif 504#ifdef _GLIBCXX_HAVE_SINL 505_GLIBCXX_MATHL_WRAPPER1 (sin, GLIBCXX_3.4); 506#endif 507#ifdef _GLIBCXX_HAVE_SQRTL 508_GLIBCXX_MATHL_WRAPPER1 (sqrt, GLIBCXX_3.4); 509#endif 510#ifdef _GLIBCXX_HAVE_TANHL 511_GLIBCXX_MATHL_WRAPPER1 (tanh, GLIBCXX_3.4); 512#endif 513#ifdef _GLIBCXX_HAVE_TANL 514_GLIBCXX_MATHL_WRAPPER1 (tan, GLIBCXX_3.4); 515#endif 516#endif // _GLIBCXX_LONG_DOUBLE_COMPAT 517 518#endif 519 520#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT 521extern void *_ZTVN10__cxxabiv123__fundamental_type_infoE[]; 522extern void *_ZTVN10__cxxabiv119__pointer_type_infoE[]; 523extern __attribute__((used, weak)) const char _ZTSe[2] = "e"; 524extern __attribute__((used, weak)) const char _ZTSPe[3] = "Pe"; 525extern __attribute__((used, weak)) const char _ZTSPKe[4] = "PKe"; 526extern __attribute__((used, weak)) const void * const _ZTIe[2] 527 = { reinterpret_cast<const void *> 528 (&_ZTVN10__cxxabiv123__fundamental_type_infoE[2]), 529 reinterpret_cast<const void *>(_ZTSe) }; 530extern __attribute__((used, weak)) const void * const _ZTIPe[4] 531 = { reinterpret_cast<const void *> 532 (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]), 533 reinterpret_cast<const void *>(_ZTSPe), 534 reinterpret_cast<const void *>(0L), 535 reinterpret_cast<const void *>(_ZTIe) }; 536extern __attribute__((used, weak)) const void * const _ZTIPKe[4] 537 = { reinterpret_cast<const void *> 538 (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]), 539 reinterpret_cast<const void *>(_ZTSPKe), 540 reinterpret_cast<const void *>(1L), 541 reinterpret_cast<const void *>(_ZTIe) }; 542#endif // _GLIBCXX_LONG_DOUBLE_COMPAT 543 544#ifdef _GLIBCXX_SYMVER_DARWIN 545#if (defined(__ppc__) || defined(__ppc64__)) && defined(_GLIBCXX_SHARED) 546/* __eprintf shouldn't have been made visible from libstdc++, or 547 anywhere, but on Mac OS X 10.4 it was defined in 548 libstdc++.6.0.3.dylib; so on that platform we have to keep defining 549 it to keep binary compatibility. We can't just put the libgcc 550 version in the export list, because that doesn't work; once a 551 symbol is marked as hidden, it stays that way. */ 552 553#include <cstdio> 554#include <cstdlib> 555 556using namespace std; 557 558extern "C" void 559__eprintf(const char *string, const char *expression, 560 unsigned int line, const char *filename) 561{ 562 fprintf(stderr, string, expression, line, filename); 563 fflush(stderr); 564 abort(); 565} 566#endif 567#endif 568