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