diff options
Diffstat (limited to 'lib/gcc/mips64el-linux-android')
77 files changed, 4649 insertions, 0 deletions
diff --git a/lib/gcc/mips64el-linux-android/4.9/32/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/32/crtbegin.o Binary files differnew file mode 100644 index 0000000..ab1403f --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/32/crtbeginS.o Binary files differnew file mode 100644 index 0000000..0bf7741 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/32/crtbeginT.o Binary files differnew file mode 100644 index 0000000..ab1403f --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/crtend.o b/lib/gcc/mips64el-linux-android/4.9/32/crtend.o Binary files differnew file mode 100644 index 0000000..de1d3f0 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/32/crtendS.o Binary files differnew file mode 100644 index 0000000..de1d3f0 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/32/crtfastmath.o Binary files differnew file mode 100644 index 0000000..d612edc --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/32/libgcc.a Binary files differnew file mode 100644 index 0000000..08a27f3 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/32/libgcov.a Binary files differnew file mode 100644 index 0000000..09db83a --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/libgcov.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbegin.o Binary files differnew file mode 100644 index 0000000..d843f16 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbeginS.o Binary files differnew file mode 100644 index 0000000..ce92312 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbeginT.o Binary files differnew file mode 100644 index 0000000..d843f16 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtend.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtend.o Binary files differnew file mode 100644 index 0000000..4670c98 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtendS.o Binary files differnew file mode 100644 index 0000000..4670c98 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtfastmath.o Binary files differnew file mode 100644 index 0000000..5ffbcf6 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/libgcc.a Binary files differnew file mode 100644 index 0000000..44399b7 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/libgcov.a Binary files differnew file mode 100644 index 0000000..5b8c698 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r1/libgcov.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbegin.o Binary files differnew file mode 100644 index 0000000..2814b8b --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbeginS.o Binary files differnew file mode 100644 index 0000000..eebba02 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbeginT.o Binary files differnew file mode 100644 index 0000000..2814b8b --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtend.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtend.o Binary files differnew file mode 100644 index 0000000..b5176d0 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtendS.o Binary files differnew file mode 100644 index 0000000..b5176d0 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtfastmath.o Binary files differnew file mode 100644 index 0000000..256be06 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/libgcc.a Binary files differnew file mode 100644 index 0000000..8f962f7 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/libgcov.a Binary files differnew file mode 100644 index 0000000..9b9ed0e --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r2/libgcov.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbegin.o Binary files differnew file mode 100644 index 0000000..b51a6f5 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbeginS.o Binary files differnew file mode 100644 index 0000000..811fcd4 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbeginT.o Binary files differnew file mode 100644 index 0000000..b51a6f5 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtend.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtend.o Binary files differnew file mode 100644 index 0000000..74c15c8 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtendS.o Binary files differnew file mode 100644 index 0000000..74c15c8 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtfastmath.o Binary files differnew file mode 100644 index 0000000..d1fe0be --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/libgcc.a Binary files differnew file mode 100644 index 0000000..b7f32b8 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/libgcov.a Binary files differnew file mode 100644 index 0000000..0db4dfa --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/32/mips-r6/libgcov.a diff --git a/lib/gcc/mips64el-linux-android/4.9/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/crtbegin.o Binary files differnew file mode 100644 index 0000000..03def6c --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o Binary files differnew file mode 100644 index 0000000..f69b91c --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o Binary files differnew file mode 100644 index 0000000..03def6c --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/crtend.o b/lib/gcc/mips64el-linux-android/4.9/crtend.o Binary files differnew file mode 100644 index 0000000..2e03318 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/crtendS.o Binary files differnew file mode 100644 index 0000000..2e03318 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o Binary files differnew file mode 100644 index 0000000..fa5a7d5 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/include-fixed/README b/lib/gcc/mips64el-linux-android/4.9/include-fixed/README new file mode 100644 index 0000000..7086a77 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include-fixed/README @@ -0,0 +1,14 @@ +This README file is copied into the directory for GCC-only header files +when fixincludes is run by the makefile for GCC. + +Many of the files in this directory were automatically edited from the +standard system header files by the fixincludes process. They are +system-specific, and will not work on any other kind of system. They +are also not part of GCC. The reason we have to do this is because +GCC requires ANSI C headers and many vendors supply ANSI-incompatible +headers. + +Because this is an automated process, sometimes headers get "fixed" +that do not, strictly speaking, need a fix. As long as nothing is broken +by the process, it is just an unfortunate collateral inconvenience. +We would like to rectify it, if it is not "too inconvenient". diff --git a/lib/gcc/mips64el-linux-android/4.9/include-fixed/arpa/nameser_compat.h b/lib/gcc/mips64el-linux-android/4.9/include-fixed/arpa/nameser_compat.h new file mode 100644 index 0000000..5ff162d --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include-fixed/arpa/nameser_compat.h @@ -0,0 +1,247 @@ +/* DO NOT EDIT THIS FILE. + + It has been auto-edited by fixincludes from: + + "/tmp/ndk-User/build/toolchain/prefix/sysroot/usr/include/arpa/nameser_compat.h" + + This had to be done to correct non-standard usages in the + original, manufacturer supplied header file. */ + +/* $NetBSD: nameser_compat.h,v 1.1.1.2 2004/11/07 01:28:27 christos Exp $ */ + +/* Copyright (c) 1983, 1989 + * The Regents of the University of California. 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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. + */ + +/* + * from nameser.h 8.1 (Berkeley) 6/2/93 + * Id: nameser_compat.h,v 1.8 2006/05/19 02:33:40 marka Exp + */ + +#ifndef _ARPA_NAMESER_COMPAT_ +#define _ARPA_NAMESER_COMPAT_ + +#define __BIND 19950621 /* (DEAD) interface version stamp. */ + +#include <endian.h> + +#ifndef BYTE_ORDER +#if (BSD >= 199103) +# include <machine/endian.h> +#else +#ifdef __linux__ +# include <endian.h> +#else +#define LITTLE_ENDIAN 1234 /* least-significant byte first (vax, pc) */ +#define BIG_ENDIAN 4321 /* most-significant byte first (IBM, net) */ +#define PDP_ENDIAN 3412 /* LSB first in word, MSW first in long (pdp)*/ + +#if defined(vax) || defined(ns32000) || defined(sun386) || defined(i386) || \ + defined(__MIPSEL__) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \ + defined(__i386__) || defined(__i386) || defined(__amd64__) || \ + defined(__x86_64__) || defined(__MIPSEL__) || defined(_MIPSEL) || \ + defined(BIT_ZERO_ON_RIGHT) || defined(__alpha__) || defined(__alpha) || \ + (defined(__Lynx__) && defined(__x86__)) +#define BYTE_ORDER LITTLE_ENDIAN +#endif + +#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \ + defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \ + defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\ + defined(apollo) || defined(__convex__) || defined(_CRAY) || \ + defined(__hppa) || defined(__hp9000) || \ + defined(__hp9000s300) || defined(__hp9000s700) || \ + defined(__hp3000s900) || defined(__hpux) || defined(MPE) || \ + defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc) || \ + (defined(__Lynx__) && \ + (defined(__68k__) || defined(__sparc__) || defined(__powerpc__))) +#define BYTE_ORDER BIG_ENDIAN +#endif +#endif /* __linux */ +#endif /* BSD */ +#endif /* BYTE_ORDER */ + +#if !defined(BYTE_ORDER) || \ + (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN && \ + BYTE_ORDER != PDP_ENDIAN) + /* you must determine what the correct bit order is for + * your compiler - the next line is an intentional error + * which will force your compiles to bomb until you fix + * the above macros. + */ + #error "Undefined or invalid BYTE_ORDER"; +#endif + +/* + * Structure for query header. The order of the fields is machine- and + * compiler-dependent, depending on the byte/bit order and the layout + * of bit fields. We use bit fields only in int variables, as this + * is all ANSI requires. This requires a somewhat confusing rearrangement. + */ + +typedef struct { + unsigned id :16; /* query identification number */ +#if BYTE_ORDER == BIG_ENDIAN + /* fields in third byte */ + unsigned qr: 1; /* response flag */ + unsigned opcode: 4; /* purpose of message */ + unsigned aa: 1; /* authoritive answer */ + unsigned tc: 1; /* truncated message */ + unsigned rd: 1; /* recursion desired */ + /* fields in fourth byte */ + unsigned ra: 1; /* recursion available */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ad: 1; /* authentic data from named */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned rcode :4; /* response code */ +#endif +#if BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN + /* fields in third byte */ + unsigned rd :1; /* recursion desired */ + unsigned tc :1; /* truncated message */ + unsigned aa :1; /* authoritive answer */ + unsigned opcode :4; /* purpose of message */ + unsigned qr :1; /* response flag */ + /* fields in fourth byte */ + unsigned rcode :4; /* response code */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned ad: 1; /* authentic data from named */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ra :1; /* recursion available */ +#endif + /* remaining bytes */ + unsigned qdcount :16; /* number of question entries */ + unsigned ancount :16; /* number of answer entries */ + unsigned nscount :16; /* number of authority entries */ + unsigned arcount :16; /* number of resource entries */ +} HEADER; + +#define PACKETSZ NS_PACKETSZ +#define MAXDNAME NS_MAXDNAME +#define MAXCDNAME NS_MAXCDNAME +#define MAXLABEL NS_MAXLABEL +#define HFIXEDSZ NS_HFIXEDSZ +#define QFIXEDSZ NS_QFIXEDSZ +#define RRFIXEDSZ NS_RRFIXEDSZ +#define INT32SZ NS_INT32SZ +#define INT16SZ NS_INT16SZ +#define INT8SZ NS_INT8SZ +#define INADDRSZ NS_INADDRSZ +#define IN6ADDRSZ NS_IN6ADDRSZ +#define INDIR_MASK NS_CMPRSFLGS +#define NAMESERVER_PORT NS_DEFAULTPORT + +#define S_ZONE ns_s_zn +#define S_PREREQ ns_s_pr +#define S_UPDATE ns_s_ud +#define S_ADDT ns_s_ar + +#define QUERY ns_o_query +#define IQUERY ns_o_iquery +#define STATUS ns_o_status +#define NS_NOTIFY_OP ns_o_notify +#define NS_UPDATE_OP ns_o_update + +#define NOERROR ns_r_noerror +#define FORMERR ns_r_formerr +#define SERVFAIL ns_r_servfail +#define NXDOMAIN ns_r_nxdomain +#define NOTIMP ns_r_notimpl +#define REFUSED ns_r_refused +#define YXDOMAIN ns_r_yxdomain +#define YXRRSET ns_r_yxrrset +#define NXRRSET ns_r_nxrrset +#define NOTAUTH ns_r_notauth +#define NOTZONE ns_r_notzone +/*#define BADSIG ns_r_badsig*/ +/*#define BADKEY ns_r_badkey*/ +/*#define BADTIME ns_r_badtime*/ + + +#define DELETE ns_uop_delete +#define ADD ns_uop_add + +#define T_A ns_t_a +#define T_NS ns_t_ns +#define T_MD ns_t_md +#define T_MF ns_t_mf +#define T_CNAME ns_t_cname +#define T_SOA ns_t_soa +#define T_MB ns_t_mb +#define T_MG ns_t_mg +#define T_MR ns_t_mr +#define T_NULL ns_t_null +#define T_WKS ns_t_wks +#define T_PTR ns_t_ptr +#define T_HINFO ns_t_hinfo +#define T_MINFO ns_t_minfo +#define T_MX ns_t_mx +#define T_TXT ns_t_txt +#define T_RP ns_t_rp +#define T_AFSDB ns_t_afsdb +#define T_X25 ns_t_x25 +#define T_ISDN ns_t_isdn +#define T_RT ns_t_rt +#define T_NSAP ns_t_nsap +#define T_NSAP_PTR ns_t_nsap_ptr +#define T_SIG ns_t_sig +#define T_KEY ns_t_key +#define T_PX ns_t_px +#define T_GPOS ns_t_gpos +#define T_AAAA ns_t_aaaa +#define T_LOC ns_t_loc +#define T_NXT ns_t_nxt +#define T_EID ns_t_eid +#define T_NIMLOC ns_t_nimloc +#define T_SRV ns_t_srv +#define T_ATMA ns_t_atma +#define T_NAPTR ns_t_naptr +#define T_A6 ns_t_a6 +#define T_TSIG ns_t_tsig +#define T_IXFR ns_t_ixfr +#define T_AXFR ns_t_axfr +#define T_MAILB ns_t_mailb +#define T_MAILA ns_t_maila +#define T_ANY ns_t_any + +#define C_IN ns_c_in +#define C_CHAOS ns_c_chaos +#define C_HS ns_c_hs +/* BIND_UPDATE */ +#define C_NONE ns_c_none +#define C_ANY ns_c_any + +#define GETSHORT NS_GET16 +#define GETLONG NS_GET32 +#define PUTSHORT NS_PUT16 +#define PUTLONG NS_PUT32 + +#endif /* _ARPA_NAMESER_COMPAT_ */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include-fixed/limits.h b/lib/gcc/mips64el-linux-android/4.9/include-fixed/limits.h new file mode 100644 index 0000000..8c6a4d3 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include-fixed/limits.h @@ -0,0 +1,171 @@ +/* Copyright (C) 1992-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. + +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 administrivia gets added to the beginning of limits.h + if the system has its own version of limits.h. */ + +/* We use _GCC_LIMITS_H_ because we want this not to match + any macros that the system's limits.h uses for its own purposes. */ +#ifndef _GCC_LIMITS_H_ /* Terminated in limity.h. */ +#define _GCC_LIMITS_H_ + +#ifndef _LIBC_LIMITS_H_ +/* Use "..." so that we find syslimits.h only in this same directory. */ +#include "syslimits.h" +#endif +/* Copyright (C) 1991-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. + +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/>. */ + +#ifndef _LIMITS_H___ +#define _LIMITS_H___ + +/* Number of bits in a `char'. */ +#undef CHAR_BIT +#define CHAR_BIT __CHAR_BIT__ + +/* Maximum length of a multibyte character. */ +#ifndef MB_LEN_MAX +#define MB_LEN_MAX 1 +#endif + +/* Minimum and maximum values a `signed char' can hold. */ +#undef SCHAR_MIN +#define SCHAR_MIN (-SCHAR_MAX - 1) +#undef SCHAR_MAX +#define SCHAR_MAX __SCHAR_MAX__ + +/* Maximum value an `unsigned char' can hold. (Minimum is 0). */ +#undef UCHAR_MAX +#if __SCHAR_MAX__ == __INT_MAX__ +# define UCHAR_MAX (SCHAR_MAX * 2U + 1U) +#else +# define UCHAR_MAX (SCHAR_MAX * 2 + 1) +#endif + +/* Minimum and maximum values a `char' can hold. */ +#ifdef __CHAR_UNSIGNED__ +# undef CHAR_MIN +# if __SCHAR_MAX__ == __INT_MAX__ +# define CHAR_MIN 0U +# else +# define CHAR_MIN 0 +# endif +# undef CHAR_MAX +# define CHAR_MAX UCHAR_MAX +#else +# undef CHAR_MIN +# define CHAR_MIN SCHAR_MIN +# undef CHAR_MAX +# define CHAR_MAX SCHAR_MAX +#endif + +/* Minimum and maximum values a `signed short int' can hold. */ +#undef SHRT_MIN +#define SHRT_MIN (-SHRT_MAX - 1) +#undef SHRT_MAX +#define SHRT_MAX __SHRT_MAX__ + +/* Maximum value an `unsigned short int' can hold. (Minimum is 0). */ +#undef USHRT_MAX +#if __SHRT_MAX__ == __INT_MAX__ +# define USHRT_MAX (SHRT_MAX * 2U + 1U) +#else +# define USHRT_MAX (SHRT_MAX * 2 + 1) +#endif + +/* Minimum and maximum values a `signed int' can hold. */ +#undef INT_MIN +#define INT_MIN (-INT_MAX - 1) +#undef INT_MAX +#define INT_MAX __INT_MAX__ + +/* Maximum value an `unsigned int' can hold. (Minimum is 0). */ +#undef UINT_MAX +#define UINT_MAX (INT_MAX * 2U + 1U) + +/* Minimum and maximum values a `signed long int' can hold. + (Same as `int'). */ +#undef LONG_MIN +#define LONG_MIN (-LONG_MAX - 1L) +#undef LONG_MAX +#define LONG_MAX __LONG_MAX__ + +/* Maximum value an `unsigned long int' can hold. (Minimum is 0). */ +#undef ULONG_MAX +#define ULONG_MAX (LONG_MAX * 2UL + 1UL) + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +/* Minimum and maximum values a `signed long long int' can hold. */ +# undef LLONG_MIN +# define LLONG_MIN (-LLONG_MAX - 1LL) +# undef LLONG_MAX +# define LLONG_MAX __LONG_LONG_MAX__ + +/* Maximum value an `unsigned long long int' can hold. (Minimum is 0). */ +# undef ULLONG_MAX +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +#endif + +#if defined (__GNU_LIBRARY__) ? defined (__USE_GNU) : !defined (__STRICT_ANSI__) +/* Minimum and maximum values a `signed long long int' can hold. */ +# undef LONG_LONG_MIN +# define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL) +# undef LONG_LONG_MAX +# define LONG_LONG_MAX __LONG_LONG_MAX__ + +/* Maximum value an `unsigned long long int' can hold. (Minimum is 0). */ +# undef ULONG_LONG_MAX +# define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL) +#endif + +#endif /* _LIMITS_H___ */ +/* This administrivia gets added to the end of limits.h + if the system has its own version of limits.h. */ + +#else /* not _GCC_LIMITS_H_ */ + +#ifdef _GCC_NEXT_LIMITS_H +#include_next <limits.h> /* recurse down to the real one */ +#endif + +#endif /* not _GCC_LIMITS_H_ */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include-fixed/linux/a.out.h b/lib/gcc/mips64el-linux-android/4.9/include-fixed/linux/a.out.h new file mode 100644 index 0000000..5f82a94 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include-fixed/linux/a.out.h @@ -0,0 +1,235 @@ +/* DO NOT EDIT THIS FILE. + + It has been auto-edited by fixincludes from: + + "/tmp/ndk-User/build/toolchain/prefix/sysroot/usr/include/linux/a.out.h" + + This had to be done to correct non-standard usages in the + original, manufacturer supplied header file. */ + +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef _UAPI__A_OUT_GNU_H__ +#define _UAPI__A_OUT_GNU_H__ +#define __GNU_EXEC_MACROS__ +#ifndef __STRUCT_EXEC_OVERRIDE__ +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#include <asm/a.out.h> +#endif +#ifndef __ASSEMBLY__ +enum machine_type { +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifdef M_OLDSUN2 + M__OLDSUN2 = M_OLDSUN2, +#else + M_OLDSUN2 = 0, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifdef M_68010 + M__68010 = M_68010, +#else +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + M_68010 = 1, +#endif +#ifdef M_68020 + M__68020 = M_68020, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#else + M_68020 = 2, +#endif +#ifdef M_SPARC +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + M__SPARC = M_SPARC, +#else + M_SPARC = 3, +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + M_386 = 100, + M_MIPS1 = 151, + M_MIPS2 = 152 +}; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_MAGIC +#define N_MAGIC(exec) ((exec).a_info & 0xffff) +#endif +#define N_MACHTYPE(exec) ((enum machine_type)(((exec).a_info >> 16) & 0xff)) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_FLAGS(exec) (((exec).a_info >> 24) & 0xff) +#define N_SET_INFO(exec, magic, type, flags) ((exec).a_info = ((magic) & 0xffff) | (((int)(type) & 0xff) << 16) | (((flags) & 0xff) << 24)) +#define N_SET_MAGIC(exec, magic) ((exec).a_info = (((exec).a_info & 0xffff0000) | ((magic) & 0xffff))) +#define N_SET_MACHTYPE(exec, machtype) ((exec).a_info = ((exec).a_info&0xff00ffff) | ((((int)(machtype))&0xff) << 16)) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_SET_FLAGS(exec, flags) ((exec).a_info = ((exec).a_info&0x00ffffff) | (((flags) & 0xff) << 24)) +#define OMAGIC 0407 +#define NMAGIC 0410 +#define ZMAGIC 0413 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define QMAGIC 0314 +#define CMAGIC 0421 +#ifndef N_BADMAG +#define N_BADMAG(x) (N_MAGIC(x) != OMAGIC && N_MAGIC(x) != NMAGIC && N_MAGIC(x) != ZMAGIC && N_MAGIC(x) != QMAGIC) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#define _N_HDROFF(x) (1024 - sizeof (struct exec)) +#ifndef N_TXTOFF +#define N_TXTOFF(x) (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec))) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifndef N_DATOFF +#define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text) +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_TRELOFF +#define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data) +#endif +#ifndef N_DRELOFF +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_DRELOFF(x) (N_TRELOFF(x) + N_TRSIZE(x)) +#endif +#ifndef N_SYMOFF +#define N_SYMOFF(x) (N_DRELOFF(x) + N_DRSIZE(x)) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifndef N_STROFF +#define N_STROFF(x) (N_SYMOFF(x) + N_SYMSIZE(x)) +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_TXTADDR +#define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? PAGE_SIZE : 0) +#endif +#if defined(vax) || defined(hp300) || defined(pyr) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define SEGMENT_SIZE page_size +#endif +#ifdef sony +#define SEGMENT_SIZE 0x2000 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifdef is68k +#define SEGMENT_SIZE 0x20000 +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#if defined(m68k) && defined(PORTAR) +#define PAGE_SIZE 0x400 +#define SEGMENT_SIZE PAGE_SIZE +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifdef __linux__ +#include <unistd.h> +#if defined(__i386__) || defined(__mc68000__) +#define SEGMENT_SIZE 1024 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#else +#ifndef SEGMENT_SIZE +#define SEGMENT_SIZE getpagesize() +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#endif +#define _N_SEGMENT_ROUND(x) ALIGN(x, SEGMENT_SIZE) +#define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_DATADDR +#define N_DATADDR(x) (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x)))) +#endif +#ifndef N_BSSADDR +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_BSSADDR(x) (N_DATADDR(x) + (x).a_data) +#endif +#ifndef N_NLIST_DECLARED +struct nlist { +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + union { + char *n_name; + struct nlist *n_next; + long n_strx; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + } n_un; + unsigned char n_type; + char n_other; + short n_desc; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + unsigned long n_value; +}; +#endif +#ifndef N_UNDF +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_UNDF 0 +#endif +#ifndef N_ABS +#define N_ABS 2 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifndef N_TEXT +#define N_TEXT 4 +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_DATA +#define N_DATA 6 +#endif +#ifndef N_BSS +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_BSS 8 +#endif +#ifndef N_FN +#define N_FN 15 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifndef N_EXT +#define N_EXT 1 +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_TYPE +#define N_TYPE 036 +#endif +#ifndef N_STAB +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_STAB 0340 +#endif +#define N_INDR 0xa +#define N_SETA 0x14 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define N_SETT 0x16 +#define N_SETD 0x18 +#define N_SETB 0x1A +#define N_SETV 0x1C +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef N_RELOCATION_INFO_DECLARED +struct relocation_info +{ + int r_address; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + unsigned int r_symbolnum:24; + unsigned int r_pcrel:1; + unsigned int r_length:2; + unsigned int r_extern:1; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifdef NS32K + unsigned r_bsr:1; + unsigned r_disp:1; + unsigned r_pad:2; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#else + unsigned int r_pad:4; +#endif +}; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#endif +#endif diff --git a/lib/gcc/mips64el-linux-android/4.9/include-fixed/syslimits.h b/lib/gcc/mips64el-linux-android/4.9/include-fixed/syslimits.h new file mode 100644 index 0000000..a362802 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include-fixed/syslimits.h @@ -0,0 +1,8 @@ +/* syslimits.h stands for the system's own limits.h file. + If we can use it ok unmodified, then we install this text. + If fixincludes fixes it, then the fixed version is installed + instead of this text. */ + +#define _GCC_NEXT_LIMITS_H /* tell gcc's limits.h to recurse */ +#include_next <limits.h> +#undef _GCC_NEXT_LIMITS_H diff --git a/lib/gcc/mips64el-linux-android/4.9/include/float.h b/lib/gcc/mips64el-linux-android/4.9/include/float.h new file mode 100644 index 0000000..a8e05bf --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/float.h @@ -0,0 +1,277 @@ +/* Copyright (C) 2002-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. + +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/>. */ + +/* + * ISO C Standard: 5.2.4.2.2 Characteristics of floating types <float.h> + */ + +#ifndef _FLOAT_H___ +#define _FLOAT_H___ + +/* Radix of exponent representation, b. */ +#undef FLT_RADIX +#define FLT_RADIX __FLT_RADIX__ + +/* Number of base-FLT_RADIX digits in the significand, p. */ +#undef FLT_MANT_DIG +#undef DBL_MANT_DIG +#undef LDBL_MANT_DIG +#define FLT_MANT_DIG __FLT_MANT_DIG__ +#define DBL_MANT_DIG __DBL_MANT_DIG__ +#define LDBL_MANT_DIG __LDBL_MANT_DIG__ + +/* Number of decimal digits, q, such that any floating-point number with q + decimal digits can be rounded into a floating-point number with p radix b + digits and back again without change to the q decimal digits, + + p * log10(b) if b is a power of 10 + floor((p - 1) * log10(b)) otherwise +*/ +#undef FLT_DIG +#undef DBL_DIG +#undef LDBL_DIG +#define FLT_DIG __FLT_DIG__ +#define DBL_DIG __DBL_DIG__ +#define LDBL_DIG __LDBL_DIG__ + +/* Minimum int x such that FLT_RADIX**(x-1) is a normalized float, emin */ +#undef FLT_MIN_EXP +#undef DBL_MIN_EXP +#undef LDBL_MIN_EXP +#define FLT_MIN_EXP __FLT_MIN_EXP__ +#define DBL_MIN_EXP __DBL_MIN_EXP__ +#define LDBL_MIN_EXP __LDBL_MIN_EXP__ + +/* Minimum negative integer such that 10 raised to that power is in the + range of normalized floating-point numbers, + + ceil(log10(b) * (emin - 1)) +*/ +#undef FLT_MIN_10_EXP +#undef DBL_MIN_10_EXP +#undef LDBL_MIN_10_EXP +#define FLT_MIN_10_EXP __FLT_MIN_10_EXP__ +#define DBL_MIN_10_EXP __DBL_MIN_10_EXP__ +#define LDBL_MIN_10_EXP __LDBL_MIN_10_EXP__ + +/* Maximum int x such that FLT_RADIX**(x-1) is a representable float, emax. */ +#undef FLT_MAX_EXP +#undef DBL_MAX_EXP +#undef LDBL_MAX_EXP +#define FLT_MAX_EXP __FLT_MAX_EXP__ +#define DBL_MAX_EXP __DBL_MAX_EXP__ +#define LDBL_MAX_EXP __LDBL_MAX_EXP__ + +/* Maximum integer such that 10 raised to that power is in the range of + representable finite floating-point numbers, + + floor(log10((1 - b**-p) * b**emax)) +*/ +#undef FLT_MAX_10_EXP +#undef DBL_MAX_10_EXP +#undef LDBL_MAX_10_EXP +#define FLT_MAX_10_EXP __FLT_MAX_10_EXP__ +#define DBL_MAX_10_EXP __DBL_MAX_10_EXP__ +#define LDBL_MAX_10_EXP __LDBL_MAX_10_EXP__ + +/* Maximum representable finite floating-point number, + + (1 - b**-p) * b**emax +*/ +#undef FLT_MAX +#undef DBL_MAX +#undef LDBL_MAX +#define FLT_MAX __FLT_MAX__ +#define DBL_MAX __DBL_MAX__ +#define LDBL_MAX __LDBL_MAX__ + +/* The difference between 1 and the least value greater than 1 that is + representable in the given floating point type, b**1-p. */ +#undef FLT_EPSILON +#undef DBL_EPSILON +#undef LDBL_EPSILON +#define FLT_EPSILON __FLT_EPSILON__ +#define DBL_EPSILON __DBL_EPSILON__ +#define LDBL_EPSILON __LDBL_EPSILON__ + +/* Minimum normalized positive floating-point number, b**(emin - 1). */ +#undef FLT_MIN +#undef DBL_MIN +#undef LDBL_MIN +#define FLT_MIN __FLT_MIN__ +#define DBL_MIN __DBL_MIN__ +#define LDBL_MIN __LDBL_MIN__ + +/* Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown. */ +/* ??? This is supposed to change with calls to fesetround in <fenv.h>. */ +#undef FLT_ROUNDS +#define FLT_ROUNDS 1 + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +/* The floating-point expression evaluation method. + -1 indeterminate + 0 evaluate all operations and constants just to the range and + precision of the type + 1 evaluate operations and constants of type float and double + to the range and precision of the double type, evaluate + long double operations and constants to the range and + precision of the long double type + 2 evaluate all operations and constants to the range and + precision of the long double type + + ??? This ought to change with the setting of the fp control word; + the value provided by the compiler assumes the widest setting. */ +#undef FLT_EVAL_METHOD +#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ + +/* Number of decimal digits, n, such that any floating-point number in the + widest supported floating type with pmax radix b digits can be rounded + to a floating-point number with n decimal digits and back again without + change to the value, + + pmax * log10(b) if b is a power of 10 + ceil(1 + pmax * log10(b)) otherwise +*/ +#undef DECIMAL_DIG +#define DECIMAL_DIG __DECIMAL_DIG__ + +#endif /* C99 */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +/* Versions of DECIMAL_DIG for each floating-point type. */ +#undef FLT_DECIMAL_DIG +#undef DBL_DECIMAL_DIG +#undef LDBL_DECIMAL_DIG +#define FLT_DECIMAL_DIG __FLT_DECIMAL_DIG__ +#define DBL_DECIMAL_DIG __DBL_DECIMAL_DIG__ +#define LDBL_DECIMAL_DIG __DECIMAL_DIG__ + +/* Whether types support subnormal numbers. */ +#undef FLT_HAS_SUBNORM +#undef DBL_HAS_SUBNORM +#undef LDBL_HAS_SUBNORM +#define FLT_HAS_SUBNORM __FLT_HAS_DENORM__ +#define DBL_HAS_SUBNORM __DBL_HAS_DENORM__ +#define LDBL_HAS_SUBNORM __LDBL_HAS_DENORM__ + +/* Minimum positive values, including subnormals. */ +#undef FLT_TRUE_MIN +#undef DBL_TRUE_MIN +#undef LDBL_TRUE_MIN +#if __FLT_HAS_DENORM__ +#define FLT_TRUE_MIN __FLT_DENORM_MIN__ +#else +#define FLT_TRUE_MIN __FLT_MIN__ +#endif +#if __DBL_HAS_DENORM__ +#define DBL_TRUE_MIN __DBL_DENORM_MIN__ +#else +#define DBL_TRUE_MIN __DBL_MIN__ +#endif +#if __LDBL_HAS_DENORM__ +#define LDBL_TRUE_MIN __LDBL_DENORM_MIN__ +#else +#define LDBL_TRUE_MIN __LDBL_MIN__ +#endif + +#endif /* C11 */ + +#ifdef __STDC_WANT_DEC_FP__ +/* Draft Technical Report 24732, extension for decimal floating-point + arithmetic: Characteristic of decimal floating types <float.h>. */ + +/* Number of base-FLT_RADIX digits in the significand, p. */ +#undef DEC32_MANT_DIG +#undef DEC64_MANT_DIG +#undef DEC128_MANT_DIG +#define DEC32_MANT_DIG __DEC32_MANT_DIG__ +#define DEC64_MANT_DIG __DEC64_MANT_DIG__ +#define DEC128_MANT_DIG __DEC128_MANT_DIG__ + +/* Minimum exponent. */ +#undef DEC32_MIN_EXP +#undef DEC64_MIN_EXP +#undef DEC128_MIN_EXP +#define DEC32_MIN_EXP __DEC32_MIN_EXP__ +#define DEC64_MIN_EXP __DEC64_MIN_EXP__ +#define DEC128_MIN_EXP __DEC128_MIN_EXP__ + +/* Maximum exponent. */ +#undef DEC32_MAX_EXP +#undef DEC64_MAX_EXP +#undef DEC128_MAX_EXP +#define DEC32_MAX_EXP __DEC32_MAX_EXP__ +#define DEC64_MAX_EXP __DEC64_MAX_EXP__ +#define DEC128_MAX_EXP __DEC128_MAX_EXP__ + +/* Maximum representable finite decimal floating-point number + (there are 6, 15, and 33 9s after the decimal points respectively). */ +#undef DEC32_MAX +#undef DEC64_MAX +#undef DEC128_MAX +#define DEC32_MAX __DEC32_MAX__ +#define DEC64_MAX __DEC64_MAX__ +#define DEC128_MAX __DEC128_MAX__ + +/* The difference between 1 and the least value greater than 1 that is + representable in the given floating point type. */ +#undef DEC32_EPSILON +#undef DEC64_EPSILON +#undef DEC128_EPSILON +#define DEC32_EPSILON __DEC32_EPSILON__ +#define DEC64_EPSILON __DEC64_EPSILON__ +#define DEC128_EPSILON __DEC128_EPSILON__ + +/* Minimum normalized positive floating-point number. */ +#undef DEC32_MIN +#undef DEC64_MIN +#undef DEC128_MIN +#define DEC32_MIN __DEC32_MIN__ +#define DEC64_MIN __DEC64_MIN__ +#define DEC128_MIN __DEC128_MIN__ + +/* Minimum subnormal positive floating-point number. */ +#undef DEC32_SUBNORMAL_MIN +#undef DEC64_SUBNORMAL_MIN +#undef DEC128_SUBNORMAL_MIN +#define DEC32_SUBNORMAL_MIN __DEC32_SUBNORMAL_MIN__ +#define DEC64_SUBNORMAL_MIN __DEC64_SUBNORMAL_MIN__ +#define DEC128_SUBNORMAL_MIN __DEC128_SUBNORMAL_MIN__ + +/* The floating-point expression evaluation method. + -1 indeterminate + 0 evaluate all operations and constants just to the range and + precision of the type + 1 evaluate operations and constants of type _Decimal32 + and _Decimal64 to the range and precision of the _Decimal64 + type, evaluate _Decimal128 operations and constants to the + range and precision of the _Decimal128 type; + 2 evaluate all operations and constants to the range and + precision of the _Decimal128 type. */ + +#undef DEC_EVAL_METHOD +#define DEC_EVAL_METHOD __DEC_EVAL_METHOD__ + +#endif /* __STDC_WANT_DEC_FP__ */ + +#endif /* _FLOAT_H___ */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/iso646.h b/lib/gcc/mips64el-linux-android/4.9/include/iso646.h new file mode 100644 index 0000000..89bc8f4 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/iso646.h @@ -0,0 +1,45 @@ +/* Copyright (C) 1997-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. + +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/>. */ + +/* + * ISO C Standard: 7.9 Alternative spellings <iso646.h> + */ + +#ifndef _ISO646_H +#define _ISO646_H + +#ifndef __cplusplus +#define and && +#define and_eq &= +#define bitand & +#define bitor | +#define compl ~ +#define not ! +#define not_eq != +#define or || +#define or_eq |= +#define xor ^ +#define xor_eq ^= +#endif + +#endif diff --git a/lib/gcc/mips64el-linux-android/4.9/include/loongson.h b/lib/gcc/mips64el-linux-android/4.9/include/loongson.h new file mode 100644 index 0000000..6e3de0d --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/loongson.h @@ -0,0 +1,690 @@ +/* Intrinsics for ST Microelectronics Loongson-2E/2F SIMD operations. + + Copyright (C) 2008-2014 Free Software Foundation, Inc. + Contributed by CodeSourcery. + + 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 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/>. */ + +#ifndef _GCC_LOONGSON_H +#define _GCC_LOONGSON_H + +#if !defined(__mips_loongson_vector_rev) +# error "You must select -march=loongson2e or -march=loongson2f to use loongson.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdint.h> + +/* Vectors of unsigned bytes, halfwords and words. */ +typedef uint8_t uint8x8_t __attribute__((vector_size (8))); +typedef uint16_t uint16x4_t __attribute__((vector_size (8))); +typedef uint32_t uint32x2_t __attribute__((vector_size (8))); + +/* Vectors of signed bytes, halfwords and words. */ +typedef int8_t int8x8_t __attribute__((vector_size (8))); +typedef int16_t int16x4_t __attribute__((vector_size (8))); +typedef int32_t int32x2_t __attribute__((vector_size (8))); + +/* SIMD intrinsics. + Unless otherwise noted, calls to the functions below will expand into + precisely one machine instruction, modulo any moves required to + satisfy register allocation constraints. */ + +/* Pack with signed saturation. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +packsswh (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_packsswh (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +packsshb (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_packsshb (s, t); +} + +/* Pack with unsigned saturation. */ +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +packushb (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_packushb (s, t); +} + +/* Vector addition, treating overflow by wraparound. */ +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +paddw_u (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_paddw_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +paddh_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_paddh_u (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +paddb_u (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_paddb_u (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +paddw_s (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_paddw_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +paddh_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_paddh_s (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +paddb_s (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_paddb_s (s, t); +} + +/* Addition of doubleword integers, treating overflow by wraparound. */ +__extension__ static __inline uint64_t __attribute__ ((__always_inline__)) +paddd_u (uint64_t s, uint64_t t) +{ + return __builtin_loongson_paddd_u (s, t); +} + +__extension__ static __inline int64_t __attribute__ ((__always_inline__)) +paddd_s (int64_t s, int64_t t) +{ + return __builtin_loongson_paddd_s (s, t); +} + +/* Vector addition, treating overflow by signed saturation. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +paddsh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_paddsh (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +paddsb (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_paddsb (s, t); +} + +/* Vector addition, treating overflow by unsigned saturation. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +paddush (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_paddush (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +paddusb (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_paddusb (s, t); +} + +/* Logical AND NOT. */ +__extension__ static __inline uint64_t __attribute__ ((__always_inline__)) +pandn_ud (uint64_t s, uint64_t t) +{ + return __builtin_loongson_pandn_ud (s, t); +} + +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +pandn_uw (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_pandn_uw (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pandn_uh (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pandn_uh (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pandn_ub (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pandn_ub (s, t); +} + +__extension__ static __inline int64_t __attribute__ ((__always_inline__)) +pandn_sd (int64_t s, int64_t t) +{ + return __builtin_loongson_pandn_sd (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +pandn_sw (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_pandn_sw (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pandn_sh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pandn_sh (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +pandn_sb (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_pandn_sb (s, t); +} + +/* Average. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pavgh (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pavgh (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pavgb (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pavgb (s, t); +} + +/* Equality test. */ +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +pcmpeqw_u (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_pcmpeqw_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pcmpeqh_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pcmpeqh_u (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pcmpeqb_u (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pcmpeqb_u (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +pcmpeqw_s (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_pcmpeqw_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pcmpeqh_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pcmpeqh_s (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +pcmpeqb_s (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_pcmpeqb_s (s, t); +} + +/* Greater-than test. */ +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +pcmpgtw_u (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_pcmpgtw_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pcmpgth_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pcmpgth_u (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pcmpgtb_u (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pcmpgtb_u (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +pcmpgtw_s (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_pcmpgtw_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pcmpgth_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pcmpgth_s (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +pcmpgtb_s (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_pcmpgtb_s (s, t); +} + +/* Extract halfword. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pextrh_u (uint16x4_t s, int field /* 0--3 */) +{ + return __builtin_loongson_pextrh_u (s, field); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pextrh_s (int16x4_t s, int field /* 0--3 */) +{ + return __builtin_loongson_pextrh_s (s, field); +} + +/* Insert halfword. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pinsrh_0_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pinsrh_0_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pinsrh_1_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pinsrh_1_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pinsrh_2_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pinsrh_2_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pinsrh_3_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pinsrh_3_u (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pinsrh_0_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pinsrh_0_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pinsrh_1_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pinsrh_1_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pinsrh_2_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pinsrh_2_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pinsrh_3_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pinsrh_3_s (s, t); +} + +/* Multiply and add. */ +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +pmaddhw (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pmaddhw (s, t); +} + +/* Maximum of signed halfwords. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pmaxsh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pmaxsh (s, t); +} + +/* Maximum of unsigned bytes. */ +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pmaxub (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pmaxub (s, t); +} + +/* Minimum of signed halfwords. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pminsh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pminsh (s, t); +} + +/* Minimum of unsigned bytes. */ +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pminub (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pminub (s, t); +} + +/* Move byte mask. */ +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pmovmskb_u (uint8x8_t s) +{ + return __builtin_loongson_pmovmskb_u (s); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +pmovmskb_s (int8x8_t s) +{ + return __builtin_loongson_pmovmskb_s (s); +} + +/* Multiply unsigned integers and store high result. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pmulhuh (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_pmulhuh (s, t); +} + +/* Multiply signed integers and store high result. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pmulhh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pmulhh (s, t); +} + +/* Multiply signed integers and store low result. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pmullh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_pmullh (s, t); +} + +/* Multiply unsigned word integers. */ +__extension__ static __inline int64_t __attribute__ ((__always_inline__)) +pmuluw (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_pmuluw (s, t); +} + +/* Absolute difference. */ +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +pasubub (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_pasubub (s, t); +} + +/* Sum of unsigned byte integers. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +biadd (uint8x8_t s) +{ + return __builtin_loongson_biadd (s); +} + +/* Sum of absolute differences. + Note that this intrinsic expands into two machine instructions: + PASUBUB followed by BIADD. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +psadbh (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_psadbh (s, t); +} + +/* Shuffle halfwords. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +pshufh_u (uint16x4_t dest, uint16x4_t s, uint8_t order) +{ + return __builtin_loongson_pshufh_u (s, order); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +pshufh_s (int16x4_t dest, int16x4_t s, uint8_t order) +{ + return __builtin_loongson_pshufh_s (s, order); +} + +/* Shift left logical. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +psllh_u (uint16x4_t s, uint8_t amount) +{ + return __builtin_loongson_psllh_u (s, amount); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +psllh_s (int16x4_t s, uint8_t amount) +{ + return __builtin_loongson_psllh_s (s, amount); +} + +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +psllw_u (uint32x2_t s, uint8_t amount) +{ + return __builtin_loongson_psllw_u (s, amount); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +psllw_s (int32x2_t s, uint8_t amount) +{ + return __builtin_loongson_psllw_s (s, amount); +} + +/* Shift right logical. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +psrlh_u (uint16x4_t s, uint8_t amount) +{ + return __builtin_loongson_psrlh_u (s, amount); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +psrlh_s (int16x4_t s, uint8_t amount) +{ + return __builtin_loongson_psrlh_s (s, amount); +} + +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +psrlw_u (uint32x2_t s, uint8_t amount) +{ + return __builtin_loongson_psrlw_u (s, amount); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +psrlw_s (int32x2_t s, uint8_t amount) +{ + return __builtin_loongson_psrlw_s (s, amount); +} + +/* Shift right arithmetic. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +psrah_u (uint16x4_t s, uint8_t amount) +{ + return __builtin_loongson_psrah_u (s, amount); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +psrah_s (int16x4_t s, uint8_t amount) +{ + return __builtin_loongson_psrah_s (s, amount); +} + +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +psraw_u (uint32x2_t s, uint8_t amount) +{ + return __builtin_loongson_psraw_u (s, amount); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +psraw_s (int32x2_t s, uint8_t amount) +{ + return __builtin_loongson_psraw_s (s, amount); +} + +/* Vector subtraction, treating overflow by wraparound. */ +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +psubw_u (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_psubw_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +psubh_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_psubh_u (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +psubb_u (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_psubb_u (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +psubw_s (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_psubw_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +psubh_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_psubh_s (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +psubb_s (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_psubb_s (s, t); +} + +/* Subtraction of doubleword integers, treating overflow by wraparound. */ +__extension__ static __inline uint64_t __attribute__ ((__always_inline__)) +psubd_u (uint64_t s, uint64_t t) +{ + return __builtin_loongson_psubd_u (s, t); +} + +__extension__ static __inline int64_t __attribute__ ((__always_inline__)) +psubd_s (int64_t s, int64_t t) +{ + return __builtin_loongson_psubd_s (s, t); +} + +/* Vector subtraction, treating overflow by signed saturation. */ +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +psubsh (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_psubsh (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +psubsb (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_psubsb (s, t); +} + +/* Vector subtraction, treating overflow by unsigned saturation. */ +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +psubush (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_psubush (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +psubusb (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_psubusb (s, t); +} + +/* Unpack high data. */ +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +punpckhwd_u (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_punpckhwd_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +punpckhhw_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_punpckhhw_u (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +punpckhbh_u (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_punpckhbh_u (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +punpckhwd_s (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_punpckhwd_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +punpckhhw_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_punpckhhw_s (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +punpckhbh_s (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_punpckhbh_s (s, t); +} + +/* Unpack low data. */ +__extension__ static __inline uint32x2_t __attribute__ ((__always_inline__)) +punpcklwd_u (uint32x2_t s, uint32x2_t t) +{ + return __builtin_loongson_punpcklwd_u (s, t); +} + +__extension__ static __inline uint16x4_t __attribute__ ((__always_inline__)) +punpcklhw_u (uint16x4_t s, uint16x4_t t) +{ + return __builtin_loongson_punpcklhw_u (s, t); +} + +__extension__ static __inline uint8x8_t __attribute__ ((__always_inline__)) +punpcklbh_u (uint8x8_t s, uint8x8_t t) +{ + return __builtin_loongson_punpcklbh_u (s, t); +} + +__extension__ static __inline int32x2_t __attribute__ ((__always_inline__)) +punpcklwd_s (int32x2_t s, int32x2_t t) +{ + return __builtin_loongson_punpcklwd_s (s, t); +} + +__extension__ static __inline int16x4_t __attribute__ ((__always_inline__)) +punpcklhw_s (int16x4_t s, int16x4_t t) +{ + return __builtin_loongson_punpcklhw_s (s, t); +} + +__extension__ static __inline int8x8_t __attribute__ ((__always_inline__)) +punpcklbh_s (int8x8_t s, int8x8_t t) +{ + return __builtin_loongson_punpcklbh_s (s, t); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/gcc/mips64el-linux-android/4.9/include/msa.h b/lib/gcc/mips64el-linux-android/4.9/include/msa.h new file mode 100644 index 0000000..64fa42c --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/msa.h @@ -0,0 +1,1113 @@ +/* MIPS MSA intrinsics include file. + + Copyright (C) 2014 Free Software Foundation, Inc. + Contributed by Imagination Technologies Ltd. + + 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 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/>. */ + +#ifndef _MSA_H +#define _MSA_H 1 + +#if defined(__mips_msa) +typedef signed char v16i8 __attribute__((vector_size(16), aligned(16))); +typedef signed char v16i8_b __attribute__((vector_size(16), aligned(1))); +typedef unsigned char v16u8 __attribute__((vector_size(16), aligned(16))); +typedef unsigned char v16u8_b __attribute__((vector_size(16), aligned(1))); +typedef short v8i16 __attribute__((vector_size(16), aligned(16))); +typedef short v8i16_h __attribute__((vector_size(16), aligned(2))); +typedef unsigned short v8u16 __attribute__((vector_size(16), aligned(16))); +typedef unsigned short v8u16_h __attribute__((vector_size(16), aligned(2))); +typedef int v4i32 __attribute__((vector_size(16), aligned(16))); +typedef int v4i32_w __attribute__((vector_size(16), aligned(4))); +typedef unsigned int v4u32 __attribute__((vector_size(16), aligned(16))); +typedef unsigned int v4u32_w __attribute__((vector_size(16), aligned(4))); +typedef long long v2i64 __attribute__((vector_size(16), aligned(16))); +typedef long long v2i64_d __attribute__((vector_size(16), aligned(8))); +typedef unsigned long long v2u64 __attribute__((vector_size(16), aligned(16))); +typedef unsigned long long v2u64_d __attribute__((vector_size(16), aligned(8))); +typedef float v4f32 __attribute__((vector_size(16), aligned(16))); +typedef float v4f32_w __attribute__((vector_size(16), aligned(4))); +typedef double v2f64 __attribute__ ((vector_size(16), aligned(16))); +typedef double v2f64_d __attribute__ ((vector_size(16), aligned(8))); + +#ifndef __clang__ +extern v16i8 __builtin_msa_sll_b(v16i8, v16i8); +#define __msa_sll_b __builtin_msa_sll_b +extern v8i16 __builtin_msa_sll_h(v8i16, v8i16); +#define __msa_sll_h __builtin_msa_sll_h +extern v4i32 __builtin_msa_sll_w(v4i32, v4i32); +#define __msa_sll_w __builtin_msa_sll_w +extern v2i64 __builtin_msa_sll_d(v2i64, v2i64); +#define __msa_sll_d __builtin_msa_sll_d +extern v16i8 __builtin_msa_slli_b(v16i8, unsigned char); +#define __msa_slli_b __builtin_msa_slli_b +extern v8i16 __builtin_msa_slli_h(v8i16, unsigned char); +#define __msa_slli_h __builtin_msa_slli_h +extern v4i32 __builtin_msa_slli_w(v4i32, unsigned char); +#define __msa_slli_w __builtin_msa_slli_w +extern v2i64 __builtin_msa_slli_d(v2i64, unsigned char); +#define __msa_slli_d __builtin_msa_slli_d +extern v16i8 __builtin_msa_sra_b(v16i8, v16i8); +#define __msa_sra_b __builtin_msa_sra_b +extern v8i16 __builtin_msa_sra_h(v8i16, v8i16); +#define __msa_sra_h __builtin_msa_sra_h +extern v4i32 __builtin_msa_sra_w(v4i32, v4i32); +#define __msa_sra_w __builtin_msa_sra_w +extern v2i64 __builtin_msa_sra_d(v2i64, v2i64); +#define __msa_sra_d __builtin_msa_sra_d +extern v16i8 __builtin_msa_srai_b(v16i8, unsigned char); +#define __msa_srai_b __builtin_msa_srai_b +extern v8i16 __builtin_msa_srai_h(v8i16, unsigned char); +#define __msa_srai_h __builtin_msa_srai_h +extern v4i32 __builtin_msa_srai_w(v4i32, unsigned char); +#define __msa_srai_w __builtin_msa_srai_w +extern v2i64 __builtin_msa_srai_d(v2i64, unsigned char); +#define __msa_srai_d __builtin_msa_srai_d +extern v16i8 __builtin_msa_srar_b(v16i8, v16i8); +#define __msa_srar_b __builtin_msa_srar_b +extern v8i16 __builtin_msa_srar_h(v8i16, v8i16); +#define __msa_srar_h __builtin_msa_srar_h +extern v4i32 __builtin_msa_srar_w(v4i32, v4i32); +#define __msa_srar_w __builtin_msa_srar_w +extern v2i64 __builtin_msa_srar_d(v2i64, v2i64); +#define __msa_srar_d __builtin_msa_srar_d +extern v16i8 __builtin_msa_srari_b(v16i8, unsigned char); +#define __msa_srari_b __builtin_msa_srari_b +extern v8i16 __builtin_msa_srari_h(v8i16, unsigned char); +#define __msa_srari_h __builtin_msa_srari_h +extern v4i32 __builtin_msa_srari_w(v4i32, unsigned char); +#define __msa_srari_w __builtin_msa_srari_w +extern v2i64 __builtin_msa_srari_d(v2i64, unsigned char); +#define __msa_srari_d __builtin_msa_srari_d +extern v16i8 __builtin_msa_srl_b(v16i8, v16i8); +#define __msa_srl_b __builtin_msa_srl_b +extern v8i16 __builtin_msa_srl_h(v8i16, v8i16); +#define __msa_srl_h __builtin_msa_srl_h +extern v4i32 __builtin_msa_srl_w(v4i32, v4i32); +#define __msa_srl_w __builtin_msa_srl_w +extern v2i64 __builtin_msa_srl_d(v2i64, v2i64); +#define __msa_srl_d __builtin_msa_srl_d +extern v16i8 __builtin_msa_srli_b(v16i8, unsigned char); +#define __msa_srli_b __builtin_msa_srli_b +extern v8i16 __builtin_msa_srli_h(v8i16, unsigned char); +#define __msa_srli_h __builtin_msa_srli_h +extern v4i32 __builtin_msa_srli_w(v4i32, unsigned char); +#define __msa_srli_w __builtin_msa_srli_w +extern v2i64 __builtin_msa_srli_d(v2i64, unsigned char); +#define __msa_srli_d __builtin_msa_srli_d +extern v16i8 __builtin_msa_srlr_b(v16i8, v16i8); +#define __msa_srlr_b __builtin_msa_srlr_b +extern v8i16 __builtin_msa_srlr_h(v8i16, v8i16); +#define __msa_srlr_h __builtin_msa_srlr_h +extern v4i32 __builtin_msa_srlr_w(v4i32, v4i32); +#define __msa_srlr_w __builtin_msa_srlr_w +extern v2i64 __builtin_msa_srlr_d(v2i64, v2i64); +#define __msa_srlr_d __builtin_msa_srlr_d +extern v16i8 __builtin_msa_srlri_b(v16i8, unsigned char); +#define __msa_srlri_b __builtin_msa_srlri_b +extern v8i16 __builtin_msa_srlri_h(v8i16, unsigned char); +#define __msa_srlri_h __builtin_msa_srlri_h +extern v4i32 __builtin_msa_srlri_w(v4i32, unsigned char); +#define __msa_srlri_w __builtin_msa_srlri_w +extern v2i64 __builtin_msa_srlri_d(v2i64, unsigned char); +#define __msa_srlri_d __builtin_msa_srlri_d +extern v16u8 __builtin_msa_bclr_b(v16u8, v16u8); +#define __msa_bclr_b __builtin_msa_bclr_b +extern v8u16 __builtin_msa_bclr_h(v8u16, v8u16); +#define __msa_bclr_h __builtin_msa_bclr_h +extern v4u32 __builtin_msa_bclr_w(v4u32, v4u32); +#define __msa_bclr_w __builtin_msa_bclr_w +extern v2u64 __builtin_msa_bclr_d(v2u64, v2u64); +#define __msa_bclr_d __builtin_msa_bclr_d +extern v16u8 __builtin_msa_bclri_b(v16u8, unsigned char); +#define __msa_bclri_b __builtin_msa_bclri_b +extern v8u16 __builtin_msa_bclri_h(v8u16, unsigned char); +#define __msa_bclri_h __builtin_msa_bclri_h +extern v4u32 __builtin_msa_bclri_w(v4u32, unsigned char); +#define __msa_bclri_w __builtin_msa_bclri_w +extern v2u64 __builtin_msa_bclri_d(v2u64, unsigned char); +#define __msa_bclri_d __builtin_msa_bclri_d +extern v16u8 __builtin_msa_bset_b(v16u8, v16u8); +#define __msa_bset_b __builtin_msa_bset_b +extern v8u16 __builtin_msa_bset_h(v8u16, v8u16); +#define __msa_bset_h __builtin_msa_bset_h +extern v4u32 __builtin_msa_bset_w(v4u32, v4u32); +#define __msa_bset_w __builtin_msa_bset_w +extern v2u64 __builtin_msa_bset_d(v2u64, v2u64); +#define __msa_bset_d __builtin_msa_bset_d +extern v16u8 __builtin_msa_bseti_b(v16u8, unsigned char); +#define __msa_bseti_b __builtin_msa_bseti_b +extern v8u16 __builtin_msa_bseti_h(v8u16, unsigned char); +#define __msa_bseti_h __builtin_msa_bseti_h +extern v4u32 __builtin_msa_bseti_w(v4u32, unsigned char); +#define __msa_bseti_w __builtin_msa_bseti_w +extern v2u64 __builtin_msa_bseti_d(v2u64, unsigned char); +#define __msa_bseti_d __builtin_msa_bseti_d +extern v16u8 __builtin_msa_bneg_b(v16u8, v16u8); +#define __msa_bneg_b __builtin_msa_bneg_b +extern v8u16 __builtin_msa_bneg_h(v8u16, v8u16); +#define __msa_bneg_h __builtin_msa_bneg_h +extern v4u32 __builtin_msa_bneg_w(v4u32, v4u32); +#define __msa_bneg_w __builtin_msa_bneg_w +extern v2u64 __builtin_msa_bneg_d(v2u64, v2u64); +#define __msa_bneg_d __builtin_msa_bneg_d +extern v16u8 __builtin_msa_bnegi_b(v16u8, unsigned char); +#define __msa_bnegi_b __builtin_msa_bnegi_b +extern v8u16 __builtin_msa_bnegi_h(v8u16, unsigned char); +#define __msa_bnegi_h __builtin_msa_bnegi_h +extern v4u32 __builtin_msa_bnegi_w(v4u32, unsigned char); +#define __msa_bnegi_w __builtin_msa_bnegi_w +extern v2u64 __builtin_msa_bnegi_d(v2u64, unsigned char); +#define __msa_bnegi_d __builtin_msa_bnegi_d +extern v16u8 __builtin_msa_binsl_b(v16u8, v16u8, v16u8); +#define __msa_binsl_b __builtin_msa_binsl_b +extern v8u16 __builtin_msa_binsl_h(v8u16, v8u16, v8u16); +#define __msa_binsl_h __builtin_msa_binsl_h +extern v4u32 __builtin_msa_binsl_w(v4u32, v4u32, v4u32); +#define __msa_binsl_w __builtin_msa_binsl_w +extern v2u64 __builtin_msa_binsl_d(v2u64, v2u64, v2u64); +#define __msa_binsl_d __builtin_msa_binsl_d +extern v16u8 __builtin_msa_binsli_b(v16u8, v16u8, unsigned char); +#define __msa_binsli_b __builtin_msa_binsli_b +extern v8u16 __builtin_msa_binsli_h(v8u16, v8u16, unsigned char); +#define __msa_binsli_h __builtin_msa_binsli_h +extern v4u32 __builtin_msa_binsli_w(v4u32, v4u32, unsigned char); +#define __msa_binsli_w __builtin_msa_binsli_w +extern v2u64 __builtin_msa_binsli_d(v2u64, v2u64, unsigned char); +#define __msa_binsli_d __builtin_msa_binsli_d +extern v16u8 __builtin_msa_binsr_b(v16u8, v16u8, v16u8); +#define __msa_binsr_b __builtin_msa_binsr_b +extern v8u16 __builtin_msa_binsr_h(v8u16, v8u16, v8u16); +#define __msa_binsr_h __builtin_msa_binsr_h +extern v4u32 __builtin_msa_binsr_w(v4u32, v4u32, v4u32); +#define __msa_binsr_w __builtin_msa_binsr_w +extern v2u64 __builtin_msa_binsr_d(v2u64, v2u64, v2u64); +#define __msa_binsr_d __builtin_msa_binsr_d +extern v16u8 __builtin_msa_binsri_b(v16u8, v16u8, unsigned char); +#define __msa_binsri_b __builtin_msa_binsri_b +extern v8u16 __builtin_msa_binsri_h(v8u16, v8u16, unsigned char); +#define __msa_binsri_h __builtin_msa_binsri_h +extern v4u32 __builtin_msa_binsri_w(v4u32, v4u32, unsigned char); +#define __msa_binsri_w __builtin_msa_binsri_w +extern v2u64 __builtin_msa_binsri_d(v2u64, v2u64, unsigned char); +#define __msa_binsri_d __builtin_msa_binsri_d +extern v16i8 __builtin_msa_addv_b(v16i8, v16i8); +#define __msa_addv_b __builtin_msa_addv_b +extern v8i16 __builtin_msa_addv_h(v8i16, v8i16); +#define __msa_addv_h __builtin_msa_addv_h +extern v4i32 __builtin_msa_addv_w(v4i32, v4i32); +#define __msa_addv_w __builtin_msa_addv_w +extern v2i64 __builtin_msa_addv_d(v2i64, v2i64); +#define __msa_addv_d __builtin_msa_addv_d +extern v16i8 __builtin_msa_addvi_b(v16i8, unsigned char); +#define __msa_addvi_b __builtin_msa_addvi_b +extern v8i16 __builtin_msa_addvi_h(v8i16, unsigned char); +#define __msa_addvi_h __builtin_msa_addvi_h +extern v4i32 __builtin_msa_addvi_w(v4i32, unsigned char); +#define __msa_addvi_w __builtin_msa_addvi_w +extern v2i64 __builtin_msa_addvi_d(v2i64, unsigned char); +#define __msa_addvi_d __builtin_msa_addvi_d +extern v16i8 __builtin_msa_subv_b(v16i8, v16i8); +#define __msa_subv_b __builtin_msa_subv_b +extern v8i16 __builtin_msa_subv_h(v8i16, v8i16); +#define __msa_subv_h __builtin_msa_subv_h +extern v4i32 __builtin_msa_subv_w(v4i32, v4i32); +#define __msa_subv_w __builtin_msa_subv_w +extern v2i64 __builtin_msa_subv_d(v2i64, v2i64); +#define __msa_subv_d __builtin_msa_subv_d +extern v16i8 __builtin_msa_subvi_b(v16i8, unsigned char); +#define __msa_subvi_b __builtin_msa_subvi_b +extern v8i16 __builtin_msa_subvi_h(v8i16, unsigned char); +#define __msa_subvi_h __builtin_msa_subvi_h +extern v4i32 __builtin_msa_subvi_w(v4i32, unsigned char); +#define __msa_subvi_w __builtin_msa_subvi_w +extern v2i64 __builtin_msa_subvi_d(v2i64, unsigned char); +#define __msa_subvi_d __builtin_msa_subvi_d +extern v16i8 __builtin_msa_max_s_b(v16i8, v16i8); +#define __msa_max_s_b __builtin_msa_max_s_b +extern v8i16 __builtin_msa_max_s_h(v8i16, v8i16); +#define __msa_max_s_h __builtin_msa_max_s_h +extern v4i32 __builtin_msa_max_s_w(v4i32, v4i32); +#define __msa_max_s_w __builtin_msa_max_s_w +extern v2i64 __builtin_msa_max_s_d(v2i64, v2i64); +#define __msa_max_s_d __builtin_msa_max_s_d +extern v16i8 __builtin_msa_maxi_s_b(v16i8, char); +#define __msa_maxi_s_b __builtin_msa_maxi_s_b +extern v8i16 __builtin_msa_maxi_s_h(v8i16, char); +#define __msa_maxi_s_h __builtin_msa_maxi_s_h +extern v4i32 __builtin_msa_maxi_s_w(v4i32, char); +#define __msa_maxi_s_w __builtin_msa_maxi_s_w +extern v2i64 __builtin_msa_maxi_s_d(v2i64, char); +#define __msa_maxi_s_d __builtin_msa_maxi_s_d +extern v16u8 __builtin_msa_max_u_b(v16u8, v16u8); +#define __msa_max_u_b __builtin_msa_max_u_b +extern v8u16 __builtin_msa_max_u_h(v8u16, v8u16); +#define __msa_max_u_h __builtin_msa_max_u_h +extern v4u32 __builtin_msa_max_u_w(v4u32, v4u32); +#define __msa_max_u_w __builtin_msa_max_u_w +extern v2u64 __builtin_msa_max_u_d(v2u64, v2u64); +#define __msa_max_u_d __builtin_msa_max_u_d +extern v16u8 __builtin_msa_maxi_u_b(v16u8, unsigned char); +#define __msa_maxi_u_b __builtin_msa_maxi_u_b +extern v8u16 __builtin_msa_maxi_u_h(v8u16, unsigned char); +#define __msa_maxi_u_h __builtin_msa_maxi_u_h +extern v4u32 __builtin_msa_maxi_u_w(v4u32, unsigned char); +#define __msa_maxi_u_w __builtin_msa_maxi_u_w +extern v2u64 __builtin_msa_maxi_u_d(v2u64, unsigned char); +#define __msa_maxi_u_d __builtin_msa_maxi_u_d +extern v16i8 __builtin_msa_min_s_b(v16i8, v16i8); +#define __msa_min_s_b __builtin_msa_min_s_b +extern v8i16 __builtin_msa_min_s_h(v8i16, v8i16); +#define __msa_min_s_h __builtin_msa_min_s_h +extern v4i32 __builtin_msa_min_s_w(v4i32, v4i32); +#define __msa_min_s_w __builtin_msa_min_s_w +extern v2i64 __builtin_msa_min_s_d(v2i64, v2i64); +#define __msa_min_s_d __builtin_msa_min_s_d +extern v16i8 __builtin_msa_mini_s_b(v16i8, char); +#define __msa_mini_s_b __builtin_msa_mini_s_b +extern v8i16 __builtin_msa_mini_s_h(v8i16, char); +#define __msa_mini_s_h __builtin_msa_mini_s_h +extern v4i32 __builtin_msa_mini_s_w(v4i32, char); +#define __msa_mini_s_w __builtin_msa_mini_s_w +extern v2i64 __builtin_msa_mini_s_d(v2i64, char); +#define __msa_mini_s_d __builtin_msa_mini_s_d +extern v16u8 __builtin_msa_min_u_b(v16u8, v16u8); +#define __msa_min_u_b __builtin_msa_min_u_b +extern v8u16 __builtin_msa_min_u_h(v8u16, v8u16); +#define __msa_min_u_h __builtin_msa_min_u_h +extern v4u32 __builtin_msa_min_u_w(v4u32, v4u32); +#define __msa_min_u_w __builtin_msa_min_u_w +extern v2u64 __builtin_msa_min_u_d(v2u64, v2u64); +#define __msa_min_u_d __builtin_msa_min_u_d +extern v16u8 __builtin_msa_mini_u_b(v16u8, unsigned char); +#define __msa_mini_u_b __builtin_msa_mini_u_b +extern v8u16 __builtin_msa_mini_u_h(v8u16, unsigned char); +#define __msa_mini_u_h __builtin_msa_mini_u_h +extern v4u32 __builtin_msa_mini_u_w(v4u32, unsigned char); +#define __msa_mini_u_w __builtin_msa_mini_u_w +extern v2u64 __builtin_msa_mini_u_d(v2u64, unsigned char); +#define __msa_mini_u_d __builtin_msa_mini_u_d +extern v16i8 __builtin_msa_max_a_b(v16i8, v16i8); +#define __msa_max_a_b __builtin_msa_max_a_b +extern v8i16 __builtin_msa_max_a_h(v8i16, v8i16); +#define __msa_max_a_h __builtin_msa_max_a_h +extern v4i32 __builtin_msa_max_a_w(v4i32, v4i32); +#define __msa_max_a_w __builtin_msa_max_a_w +extern v2i64 __builtin_msa_max_a_d(v2i64, v2i64); +#define __msa_max_a_d __builtin_msa_max_a_d +extern v16i8 __builtin_msa_min_a_b(v16i8, v16i8); +#define __msa_min_a_b __builtin_msa_min_a_b +extern v8i16 __builtin_msa_min_a_h(v8i16, v8i16); +#define __msa_min_a_h __builtin_msa_min_a_h +extern v4i32 __builtin_msa_min_a_w(v4i32, v4i32); +#define __msa_min_a_w __builtin_msa_min_a_w +extern v2i64 __builtin_msa_min_a_d(v2i64, v2i64); +#define __msa_min_a_d __builtin_msa_min_a_d +extern v16i8 __builtin_msa_ceq_b(v16i8, v16i8); +#define __msa_ceq_b __builtin_msa_ceq_b +extern v8i16 __builtin_msa_ceq_h(v8i16, v8i16); +#define __msa_ceq_h __builtin_msa_ceq_h +extern v4i32 __builtin_msa_ceq_w(v4i32, v4i32); +#define __msa_ceq_w __builtin_msa_ceq_w +extern v2i64 __builtin_msa_ceq_d(v2i64, v2i64); +#define __msa_ceq_d __builtin_msa_ceq_d +extern v16i8 __builtin_msa_ceqi_b(v16i8, char); +#define __msa_ceqi_b __builtin_msa_ceqi_b +extern v8i16 __builtin_msa_ceqi_h(v8i16, char); +#define __msa_ceqi_h __builtin_msa_ceqi_h +extern v4i32 __builtin_msa_ceqi_w(v4i32, char); +#define __msa_ceqi_w __builtin_msa_ceqi_w +extern v2i64 __builtin_msa_ceqi_d(v2i64, char); +#define __msa_ceqi_d __builtin_msa_ceqi_d +extern v16i8 __builtin_msa_clt_s_b(v16i8, v16i8); +#define __msa_clt_s_b __builtin_msa_clt_s_b +extern v8i16 __builtin_msa_clt_s_h(v8i16, v8i16); +#define __msa_clt_s_h __builtin_msa_clt_s_h +extern v4i32 __builtin_msa_clt_s_w(v4i32, v4i32); +#define __msa_clt_s_w __builtin_msa_clt_s_w +extern v2i64 __builtin_msa_clt_s_d(v2i64, v2i64); +#define __msa_clt_s_d __builtin_msa_clt_s_d +extern v16i8 __builtin_msa_clti_s_b(v16i8, char); +#define __msa_clti_s_b __builtin_msa_clti_s_b +extern v8i16 __builtin_msa_clti_s_h(v8i16, char); +#define __msa_clti_s_h __builtin_msa_clti_s_h +extern v4i32 __builtin_msa_clti_s_w(v4i32, char); +#define __msa_clti_s_w __builtin_msa_clti_s_w +extern v2i64 __builtin_msa_clti_s_d(v2i64, char); +#define __msa_clti_s_d __builtin_msa_clti_s_d +extern v16i8 __builtin_msa_clt_u_b(v16u8, v16u8); +#define __msa_clt_u_b __builtin_msa_clt_u_b +extern v8i16 __builtin_msa_clt_u_h(v8u16, v8u16); +#define __msa_clt_u_h __builtin_msa_clt_u_h +extern v4i32 __builtin_msa_clt_u_w(v4u32, v4u32); +#define __msa_clt_u_w __builtin_msa_clt_u_w +extern v2i64 __builtin_msa_clt_u_d(v2u64, v2u64); +#define __msa_clt_u_d __builtin_msa_clt_u_d +extern v16i8 __builtin_msa_clti_u_b(v16u8, unsigned char); +#define __msa_clti_u_b __builtin_msa_clti_u_b +extern v8i16 __builtin_msa_clti_u_h(v8u16, unsigned char); +#define __msa_clti_u_h __builtin_msa_clti_u_h +extern v4i32 __builtin_msa_clti_u_w(v4u32, unsigned char); +#define __msa_clti_u_w __builtin_msa_clti_u_w +extern v2i64 __builtin_msa_clti_u_d(v2u64, unsigned char); +#define __msa_clti_u_d __builtin_msa_clti_u_d +extern v16i8 __builtin_msa_cle_s_b(v16i8, v16i8); +#define __msa_cle_s_b __builtin_msa_cle_s_b +extern v8i16 __builtin_msa_cle_s_h(v8i16, v8i16); +#define __msa_cle_s_h __builtin_msa_cle_s_h +extern v4i32 __builtin_msa_cle_s_w(v4i32, v4i32); +#define __msa_cle_s_w __builtin_msa_cle_s_w +extern v2i64 __builtin_msa_cle_s_d(v2i64, v2i64); +#define __msa_cle_s_d __builtin_msa_cle_s_d +extern v16i8 __builtin_msa_clei_s_b(v16i8, char); +#define __msa_clei_s_b __builtin_msa_clei_s_b +extern v8i16 __builtin_msa_clei_s_h(v8i16, char); +#define __msa_clei_s_h __builtin_msa_clei_s_h +extern v4i32 __builtin_msa_clei_s_w(v4i32, char); +#define __msa_clei_s_w __builtin_msa_clei_s_w +extern v2i64 __builtin_msa_clei_s_d(v2i64, char); +#define __msa_clei_s_d __builtin_msa_clei_s_d +extern v16i8 __builtin_msa_cle_u_b(v16u8, v16u8); +#define __msa_cle_u_b __builtin_msa_cle_u_b +extern v8i16 __builtin_msa_cle_u_h(v8u16, v8u16); +#define __msa_cle_u_h __builtin_msa_cle_u_h +extern v4i32 __builtin_msa_cle_u_w(v4u32, v4u32); +#define __msa_cle_u_w __builtin_msa_cle_u_w +extern v2i64 __builtin_msa_cle_u_d(v2u64, v2u64); +#define __msa_cle_u_d __builtin_msa_cle_u_d +extern v16i8 __builtin_msa_clei_u_b(v16u8, unsigned char); +#define __msa_clei_u_b __builtin_msa_clei_u_b +extern v8i16 __builtin_msa_clei_u_h(v8u16, unsigned char); +#define __msa_clei_u_h __builtin_msa_clei_u_h +extern v4i32 __builtin_msa_clei_u_w(v4u32, unsigned char); +#define __msa_clei_u_w __builtin_msa_clei_u_w +extern v2i64 __builtin_msa_clei_u_d(v2u64, unsigned char); +#define __msa_clei_u_d __builtin_msa_clei_u_d +extern v16i8 __builtin_msa_ld_b(void *, int); +#define __msa_ld_b __builtin_msa_ld_b +extern v8i16 __builtin_msa_ld_h(void *, int); +#define __msa_ld_h __builtin_msa_ld_h +extern v4i32 __builtin_msa_ld_w(void *, int); +#define __msa_ld_w __builtin_msa_ld_w +extern v2i64 __builtin_msa_ld_d(void *, int); +#define __msa_ld_d __builtin_msa_ld_d +extern v16i8 __builtin_msa_sat_s_b(v16i8, unsigned char); +#define __msa_sat_s_b __builtin_msa_sat_s_b +extern v8i16 __builtin_msa_sat_s_h(v8i16, unsigned char); +#define __msa_sat_s_h __builtin_msa_sat_s_h +extern v4i32 __builtin_msa_sat_s_w(v4i32, unsigned char); +#define __msa_sat_s_w __builtin_msa_sat_s_w +extern v2i64 __builtin_msa_sat_s_d(v2i64, unsigned char); +#define __msa_sat_s_d __builtin_msa_sat_s_d +extern v16u8 __builtin_msa_sat_u_b(v16u8, unsigned char); +#define __msa_sat_u_b __builtin_msa_sat_u_b +extern v8u16 __builtin_msa_sat_u_h(v8u16, unsigned char); +#define __msa_sat_u_h __builtin_msa_sat_u_h +extern v4u32 __builtin_msa_sat_u_w(v4u32, unsigned char); +#define __msa_sat_u_w __builtin_msa_sat_u_w +extern v2u64 __builtin_msa_sat_u_d(v2u64, unsigned char); +#define __msa_sat_u_d __builtin_msa_sat_u_d +extern v16i8 __builtin_msa_add_a_b(v16i8, v16i8); +#define __msa_add_a_b __builtin_msa_add_a_b +extern v8i16 __builtin_msa_add_a_h(v8i16, v8i16); +#define __msa_add_a_h __builtin_msa_add_a_h +extern v4i32 __builtin_msa_add_a_w(v4i32, v4i32); +#define __msa_add_a_w __builtin_msa_add_a_w +extern v2i64 __builtin_msa_add_a_d(v2i64, v2i64); +#define __msa_add_a_d __builtin_msa_add_a_d +extern v16i8 __builtin_msa_adds_a_b(v16i8, v16i8); +#define __msa_adds_a_b __builtin_msa_adds_a_b +extern v8i16 __builtin_msa_adds_a_h(v8i16, v8i16); +#define __msa_adds_a_h __builtin_msa_adds_a_h +extern v4i32 __builtin_msa_adds_a_w(v4i32, v4i32); +#define __msa_adds_a_w __builtin_msa_adds_a_w +extern v2i64 __builtin_msa_adds_a_d(v2i64, v2i64); +#define __msa_adds_a_d __builtin_msa_adds_a_d +extern v16i8 __builtin_msa_adds_s_b(v16i8, v16i8); +#define __msa_adds_s_b __builtin_msa_adds_s_b +extern v8i16 __builtin_msa_adds_s_h(v8i16, v8i16); +#define __msa_adds_s_h __builtin_msa_adds_s_h +extern v4i32 __builtin_msa_adds_s_w(v4i32, v4i32); +#define __msa_adds_s_w __builtin_msa_adds_s_w +extern v2i64 __builtin_msa_adds_s_d(v2i64, v2i64); +#define __msa_adds_s_d __builtin_msa_adds_s_d +extern v16u8 __builtin_msa_adds_u_b(v16u8, v16u8); +#define __msa_adds_u_b __builtin_msa_adds_u_b +extern v8u16 __builtin_msa_adds_u_h(v8u16, v8u16); +#define __msa_adds_u_h __builtin_msa_adds_u_h +extern v4u32 __builtin_msa_adds_u_w(v4u32, v4u32); +#define __msa_adds_u_w __builtin_msa_adds_u_w +extern v2u64 __builtin_msa_adds_u_d(v2u64, v2u64); +#define __msa_adds_u_d __builtin_msa_adds_u_d +extern v16i8 __builtin_msa_ave_s_b(v16i8, v16i8); +#define __msa_ave_s_b __builtin_msa_ave_s_b +extern v8i16 __builtin_msa_ave_s_h(v8i16, v8i16); +#define __msa_ave_s_h __builtin_msa_ave_s_h +extern v4i32 __builtin_msa_ave_s_w(v4i32, v4i32); +#define __msa_ave_s_w __builtin_msa_ave_s_w +extern v2i64 __builtin_msa_ave_s_d(v2i64, v2i64); +#define __msa_ave_s_d __builtin_msa_ave_s_d +extern v16u8 __builtin_msa_ave_u_b(v16u8, v16u8); +#define __msa_ave_u_b __builtin_msa_ave_u_b +extern v8u16 __builtin_msa_ave_u_h(v8u16, v8u16); +#define __msa_ave_u_h __builtin_msa_ave_u_h +extern v4u32 __builtin_msa_ave_u_w(v4u32, v4u32); +#define __msa_ave_u_w __builtin_msa_ave_u_w +extern v2u64 __builtin_msa_ave_u_d(v2u64, v2u64); +#define __msa_ave_u_d __builtin_msa_ave_u_d +extern v16i8 __builtin_msa_aver_s_b(v16i8, v16i8); +#define __msa_aver_s_b __builtin_msa_aver_s_b +extern v8i16 __builtin_msa_aver_s_h(v8i16, v8i16); +#define __msa_aver_s_h __builtin_msa_aver_s_h +extern v4i32 __builtin_msa_aver_s_w(v4i32, v4i32); +#define __msa_aver_s_w __builtin_msa_aver_s_w +extern v2i64 __builtin_msa_aver_s_d(v2i64, v2i64); +#define __msa_aver_s_d __builtin_msa_aver_s_d +extern v16u8 __builtin_msa_aver_u_b(v16u8, v16u8); +#define __msa_aver_u_b __builtin_msa_aver_u_b +extern v8u16 __builtin_msa_aver_u_h(v8u16, v8u16); +#define __msa_aver_u_h __builtin_msa_aver_u_h +extern v4u32 __builtin_msa_aver_u_w(v4u32, v4u32); +#define __msa_aver_u_w __builtin_msa_aver_u_w +extern v2u64 __builtin_msa_aver_u_d(v2u64, v2u64); +#define __msa_aver_u_d __builtin_msa_aver_u_d +extern v16i8 __builtin_msa_subs_s_b(v16i8, v16i8); +#define __msa_subs_s_b __builtin_msa_subs_s_b +extern v8i16 __builtin_msa_subs_s_h(v8i16, v8i16); +#define __msa_subs_s_h __builtin_msa_subs_s_h +extern v4i32 __builtin_msa_subs_s_w(v4i32, v4i32); +#define __msa_subs_s_w __builtin_msa_subs_s_w +extern v2i64 __builtin_msa_subs_s_d(v2i64, v2i64); +#define __msa_subs_s_d __builtin_msa_subs_s_d +extern v16u8 __builtin_msa_subs_u_b(v16u8, v16u8); +#define __msa_subs_u_b __builtin_msa_subs_u_b +extern v8u16 __builtin_msa_subs_u_h(v8u16, v8u16); +#define __msa_subs_u_h __builtin_msa_subs_u_h +extern v4u32 __builtin_msa_subs_u_w(v4u32, v4u32); +#define __msa_subs_u_w __builtin_msa_subs_u_w +extern v2u64 __builtin_msa_subs_u_d(v2u64, v2u64); +#define __msa_subs_u_d __builtin_msa_subs_u_d +extern v16i8 __builtin_msa_subsuu_s_b(v16u8, v16u8); +#define __msa_subsuu_s_b __builtin_msa_subsuu_s_b +extern v8i16 __builtin_msa_subsuu_s_h(v8u16, v8u16); +#define __msa_subsuu_s_h __builtin_msa_subsuu_s_h +extern v4i32 __builtin_msa_subsuu_s_w(v4u32, v4u32); +#define __msa_subsuu_s_w __builtin_msa_subsuu_s_w +extern v2i64 __builtin_msa_subsuu_s_d(v2u64, v2u64); +#define __msa_subsuu_s_d __builtin_msa_subsuu_s_d +extern v16u8 __builtin_msa_subsus_u_b(v16u8, v16i8); +#define __msa_subsus_u_b __builtin_msa_subsus_u_b +extern v8u16 __builtin_msa_subsus_u_h(v8u16, v8i16); +#define __msa_subsus_u_h __builtin_msa_subsus_u_h +extern v4u32 __builtin_msa_subsus_u_w(v4u32, v4i32); +#define __msa_subsus_u_w __builtin_msa_subsus_u_w +extern v2u64 __builtin_msa_subsus_u_d(v2u64, v2i64); +#define __msa_subsus_u_d __builtin_msa_subsus_u_d +extern v16i8 __builtin_msa_asub_s_b(v16i8, v16i8); +#define __msa_asub_s_b __builtin_msa_asub_s_b +extern v8i16 __builtin_msa_asub_s_h(v8i16, v8i16); +#define __msa_asub_s_h __builtin_msa_asub_s_h +extern v4i32 __builtin_msa_asub_s_w(v4i32, v4i32); +#define __msa_asub_s_w __builtin_msa_asub_s_w +extern v2i64 __builtin_msa_asub_s_d(v2i64, v2i64); +#define __msa_asub_s_d __builtin_msa_asub_s_d +extern v16u8 __builtin_msa_asub_u_b(v16u8, v16u8); +#define __msa_asub_u_b __builtin_msa_asub_u_b +extern v8u16 __builtin_msa_asub_u_h(v8u16, v8u16); +#define __msa_asub_u_h __builtin_msa_asub_u_h +extern v4u32 __builtin_msa_asub_u_w(v4u32, v4u32); +#define __msa_asub_u_w __builtin_msa_asub_u_w +extern v2u64 __builtin_msa_asub_u_d(v2u64, v2u64); +#define __msa_asub_u_d __builtin_msa_asub_u_d +extern v16i8 __builtin_msa_mulv_b(v16i8, v16i8); +#define __msa_mulv_b __builtin_msa_mulv_b +extern v8i16 __builtin_msa_mulv_h(v8i16, v8i16); +#define __msa_mulv_h __builtin_msa_mulv_h +extern v4i32 __builtin_msa_mulv_w(v4i32, v4i32); +#define __msa_mulv_w __builtin_msa_mulv_w +extern v2i64 __builtin_msa_mulv_d(v2i64, v2i64); +#define __msa_mulv_d __builtin_msa_mulv_d +extern v16i8 __builtin_msa_maddv_b(v16i8, v16i8, v16i8); +#define __msa_maddv_b __builtin_msa_maddv_b +extern v8i16 __builtin_msa_maddv_h(v8i16, v8i16, v8i16); +#define __msa_maddv_h __builtin_msa_maddv_h +extern v4i32 __builtin_msa_maddv_w(v4i32, v4i32, v4i32); +#define __msa_maddv_w __builtin_msa_maddv_w +extern v2i64 __builtin_msa_maddv_d(v2i64, v2i64, v2i64); +#define __msa_maddv_d __builtin_msa_maddv_d +extern v16i8 __builtin_msa_msubv_b(v16i8, v16i8, v16i8); +#define __msa_msubv_b __builtin_msa_msubv_b +extern v8i16 __builtin_msa_msubv_h(v8i16, v8i16, v8i16); +#define __msa_msubv_h __builtin_msa_msubv_h +extern v4i32 __builtin_msa_msubv_w(v4i32, v4i32, v4i32); +#define __msa_msubv_w __builtin_msa_msubv_w +extern v2i64 __builtin_msa_msubv_d(v2i64, v2i64, v2i64); +#define __msa_msubv_d __builtin_msa_msubv_d +extern v16i8 __builtin_msa_div_s_b(v16i8, v16i8); +#define __msa_div_s_b __builtin_msa_div_s_b +extern v8i16 __builtin_msa_div_s_h(v8i16, v8i16); +#define __msa_div_s_h __builtin_msa_div_s_h +extern v4i32 __builtin_msa_div_s_w(v4i32, v4i32); +#define __msa_div_s_w __builtin_msa_div_s_w +extern v2i64 __builtin_msa_div_s_d(v2i64, v2i64); +#define __msa_div_s_d __builtin_msa_div_s_d +extern v16u8 __builtin_msa_div_u_b(v16u8, v16u8); +#define __msa_div_u_b __builtin_msa_div_u_b +extern v8u16 __builtin_msa_div_u_h(v8u16, v8u16); +#define __msa_div_u_h __builtin_msa_div_u_h +extern v4u32 __builtin_msa_div_u_w(v4u32, v4u32); +#define __msa_div_u_w __builtin_msa_div_u_w +extern v2u64 __builtin_msa_div_u_d(v2u64, v2u64); +#define __msa_div_u_d __builtin_msa_div_u_d +extern v8i16 __builtin_msa_hadd_s_h(v16i8, v16i8); +#define __msa_hadd_s_h __builtin_msa_hadd_s_h +extern v4i32 __builtin_msa_hadd_s_w(v8i16, v8i16); +#define __msa_hadd_s_w __builtin_msa_hadd_s_w +extern v2i64 __builtin_msa_hadd_s_d(v4i32, v4i32); +#define __msa_hadd_s_d __builtin_msa_hadd_s_d +extern v8u16 __builtin_msa_hadd_u_h(v16u8, v16u8); +#define __msa_hadd_u_h __builtin_msa_hadd_u_h +extern v4u32 __builtin_msa_hadd_u_w(v8u16, v8u16); +#define __msa_hadd_u_w __builtin_msa_hadd_u_w +extern v2u64 __builtin_msa_hadd_u_d(v4u32, v4u32); +#define __msa_hadd_u_d __builtin_msa_hadd_u_d +extern v8i16 __builtin_msa_hsub_s_h(v16i8, v16i8); +#define __msa_hsub_s_h __builtin_msa_hsub_s_h +extern v4i32 __builtin_msa_hsub_s_w(v8i16, v8i16); +#define __msa_hsub_s_w __builtin_msa_hsub_s_w +extern v2i64 __builtin_msa_hsub_s_d(v4i32, v4i32); +#define __msa_hsub_s_d __builtin_msa_hsub_s_d +extern v8i16 __builtin_msa_hsub_u_h(v16u8, v16u8); +#define __msa_hsub_u_h __builtin_msa_hsub_u_h +extern v4i32 __builtin_msa_hsub_u_w(v8u16, v8u16); +#define __msa_hsub_u_w __builtin_msa_hsub_u_w +extern v2i64 __builtin_msa_hsub_u_d(v4u32, v4u32); +#define __msa_hsub_u_d __builtin_msa_hsub_u_d +extern v16i8 __builtin_msa_mod_s_b(v16i8, v16i8); +#define __msa_mod_s_b __builtin_msa_mod_s_b +extern v8i16 __builtin_msa_mod_s_h(v8i16, v8i16); +#define __msa_mod_s_h __builtin_msa_mod_s_h +extern v4i32 __builtin_msa_mod_s_w(v4i32, v4i32); +#define __msa_mod_s_w __builtin_msa_mod_s_w +extern v2i64 __builtin_msa_mod_s_d(v2i64, v2i64); +#define __msa_mod_s_d __builtin_msa_mod_s_d +extern v16u8 __builtin_msa_mod_u_b(v16u8, v16u8); +#define __msa_mod_u_b __builtin_msa_mod_u_b +extern v8u16 __builtin_msa_mod_u_h(v8u16, v8u16); +#define __msa_mod_u_h __builtin_msa_mod_u_h +extern v4u32 __builtin_msa_mod_u_w(v4u32, v4u32); +#define __msa_mod_u_w __builtin_msa_mod_u_w +extern v2u64 __builtin_msa_mod_u_d(v2u64, v2u64); +#define __msa_mod_u_d __builtin_msa_mod_u_d +extern v8i16 __builtin_msa_dotp_s_h(v16i8, v16i8); +#define __msa_dotp_s_h __builtin_msa_dotp_s_h +extern v4i32 __builtin_msa_dotp_s_w(v8i16, v8i16); +#define __msa_dotp_s_w __builtin_msa_dotp_s_w +extern v2i64 __builtin_msa_dotp_s_d(v4i32, v4i32); +#define __msa_dotp_s_d __builtin_msa_dotp_s_d +extern v8u16 __builtin_msa_dotp_u_h(v16u8, v16u8); +#define __msa_dotp_u_h __builtin_msa_dotp_u_h +extern v4u32 __builtin_msa_dotp_u_w(v8u16, v8u16); +#define __msa_dotp_u_w __builtin_msa_dotp_u_w +extern v2u64 __builtin_msa_dotp_u_d(v4u32, v4u32); +#define __msa_dotp_u_d __builtin_msa_dotp_u_d +extern v8i16 __builtin_msa_dpadd_s_h(v8i16, v16i8, v16i8); +#define __msa_dpadd_s_h __builtin_msa_dpadd_s_h +extern v4i32 __builtin_msa_dpadd_s_w(v4i32, v8i16, v8i16); +#define __msa_dpadd_s_w __builtin_msa_dpadd_s_w +extern v2i64 __builtin_msa_dpadd_s_d(v2i64, v4i32, v4i32); +#define __msa_dpadd_s_d __builtin_msa_dpadd_s_d +extern v8u16 __builtin_msa_dpadd_u_h(v8u16, v16u8, v16u8); +#define __msa_dpadd_u_h __builtin_msa_dpadd_u_h +extern v4u32 __builtin_msa_dpadd_u_w(v4u32, v8u16, v8u16); +#define __msa_dpadd_u_w __builtin_msa_dpadd_u_w +extern v2u64 __builtin_msa_dpadd_u_d(v2u64, v4u32, v4u32); +#define __msa_dpadd_u_d __builtin_msa_dpadd_u_d +extern v8i16 __builtin_msa_dpsub_s_h(v8i16, v16i8, v16i8); +#define __msa_dpsub_s_h __builtin_msa_dpsub_s_h +extern v4i32 __builtin_msa_dpsub_s_w(v4i32, v8i16, v8i16); +#define __msa_dpsub_s_w __builtin_msa_dpsub_s_w +extern v2i64 __builtin_msa_dpsub_s_d(v2i64, v4i32, v4i32); +#define __msa_dpsub_s_d __builtin_msa_dpsub_s_d +extern v8i16 __builtin_msa_dpsub_u_h(v8i16, v16u8, v16u8); +#define __msa_dpsub_u_h __builtin_msa_dpsub_u_h +extern v4i32 __builtin_msa_dpsub_u_w(v4i32, v8u16, v8u16); +#define __msa_dpsub_u_w __builtin_msa_dpsub_u_w +extern v2i64 __builtin_msa_dpsub_u_d(v2i64, v4u32, v4u32); +#define __msa_dpsub_u_d __builtin_msa_dpsub_u_d +extern v16i8 __builtin_msa_sld_b(v16i8, v16i8, int); +#define __msa_sld_b __builtin_msa_sld_b +extern v8i16 __builtin_msa_sld_h(v8i16, v8i16, int); +#define __msa_sld_h __builtin_msa_sld_h +extern v4i32 __builtin_msa_sld_w(v4i32, v4i32, int); +#define __msa_sld_w __builtin_msa_sld_w +extern v2i64 __builtin_msa_sld_d(v2i64, v2i64, int); +#define __msa_sld_d __builtin_msa_sld_d +extern v16i8 __builtin_msa_sldi_b(v16i8, v16i8, unsigned char); +#define __msa_sldi_b __builtin_msa_sldi_b +extern v8i16 __builtin_msa_sldi_h(v8i16, v8i16, unsigned char); +#define __msa_sldi_h __builtin_msa_sldi_h +extern v4i32 __builtin_msa_sldi_w(v4i32, v4i32, unsigned char); +#define __msa_sldi_w __builtin_msa_sldi_w +extern v2i64 __builtin_msa_sldi_d(v2i64, v2i64, unsigned char); +#define __msa_sldi_d __builtin_msa_sldi_d +extern v16i8 __builtin_msa_splat_b(v16i8, int); +#define __msa_splat_b __builtin_msa_splat_b +extern v8i16 __builtin_msa_splat_h(v8i16, int); +#define __msa_splat_h __builtin_msa_splat_h +extern v4i32 __builtin_msa_splat_w(v4i32, int); +#define __msa_splat_w __builtin_msa_splat_w +extern v2i64 __builtin_msa_splat_d(v2i64, int); +#define __msa_splat_d __builtin_msa_splat_d +extern v16i8 __builtin_msa_splati_b(v16i8, unsigned char); +#define __msa_splati_b __builtin_msa_splati_b +extern v8i16 __builtin_msa_splati_h(v8i16, unsigned char); +#define __msa_splati_h __builtin_msa_splati_h +extern v4i32 __builtin_msa_splati_w(v4i32, unsigned char); +#define __msa_splati_w __builtin_msa_splati_w +extern v2i64 __builtin_msa_splati_d(v2i64, unsigned char); +#define __msa_splati_d __builtin_msa_splati_d +extern v16i8 __builtin_msa_pckev_b(v16i8, v16i8); +#define __msa_pckev_b __builtin_msa_pckev_b +extern v8i16 __builtin_msa_pckev_h(v8i16, v8i16); +#define __msa_pckev_h __builtin_msa_pckev_h +extern v4i32 __builtin_msa_pckev_w(v4i32, v4i32); +#define __msa_pckev_w __builtin_msa_pckev_w +extern v2i64 __builtin_msa_pckev_d(v2i64, v2i64); +#define __msa_pckev_d __builtin_msa_pckev_d +extern v16i8 __builtin_msa_pckod_b(v16i8, v16i8); +#define __msa_pckod_b __builtin_msa_pckod_b +extern v8i16 __builtin_msa_pckod_h(v8i16, v8i16); +#define __msa_pckod_h __builtin_msa_pckod_h +extern v4i32 __builtin_msa_pckod_w(v4i32, v4i32); +#define __msa_pckod_w __builtin_msa_pckod_w +extern v2i64 __builtin_msa_pckod_d(v2i64, v2i64); +#define __msa_pckod_d __builtin_msa_pckod_d +extern v16i8 __builtin_msa_ilvl_b(v16i8, v16i8); +#define __msa_ilvl_b __builtin_msa_ilvl_b +extern v8i16 __builtin_msa_ilvl_h(v8i16, v8i16); +#define __msa_ilvl_h __builtin_msa_ilvl_h +extern v4i32 __builtin_msa_ilvl_w(v4i32, v4i32); +#define __msa_ilvl_w __builtin_msa_ilvl_w +extern v2i64 __builtin_msa_ilvl_d(v2i64, v2i64); +#define __msa_ilvl_d __builtin_msa_ilvl_d +extern v16i8 __builtin_msa_ilvr_b(v16i8, v16i8); +#define __msa_ilvr_b __builtin_msa_ilvr_b +extern v8i16 __builtin_msa_ilvr_h(v8i16, v8i16); +#define __msa_ilvr_h __builtin_msa_ilvr_h +extern v4i32 __builtin_msa_ilvr_w(v4i32, v4i32); +#define __msa_ilvr_w __builtin_msa_ilvr_w +extern v2i64 __builtin_msa_ilvr_d(v2i64, v2i64); +#define __msa_ilvr_d __builtin_msa_ilvr_d +extern v16i8 __builtin_msa_ilvev_b(v16i8, v16i8); +#define __msa_ilvev_b __builtin_msa_ilvev_b +extern v8i16 __builtin_msa_ilvev_h(v8i16, v8i16); +#define __msa_ilvev_h __builtin_msa_ilvev_h +extern v4i32 __builtin_msa_ilvev_w(v4i32, v4i32); +#define __msa_ilvev_w __builtin_msa_ilvev_w +extern v2i64 __builtin_msa_ilvev_d(v2i64, v2i64); +#define __msa_ilvev_d __builtin_msa_ilvev_d +extern v16i8 __builtin_msa_ilvod_b(v16i8, v16i8); +#define __msa_ilvod_b __builtin_msa_ilvod_b +extern v8i16 __builtin_msa_ilvod_h(v8i16, v8i16); +#define __msa_ilvod_h __builtin_msa_ilvod_h +extern v4i32 __builtin_msa_ilvod_w(v4i32, v4i32); +#define __msa_ilvod_w __builtin_msa_ilvod_w +extern v2i64 __builtin_msa_ilvod_d(v2i64, v2i64); +#define __msa_ilvod_d __builtin_msa_ilvod_d +extern v16i8 __builtin_msa_vshf_b(v16i8, v16i8, v16i8); +#define __msa_vshf_b __builtin_msa_vshf_b +extern v8i16 __builtin_msa_vshf_h(v8i16, v8i16, v8i16); +#define __msa_vshf_h __builtin_msa_vshf_h +extern v4i32 __builtin_msa_vshf_w(v4i32, v4i32, v4i32); +#define __msa_vshf_w __builtin_msa_vshf_w +extern v2i64 __builtin_msa_vshf_d(v2i64, v2i64, v2i64); +#define __msa_vshf_d __builtin_msa_vshf_d +extern v16u8 __builtin_msa_and_v(v16u8, v16u8); +#define __msa_and_v __builtin_msa_and_v +extern v16u8 __builtin_msa_andi_b(v16u8, unsigned char); +#define __msa_andi_b __builtin_msa_andi_b +extern v16u8 __builtin_msa_or_v(v16u8, v16u8); +#define __msa_or_v __builtin_msa_or_v +extern v16u8 __builtin_msa_ori_b(v16u8, unsigned char); +#define __msa_ori_b __builtin_msa_ori_b +extern v16u8 __builtin_msa_nor_v(v16u8, v16u8); +#define __msa_nor_v __builtin_msa_nor_v +extern v16u8 __builtin_msa_nori_b(v16u8, unsigned char); +#define __msa_nori_b __builtin_msa_nori_b +extern v16u8 __builtin_msa_xor_v(v16u8, v16u8); +#define __msa_xor_v __builtin_msa_xor_v +extern v16u8 __builtin_msa_xori_b(v16u8, unsigned char); +#define __msa_xori_b __builtin_msa_xori_b +extern v16u8 __builtin_msa_bmnz_v(v16u8, v16u8, v16u8); +#define __msa_bmnz_v __builtin_msa_bmnz_v +extern v16u8 __builtin_msa_bmnzi_b(v16u8, v16u8, unsigned char); +#define __msa_bmnzi_b __builtin_msa_bmnzi_b +extern v16u8 __builtin_msa_bmz_v(v16u8, v16u8, v16u8); +#define __msa_bmz_v __builtin_msa_bmz_v +extern v16u8 __builtin_msa_bmzi_b(v16u8, v16u8, unsigned char); +#define __msa_bmzi_b __builtin_msa_bmzi_b +extern v16u8 __builtin_msa_bsel_v(v16u8, v16u8, v16u8); +#define __msa_bsel_v __builtin_msa_bsel_v +extern v16u8 __builtin_msa_bseli_b(v16u8, v16u8, unsigned char); +#define __msa_bseli_b __builtin_msa_bseli_b +extern v16i8 __builtin_msa_shf_b(v16i8, unsigned char); +#define __msa_shf_b __builtin_msa_shf_b +extern v8i16 __builtin_msa_shf_h(v8i16, unsigned char); +#define __msa_shf_h __builtin_msa_shf_h +extern v4i32 __builtin_msa_shf_w(v4i32, unsigned char); +#define __msa_shf_w __builtin_msa_shf_w +extern int __builtin_msa_bnz_v(v16u8); +#define __msa_test_bnz_v __builtin_msa_bnz_v +extern int __builtin_msa_bz_v(v16u8); +#define __msa_test_bz_v __builtin_msa_bz_v +extern v16i8 __builtin_msa_fill_b(int); +#define __msa_fill_b __builtin_msa_fill_b +extern v8i16 __builtin_msa_fill_h(int); +#define __msa_fill_h __builtin_msa_fill_h +extern v4i32 __builtin_msa_fill_w(int); +#define __msa_fill_w __builtin_msa_fill_w +extern v2i64 __builtin_msa_fill_d(long long); +#define __msa_fill_d __builtin_msa_fill_d +extern v16i8 __builtin_msa_pcnt_b(v16i8); +#define __msa_pcnt_b __builtin_msa_pcnt_b +extern v8i16 __builtin_msa_pcnt_h(v8i16); +#define __msa_pcnt_h __builtin_msa_pcnt_h +extern v4i32 __builtin_msa_pcnt_w(v4i32); +#define __msa_pcnt_w __builtin_msa_pcnt_w +extern v2i64 __builtin_msa_pcnt_d(v2i64); +#define __msa_pcnt_d __builtin_msa_pcnt_d +extern v16i8 __builtin_msa_nloc_b(v16i8); +#define __msa_nloc_b __builtin_msa_nloc_b +extern v8i16 __builtin_msa_nloc_h(v8i16); +#define __msa_nloc_h __builtin_msa_nloc_h +extern v4i32 __builtin_msa_nloc_w(v4i32); +#define __msa_nloc_w __builtin_msa_nloc_w +extern v2i64 __builtin_msa_nloc_d(v2i64); +#define __msa_nloc_d __builtin_msa_nloc_d +extern v16i8 __builtin_msa_nlzc_b(v16i8); +#define __msa_nlzc_b __builtin_msa_nlzc_b +extern v8i16 __builtin_msa_nlzc_h(v8i16); +#define __msa_nlzc_h __builtin_msa_nlzc_h +extern v4i32 __builtin_msa_nlzc_w(v4i32); +#define __msa_nlzc_w __builtin_msa_nlzc_w +extern v2i64 __builtin_msa_nlzc_d(v2i64); +#define __msa_nlzc_d __builtin_msa_nlzc_d +extern int __builtin_msa_copy_s_b(v16i8, unsigned char); +#define __msa_copy_s_b __builtin_msa_copy_s_b +extern int __builtin_msa_copy_s_h(v8i16, unsigned char); +#define __msa_copy_s_h __builtin_msa_copy_s_h +extern int __builtin_msa_copy_s_w(v4i32, unsigned char); +#define __msa_copy_s_w __builtin_msa_copy_s_w +extern long long __builtin_msa_copy_s_d(v2i64, unsigned char); +#define __msa_copy_s_d __builtin_msa_copy_s_d +extern int __builtin_msa_copy_u_b(v16i8, unsigned char); +#define __msa_copy_u_b __builtin_msa_copy_u_b +extern int __builtin_msa_copy_u_h(v8i16, unsigned char); +#define __msa_copy_u_h __builtin_msa_copy_u_h +extern int __builtin_msa_copy_u_w(v4i32, unsigned char); +#define __msa_copy_u_w __builtin_msa_copy_u_w +extern long long __builtin_msa_copy_u_d(v2i64, unsigned char); +#define __msa_copy_u_d __builtin_msa_copy_u_d +extern v16i8 __builtin_msa_insert_b(v16i8, unsigned char, int); +#define __msa_insert_b __builtin_msa_insert_b +extern v8i16 __builtin_msa_insert_h(v8i16, unsigned char, int); +#define __msa_insert_h __builtin_msa_insert_h +extern v4i32 __builtin_msa_insert_w(v4i32, unsigned char, int); +#define __msa_insert_w __builtin_msa_insert_w +extern v2i64 __builtin_msa_insert_d(v2i64, unsigned char, long long); +#define __msa_insert_d __builtin_msa_insert_d +extern v16i8 __builtin_msa_insve_b(v16i8, unsigned char, v16i8); +#define __msa_insve_b __builtin_msa_insve_b +extern v8i16 __builtin_msa_insve_h(v8i16, unsigned char, v8i16); +#define __msa_insve_h __builtin_msa_insve_h +extern v4i32 __builtin_msa_insve_w(v4i32, unsigned char, v4i32); +#define __msa_insve_w __builtin_msa_insve_w +extern v2i64 __builtin_msa_insve_d(v2i64, unsigned char, v2i64); +#define __msa_insve_d __builtin_msa_insve_d +extern int __builtin_msa_bnz_b(v16u8); +#define __msa_test_bnz_b __builtin_msa_bnz_b +extern int __builtin_msa_bnz_h(v8u16); +#define __msa_test_bnz_h __builtin_msa_bnz_h +extern int __builtin_msa_bnz_w(v4u32); +#define __msa_test_bnz_w __builtin_msa_bnz_w +extern int __builtin_msa_bnz_d(v2u64); +#define __msa_test_bnz_d __builtin_msa_bnz_d +extern int __builtin_msa_bz_b(v16u8); +#define __msa_test_bz_b __builtin_msa_bz_b +extern int __builtin_msa_bz_h(v8u16); +#define __msa_test_bz_h __builtin_msa_bz_h +extern int __builtin_msa_bz_w(v4u32); +#define __msa_test_bz_w __builtin_msa_bz_w +extern int __builtin_msa_bz_d(v2u64); +#define __msa_test_bz_d __builtin_msa_bz_d +extern v16i8 __builtin_msa_ldi_b(short); +#define __msa_ldi_b __builtin_msa_ldi_b +extern v8i16 __builtin_msa_ldi_h(short); +#define __msa_ldi_h __builtin_msa_ldi_h +extern v4i32 __builtin_msa_ldi_w(short); +#define __msa_ldi_w __builtin_msa_ldi_w +extern v2i64 __builtin_msa_ldi_d(short); +#define __msa_ldi_d __builtin_msa_ldi_d +extern v4i32 __builtin_msa_fcaf_w(v4f32, v4f32); +#define __msa_fcaf_w __builtin_msa_fcaf_w +extern v2i64 __builtin_msa_fcaf_d(v2f64, v2f64); +#define __msa_fcaf_d __builtin_msa_fcaf_d +extern v4i32 __builtin_msa_fcor_w(v4f32, v4f32); +#define __msa_fcor_w __builtin_msa_fcor_w +extern v2i64 __builtin_msa_fcor_d(v2f64, v2f64); +#define __msa_fcor_d __builtin_msa_fcor_d +extern v4i32 __builtin_msa_fcun_w(v4f32, v4f32); +#define __msa_fcun_w __builtin_msa_fcun_w +extern v2i64 __builtin_msa_fcun_d(v2f64, v2f64); +#define __msa_fcun_d __builtin_msa_fcun_d +extern v4i32 __builtin_msa_fcune_w(v4f32, v4f32); +#define __msa_fcune_w __builtin_msa_fcune_w +extern v2i64 __builtin_msa_fcune_d(v2f64, v2f64); +#define __msa_fcune_d __builtin_msa_fcune_d +extern v4i32 __builtin_msa_fcueq_w(v4f32, v4f32); +#define __msa_fcueq_w __builtin_msa_fcueq_w +extern v2i64 __builtin_msa_fcueq_d(v2f64, v2f64); +#define __msa_fcueq_d __builtin_msa_fcueq_d +extern v4i32 __builtin_msa_fceq_w(v4f32, v4f32); +#define __msa_fceq_w __builtin_msa_fceq_w +extern v2i64 __builtin_msa_fceq_d(v2f64, v2f64); +#define __msa_fceq_d __builtin_msa_fceq_d +extern v4i32 __builtin_msa_fcne_w(v4f32, v4f32); +#define __msa_fcne_w __builtin_msa_fcne_w +extern v2i64 __builtin_msa_fcne_d(v2f64, v2f64); +#define __msa_fcne_d __builtin_msa_fcne_d +extern v4i32 __builtin_msa_fclt_w(v4f32, v4f32); +#define __msa_fclt_w __builtin_msa_fclt_w +extern v2i64 __builtin_msa_fclt_d(v2f64, v2f64); +#define __msa_fclt_d __builtin_msa_fclt_d +extern v4i32 __builtin_msa_fcult_w(v4f32, v4f32); +#define __msa_fcult_w __builtin_msa_fcult_w +extern v2i64 __builtin_msa_fcult_d(v2f64, v2f64); +#define __msa_fcult_d __builtin_msa_fcult_d +extern v4i32 __builtin_msa_fcle_w(v4f32, v4f32); +#define __msa_fcle_w __builtin_msa_fcle_w +extern v2i64 __builtin_msa_fcle_d(v2f64, v2f64); +#define __msa_fcle_d __builtin_msa_fcle_d +extern v4i32 __builtin_msa_fcule_w(v4f32, v4f32); +#define __msa_fcule_w __builtin_msa_fcule_w +extern v2i64 __builtin_msa_fcule_d(v2f64, v2f64); +#define __msa_fcule_d __builtin_msa_fcule_d +extern v4i32 __builtin_msa_fsaf_w(v4f32, v4f32); +#define __msa_fsaf_w __builtin_msa_fsaf_w +extern v2i64 __builtin_msa_fsaf_d(v2f64, v2f64); +#define __msa_fsaf_d __builtin_msa_fsaf_d +extern v4i32 __builtin_msa_fsor_w(v4f32, v4f32); +#define __msa_fsor_w __builtin_msa_fsor_w +extern v2i64 __builtin_msa_fsor_d(v2f64, v2f64); +#define __msa_fsor_d __builtin_msa_fsor_d +extern v4i32 __builtin_msa_fsun_w(v4f32, v4f32); +#define __msa_fsun_w __builtin_msa_fsun_w +extern v2i64 __builtin_msa_fsun_d(v2f64, v2f64); +#define __msa_fsun_d __builtin_msa_fsun_d +extern v4i32 __builtin_msa_fsune_w(v4f32, v4f32); +#define __msa_fsune_w __builtin_msa_fsune_w +extern v2i64 __builtin_msa_fsune_d(v2f64, v2f64); +#define __msa_fsune_d __builtin_msa_fsune_d +extern v4i32 __builtin_msa_fsueq_w(v4f32, v4f32); +#define __msa_fsueq_w __builtin_msa_fsueq_w +extern v2i64 __builtin_msa_fsueq_d(v2f64, v2f64); +#define __msa_fsueq_d __builtin_msa_fsueq_d +extern v4i32 __builtin_msa_fseq_w(v4f32, v4f32); +#define __msa_fseq_w __builtin_msa_fseq_w +extern v2i64 __builtin_msa_fseq_d(v2f64, v2f64); +#define __msa_fseq_d __builtin_msa_fseq_d +extern v4i32 __builtin_msa_fsne_w(v4f32, v4f32); +#define __msa_fsne_w __builtin_msa_fsne_w +extern v2i64 __builtin_msa_fsne_d(v2f64, v2f64); +#define __msa_fsne_d __builtin_msa_fsne_d +extern v4i32 __builtin_msa_fslt_w(v4f32, v4f32); +#define __msa_fslt_w __builtin_msa_fslt_w +extern v2i64 __builtin_msa_fslt_d(v2f64, v2f64); +#define __msa_fslt_d __builtin_msa_fslt_d +extern v4i32 __builtin_msa_fsult_w(v4f32, v4f32); +#define __msa_fsult_w __builtin_msa_fsult_w +extern v2i64 __builtin_msa_fsult_d(v2f64, v2f64); +#define __msa_fsult_d __builtin_msa_fsult_d +extern v4i32 __builtin_msa_fsle_w(v4f32, v4f32); +#define __msa_fsle_w __builtin_msa_fsle_w +extern v2i64 __builtin_msa_fsle_d(v2f64, v2f64); +#define __msa_fsle_d __builtin_msa_fsle_d +extern v4i32 __builtin_msa_fsule_w(v4f32, v4f32); +#define __msa_fsule_w __builtin_msa_fsule_w +extern v2i64 __builtin_msa_fsule_d(v2f64, v2f64); +#define __msa_fsule_d __builtin_msa_fsule_d +extern v4f32 __builtin_msa_fadd_w(v4f32, v4f32); +#define __msa_fadd_w __builtin_msa_fadd_w +extern v2f64 __builtin_msa_fadd_d(v2f64, v2f64); +#define __msa_fadd_d __builtin_msa_fadd_d +extern v4f32 __builtin_msa_fsub_w(v4f32, v4f32); +#define __msa_fsub_w __builtin_msa_fsub_w +extern v2f64 __builtin_msa_fsub_d(v2f64, v2f64); +#define __msa_fsub_d __builtin_msa_fsub_d +extern v4f32 __builtin_msa_fmul_w(v4f32, v4f32); +#define __msa_fmul_w __builtin_msa_fmul_w +extern v2f64 __builtin_msa_fmul_d(v2f64, v2f64); +#define __msa_fmul_d __builtin_msa_fmul_d +extern v4f32 __builtin_msa_fdiv_w(v4f32, v4f32); +#define __msa_fdiv_w __builtin_msa_fdiv_w +extern v2f64 __builtin_msa_fdiv_d(v2f64, v2f64); +#define __msa_fdiv_d __builtin_msa_fdiv_d +extern v4f32 __builtin_msa_fmadd_w(v4f32, v4f32, v4f32); +#define __msa_fmadd_w __builtin_msa_fmadd_w +extern v2f64 __builtin_msa_fmadd_d(v2f64, v2f64, v2f64); +#define __msa_fmadd_d __builtin_msa_fmadd_d +extern v4f32 __builtin_msa_fmsub_w(v4f32, v4f32, v4f32); +#define __msa_fmsub_w __builtin_msa_fmsub_w +extern v2f64 __builtin_msa_fmsub_d(v2f64, v2f64, v2f64); +#define __msa_fmsub_d __builtin_msa_fmsub_d +extern v4f32 __builtin_msa_fexp2_w(v4f32, v4i32); +#define __msa_fexp2_w __builtin_msa_fexp2_w +extern v2f64 __builtin_msa_fexp2_d(v2f64, v2i64); +#define __msa_fexp2_d __builtin_msa_fexp2_d +extern v8i16 __builtin_msa_fexdo_h(v4f32, v4f32); +#define __msa_fexdo_h __builtin_msa_fexdo_h +extern v4f32 __builtin_msa_fexdo_w(v2f64, v2f64); +#define __msa_fexdo_w __builtin_msa_fexdo_w +extern v8i16 __builtin_msa_ftq_h(v4f32, v4f32); +#define __msa_ftq_h __builtin_msa_ftq_h +extern v4i32 __builtin_msa_ftq_w(v2f64, v2f64); +#define __msa_ftq_w __builtin_msa_ftq_w +extern v4f32 __builtin_msa_fmin_w(v4f32, v4f32); +#define __msa_fmin_w __builtin_msa_fmin_w +extern v2f64 __builtin_msa_fmin_d(v2f64, v2f64); +#define __msa_fmin_d __builtin_msa_fmin_d +extern v4f32 __builtin_msa_fmin_a_w(v4f32, v4f32); +#define __msa_fmin_a_w __builtin_msa_fmin_a_w +extern v2f64 __builtin_msa_fmin_a_d(v2f64, v2f64); +#define __msa_fmin_a_d __builtin_msa_fmin_a_d +extern v4f32 __builtin_msa_fmax_w(v4f32, v4f32); +#define __msa_fmax_w __builtin_msa_fmax_w +extern v2f64 __builtin_msa_fmax_d(v2f64, v2f64); +#define __msa_fmax_d __builtin_msa_fmax_d +extern v4f32 __builtin_msa_fmax_a_w(v4f32, v4f32); +#define __msa_fmax_a_w __builtin_msa_fmax_a_w +extern v2f64 __builtin_msa_fmax_a_d(v2f64, v2f64); +#define __msa_fmax_a_d __builtin_msa_fmax_a_d +extern v8i16 __builtin_msa_mul_q_h(v8i16, v8i16); +#define __msa_mul_q_h __builtin_msa_mul_q_h +extern v4i32 __builtin_msa_mul_q_w(v4i32, v4i32); +#define __msa_mul_q_w __builtin_msa_mul_q_w +extern v8i16 __builtin_msa_mulr_q_h(v8i16, v8i16); +#define __msa_mulr_q_h __builtin_msa_mulr_q_h +extern v4i32 __builtin_msa_mulr_q_w(v4i32, v4i32); +#define __msa_mulr_q_w __builtin_msa_mulr_q_w +extern v8i16 __builtin_msa_madd_q_h(v8i16, v8i16, v8i16); +#define __msa_madd_q_h __builtin_msa_madd_q_h +extern v4i32 __builtin_msa_madd_q_w(v4i32, v4i32, v4i32); +#define __msa_madd_q_w __builtin_msa_madd_q_w +extern v8i16 __builtin_msa_maddr_q_h(v8i16, v8i16, v8i16); +#define __msa_maddr_q_h __builtin_msa_maddr_q_h +extern v4i32 __builtin_msa_maddr_q_w(v4i32, v4i32, v4i32); +#define __msa_maddr_q_w __builtin_msa_maddr_q_w +extern v8i16 __builtin_msa_msub_q_h(v8i16, v8i16, v8i16); +#define __msa_msub_q_h __builtin_msa_msub_q_h +extern v4i32 __builtin_msa_msub_q_w(v4i32, v4i32, v4i32); +#define __msa_msub_q_w __builtin_msa_msub_q_w +extern v8i16 __builtin_msa_msubr_q_h(v8i16, v8i16, v8i16); +#define __msa_msubr_q_h __builtin_msa_msubr_q_h +extern v4i32 __builtin_msa_msubr_q_w(v4i32, v4i32, v4i32); +#define __msa_msubr_q_w __builtin_msa_msubr_q_w +extern v4i32 __builtin_msa_fclass_w(v4f32); +#define __msa_fclass_w __builtin_msa_fclass_w +extern v2i64 __builtin_msa_fclass_d(v2f64); +#define __msa_fclass_d __builtin_msa_fclass_d +extern v4f32 __builtin_msa_fsqrt_w(v4f32); +#define __msa_fsqrt_w __builtin_msa_fsqrt_w +extern v2f64 __builtin_msa_fsqrt_d(v2f64); +#define __msa_fsqrt_d __builtin_msa_fsqrt_d +extern v4f32 __builtin_msa_frcp_w(v4f32); +#define __msa_frcp_w __builtin_msa_frcp_w +extern v2f64 __builtin_msa_frcp_d(v2f64); +#define __msa_frcp_d __builtin_msa_frcp_d +extern v4f32 __builtin_msa_frint_w(v4f32); +#define __msa_frint_w __builtin_msa_frint_w +extern v2f64 __builtin_msa_frint_d(v2f64); +#define __msa_frint_d __builtin_msa_frint_d +extern v4f32 __builtin_msa_frsqrt_w(v4f32); +#define __msa_frsqrt_w __builtin_msa_frsqrt_w +extern v2f64 __builtin_msa_frsqrt_d(v2f64); +#define __msa_frsqrt_d __builtin_msa_frsqrt_d +extern v4f32 __builtin_msa_flog2_w(v4f32); +#define __msa_flog2_w __builtin_msa_flog2_w +extern v2f64 __builtin_msa_flog2_d(v2f64); +#define __msa_flog2_d __builtin_msa_flog2_d +extern v4f32 __builtin_msa_fexupl_w(v8i16); +#define __msa_fexupl_w __builtin_msa_fexupl_w +extern v2f64 __builtin_msa_fexupl_d(v4f32); +#define __msa_fexupl_d __builtin_msa_fexupl_d +extern v4f32 __builtin_msa_fexupr_w(v8i16); +#define __msa_fexupr_w __builtin_msa_fexupr_w +extern v2f64 __builtin_msa_fexupr_d(v4f32); +#define __msa_fexupr_d __builtin_msa_fexupr_d +extern v4f32 __builtin_msa_ffql_w(v8i16); +#define __msa_ffql_w __builtin_msa_ffql_w +extern v2f64 __builtin_msa_ffql_d(v4i32); +#define __msa_ffql_d __builtin_msa_ffql_d +extern v4f32 __builtin_msa_ffqr_w(v8i16); +#define __msa_ffqr_w __builtin_msa_ffqr_w +extern v2f64 __builtin_msa_ffqr_d(v4i32); +#define __msa_ffqr_d __builtin_msa_ffqr_d +extern v4i32 __builtin_msa_ftint_s_w(v4f32); +#define __msa_ftint_s_w __builtin_msa_ftint_s_w +extern v2i64 __builtin_msa_ftint_s_d(v2f64); +#define __msa_ftint_s_d __builtin_msa_ftint_s_d +extern v4u32 __builtin_msa_ftint_u_w(v4f32); +#define __msa_ftint_u_w __builtin_msa_ftint_u_w +extern v2u64 __builtin_msa_ftint_u_d(v2f64); +#define __msa_ftint_u_d __builtin_msa_ftint_u_d +extern v4i32 __builtin_msa_ftrunc_s_w(v4f32); +#define __msa_ftrunc_s_w __builtin_msa_ftrunc_s_w +extern v2i64 __builtin_msa_ftrunc_s_d(v2f64); +#define __msa_ftrunc_s_d __builtin_msa_ftrunc_s_d +extern v4u32 __builtin_msa_ftrunc_u_w(v4f32); +#define __msa_ftrunc_u_w __builtin_msa_ftrunc_u_w +extern v2u64 __builtin_msa_ftrunc_u_d(v2f64); +#define __msa_ftrunc_u_d __builtin_msa_ftrunc_u_d +extern v4f32 __builtin_msa_ffint_s_w(v4i32); +#define __msa_ffint_s_w __builtin_msa_ffint_s_w +extern v2f64 __builtin_msa_ffint_s_d(v2i64); +#define __msa_ffint_s_d __builtin_msa_ffint_s_d +extern v4f32 __builtin_msa_ffint_u_w(v4u32); +#define __msa_ffint_u_w __builtin_msa_ffint_u_w +extern v2f64 __builtin_msa_ffint_u_d(v2u64); +#define __msa_ffint_u_d __builtin_msa_ffint_u_d +extern int __builtin_msa_cfcmsa(unsigned char); +#define __msa_cfcmsa __builtin_msa_cfcmsa +extern v16i8 __builtin_msa_move_v(v16i8); +#define __msa_move_v __builtin_msa_move_v +extern v4f32 __builtin_msa_cast_to_vector_float(float); +#define __msa_cast_to_vector_float __builtin_msa_cast_to_vector_float +extern v2f64 __builtin_msa_cast_to_vector_double(double); +#define __msa_cast_to_vector_double __builtin_msa_cast_to_vector_double +extern float __builtin_msa_cast_to_scalar_float(v4f32); +#define __msa_cast_to_scalar_float __builtin_msa_cast_to_scalar_float +extern double __builtin_msa_cast_to_scalar_double(v2f64); +#define __msa_cast_to_scalar_double __builtin_msa_cast_to_scalar_double +#endif /* __clang__ */ +#endif /* defined(__mips_msa) */ +#endif /* _MSA_H */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/omp.h b/lib/gcc/mips64el-linux-android/4.9/include/omp.h new file mode 100644 index 0000000..b1824b5 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/omp.h @@ -0,0 +1,127 @@ +/* Copyright (C) 2005-2014 Free Software Foundation, Inc. + Contributed by Richard Henderson <rth@redhat.com>. + + This file is part of the GNU OpenMP Library (libgomp). + + Libgomp 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. + + Libgomp 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/>. */ + +#ifndef _OMP_H +#define _OMP_H 1 + +#ifndef _LIBGOMP_OMP_LOCK_DEFINED +#define _LIBGOMP_OMP_LOCK_DEFINED 1 +/* These two structures get edited by the libgomp build process to + reflect the shape of the two types. Their internals are private + to the library. */ + +typedef struct +{ + unsigned char _x[4] + __attribute__((__aligned__(4))); +} omp_lock_t; + +typedef struct +{ + unsigned char _x[12] + __attribute__((__aligned__(4))); +} omp_nest_lock_t; +#endif + +typedef enum omp_sched_t +{ + omp_sched_static = 1, + omp_sched_dynamic = 2, + omp_sched_guided = 3, + omp_sched_auto = 4 +} omp_sched_t; + +typedef enum omp_proc_bind_t +{ + omp_proc_bind_false = 0, + omp_proc_bind_true = 1, + omp_proc_bind_master = 2, + omp_proc_bind_close = 3, + omp_proc_bind_spread = 4 +} omp_proc_bind_t; + +#ifdef __cplusplus +extern "C" { +# define __GOMP_NOTHROW throw () +#else +# define __GOMP_NOTHROW __attribute__((__nothrow__)) +#endif + +extern void omp_set_num_threads (int) __GOMP_NOTHROW; +extern int omp_get_num_threads (void) __GOMP_NOTHROW; +extern int omp_get_max_threads (void) __GOMP_NOTHROW; +extern int omp_get_thread_num (void) __GOMP_NOTHROW; +extern int omp_get_num_procs (void) __GOMP_NOTHROW; + +extern int omp_in_parallel (void) __GOMP_NOTHROW; + +extern void omp_set_dynamic (int) __GOMP_NOTHROW; +extern int omp_get_dynamic (void) __GOMP_NOTHROW; + +extern void omp_set_nested (int) __GOMP_NOTHROW; +extern int omp_get_nested (void) __GOMP_NOTHROW; + +extern void omp_init_lock (omp_lock_t *) __GOMP_NOTHROW; +extern void omp_destroy_lock (omp_lock_t *) __GOMP_NOTHROW; +extern void omp_set_lock (omp_lock_t *) __GOMP_NOTHROW; +extern void omp_unset_lock (omp_lock_t *) __GOMP_NOTHROW; +extern int omp_test_lock (omp_lock_t *) __GOMP_NOTHROW; + +extern void omp_init_nest_lock (omp_nest_lock_t *) __GOMP_NOTHROW; +extern void omp_destroy_nest_lock (omp_nest_lock_t *) __GOMP_NOTHROW; +extern void omp_set_nest_lock (omp_nest_lock_t *) __GOMP_NOTHROW; +extern void omp_unset_nest_lock (omp_nest_lock_t *) __GOMP_NOTHROW; +extern int omp_test_nest_lock (omp_nest_lock_t *) __GOMP_NOTHROW; + +extern double omp_get_wtime (void) __GOMP_NOTHROW; +extern double omp_get_wtick (void) __GOMP_NOTHROW; + +extern void omp_set_schedule (omp_sched_t, int) __GOMP_NOTHROW; +extern void omp_get_schedule (omp_sched_t *, int *) __GOMP_NOTHROW; +extern int omp_get_thread_limit (void) __GOMP_NOTHROW; +extern void omp_set_max_active_levels (int) __GOMP_NOTHROW; +extern int omp_get_max_active_levels (void) __GOMP_NOTHROW; +extern int omp_get_level (void) __GOMP_NOTHROW; +extern int omp_get_ancestor_thread_num (int) __GOMP_NOTHROW; +extern int omp_get_team_size (int) __GOMP_NOTHROW; +extern int omp_get_active_level (void) __GOMP_NOTHROW; + +extern int omp_in_final (void) __GOMP_NOTHROW; + +extern int omp_get_cancellation (void) __GOMP_NOTHROW; +extern omp_proc_bind_t omp_get_proc_bind (void) __GOMP_NOTHROW; + +extern void omp_set_default_device (int) __GOMP_NOTHROW; +extern int omp_get_default_device (void) __GOMP_NOTHROW; +extern int omp_get_num_devices (void) __GOMP_NOTHROW; +extern int omp_get_num_teams (void) __GOMP_NOTHROW; +extern int omp_get_team_num (void) __GOMP_NOTHROW; + +extern int omp_is_initial_device (void) __GOMP_NOTHROW; + +#ifdef __cplusplus +} +#endif + +#endif /* _OMP_H */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdalign.h b/lib/gcc/mips64el-linux-android/4.9/include/stdalign.h new file mode 100644 index 0000000..ee2d81f --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdalign.h @@ -0,0 +1,39 @@ +/* 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. + +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/>. */ + +/* ISO C1X: 7.15 Alignment <stdalign.h>. */ + +#ifndef _STDALIGN_H +#define _STDALIGN_H + +#ifndef __cplusplus + +#define alignas _Alignas +#define alignof _Alignof + +#define __alignas_is_defined 1 +#define __alignof_is_defined 1 + +#endif + +#endif /* stdalign.h */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdarg.h b/lib/gcc/mips64el-linux-android/4.9/include/stdarg.h new file mode 100644 index 0000000..1d4418b --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdarg.h @@ -0,0 +1,126 @@ +/* Copyright (C) 1989-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. + +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/>. */ + +/* + * ISO C Standard: 7.15 Variable arguments <stdarg.h> + */ + +#ifndef _STDARG_H +#ifndef _ANSI_STDARG_H_ +#ifndef __need___va_list +#define _STDARG_H +#define _ANSI_STDARG_H_ +#endif /* not __need___va_list */ +#undef __need___va_list + +/* Define __gnuc_va_list. */ + +#ifndef __GNUC_VA_LIST +#define __GNUC_VA_LIST +typedef __builtin_va_list __gnuc_va_list; +#endif + +/* Define the standard macros for the user, + if this invocation was from the user program. */ +#ifdef _STDARG_H + +#define va_start(v,l) __builtin_va_start(v,l) +#define va_end(v) __builtin_va_end(v) +#define va_arg(v,l) __builtin_va_arg(v,l) +#if !defined(__STRICT_ANSI__) || __STDC_VERSION__ + 0 >= 199900L || defined(__GXX_EXPERIMENTAL_CXX0X__) +#define va_copy(d,s) __builtin_va_copy(d,s) +#endif +#define __va_copy(d,s) __builtin_va_copy(d,s) + +/* Define va_list, if desired, from __gnuc_va_list. */ +/* We deliberately do not define va_list when called from + stdio.h, because ANSI C says that stdio.h is not supposed to define + va_list. stdio.h needs to have access to that data type, + but must not use that name. It should use the name __gnuc_va_list, + which is safe because it is reserved for the implementation. */ + +#ifdef _BSD_VA_LIST +#undef _BSD_VA_LIST +#endif + +#if defined(__svr4__) || (defined(_SCO_DS) && !defined(__VA_LIST)) +/* SVR4.2 uses _VA_LIST for an internal alias for va_list, + so we must avoid testing it and setting it here. + SVR4 uses _VA_LIST as a flag in stdarg.h, but we should + have no conflict with that. */ +#ifndef _VA_LIST_ +#define _VA_LIST_ +#ifdef __i860__ +#ifndef _VA_LIST +#define _VA_LIST va_list +#endif +#endif /* __i860__ */ +typedef __gnuc_va_list va_list; +#ifdef _SCO_DS +#define __VA_LIST +#endif +#endif /* _VA_LIST_ */ +#else /* not __svr4__ || _SCO_DS */ + +/* The macro _VA_LIST_ is the same thing used by this file in Ultrix. + But on BSD NET2 we must not test or define or undef it. + (Note that the comments in NET 2's ansi.h + are incorrect for _VA_LIST_--see stdio.h!) */ +#if !defined (_VA_LIST_) || defined (__BSD_NET2__) || defined (____386BSD____) || defined (__bsdi__) || defined (__sequent__) || defined (__FreeBSD__) || defined(WINNT) +/* The macro _VA_LIST_DEFINED is used in Windows NT 3.5 */ +#ifndef _VA_LIST_DEFINED +/* The macro _VA_LIST is used in SCO Unix 3.2. */ +#ifndef _VA_LIST +/* The macro _VA_LIST_T_H is used in the Bull dpx2 */ +#ifndef _VA_LIST_T_H +/* The macro __va_list__ is used by BeOS. */ +#ifndef __va_list__ +typedef __gnuc_va_list va_list; +#endif /* not __va_list__ */ +#endif /* not _VA_LIST_T_H */ +#endif /* not _VA_LIST */ +#endif /* not _VA_LIST_DEFINED */ +#if !(defined (__BSD_NET2__) || defined (____386BSD____) || defined (__bsdi__) || defined (__sequent__) || defined (__FreeBSD__)) +#define _VA_LIST_ +#endif +#ifndef _VA_LIST +#define _VA_LIST +#endif +#ifndef _VA_LIST_DEFINED +#define _VA_LIST_DEFINED +#endif +#ifndef _VA_LIST_T_H +#define _VA_LIST_T_H +#endif +#ifndef __va_list__ +#define __va_list__ +#endif + +#endif /* not _VA_LIST_, except on certain systems */ + +#endif /* not __svr4__ */ + +#endif /* _STDARG_H */ + +#endif /* not _ANSI_STDARG_H_ */ +#endif /* not _STDARG_H */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdatomic.h b/lib/gcc/mips64el-linux-android/4.9/include/stdatomic.h new file mode 100644 index 0000000..108259b --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdatomic.h @@ -0,0 +1,252 @@ +/* Copyright (C) 2013-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. + +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/>. */ + +/* ISO C11 Standard: 7.17 Atomics <stdatomic.h>. */ + +#ifndef _STDATOMIC_H +#define _STDATOMIC_H + +typedef enum + { + memory_order_relaxed = __ATOMIC_RELAXED, + memory_order_consume = __ATOMIC_CONSUME, + memory_order_acquire = __ATOMIC_ACQUIRE, + memory_order_release = __ATOMIC_RELEASE, + memory_order_acq_rel = __ATOMIC_ACQ_REL, + memory_order_seq_cst = __ATOMIC_SEQ_CST + } memory_order; + + +typedef _Atomic _Bool atomic_bool; +typedef _Atomic char atomic_char; +typedef _Atomic signed char atomic_schar; +typedef _Atomic unsigned char atomic_uchar; +typedef _Atomic short atomic_short; +typedef _Atomic unsigned short atomic_ushort; +typedef _Atomic int atomic_int; +typedef _Atomic unsigned int atomic_uint; +typedef _Atomic long atomic_long; +typedef _Atomic unsigned long atomic_ulong; +typedef _Atomic long long atomic_llong; +typedef _Atomic unsigned long long atomic_ullong; +typedef _Atomic __CHAR16_TYPE__ atomic_char16_t; +typedef _Atomic __CHAR32_TYPE__ atomic_char32_t; +typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t; +typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t; +typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t; +typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t; +typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t; +typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t; +typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t; +typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t; +typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t; +typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t; +typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t; +typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t; +typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t; +typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t; +typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t; +typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t; +typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t; +typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t; +typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t; +typedef _Atomic __SIZE_TYPE__ atomic_size_t; +typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t; +typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t; +typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t; + + +#define ATOMIC_VAR_INIT(VALUE) (VALUE) +#define atomic_init(PTR, VAL) \ + do \ + { \ + *(PTR) = (VAL); \ + } \ + while (0) + +#define kill_dependency(Y) \ + __extension__ \ + ({ \ + __auto_type __kill_dependency_tmp = (Y); \ + __kill_dependency_tmp; \ + }) + +#define atomic_thread_fence(MO) __atomic_thread_fence (MO) +#define atomic_signal_fence(MO) __atomic_signal_fence (MO) +#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ)) + +#define __atomic_type_lock_free(T) \ + (__atomic_always_lock_free (sizeof (T), (void *) 0) \ + ? 2 \ + : (__atomic_is_lock_free (sizeof (T), (void *) 0) ? 1 : 0)) +#define ATOMIC_BOOL_LOCK_FREE \ + __atomic_type_lock_free (atomic_bool) +#define ATOMIC_CHAR_LOCK_FREE \ + __atomic_type_lock_free (atomic_char) +#define ATOMIC_CHAR16_T_LOCK_FREE \ + __atomic_type_lock_free (atomic_char16_t) +#define ATOMIC_CHAR32_T_LOCK_FREE \ + __atomic_type_lock_free (atomic_char32_t) +#define ATOMIC_WCHAR_T_LOCK_FREE \ + __atomic_type_lock_free (atomic_wchar_t) +#define ATOMIC_SHORT_LOCK_FREE \ + __atomic_type_lock_free (atomic_short) +#define ATOMIC_INT_LOCK_FREE \ + __atomic_type_lock_free (atomic_int) +#define ATOMIC_LONG_LOCK_FREE \ + __atomic_type_lock_free (atomic_long) +#define ATOMIC_LLONG_LOCK_FREE \ + __atomic_type_lock_free (atomic_llong) +#define ATOMIC_POINTER_LOCK_FREE \ + __atomic_type_lock_free (void * _Atomic) + + +/* Note that these macros require __typeof__ and __auto_type to remove + _Atomic qualifiers (and const qualifiers, if those are valid on + macro operands). + + Also note that the header file uses the generic form of __atomic + builtins, which requires the address to be taken of the value + parameter, and then we pass that value on. This allows the macros + to work for any type, and the compiler is smart enough to convert + these to lock-free _N variants if possible, and throw away the + temps. */ + +#define atomic_store_explicit(PTR, VAL, MO) \ + __extension__ \ + ({ \ + __auto_type __atomic_store_ptr = (PTR); \ + __typeof__ (*__atomic_store_ptr) __atomic_store_tmp = (VAL); \ + __atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO)); \ + }) + +#define atomic_store(PTR, VAL) \ + atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST) + + +#define atomic_load_explicit(PTR, MO) \ + __extension__ \ + ({ \ + __auto_type __atomic_load_ptr = (PTR); \ + __typeof__ (*__atomic_load_ptr) __atomic_load_tmp; \ + __atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO)); \ + __atomic_load_tmp; \ + }) + +#define atomic_load(PTR) atomic_load_explicit (PTR, __ATOMIC_SEQ_CST) + + +#define atomic_exchange_explicit(PTR, VAL, MO) \ + __extension__ \ + ({ \ + __auto_type __atomic_exchange_ptr = (PTR); \ + __typeof__ (*__atomic_exchange_ptr) __atomic_exchange_val = (VAL); \ + __typeof__ (*__atomic_exchange_ptr) __atomic_exchange_tmp; \ + __atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val, \ + &__atomic_exchange_tmp, (MO)); \ + __atomic_exchange_tmp; \ + }) + +#define atomic_exchange(PTR, VAL) \ + atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST) + + +#define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \ + __extension__ \ + ({ \ + __auto_type __atomic_compare_exchange_ptr = (PTR); \ + __typeof__ (*__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \ + = (DES); \ + __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \ + &__atomic_compare_exchange_tmp, 0, \ + (SUC), (FAIL)); \ + }) + +#define atomic_compare_exchange_strong(PTR, VAL, DES) \ + atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \ + __ATOMIC_SEQ_CST) + +#define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \ + __extension__ \ + ({ \ + __auto_type __atomic_compare_exchange_ptr = (PTR); \ + __typeof__ (*__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \ + = (DES); \ + __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \ + &__atomic_compare_exchange_tmp, 1, \ + (SUC), (FAIL)); \ + }) + +#define atomic_compare_exchange_weak(PTR, VAL, DES) \ + atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \ + __ATOMIC_SEQ_CST) + + + +#define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL), \ + __ATOMIC_SEQ_CST) +#define atomic_fetch_add_explicit(PTR, VAL, MO) \ + __atomic_fetch_add ((PTR), (VAL), (MO)) + +#define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL), \ + __ATOMIC_SEQ_CST) +#define atomic_fetch_sub_explicit(PTR, VAL, MO) \ + __atomic_fetch_sub ((PTR), (VAL), (MO)) + +#define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL), \ + __ATOMIC_SEQ_CST) +#define atomic_fetch_or_explicit(PTR, VAL, MO) \ + __atomic_fetch_or ((PTR), (VAL), (MO)) + +#define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL), \ + __ATOMIC_SEQ_CST) +#define atomic_fetch_xor_explicit(PTR, VAL, MO) \ + __atomic_fetch_xor ((PTR), (VAL), (MO)) + +#define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL), \ + __ATOMIC_SEQ_CST) +#define atomic_fetch_and_explicit(PTR, VAL, MO) \ + __atomic_fetch_and ((PTR), (VAL), (MO)) + + +typedef _Atomic struct +{ +#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1 + _Bool __val; +#else + unsigned char __val; +#endif +} atomic_flag; + +#define ATOMIC_FLAG_INIT { 0 } + + +#define atomic_flag_test_and_set(PTR) \ + __atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST) +#define atomic_flag_test_and_set_explicit(PTR, MO) \ + __atomic_test_and_set ((PTR), (MO)) + +#define atomic_flag_clear(PTR) __atomic_clear ((PTR), __ATOMIC_SEQ_CST) +#define atomic_flag_clear_explicit(PTR, MO) __atomic_clear ((PTR), (MO)) + +#endif /* _STDATOMIC_H */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdbool.h b/lib/gcc/mips64el-linux-android/4.9/include/stdbool.h new file mode 100644 index 0000000..f4e802f --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdbool.h @@ -0,0 +1,50 @@ +/* Copyright (C) 1998-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. + +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/>. */ + +/* + * ISO C Standard: 7.16 Boolean type and values <stdbool.h> + */ + +#ifndef _STDBOOL_H +#define _STDBOOL_H + +#ifndef __cplusplus + +#define bool _Bool +#define true 1 +#define false 0 + +#else /* __cplusplus */ + +/* Supporting <stdbool.h> in C++ is a GCC extension. */ +#define _Bool bool +#define bool bool +#define false false +#define true true + +#endif /* __cplusplus */ + +/* Signal that all the definitions are present. */ +#define __bool_true_false_are_defined 1 + +#endif /* stdbool.h */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stddef.h b/lib/gcc/mips64el-linux-android/4.9/include/stddef.h new file mode 100644 index 0000000..cfa8df3 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stddef.h @@ -0,0 +1,439 @@ +/* Copyright (C) 1989-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. + +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/>. */ + +/* + * ISO C Standard: 7.17 Common definitions <stddef.h> + */ +#if (!defined(_STDDEF_H) && !defined(_STDDEF_H_) && !defined(_ANSI_STDDEF_H) \ + && !defined(__STDDEF_H__)) \ + || defined(__need_wchar_t) || defined(__need_size_t) \ + || defined(__need_ptrdiff_t) || defined(__need_NULL) \ + || defined(__need_wint_t) + +/* Any one of these symbols __need_* means that GNU libc + wants us just to define one data type. So don't define + the symbols that indicate this file's entire job has been done. */ +#if (!defined(__need_wchar_t) && !defined(__need_size_t) \ + && !defined(__need_ptrdiff_t) && !defined(__need_NULL) \ + && !defined(__need_wint_t)) +#define _STDDEF_H +#define _STDDEF_H_ +/* snaroff@next.com says the NeXT needs this. */ +#define _ANSI_STDDEF_H +#endif + +#ifndef __sys_stdtypes_h +/* This avoids lossage on SunOS but only if stdtypes.h comes first. + There's no way to win with the other order! Sun lossage. */ + +/* On 4.3bsd-net2, make sure ansi.h is included, so we have + one less case to deal with in the following. */ +#if defined (__BSD_NET2__) || defined (____386BSD____) || (defined (__FreeBSD__) && (__FreeBSD__ < 5)) || defined(__NetBSD__) +#include <machine/ansi.h> +#endif +/* On FreeBSD 5, machine/ansi.h does not exist anymore... */ +#if defined (__FreeBSD__) && (__FreeBSD__ >= 5) +#include <sys/_types.h> +#endif + +/* In 4.3bsd-net2, machine/ansi.h defines these symbols, which are + defined if the corresponding type is *not* defined. + FreeBSD-2.1 defines _MACHINE_ANSI_H_ instead of _ANSI_H_. + NetBSD defines _I386_ANSI_H_ and _X86_64_ANSI_H_ instead of _ANSI_H_ */ +#if defined(_ANSI_H_) || defined(_MACHINE_ANSI_H_) || defined(_X86_64_ANSI_H_) || defined(_I386_ANSI_H_) +#if !defined(_SIZE_T_) && !defined(_BSD_SIZE_T_) +#define _SIZE_T +#endif +#if !defined(_PTRDIFF_T_) && !defined(_BSD_PTRDIFF_T_) +#define _PTRDIFF_T +#endif +/* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_ + instead of _WCHAR_T_. */ +#if !defined(_WCHAR_T_) && !defined(_BSD_WCHAR_T_) +#ifndef _BSD_WCHAR_T_ +#define _WCHAR_T +#endif +#endif +/* Undef _FOO_T_ if we are supposed to define foo_t. */ +#if defined (__need_ptrdiff_t) || defined (_STDDEF_H_) +#undef _PTRDIFF_T_ +#undef _BSD_PTRDIFF_T_ +#endif +#if defined (__need_size_t) || defined (_STDDEF_H_) +#undef _SIZE_T_ +#undef _BSD_SIZE_T_ +#endif +#if defined (__need_wchar_t) || defined (_STDDEF_H_) +#undef _WCHAR_T_ +#undef _BSD_WCHAR_T_ +#endif +#endif /* defined(_ANSI_H_) || defined(_MACHINE_ANSI_H_) || defined(_X86_64_ANSI_H_) || defined(_I386_ANSI_H_) */ + +/* Sequent's header files use _PTRDIFF_T_ in some conflicting way. + Just ignore it. */ +#if defined (__sequent__) && defined (_PTRDIFF_T_) +#undef _PTRDIFF_T_ +#endif + +/* On VxWorks, <type/vxTypesBase.h> may have defined macros like + _TYPE_size_t which will typedef size_t. fixincludes patched the + vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is + not defined, and so that defining this macro defines _GCC_SIZE_T. + If we find that the macros are still defined at this point, we must + invoke them so that the type is defined as expected. */ +#if defined (_TYPE_ptrdiff_t) && (defined (__need_ptrdiff_t) || defined (_STDDEF_H_)) +_TYPE_ptrdiff_t; +#undef _TYPE_ptrdiff_t +#endif +#if defined (_TYPE_size_t) && (defined (__need_size_t) || defined (_STDDEF_H_)) +_TYPE_size_t; +#undef _TYPE_size_t +#endif +#if defined (_TYPE_wchar_t) && (defined (__need_wchar_t) || defined (_STDDEF_H_)) +_TYPE_wchar_t; +#undef _TYPE_wchar_t +#endif + +/* In case nobody has defined these types, but we aren't running under + GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and + __WCHAR_TYPE__ have reasonable values. This can happen if the + parts of GCC is compiled by an older compiler, that actually + include gstddef.h, such as collect2. */ + +/* Signed type of difference of two pointers. */ + +/* Define this type if we are doing the whole job, + or if we want this type in particular. */ +#if defined (_STDDEF_H) || defined (__need_ptrdiff_t) +#ifndef _PTRDIFF_T /* in case <sys/types.h> has defined it. */ +#ifndef _T_PTRDIFF_ +#ifndef _T_PTRDIFF +#ifndef __PTRDIFF_T +#ifndef _PTRDIFF_T_ +#ifndef _BSD_PTRDIFF_T_ +#ifndef ___int_ptrdiff_t_h +#ifndef _GCC_PTRDIFF_T +#define _PTRDIFF_T +#define _T_PTRDIFF_ +#define _T_PTRDIFF +#define __PTRDIFF_T +#define _PTRDIFF_T_ +#define _BSD_PTRDIFF_T_ +#define ___int_ptrdiff_t_h +#define _GCC_PTRDIFF_T +#ifndef __PTRDIFF_TYPE__ +#define __PTRDIFF_TYPE__ long int +#endif +typedef __PTRDIFF_TYPE__ ptrdiff_t; +#endif /* _GCC_PTRDIFF_T */ +#endif /* ___int_ptrdiff_t_h */ +#endif /* _BSD_PTRDIFF_T_ */ +#endif /* _PTRDIFF_T_ */ +#endif /* __PTRDIFF_T */ +#endif /* _T_PTRDIFF */ +#endif /* _T_PTRDIFF_ */ +#endif /* _PTRDIFF_T */ + +/* If this symbol has done its job, get rid of it. */ +#undef __need_ptrdiff_t + +#endif /* _STDDEF_H or __need_ptrdiff_t. */ + +/* Unsigned type of `sizeof' something. */ + +/* Define this type if we are doing the whole job, + or if we want this type in particular. */ +#if defined (_STDDEF_H) || defined (__need_size_t) +#ifndef __size_t__ /* BeOS */ +#ifndef __SIZE_T__ /* Cray Unicos/Mk */ +#ifndef _SIZE_T /* in case <sys/types.h> has defined it. */ +#ifndef _SYS_SIZE_T_H +#ifndef _T_SIZE_ +#ifndef _T_SIZE +#ifndef __SIZE_T +#ifndef _SIZE_T_ +#ifndef _BSD_SIZE_T_ +#ifndef _SIZE_T_DEFINED_ +#ifndef _SIZE_T_DEFINED +#ifndef _BSD_SIZE_T_DEFINED_ /* Darwin */ +#ifndef _SIZE_T_DECLARED /* FreeBSD 5 */ +#ifndef ___int_size_t_h +#ifndef _GCC_SIZE_T +#ifndef _SIZET_ +#ifndef __size_t +#define __size_t__ /* BeOS */ +#define __SIZE_T__ /* Cray Unicos/Mk */ +#define _SIZE_T +#define _SYS_SIZE_T_H +#define _T_SIZE_ +#define _T_SIZE +#define __SIZE_T +#define _SIZE_T_ +#define _BSD_SIZE_T_ +#define _SIZE_T_DEFINED_ +#define _SIZE_T_DEFINED +#define _BSD_SIZE_T_DEFINED_ /* Darwin */ +#define _SIZE_T_DECLARED /* FreeBSD 5 */ +#define ___int_size_t_h +#define _GCC_SIZE_T +#define _SIZET_ +#if (defined (__FreeBSD__) && (__FreeBSD__ >= 5)) \ + || defined(__FreeBSD_kernel__) +/* __size_t is a typedef on FreeBSD 5, must not trash it. */ +#elif defined (__VMS__) +/* __size_t is also a typedef on VMS. */ +#else +#define __size_t +#endif +#ifndef __SIZE_TYPE__ +#define __SIZE_TYPE__ long unsigned int +#endif +#if !(defined (__GNUG__) && defined (size_t)) +typedef __SIZE_TYPE__ size_t; +#ifdef __BEOS__ +typedef long ssize_t; +#endif /* __BEOS__ */ +#endif /* !(defined (__GNUG__) && defined (size_t)) */ +#endif /* __size_t */ +#endif /* _SIZET_ */ +#endif /* _GCC_SIZE_T */ +#endif /* ___int_size_t_h */ +#endif /* _SIZE_T_DECLARED */ +#endif /* _BSD_SIZE_T_DEFINED_ */ +#endif /* _SIZE_T_DEFINED */ +#endif /* _SIZE_T_DEFINED_ */ +#endif /* _BSD_SIZE_T_ */ +#endif /* _SIZE_T_ */ +#endif /* __SIZE_T */ +#endif /* _T_SIZE */ +#endif /* _T_SIZE_ */ +#endif /* _SYS_SIZE_T_H */ +#endif /* _SIZE_T */ +#endif /* __SIZE_T__ */ +#endif /* __size_t__ */ +#undef __need_size_t +#endif /* _STDDEF_H or __need_size_t. */ + + +/* Wide character type. + Locale-writers should change this as necessary to + be big enough to hold unique values not between 0 and 127, + and not (wchar_t) -1, for each defined multibyte character. */ + +/* Define this type if we are doing the whole job, + or if we want this type in particular. */ +#if defined (_STDDEF_H) || defined (__need_wchar_t) +#ifndef __wchar_t__ /* BeOS */ +#ifndef __WCHAR_T__ /* Cray Unicos/Mk */ +#ifndef _WCHAR_T +#ifndef _T_WCHAR_ +#ifndef _T_WCHAR +#ifndef __WCHAR_T +#ifndef _WCHAR_T_ +#ifndef _BSD_WCHAR_T_ +#ifndef _BSD_WCHAR_T_DEFINED_ /* Darwin */ +#ifndef _BSD_RUNE_T_DEFINED_ /* Darwin */ +#ifndef _WCHAR_T_DECLARED /* FreeBSD 5 */ +#ifndef _WCHAR_T_DEFINED_ +#ifndef _WCHAR_T_DEFINED +#ifndef _WCHAR_T_H +#ifndef ___int_wchar_t_h +#ifndef __INT_WCHAR_T_H +#ifndef _GCC_WCHAR_T +#define __wchar_t__ /* BeOS */ +#define __WCHAR_T__ /* Cray Unicos/Mk */ +#define _WCHAR_T +#define _T_WCHAR_ +#define _T_WCHAR +#define __WCHAR_T +#define _WCHAR_T_ +#define _BSD_WCHAR_T_ +#define _WCHAR_T_DEFINED_ +#define _WCHAR_T_DEFINED +#define _WCHAR_T_H +#define ___int_wchar_t_h +#define __INT_WCHAR_T_H +#define _GCC_WCHAR_T +#define _WCHAR_T_DECLARED + +/* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_ + instead of _WCHAR_T_, and _BSD_RUNE_T_ (which, unlike the other + symbols in the _FOO_T_ family, stays defined even after its + corresponding type is defined). If we define wchar_t, then we + must undef _WCHAR_T_; for BSD/386 1.1 (and perhaps others), if + we undef _WCHAR_T_, then we must also define rune_t, since + headers like runetype.h assume that if machine/ansi.h is included, + and _BSD_WCHAR_T_ is not defined, then rune_t is available. + machine/ansi.h says, "Note that _WCHAR_T_ and _RUNE_T_ must be of + the same type." */ +#ifdef _BSD_WCHAR_T_ +#undef _BSD_WCHAR_T_ +#ifdef _BSD_RUNE_T_ +#if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE) +typedef _BSD_RUNE_T_ rune_t; +#define _BSD_WCHAR_T_DEFINED_ +#define _BSD_RUNE_T_DEFINED_ /* Darwin */ +#if defined (__FreeBSD__) && (__FreeBSD__ < 5) +/* Why is this file so hard to maintain properly? In contrast to + the comment above regarding BSD/386 1.1, on FreeBSD for as long + as the symbol has existed, _BSD_RUNE_T_ must not stay defined or + redundant typedefs will occur when stdlib.h is included after this file. */ +#undef _BSD_RUNE_T_ +#endif +#endif +#endif +#endif +/* FreeBSD 5 can't be handled well using "traditional" logic above + since it no longer defines _BSD_RUNE_T_ yet still desires to export + rune_t in some cases... */ +#if defined (__FreeBSD__) && (__FreeBSD__ >= 5) +#if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE) +#if __BSD_VISIBLE +#ifndef _RUNE_T_DECLARED +typedef __rune_t rune_t; +#define _RUNE_T_DECLARED +#endif +#endif +#endif +#endif + +#ifndef __WCHAR_TYPE__ +#define __WCHAR_TYPE__ int +#endif +#ifndef __cplusplus +typedef __WCHAR_TYPE__ wchar_t; +#endif +#endif +#endif +#endif +#endif +#endif +#endif +#endif /* _WCHAR_T_DECLARED */ +#endif /* _BSD_RUNE_T_DEFINED_ */ +#endif +#endif +#endif +#endif +#endif +#endif +#endif +#endif /* __WCHAR_T__ */ +#endif /* __wchar_t__ */ +#undef __need_wchar_t +#endif /* _STDDEF_H or __need_wchar_t. */ + +#if defined (__need_wint_t) +#ifndef _WINT_T +#define _WINT_T + +#ifndef __WINT_TYPE__ +#define __WINT_TYPE__ unsigned int +#endif +typedef __WINT_TYPE__ wint_t; +#endif +#undef __need_wint_t +#endif + +/* In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. + are already defined. */ +/* BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. */ +/* NetBSD 5 requires the I386_ANSI_H and X86_64_ANSI_H checks here. */ +#if defined(_ANSI_H_) || defined(_MACHINE_ANSI_H_) || defined(_X86_64_ANSI_H_) || defined(_I386_ANSI_H_) +/* The references to _GCC_PTRDIFF_T_, _GCC_SIZE_T_, and _GCC_WCHAR_T_ + are probably typos and should be removed before 2.8 is released. */ +#ifdef _GCC_PTRDIFF_T_ +#undef _PTRDIFF_T_ +#undef _BSD_PTRDIFF_T_ +#endif +#ifdef _GCC_SIZE_T_ +#undef _SIZE_T_ +#undef _BSD_SIZE_T_ +#endif +#ifdef _GCC_WCHAR_T_ +#undef _WCHAR_T_ +#undef _BSD_WCHAR_T_ +#endif +/* The following ones are the real ones. */ +#ifdef _GCC_PTRDIFF_T +#undef _PTRDIFF_T_ +#undef _BSD_PTRDIFF_T_ +#endif +#ifdef _GCC_SIZE_T +#undef _SIZE_T_ +#undef _BSD_SIZE_T_ +#endif +#ifdef _GCC_WCHAR_T +#undef _WCHAR_T_ +#undef _BSD_WCHAR_T_ +#endif +#endif /* _ANSI_H_ || _MACHINE_ANSI_H_ || _X86_64_ANSI_H_ || _I386_ANSI_H_ */ + +#endif /* __sys_stdtypes_h */ + +/* A null pointer constant. */ + +#if defined (_STDDEF_H) || defined (__need_NULL) +#undef NULL /* in case <stdio.h> has defined it. */ +#ifdef __GNUG__ +#define NULL __null +#else /* G++ */ +#ifndef __cplusplus +#define NULL ((void *)0) +#else /* C++ */ +#define NULL 0 +#endif /* C++ */ +#endif /* G++ */ +#endif /* NULL not defined and <stddef.h> or need NULL. */ +#undef __need_NULL + +#ifdef _STDDEF_H + +/* Offset of member MEMBER in a struct of type TYPE. */ +#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER) + +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) \ + || (defined(__cplusplus) && __cplusplus >= 201103L) +#ifndef _GCC_MAX_ALIGN_T +#define _GCC_MAX_ALIGN_T +/* Type whose alignment is supported in every context and is at least + as great as that of any standard type not using alignment + specifiers. */ +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +#endif +#endif /* C11 or C++11. */ + +#if defined(__cplusplus) && __cplusplus >= 201103L +#ifndef _GXX_NULLPTR_T +#define _GXX_NULLPTR_T + typedef decltype(nullptr) nullptr_t; +#endif +#endif /* C++11. */ + +#endif /* _STDDEF_H was defined this time */ + +#endif /* !_STDDEF_H && !_STDDEF_H_ && !_ANSI_STDDEF_H && !__STDDEF_H__ + || __need_XXX was not defined before */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdfix.h b/lib/gcc/mips64el-linux-android/4.9/include/stdfix.h new file mode 100644 index 0000000..93e759a --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdfix.h @@ -0,0 +1,204 @@ +/* Copyright (C) 2007-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. + +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/>. */ + +/* ISO/IEC JTC1 SC22 WG14 N1169 + * Date: 2006-04-04 + * ISO/IEC TR 18037 + * Programming languages - C - Extensions to support embedded processors + */ + +#ifndef _STDFIX_H +#define _STDFIX_H + +/* 7.18a.1 Introduction. */ + +#undef fract +#undef accum +#undef sat +#define fract _Fract +#define accum _Accum +#define sat _Sat + +/* 7.18a.3 Precision macros. */ + +#undef SFRACT_FBIT +#undef SFRACT_MIN +#undef SFRACT_MAX +#undef SFRACT_EPSILON +#define SFRACT_FBIT __SFRACT_FBIT__ +#define SFRACT_MIN __SFRACT_MIN__ +#define SFRACT_MAX __SFRACT_MAX__ +#define SFRACT_EPSILON __SFRACT_EPSILON__ + +#undef USFRACT_FBIT +#undef USFRACT_MIN +#undef USFRACT_MAX +#undef USFRACT_EPSILON +#define USFRACT_FBIT __USFRACT_FBIT__ +#define USFRACT_MIN __USFRACT_MIN__ /* GCC extension. */ +#define USFRACT_MAX __USFRACT_MAX__ +#define USFRACT_EPSILON __USFRACT_EPSILON__ + +#undef FRACT_FBIT +#undef FRACT_MIN +#undef FRACT_MAX +#undef FRACT_EPSILON +#define FRACT_FBIT __FRACT_FBIT__ +#define FRACT_MIN __FRACT_MIN__ +#define FRACT_MAX __FRACT_MAX__ +#define FRACT_EPSILON __FRACT_EPSILON__ + +#undef UFRACT_FBIT +#undef UFRACT_MIN +#undef UFRACT_MAX +#undef UFRACT_EPSILON +#define UFRACT_FBIT __UFRACT_FBIT__ +#define UFRACT_MIN __UFRACT_MIN__ /* GCC extension. */ +#define UFRACT_MAX __UFRACT_MAX__ +#define UFRACT_EPSILON __UFRACT_EPSILON__ + +#undef LFRACT_FBIT +#undef LFRACT_MIN +#undef LFRACT_MAX +#undef LFRACT_EPSILON +#define LFRACT_FBIT __LFRACT_FBIT__ +#define LFRACT_MIN __LFRACT_MIN__ +#define LFRACT_MAX __LFRACT_MAX__ +#define LFRACT_EPSILON __LFRACT_EPSILON__ + +#undef ULFRACT_FBIT +#undef ULFRACT_MIN +#undef ULFRACT_MAX +#undef ULFRACT_EPSILON +#define ULFRACT_FBIT __ULFRACT_FBIT__ +#define ULFRACT_MIN __ULFRACT_MIN__ /* GCC extension. */ +#define ULFRACT_MAX __ULFRACT_MAX__ +#define ULFRACT_EPSILON __ULFRACT_EPSILON__ + +#undef LLFRACT_FBIT +#undef LLFRACT_MIN +#undef LLFRACT_MAX +#undef LLFRACT_EPSILON +#define LLFRACT_FBIT __LLFRACT_FBIT__ /* GCC extension. */ +#define LLFRACT_MIN __LLFRACT_MIN__ /* GCC extension. */ +#define LLFRACT_MAX __LLFRACT_MAX__ /* GCC extension. */ +#define LLFRACT_EPSILON __LLFRACT_EPSILON__ /* GCC extension. */ + +#undef ULLFRACT_FBIT +#undef ULLFRACT_MIN +#undef ULLFRACT_MAX +#undef ULLFRACT_EPSILON +#define ULLFRACT_FBIT __ULLFRACT_FBIT__ /* GCC extension. */ +#define ULLFRACT_MIN __ULLFRACT_MIN__ /* GCC extension. */ +#define ULLFRACT_MAX __ULLFRACT_MAX__ /* GCC extension. */ +#define ULLFRACT_EPSILON __ULLFRACT_EPSILON__ /* GCC extension. */ + +#undef SACCUM_FBIT +#undef SACCUM_IBIT +#undef SACCUM_MIN +#undef SACCUM_MAX +#undef SACCUM_EPSILON +#define SACCUM_FBIT __SACCUM_FBIT__ +#define SACCUM_IBIT __SACCUM_IBIT__ +#define SACCUM_MIN __SACCUM_MIN__ +#define SACCUM_MAX __SACCUM_MAX__ +#define SACCUM_EPSILON __SACCUM_EPSILON__ + +#undef USACCUM_FBIT +#undef USACCUM_IBIT +#undef USACCUM_MIN +#undef USACCUM_MAX +#undef USACCUM_EPSILON +#define USACCUM_FBIT __USACCUM_FBIT__ +#define USACCUM_IBIT __USACCUM_IBIT__ +#define USACCUM_MIN __USACCUM_MIN__ /* GCC extension. */ +#define USACCUM_MAX __USACCUM_MAX__ +#define USACCUM_EPSILON __USACCUM_EPSILON__ + +#undef ACCUM_FBIT +#undef ACCUM_IBIT +#undef ACCUM_MIN +#undef ACCUM_MAX +#undef ACCUM_EPSILON +#define ACCUM_FBIT __ACCUM_FBIT__ +#define ACCUM_IBIT __ACCUM_IBIT__ +#define ACCUM_MIN __ACCUM_MIN__ +#define ACCUM_MAX __ACCUM_MAX__ +#define ACCUM_EPSILON __ACCUM_EPSILON__ + +#undef UACCUM_FBIT +#undef UACCUM_IBIT +#undef UACCUM_MIN +#undef UACCUM_MAX +#undef UACCUM_EPSILON +#define UACCUM_FBIT __UACCUM_FBIT__ +#define UACCUM_IBIT __UACCUM_IBIT__ +#define UACCUM_MIN __UACCUM_MIN__ /* GCC extension. */ +#define UACCUM_MAX __UACCUM_MAX__ +#define UACCUM_EPSILON __UACCUM_EPSILON__ + +#undef LACCUM_FBIT +#undef LACCUM_IBIT +#undef LACCUM_MIN +#undef LACCUM_MAX +#undef LACCUM_EPSILON +#define LACCUM_FBIT __LACCUM_FBIT__ +#define LACCUM_IBIT __LACCUM_IBIT__ +#define LACCUM_MIN __LACCUM_MIN__ +#define LACCUM_MAX __LACCUM_MAX__ +#define LACCUM_EPSILON __LACCUM_EPSILON__ + +#undef ULACCUM_FBIT +#undef ULACCUM_IBIT +#undef ULACCUM_MIN +#undef ULACCUM_MAX +#undef ULACCUM_EPSILON +#define ULACCUM_FBIT __ULACCUM_FBIT__ +#define ULACCUM_IBIT __ULACCUM_IBIT__ +#define ULACCUM_MIN __ULACCUM_MIN__ /* GCC extension. */ +#define ULACCUM_MAX __ULACCUM_MAX__ +#define ULACCUM_EPSILON __ULACCUM_EPSILON__ + +#undef LLACCUM_FBIT +#undef LLACCUM_IBIT +#undef LLACCUM_MIN +#undef LLACCUM_MAX +#undef LLACCUM_EPSILON +#define LLACCUM_FBIT __LLACCUM_FBIT__ /* GCC extension. */ +#define LLACCUM_IBIT __LLACCUM_IBIT__ /* GCC extension. */ +#define LLACCUM_MIN __LLACCUM_MIN__ /* GCC extension. */ +#define LLACCUM_MAX __LLACCUM_MAX__ /* GCC extension. */ +#define LLACCUM_EPSILON __LLACCUM_EPSILON__ /* GCC extension. */ + +#undef ULLACCUM_FBIT +#undef ULLACCUM_IBIT +#undef ULLACCUM_MIN +#undef ULLACCUM_MAX +#undef ULLACCUM_EPSILON +#define ULLACCUM_FBIT __ULLACCUM_FBIT__ /* GCC extension. */ +#define ULLACCUM_IBIT __ULLACCUM_IBIT__ /* GCC extension. */ +#define ULLACCUM_MIN __ULLACCUM_MIN__ /* GCC extension. */ +#define ULLACCUM_MAX __ULLACCUM_MAX__ /* GCC extension. */ +#define ULLACCUM_EPSILON __ULLACCUM_EPSILON__ /* GCC extension. */ + +#endif /* _STDFIX_H */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdint-gcc.h b/lib/gcc/mips64el-linux-android/4.9/include/stdint-gcc.h new file mode 100644 index 0000000..1470cea --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdint-gcc.h @@ -0,0 +1,263 @@ +/* Copyright (C) 2008-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. + +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/>. */ + +/* + * ISO C Standard: 7.18 Integer types <stdint.h> + */ + +#ifndef _GCC_STDINT_H +#define _GCC_STDINT_H + +/* 7.8.1.1 Exact-width integer types */ + +#ifdef __INT8_TYPE__ +typedef __INT8_TYPE__ int8_t; +#endif +#ifdef __INT16_TYPE__ +typedef __INT16_TYPE__ int16_t; +#endif +#ifdef __INT32_TYPE__ +typedef __INT32_TYPE__ int32_t; +#endif +#ifdef __INT64_TYPE__ +typedef __INT64_TYPE__ int64_t; +#endif +#ifdef __UINT8_TYPE__ +typedef __UINT8_TYPE__ uint8_t; +#endif +#ifdef __UINT16_TYPE__ +typedef __UINT16_TYPE__ uint16_t; +#endif +#ifdef __UINT32_TYPE__ +typedef __UINT32_TYPE__ uint32_t; +#endif +#ifdef __UINT64_TYPE__ +typedef __UINT64_TYPE__ uint64_t; +#endif + +/* 7.8.1.2 Minimum-width integer types */ + +typedef __INT_LEAST8_TYPE__ int_least8_t; +typedef __INT_LEAST16_TYPE__ int_least16_t; +typedef __INT_LEAST32_TYPE__ int_least32_t; +typedef __INT_LEAST64_TYPE__ int_least64_t; +typedef __UINT_LEAST8_TYPE__ uint_least8_t; +typedef __UINT_LEAST16_TYPE__ uint_least16_t; +typedef __UINT_LEAST32_TYPE__ uint_least32_t; +typedef __UINT_LEAST64_TYPE__ uint_least64_t; + +/* 7.8.1.3 Fastest minimum-width integer types */ + +typedef __INT_FAST8_TYPE__ int_fast8_t; +typedef __INT_FAST16_TYPE__ int_fast16_t; +typedef __INT_FAST32_TYPE__ int_fast32_t; +typedef __INT_FAST64_TYPE__ int_fast64_t; +typedef __UINT_FAST8_TYPE__ uint_fast8_t; +typedef __UINT_FAST16_TYPE__ uint_fast16_t; +typedef __UINT_FAST32_TYPE__ uint_fast32_t; +typedef __UINT_FAST64_TYPE__ uint_fast64_t; + +/* 7.8.1.4 Integer types capable of holding object pointers */ + +#ifdef __INTPTR_TYPE__ +typedef __INTPTR_TYPE__ intptr_t; +#endif +#ifdef __UINTPTR_TYPE__ +typedef __UINTPTR_TYPE__ uintptr_t; +#endif + +/* 7.8.1.5 Greatest-width integer types */ + +typedef __INTMAX_TYPE__ intmax_t; +typedef __UINTMAX_TYPE__ uintmax_t; + +#if (!defined __cplusplus || __cplusplus >= 201103L \ + || defined __STDC_LIMIT_MACROS) + +/* 7.18.2 Limits of specified-width integer types */ + +#ifdef __INT8_MAX__ +# undef INT8_MAX +# define INT8_MAX __INT8_MAX__ +# undef INT8_MIN +# define INT8_MIN (-INT8_MAX - 1) +#endif +#ifdef __UINT8_MAX__ +# undef UINT8_MAX +# define UINT8_MAX __UINT8_MAX__ +#endif +#ifdef __INT16_MAX__ +# undef INT16_MAX +# define INT16_MAX __INT16_MAX__ +# undef INT16_MIN +# define INT16_MIN (-INT16_MAX - 1) +#endif +#ifdef __UINT16_MAX__ +# undef UINT16_MAX +# define UINT16_MAX __UINT16_MAX__ +#endif +#ifdef __INT32_MAX__ +# undef INT32_MAX +# define INT32_MAX __INT32_MAX__ +# undef INT32_MIN +# define INT32_MIN (-INT32_MAX - 1) +#endif +#ifdef __UINT32_MAX__ +# undef UINT32_MAX +# define UINT32_MAX __UINT32_MAX__ +#endif +#ifdef __INT64_MAX__ +# undef INT64_MAX +# define INT64_MAX __INT64_MAX__ +# undef INT64_MIN +# define INT64_MIN (-INT64_MAX - 1) +#endif +#ifdef __UINT64_MAX__ +# undef UINT64_MAX +# define UINT64_MAX __UINT64_MAX__ +#endif + +#undef INT_LEAST8_MAX +#define INT_LEAST8_MAX __INT_LEAST8_MAX__ +#undef INT_LEAST8_MIN +#define INT_LEAST8_MIN (-INT_LEAST8_MAX - 1) +#undef UINT_LEAST8_MAX +#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__ +#undef INT_LEAST16_MAX +#define INT_LEAST16_MAX __INT_LEAST16_MAX__ +#undef INT_LEAST16_MIN +#define INT_LEAST16_MIN (-INT_LEAST16_MAX - 1) +#undef UINT_LEAST16_MAX +#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__ +#undef INT_LEAST32_MAX +#define INT_LEAST32_MAX __INT_LEAST32_MAX__ +#undef INT_LEAST32_MIN +#define INT_LEAST32_MIN (-INT_LEAST32_MAX - 1) +#undef UINT_LEAST32_MAX +#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__ +#undef INT_LEAST64_MAX +#define INT_LEAST64_MAX __INT_LEAST64_MAX__ +#undef INT_LEAST64_MIN +#define INT_LEAST64_MIN (-INT_LEAST64_MAX - 1) +#undef UINT_LEAST64_MAX +#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__ + +#undef INT_FAST8_MAX +#define INT_FAST8_MAX __INT_FAST8_MAX__ +#undef INT_FAST8_MIN +#define INT_FAST8_MIN (-INT_FAST8_MAX - 1) +#undef UINT_FAST8_MAX +#define UINT_FAST8_MAX __UINT_FAST8_MAX__ +#undef INT_FAST16_MAX +#define INT_FAST16_MAX __INT_FAST16_MAX__ +#undef INT_FAST16_MIN +#define INT_FAST16_MIN (-INT_FAST16_MAX - 1) +#undef UINT_FAST16_MAX +#define UINT_FAST16_MAX __UINT_FAST16_MAX__ +#undef INT_FAST32_MAX +#define INT_FAST32_MAX __INT_FAST32_MAX__ +#undef INT_FAST32_MIN +#define INT_FAST32_MIN (-INT_FAST32_MAX - 1) +#undef UINT_FAST32_MAX +#define UINT_FAST32_MAX __UINT_FAST32_MAX__ +#undef INT_FAST64_MAX +#define INT_FAST64_MAX __INT_FAST64_MAX__ +#undef INT_FAST64_MIN +#define INT_FAST64_MIN (-INT_FAST64_MAX - 1) +#undef UINT_FAST64_MAX +#define UINT_FAST64_MAX __UINT_FAST64_MAX__ + +#ifdef __INTPTR_MAX__ +# undef INTPTR_MAX +# define INTPTR_MAX __INTPTR_MAX__ +# undef INTPTR_MIN +# define INTPTR_MIN (-INTPTR_MAX - 1) +#endif +#ifdef __UINTPTR_MAX__ +# undef UINTPTR_MAX +# define UINTPTR_MAX __UINTPTR_MAX__ +#endif + +#undef INTMAX_MAX +#define INTMAX_MAX __INTMAX_MAX__ +#undef INTMAX_MIN +#define INTMAX_MIN (-INTMAX_MAX - 1) +#undef UINTMAX_MAX +#define UINTMAX_MAX __UINTMAX_MAX__ + +/* 7.18.3 Limits of other integer types */ + +#undef PTRDIFF_MAX +#define PTRDIFF_MAX __PTRDIFF_MAX__ +#undef PTRDIFF_MIN +#define PTRDIFF_MIN (-PTRDIFF_MAX - 1) + +#undef SIG_ATOMIC_MAX +#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__ +#undef SIG_ATOMIC_MIN +#define SIG_ATOMIC_MIN __SIG_ATOMIC_MIN__ + +#undef SIZE_MAX +#define SIZE_MAX __SIZE_MAX__ + +#undef WCHAR_MAX +#define WCHAR_MAX __WCHAR_MAX__ +#undef WCHAR_MIN +#define WCHAR_MIN __WCHAR_MIN__ + +#undef WINT_MAX +#define WINT_MAX __WINT_MAX__ +#undef WINT_MIN +#define WINT_MIN __WINT_MIN__ + +#endif /* (!defined __cplusplus || __cplusplus >= 201103L + || defined __STDC_LIMIT_MACROS) */ + +#if (!defined __cplusplus || __cplusplus >= 201103L \ + || defined __STDC_CONSTANT_MACROS) + +#undef INT8_C +#define INT8_C(c) __INT8_C(c) +#undef INT16_C +#define INT16_C(c) __INT16_C(c) +#undef INT32_C +#define INT32_C(c) __INT32_C(c) +#undef INT64_C +#define INT64_C(c) __INT64_C(c) +#undef UINT8_C +#define UINT8_C(c) __UINT8_C(c) +#undef UINT16_C +#define UINT16_C(c) __UINT16_C(c) +#undef UINT32_C +#define UINT32_C(c) __UINT32_C(c) +#undef UINT64_C +#define UINT64_C(c) __UINT64_C(c) +#undef INTMAX_C +#define INTMAX_C(c) __INTMAX_C(c) +#undef UINTMAX_C +#define UINTMAX_C(c) __UINTMAX_C(c) + +#endif /* (!defined __cplusplus || __cplusplus >= 201103L + || defined __STDC_CONSTANT_MACROS) */ + +#endif /* _GCC_STDINT_H */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdint.h b/lib/gcc/mips64el-linux-android/4.9/include/stdint.h new file mode 100644 index 0000000..83b6f70 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdint.h @@ -0,0 +1,14 @@ +#ifndef _GCC_WRAP_STDINT_H +#if __STDC_HOSTED__ +# if defined __cplusplus && __cplusplus >= 201103L +# undef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +# undef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS +# endif +# include_next <stdint.h> +#else +# include "stdint-gcc.h" +#endif +#define _GCC_WRAP_STDINT_H +#endif diff --git a/lib/gcc/mips64el-linux-android/4.9/include/stdnoreturn.h b/lib/gcc/mips64el-linux-android/4.9/include/stdnoreturn.h new file mode 100644 index 0000000..0134137 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/stdnoreturn.h @@ -0,0 +1,35 @@ +/* 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. + +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/>. */ + +/* ISO C1X: 7.23 _Noreturn <stdnoreturn.h>. */ + +#ifndef _STDNORETURN_H +#define _STDNORETURN_H + +#ifndef __cplusplus + +#define noreturn _Noreturn + +#endif + +#endif /* stdnoreturn.h */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/unwind.h b/lib/gcc/mips64el-linux-android/4.9/include/unwind.h new file mode 100644 index 0000000..d351fb9 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/unwind.h @@ -0,0 +1,293 @@ +/* Exception handling and frame unwind runtime interface routines. + Copyright (C) 2001-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. + + 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 is derived from the C++ ABI for IA-64. Where we diverge + for cross-architecture compatibility are noted with "@@@". */ + +#ifndef _UNWIND_H +#define _UNWIND_H + +#if defined (__SEH__) && !defined (__USING_SJLJ_EXCEPTIONS__) +/* Only for _GCC_specific_handler. */ +#include <windows.h> +#endif + +#ifndef HIDE_EXPORTS +#pragma GCC visibility push(default) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* Level 1: Base ABI */ + +/* @@@ The IA-64 ABI uses uint64 throughout. Most places this is + inefficient for 32-bit and smaller machines. */ +typedef unsigned _Unwind_Word __attribute__((__mode__(__unwind_word__))); +typedef signed _Unwind_Sword __attribute__((__mode__(__unwind_word__))); +#if defined(__ia64__) && defined(__hpux__) +typedef unsigned _Unwind_Ptr __attribute__((__mode__(__word__))); +#else +typedef unsigned _Unwind_Ptr __attribute__((__mode__(__pointer__))); +#endif +typedef unsigned _Unwind_Internal_Ptr __attribute__((__mode__(__pointer__))); + +/* @@@ The IA-64 ABI uses a 64-bit word to identify the producer and + consumer of an exception. We'll go along with this for now even on + 32-bit machines. We'll need to provide some other option for + 16-bit machines and for machines with > 8 bits per byte. */ +typedef unsigned _Unwind_Exception_Class __attribute__((__mode__(__DI__))); + +/* The unwind interface uses reason codes in several contexts to + identify the reasons for failures or other actions. */ +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; + + +/* The unwind interface uses a pointer to an exception header object + as its representation of an exception being thrown. In general, the + full representation of an exception object is language- and + implementation-specific, but it will be prefixed by a header + understood by the unwind interface. */ + +struct _Unwind_Exception; + +typedef void (*_Unwind_Exception_Cleanup_Fn) (_Unwind_Reason_Code, + struct _Unwind_Exception *); + +struct _Unwind_Exception +{ + _Unwind_Exception_Class exception_class; + _Unwind_Exception_Cleanup_Fn exception_cleanup; + +#if !defined (__USING_SJLJ_EXCEPTIONS__) && defined (__SEH__) + _Unwind_Word private_[6]; +#else + _Unwind_Word private_1; + _Unwind_Word private_2; +#endif + + /* @@@ The IA-64 ABI says that this structure must be double-word aligned. + Taking that literally does not make much sense generically. Instead we + provide the maximum alignment required by any type for the machine. */ +} __attribute__((__aligned__)); + + +/* The ACTIONS argument to the personality routine is a bitwise OR of one + or more of the following constants. */ +typedef int _Unwind_Action; + +#define _UA_SEARCH_PHASE 1 +#define _UA_CLEANUP_PHASE 2 +#define _UA_HANDLER_FRAME 4 +#define _UA_FORCE_UNWIND 8 +#define _UA_END_OF_STACK 16 + +/* The target can override this macro to define any back-end-specific + attributes required for the lowest-level stack frame. */ +#ifndef LIBGCC2_UNWIND_ATTRIBUTE +#define LIBGCC2_UNWIND_ATTRIBUTE +#endif + +/* This is an opaque type used to refer to a system-specific data + structure used by the system unwinder. This context is created and + destroyed by the system, and passed to the personality routine + during unwinding. */ +struct _Unwind_Context; + +/* Raise an exception, passing along the given exception object. */ +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_RaiseException (struct _Unwind_Exception *); + +/* Raise an exception for forced unwinding. */ + +typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn) + (int, _Unwind_Action, _Unwind_Exception_Class, + struct _Unwind_Exception *, struct _Unwind_Context *, void *); + +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_ForcedUnwind (struct _Unwind_Exception *, _Unwind_Stop_Fn, void *); + +/* Helper to invoke the exception_cleanup routine. */ +extern void _Unwind_DeleteException (struct _Unwind_Exception *); + +/* Resume propagation of an existing exception. This is used after + e.g. executing cleanup code, and not to implement rethrowing. */ +extern void LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_Resume (struct _Unwind_Exception *); + +/* @@@ Resume propagation of a FORCE_UNWIND exception, or to rethrow + a normal exception that was handled. */ +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_Resume_or_Rethrow (struct _Unwind_Exception *); + +/* @@@ Use unwind data to perform a stack backtrace. The trace callback + is called for every stack frame in the call chain, but no cleanup + actions are performed. */ +typedef _Unwind_Reason_Code (*_Unwind_Trace_Fn) + (struct _Unwind_Context *, void *); + +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_Backtrace (_Unwind_Trace_Fn, void *); + +/* These functions are used for communicating information about the unwind + context (i.e. the unwind descriptors and the user register state) between + the unwind library and the personality routine and landing pad. Only + selected registers may be manipulated. */ + +extern _Unwind_Word _Unwind_GetGR (struct _Unwind_Context *, int); +extern void _Unwind_SetGR (struct _Unwind_Context *, int, _Unwind_Word); + +extern _Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *); +extern _Unwind_Ptr _Unwind_GetIPInfo (struct _Unwind_Context *, int *); +extern void _Unwind_SetIP (struct _Unwind_Context *, _Unwind_Ptr); + +/* @@@ Retrieve the CFA of the given context. */ +extern _Unwind_Word _Unwind_GetCFA (struct _Unwind_Context *); + +extern void *_Unwind_GetLanguageSpecificData (struct _Unwind_Context *); + +extern _Unwind_Ptr _Unwind_GetRegionStart (struct _Unwind_Context *); + + +/* The personality routine is the function in the C++ (or other language) + runtime library which serves as an interface between the system unwind + library and language-specific exception handling semantics. It is + specific to the code fragment described by an unwind info block, and + it is always referenced via the pointer in the unwind info block, and + hence it has no ABI-specified name. + + Note that this implies that two different C++ implementations can + use different names, and have different contents in the language + specific data area. Moreover, that the language specific data + area contains no version info because name of the function invoked + provides more effective versioning by detecting at link time the + lack of code to handle the different data format. */ + +typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn) + (int, _Unwind_Action, _Unwind_Exception_Class, + struct _Unwind_Exception *, struct _Unwind_Context *); + +/* @@@ The following alternate entry points are for setjmp/longjmp + based unwinding. */ + +struct SjLj_Function_Context; +extern void _Unwind_SjLj_Register (struct SjLj_Function_Context *); +extern void _Unwind_SjLj_Unregister (struct SjLj_Function_Context *); + +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_SjLj_RaiseException (struct _Unwind_Exception *); +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_SjLj_ForcedUnwind (struct _Unwind_Exception *, _Unwind_Stop_Fn, void *); +extern void LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_SjLj_Resume (struct _Unwind_Exception *); +extern _Unwind_Reason_Code LIBGCC2_UNWIND_ATTRIBUTE +_Unwind_SjLj_Resume_or_Rethrow (struct _Unwind_Exception *); + +/* @@@ The following provide access to the base addresses for text + and data-relative addressing in the LDSA. In order to stay link + compatible with the standard ABI for IA-64, we inline these. */ + +#ifdef __ia64__ +#include <stdlib.h> + +static inline _Unwind_Ptr +_Unwind_GetDataRelBase (struct _Unwind_Context *_C) +{ + /* The GP is stored in R1. */ + return _Unwind_GetGR (_C, 1); +} + +static inline _Unwind_Ptr +_Unwind_GetTextRelBase (struct _Unwind_Context *_C __attribute__ ((__unused__))) +{ + abort (); + return 0; +} + +/* @@@ Retrieve the Backing Store Pointer of the given context. */ +extern _Unwind_Word _Unwind_GetBSP (struct _Unwind_Context *); +#else +extern _Unwind_Ptr _Unwind_GetDataRelBase (struct _Unwind_Context *); +extern _Unwind_Ptr _Unwind_GetTextRelBase (struct _Unwind_Context *); +#endif + +/* @@@ Given an address, return the entry point of the function that + contains it. */ +extern void * _Unwind_FindEnclosingFunction (void *pc); + +#ifndef __SIZEOF_LONG__ + #error "__SIZEOF_LONG__ macro not defined" +#endif + +#ifndef __SIZEOF_POINTER__ + #error "__SIZEOF_POINTER__ macro not defined" +#endif + + +/* leb128 type numbers have a potentially unlimited size. + The target of the following definitions of _sleb128_t and _uleb128_t + is to have efficient data types large enough to hold the leb128 type + numbers used in the unwind code. + Mostly these types will simply be defined to long and unsigned long + except when a unsigned long data type on the target machine is not + capable of storing a pointer. */ + +#if __SIZEOF_LONG__ >= __SIZEOF_POINTER__ + typedef long _sleb128_t; + typedef unsigned long _uleb128_t; +#elif __SIZEOF_LONG_LONG__ >= __SIZEOF_POINTER__ + typedef long long _sleb128_t; + typedef unsigned long long _uleb128_t; +#else +# error "What type shall we use for _sleb128_t?" +#endif + +#if defined (__SEH__) && !defined (__USING_SJLJ_EXCEPTIONS__) +/* Handles the mapping from SEH to GCC interfaces. */ +EXCEPTION_DISPOSITION _GCC_specific_handler (PEXCEPTION_RECORD, void *, + PCONTEXT, PDISPATCHER_CONTEXT, + _Unwind_Personality_Fn); +#endif + +#ifdef __cplusplus +} +#endif + +#ifndef HIDE_EXPORTS +#pragma GCC visibility pop +#endif + +#endif /* unwind.h */ diff --git a/lib/gcc/mips64el-linux-android/4.9/include/varargs.h b/lib/gcc/mips64el-linux-android/4.9/include/varargs.h new file mode 100644 index 0000000..4b9803e --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/include/varargs.h @@ -0,0 +1,7 @@ +#ifndef _VARARGS_H +#define _VARARGS_H + +#error "GCC no longer implements <varargs.h>." +#error "Revise your code to use <stdarg.h>." + +#endif diff --git a/lib/gcc/mips64el-linux-android/4.9/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/libgcc.a Binary files differnew file mode 100644 index 0000000..66c9d95 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/libgcov.a Binary files differnew file mode 100644 index 0000000..ad35edd --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/libgcov.a diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbegin.o Binary files differnew file mode 100644 index 0000000..cab47b3 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbeginS.o Binary files differnew file mode 100644 index 0000000..202c106 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbeginT.o Binary files differnew file mode 100644 index 0000000..cab47b3 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtend.o b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtend.o Binary files differnew file mode 100644 index 0000000..8949a37 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtendS.o Binary files differnew file mode 100644 index 0000000..8949a37 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtfastmath.o Binary files differnew file mode 100644 index 0000000..b060b5e --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/libgcc.a Binary files differnew file mode 100644 index 0000000..e506a40 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/mips64-r2/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/libgcov.a Binary files differnew file mode 100644 index 0000000..0f46d2c --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/mips64-r2/libgcov.a diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/n32/crtbegin.o Binary files differnew file mode 100644 index 0000000..1d533dd --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/crtbegin.o diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/n32/crtbeginS.o Binary files differnew file mode 100644 index 0000000..9317690 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/crtbeginS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/n32/crtbeginT.o Binary files differnew file mode 100644 index 0000000..1d533dd --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/crtbeginT.o diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/crtend.o b/lib/gcc/mips64el-linux-android/4.9/n32/crtend.o Binary files differnew file mode 100644 index 0000000..9beeadc --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/crtend.o diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/n32/crtendS.o Binary files differnew file mode 100644 index 0000000..9beeadc --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/crtendS.o diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/n32/crtfastmath.o Binary files differnew file mode 100644 index 0000000..4c59ccb --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/crtfastmath.o diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/n32/libgcc.a Binary files differnew file mode 100644 index 0000000..37fc5b3 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/libgcc.a diff --git a/lib/gcc/mips64el-linux-android/4.9/n32/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/n32/libgcov.a Binary files differnew file mode 100644 index 0000000..ace55b7 --- /dev/null +++ b/lib/gcc/mips64el-linux-android/4.9/n32/libgcov.a |