diff options
Diffstat (limited to 'gcc-4.9/libgcc/config/c6x')
22 files changed, 2328 insertions, 0 deletions
diff --git a/gcc-4.9/libgcc/config/c6x/c6x-abi.h b/gcc-4.9/libgcc/config/c6x/c6x-abi.h new file mode 100644 index 000000000..b68c60782 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/c6x-abi.h @@ -0,0 +1,108 @@ +/* Header file for C6X ABI versions of libgcc functions. + Copyright (C) 2011-2014 Free Software Foundation, Inc. + Contributed by Bernd Schmidt <bernds@codesourcery.com> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GCC is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License + along with GCC; see the file COPYING3. If not see + <http://www.gnu.org/licenses/>. */ + +/* Make __c6xabi_AEABI_NAME an alias for __GCC_NAME. */ +#define RENAME_LIBRARY(GCC_NAME, AEABI_NAME) \ + __asm__ (".globl\t__c6xabi_" #AEABI_NAME "\n" \ + ".set\t__c6xabi_" #AEABI_NAME \ + ", __gnu_" #GCC_NAME "\n"); + +/* Rename helper functions to the names specified in the C6000 ELF ABI. */ +#ifdef L_divsi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (divsi3, divi) +#endif +#ifdef L_divdi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (divdi3, divlli) +#endif +#ifdef L_udivsi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (udivsi3, divu) +#endif +#ifdef L_udivdi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (udivdi3, divull) +#endif +#ifdef L_udivmoddi4 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (udivmoddi4, divremull) +#endif +#ifdef L_modsi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (modsi3, remi) +#endif +#ifdef L_moddi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (moddi3, remlli) +#endif +#ifdef L_umodsi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (umodsi3, remu) +#endif +#ifdef L_umoddi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (umoddi3, remull) +#endif +#ifdef L_negdi2 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (negdi2, negll) +#endif +#ifdef L_muldi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (muldi3, mpyll) +#endif +#ifdef L_ashrdi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (ashrdi3, llshr) +#endif +#ifdef L_lshrdi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (lshrdi3, llshru) +#endif +#ifdef L_ashldi3 +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (ashldi3, llshl) +#endif + +/* The following are excluded from softfp due to softfp_exclude_libgcc2, + so we rename them here rather than in sfp-machine.h. */ +#ifdef L_fixdfdi +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixdfdi, fixdlli) +#endif +#ifdef L_fixunsdfsi +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixunsdfsi, fixdu) +#endif +#ifdef L_fixunsdfdi +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixunsdfdi, fixdull) +#endif +#ifdef L_fixsfdi +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixsfdi, fixflli) +#endif +#ifdef L_fixunssfsi +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixunssfsi, fixfu) +#endif +#ifdef L_fixunssfdi +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (fixunssfdi, fixfull) +#endif +#ifdef L_floatdidf +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (floatdidf, fltllid) +#endif +#ifdef L_floatundidf +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (floatundidf, fltulld) +#endif +#ifdef L_floatdisf +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (floatdisf, fltllif) +#endif +#ifdef L_floatundisf +#define DECLARE_LIBRARY_RENAMES RENAME_LIBRARY (floatundisf, fltullf) +#endif + +#define LIBGCC2_GNU_PREFIX diff --git a/gcc-4.9/libgcc/config/c6x/crti.S b/gcc-4.9/libgcc/config/c6x/crti.S new file mode 100644 index 000000000..938e410b8 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/crti.S @@ -0,0 +1,39 @@ +/* Copyright (C) 2010-2014 Free Software Foundation, Inc. + Contributed by Bernd Schmidt <bernds@codesourcery.com>. + +This file is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 3, or (at your option) any +later version. + +This file is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +/* + * This file just supplies function prologues for the .init and .fini + * sections. It is linked in before crtbegin.o. + */ + + .section .init + .globl _init + .type _init,@function +_init: + add .l2 -8, B15, B15 + stw .d2t2 B3,*+B15(4) + .section .fini + .globl _fini + .type _fini,@function +_fini: + add .l2 -8, B15, B15 + stw .d2t2 B3,*+B15(4) diff --git a/gcc-4.9/libgcc/config/c6x/crtn.S b/gcc-4.9/libgcc/config/c6x/crtn.S new file mode 100644 index 000000000..88e35ed85 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/crtn.S @@ -0,0 +1,41 @@ +/* Copyright (C) 2010-2014 Free Software Foundation, Inc. + Contributed by Bernd Schmidt <bernds@codesourcery.com>. + +This file is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 3, or (at your option) any +later version. + +This file is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +/* + * This file supplies function epilogues for the .init and .fini sections. + * It is linked in after all other files. + */ + + .section .init + ldw .d2t2 *+B15(4), B3 + add .d2 B15, 8, B15 + nop 3 + ret .s2 B3 + nop 5 + + .section .fini + ldw .d2t2 *+B15(4), B3 + add .d2 B15, 8, B15 + nop 3 + ret .s2 B3 + nop 5 + diff --git a/gcc-4.9/libgcc/config/c6x/eqd.c b/gcc-4.9/libgcc/config/c6x/eqd.c new file mode 100644 index 000000000..283b2214e --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/eqd.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a == b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/double.h> + +CMPtype __c6xabi_eqd(DFtype a, DFtype b) +{ + FP_DECL_EX; + FP_DECL_D(A); FP_DECL_D(B); + CMPtype r; + + FP_UNPACK_RAW_D(A, a); + FP_UNPACK_RAW_D(B, b); + FP_CMP_EQ_D(r, A, B); + if (r && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return !r; +} diff --git a/gcc-4.9/libgcc/config/c6x/eqf.c b/gcc-4.9/libgcc/config/c6x/eqf.c new file mode 100644 index 000000000..e99fc84a0 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/eqf.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a == b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/single.h> + +CMPtype __c6xabi_eqf(SFtype a, SFtype b) +{ + FP_DECL_EX; + FP_DECL_S(A); FP_DECL_S(B); + CMPtype r; + + FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S(B, b); + FP_CMP_EQ_S(r, A, B); + if (r && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return !r; +} diff --git a/gcc-4.9/libgcc/config/c6x/ged.c b/gcc-4.9/libgcc/config/c6x/ged.c new file mode 100644 index 000000000..29704cf6a --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/ged.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a >= b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/double.h> + +CMPtype __c6xabi_ged(DFtype a, DFtype b) +{ + FP_DECL_EX; + FP_DECL_D(A); FP_DECL_D(B); + CMPtype r; + + FP_UNPACK_RAW_D(A, a); + FP_UNPACK_RAW_D(B, b); + FP_CMP_D(r, A, B, -2); + if (r == -2 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r >= 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/gef.c b/gcc-4.9/libgcc/config/c6x/gef.c new file mode 100644 index 000000000..bd6f27d15 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/gef.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a >= b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/single.h> + +CMPtype __c6xabi_gef(SFtype a, SFtype b) +{ + FP_DECL_EX; + FP_DECL_S(A); FP_DECL_S(B); + CMPtype r; + + FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S(B, b); + FP_CMP_S(r, A, B, -2); + if (r == -2 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r >= 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/gtd.c b/gcc-4.9/libgcc/config/c6x/gtd.c new file mode 100644 index 000000000..6a9ca924f --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/gtd.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a > b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/double.h> + +CMPtype __c6xabi_gtd(DFtype a, DFtype b) +{ + FP_DECL_EX; + FP_DECL_D(A); FP_DECL_D(B); + CMPtype r; + + FP_UNPACK_RAW_D(A, a); + FP_UNPACK_RAW_D(B, b); + FP_CMP_D(r, A, B, -2); + if (r == -2 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r > 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/gtf.c b/gcc-4.9/libgcc/config/c6x/gtf.c new file mode 100644 index 000000000..a7db8f83c --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/gtf.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a > b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/single.h> + +CMPtype __c6xabi_gtf(SFtype a, SFtype b) +{ + FP_DECL_EX; + FP_DECL_S(A); FP_DECL_S(B); + CMPtype r; + + FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S(B, b); + FP_CMP_S(r, A, B, -2); + if (r == -2 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r > 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/led.c b/gcc-4.9/libgcc/config/c6x/led.c new file mode 100644 index 000000000..14c48d332 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/led.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a <= b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/double.h> + +CMPtype __c6xabi_led(DFtype a, DFtype b) +{ + FP_DECL_EX; + FP_DECL_D(A); FP_DECL_D(B); + CMPtype r; + + FP_UNPACK_RAW_D(A, a); + FP_UNPACK_RAW_D(B, b); + FP_CMP_D(r, A, B, 2); + if (r == 2 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r <= 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/lef.c b/gcc-4.9/libgcc/config/c6x/lef.c new file mode 100644 index 000000000..9742ae087 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/lef.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a <= b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/single.h> + +CMPtype __c6xabi_lef(SFtype a, SFtype b) +{ + FP_DECL_EX; + FP_DECL_S(A); FP_DECL_S(B); + CMPtype r; + + FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S(B, b); + FP_CMP_S(r, A, B, 2); + if (r == 2 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r <= 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/lib1funcs.S b/gcc-4.9/libgcc/config/c6x/lib1funcs.S new file mode 100644 index 000000000..9ce1f6fda --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/lib1funcs.S @@ -0,0 +1,438 @@ +/* Copyright (C) 2010-2014 Free Software Foundation, Inc. + Contributed by Bernd Schmidt <bernds@codesourcery.com>. + +This file is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 3, or (at your option) any +later version. + +This file is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + + ;; ABI considerations for the divide functions + ;; The following registers are call-used: + ;; __c6xabi_divi A0,A1,A2,A4,A6,B0,B1,B2,B4,B5 + ;; __c6xabi_divu A0,A1,A2,A4,A6,B0,B1,B2,B4 + ;; __c6xabi_remi A1,A2,A4,A5,A6,B0,B1,B2,B4 + ;; __c6xabi_remu A1,A4,A5,A7,B0,B1,B2,B4 + ;; + ;; In our implementation, divu and remu are leaf functions, + ;; while both divi and remi call into divu. + ;; A0 is not clobbered by any of the functions. + ;; divu does not clobber B2 either, which is taken advantage of + ;; in remi. + ;; divi uses B5 to hold the original return address during + ;; the call to divu. + ;; remi uses B2 and A5 to hold the input values during the + ;; call to divu. It stores B3 in on the stack. + +#ifdef L_divsi3 +.text +.align 2 +.global __c6xabi_divi +.hidden __c6xabi_divi +.type __c6xabi_divi, STT_FUNC + +__c6xabi_divi: + call .s2 __c6xabi_divu +|| mv .d2 B3, B5 +|| cmpgt .l1 0, A4, A1 +|| cmpgt .l2 0, B4, B1 + + [A1] neg .l1 A4, A4 +|| [B1] neg .l2 B4, B4 +|| xor .s1x A1, B1, A1 + +#ifdef _TMS320C6400 + [A1] addkpc .s2 1f, B3, 4 +#else + [A1] mvkl .s2 1f, B3 + [A1] mvkh .s2 1f, B3 + nop 2 +#endif +1: + neg .l1 A4, A4 +|| mv .l2 B3,B5 +|| ret .s2 B5 + nop 5 +#endif + +#if defined L_modsi3 || defined L_divmodsi4 +.align 2 +#ifdef L_modsi3 +#define MOD_OUTPUT_REG A4 +.global __c6xabi_remi +.hidden __c6xabi_remi +.type __c6xabi_remi, STT_FUNC +#else +#define MOD_OUTPUT_REG A5 +.global __c6xabi_divremi +.hidden __c6xabi_divremi +.type __c6xabi_divremi, STT_FUNC +__c6xabi_divremi: +#endif + +__c6xabi_remi: + stw .d2t2 B3, *B15--[2] +|| cmpgt .l1 0, A4, A1 +|| cmpgt .l2 0, B4, B2 +|| mv .s1 A4, A5 +|| call .s2 __c6xabi_divu + + [A1] neg .l1 A4, A4 +|| [B2] neg .l2 B4, B4 +|| xor .s2x B2, A1, B0 +|| mv .d2 B4, B2 + +#ifdef _TMS320C6400 + [B0] addkpc .s2 1f, B3, 1 + [!B0] addkpc .s2 2f, B3, 1 + nop 2 +#else + [B0] mvkl .s2 1f,B3 + [!B0] mvkl .s2 2f,B3 + + [B0] mvkh .s2 1f,B3 + [!B0] mvkh .s2 2f,B3 +#endif +1: + neg .l1 A4, A4 +2: + ldw .d2t2 *++B15[2], B3 + +#ifdef _TMS320C6400_PLUS + mpy32 .m1x A4, B2, A6 + nop 3 + ret .s2 B3 + sub .l1 A5, A6, MOD_OUTPUT_REG + nop 4 +#else + mpyu .m1x A4, B2, A1 + nop 1 + mpylhu .m1x A4, B2, A6 +|| mpylhu .m2x B2, A4, B2 + nop 1 + add .l1x A6, B2, A6 +|| ret .s2 B3 + shl .s1 A6, 16, A6 + add .d1 A6, A1, A6 + sub .l1 A5, A6, MOD_OUTPUT_REG + nop 2 +#endif + +#endif + +#if defined L_udivsi3 || defined L_udivmodsi4 +.align 2 +#ifdef L_udivsi3 +.global __c6xabi_divu +.hidden __c6xabi_divu +.type __c6xabi_divu, STT_FUNC +__c6xabi_divu: +#else +.global __c6xabi_divremu +.hidden __c6xabi_divremu +.type __c6xabi_divremu, STT_FUNC +__c6xabi_divremu: +#endif + ;; We use a series of up to 31 subc instructions. First, we find + ;; out how many leading zero bits there are in the divisor. This + ;; gives us both a shift count for aligning (shifting) the divisor + ;; to the, and the number of times we have to execute subc. + + ;; At the end, we have both the remainder and most of the quotient + ;; in A4. The top bit of the quotient is computed first and is + ;; placed in A2. + + ;; Return immediately if the dividend is zero. Setting B4 to 1 + ;; is a trick to allow us to leave the following insns in the jump + ;; delay slot without affecting the result. + mv .s2x A4, B1 + +#ifndef _TMS320C6400 +[!b1] mvk .s2 1, B4 +#endif +[b1] lmbd .l2 1, B4, B1 +||[!b1] b .s2 B3 ; RETURN A +#ifdef _TMS320C6400 +||[!b1] mvk .d2 1, B4 +#endif +#ifdef L_udivmodsi4 +||[!b1] zero .s1 A5 +#endif + mv .l1x B1, A6 +|| shl .s2 B4, B1, B4 + + ;; The loop performs a maximum of 28 steps, so we do the + ;; first 3 here. + cmpltu .l1x A4, B4, A2 +[!A2] sub .l1x A4, B4, A4 +|| shru .s2 B4, 1, B4 +|| xor .s1 1, A2, A2 + + shl .s1 A2, 31, A2 +|| [b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 + + ;; RETURN A may happen here (note: must happen before the next branch) +0: + cmpgt .l2 B1, 7, B0 +|| [b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +|| [b0] b .s1 0b +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 + ;; loop backwards branch happens here + + ret .s2 B3 +|| mvk .s1 32, A1 + sub .l1 A1, A6, A6 +#ifdef L_udivmodsi4 +|| extu .s1 A4, A6, A5 +#endif + shl .s1 A4, A6, A4 + shru .s1 A4, 1, A4 +|| sub .l1 A6, 1, A6 + or .l1 A2, A4, A4 + shru .s1 A4, A6, A4 + nop + +#endif + +#ifdef L_umodsi3 +.align 2 +.global __c6xabi_remu +.hidden __c6xabi_remu +.type __c6xabi_remu, STT_FUNC +__c6xabi_remu: + ;; The ABI seems designed to prevent these functions calling each other, + ;; so we duplicate most of the divsi3 code here. + mv .s2x A4, B1 +#ifndef _TMS320C6400 +[!b1] mvk .s2 1, B4 +#endif + lmbd .l2 1, B4, B1 +||[!b1] b .s2 B3 ; RETURN A +#ifdef _TMS320C6400 +||[!b1] mvk .d2 1, B4 +#endif + + mv .l1x B1, A7 +|| shl .s2 B4, B1, B4 + + cmpltu .l1x A4, B4, A1 +[!a1] sub .l1x A4, B4, A4 + shru .s2 B4, 1, B4 + +0: + cmpgt .l2 B1, 7, B0 +|| [b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 + ;; RETURN A may happen here (note: must happen before the next branch) +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +|| [b0] b .s1 0b +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 + ;; loop backwards branch happens here + + ret .s2 B3 +[b1] subc .l1x A4,B4,A4 +|| [b1] add .s2 -1, B1, B1 +[b1] subc .l1x A4,B4,A4 + + extu .s1 A4, A7, A4 + nop 2 +#endif + +#if defined L_strasgi_64plus && defined _TMS320C6400_PLUS + +.align 2 +.global __c6xabi_strasgi_64plus +.hidden __c6xabi_strasgi_64plus +.type __c6xabi_strasgi_64plus, STT_FUNC +__c6xabi_strasgi_64plus: + shru .s2x a6, 2, b31 +|| mv .s1 a4, a30 +|| mv .d2 b4, b30 + + add .s2 -4, b31, b31 + + sploopd 1 +|| mvc .s2 b31, ilc + ldw .d2t2 *b30++, b31 + nop 4 + mv .s1x b31,a31 + spkernel 6, 0 +|| stw .d1t1 a31, *a30++ + + ret .s2 b3 + nop 5 +#endif + +#ifdef L_strasgi +.global __c6xabi_strasgi +.type __c6xabi_strasgi, STT_FUNC +__c6xabi_strasgi: + ;; This is essentially memcpy, with alignment known to be at least + ;; 4, and the size a multiple of 4 greater than or equal to 28. + ldw .d2t1 *B4++, A0 +|| mvk .s2 16, B1 + ldw .d2t1 *B4++, A1 +|| mvk .s2 20, B2 +|| sub .d1 A6, 24, A6 + ldw .d2t1 *B4++, A5 + ldw .d2t1 *B4++, A7 +|| mv .l2x A6, B7 + ldw .d2t1 *B4++, A8 + ldw .d2t1 *B4++, A9 +|| mv .s2x A0, B5 +|| cmpltu .l2 B2, B7, B0 + +0: + stw .d1t2 B5, *A4++ +||[b0] ldw .d2t1 *B4++, A0 +|| mv .s2x A1, B5 +|| mv .l2 B7, B6 + +[b0] sub .d2 B6, 24, B7 +||[b0] b .s2 0b +|| cmpltu .l2 B1, B6, B0 + +[b0] ldw .d2t1 *B4++, A1 +|| stw .d1t2 B5, *A4++ +|| mv .s2x A5, B5 +|| cmpltu .l2 12, B6, B0 + +[b0] ldw .d2t1 *B4++, A5 +|| stw .d1t2 B5, *A4++ +|| mv .s2x A7, B5 +|| cmpltu .l2 8, B6, B0 + +[b0] ldw .d2t1 *B4++, A7 +|| stw .d1t2 B5, *A4++ +|| mv .s2x A8, B5 +|| cmpltu .l2 4, B6, B0 + +[b0] ldw .d2t1 *B4++, A8 +|| stw .d1t2 B5, *A4++ +|| mv .s2x A9, B5 +|| cmpltu .l2 0, B6, B0 + +[b0] ldw .d2t1 *B4++, A9 +|| stw .d1t2 B5, *A4++ +|| mv .s2x A0, B5 +|| cmpltu .l2 B2, B7, B0 + + ;; loop back branch happens here + + cmpltu .l2 B1, B6, B0 +|| ret .s2 b3 + +[b0] stw .d1t1 A1, *A4++ +|| cmpltu .l2 12, B6, B0 +[b0] stw .d1t1 A5, *A4++ +|| cmpltu .l2 8, B6, B0 +[b0] stw .d1t1 A7, *A4++ +|| cmpltu .l2 4, B6, B0 +[b0] stw .d1t1 A8, *A4++ +|| cmpltu .l2 0, B6, B0 +[b0] stw .d1t1 A9, *A4++ + + ;; return happens here + +#endif + +#ifdef _TMS320C6400_PLUS +#ifdef L_push_rts +.align 2 +.global __c6xabi_push_rts +.hidden __c6xabi_push_rts +.type __c6xabi_push_rts, STT_FUNC +__c6xabi_push_rts: + stw .d2t2 B14, *B15--[2] + stdw .d2t1 A15:A14, *B15-- +|| b .s2x A3 + stdw .d2t2 B13:B12, *B15-- + stdw .d2t1 A13:A12, *B15-- + stdw .d2t2 B11:B10, *B15-- + stdw .d2t1 A11:A10, *B15-- + stdw .d2t2 B3:B2, *B15-- +#endif + +#ifdef L_pop_rts +.align 2 +.global __c6xabi_pop_rts +.hidden __c6xabi_pop_rts +.type __c6xabi_pop_rts, STT_FUNC +__c6xabi_pop_rts: + lddw .d2t2 *++B15, B3:B2 + lddw .d2t1 *++B15, A11:A10 + lddw .d2t2 *++B15, B11:B10 + lddw .d2t1 *++B15, A13:A12 + lddw .d2t2 *++B15, B13:B12 + lddw .d2t1 *++B15, A15:A14 +|| b .s2 B3 + ldw .d2t2 *++B15[2], B14 + nop 4 +#endif + +#ifdef L_call_stub +.align 2 +.global __c6xabi_call_stub +.type __c6xabi_call_stub, STT_FUNC +__c6xabi_call_stub: + stw .d2t1 A2, *B15--[2] + stdw .d2t1 A7:A6, *B15-- +|| call .s2 B31 + stdw .d2t1 A1:A0, *B15-- + stdw .d2t2 B7:B6, *B15-- + stdw .d2t2 B5:B4, *B15-- + stdw .d2t2 B1:B0, *B15-- + stdw .d2t2 B3:B2, *B15-- +|| addkpc .s2 1f, B3, 0 +1: + lddw .d2t2 *++B15, B3:B2 + lddw .d2t2 *++B15, B1:B0 + lddw .d2t2 *++B15, B5:B4 + lddw .d2t2 *++B15, B7:B6 + lddw .d2t1 *++B15, A1:A0 + lddw .d2t1 *++B15, A7:A6 +|| b .s2 B3 + ldw .d2t1 *++B15[2], A2 + nop 4 +#endif + +#endif + diff --git a/gcc-4.9/libgcc/config/c6x/libgcc-eabi.ver b/gcc-4.9/libgcc/config/c6x/libgcc-eabi.ver new file mode 100644 index 000000000..01bff9447 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/libgcc-eabi.ver @@ -0,0 +1,103 @@ +# Copyright (C) 2011-2014 Free Software Foundation, Inc. +# +# This file is part of GCC. +# +# GCC is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GCC is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + +GCC_4.7.0 { + __c6xabi_strasgi + __c6xabi_call_stub + __c6xabi_mpyll + __c6xabi_negll + __c6xabi_llshru + __c6xabi_llshl + __c6xabi_llshr + __c6xabi_fixfu + __c6xabi_fixdu + __c6xabi_fixflli + __c6xabi_fixdlli + __c6xabi_fixfull + __c6xabi_fixdull + __c6xabi_fltllif + __c6xabi_fltllid + __c6xabi_fltullf + __c6xabi_fltulld + __c6xabi_divlli + __c6xabi_remlli + __c6xabi_divull + __c6xabi_remull + __c6xabi_divremull + __c6xabi_gef + __c6xabi_gtf + __c6xabi_lef + __c6xabi_ltf + __c6xabi_eqf + __c6xabi_ged + __c6xabi_gtd + __c6xabi_led + __c6xabi_ltd + __c6xabi_eqd + __c6xabi_addf + __c6xabi_divf + __c6xabi_neqf + __c6xabi_cmpf + __c6xabi_mpyf + __c6xabi_negf + __c6xabi_subf + __c6xabi_unordf + __c6xabi_fixfi + __c6xabi_fltif + __c6xabi_fltuf + __c6xabi_addd + __c6xabi_divd + __c6xabi_neqd + __c6xabi_cmpd + __c6xabi_mpyd + __c6xabi_negd + __c6xabi_subd + __c6xabi_unordd + __c6xabi_fixdi + __c6xabi_fltid + __c6xabi_fltud + __c6xabi_cvtfd + __c6xabi_cvtdf + __c6xabi_mulcf + __c6xabi_mulcd + __c6xabi_divcf + __c6xabi_divcd + + __gnu_ltsf2 + __gnu_ltdf2 + __gnu_gesf2 + __gnu_gedf2 + __gnu_gtsf2 + __gnu_gtdf2 + __gnu_eqsf2 + __gnu_eqdf2 + + # Exception-Handling + _Unwind_Complete + _Unwind_VRS_Get + _Unwind_VRS_Set + _Unwind_VRS_Pop + __c6xabi_unwind_cpp_pr0 + __c6xabi_unwind_cpp_pr1 + __c6xabi_unwind_cpp_pr2 + __c6xabi_unwind_cpp_pr3 + __c6xabi_unwind_cpp_pr4 + # The libstdc++ exception-handling personality routine uses this + # GNU-specific entry point. + __gnu_unwind_frame +} diff --git a/gcc-4.9/libgcc/config/c6x/libunwind.S b/gcc-4.9/libgcc/config/c6x/libunwind.S new file mode 100644 index 000000000..7e6498378 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/libunwind.S @@ -0,0 +1,133 @@ +.text +.macro do_call fn +#ifdef _TMS320C6400_PLUS + callp .s2 (\fn), B3 +#elif defined(_TMS320C6400) + call .s2 (\fn) + addkpc .s2 9f, B3, 0 + nop 4 +9f: +#else + call .s2 (\fn) + mhkl .s2 9f, B3 + mhkh .s2 9f, B3 + nop 3 +9f: +#endif +.endm +.align 2 +.global restore_core_regs +.type restore_core_regs, STT_FUNC +restore_core_regs: + mv .s2x A4, B4 + ldw .d1t1 *+A4[0], A0 + || ldw .d2t2 *++B4[16], B0 + ldw .d1t1 *+A4[1], A1 + || ldw .d2t2 *+B4[1], B1 + ldw .d1t1 *+A4[2], A2 + || ldw .d2t2 *+B4[2], B2 + ldw .d1t1 *+A4[3], A3 + || ldw .d2t2 *+B4[3], B3 + ;; Base registers are loaded later + ldw .d1t1 *+A4[5], A5 + || ldw .d2t2 *+B4[5], B5 + ldw .d1t1 *+A4[6], A6 + || ldw .d2t2 *+B4[6], B6 + ldw .d1t1 *+A4[7], A7 + || ldw .d2t2 *+B4[7], B7 + ldw .d1t1 *+A4[8], A8 + || ldw .d2t2 *+B4[8], B8 + ldw .d1t1 *+A4[9], A9 + || ldw .d2t2 *+B4[9], B9 + ;; load PC into B10 so that it is ready for the branch + ldw .d2t2 *+B4[16], B10 + ldw .d1t1 *+A4[11], A11 + || ldw .d2t2 *+B4[11], B11 + ldw .d1t1 *+A4[12], A12 + || ldw .d2t2 *+B4[12], B12 + ldw .d1t1 *+A4[13], A13 + || ldw .d2t2 *+B4[13], B13 + ldw .d1t1 *+A4[14], A14 + || ldw .d2t2 *+B4[14], B14 + ;; Loads have 4 delay slots. Take advantage of this to restore the + ;; scratch registers and stack pointer before the base registers + ;; disappear. We also need to make sure no interrupts occur, + ;; so put the whole thing in the delay slots of a dummy branch + ;; We can not move the ret earlier as that would cause it to occur + ;; before the last load completes + b .s1 (1f) + ldw .d1t1 *+A4[4], A4 + || ldw .d2t2 *+B4[4], B4 + ldw .d1t1 *+A4[15], A15 + || ldw .d2t2 *+B4[15], B15 + ret .s2 B10 + ldw .d1t1 *+A4[10], A10 + || ldw .d2t2 *+B4[10], B10 + nop 1 +1: + nop 3 +.size restore_core_regs, . - restore_core_regs + +.macro UNWIND_WRAPPER name argreg argside +.global \name +.type \name, STT_FUNC +\name: + # Create saved register state: flags,A0-A15,B0-B15,PC = 136 bytes. + # Plus 4 (rounded to 8) for saving return. + addk .s2 -144, B15 + stw .d2t1 A0, *+B15[2] + stw .d2t1 A1, *+B15[3] + stw .d2t1 A2, *+B15[4] + stw .d2t1 A3, *+B15[5] + stw .d2t1 A4, *+B15[6] + stw .d2t1 A5, *+B15[7] + stw .d2t1 A6, *+B15[8] + stw .d2t1 A7, *+B15[9] + stw .d2t1 A8, *+B15[10] + stw .d2t1 A9, *+B15[11] + stw .d2t1 A10, *+B15[12] + stw .d2t1 A11, *+B15[13] + stw .d2t1 A12, *+B15[14] + stw .d2t1 A13, *+B15[15] + stw .d2t1 A14, *+B15[16] + stw .d2t1 A15, *+B15[17] + mv .s1x B15, A0 + addk .s1 144, A0 + stw .d2t2 B0, *+B15[18] + stw .d2t2 B1, *+B15[19] + stw .d2t2 B2, *+B15[20] + stw .d2t2 B3, *+B15[21] + stw .d2t2 B4, *+B15[22] + stw .d2t2 B5, *+B15[23] + stw .d2t2 B6, *+B15[24] + stw .d2t2 B7, *+B15[25] + stw .d2t2 B8, *+B15[26] + stw .d2t2 B9, *+B15[27] + stw .d2t2 B10, *+B15[28] + stw .d2t2 B11, *+B15[29] + stw .d2t2 B12, *+B15[30] + stw .d2t2 B13, *+B15[31] + stw .d2t2 B14, *+B15[32] + stw .d2t1 A0, *+B15[33] + stw .d2t1 A0, *+B15[34] + # Zero demand saved flags + mvk .s1 0, A0 + stw .d2t1 A0, *+B15[1] + # Save return address, setup additional argument and call function + stw .d2t2 B3, *+B15[35] + add .d\argside B15, 4, \argreg + do_call __gnu\name + # Restore stack and return + ldw .d2t2 *+B15[35], B3 + addk .s2 144, B15 + nop 3 + ret .s2 B3 + nop 5 +.size \name, . - \name +.endm + +UNWIND_WRAPPER _Unwind_RaiseException B4 2 +UNWIND_WRAPPER _Unwind_Resume B4 2 +UNWIND_WRAPPER _Unwind_Resume_or_Rethrow B4 2 +UNWIND_WRAPPER _Unwind_ForcedUnwind B6 2 +UNWIND_WRAPPER _Unwind_Backtrace A6 1x diff --git a/gcc-4.9/libgcc/config/c6x/ltd.c b/gcc-4.9/libgcc/config/c6x/ltd.c new file mode 100644 index 000000000..ca8148fcd --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/ltd.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a < b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/double.h> + +CMPtype __c6xabi_ltd(DFtype a, DFtype b) +{ + FP_DECL_EX; + FP_DECL_D(A); FP_DECL_D(B); + CMPtype r; + + FP_UNPACK_RAW_D(A, a); + FP_UNPACK_RAW_D(B, b); + FP_CMP_D(r, A, B, 2); + if (r == 2 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r < 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/ltf.c b/gcc-4.9/libgcc/config/c6x/ltf.c new file mode 100644 index 000000000..ab7080baa --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/ltf.c @@ -0,0 +1,47 @@ +/* Software floating-point emulation. + Return 1 iff a < b, 0 otherwise. + Copyright (C) 1997-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson (rth@cygnus.com) and + Jakub Jelinek (jj@ultra.linux.cz). + + This file is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#include <soft-fp/soft-fp.h> +#include <soft-fp/single.h> + +CMPtype __c6xabi_ltf(SFtype a, SFtype b) +{ + FP_DECL_EX; + FP_DECL_S(A); FP_DECL_S(B); + CMPtype r; + + FP_UNPACK_RAW_S(A, a); + FP_UNPACK_RAW_S(B, b); + FP_CMP_S(r, A, B, 2); + if (r == 2 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B))) + FP_SET_EXCEPTION(FP_EX_INVALID); + FP_HANDLE_EXCEPTIONS; + + return r < 0; +} diff --git a/gcc-4.9/libgcc/config/c6x/pr-support.c b/gcc-4.9/libgcc/config/c6x/pr-support.c new file mode 100644 index 000000000..99f44d397 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/pr-support.c @@ -0,0 +1,535 @@ +/* C6X ABI compliant unwinding routines + Copyright (C) 2011-2014 Free Software Foundation, Inc. + + This file is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 3, or (at your option) any + later version. + + This file is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + <http://www.gnu.org/licenses/>. */ + +#include "unwind.h" + +/* We add a prototype for abort here to avoid creating a dependency on + target headers. */ +extern void abort (void); + +typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */ + +/* Misc constants. */ +#define R_A0 0 +#define R_A1 1 +#define R_A2 2 +#define R_A3 3 +#define R_A4 4 +#define R_A5 5 +#define R_A6 6 +#define R_A7 7 +#define R_A8 8 +#define R_A9 9 +#define R_A10 10 +#define R_A11 11 +#define R_A12 12 +#define R_A13 13 +#define R_A14 14 +#define R_A15 15 +#define R_B0 16 +#define R_B1 17 +#define R_B2 18 +#define R_B3 19 +#define R_B4 20 +#define R_B5 21 +#define R_B6 22 +#define R_B7 23 +#define R_B8 24 +#define R_B9 25 +#define R_B10 26 +#define R_B11 27 +#define R_B12 28 +#define R_B13 29 +#define R_B14 30 +#define R_B15 31 + +#define R_SP R_B15 +#define R_PC 33 + +#define uint32_highbit (((_uw) 1) << 31) + +void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp); + +/* Unwind descriptors. */ + +typedef struct +{ + _uw16 length; + _uw16 offset; +} EHT16; + +typedef struct +{ + _uw length; + _uw offset; +} EHT32; + +/* Calculate the address encoded by a 31-bit self-relative offset at address + P. Copy of routine in unwind-arm.c. */ + +static inline _uw +selfrel_offset31 (const _uw *p) +{ + _uw offset; + + offset = *p; + /* Sign extend to 32 bits. */ + if (offset & (1 << 30)) + offset |= 1u << 31; + + return offset + (_uw) p; +} + + +/* Personality routine helper functions. */ + +#define CODE_FINISH (0xe7) + +/* Return the next byte of unwinding information, or CODE_FINISH if there is + no data remaining. */ +static inline _uw8 +next_unwind_byte (__gnu_unwind_state * uws) +{ + _uw8 b; + + if (uws->bytes_left == 0) + { + /* Load another word */ + if (uws->words_left == 0) + return CODE_FINISH; /* Nothing left. */ + uws->words_left--; + uws->data = *(uws->next++); + uws->bytes_left = 3; + } + else + uws->bytes_left--; + + /* Extract the most significant byte. */ + b = (uws->data >> 24) & 0xff; + uws->data <<= 8; + return b; +} + +static void +unwind_restore_pair (_Unwind_Context * context, int reg, _uw *ptr) +{ +#ifdef _BIG_ENDIAN + _Unwind_VRS_Set (context, _UVRSC_CORE, reg, _UVRSD_UINT32, ptr + 1); + _Unwind_VRS_Set (context, _UVRSC_CORE, reg + 1, _UVRSD_UINT32, ptr); +#else + _Unwind_VRS_Set (context, _UVRSC_CORE, reg, _UVRSD_UINT32, ptr); + _Unwind_VRS_Set (context, _UVRSC_CORE, reg + 1, _UVRSD_UINT32, ptr + 1); +#endif +} + +static const int +unwind_frame_regs[13] = +{ + R_A15, R_B15, R_B14, R_B13, R_B12, R_B11, R_B10, R_B3, + R_A14, R_A13, R_A12, R_A11, R_A10 +}; + +static void +pop_compact_frame (_Unwind_Context * context, _uw mask, _uw *ptr, int inc_sp) +{ + int size; + _uw test; + int i, regno, nregs; + + size = 0; + nregs = __builtin_popcount (mask); + for (i = 0; i < 13; i++) + { + test = 1 << i; + if ((mask & test) == 0) + continue; + + regno = unwind_frame_regs[12 - i]; + + if (i < 12 && nregs > 2 + && (mask & (test << 1)) != 0 + && unwind_frame_regs[11 - i] == regno + 1 + && (regno & 1) == 0) + { + i++; + nregs--; + } + + nregs--; + size += 2; + } + + if (!inc_sp) + ptr -= size; + + /* SP points just past the end of the stack. */ + ptr += 2; + nregs = __builtin_popcount (mask); + for (i = 0; i < 13; i++) + { + test = 1 << i; + if ((mask & test) == 0) + continue; + + regno = unwind_frame_regs[12 - i]; + + if (i < 12 && nregs > 2 + && (mask & (test << 1)) != 0 + && unwind_frame_regs[11 - i] == regno + 1 + && (regno & 1) == 0) + { + /* Register pair. */ + unwind_restore_pair (context, regno, ptr); + i++; + nregs--; + } + else + { + /* Single register with padding. */ + _Unwind_VRS_Set (context, _UVRSC_CORE, regno, _UVRSD_UINT32, ptr); + } + + nregs--; + ptr += 2; + } + + ptr -= 2; + if ((mask & (1 << 11)) == 0) + _Unwind_VRS_Set (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); +} + +static void +pop_frame (_Unwind_Context * context, _uw mask, _uw *ptr, int inc_sp) +{ + int i; + int regno; + int nregs; + + nregs = __builtin_popcount (mask); + + if (!inc_sp) + ptr -= nregs; + else if (nregs & 1) + ptr++; + + ptr++; + for (i = 0; i < 13; i++) + { + if ((mask & (1 << i)) == 0) + continue; + regno = unwind_frame_regs[12 - i]; + if (i < 12 && unwind_frame_regs[11 - i] == (regno + 1) + && (mask & (1 << (i + 1))) != 0 + && (((_uw)ptr) & 4) == 0 + && (regno & 1) == 0) + { + unwind_restore_pair (context, regno, ptr); + i++; + ptr += 2; + } + else + { + _Unwind_VRS_Set (context, _UVRSC_CORE, regno, _UVRSD_UINT32, + ptr); + ptr++; + } + } + + ptr--; + if ((mask & (1 << 11)) == 0) + _Unwind_VRS_Set (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); +} + +/* Unwind a 24-bit encoded frame. */ +_Unwind_Reason_Code +__gnu_unwind_24bit (_Unwind_Context * context, _uw data, int compact) +{ + _uw offset; + _uw mask; + _uw *ptr; + _uw tmp; + int ret_reg = unwind_frame_regs[data & 0xf]; + + if (ret_reg != R_B3) + { + _Unwind_VRS_Get (context, _UVRSC_CORE, unwind_frame_regs[data & 0xf], + _UVRSD_UINT32, &tmp); + _Unwind_VRS_Set (context, _UVRSC_CORE, R_B3, _UVRSD_UINT32, &tmp); + } + + mask = (data >> 4) & 0x1fff; + + offset = (data >> 17) & 0x7f; + if (offset == 0x7f) + _Unwind_VRS_Get (context, _UVRSC_CORE, R_A15, _UVRSD_UINT32, &ptr); + else + { + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); + ptr += offset * 2; + } + + + if (compact) + pop_compact_frame (context, mask, ptr, offset != 0x7f); + else + pop_frame (context, mask, ptr, offset != 0x7f); + + _Unwind_VRS_Get (context, _UVRSC_CORE, R_B3, _UVRSD_UINT32, &tmp); + _Unwind_VRS_Set (context, _UVRSC_CORE, R_PC, _UVRSD_UINT32, &tmp); + + return _URC_OK; +} + +static void +unwind_pop_rts (_Unwind_Context * context) +{ + _uw *ptr; + + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); +#ifdef _BIG_ENDIAN + _Unwind_VRS_Set (context, _UVRSC_CORE, R_B3, _UVRSD_UINT32, ptr + 1); +#else + _Unwind_VRS_Set (context, _UVRSC_CORE, R_B3, _UVRSD_UINT32, ptr + 2); +#endif + ptr += 3; + unwind_restore_pair (context, R_A10, ptr); + ptr += 2; + unwind_restore_pair (context, R_B10, ptr); + ptr += 2; + unwind_restore_pair (context, R_A12, ptr); + ptr += 2; + unwind_restore_pair (context, R_B12, ptr); + ptr += 2; + unwind_restore_pair (context, R_A14, ptr); + ptr += 2; + _Unwind_VRS_Set (context, _UVRSC_CORE, R_B14, _UVRSD_UINT32, ptr); + _Unwind_VRS_Set (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); + /* PC will be set by implicit RETURN opcode. */ +} + +/* Execute the unwinding instructions described by UWS. */ +_Unwind_Reason_Code +__gnu_unwind_execute (_Unwind_Context * context, __gnu_unwind_state * uws) +{ + _uw op; + int inc_sp; + _uw reg; + _uw *ptr; + + inc_sp = 1; + for (;;) + { + op = next_unwind_byte (uws); + if (op == CODE_FINISH) + { + /* Drop out of the loop. */ + break; + } + if ((op & 0xc0) == 0) + { + /* sp += (imm6 << 3) + 8. */ + _uw offset; + + offset = ((op & 0x3f) << 3) + 8; + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, ®); + reg += offset; + _Unwind_VRS_Set (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, ®); + continue; + } + + if (op == 0xd2) + { + /* vsp = vsp + 0x204 + (uleb128 << 2). */ + int shift; + + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, ®); + op = next_unwind_byte (uws); + shift = 3; + while (op & 0x80) + { + reg += ((op & 0x7f) << shift); + shift += 7; + op = next_unwind_byte (uws); + } + reg += ((op & 0x7f) << shift) + 0x408; + _Unwind_VRS_Set (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, ®); + continue; + } + + if ((op & 0xe0) == 0x80) + { + /* POP bitmask */ + _uw mask = ((op & 0x1f) << 8) | next_unwind_byte (uws); + + if (mask == 0) + { + /* CANTUNWIND */ + return _URC_FAILURE; + } + + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); + pop_frame (context, mask, ptr, inc_sp); + continue; + } + + if ((op & 0xe0) == 0xa0) + { + /* POP bitmask (compact) */ + _uw mask = ((op & 0x1f) << 8) | next_unwind_byte (uws); + + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); + pop_compact_frame (context, mask, ptr, inc_sp); + continue; + } + + if ((op & 0xf0) == 0xc0) + { + /* POP registers */ + int nregs = op & 0xf; + + _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &ptr); + while (nregs > 0) + { + op = next_unwind_byte (uws); + if ((op >> 4) != 0xf) + { + reg = unwind_frame_regs[op >> 4]; + _Unwind_VRS_Set (context, _UVRSC_CORE, reg, _UVRSD_UINT32, + ptr); + nregs--; + } + ptr--; + if ((op & 0xf) != 0xf) + { + reg = unwind_frame_regs[op & 0xf]; + _Unwind_VRS_Set (context, _UVRSC_CORE, reg, _UVRSD_UINT32, + ptr); + nregs--; + } + ptr--; + } + + continue; + } + + if (op == 0xd0) + { + /* MV FP, SP */ + inc_sp = 0; + _Unwind_VRS_Get (context, _UVRSC_CORE, R_A15, _UVRSD_UINT32, ®); + _Unwind_VRS_Set (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, ®); + continue; + } + + if (op == 0xd1) + { + /* __cx6abi_pop_rts */ + unwind_pop_rts (context); + break; + } + + if ((op & 0xf0) == 0xe0) + { + /* B3 = reg. RETURN case alreadh handled above. */ + int regno = unwind_frame_regs[op & 0xf]; + + _Unwind_VRS_Get (context, _UVRSC_CORE, regno, _UVRSD_UINT32, ®); + _Unwind_VRS_Set (context, _UVRSC_CORE, R_B3, _UVRSD_UINT32, ®); + continue; + } + + /* Reserved. */ + return _URC_FAILURE; + } + + /* Implicit RETURN. */ + _Unwind_VRS_Get (context, _UVRSC_CORE, R_B3, _UVRSD_UINT32, ®); + _Unwind_VRS_Set (context, _UVRSC_CORE, R_PC, _UVRSD_UINT32, ®); + return _URC_OK; +} + + +/* Execute the unwinding instructions associated with a frame. UCBP and + CONTEXT are the current exception object and virtual CPU state + respectively. */ + +_Unwind_Reason_Code +__gnu_unwind_frame (_Unwind_Control_Block * ucbp, _Unwind_Context * context) +{ + _uw *ptr; + __gnu_unwind_state uws; + + ptr = (_uw *) ucbp->pr_cache.ehtp; + /* Skip over the personality routine address. */ + ptr++; + /* Setup the unwinder state. */ + uws.data = (*ptr) << 8; + uws.next = ptr + 1; + uws.bytes_left = 3; + uws.words_left = ((*ptr) >> 24) & 0xff; + + return __gnu_unwind_execute (context, &uws); +} + +/* Data segment base pointer corresponding to the function catching + the exception. */ + +_Unwind_Ptr +_Unwind_GetDataRelBase (_Unwind_Context *context) +{ + return _Unwind_GetGR (context, R_B14); +} + +/* This should never be used. */ + +_Unwind_Ptr +_Unwind_GetTextRelBase (_Unwind_Context *context __attribute__ ((unused))) +{ + abort (); +} + +/* Only used by gcc personality routines, so can rely on a value they hid + there earlier. */ +_Unwind_Ptr +_Unwind_GetRegionStart (_Unwind_Context *context) +{ + _Unwind_Control_Block *ucbp; + + ucbp = (_Unwind_Control_Block *) _Unwind_GetGR (context, UNWIND_POINTER_REG); + return (_Unwind_Ptr) ucbp->pr_cache.fnstart; +} + +void * +_Unwind_GetLanguageSpecificData (_Unwind_Context *context) +{ + _Unwind_Control_Block *ucbp; + _uw *ptr; + + ucbp = (_Unwind_Control_Block *) _Unwind_GetGR (context, UNWIND_POINTER_REG); + ptr = (_uw *) ucbp->pr_cache.ehtp; + /* Skip the personality routine address. */ + ptr++; + /* Skip the unwind opcodes. */ + ptr += (((*ptr) >> 24) & 0xff) + 1; + + return ptr; +} diff --git a/gcc-4.9/libgcc/config/c6x/sfp-machine.h b/gcc-4.9/libgcc/config/c6x/sfp-machine.h new file mode 100644 index 000000000..9b7a02e9f --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/sfp-machine.h @@ -0,0 +1,124 @@ +/* Soft-FP definitions for TI C6X. + Copyright (C) 2010-2014 Free Software Foundation, Inc. + + This files is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + In addition to the permissions in the GNU Lesser General Public + License, the Free Software Foundation gives you unlimited + permission to link the compiled version of this file into + combinations with other programs, and to distribute those + combinations without any restriction coming from the use of this + file. (The Lesser General Public License restrictions do apply in + other respects; for example, they cover modification of the file, + and distribution when not linked into a combine executable.) + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with GCC; see the file COPYING.LIB. If not see + <http://www.gnu.org/licenses/>. */ + +#define _FP_W_TYPE_SIZE 32 +#define _FP_W_TYPE unsigned long +#define _FP_WS_TYPE signed long +#define _FP_I_TYPE long + +#define _FP_MUL_MEAT_S(R,X,Y) \ + _FP_MUL_MEAT_1_wide(_FP_WFRACBITS_S,R,X,Y,umul_ppmm) +#define _FP_MUL_MEAT_D(R,X,Y) \ + _FP_MUL_MEAT_2_wide(_FP_WFRACBITS_D,R,X,Y,umul_ppmm) +#define _FP_MUL_MEAT_Q(R,X,Y) \ + _FP_MUL_MEAT_4_wide(_FP_WFRACBITS_Q,R,X,Y,umul_ppmm) + +#define _FP_DIV_MEAT_S(R,X,Y) _FP_DIV_MEAT_1_loop(S,R,X,Y) +#define _FP_DIV_MEAT_D(R,X,Y) _FP_DIV_MEAT_2_udiv(D,R,X,Y) +#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_4_udiv(Q,R,X,Y) + +#define _FP_NANFRAC_H ((_FP_QNANBIT_H << 1) - 1) +#define _FP_NANFRAC_S ((_FP_QNANBIT_S << 1) - 1) +#define _FP_NANFRAC_D ((_FP_QNANBIT_D << 1) - 1), -1 +#define _FP_NANFRAC_Q ((_FP_QNANBIT_Q << 1) - 1), -1, -1, -1 +#define _FP_NANSIGN_H 0 +#define _FP_NANSIGN_S 0 +#define _FP_NANSIGN_D 0 +#define _FP_NANSIGN_Q 0 + +#define _FP_KEEPNANFRACP 1 +#define _FP_QNANNEGATEDP 0 + +/* Someone please check this. */ +#define _FP_CHOOSENAN(fs, wc, R, X, Y, OP) \ + do { \ + if ((_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs) \ + && !(_FP_FRAC_HIGH_RAW_##fs(Y) & _FP_QNANBIT_##fs)) \ + { \ + R##_s = Y##_s; \ + _FP_FRAC_COPY_##wc(R,Y); \ + } \ + else \ + { \ + R##_s = X##_s; \ + _FP_FRAC_COPY_##wc(R,X); \ + } \ + R##_c = FP_CLS_NAN; \ + } while (0) + +#define __LITTLE_ENDIAN 1234 +#define __BIG_ENDIAN 4321 + +#if defined _BIG_ENDIAN +# define __BYTE_ORDER __BIG_ENDIAN +#else +# define __BYTE_ORDER __LITTLE_ENDIAN +#endif + +/* Not checked. */ +#define _FP_TININESS_AFTER_ROUNDING 0 + + +/* Define ALIASNAME as a strong alias for NAME. */ +# define strong_alias(name, aliasname) _strong_alias(name, aliasname) +# define _strong_alias(name, aliasname) \ + extern __typeof (name) aliasname __attribute__ ((alias (#name))); + +/* Rename helper functions to the names specified in the C6000 ELF ABI. */ +#define __fixdfsi __c6xabi_fixdi +#define __fixsfsi __c6xabi_fixfi +#define __floatsidf __c6xabi_fltid +#define __floatunsidf __c6xabi_fltud +#define __floatsisf __c6xabi_fltif +#define __floatunsisf __c6xabi_fltuf +#define __truncdfsf2 __c6xabi_cvtdf +#define __extendsfdf2 __c6xabi_cvtfd +#define __adddf3 __c6xabi_addd +#define __subdf3 __c6xabi_subd +#define __muldf3 __c6xabi_mpyd +#define __divdf3 __c6xabi_divd +#define __negdf2 __c6xabi_negd +#define __absdf2 __c6xabi_absd +#define __addsf3 __c6xabi_addf +#define __subsf3 __c6xabi_subf +#define __mulsf3 __c6xabi_mpyf +#define __divsf3 __c6xabi_divf +#define __negsf2 __c6xabi_negf +#define __abssf2 __c6xabi_absf +#define __lesf2 __c6xabi_cmpf +#define __ledf2 __c6xabi_cmpd +#define __ltsf2 __gnu_ltsf2 +#define __ltdf2 __gnu_ltdf2 +#define __gesf2 __gnu_gesf2 +#define __gedf2 __gnu_gedf2 +#define __gtsf2 __gnu_gtsf2 +#define __gtdf2 __gnu_gtdf2 +#define __eqsf2 __gnu_eqsf2 +#define __eqdf2 __gnu_eqdf2 +#define __nesf2 __c6xabi_neqf +#define __nedf2 __c6xabi_neqd +#define __unordsf2 __c6xabi_unordf +#define __unorddf2 __c6xabi_unordd diff --git a/gcc-4.9/libgcc/config/c6x/t-elf b/gcc-4.9/libgcc/config/c6x/t-elf new file mode 100644 index 000000000..338571d1b --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/t-elf @@ -0,0 +1,40 @@ +# Cannot use default rules due to $(CRTSTUFF_T_CFLAGS). +CUSTOM_CRTIN = yes + +LIB1ASMSRC = c6x/lib1funcs.S +LIB1ASMFUNCS = _divsi3 _udivsi3 _umodsi3 _modsi3 _udivmodsi4 _divmodsi4 +LIB1ASMFUNCS += _strasgi _strasgi_64plus _clzsi2 _clzdi2 _clz +LIB1ASMFUNCS += _push_rts _pop_rts _call_stub + +LIB2FUNCS_EXCLUDE = _cmpdi2 _ucmpdi2 _gcc_bcmp _eprintf _clzsi _clzdi + +LIB2ADD += $(srcdir)/config/c6x/gef.c \ + $(srcdir)/config/c6x/gtf.c \ + $(srcdir)/config/c6x/lef.c \ + $(srcdir)/config/c6x/ltf.c \ + $(srcdir)/config/c6x/eqf.c \ + $(srcdir)/config/c6x/ged.c \ + $(srcdir)/config/c6x/gtd.c \ + $(srcdir)/config/c6x/led.c \ + $(srcdir)/config/c6x/ltd.c \ + $(srcdir)/config/c6x/eqd.c + +# Avoid failures when the user's GOT becomes too large. +HOST_LIBGCC2_CFLAGS += -msdata=none + +LIB2ADDEH = $(srcdir)/config/c6x/unwind-c6x.c \ + $(srcdir)/config/c6x/libunwind.S \ + $(srcdir)/config/c6x/pr-support.c $(srcdir)/unwind-c.c + +# Assemble startup files. +crti.o: $(srcdir)/config/c6x/crti.S + $(crt_compile) -c $(CRTSTUFF_T_CFLAGS) $< + +crtn.o: $(srcdir)/config/c6x/crtn.S + $(crt_compile) -c $(CRTSTUFF_T_CFLAGS) $< + +# Avoid failures when the user's GOT becomes too large. +CRTSTUFF_T_CFLAGS = -msdata=none +CRTSTUFF_T_CFLAGS_S = -msdata=none + +SHLIB_MAPFILES += $(srcdir)/config/c6x/libgcc-eabi.ver diff --git a/gcc-4.9/libgcc/config/c6x/t-uclinux b/gcc-4.9/libgcc/config/c6x/t-uclinux new file mode 100644 index 000000000..72a170a57 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/t-uclinux @@ -0,0 +1,3 @@ +HOST_LIBGCC2_CFLAGS += -msdata=none + +CRTSTUFF_T_CFLAGS += $(PICFLAG) diff --git a/gcc-4.9/libgcc/config/c6x/unwind-c6x.c b/gcc-4.9/libgcc/config/c6x/unwind-c6x.c new file mode 100644 index 000000000..bf5155c00 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/unwind-c6x.c @@ -0,0 +1,224 @@ +/* C6X EABI compliant unwinding routines. + Copyright (C) 2011-2014 Free Software Foundation, Inc. + + This file is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 3, or (at your option) any + later version. + + This file is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + <http://www.gnu.org/licenses/>. */ + +#include "unwind.h" + +/* Misc constants. */ +#define NUM_SAVED_REGS 32 +#define R_B0 16 +#define R_B3 (R_B0 + 3) +#define R_B15 (R_B0 + 15) +#define R_SP R_B15 +#define R_LR R_B3 +#define R_PC 33 + +#define VRS_PC(vrs) ((vrs)->core.pc) +#define VRS_SP(vrs) ((vrs)->core.reg[R_SP]) +#define VRS_RETURN(vrs) ((vrs)->core.reg[R_B3]) + +struct core_regs +{ + _uw reg[NUM_SAVED_REGS]; + _uw pc; +}; + +typedef struct +{ + /* The first fields must be the same as a phase2_vrs. */ + _uw demand_save_flags; /* Currently always zero. */ + struct core_regs core; + _uw prev_sp; /* Only valid during forced unwinding. */ +} phase1_vrs; + +/* This must match the structure created by the assembly wrappers. */ +typedef struct +{ + _uw demand_save_flags; + struct core_regs core; +} phase2_vrs; + +/* Coprocessor register state manipulation functions. */ + +/* Restore coprocessor state after phase1 unwinding. */ +static void +restore_non_core_regs (phase1_vrs * vrs __attribute__((unused))) +{ +} + +#include "unwind-arm-common.inc" + +/* ABI defined personality routines. */ +extern _Unwind_Reason_Code __c6xabi_unwind_cpp_pr0 (_Unwind_State, + _Unwind_Control_Block *, _Unwind_Context *);// __attribute__((weak)); +extern _Unwind_Reason_Code __c6xabi_unwind_cpp_pr1 (_Unwind_State, + _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak)); +extern _Unwind_Reason_Code __c6xabi_unwind_cpp_pr2 (_Unwind_State, + _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak)); +extern _Unwind_Reason_Code __c6xabi_unwind_cpp_pr3 (_Unwind_State, + _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak)); +extern _Unwind_Reason_Code __c6xabi_unwind_cpp_pr4 (_Unwind_State, + _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak)); + +/* ABI defined routine to store a virtual register to memory. */ + +_Unwind_VRS_Result _Unwind_VRS_Get (_Unwind_Context *context, + _Unwind_VRS_RegClass regclass, + _uw regno, + _Unwind_VRS_DataRepresentation representation, + void *valuep) +{ + phase1_vrs *vrs = (phase1_vrs *) context; + + switch (regclass) + { + case _UVRSC_CORE: + if (representation != _UVRSD_UINT32) + return _UVRSR_FAILED; + if (regno == R_PC) + { + *(_uw *) valuep = vrs->core.pc; + return _UVRSR_OK; + } + if (regno >= NUM_SAVED_REGS) + return _UVRSR_FAILED; + *(_uw *) valuep = vrs->core.reg[regno]; + return _UVRSR_OK; + + default: + return _UVRSR_FAILED; + } +} + + +/* ABI defined function to load a virtual register from memory. */ + +_Unwind_VRS_Result _Unwind_VRS_Set (_Unwind_Context *context, + _Unwind_VRS_RegClass regclass, + _uw regno, + _Unwind_VRS_DataRepresentation representation, + void *valuep) +{ + phase1_vrs *vrs = (phase1_vrs *) context; + + switch (regclass) + { + case _UVRSC_CORE: + if (representation != _UVRSD_UINT32) + return _UVRSR_FAILED; + if (regno == R_PC) + { + vrs->core.pc = *(_uw *) valuep; + return _UVRSR_OK; + } + if (regno >= NUM_SAVED_REGS) + return _UVRSR_FAILED; + + vrs->core.reg[regno] = *(_uw *) valuep; + return _UVRSR_OK; + + default: + return _UVRSR_FAILED; + } +} + + +/* Core unwinding functions. */ + +/* Calculate the address encoded by a 31-bit self-relative offset at address + P. */ +static inline _uw +selfrel_offset31 (const _uw *p) +{ + _uw offset; + + offset = *p << 1; + return offset + (_uw) p; +} + + +static _uw +__gnu_unwind_get_pr_addr (int idx) +{ + switch (idx) + { + case 0: + return (_uw) &__c6xabi_unwind_cpp_pr0; + + case 1: + return (_uw) &__c6xabi_unwind_cpp_pr1; + + case 2: + return (_uw) &__c6xabi_unwind_cpp_pr2; + + case 3: + return (_uw) &__c6xabi_unwind_cpp_pr3; + + case 4: + return (_uw) &__c6xabi_unwind_cpp_pr4; + + default: + return 0; + } +} + + +/* ABI defined personality routine entry points. */ + +_Unwind_Reason_Code +__c6xabi_unwind_cpp_pr0 (_Unwind_State state, + _Unwind_Control_Block *ucbp, + _Unwind_Context *context) +{ + return __gnu_unwind_pr_common (state, ucbp, context, 0); +} + +_Unwind_Reason_Code +__c6xabi_unwind_cpp_pr1 (_Unwind_State state, + _Unwind_Control_Block *ucbp, + _Unwind_Context *context) +{ + return __gnu_unwind_pr_common (state, ucbp, context, 1); +} + +_Unwind_Reason_Code +__c6xabi_unwind_cpp_pr2 (_Unwind_State state, + _Unwind_Control_Block *ucbp, + _Unwind_Context *context) +{ + return __gnu_unwind_pr_common (state, ucbp, context, 2); +} + +_Unwind_Reason_Code +__c6xabi_unwind_cpp_pr3 (_Unwind_State state, + _Unwind_Control_Block *ucbp, + _Unwind_Context *context) +{ + return __gnu_unwind_pr_common (state, ucbp, context, 3); +} + +_Unwind_Reason_Code +__c6xabi_unwind_cpp_pr4 (_Unwind_State state, + _Unwind_Control_Block *ucbp, + _Unwind_Context *context) +{ + return __gnu_unwind_pr_common (state, ucbp, context, 4); +} diff --git a/gcc-4.9/libgcc/config/c6x/unwind-c6x.h b/gcc-4.9/libgcc/config/c6x/unwind-c6x.h new file mode 100644 index 000000000..258a035b8 --- /dev/null +++ b/gcc-4.9/libgcc/config/c6x/unwind-c6x.h @@ -0,0 +1,70 @@ +/* Header file for the C6X EABI unwinder + Copyright (C) 2011-2014 Free Software Foundation, Inc. + + This file is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 3, or (at your option) any + later version. + + This file is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + <http://www.gnu.org/licenses/>. */ + +/* Language-independent unwinder header public defines. This contains both + ABI defined objects, and GNU support routines. */ + +#ifndef UNWIND_C6X_H +#define UNWIND_C6X_H + +/* Not really the ARM EABI, but pretty close. */ +#include "unwind-arm-common.h" + +#define UNWIND_STACK_REG 31 +/* Use A0 as a scratch register within the personality routine. */ +#define UNWIND_POINTER_REG 0 + +#ifdef __cplusplus +extern "C" { +#endif + _Unwind_Reason_Code __gnu_unwind_24bit (_Unwind_Context *, _uw, int); + + /* Decode an EH table reference to a typeinfo object. */ + static inline _Unwind_Word + _Unwind_decode_typeinfo_ptr (_Unwind_Ptr base, _Unwind_Word ptr) + { + _Unwind_Word tmp; + + tmp = *(_Unwind_Word *) ptr; + /* Zero values are always NULL. */ + if (!tmp) + return 0; + + /* SB-relative indirect. Propagate the bottom 2 bits, which can + contain referenceness information in gnu unwinding tables. */ + tmp += base; + tmp = *(_Unwind_Word *) (tmp & ~(_Unwind_Word)3) | (tmp & 3); + return tmp; + } + +#define _Unwind_GetIP(context) \ + (_Unwind_GetGR (context, 33)) + + +#define _Unwind_SetIP(context, val) \ + _Unwind_SetGR (context, 33, val) + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* defined UNWIND_ARM_H */ |