1 // Compatibility symbols for previous versions -*- C++ -*- 2 3 // Copyright (C) 2005-2022 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>:: 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>:: 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 #ifdef _GLIBCXX_COMPAT_ 385 #define _GLIBCXX_3_4_SYMVER(XXname, name) \ 386 extern "C" void \ 387 _X##name(...) \ 388 __attribute__ ((alias(#XXname))); \ 389 asm (".symver " "_X" #name "," #name "@GLIBCXX_3.4"); 390 391 #define _GLIBCXX_3_4_5_SYMVER(XXname, name) \ 392 extern "C" void \ 393 _Y##name(...) \ 394 __attribute__ ((alias(#XXname))); \ 395 asm (".symver " "_Y" #name "," #name "@@GLIBCXX_3.4.5"); 396 397 #define _GLIBCXX_ASM_SYMVER(cur, old, version) \ 398 asm (".symver " #cur "," #old "@@" #version); 399 #else 400 #define _GLIBCXX_3_4_SYMVER(XXname, name) 401 #define _GLIBCXX_3_4_5_SYMVER(XXname, name) 402 #define _GLIBCXX_ASM_SYMVER(cur, old, version) 403 #endif 404 405 #define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_SYMVER 406 #include <abi/compatibility.h> 407 #undef _GLIBCXX_APPLY_SYMVER 408 409 #define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_5_SYMVER 410 #include <abi/compatibility.h> 411 #undef _GLIBCXX_APPLY_SYMVER 412 413 414 /* gcc-3.4.0 415 _ZN10__gnu_norm15_List_node_base4hookEPS0_; 416 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_; 417 _ZN10__gnu_norm15_List_node_base6unhookEv; 418 _ZN10__gnu_norm15_List_node_base7reverseEv; 419 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_; 420 */ 421 #include "list.cc" 422 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX7_M_hookEPS0_, \ 423 _ZN10__gnu_norm15_List_node_base4hookEPS0_, \ 424 GLIBCXX_3.4) 425 426 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX4swapERS0_S1_, \ 427 _ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \ 428 GLIBCXX_3.4) 429 430 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX9_M_unhookEv, \ 431 _ZN10__gnu_norm15_List_node_base6unhookEv, \ 432 GLIBCXX_3.4) 433 434 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX10_M_reverseEv, \ 435 _ZN10__gnu_norm15_List_node_base7reverseEv, \ 436 GLIBCXX_3.4) 437 438 _GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX11_M_transferEPS0_S1_, \ 439 _ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \ 440 GLIBCXX_3.4) 441 #undef _List_node_base 442 443 // gcc-4.1.0 444 // Long double versions of "C" math functions. 445 #if defined (_GLIBCXX_LONG_DOUBLE_COMPAT) \ 446 || (defined (__arm__) && defined (__linux__) && defined (__ARM_EABI__)) \ 447 || (defined (__hppa__) && defined (__linux__)) \ 448 || (defined (__m68k__) && defined (__mcoldfire__) && defined (__linux__)) \ 449 || (defined (__mips__) && defined (_ABIO32) && defined (__linux__)) \ 450 || (defined (__sh__) && defined (__linux__) && __SIZEOF_SIZE_T__ == 4) \ 451 452 #define _GLIBCXX_MATHL_WRAPPER(name, argdecl, args, ver) \ 453 extern "C" double \ 454 __ ## name ## l_wrapper argdecl \ 455 { \ 456 return name args; \ 457 } \ 458 asm (".symver __" #name "l_wrapper, " #name "l@" #ver) 459 460 #define _GLIBCXX_MATHL_WRAPPER1(name, ver) \ 461 _GLIBCXX_MATHL_WRAPPER (name, (double x), (x), ver) 462 463 #define _GLIBCXX_MATHL_WRAPPER2(name, ver) \ 464 _GLIBCXX_MATHL_WRAPPER (name, (double x, double y), (x, y), ver) 465 466 #ifdef _GLIBCXX_HAVE_ACOSL 467 _GLIBCXX_MATHL_WRAPPER1 (acos, GLIBCXX_3.4.3); 468 #endif 469 #ifdef _GLIBCXX_HAVE_ASINL 470 _GLIBCXX_MATHL_WRAPPER1 (asin, GLIBCXX_3.4.3); 471 #endif 472 #ifdef _GLIBCXX_HAVE_ATAN2L 473 _GLIBCXX_MATHL_WRAPPER2 (atan2, GLIBCXX_3.4); 474 #endif 475 #ifdef _GLIBCXX_HAVE_ATANL 476 _GLIBCXX_MATHL_WRAPPER1 (atan, GLIBCXX_3.4.3); 477 #endif 478 #ifdef _GLIBCXX_HAVE_CEILL 479 _GLIBCXX_MATHL_WRAPPER1 (ceil, GLIBCXX_3.4.3); 480 #endif 481 #ifdef _GLIBCXX_HAVE_COSHL 482 _GLIBCXX_MATHL_WRAPPER1 (cosh, GLIBCXX_3.4); 483 #endif 484 #ifdef _GLIBCXX_HAVE_COSL 485 _GLIBCXX_MATHL_WRAPPER1 (cos, GLIBCXX_3.4); 486 #endif 487 #ifdef _GLIBCXX_HAVE_EXPL 488 _GLIBCXX_MATHL_WRAPPER1 (exp, GLIBCXX_3.4); 489 #endif 490 #ifdef _GLIBCXX_HAVE_FLOORL 491 _GLIBCXX_MATHL_WRAPPER1 (floor, GLIBCXX_3.4.3); 492 #endif 493 #ifdef _GLIBCXX_HAVE_FMODL 494 _GLIBCXX_MATHL_WRAPPER2 (fmod, GLIBCXX_3.4.3); 495 #endif 496 #ifdef _GLIBCXX_HAVE_FREXPL 497 _GLIBCXX_MATHL_WRAPPER (frexp, (double x, int *y), (x, y), GLIBCXX_3.4.3); 498 #endif 499 #ifdef _GLIBCXX_HAVE_HYPOTL 500 _GLIBCXX_MATHL_WRAPPER2 (hypot, GLIBCXX_3.4); 501 #endif 502 #ifdef _GLIBCXX_HAVE_LDEXPL 503 _GLIBCXX_MATHL_WRAPPER (ldexp, (double x, int y), (x, y), GLIBCXX_3.4.3); 504 #endif 505 #ifdef _GLIBCXX_HAVE_LOG10L 506 _GLIBCXX_MATHL_WRAPPER1 (log10, GLIBCXX_3.4); 507 #endif 508 #ifdef _GLIBCXX_HAVE_LOGL 509 _GLIBCXX_MATHL_WRAPPER1 (log, GLIBCXX_3.4); 510 #endif 511 #ifdef _GLIBCXX_HAVE_MODFL 512 _GLIBCXX_MATHL_WRAPPER (modf, (double x, double *y), (x, y), GLIBCXX_3.4.3); 513 #endif 514 #ifdef _GLIBCXX_HAVE_POWL 515 _GLIBCXX_MATHL_WRAPPER2 (pow, GLIBCXX_3.4); 516 #endif 517 #ifdef _GLIBCXX_HAVE_SINHL 518 _GLIBCXX_MATHL_WRAPPER1 (sinh, GLIBCXX_3.4); 519 #endif 520 #ifdef _GLIBCXX_HAVE_SINL 521 _GLIBCXX_MATHL_WRAPPER1 (sin, GLIBCXX_3.4); 522 #endif 523 #ifdef _GLIBCXX_HAVE_SQRTL 524 _GLIBCXX_MATHL_WRAPPER1 (sqrt, GLIBCXX_3.4); 525 #endif 526 #ifdef _GLIBCXX_HAVE_TANHL 527 _GLIBCXX_MATHL_WRAPPER1 (tanh, GLIBCXX_3.4); 528 #endif 529 #ifdef _GLIBCXX_HAVE_TANL 530 _GLIBCXX_MATHL_WRAPPER1 (tan, GLIBCXX_3.4); 531 #endif 532 #endif // _GLIBCXX_LONG_DOUBLE_COMPAT 533 534 #endif 535 536 #ifdef _GLIBCXX_LONG_DOUBLE_COMPAT 537 extern void *_ZTVN10__cxxabiv123__fundamental_type_infoE[]; 538 extern void *_ZTVN10__cxxabiv119__pointer_type_infoE[]; 539 extern __attribute__((used, weak)) const char _ZTSe[2] = "e"; 540 extern __attribute__((used, weak)) const char _ZTSPe[3] = "Pe"; 541 extern __attribute__((used, weak)) const char _ZTSPKe[4] = "PKe"; 542 extern __attribute__((used, weak)) const void * const _ZTIe[2] 543 = { reinterpret_cast<const void *> 544 (&_ZTVN10__cxxabiv123__fundamental_type_infoE[2]), 545 reinterpret_cast<const void *>(_ZTSe) }; 546 extern __attribute__((used, weak)) const void * const _ZTIPe[4] 547 = { reinterpret_cast<const void *> 548 (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]), 549 reinterpret_cast<const void *>(_ZTSPe), 550 reinterpret_cast<const void *>(0L), 551 reinterpret_cast<const void *>(_ZTIe) }; 552 extern __attribute__((used, weak)) const void * const _ZTIPKe[4] 553 = { reinterpret_cast<const void *> 554 (&_ZTVN10__cxxabiv119__pointer_type_infoE[2]), 555 reinterpret_cast<const void *>(_ZTSPKe), 556 reinterpret_cast<const void *>(1L), 557 reinterpret_cast<const void *>(_ZTIe) }; 558 #endif // _GLIBCXX_LONG_DOUBLE_COMPAT 559 560 #ifdef _GLIBCXX_SYMVER_DARWIN 561 #if (defined(__ppc__) || defined(__ppc64__)) && defined(_GLIBCXX_SHARED) 562 /* __eprintf shouldn't have been made visible from libstdc++, or 563 anywhere, but on Mac OS X 10.4 it was defined in 564 libstdc++.6.0.3.dylib; so on that platform we have to keep defining 565 it to keep binary compatibility. We can't just put the libgcc 566 version in the export list, because that doesn't work; once a 567 symbol is marked as hidden, it stays that way. */ 568 569 #include <cstdio> 570 #include <cstdlib> 571 572 using namespace std; 573 574 extern "C" void 575 __eprintf(const char *string, const char *expression, 576 unsigned int line, const char *filename) 577 { 578 fprintf(stderr, string, expression, line, filename); 579 fflush(stderr); 580 abort(); 581 } 582 #endif 583 #endif 584