diff options
Diffstat (limited to '9/sources/cxx-stl/EH/gabi++/include')
25 files changed, 1983 insertions, 0 deletions
diff --git a/9/sources/cxx-stl/EH/gabi++/include/cassert b/9/sources/cxx-stl/EH/gabi++/include/cassert new file mode 100644 index 0000000..5753e34 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cassert @@ -0,0 +1,39 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Standard C++ Library wrapper around the C assert.h header file. This file + * can be included multiple times with different definition of NDEBUG, hence the + * absence of include guards. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CASSERT__ +#define BIONIC_LIBSTDCPP_INCLUDE_CASSERT__ +#endif +#include <assert.h> diff --git a/9/sources/cxx-stl/EH/gabi++/include/cctype b/9/sources/cxx-stl/EH/gabi++/include/cctype new file mode 100644 index 0000000..e0eb981 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cctype @@ -0,0 +1,60 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CCTYPE__ +#define BIONIC_LIBSTDCPP_INCLUDE_CCTYPE__ + +/* + * Standard C++ Library wrapper around the C ctype.h header file. + */ + +#include <ctype.h> + +extern "C++" { + +namespace std +{ +using ::isalnum; +using ::isalpha; +using ::iscntrl; +using ::isdigit; +using ::isgraph; +using ::islower; +using ::isprint; +using ::ispunct; +using ::isspace; +using ::isupper; +using ::isxdigit; +using ::tolower; +using ::toupper; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CCTYPE__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cerrno b/9/sources/cxx-stl/EH/gabi++/include/cerrno new file mode 100644 index 0000000..e53ca25 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cerrno @@ -0,0 +1,40 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CERRNO__ +#define BIONIC_LIBSTDCPP_INCLUDE_CERRNO__ + +/* + * Standard C++ Library wrapper around the C errno.h header file. + */ +#include <errno.h> + +// errno is a macro, so we can't define std::errno + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CERRNO__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cfloat b/9/sources/cxx-stl/EH/gabi++/include/cfloat new file mode 100644 index 0000000..21c01d9 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cfloat @@ -0,0 +1,39 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CFLOAT__ +#define BIONIC_LIBSTDCPP_INCLUDE_CFLOAT__ + +/* + * Standard C++ Library wrapper around the C float.h header file. + */ +#include <sys/limits.h> +#include <float.h> + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CFLOAT__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/climits b/9/sources/cxx-stl/EH/gabi++/include/climits new file mode 100644 index 0000000..df85cb9 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/climits @@ -0,0 +1,39 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CLIMITS__ +#define BIONIC_LIBSTDCPP_INCLUDE_CLIMITS__ + +/* + * Standard C++ Library wrapper around the C limits.h header file. + */ + +#include <limits.h> + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CLIMITS__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cmath b/9/sources/cxx-stl/EH/gabi++/include/cmath new file mode 100644 index 0000000..be70343 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cmath @@ -0,0 +1,75 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CMATH__ +#define BIONIC_LIBSTDCPP_INCLUDE_CMATH__ + +/* + * Standard C++ Library wrapper around the C time.h header file. + */ + +#include <cstddef> +#include <math.h> + +extern "C++" { + +namespace std +{ +// Functions. +using ::cos; +using ::sin; +using ::tan; +using ::acos; +using ::asin; +using ::atan; +using ::atan2; + +using ::cosh; +using ::sinh; +using ::tanh; + +using ::exp; +using ::frexp; +using ::ldexp; +using ::log; +using ::log10; +using ::modf; + +using ::pow; +using ::sqrt; + +using ::ceil; +using ::fabs; +using ::floor; +using ::fmod; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CMATH__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/csetjmp b/9/sources/cxx-stl/EH/gabi++/include/csetjmp new file mode 100644 index 0000000..ba82144 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/csetjmp @@ -0,0 +1,53 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSETJMP__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSETJMP__ + +/* + * Standard C++ Library wrapper around the C setjmp.h header file. + */ + +#include <setjmp.h> + +extern "C++" { + +#ifndef setjmp +#define setjmp(env) setjmp (env) +#endif + +namespace std +{ +using ::jmp_buf; +using ::longjmp; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSETJMP__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/csignal b/9/sources/cxx-stl/EH/gabi++/include/csignal new file mode 100644 index 0000000..84f0e1d --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/csignal @@ -0,0 +1,50 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSIGNAL__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSIGNAL__ + +/* + * Standard C++ Library wrapper around the C signal.h header file. + */ + +#include <signal.h> + +extern "C++" { + +namespace std +{ +using ::sig_atomic_t; +using ::signal; +using ::raise; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSIGNAL__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cstddef b/9/sources/cxx-stl/EH/gabi++/include/cstddef new file mode 100644 index 0000000..cb06b49 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cstddef @@ -0,0 +1,50 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSTDDEF__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSTDDEF__ + +/* + * Standard C++ Library wrapper around the C stddef.h header file. + * The following 2 types are also declared in the 'std' namespace: + * . ptrdiff_t + * . size_t + */ +#include <stddef.h> + +extern "C++" { + +namespace std { +using ::ptrdiff_t; +using ::size_t; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSTDDEF__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cstdint b/9/sources/cxx-stl/EH/gabi++/include/cstdint new file mode 100644 index 0000000..3df56df --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cstdint @@ -0,0 +1,40 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSTDINT__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSTDINT__ + +/* + * Standard C++ Library wrapper around the C stdint.h header file. + */ + +#include <stdint.h> + + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSTDINT__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cstdio b/9/sources/cxx-stl/EH/gabi++/include/cstdio new file mode 100644 index 0000000..3c8b5c6 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cstdio @@ -0,0 +1,96 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSTDIO__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSTDIO__ + +/* + * Standard C++ Library wrapper around the C stdio.h header file. + */ +#include <cstddef> +#include <stdio.h> + +extern "C++" { + +namespace std { +using ::FILE; +using ::fpos_t; + +using ::clearerr; +using ::fclose; +using ::feof; +using ::ferror; +using ::fflush; +using ::fgetc; +using ::fgetpos; +using ::fgets; +using ::fopen; +using ::fprintf; +using ::fputc; +using ::fputs; +using ::fread; +using ::freopen; +using ::fscanf; +using ::fseek; +using ::fsetpos; +using ::ftell; +using ::fwrite; +using ::getc; +using ::getchar; +using ::gets; +using ::perror; +using ::printf; +using ::putc; +using ::putchar; +using ::puts; +using ::remove; +using ::rename; +using ::rewind; +using ::scanf; +using ::setbuf; +using ::setvbuf; +using ::sprintf; +using ::sscanf; +using ::tmpfile; +using ::tmpnam; +using ::ungetc; +using ::vfprintf; +using ::vprintf; +using ::vsprintf; + +using ::snprintf; +using ::vfscanf; +using ::vscanf; +using ::vsnprintf; +using ::vsscanf; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSTDIO__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cstdlib b/9/sources/cxx-stl/EH/gabi++/include/cstdlib new file mode 100644 index 0000000..ef29fa7 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cstdlib @@ -0,0 +1,123 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSTDLIB__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSTDLIB__ + +/* + * Standard C++ Library wrapper around the C stdlib.h header file. + */ +#include <stdlib.h> + +extern "C++" { + +namespace std { + +using ::exit; +using ::abort; +using ::atexit; +#if 0 /* MISSING FROM BIONIC */ +using ::on_exit; +#endif + +using ::getenv; +using ::putenv; +using ::setenv; +using ::unsetenv; + +using ::mktemp; +using ::mkstemp; + +using ::strtol; +using ::strtoll; +using ::strtoul; +using ::strtoull; +using ::strtod; +using ::strtof; + +using ::atoi; +using ::atol; +using ::atoll; +using ::atof; + +using ::abs; +using ::labs; +using ::llabs; + +using ::realpath; +using ::system; + +using ::bsearch; +using ::qsort; + +using ::jrand48; +using ::mrand48; +using ::nrand48; +using ::lrand48; +using ::seed48; +using ::srand48; + +using ::rand; +using ::srand; +using ::random; +using ::srandom; + +using ::malloc; +using ::free; +using ::calloc; +using ::realloc; + +using ::unlockpt; +using ::ptsname; +using ::ptsname_r; +using ::getpt; +using ::grantpt; + +using ::div_t; +using ::div; +using ::ldiv_t; +using ::ldiv; +using ::lldiv_t; +using ::lldiv; + +using ::mblen; +using ::mbstowcs; +using ::mbtowc; +using ::wctomb; +using ::wcstombs; + +#if __ANDROID_API__ >= 9 +using ::clearenv; +#endif + +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSTDLIB__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cstring b/9/sources/cxx-stl/EH/gabi++/include/cstring new file mode 100644 index 0000000..d3d9387 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cstring @@ -0,0 +1,70 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CSTRING__ +#define BIONIC_LIBSTDCPP_INCLUDE_CSTRING__ + +/* + * Standard C++ Library wrapper around the C string.h header file. + */ + +#include <cstddef> +#include <string.h> + +extern "C++" { + +namespace std +{ +using ::memchr; +using ::memcmp; +using ::memcpy; +using ::memmove; +using ::memset; +using ::strcat; +using ::strchr; +using ::strcmp; +using ::strcoll; +using ::strcpy; +using ::strcspn; +using ::strerror; +using ::strlen; +using ::strncat; +using ::strncmp; +using ::strncpy; +using ::strpbrk; +using ::strrchr; +using ::strspn; +using ::strstr; +using ::strtok; +using ::strxfrm; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CSTRING__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/ctime b/9/sources/cxx-stl/EH/gabi++/include/ctime new file mode 100644 index 0000000..9e6744f --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/ctime @@ -0,0 +1,63 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BIONIC_LIBSTDCPP_INCLUDE_CTIME__ +#define BIONIC_LIBSTDCPP_INCLUDE_CTIME__ + +/* + * Standard C++ Library wrapper around the C time.h header file. + */ + +#include <cstddef> +#include <time.h> + +extern "C++" { + +namespace std +{ +// Types. +using ::clock_t; +using ::time_t; +using ::tm; + +// Functions. +using ::clock; +using ::difftime; +using ::mktime; +using ::time; +using ::asctime; +using ::ctime; +using ::gmtime; +using ::localtime; +using ::strftime; +} // namespace std + +} // extern C++ + +#endif // BIONIC_LIBSTDCPP_INCLUDE_CTIME__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cwchar b/9/sources/cxx-stl/EH/gabi++/include/cwchar new file mode 100644 index 0000000..a4f9f42 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cwchar @@ -0,0 +1,31 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* IMPORTANT: cwchar and cwctype are not supported. See comment in + * bionic/libc/include/wchar.h */ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cwctype_is_not_supported b/9/sources/cxx-stl/EH/gabi++/include/cwctype_is_not_supported new file mode 100644 index 0000000..a4f9f42 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cwctype_is_not_supported @@ -0,0 +1,31 @@ +/* -*- c++ -*- */ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* IMPORTANT: cwchar and cwctype are not supported. See comment in + * bionic/libc/include/wchar.h */ diff --git a/9/sources/cxx-stl/EH/gabi++/include/cxxabi.h b/9/sources/cxx-stl/EH/gabi++/include/cxxabi.h new file mode 100644 index 0000000..6f44bbe --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/cxxabi.h @@ -0,0 +1,362 @@ +// Copyright (C) 2011 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. +// + +#ifndef __GABIXX_CXXABI_H__ +#define __GABIXX_CXXABI_H__ + +#include <exception> +#include <stdint.h> +#include <typeinfo> +#include <unwind.h> + +namespace __cxxabiv1 +{ + // Derived types of type_info below are based on 2.9.5 of C++ ABI. + + class __shim_type_info : public std::type_info + { + public: + virtual ~__shim_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const = 0; + }; + + // Typeinfo for fundamental types. + class __fundamental_type_info : public __shim_type_info + { + public: + virtual ~__fundamental_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const; + }; + + // Typeinfo for array types. + class __array_type_info : public __shim_type_info + { + public: + virtual ~__array_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const; + }; + + // Typeinfo for function types. + class __function_type_info : public __shim_type_info + { + public: + virtual ~__function_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const; + }; + + // Typeinfo for enum types. + class __enum_type_info : public __shim_type_info + { + public: + virtual ~__enum_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const; + }; + + + class __class_type_info; + + // Used in __vmi_class_type_info + struct __base_class_type_info + { + public: + const __class_type_info *__base_type; + + long __offset_flags; + + enum __offset_flags_masks { + __virtual_mask = 0x1, + __public_mask = 0x2, + __offset_shift = 8 // lower 8 bits are flags + }; + + bool is_virtual() const { + return (__offset_flags & __virtual_mask) != 0; + } + + bool is_public() const { + return (__offset_flags & __public_mask) != 0; + } + + // FIXME: Right-shift of signed integer is implementation dependent. + // GCC Implement is as signed (as we expect) + long offset() const { + return __offset_flags >> __offset_shift; + } + + long flags() const { + return __offset_flags & ((1 << __offset_shift) - 1); + } + }; + + // Helper struct to support catch-clause match + struct __UpcastInfo { + enum ContainedStatus { + unknown = 0, + has_public_contained, + has_ambig_or_not_public + }; + + ContainedStatus status; + const __class_type_info* base_type; + void* adjustedPtr; + unsigned int premier_flags; + bool nullobj_may_conflict; + + __UpcastInfo(const __class_type_info* type); + }; + + // Typeinfo for classes with no bases. + class __class_type_info : public __shim_type_info + { + public: + virtual ~__class_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const; + + enum class_type_info_code { + CLASS_TYPE_INFO_CODE, + SI_CLASS_TYPE_INFO_CODE, + VMI_CLASS_TYPE_INFO_CODE + }; + + virtual class_type_info_code + code() const { return CLASS_TYPE_INFO_CODE; } + + virtual bool walk_to(const __class_type_info* base_type, + void*& adjustedPtr, + __UpcastInfo& info) const; + + protected: + bool self_class_type_match(const __class_type_info* base_type, + void*& adjustedPtr, + __UpcastInfo& info) const; + }; + + // Typeinfo for classes containing only a single, public, non-virtual base at + // offset zero. + class __si_class_type_info : public __class_type_info + { + public: + virtual ~__si_class_type_info(); + const __class_type_info *__base_type; + + virtual __class_type_info::class_type_info_code + code() const { return SI_CLASS_TYPE_INFO_CODE; } + + virtual bool walk_to(const __class_type_info* base_type, + void*& adjustedPtr, + __UpcastInfo& info) const; + }; + + + // Typeinfo for classes with bases that do not satisfy the + // __si_class_type_info constraints. + class __vmi_class_type_info : public __class_type_info + { + public: + virtual ~__vmi_class_type_info(); + unsigned int __flags; + unsigned int __base_count; + __base_class_type_info __base_info[1]; + + enum __flags_masks { + __non_diamond_repeat_mask = 0x1, + __diamond_shaped_mask = 0x2, + }; + + virtual __class_type_info::class_type_info_code + code() const { return VMI_CLASS_TYPE_INFO_CODE; } + + virtual bool walk_to(const __class_type_info* base_type, + void*& adjustedPtr, + __UpcastInfo& info) const; + }; + + class __pbase_type_info : public __shim_type_info + { + public: + virtual ~__pbase_type_info(); + virtual bool can_catch(const __shim_type_info* thrown_type, + void*& adjustedPtr) const; + unsigned int __flags; + const __shim_type_info* __pointee; + + enum __masks { + __const_mask = 0x1, + __volatile_mask = 0x2, + __restrict_mask = 0x4, + __incomplete_mask = 0x8, + __incomplete_class_mask = 0x10 + }; + + + virtual bool can_catch_typeinfo_wrapper(const __shim_type_info* thrown_type, + void*& adjustedPtr, + unsigned tracker) const; + + protected: + enum __constness_tracker_status { + first_time_init = 0x1, + keep_constness = 0x2, + after_gap = 0x4 // after one non-const qualified, + // we cannot face const again in future + }; + + private: + bool can_catch_ptr(const __pbase_type_info *thrown_type, + void *&adjustedPtr, + unsigned tracker) const; + + // Return true if making decision done. + virtual bool do_can_catch_ptr(const __pbase_type_info* thrown_type, + void*& adjustedPtr, + unsigned tracker, + bool& result) const = 0; + }; + + class __pointer_type_info : public __pbase_type_info + { + public: + virtual ~__pointer_type_info(); + + private: + virtual bool do_can_catch_ptr(const __pbase_type_info* thrown_type, + void*& adjustedPtr, + unsigned tracker, + bool& result) const; + }; + + class __pointer_to_member_type_info : public __pbase_type_info + { + public: + __class_type_info* __context; + + virtual ~__pointer_to_member_type_info(); + + private: + virtual bool do_can_catch_ptr(const __pbase_type_info* thrown_type, + void*& adjustedPtr, + unsigned tracker, + bool& result) const; + }; + + + extern "C" { + + // Compatible with GNU C++ + const uint64_t __gxx_exception_class = 0x474E5543432B2B00LL; // GNUCC++\0 + + // TODO: Support dependent exception + // TODO: Support C++0x exception propagation + // http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html + struct __cxa_exception { + size_t referenceCount; + + std::type_info* exceptionType; + void (*exceptionDestructor)(void*); + std::unexpected_handler unexpectedHandler; + std::terminate_handler terminateHandler; + __cxa_exception* nextException; + + int handlerCount; +#ifdef __arm__ + /** + * ARM EHABI requires the unwind library to keep track of exceptions + * during cleanups. These support nesting, so we need to keep a list of + * them. + */ + __cxa_exception* nextCleanup; + int cleanupCount; +#endif + int handlerSwitchValue; + const uint8_t* actionRecord; + const uint8_t* languageSpecificData; + void* catchTemp; + void* adjustedPtr; + + _Unwind_Exception unwindHeader; // must be last + }; + + struct __cxa_eh_globals { + __cxa_exception* caughtExceptions; + unsigned int uncaughtExceptions; +#ifdef __arm__ + __cxa_exception* cleanupExceptions; +#endif + }; + + struct __cxa_thread_info { + std::unexpected_handler unexpectedHandler; + std::terminate_handler terminateHandler; + _Unwind_Exception* currentCleanup; + + __cxa_eh_globals globals; + }; + + __cxa_eh_globals* __cxa_get_globals(); + __cxa_eh_globals* __cxa_get_globals_fast(); + + void* __cxa_allocate_exception(size_t thrown_size); + void __cxa_free_exception(void* thrown_exception); + + void __cxa_throw(void* thrown_exception, std::type_info* tinfo, void (*dest)(void*)); + void __cxa_rethrow(); + + void* __cxa_begin_catch(void* exceptionObject); + void __cxa_end_catch(); + + bool __cxa_begin_cleanup(_Unwind_Exception*); + void __cxa_end_cleanup(); + + void __cxa_bad_cast(); + void __cxa_bad_typeid(); + + void* __cxa_get_exception_ptr(void* exceptionObject); + + void __cxa_pure_virtual(); + + // Missing libcxxabi functions. + bool __cxa_uncaught_exception() throw(); + void __cxa_decrement_exception_refcount(void* exceptionObject) throw(); + void __cxa_increment_exception_refcount(void* exceptionObject) throw(); + void __cxa_rethrow_primary_exception(void* exceptionObject); + void* __cxa_current_primary_exception() throw(); + + } // extern "C" + +} // namespace __cxxabiv1 + +namespace abi = __cxxabiv1; + +#endif /* defined(__GABIXX_CXXABI_H__) */ + diff --git a/9/sources/cxx-stl/EH/gabi++/include/exception b/9/sources/cxx-stl/EH/gabi++/include/exception new file mode 100644 index 0000000..d4019ce --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/exception @@ -0,0 +1,65 @@ +// Copyright (C) 2011 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +#ifndef __GABIXX_EXCEPTION__ +#define __GABIXX_EXCEPTION__ + +#if !defined(GABIXX_LIBCXX) + +namespace std { + + class exception { + public: + exception() throw(); + virtual ~exception() throw(); + virtual const char* what() const throw(); + }; + + class bad_exception : public exception { + public: + bad_exception() throw(); + virtual ~bad_exception() throw(); + virtual const char* what() const throw(); + }; + + typedef void (*terminate_handler)(); + terminate_handler get_terminate(); + terminate_handler set_terminate(terminate_handler f); + void terminate(); + + typedef void (*unexpected_handler)(); + unexpected_handler get_unexpected(); + unexpected_handler set_unexpected(unexpected_handler f); + void unexpected(); + + bool uncaught_exception() throw(); + +} // namespace std + +#endif // !defined(GABIXX_LIBCXX) + +#endif // __GABIXX_EXCEPTION__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/new b/9/sources/cxx-stl/EH/gabi++/include/new new file mode 100644 index 0000000..d66fef7 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/new @@ -0,0 +1,73 @@ +// Copyright (C) 2011 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. +// +// new: Dynamic storage management. + +#ifndef __GABIXX_NEW__ +#define __GABIXX_NEW__ + +#if !defined(GABIXX_LIBCXX) + +#include <cstddef> +#include <exception> + +namespace std +{ + struct nothrow_t {}; + extern const nothrow_t nothrow; + typedef void (*new_handler)(); + +class bad_alloc : public exception { +public: + bad_alloc() throw(); + virtual ~bad_alloc() throw(); + virtual const char* what() const throw(); +}; + +typedef void (*new_handler)(); +new_handler set_new_handler(new_handler) throw(); + +} + +void* operator new(std::size_t size) throw(std::bad_alloc); +void* operator new(std::size_t size, const std::nothrow_t&) throw(); +void* operator new[](std::size_t size) throw(std::bad_alloc); +void* operator new[](std::size_t size, const std::nothrow_t&) throw(); + +void operator delete[](void* ptr) throw(); +void operator delete[](void* const, std::nothrow_t&) throw(); +void operator delete(void* ptr) throw(); +void operator delete(void*, const std::nothrow_t&) throw(); + +inline void* operator new(std::size_t, void* p) throw() { return p; } +inline void* operator new[](std::size_t, void* p) throw() { return p; } +inline void operator delete(void*, void*) throw() {} +inline void operator delete[](void*, void*) throw() {} + +#endif // !defined(GABIXX_LIBCXX) + +#endif // __GABIXX_NEW__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/stl_pair.h b/9/sources/cxx-stl/EH/gabi++/include/stl_pair.h new file mode 100644 index 0000000..648f213 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/stl_pair.h @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/* NOTE: This is an internal header file, included by other STL headers. + * You should not attempt to use it directly. + */ + +#ifndef __SGI_STL_INTERNAL_PAIR_H +#define __SGI_STL_INTERNAL_PAIR_H + +#ifndef __STL_BEGIN_NAMESPACE +#define __STL_BEGIN_NAMESPACE namespace std { +#endif + +#ifndef __STL_END_NAMESPACE +#define __STL_END_NAMESPACE } +#endif + +__STL_BEGIN_NAMESPACE + +template <class _T1, class _T2> +struct pair { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + pair() : first(), second() {} + pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {} + + template <class _U1, class _U2> + pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {} +}; + +template <class _T1, class _T2> +inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) +{ + return __x.first == __y.first && __x.second == __y.second; +} + +template <class _T1, class _T2> +inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) +{ + return __x.first < __y.first || + (!(__y.first < __x.first) && __x.second < __y.second); +} + +template <class _T1, class _T2> +inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { + return !(__x == __y); +} + +template <class _T1, class _T2> +inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { + return __y < __x; +} + +template <class _T1, class _T2> +inline bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { + return !(__y < __x); +} + +template <class _T1, class _T2> +inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { + return !(__x < __y); +} + +template <class _T1, class _T2> +inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y) +{ + return pair<_T1, _T2>(__x, __y); +} + +__STL_END_NAMESPACE + +#endif /* __SGI_STL_INTERNAL_PAIR_H */ + +// Local Variables: +// mode:C++ +// End: diff --git a/9/sources/cxx-stl/EH/gabi++/include/typeinfo b/9/sources/cxx-stl/EH/gabi++/include/typeinfo new file mode 100644 index 0000000..486eb40 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/typeinfo @@ -0,0 +1,98 @@ +// Copyright (C) 2011 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. +// +// typeinfo: RTTI support header. +// +// References: +// Itanium C++ ABI at http://www.codesourcery.com/public/cxx-abi/abi.html. +// IHI0041A C++ Application Binary Interface for the ARM architecture. +// Linux Standard Base C++ Specification for S390X 4.1. +// +#ifndef __GABIXX_TYPEINFO__ +#define __GABIXX_TYPEINFO__ + +#if !defined(GABIXX_LIBCXX) + +#include <exception> + +namespace std +{ + // Defintion of type_info based on example in C++ ABI section 2.9.3 + class type_info + { + public: + virtual + ~type_info(); + + // Whether two type_infos corresponds to the same types. + bool + operator==(const type_info &ti) const; + + // Whether two type_infos corresponds to the different types. + bool + operator!=(const type_info &ti) const; + + bool + before(const type_info &ti) const; + + // Return name of type. + const char* name() const { + // Compatible with GNU + return (__type_name[0] == '*') ? __type_name + 1 : __type_name; + } + + private: + // Assignment of type_info is not allowed. + type_info (const type_info& rhs); + + type_info& + operator=(const type_info& rhs); + + // Mangled name of type. + const char *__type_name; + }; + + + class bad_cast : public exception { + public: + bad_cast() throw(); + virtual ~bad_cast() throw(); + virtual const char* what() const throw(); + }; + + class bad_typeid : public exception { + public: + bad_typeid() throw(); + virtual ~bad_typeid() throw(); + virtual const char* what() const throw(); + }; + +} // namespace std + +#endif // !defined(GABIXX_LIBCXX) + +#endif // _GABIXX_TYPEINFO_ diff --git a/9/sources/cxx-stl/EH/gabi++/include/unwind-arm.h b/9/sources/cxx-stl/EH/gabi++/include/unwind-arm.h new file mode 100644 index 0000000..d3f697e --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/unwind-arm.h @@ -0,0 +1,170 @@ +// Copyright (C) 2012 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +#ifndef __GABIXX_UNWIND_ARM_H__ +#define __GABIXX_UNWIND_ARM_H__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + _URC_NO_REASON = 0, + _URC_FOREIGN_EXCEPTION_CAUGHT = 1, + _URC_FATAL_PHASE2_ERROR = 2, + _URC_FATAL_PHASE1_ERROR = 3, + _URC_END_OF_STACK = 5, + _URC_HANDLER_FOUND = 6, + _URC_INSTALL_CONTEXT = 7, + _URC_CONTINUE_UNWIND = 8, + _URC_FAILURE = 9, + _URC_OK = 0 +} _Unwind_Reason_Code; + +typedef uint32_t _Unwind_State; +static const _Unwind_State _US_VIRTUAL_UNWIND_FRAME = 0; +static const _Unwind_State _US_UNWIND_FRAME_STARTING = 1; +static const _Unwind_State _US_UNWIND_FRAME_RESUME = 2; + +typedef struct _Unwind_Control_Block _Unwind_Control_Block; +typedef struct _Unwind_Context _Unwind_Context; +typedef uint32_t _Unwind_EHT_Header; + +struct _Unwind_Control_Block { + uint64_t exception_class; // Compatible with Itanium ABI + void (*exception_cleanup)(_Unwind_Reason_Code, _Unwind_Control_Block*); + + struct { + uint32_t reserved1; // init reserved1 to 0, then don't touch + uint32_t reserved2; + uint32_t reserved3; + uint32_t reserved4; + uint32_t reserved5; + } unwinder_cache; + + struct { + uint32_t sp; + uint32_t bitpattern[5]; + } barrier_cache; + + struct { + uint32_t bitpattern[4]; + } cleanup_cache; + + struct { + uint32_t fnstart; // function start address + _Unwind_EHT_Header* ehtp; // pointer to EHT entry header word + uint32_t additional; // additional data + uint32_t reserved1; + } pr_cache; + + long long int : 0; // Force alignment of next item to 8-byte boundary +}; + +// This makes our code more simple +typedef _Unwind_Control_Block _Unwind_Exception; + +typedef enum { + _UVRSC_CORE = 0, // integer register + _UVRSC_VFP = 1, // vfp + _UVRSC_WMMXD = 3, // Intel WMMX data register + _UVRSC_WMMXC = 4 // Intel WMMX control register +} _Unwind_VRS_RegClass; + +typedef enum { + _UVRSD_UINT32 = 0, + _UVRSD_VFPX = 1, + _UVRSD_UINT64 = 3, + _UVRSD_FLOAT = 4, + _UVRSD_DOUBLE = 5 +} _Unwind_VRS_DataRepresentation; + +typedef enum { + _UVRSR_OK = 0, + _UVRSR_NOT_IMPLEMENTED = 1, + _UVRSR_FAILED = 2 +} _Unwind_VRS_Result; + +_Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception* ucbp); +void _Unwind_Resume(_Unwind_Exception* ucbp); +void _Unwind_Complete(_Unwind_Exception* ucbp); +void _Unwind_DeleteException(_Unwind_Exception* ucbp); +uint64_t _Unwind_GetRegionStart(_Unwind_Context*); +void* _Unwind_GetLanguageSpecificData(_Unwind_Context*); + + +_Unwind_VRS_Result _Unwind_VRS_Get(_Unwind_Context *context, + _Unwind_VRS_RegClass regclass, + uint32_t regno, + _Unwind_VRS_DataRepresentation representation, + void* valuep); + +_Unwind_VRS_Result _Unwind_VRS_Set(_Unwind_Context *context, + _Unwind_VRS_RegClass regclass, + uint32_t regno, + _Unwind_VRS_DataRepresentation representation, + void* valuep); + +/* + * Implement Itanium ABI based on ARM EHABI to simplify code + */ +typedef int _Unwind_Action; +static const _Unwind_Action _UA_SEARCH_PHASE = 1; +static const _Unwind_Action _UA_CLEANUP_PHASE = 2; +static const _Unwind_Action _UA_HANDLER_FRAME = 4; +static const _Unwind_Action _UA_FORCE_UNWIND = 8; + +#define UNWIND_POINTER_REG 12 +#define UNWIND_STACK_REG 13 +#define UNWIND_IP_REG 15 + +static inline uint32_t _Unwind_GetGR( _Unwind_Context* ctx, int reg) { + uint32_t val; + _Unwind_VRS_Get(ctx, _UVRSC_CORE, reg, _UVRSD_UINT32, &val); + return val; +} + +static inline void _Unwind_SetGR(_Unwind_Context* ctx, int reg, uint32_t val) { + _Unwind_VRS_Set(ctx, _UVRSC_CORE, reg, _UVRSD_UINT32, &val); +} + +static inline uint32_t _Unwind_GetIP(_Unwind_Context* ctx) { + return _Unwind_GetGR(ctx, UNWIND_IP_REG) & ~1; // thumb bit +} +static inline void _Unwind_SetIP(_Unwind_Context* ctx, uint32_t val) { + // Propagate thumb bit to instruction pointer + uint32_t thumbState = _Unwind_GetGR(ctx, UNWIND_IP_REG) & 1; + _Unwind_SetGR(ctx, UNWIND_IP_REG, (val | thumbState)); +} + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // __GABIXX_UNWIND_ARM_H__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/unwind-itanium.h b/9/sources/cxx-stl/EH/gabi++/include/unwind-itanium.h new file mode 100644 index 0000000..717cc56 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/unwind-itanium.h @@ -0,0 +1,111 @@ +// Copyright (C) 2012 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +#ifndef __GABIXX_UNWIND_ITANIUM_H__ +#define __GABIXX_UNWIND_ITANIUM_H__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + _URC_NO_REASON = 0, + _URC_FOREIGN_EXCEPTION_CAUGHT = 1, + _URC_FATAL_PHASE2_ERROR = 2, + _URC_FATAL_PHASE1_ERROR = 3, + _URC_NORMAL_STOP = 4, + _URC_END_OF_STACK = 5, + _URC_HANDLER_FOUND = 6, + _URC_INSTALL_CONTEXT = 7, + _URC_CONTINUE_UNWIND = 8 +} _Unwind_Reason_Code; + +typedef int _Unwind_Action; +static const _Unwind_Action _UA_SEARCH_PHASE = 1; +static const _Unwind_Action _UA_CLEANUP_PHASE = 2; +static const _Unwind_Action _UA_HANDLER_FRAME = 4; +static const _Unwind_Action _UA_FORCE_UNWIND = 8; + +struct _Unwind_Context; // system-specific opaque +struct _Unwind_Exception; + +typedef void (*_Unwind_Exception_Cleanup_Fn) (_Unwind_Reason_Code reason, + struct _Unwind_Exception* exc); + +typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn) (int version, + _Unwind_Action actions, + uint64_t exceptionClass, + struct _Unwind_Exception*, + struct _Unwind_Context*, + void* stop_parameter); + +struct _Unwind_Exception { + uint64_t exception_class; + _Unwind_Exception_Cleanup_Fn exception_cleanup; + uint32_t private_1; + uint32_t private_2; +} +#if defined(__clang__) && defined(__mips__) +// FIXME: It seems that mipsel-linux-android-gcc will use 24 as the object size +// with or without the aligned attribute. However, clang (mipsel) will align +// the object size to 32 when we specify the aligned attribute, which may +// result in some sort of incompatibility. As a workaround, let's remove this +// attribute when we are compiling this file for MIPS architecture with clang. +// Add the attribute back when clang can have same behavior as gcc. +#else +__attribute__((__aligned__)) // must be double-word aligned +#endif +; + +_Unwind_Reason_Code _Unwind_RaiseException(struct _Unwind_Exception*); +void _Unwind_Resume(struct _Unwind_Exception*); +void _Unwind_DeleteException(struct _Unwind_Exception*); + +uint64_t _Unwind_GetGR(struct _Unwind_Context*, int index); +void _Unwind_SetGR(struct _Unwind_Context*, int index, uint64_t new_value); + +uint64_t _Unwind_GetIP(struct _Unwind_Context*); +void _Unwind_SetIP(struct _Unwind_Context*, uintptr_t new_value); + +uint64_t _Unwind_GetRegionStart(struct _Unwind_Context*); +uint64_t _Unwind_GetLanguageSpecificData(struct _Unwind_Context*); + +_Unwind_Reason_Code _Unwind_ForcedUnwind(struct _Unwind_Exception*, + _Unwind_Stop_Fn stop, + void* stop_parameter); + +_Unwind_Reason_Code _Unwind_RaiseException(struct _Unwind_Exception*); +void _Unwind_Resume(struct _Unwind_Exception*); +void _Unwind_DeleteException(struct _Unwind_Exception*); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // __GABIXX_UNWIND_ITANIUM_H__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/unwind.h b/9/sources/cxx-stl/EH/gabi++/include/unwind.h new file mode 100644 index 0000000..c4d0732 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/unwind.h @@ -0,0 +1,37 @@ +// Copyright (C) 2012 The Android Open Source Project +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. Neither the name of the project nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +#ifndef __GABIXX_UNWIND_H__ +#define __GABIXX_UNWIND_H__ + +#ifdef __arm__ +# include "unwind-arm.h" +#else +# include "unwind-itanium.h" +#endif + +#endif // __GABIXX_UNWIND_H__ diff --git a/9/sources/cxx-stl/EH/gabi++/include/utility b/9/sources/cxx-stl/EH/gabi++/include/utility new file mode 100644 index 0000000..12044a7 --- /dev/null +++ b/9/sources/cxx-stl/EH/gabi++/include/utility @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _CPP_UTILITY +#define _CPP_UTILITY + +#pragma GCC system_header + +#define __STL_BEGIN_NAMESPACE namespace std { +#define __STL_END_NAMESPACE } + +#include <stl_pair.h> + +#endif /* _CPP_UTILITY */ |