Update mips64 toolchain mips64el-linux-android-4.9 (darwin-x86_64)
See previous commit for build instructions
BUG=18345370
Change-Id: If18ea6ed885c158a9f60699059090f3041b4a00e
diff --git a/SOURCES b/SOURCES
index 07fe8db..65be694 100644
--- a/SOURCES
+++ b/SOURCES
@@ -6,15 +6,15 @@
toolchain/isl.git b05d4572958c5d497da793f3317084bab90c3033 add isl-0.11.1.tar.bz2 needed by GCC 4.8 with graphite
toolchain/ppl.git 8ba1875b4c5341d902321761022a6d2a0b5b19a4 add ppl-1.0.tar.bz2
toolchain/expat.git 40172a0ae9d40a068f1e1a48ffcf6a1ccf765ed5 expat package for building gdb-7.3
-toolchain/binutils.git 8390634fd5fb311f01b82ba35a8db4b40b983cc8 Update Binutils 2.24 to include mips32r6, mips64r6 and MSA changes.
-toolchain/gcc.git 1a6666161c7e53383194203abfbe0367a804416f Merge "Fix mips64el-linux-android-4.9 build"
+toolchain/binutils.git fff40e635995d00e3455f861a97d8cbf3ebb6b4e Merge "Add missing mtc1, mthc1, mfhc1 instructions to Ingenic's MXU patch."
+toolchain/gcc.git 142855c94b3bc9e140a1b55c1a424259285d751c [gcc-4.9] Backport fix for PR62040 and PR62262 Backport two patches from upstream gcc 4.9 branch that fix PR62040 and PR62262
toolchain/gdb.git 24237bc8bc3001a82d6cd9685719c4679f721792 fix some build errors
toolchain/python.git 0d4194853e08d3244931523470331c00dfb94863 Fix python build inc_dirs[] and lib_dirs[] for linux/darwin
toolchain/perl.git 1121daca35c6c692602621eab28d4de19f0b347d Add -Dcc_as_ld to configure
toolchain/mclinker.git 5fca8b9c9c671d6c01f428c00ca131e65042a9fd Merge upstream mclinker 2.7
toolchain/yasm.git 87c09baff80ca5bbe938392d8f320e621707f317 test commit
toolchain/clang.git (release_34) 93fb9b3846bf0de34125b9b556d73dbe88c0175a Backport of clang svn@r211688
-toolchain/llvm.git (release_34) 4e3e3137a7d3c271f5190ac9ef8af7848e5f67e2 Fix missing change for expandVAArg.
+toolchain/llvm.git (release_34) b575a08d23ced75e304869d9e3f06b15c5368ab7 Backport of clang svn@r216114
toolchain/compiler-rt.git (release_34) 4f9b4718e8d836317c224955a1e87b7bb5252ae1 Update clear_cache to trunk@208591
toolchain/clang.git (release_33) 605eefd99fed56bcb7dec02f2776908b1df91646 Align with new GCC options for x86 Android These changes are based on revision 211688 from clang 3.5
toolchain/llvm.git (release_33) 8609a3469a8126eb6fb99ff65906bcc20c272d95 [ndk] Fix createBranchWeights() assertions.
diff --git a/bin/gcov-tool b/bin/gcov-tool
new file mode 100755
index 0000000..ebe7ec3
--- /dev/null
+++ b/bin/gcov-tool
Binary files differ
diff --git a/bin/mips64el-linux-android-as b/bin/mips64el-linux-android-as
index 74cb8cc..2f07b02 100755
--- a/bin/mips64el-linux-android-as
+++ b/bin/mips64el-linux-android-as
Binary files differ
diff --git a/bin/mips64el-linux-android-cpp b/bin/mips64el-linux-android-cpp
index 240698e..8ffe654 100755
--- a/bin/mips64el-linux-android-cpp
+++ b/bin/mips64el-linux-android-cpp
Binary files differ
diff --git a/bin/mips64el-linux-android-g++ b/bin/mips64el-linux-android-g++
index e4e8382..3e0b134 100755
--- a/bin/mips64el-linux-android-g++
+++ b/bin/mips64el-linux-android-g++
Binary files differ
diff --git a/bin/mips64el-linux-android-gcc b/bin/mips64el-linux-android-gcc
index 9b32151..b073993 100755
--- a/bin/mips64el-linux-android-gcc
+++ b/bin/mips64el-linux-android-gcc
Binary files differ
diff --git a/bin/mips64el-linux-android-gcov b/bin/mips64el-linux-android-gcov
index ec1edb9..ed71ed3 100755
--- a/bin/mips64el-linux-android-gcov
+++ b/bin/mips64el-linux-android-gcov
Binary files differ
diff --git a/bin/mips64el-linux-android-gcov-tool b/bin/mips64el-linux-android-gcov-tool
new file mode 100755
index 0000000..56b435e
--- /dev/null
+++ b/bin/mips64el-linux-android-gcov-tool
Binary files differ
diff --git a/bin/mips64el-linux-android-gdb b/bin/mips64el-linux-android-gdb
index 43a854a..840b475 100755
--- a/bin/mips64el-linux-android-gdb
+++ b/bin/mips64el-linux-android-gdb
Binary files differ
diff --git a/bin/mips64el-linux-android-ld.bfd b/bin/mips64el-linux-android-ld.bfd
index 29eb091..111a8c3 100755
--- a/bin/mips64el-linux-android-ld.bfd
+++ b/bin/mips64el-linux-android-ld.bfd
Binary files differ
diff --git a/bin/mips64el-linux-android-ld.mcld b/bin/mips64el-linux-android-ld.mcld
index a41346f..095a211 100755
--- a/bin/mips64el-linux-android-ld.mcld
+++ b/bin/mips64el-linux-android-ld.mcld
Binary files differ
diff --git a/bin/mips64el-linux-android-objdump b/bin/mips64el-linux-android-objdump
index 441215c..d212405 100755
--- a/bin/mips64el-linux-android-objdump
+++ b/bin/mips64el-linux-android-objdump
Binary files differ
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
index d843f16..12966f9 100644
--- 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 differ
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
index ce92312..f444e1a 100644
--- 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 differ
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
index d843f16..12966f9 100644
--- 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 differ
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
index 4670c98..1d56e74 100644
--- 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 differ
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
index 4670c98..1d56e74 100644
--- 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 differ
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
index 5ffbcf6..5e1a7be 100644
--- 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 differ
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
index 44399b7..c65ba1a 100644
--- 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 differ
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
index 5b8c698..592c055 100644
--- 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 differ
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
index 2814b8b..f94e22c 100644
--- 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 differ
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
index eebba02..a6cfd6f 100644
--- 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 differ
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
index 2814b8b..f94e22c 100644
--- 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 differ
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
index b5176d0..f0cc82a 100644
--- 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 differ
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
index b5176d0..f0cc82a 100644
--- 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 differ
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
index 256be06..c9f788b 100644
--- 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 differ
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
index 8f962f7..917061c 100644
--- 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 differ
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
index 9b9ed0e..9bfaa62 100644
--- 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 differ
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
index b51a6f5..0150c4b 100644
--- 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 differ
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
index 811fcd4..5b6d844 100644
--- 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 differ
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
index b51a6f5..0150c4b 100644
--- 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 differ
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
index 74c15c8..08f8ca8 100644
--- 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 differ
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
index 74c15c8..08f8ca8 100644
--- 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 differ
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
index d1fe0be..bad3be4 100644
--- 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 differ
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
index b7f32b8..017d990 100644
--- 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 differ
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
index 0db4dfa..6f770d4 100644
--- 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 differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/crtbegin.o b/lib/gcc/mips64el-linux-android/4.9/crtbegin.o
index 03def6c..9c8169a 100644
--- a/lib/gcc/mips64el-linux-android/4.9/crtbegin.o
+++ b/lib/gcc/mips64el-linux-android/4.9/crtbegin.o
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o b/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o
index f69b91c..f443a78 100644
--- a/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o
+++ b/lib/gcc/mips64el-linux-android/4.9/crtbeginS.o
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o b/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o
index 03def6c..9c8169a 100644
--- a/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o
+++ b/lib/gcc/mips64el-linux-android/4.9/crtbeginT.o
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/crtend.o b/lib/gcc/mips64el-linux-android/4.9/crtend.o
index 2e03318..ddbe1bb 100644
--- a/lib/gcc/mips64el-linux-android/4.9/crtend.o
+++ b/lib/gcc/mips64el-linux-android/4.9/crtend.o
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/crtendS.o b/lib/gcc/mips64el-linux-android/4.9/crtendS.o
index 2e03318..ddbe1bb 100644
--- a/lib/gcc/mips64el-linux-android/4.9/crtendS.o
+++ b/lib/gcc/mips64el-linux-android/4.9/crtendS.o
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o b/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o
index fa5a7d5..60a74b3 100644
--- a/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o
+++ b/lib/gcc/mips64el-linux-android/4.9/crtfastmath.o
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-io.c b/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-io.c
new file mode 100644
index 0000000..f226cbf
--- /dev/null
+++ b/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-io.c
@@ -0,0 +1,1088 @@
+/* File format for coverage information
+ Copyright (C) 1996-2014 Free Software Foundation, Inc.
+ Contributed by Bob Manson <manson@cygnus.com>.
+ Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License 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/>. */
+
+/* Routines declared in gcov-io.h. This file should be #included by
+ another source file, after having #included gcov-io.h. */
+
+#if !IN_GCOV
+static void gcov_write_block (unsigned);
+static gcov_unsigned_t *gcov_write_words (unsigned);
+#endif
+static const gcov_unsigned_t *gcov_read_words (unsigned);
+#if !IN_LIBGCOV
+static void gcov_allocate (unsigned);
+#endif
+
+/* Optimum number of gcov_unsigned_t's read from or written to disk. */
+#define GCOV_BLOCK_SIZE (1 << 10)
+
+GCOV_LINKAGE struct gcov_var
+{
+ FILE *file;
+ gcov_position_t start; /* Position of first byte of block */
+ unsigned offset; /* Read/write position within the block. */
+ unsigned length; /* Read limit in the block. */
+ unsigned overread; /* Number of words overread. */
+ int error; /* < 0 overflow, > 0 disk error. */
+ int mode; /* < 0 writing, > 0 reading */
+#if IN_LIBGCOV
+ /* Holds one block plus 4 bytes, thus all coverage reads & writes
+ fit within this buffer and we always can transfer GCOV_BLOCK_SIZE
+ to and from the disk. libgcov never backtracks and only writes 4
+ or 8 byte objects. */
+ gcov_unsigned_t buffer[GCOV_BLOCK_SIZE + 1];
+#else
+ int endian; /* Swap endianness. */
+ /* Holds a variable length block, as the compiler can write
+ strings and needs to backtrack. */
+ size_t alloc;
+ gcov_unsigned_t *buffer;
+#endif
+} gcov_var;
+
+/* Save the current position in the gcov file. */
+/* We need to expose this function when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static inline
+#endif
+gcov_position_t
+gcov_position (void)
+{
+ return gcov_var.start + gcov_var.offset;
+}
+
+/* Return nonzero if the error flag is set. */
+/* We need to expose this function when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static inline
+#endif
+int
+gcov_is_error (void)
+{
+ return gcov_var.file ? gcov_var.error : 1;
+}
+
+#if IN_LIBGCOV
+/* Move to beginning of file and initialize for writing. */
+GCOV_LINKAGE inline void
+gcov_rewrite (void)
+{
+ gcc_assert (gcov_var.mode > 0);
+ gcov_var.mode = -1;
+ gcov_var.start = 0;
+ gcov_var.offset = 0;
+ fseek (gcov_var.file, 0L, SEEK_SET);
+}
+#endif
+
+static inline gcov_unsigned_t from_file (gcov_unsigned_t value)
+{
+#if !IN_LIBGCOV
+ if (gcov_var.endian)
+ {
+ value = (value >> 16) | (value << 16);
+ value = ((value & 0xff00ff) << 8) | ((value >> 8) & 0xff00ff);
+ }
+#endif
+ return value;
+}
+
+/* Open a gcov file. NAME is the name of the file to open and MODE
+ indicates whether a new file should be created, or an existing file
+ opened. If MODE is >= 0 an existing file will be opened, if
+ possible, and if MODE is <= 0, a new file will be created. Use
+ MODE=0 to attempt to reopen an existing file and then fall back on
+ creating a new one. If MODE < 0, the file will be opened in
+ read-only mode. Otherwise it will be opened for modification.
+ Return zero on failure, >0 on opening an existing file and <0 on
+ creating a new one. */
+
+GCOV_LINKAGE int
+#if IN_LIBGCOV
+gcov_open (const char *name)
+#else
+gcov_open (const char *name, int mode)
+#endif
+{
+#if IN_LIBGCOV
+ const int mode = 0;
+#endif
+#if GCOV_LOCKED
+ struct flock s_flock;
+ int fd;
+
+ s_flock.l_whence = SEEK_SET;
+ s_flock.l_start = 0;
+ s_flock.l_len = 0; /* Until EOF. */
+ s_flock.l_pid = getpid ();
+#endif
+
+ gcc_assert (!gcov_var.file);
+ gcov_var.start = 0;
+ gcov_var.offset = gcov_var.length = 0;
+ gcov_var.overread = -1u;
+ gcov_var.error = 0;
+#if !IN_LIBGCOV
+ gcov_var.endian = 0;
+#endif
+#if GCOV_LOCKED
+ if (mode > 0)
+ {
+ /* Read-only mode - acquire a read-lock. */
+ s_flock.l_type = F_RDLCK;
+ /* pass mode (ignored) for compatibility */
+ fd = open (name, O_RDONLY, S_IRUSR | S_IWUSR);
+ }
+ else if (mode < 0)
+ {
+ /* Write mode - acquire a write-lock. */
+ s_flock.l_type = F_WRLCK;
+ fd = open (name, O_RDWR | O_CREAT | O_TRUNC, 0666);
+ }
+ else /* mode == 0 */
+ {
+ /* Read-Write mode - acquire a write-lock. */
+ s_flock.l_type = F_WRLCK;
+ fd = open (name, O_RDWR | O_CREAT, 0666);
+ }
+ if (fd < 0)
+ return 0;
+
+ while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR)
+ continue;
+
+ gcov_var.file = fdopen (fd, (mode > 0) ? "rb" : "r+b");
+
+ if (!gcov_var.file)
+ {
+ close (fd);
+ return 0;
+ }
+
+ if (mode > 0)
+ gcov_var.mode = 1;
+ else if (mode == 0)
+ {
+ struct stat st;
+
+ if (fstat (fd, &st) < 0)
+ {
+ fclose (gcov_var.file);
+ gcov_var.file = 0;
+ return 0;
+ }
+ if (st.st_size != 0)
+ gcov_var.mode = 1;
+ else
+ gcov_var.mode = mode * 2 + 1;
+ }
+ else
+ gcov_var.mode = mode * 2 + 1;
+#else
+ if (mode >= 0)
+ gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b");
+
+ if (gcov_var.file)
+ gcov_var.mode = 1;
+ else if (mode <= 0)
+ {
+ gcov_var.file = fopen (name, "w+b");
+ if (gcov_var.file)
+ gcov_var.mode = mode * 2 + 1;
+ }
+ if (!gcov_var.file)
+ return 0;
+#endif
+
+ setbuf (gcov_var.file, (char *)0);
+
+ return 1;
+}
+
+/* Close the current gcov file. Flushes data to disk. Returns nonzero
+ on failure or error flag set. */
+
+GCOV_LINKAGE int
+gcov_close (void)
+{
+ if (gcov_var.file)
+ {
+#if !IN_GCOV
+ if (gcov_var.offset && gcov_var.mode < 0)
+ gcov_write_block (gcov_var.offset);
+#endif
+ fclose (gcov_var.file);
+ gcov_var.file = 0;
+ gcov_var.length = 0;
+ }
+#if !IN_LIBGCOV
+ free (gcov_var.buffer);
+ gcov_var.alloc = 0;
+ gcov_var.buffer = 0;
+#endif
+ gcov_var.mode = 0;
+ return gcov_var.error;
+}
+
+#if !IN_LIBGCOV
+/* Check if MAGIC is EXPECTED. Use it to determine endianness of the
+ file. Returns +1 for same endian, -1 for other endian and zero for
+ not EXPECTED. */
+
+GCOV_LINKAGE int
+gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected)
+{
+ if (magic == expected)
+ return 1;
+ magic = (magic >> 16) | (magic << 16);
+ magic = ((magic & 0xff00ff) << 8) | ((magic >> 8) & 0xff00ff);
+ if (magic == expected)
+ {
+ gcov_var.endian = 1;
+ return -1;
+ }
+ return 0;
+}
+#endif
+
+#if !IN_LIBGCOV
+static void
+gcov_allocate (unsigned length)
+{
+ size_t new_size = gcov_var.alloc;
+
+ if (!new_size)
+ new_size = GCOV_BLOCK_SIZE;
+ new_size += length;
+ new_size *= 2;
+
+ gcov_var.alloc = new_size;
+ gcov_var.buffer = XRESIZEVAR (gcov_unsigned_t, gcov_var.buffer, new_size << 2);
+}
+#endif
+
+#if !IN_GCOV
+/* Write out the current block, if needs be. */
+
+static void
+gcov_write_block (unsigned size)
+{
+ if (fwrite (gcov_var.buffer, size << 2, 1, gcov_var.file) != 1)
+ gcov_var.error = 1;
+ gcov_var.start += size;
+ gcov_var.offset -= size;
+}
+
+/* Allocate space to write BYTES bytes to the gcov file. Return a
+ pointer to those bytes, or NULL on failure. */
+
+static gcov_unsigned_t *
+gcov_write_words (unsigned words)
+{
+ gcov_unsigned_t *result;
+
+ gcc_assert (gcov_var.mode < 0);
+#if IN_LIBGCOV
+ if (gcov_var.offset >= GCOV_BLOCK_SIZE)
+ {
+ gcov_write_block (GCOV_BLOCK_SIZE);
+ if (gcov_var.offset)
+ {
+ gcc_assert (gcov_var.offset == 1);
+ memcpy (gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4);
+ }
+ }
+#else
+ if (gcov_var.offset + words > gcov_var.alloc)
+ gcov_allocate (gcov_var.offset + words);
+#endif
+ result = &gcov_var.buffer[gcov_var.offset];
+ gcov_var.offset += words;
+
+ return result;
+}
+
+/* Write unsigned VALUE to coverage file. Sets error flag
+ appropriately. */
+
+GCOV_LINKAGE void
+gcov_write_unsigned (gcov_unsigned_t value)
+{
+ gcov_unsigned_t *buffer = gcov_write_words (1);
+
+ buffer[0] = value;
+}
+
+/* Write counter VALUE to coverage file. Sets error flag
+ appropriately. */
+
+#if IN_LIBGCOV
+GCOV_LINKAGE void
+gcov_write_counter (gcov_type value)
+{
+ gcov_unsigned_t *buffer = gcov_write_words (2);
+
+ buffer[0] = (gcov_unsigned_t) value;
+ if (sizeof (value) > sizeof (gcov_unsigned_t))
+ buffer[1] = (gcov_unsigned_t) (value >> 32);
+ else
+ buffer[1] = 0;
+}
+#endif /* IN_LIBGCOV */
+
+#if !IN_LIBGCOV
+/* Write STRING to coverage file. Sets error flag on file
+ error, overflow flag on overflow */
+
+GCOV_LINKAGE void
+gcov_write_string (const char *string)
+{
+ unsigned length = 0;
+ unsigned alloc = 0;
+ gcov_unsigned_t *buffer;
+
+ if (string)
+ {
+ length = strlen (string);
+ alloc = (length + 4) >> 2;
+ }
+
+ buffer = gcov_write_words (1 + alloc);
+
+ buffer[0] = alloc;
+ buffer[alloc] = 0;
+ memcpy (&buffer[1], string, length);
+}
+#endif
+
+#if !IN_LIBGCOV
+/* Write a tag TAG and reserve space for the record length. Return a
+ value to be used for gcov_write_length. */
+
+GCOV_LINKAGE gcov_position_t
+gcov_write_tag (gcov_unsigned_t tag)
+{
+ gcov_position_t result = gcov_var.start + gcov_var.offset;
+ gcov_unsigned_t *buffer = gcov_write_words (2);
+
+ buffer[0] = tag;
+ buffer[1] = 0;
+
+ return result;
+}
+
+/* Write a record length using POSITION, which was returned by
+ gcov_write_tag. The current file position is the end of the
+ record, and is restored before returning. Returns nonzero on
+ overflow. */
+
+GCOV_LINKAGE void
+gcov_write_length (gcov_position_t position)
+{
+ unsigned offset;
+ gcov_unsigned_t length;
+ gcov_unsigned_t *buffer;
+
+ gcc_assert (gcov_var.mode < 0);
+ gcc_assert (position + 2 <= gcov_var.start + gcov_var.offset);
+ gcc_assert (position >= gcov_var.start);
+ offset = position - gcov_var.start;
+ length = gcov_var.offset - offset - 2;
+ buffer = (gcov_unsigned_t *) &gcov_var.buffer[offset];
+ buffer[1] = length;
+ if (gcov_var.offset >= GCOV_BLOCK_SIZE)
+ gcov_write_block (gcov_var.offset);
+}
+
+#else /* IN_LIBGCOV */
+
+/* Write a tag TAG and length LENGTH. */
+
+GCOV_LINKAGE void
+gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length)
+{
+ gcov_unsigned_t *buffer = gcov_write_words (2);
+
+ buffer[0] = tag;
+ buffer[1] = length;
+}
+
+/* Write a summary structure to the gcov file. Return nonzero on
+ overflow. */
+
+GCOV_LINKAGE void
+gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
+{
+ unsigned ix, h_ix, bv_ix, h_cnt = 0;
+ const struct gcov_ctr_summary *csum;
+ unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
+
+ /* Count number of non-zero histogram entries, and fill in a bit vector
+ of non-zero indices. The histogram is only currently computed for arc
+ counters. */
+ for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
+ histo_bitvector[bv_ix] = 0;
+ csum = &summary->ctrs[GCOV_COUNTER_ARCS];
+ for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
+ {
+ if (csum->histogram[h_ix].num_counters > 0)
+ {
+ histo_bitvector[h_ix / 32] |= 1 << (h_ix % 32);
+ h_cnt++;
+ }
+ }
+ gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH (h_cnt));
+ gcov_write_unsigned (summary->checksum);
+ for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
+ {
+ gcov_write_unsigned (csum->num);
+ gcov_write_unsigned (csum->runs);
+ gcov_write_counter (csum->sum_all);
+ gcov_write_counter (csum->run_max);
+ gcov_write_counter (csum->sum_max);
+ if (ix != GCOV_COUNTER_ARCS)
+ {
+ for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
+ gcov_write_unsigned (0);
+ continue;
+ }
+ for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
+ gcov_write_unsigned (histo_bitvector[bv_ix]);
+ for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
+ {
+ if (!csum->histogram[h_ix].num_counters)
+ continue;
+ gcov_write_unsigned (csum->histogram[h_ix].num_counters);
+ gcov_write_counter (csum->histogram[h_ix].min_value);
+ gcov_write_counter (csum->histogram[h_ix].cum_value);
+ }
+ }
+}
+#endif /* IN_LIBGCOV */
+
+#endif /*!IN_GCOV */
+
+/* Return a pointer to read BYTES bytes from the gcov file. Returns
+ NULL on failure (read past EOF). */
+
+static const gcov_unsigned_t *
+gcov_read_words (unsigned words)
+{
+ const gcov_unsigned_t *result;
+ unsigned excess = gcov_var.length - gcov_var.offset;
+
+ gcc_assert (gcov_var.mode > 0);
+ if (excess < words)
+ {
+ gcov_var.start += gcov_var.offset;
+#if IN_LIBGCOV
+ if (excess)
+ {
+ gcc_assert (excess == 1);
+ memcpy (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4);
+ }
+#else
+ memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, excess * 4);
+#endif
+ gcov_var.offset = 0;
+ gcov_var.length = excess;
+#if IN_LIBGCOV
+ gcc_assert (!gcov_var.length || gcov_var.length == 1);
+ excess = GCOV_BLOCK_SIZE;
+#else
+ if (gcov_var.length + words > gcov_var.alloc)
+ gcov_allocate (gcov_var.length + words);
+ excess = gcov_var.alloc - gcov_var.length;
+#endif
+ excess = fread (gcov_var.buffer + gcov_var.length,
+ 1, excess << 2, gcov_var.file) >> 2;
+ gcov_var.length += excess;
+ if (gcov_var.length < words)
+ {
+ gcov_var.overread += words - gcov_var.length;
+ gcov_var.length = 0;
+ return 0;
+ }
+ }
+ result = &gcov_var.buffer[gcov_var.offset];
+ gcov_var.offset += words;
+ return result;
+}
+
+/* Read unsigned value from a coverage file. Sets error flag on file
+ error, overflow flag on overflow */
+
+GCOV_LINKAGE gcov_unsigned_t
+gcov_read_unsigned (void)
+{
+ gcov_unsigned_t value;
+ const gcov_unsigned_t *buffer = gcov_read_words (1);
+
+ if (!buffer)
+ return 0;
+ value = from_file (buffer[0]);
+ return value;
+}
+
+/* Read counter value from a coverage file. Sets error flag on file
+ error, overflow flag on overflow */
+
+GCOV_LINKAGE gcov_type
+gcov_read_counter (void)
+{
+ gcov_type value;
+ const gcov_unsigned_t *buffer = gcov_read_words (2);
+
+ if (!buffer)
+ return 0;
+ value = from_file (buffer[0]);
+ if (sizeof (value) > sizeof (gcov_unsigned_t))
+ value |= ((gcov_type) from_file (buffer[1])) << 32;
+ else if (buffer[1])
+ gcov_var.error = -1;
+
+ return value;
+}
+
+/* We need to expose the below function when compiling for gcov-tool. */
+
+#if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
+/* Read string from coverage file. Returns a pointer to a static
+ buffer, or NULL on empty string. You must copy the string before
+ calling another gcov function. */
+
+GCOV_LINKAGE const char *
+gcov_read_string (void)
+{
+ unsigned length = gcov_read_unsigned ();
+
+ if (!length)
+ return 0;
+
+ return (const char *) gcov_read_words (length);
+}
+#endif
+
+GCOV_LINKAGE void
+gcov_read_summary (struct gcov_summary *summary)
+{
+ unsigned ix, h_ix, bv_ix, h_cnt = 0;
+ struct gcov_ctr_summary *csum;
+ unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
+ unsigned cur_bitvector;
+
+ summary->checksum = gcov_read_unsigned ();
+ for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
+ {
+ csum->num = gcov_read_unsigned ();
+ csum->runs = gcov_read_unsigned ();
+ csum->sum_all = gcov_read_counter ();
+ csum->run_max = gcov_read_counter ();
+ csum->sum_max = gcov_read_counter ();
+ memset (csum->histogram, 0,
+ sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+ for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
+ {
+ histo_bitvector[bv_ix] = gcov_read_unsigned ();
+#if IN_LIBGCOV
+ /* When building libgcov we don't include system.h, which includes
+ hwint.h (where popcount_hwi is declared). However, libgcov.a
+ is built by the bootstrapped compiler and therefore the builtins
+ are always available. */
+ h_cnt += __builtin_popcount (histo_bitvector[bv_ix]);
+#else
+ h_cnt += popcount_hwi (histo_bitvector[bv_ix]);
+#endif
+ }
+ bv_ix = 0;
+ h_ix = 0;
+ cur_bitvector = 0;
+ while (h_cnt--)
+ {
+ /* Find the index corresponding to the next entry we will read in.
+ First find the next non-zero bitvector and re-initialize
+ the histogram index accordingly, then right shift and increment
+ the index until we find a set bit. */
+ while (!cur_bitvector)
+ {
+ h_ix = bv_ix * 32;
+ gcc_assert (bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE);
+ cur_bitvector = histo_bitvector[bv_ix++];
+ }
+ while (!(cur_bitvector & 0x1))
+ {
+ h_ix++;
+ cur_bitvector >>= 1;
+ }
+ gcc_assert (h_ix < GCOV_HISTOGRAM_SIZE);
+
+ csum->histogram[h_ix].num_counters = gcov_read_unsigned ();
+ csum->histogram[h_ix].min_value = gcov_read_counter ();
+ csum->histogram[h_ix].cum_value = gcov_read_counter ();
+ /* Shift off the index we are done with and increment to the
+ corresponding next histogram entry. */
+ cur_bitvector >>= 1;
+ h_ix++;
+ }
+ }
+}
+
+#if (!IN_LIBGCOV && IN_GCOV != 1) || defined (IN_GCOV_TOOL)
+/* Read LEN words (unsigned type) and construct MOD_INFO. */
+
+GCOV_LINKAGE void
+gcov_read_module_info (struct gcov_module_info *mod_info,
+ gcov_unsigned_t len)
+{
+ gcov_unsigned_t src_filename_len, filename_len, i, j, num_strings;
+ mod_info->ident = gcov_read_unsigned ();
+ mod_info->is_primary = gcov_read_unsigned ();
+ mod_info->flags = gcov_read_unsigned ();
+ mod_info->lang = gcov_read_unsigned ();
+ mod_info->ggc_memory = gcov_read_unsigned ();
+ mod_info->num_quote_paths = gcov_read_unsigned ();
+ mod_info->num_bracket_paths = gcov_read_unsigned ();
+ mod_info->num_system_paths = gcov_read_unsigned ();
+ mod_info->num_cpp_defines = gcov_read_unsigned ();
+ mod_info->num_cpp_includes = gcov_read_unsigned ();
+ mod_info->num_cl_args = gcov_read_unsigned ();
+ len -= 11;
+
+ filename_len = gcov_read_unsigned ();
+ mod_info->da_filename = (char *) xmalloc (filename_len *
+ sizeof (gcov_unsigned_t));
+ for (i = 0; i < filename_len; i++)
+ ((gcov_unsigned_t *) mod_info->da_filename)[i] = gcov_read_unsigned ();
+ len -= (filename_len + 1);
+
+ src_filename_len = gcov_read_unsigned ();
+ mod_info->source_filename = (char *) xmalloc (src_filename_len *
+ sizeof (gcov_unsigned_t));
+ for (i = 0; i < src_filename_len; i++)
+ ((gcov_unsigned_t *) mod_info->source_filename)[i] = gcov_read_unsigned ();
+ len -= (src_filename_len + 1);
+
+ num_strings = mod_info->num_quote_paths + mod_info->num_bracket_paths
+ + mod_info->num_system_paths
+ + mod_info->num_cpp_defines + mod_info->num_cpp_includes
+ + mod_info->num_cl_args;
+ for (j = 0; j < num_strings; j++)
+ {
+ gcov_unsigned_t string_len = gcov_read_unsigned ();
+ mod_info->string_array[j] =
+ (char *) xmalloc (string_len * sizeof (gcov_unsigned_t));
+ for (i = 0; i < string_len; i++)
+ ((gcov_unsigned_t *) mod_info->string_array[j])[i] =
+ gcov_read_unsigned ();
+ len -= (string_len + 1);
+ }
+ gcc_assert (!len);
+}
+#endif
+
+/* We need to expose the below function when compiling for gcov-tool. */
+
+#if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
+/* Reset to a known position. BASE should have been obtained from
+ gcov_position, LENGTH should be a record length. */
+
+GCOV_LINKAGE void
+gcov_sync (gcov_position_t base, gcov_unsigned_t length)
+{
+ gcc_assert (gcov_var.mode > 0);
+ base += length;
+ if (base - gcov_var.start <= gcov_var.length)
+ gcov_var.offset = base - gcov_var.start;
+ else
+ {
+ gcov_var.offset = gcov_var.length = 0;
+ fseek (gcov_var.file, base << 2, SEEK_SET);
+ gcov_var.start = ftell (gcov_var.file) >> 2;
+ }
+}
+#endif
+
+#if IN_LIBGCOV
+/* Move to a given position in a gcov file. */
+
+GCOV_LINKAGE void
+gcov_seek (gcov_position_t base)
+{
+ gcc_assert (gcov_var.mode < 0);
+ if (gcov_var.offset)
+ gcov_write_block (gcov_var.offset);
+ fseek (gcov_var.file, base << 2, SEEK_SET);
+ gcov_var.start = ftell (gcov_var.file) >> 2;
+}
+
+/* Truncate the gcov file at the current position. */
+
+GCOV_LINKAGE void
+gcov_truncate (void)
+{
+ long offs;
+ int filenum;
+ gcc_assert (gcov_var.mode < 0);
+ if (gcov_var.offset)
+ gcov_write_block (gcov_var.offset);
+ offs = ftell (gcov_var.file);
+ filenum = fileno (gcov_var.file);
+ if (offs == -1 || filenum == -1 || ftruncate (filenum, offs))
+ gcov_var.error = 1;
+}
+#endif
+
+#if IN_GCOV > 0
+/* Return the modification time of the current gcov file. */
+
+GCOV_LINKAGE time_t
+gcov_time (void)
+{
+ struct stat status;
+
+ if (fstat (fileno (gcov_var.file), &status))
+ return 0;
+ else
+ return status.st_mtime;
+}
+#endif /* IN_GCOV */
+
+#if !IN_GCOV
+/* Determine the index into histogram for VALUE. */
+
+#if IN_LIBGCOV
+static unsigned
+#else
+GCOV_LINKAGE unsigned
+#endif
+gcov_histo_index (gcov_type value)
+{
+ gcov_type_unsigned v = (gcov_type_unsigned)value;
+ unsigned r = 0;
+ unsigned prev2bits = 0;
+
+ /* Find index into log2 scale histogram, where each of the log2
+ sized buckets is divided into 4 linear sub-buckets for better
+ focus in the higher buckets. */
+
+ /* Find the place of the most-significant bit set. */
+ if (v > 0)
+ {
+#if IN_LIBGCOV
+ /* When building libgcov we don't include system.h, which includes
+ hwint.h (where floor_log2 is declared). However, libgcov.a
+ is built by the bootstrapped compiler and therefore the builtins
+ are always available. */
+ r = sizeof (long long) * __CHAR_BIT__ - 1 - __builtin_clzll (v);
+#else
+ /* We use floor_log2 from hwint.c, which takes a HOST_WIDE_INT
+ that is either 32 or 64 bits, and gcov_type_unsigned may be 64 bits.
+ Need to check for the case where gcov_type_unsigned is 64 bits
+ and HOST_WIDE_INT is 32 bits and handle it specially. */
+#if HOST_BITS_PER_WIDEST_INT == HOST_BITS_PER_WIDE_INT
+ r = floor_log2 (v);
+#elif HOST_BITS_PER_WIDEST_INT == 2 * HOST_BITS_PER_WIDE_INT
+ HOST_WIDE_INT hwi_v = v >> HOST_BITS_PER_WIDE_INT;
+ if (hwi_v)
+ r = floor_log2 (hwi_v) + HOST_BITS_PER_WIDE_INT;
+ else
+ r = floor_log2 ((HOST_WIDE_INT)v);
+#else
+ gcc_unreachable ();
+#endif
+#endif
+ }
+
+ /* If at most the 2 least significant bits are set (value is
+ 0 - 3) then that value is our index into the lowest set of
+ four buckets. */
+ if (r < 2)
+ return (unsigned)value;
+
+ gcc_assert (r < 64);
+
+ /* Find the two next most significant bits to determine which
+ of the four linear sub-buckets to select. */
+ prev2bits = (v >> (r - 2)) & 0x3;
+ /* Finally, compose the final bucket index from the log2 index and
+ the next 2 bits. The minimum r value at this point is 2 since we
+ returned above if r was 2 or more, so the minimum bucket at this
+ point is 4. */
+ return (r - 1) * 4 + prev2bits;
+}
+
+/* Merge SRC_HISTO into TGT_HISTO. The counters are assumed to be in
+ the same relative order in both histograms, and are matched up
+ and merged in reverse order. Each counter is assigned an equal portion of
+ its entry's original cumulative counter value when computing the
+ new merged cum_value. */
+
+static void gcov_histogram_merge (gcov_bucket_type *tgt_histo,
+ gcov_bucket_type *src_histo)
+{
+ int src_i, tgt_i, tmp_i = 0;
+ unsigned src_num, tgt_num, merge_num;
+ gcov_type src_cum, tgt_cum, merge_src_cum, merge_tgt_cum, merge_cum;
+ gcov_type merge_min;
+ gcov_bucket_type tmp_histo[GCOV_HISTOGRAM_SIZE];
+ int src_done = 0;
+
+ memset (tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+
+ /* Assume that the counters are in the same relative order in both
+ histograms. Walk the histograms from largest to smallest entry,
+ matching up and combining counters in order. */
+ src_num = 0;
+ src_cum = 0;
+ src_i = GCOV_HISTOGRAM_SIZE - 1;
+ for (tgt_i = GCOV_HISTOGRAM_SIZE - 1; tgt_i >= 0 && !src_done; tgt_i--)
+ {
+ tgt_num = tgt_histo[tgt_i].num_counters;
+ tgt_cum = tgt_histo[tgt_i].cum_value;
+ /* Keep going until all of the target histogram's counters at this
+ position have been matched and merged with counters from the
+ source histogram. */
+ while (tgt_num > 0 && !src_done)
+ {
+ /* If this is either the first time through this loop or we just
+ exhausted the previous non-zero source histogram entry, look
+ for the next non-zero source histogram entry. */
+ if (!src_num)
+ {
+ /* Locate the next non-zero entry. */
+ while (src_i >= 0 && !src_histo[src_i].num_counters)
+ src_i--;
+ /* If source histogram has fewer counters, then just copy over the
+ remaining target counters and quit. */
+ if (src_i < 0)
+ {
+ tmp_histo[tgt_i].num_counters += tgt_num;
+ tmp_histo[tgt_i].cum_value += tgt_cum;
+ if (!tmp_histo[tgt_i].min_value ||
+ tgt_histo[tgt_i].min_value < tmp_histo[tgt_i].min_value)
+ tmp_histo[tgt_i].min_value = tgt_histo[tgt_i].min_value;
+ while (--tgt_i >= 0)
+ {
+ tmp_histo[tgt_i].num_counters
+ += tgt_histo[tgt_i].num_counters;
+ tmp_histo[tgt_i].cum_value += tgt_histo[tgt_i].cum_value;
+ if (!tmp_histo[tgt_i].min_value ||
+ tgt_histo[tgt_i].min_value
+ < tmp_histo[tgt_i].min_value)
+ tmp_histo[tgt_i].min_value = tgt_histo[tgt_i].min_value;
+ }
+
+ src_done = 1;
+ break;
+ }
+
+ src_num = src_histo[src_i].num_counters;
+ src_cum = src_histo[src_i].cum_value;
+ }
+
+ /* The number of counters to merge on this pass is the minimum
+ of the remaining counters from the current target and source
+ histogram entries. */
+ merge_num = tgt_num;
+ if (src_num < merge_num)
+ merge_num = src_num;
+
+ /* The merged min_value is the sum of the min_values from target
+ and source. */
+ merge_min = tgt_histo[tgt_i].min_value + src_histo[src_i].min_value;
+
+ /* Compute the portion of source and target entries' cum_value
+ that will be apportioned to the counters being merged.
+ The total remaining cum_value from each entry is divided
+ equally among the counters from that histogram entry if we
+ are not merging all of them. */
+ merge_src_cum = src_cum;
+ if (merge_num < src_num)
+ merge_src_cum = merge_num * src_cum / src_num;
+ merge_tgt_cum = tgt_cum;
+ if (merge_num < tgt_num)
+ merge_tgt_cum = merge_num * tgt_cum / tgt_num;
+ /* The merged cum_value is the sum of the source and target
+ components. */
+ merge_cum = merge_src_cum + merge_tgt_cum;
+
+ /* Update the remaining number of counters and cum_value left
+ to be merged from this source and target entry. */
+ src_cum -= merge_src_cum;
+ tgt_cum -= merge_tgt_cum;
+ src_num -= merge_num;
+ tgt_num -= merge_num;
+
+ /* The merged counters get placed in the new merged histogram
+ at the entry for the merged min_value. */
+ tmp_i = gcov_histo_index (merge_min);
+ gcc_assert (tmp_i < GCOV_HISTOGRAM_SIZE);
+ tmp_histo[tmp_i].num_counters += merge_num;
+ tmp_histo[tmp_i].cum_value += merge_cum;
+ if (!tmp_histo[tmp_i].min_value ||
+ merge_min < tmp_histo[tmp_i].min_value)
+ tmp_histo[tmp_i].min_value = merge_min;
+
+ /* Ensure the search for the next non-zero src_histo entry starts
+ at the next smallest histogram bucket. */
+ if (!src_num)
+ src_i--;
+ }
+ }
+
+ gcc_assert (tgt_i < 0);
+
+ /* In the case where there were more counters in the source histogram,
+ accumulate the remaining unmerged cumulative counter values. Add
+ those to the smallest non-zero target histogram entry. Otherwise,
+ the total cumulative counter values in the histogram will be smaller
+ than the sum_all stored in the summary, which will complicate
+ computing the working set information from the histogram later on. */
+ if (src_num)
+ src_i--;
+ while (src_i >= 0)
+ {
+ src_cum += src_histo[src_i].cum_value;
+ src_i--;
+ }
+ /* At this point, tmp_i should be the smallest non-zero entry in the
+ tmp_histo. */
+ gcc_assert (tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE
+ && tmp_histo[tmp_i].num_counters > 0);
+ tmp_histo[tmp_i].cum_value += src_cum;
+
+ /* Finally, copy the merged histogram into tgt_histo. */
+ memcpy (tgt_histo, tmp_histo,
+ sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+}
+#endif /* !IN_GCOV */
+
+/* This is used by gcov-dump (IN_GCOV == -1) and in the compiler
+ (!IN_GCOV && !IN_LIBGCOV). */
+#if IN_GCOV <= 0 && !IN_LIBGCOV
+/* Compute the working set information from the counter histogram in
+ the profile summary. This is an array of information corresponding to a
+ range of percentages of the total execution count (sum_all), and includes
+ the number of counters required to cover that working set percentage and
+ the minimum counter value in that working set. */
+
+GCOV_LINKAGE void
+compute_working_sets (const struct gcov_ctr_summary *summary,
+ gcov_working_set_t *gcov_working_sets)
+{
+ gcov_type working_set_cum_values[NUM_GCOV_WORKING_SETS];
+ gcov_type ws_cum_hotness_incr;
+ gcov_type cum, tmp_cum;
+ const gcov_bucket_type *histo_bucket;
+ unsigned ws_ix, c_num, count;
+ int h_ix;
+
+ /* Compute the amount of sum_all that the cumulative hotness grows
+ by in each successive working set entry, which depends on the
+ number of working set entries. */
+ ws_cum_hotness_incr = summary->sum_all / NUM_GCOV_WORKING_SETS;
+
+ /* Next fill in an array of the cumulative hotness values corresponding
+ to each working set summary entry we are going to compute below.
+ Skip 0% statistics, which can be extrapolated from the
+ rest of the summary data. */
+ cum = ws_cum_hotness_incr;
+ for (ws_ix = 0; ws_ix < NUM_GCOV_WORKING_SETS;
+ ws_ix++, cum += ws_cum_hotness_incr)
+ working_set_cum_values[ws_ix] = cum;
+ /* The last summary entry is reserved for (roughly) 99.9% of the
+ working set. Divide by 1024 so it becomes a shift, which gives
+ almost exactly 99.9%. */
+ working_set_cum_values[NUM_GCOV_WORKING_SETS-1]
+ = summary->sum_all - summary->sum_all/1024;
+
+ /* Next, walk through the histogram in decending order of hotness
+ and compute the statistics for the working set summary array.
+ As histogram entries are accumulated, we check to see which
+ working set entries have had their expected cum_value reached
+ and fill them in, walking the working set entries in increasing
+ size of cum_value. */
+ ws_ix = 0; /* The current entry into the working set array. */
+ cum = 0; /* The current accumulated counter sum. */
+ count = 0; /* The current accumulated count of block counters. */
+ for (h_ix = GCOV_HISTOGRAM_SIZE - 1;
+ h_ix >= 0 && ws_ix < NUM_GCOV_WORKING_SETS; h_ix--)
+ {
+ histo_bucket = &summary->histogram[h_ix];
+
+ /* If we haven't reached the required cumulative counter value for
+ the current working set percentage, simply accumulate this histogram
+ entry into the running sums and continue to the next histogram
+ entry. */
+ if (cum + histo_bucket->cum_value < working_set_cum_values[ws_ix])
+ {
+ cum += histo_bucket->cum_value;
+ count += histo_bucket->num_counters;
+ continue;
+ }
+
+ /* If adding the current histogram entry's cumulative counter value
+ causes us to exceed the current working set size, then estimate
+ how many of this histogram entry's counter values are required to
+ reach the working set size, and fill in working set entries
+ as we reach their expected cumulative value. */
+ for (c_num = 0, tmp_cum = cum;
+ c_num < histo_bucket->num_counters && ws_ix < NUM_GCOV_WORKING_SETS;
+ c_num++)
+ {
+ count++;
+ /* If we haven't reached the last histogram entry counter, add
+ in the minimum value again. This will underestimate the
+ cumulative sum so far, because many of the counter values in this
+ entry may have been larger than the minimum. We could add in the
+ average value every time, but that would require an expensive
+ divide operation. */
+ if (c_num + 1 < histo_bucket->num_counters)
+ tmp_cum += histo_bucket->min_value;
+ /* If we have reached the last histogram entry counter, then add
+ in the entire cumulative value. */
+ else
+ tmp_cum = cum + histo_bucket->cum_value;
+
+ /* Next walk through successive working set entries and fill in
+ the statistics for any whose size we have reached by accumulating
+ this histogram counter. */
+ while (ws_ix < NUM_GCOV_WORKING_SETS
+ && tmp_cum >= working_set_cum_values[ws_ix])
+ {
+ gcov_working_sets[ws_ix].num_counters = count;
+ gcov_working_sets[ws_ix].min_counter
+ = histo_bucket->min_value;
+ ws_ix++;
+ }
+ }
+ /* Finally, update the running cumulative value since we were
+ using a temporary above. */
+ cum += histo_bucket->cum_value;
+ }
+ gcc_assert (ws_ix == NUM_GCOV_WORKING_SETS);
+}
+#endif /* IN_GCOV <= 0 && !IN_LIBGCOV */
diff --git a/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-io.h b/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-io.h
new file mode 100644
index 0000000..50ffa55
--- /dev/null
+++ b/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-io.h
@@ -0,0 +1,489 @@
+/* File format for coverage information
+ Copyright (C) 1996-2014 Free Software Foundation, Inc.
+ Contributed by Bob Manson <manson@cygnus.com>.
+ Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License 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/>. */
+
+
+/* Coverage information is held in two files. A notes file, which is
+ generated by the compiler, and a data file, which is generated by
+ the program under test. Both files use a similar structure. We do
+ not attempt to make these files backwards compatible with previous
+ versions, as you only need coverage information when developing a
+ program. We do hold version information, so that mismatches can be
+ detected, and we use a format that allows tools to skip information
+ they do not understand or are not interested in.
+
+ Numbers are recorded in the 32 bit unsigned binary form of the
+ endianness of the machine generating the file. 64 bit numbers are
+ stored as two 32 bit numbers, the low part first. Strings are
+ padded with 1 to 4 NUL bytes, to bring the length up to a multiple
+ of 4. The number of 4 bytes is stored, followed by the padded
+ string. Zero length and NULL strings are simply stored as a length
+ of zero (they have no trailing NUL or padding).
+
+ int32: byte3 byte2 byte1 byte0 | byte0 byte1 byte2 byte3
+ int64: int32:low int32:high
+ string: int32:0 | int32:length char* char:0 padding
+ padding: | char:0 | char:0 char:0 | char:0 char:0 char:0
+ item: int32 | int64 | string
+
+ The basic format of the files is
+
+ file : int32:magic int32:version int32:stamp record*
+
+ The magic ident is different for the notes and the data files. The
+ magic ident is used to determine the endianness of the file, when
+ reading. The version is the same for both files and is derived
+ from gcc's version number. The stamp value is used to synchronize
+ note and data files and to synchronize merging within a data
+ file. It need not be an absolute time stamp, merely a ticker that
+ increments fast enough and cycles slow enough to distinguish
+ different compile/run/compile cycles.
+
+ Although the ident and version are formally 32 bit numbers, they
+ are derived from 4 character ASCII strings. The version number
+ consists of the single character major version number, a two
+ character minor version number (leading zero for versions less than
+ 10), and a single character indicating the status of the release.
+ That will be 'e' experimental, 'p' prerelease and 'r' for release.
+ Because, by good fortune, these are in alphabetical order, string
+ collating can be used to compare version strings. Be aware that
+ the 'e' designation will (naturally) be unstable and might be
+ incompatible with itself. For gcc 3.4 experimental, it would be
+ '304e' (0x33303465). When the major version reaches 10, the
+ letters A-Z will be used. Assuming minor increments releases every
+ 6 months, we have to make a major increment every 50 years.
+ Assuming major increments releases every 5 years, we're ok for the
+ next 155 years -- good enough for me.
+
+ A record has a tag, length and variable amount of data.
+
+ record: header data
+ header: int32:tag int32:length
+ data: item*
+
+ Records are not nested, but there is a record hierarchy. Tag
+ numbers reflect this hierarchy. Tags are unique across note and
+ data files. Some record types have a varying amount of data. The
+ LENGTH is the number of 4bytes that follow and is usually used to
+ determine how much data. The tag value is split into 4 8-bit
+ fields, one for each of four possible levels. The most significant
+ is allocated first. Unused levels are zero. Active levels are
+ odd-valued, so that the LSB of the level is one. A sub-level
+ incorporates the values of its superlevels. This formatting allows
+ you to determine the tag hierarchy, without understanding the tags
+ themselves, and is similar to the standard section numbering used
+ in technical documents. Level values [1..3f] are used for common
+ tags, values [41..9f] for the notes file and [a1..ff] for the data
+ file.
+
+ The notes file contains the following records
+ note: unit function-graph*
+ unit: header int32:checksum string:source
+ function-graph: announce_function basic_blocks {arcs | lines}*
+ announce_function: header int32:ident
+ int32:lineno_checksum int32:cfg_checksum
+ string:name string:source int32:lineno
+ basic_block: header int32:flags*
+ arcs: header int32:block_no arc*
+ arc: int32:dest_block int32:flags
+ lines: header int32:block_no line*
+ int32:0 string:NULL
+ line: int32:line_no | int32:0 string:filename
+
+ The BASIC_BLOCK record holds per-bb flags. The number of blocks
+ can be inferred from its data length. There is one ARCS record per
+ basic block. The number of arcs from a bb is implicit from the
+ data length. It enumerates the destination bb and per-arc flags.
+ There is one LINES record per basic block, it enumerates the source
+ lines which belong to that basic block. Source file names are
+ introduced by a line number of 0, following lines are from the new
+ source file. The initial source file for the function is NULL, but
+ the current source file should be remembered from one LINES record
+ to the next. The end of a block is indicated by an empty filename
+ - this does not reset the current source file. Note there is no
+ ordering of the ARCS and LINES records: they may be in any order,
+ interleaved in any manner. The current filename follows the order
+ the LINES records are stored in the file, *not* the ordering of the
+ blocks they are for.
+
+ The data file contains the following records.
+ data: {unit summary:object summary:program* function-data*}*
+ unit: header int32:checksum
+ function-data: announce_function present counts
+ announce_function: header int32:ident
+ int32:lineno_checksum int32:cfg_checksum
+ present: header int32:present
+ counts: header int64:count*
+ summary: int32:checksum {count-summary}GCOV_COUNTERS_SUMMABLE
+ count-summary: int32:num int32:runs int64:sum
+ int64:max int64:sum_max histogram
+ histogram: {int32:bitvector}8 histogram-buckets*
+ histogram-buckets: int32:num int64:min int64:sum
+
+ The ANNOUNCE_FUNCTION record is the same as that in the note file,
+ but without the source location. The COUNTS gives the
+ counter values for instrumented features. The about the whole
+ program. The checksum is used for whole program summaries, and
+ disambiguates different programs which include the same
+ instrumented object file. There may be several program summaries,
+ each with a unique checksum. The object summary's checksum is
+ zero. Note that the data file might contain information from
+ several runs concatenated, or the data might be merged.
+
+ This file is included by both the compiler, gcov tools and the
+ runtime support library libgcov. IN_LIBGCOV and IN_GCOV are used to
+ distinguish which case is which. If IN_LIBGCOV is nonzero,
+ libgcov is being built. If IN_GCOV is nonzero, the gcov tools are
+ being built. Otherwise the compiler is being built. IN_GCOV may be
+ positive or negative. If positive, we are compiling a tool that
+ requires additional functions (see the code for knowledge of what
+ those functions are). */
+
+#ifndef GCC_GCOV_IO_H
+#define GCC_GCOV_IO_H
+
+#ifndef IN_LIBGCOV
+/* About the host */
+
+typedef unsigned gcov_unsigned_t;
+typedef unsigned gcov_position_t;
+
+#if LONG_LONG_TYPE_SIZE > 32
+#define GCOV_TYPE_ATOMIC_FETCH_ADD_FN __atomic_fetch_add_8
+#define GCOV_TYPE_ATOMIC_FETCH_ADD BUILT_IN_ATOMIC_FETCH_ADD_8
+#else
+#define GCOV_TYPE_ATOMIC_FETCH_ADD_FN __atomic_fetch_add_4
+#define GCOV_TYPE_ATOMIC_FETCH_ADD BUILT_IN_ATOMIC_FETCH_ADD_4
+#endif
+#define PROFILE_GEN_EDGE_ATOMIC (flag_profile_gen_atomic == 1 || \
+ flag_profile_gen_atomic == 3)
+#define PROFILE_GEN_VALUE_ATOMIC (flag_profile_gen_atomic == 2 || \
+ flag_profile_gen_atomic == 3)
+
+/* gcov_type is typedef'd elsewhere for the compiler */
+#if IN_GCOV
+#define GCOV_LINKAGE static
+typedef HOST_WIDEST_INT gcov_type;
+typedef unsigned HOST_WIDEST_INT gcov_type_unsigned;
+#if IN_GCOV > 0
+#include <sys/types.h>
+#endif
+
+#define FUNC_ID_WIDTH HOST_BITS_PER_WIDE_INT/2
+#define FUNC_ID_MASK ((1L << FUNC_ID_WIDTH) - 1)
+#define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) (unsigned)(((gid) >> FUNC_ID_WIDTH) & FUNC_ID_MASK)
+#define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) (unsigned)((gid) & FUNC_ID_MASK)
+#define FUNC_GLOBAL_ID(m,f) ((((HOST_WIDE_INT) (m)) << FUNC_ID_WIDTH) | (f)
+
+#else /*!IN_GCOV */
+#define GCOV_TYPE_SIZE (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32)
+#endif
+
+#if defined (HOST_HAS_F_SETLKW)
+#define GCOV_LOCKED 1
+#else
+#define GCOV_LOCKED 0
+#endif
+
+#define ATTRIBUTE_HIDDEN
+
+#endif /* !IN_LIBGOCV */
+
+#ifndef GCOV_LINKAGE
+#define GCOV_LINKAGE extern
+#endif
+
+/* File suffixes. */
+#define GCOV_DATA_SUFFIX ".gcda"
+#define GCOV_NOTE_SUFFIX ".gcno"
+
+/* File magic. Must not be palindromes. */
+#define GCOV_DATA_MAGIC ((gcov_unsigned_t)0x67636461) /* "gcda" */
+#define GCOV_NOTE_MAGIC ((gcov_unsigned_t)0x67636e6f) /* "gcno" */
+
+/* gcov-iov.h is automatically generated by the makefile from
+ version.c, it looks like
+ #define GCOV_VERSION ((gcov_unsigned_t)0x89abcdef)
+*/
+#include "gcov-iov.h"
+
+/* Convert a magic or version number to a 4 character string. */
+#define GCOV_UNSIGNED2STRING(ARRAY,VALUE) \
+ ((ARRAY)[0] = (char)((VALUE) >> 24), \
+ (ARRAY)[1] = (char)((VALUE) >> 16), \
+ (ARRAY)[2] = (char)((VALUE) >> 8), \
+ (ARRAY)[3] = (char)((VALUE) >> 0))
+
+/* The record tags. Values [1..3f] are for tags which may be in either
+ file. Values [41..9f] for those in the note file and [a1..ff] for
+ the data file. The tag value zero is used as an explicit end of
+ file marker -- it is not required to be present. */
+
+#define GCOV_TAG_FUNCTION ((gcov_unsigned_t)0x01000000)
+#define GCOV_TAG_FUNCTION_LENGTH (3)
+#define GCOV_TAG_BLOCKS ((gcov_unsigned_t)0x01410000)
+#define GCOV_TAG_BLOCKS_LENGTH(NUM) (NUM)
+#define GCOV_TAG_BLOCKS_NUM(LENGTH) (LENGTH)
+#define GCOV_TAG_ARCS ((gcov_unsigned_t)0x01430000)
+#define GCOV_TAG_ARCS_LENGTH(NUM) (1 + (NUM) * 2)
+#define GCOV_TAG_ARCS_NUM(LENGTH) (((LENGTH) - 1) / 2)
+#define GCOV_TAG_LINES ((gcov_unsigned_t)0x01450000)
+#define GCOV_TAG_COUNTER_BASE ((gcov_unsigned_t)0x01a10000)
+#define GCOV_TAG_COUNTER_LENGTH(NUM) ((NUM) * 2)
+#define GCOV_TAG_COUNTER_NUM(LENGTH) ((LENGTH) / 2)
+#define GCOV_TAG_OBJECT_SUMMARY ((gcov_unsigned_t)0xa1000000) /* Obsolete */
+#define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000)
+#define GCOV_TAG_SUMMARY_LENGTH(NUM) \
+ (1 + GCOV_COUNTERS_SUMMABLE * (10 + 3 * 2) + (NUM) * 5)
+#define GCOV_TAG_MODULE_INFO ((gcov_unsigned_t)0xab000000)
+#define GCOV_TAG_AFDO_FILE_NAMES ((gcov_unsigned_t)0xaa000000)
+#define GCOV_TAG_AFDO_FUNCTION ((gcov_unsigned_t)0xac000000)
+#define GCOV_TAG_AFDO_MODULE_GROUPING ((gcov_unsigned_t)0xae000000)
+#define GCOV_TAG_AFDO_WORKING_SET ((gcov_unsigned_t)0xaf000000)
+
+/* Counters that are collected. */
+#define DEF_GCOV_COUNTER(COUNTER, NAME, MERGE_FN) COUNTER,
+enum {
+#include "gcov-counter.def"
+GCOV_COUNTERS
+};
+#undef DEF_GCOV_COUNTER
+
+/* Counters which can be summaried. */
+#define GCOV_COUNTERS_SUMMABLE (GCOV_COUNTER_ARCS + 1)
+
+/* The first of counters used for value profiling. They must form a
+ consecutive interval and their order must match the order of
+ HIST_TYPEs in value-prof.h. */
+#define GCOV_FIRST_VALUE_COUNTER GCOV_COUNTERS_SUMMABLE
+
+/* The last of counters used for value profiling. */
+#define GCOV_LAST_VALUE_COUNTER (GCOV_COUNTERS - 2)
+
+/* Number of counters used for value profiling. */
+#define GCOV_N_VALUE_COUNTERS \
+ (GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1)
+
+#define GCOV_ICALL_TOPN_VAL 2 /* Track two hottest callees */
+#define GCOV_ICALL_TOPN_NCOUNTS 9 /* The number of counter entries per icall callsite */
+
+/* Convert a counter index to a tag. */
+#define GCOV_TAG_FOR_COUNTER(COUNT) \
+ (GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17))
+/* Convert a tag to a counter. */
+#define GCOV_COUNTER_FOR_TAG(TAG) \
+ ((unsigned)(((TAG) - GCOV_TAG_COUNTER_BASE) >> 17))
+/* Check whether a tag is a counter tag. */
+#define GCOV_TAG_IS_COUNTER(TAG) \
+ (!((TAG) & 0xFFFF) && GCOV_COUNTER_FOR_TAG (TAG) < GCOV_COUNTERS)
+
+/* The tag level mask has 1's in the position of the inner levels, &
+ the lsb of the current level, and zero on the current and outer
+ levels. */
+#define GCOV_TAG_MASK(TAG) (((TAG) - 1) ^ (TAG))
+
+/* Return nonzero if SUB is an immediate subtag of TAG. */
+#define GCOV_TAG_IS_SUBTAG(TAG,SUB) \
+ (GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) \
+ && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK (TAG)))
+
+/* Return nonzero if SUB is at a sublevel to TAG. */
+#define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \
+ (GCOV_TAG_MASK (TAG) > GCOV_TAG_MASK (SUB))
+
+/* Basic block flags. */
+#define GCOV_BLOCK_UNEXPECTED (1 << 1)
+
+/* Arc flags. */
+#define GCOV_ARC_ON_TREE (1 << 0)
+#define GCOV_ARC_FAKE (1 << 1)
+#define GCOV_ARC_FALLTHROUGH (1 << 2)
+
+/* Structured records. */
+
+/* Structure used for each bucket of the log2 histogram of counter values. */
+typedef struct
+{
+ /* Number of counters whose profile count falls within the bucket. */
+ gcov_unsigned_t num_counters;
+ /* Smallest profile count included in this bucket. */
+ gcov_type min_value;
+ /* Cumulative value of the profile counts in this bucket. */
+ gcov_type cum_value;
+} gcov_bucket_type;
+
+/* For a log2 scale histogram with each range split into 4
+ linear sub-ranges, there will be at most 64 (max gcov_type bit size) - 1 log2
+ ranges since the lowest 2 log2 values share the lowest 4 linear
+ sub-range (values 0 - 3). This is 252 total entries (63*4). */
+
+#define GCOV_HISTOGRAM_SIZE 252
+
+/* How many unsigned ints are required to hold a bit vector of non-zero
+ histogram entries when the histogram is written to the gcov file.
+ This is essentially a ceiling divide by 32 bits. */
+#define GCOV_HISTOGRAM_BITVECTOR_SIZE (GCOV_HISTOGRAM_SIZE + 31) / 32
+
+/* Cumulative counter data. */
+struct gcov_ctr_summary
+{
+ gcov_unsigned_t num; /* number of counters. */
+ gcov_unsigned_t runs; /* number of program runs */
+ gcov_type sum_all; /* sum of all counters accumulated. */
+ gcov_type run_max; /* maximum value on a single run. */
+ gcov_type sum_max; /* sum of individual run max values. */
+ gcov_bucket_type histogram[GCOV_HISTOGRAM_SIZE]; /* histogram of
+ counter values. */
+};
+
+/* Object & program summary record. */
+struct gcov_summary
+{
+ gcov_unsigned_t checksum; /* checksum of program */
+ struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE];
+};
+
+#define GCOV_MODULE_UNKNOWN_LANG 0
+#define GCOV_MODULE_C_LANG 1
+#define GCOV_MODULE_CPP_LANG 2
+#define GCOV_MODULE_FORT_LANG 3
+
+#define GCOV_MODULE_ASM_STMTS (1 << 16)
+#define GCOV_MODULE_LANG_MASK 0xffff
+
+/* Source module info. The data structure is used in
+ both runtime and profile-use phase. Make sure to allocate
+ enough space for the variable length member. */
+struct gcov_module_info
+{
+ gcov_unsigned_t ident;
+ gcov_unsigned_t is_primary; /* this is overloaded to mean two things:
+ (1) means FDO/LIPO in instrumented binary.
+ (2) means IS_PRIMARY in persistent file or
+ memory copy used in profile-use. */
+ gcov_unsigned_t flags; /* bit 0: is_exported,
+ bit 1: need to include all the auxiliary
+ modules in use compilation. */
+ gcov_unsigned_t lang; /* lower 16 bits encode the language, and the upper
+ 16 bits enocde other attributes, such as whether
+ any assembler is present in the source, etc. */
+ gcov_unsigned_t ggc_memory; /* memory needed for parsing in kb */
+ char *da_filename;
+ char *source_filename;
+ gcov_unsigned_t num_quote_paths;
+ gcov_unsigned_t num_bracket_paths;
+ gcov_unsigned_t num_system_paths;
+ gcov_unsigned_t num_cpp_defines;
+ gcov_unsigned_t num_cpp_includes;
+ gcov_unsigned_t num_cl_args;
+ char *string_array[1];
+};
+
+extern struct gcov_module_info **module_infos;
+extern unsigned primary_module_id;
+#define SET_MODULE_INCLUDE_ALL_AUX(modu) ((modu->flags |= 0x2))
+#define MODULE_INCLUDE_ALL_AUX_FLAG(modu) ((modu->flags & 0x2))
+#define SET_MODULE_EXPORTED(modu) ((modu->flags |= 0x1))
+#define MODULE_EXPORTED_FLAG(modu) ((modu->flags & 0x1))
+#define PRIMARY_MODULE_EXPORTED \
+ (MODULE_EXPORTED_FLAG (module_infos[0]) \
+ && !((module_infos[0]->lang & GCOV_MODULE_ASM_STMTS) \
+ && flag_ripa_disallow_asm_modules))
+
+#if !defined(inhibit_libc)
+
+/* Functions for reading and writing gcov files. In libgcov you can
+ open the file for reading then writing. Elsewhere you can open the
+ file either for reading or for writing. When reading a file you may
+ use the gcov_read_* functions, gcov_sync, gcov_position, &
+ gcov_error. When writing a file you may use the gcov_write
+ functions, gcov_seek & gcov_error. When a file is to be rewritten
+ you use the functions for reading, then gcov_rewrite then the
+ functions for writing. Your file may become corrupted if you break
+ these invariants. */
+
+#if !IN_LIBGCOV
+GCOV_LINKAGE int gcov_open (const char */*name*/, int /*direction*/);
+GCOV_LINKAGE int gcov_magic (gcov_unsigned_t, gcov_unsigned_t);
+#endif
+
+/* Available everywhere. */
+GCOV_LINKAGE int gcov_close (void) ATTRIBUTE_HIDDEN;
+GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void) ATTRIBUTE_HIDDEN;
+GCOV_LINKAGE gcov_type gcov_read_counter (void) ATTRIBUTE_HIDDEN;
+GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *) ATTRIBUTE_HIDDEN;
+GCOV_LINKAGE const char *gcov_read_string (void);
+GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/,
+ gcov_unsigned_t /*length */);
+
+
+#if !IN_LIBGCOV && IN_GCOV != 1
+GCOV_LINKAGE void gcov_read_module_info (struct gcov_module_info *mod_info,
+ gcov_unsigned_t len) ATTRIBUTE_HIDDEN;
+#endif
+
+#if !IN_GCOV
+/* Available outside gcov */
+GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t) ATTRIBUTE_HIDDEN;
+#endif
+
+#if !IN_GCOV && !IN_LIBGCOV
+/* Available only in compiler */
+GCOV_LINKAGE unsigned gcov_histo_index (gcov_type value);
+GCOV_LINKAGE void gcov_write_string (const char *);
+GCOV_LINKAGE gcov_position_t gcov_write_tag (gcov_unsigned_t);
+GCOV_LINKAGE void gcov_write_length (gcov_position_t /*position*/);
+#endif
+
+#if IN_GCOV <= 0 && !IN_LIBGCOV
+/* Available in gcov-dump and the compiler. */
+
+/* Number of data points in the working set summary array. Using 128
+ provides information for at least every 1% increment of the total
+ profile size. The last entry is hardwired to 99.9% of the total. */
+#define NUM_GCOV_WORKING_SETS 128
+
+/* Working set size statistics for a given percentage of the entire
+ profile (sum_all from the counter summary). */
+typedef struct gcov_working_set_info
+{
+ /* Number of hot counters included in this working set. */
+ unsigned num_counters;
+ /* Smallest counter included in this working set. */
+ gcov_type min_counter;
+} gcov_working_set_t;
+
+GCOV_LINKAGE void compute_working_sets (const struct gcov_ctr_summary *summary,
+ gcov_working_set_t *gcov_working_sets);
+#endif
+
+#if IN_GCOV > 0
+/* Available in gcov */
+GCOV_LINKAGE time_t gcov_time (void);
+#endif
+
+#endif /* !inhibit_libc */
+
+#endif /* GCC_GCOV_IO_H */
diff --git a/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-iov.h b/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-iov.h
new file mode 100644
index 0000000..d6e33b7
--- /dev/null
+++ b/lib/gcc/mips64el-linux-android/4.9/gcov-src/gcov-iov.h
@@ -0,0 +1,4 @@
+/* Generated automatically by the program `build/gcov-iov'
+ from `4.9 (4 9) and prerelease (*)'. */
+
+#define GCOV_VERSION ((gcov_unsigned_t)0x3430392a) /* 409* */
diff --git a/lib/gcc/mips64el-linux-android/4.9/gcov-src/libgcov-driver.c b/lib/gcc/mips64el-linux-android/4.9/gcov-src/libgcov-driver.c
new file mode 100644
index 0000000..dc8cf36
--- /dev/null
+++ b/lib/gcc/mips64el-linux-android/4.9/gcov-src/libgcov-driver.c
@@ -0,0 +1,1193 @@
+/* Routines required for instrumenting a program. */
+/* Compile this one with gcc. */
+/* 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/>. */
+
+#include "libgcov.h"
+
+#if defined(inhibit_libc)
+/* If libc and its header files are not available, provide dummy functions. */
+
+#if defined(L_gcov)
+void __gcov_init (struct gcov_info *p __attribute__ ((unused))) {}
+#endif
+
+#else /* inhibit_libc */
+
+#include <string.h>
+#if GCOV_LOCKED
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/stat.h>
+#endif
+
+#ifdef L_gcov
+#include "gcov-io.c"
+
+#ifndef IN_GCOV_TOOL
+extern gcov_unsigned_t __gcov_sampling_period;
+extern gcov_unsigned_t __gcov_has_sampling;
+static int gcov_sampling_period_initialized = 0;
+#endif
+
+/* Unique identifier assigned to each module (object file). */
+static gcov_unsigned_t gcov_cur_module_id = 0;
+
+
+/* Dynamic call graph build and form module groups. */
+int __gcov_compute_module_groups (void) ATTRIBUTE_HIDDEN;
+void __gcov_finalize_dyn_callgraph (void) ATTRIBUTE_HIDDEN;
+
+/* The following functions can be called from outside of this file. */
+extern void gcov_clear (void) ATTRIBUTE_HIDDEN;
+extern void gcov_exit (void) ATTRIBUTE_HIDDEN;
+extern void set_gcov_dump_complete (void) ATTRIBUTE_HIDDEN;
+extern void reset_gcov_dump_complete (void) ATTRIBUTE_HIDDEN;
+extern int get_gcov_dump_complete (void) ATTRIBUTE_HIDDEN;
+extern void set_gcov_list (struct gcov_info *) ATTRIBUTE_HIDDEN;
+__attribute__((weak)) void __coverage_callback (gcov_type, int);
+
+#ifndef IN_GCOV_TOOL
+/* Create a strong reference to these symbols so that they are
+ unconditionally pulled into the instrumented binary, even when
+ the only reference is a weak reference. This is necessary because
+ we are using weak references to enable references from code that
+ may not be linked with libgcov. These are the only symbols that
+ should be accessed via link references from application code!
+
+ A subtlety of the linker is that it will only resolve weak references
+ defined within archive libraries when there is a strong reference to
+ something else defined within the same object file. Since these functions
+ are defined within their own object files, they would not automatically
+ get resolved. Since there are symbols within the main L_gcov
+ section that are strongly referenced during -fprofile-generate and
+ -ftest-coverage builds, these dummy symbols will always need to be
+ resolved. */
+void (*__gcov_dummy_ref1)(void) = &__gcov_reset;
+void (*__gcov_dummy_ref2)(void) = &__gcov_dump;
+extern char *__gcov_get_profile_prefix (void);
+char *(*__gcov_dummy_ref3)(void) = &__gcov_get_profile_prefix;
+extern void __gcov_set_sampling_period (unsigned int period);
+char *(*__gcov_dummy_ref4)(void) = &__gcov_set_sampling_period;
+extern unsigned int __gcov_sampling_enabled (void);
+char *(*__gcov_dummy_ref5)(void) = &__gcov_sampling_enabled;
+extern void __gcov_flush (void);
+char *(*__gcov_dummy_ref6)(void) = &__gcov_flush;
+extern unsigned int __gcov_profiling_for_test_coverage (void);
+char *(*__gcov_dummy_ref7)(void) = &__gcov_profiling_for_test_coverage;
+#endif
+
+/* Default callback function for profile instrumentation callback. */
+__attribute__((weak)) void
+__coverage_callback (gcov_type funcdef_no __attribute__ ((unused)),
+ int edge_no __attribute__ ((unused)))
+{
+ /* nothing */
+}
+
+struct gcov_fn_buffer
+{
+ struct gcov_fn_buffer *next;
+ unsigned fn_ix;
+ struct gcov_fn_info info;
+ /* note gcov_fn_info ends in a trailing array. */
+};
+
+struct gcov_summary_buffer
+{
+ struct gcov_summary_buffer *next;
+ struct gcov_summary summary;
+};
+
+/* Chain of per-object gcov structures. */
+extern struct gcov_info *__gcov_list;
+
+/* Set the head of gcov_list. */
+void
+set_gcov_list (struct gcov_info *head)
+{
+ __gcov_list = head;
+}
+
+/* Size of the longest file name. */
+/* We need to expose this static variable when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static
+#endif
+size_t gcov_max_filename = 0;
+
+/* Flag when the profile has already been dumped via __gcov_dump(). */
+static int gcov_dump_complete;
+
+/* A global function that get the vaule of gcov_dump_complete. */
+
+int
+get_gcov_dump_complete (void)
+{
+ return gcov_dump_complete;
+}
+
+/* A global functino that set the vaule of gcov_dump_complete. Will
+ be used in __gcov_dump() in libgcov-interface.c. */
+
+void
+set_gcov_dump_complete (void)
+{
+ gcov_dump_complete = 1;
+}
+
+/* A global functino that set the vaule of gcov_dump_complete. Will
+ be used in __gcov_reset() in libgcov-interface.c. */
+
+void
+reset_gcov_dump_complete (void)
+{
+ gcov_dump_complete = 0;
+}
+
+/* A utility function for outputing errors. */
+static int gcov_error (const char *, ...);
+
+static struct gcov_fn_buffer *
+free_fn_data (const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer,
+ unsigned limit)
+{
+ struct gcov_fn_buffer *next;
+ unsigned ix, n_ctr = 0;
+
+ if (!buffer)
+ return 0;
+ next = buffer->next;
+
+ for (ix = 0; ix != limit; ix++)
+ if (gi_ptr->merge[ix])
+ free (buffer->info.ctrs[n_ctr++].values);
+ free (buffer);
+ return next;
+}
+
+static struct gcov_fn_buffer **
+buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr,
+ struct gcov_fn_buffer **end_ptr, unsigned fn_ix)
+{
+ unsigned n_ctrs = 0, ix = 0;
+ struct gcov_fn_buffer *fn_buffer;
+ unsigned len;
+
+ for (ix = GCOV_COUNTERS; ix--;)
+ if (gi_ptr->merge[ix])
+ n_ctrs++;
+
+ len = sizeof (*fn_buffer) + sizeof (fn_buffer->info.ctrs[0]) * n_ctrs;
+ fn_buffer = (struct gcov_fn_buffer *) xmalloc (len);
+
+ if (!fn_buffer)
+ goto fail;
+
+ fn_buffer->next = 0;
+ fn_buffer->fn_ix = fn_ix;
+ fn_buffer->info.ident = gcov_read_unsigned ();
+ fn_buffer->info.lineno_checksum = gcov_read_unsigned ();
+ fn_buffer->info.cfg_checksum = gcov_read_unsigned ();
+
+ for (n_ctrs = ix = 0; ix != GCOV_COUNTERS; ix++)
+ {
+ gcov_unsigned_t length;
+ gcov_type *values;
+
+ if (!gi_ptr->merge[ix])
+ continue;
+
+ if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix))
+ {
+ len = 0;
+ goto fail;
+ }
+
+ length = GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ());
+ len = length * sizeof (gcov_type);
+ values = (gcov_type *) xmalloc (len);
+ if (!values)
+ goto fail;
+
+ fn_buffer->info.ctrs[n_ctrs].num = length;
+ fn_buffer->info.ctrs[n_ctrs].values = values;
+
+ while (length--)
+ *values++ = gcov_read_counter ();
+ n_ctrs++;
+ }
+
+ *end_ptr = fn_buffer;
+ return &fn_buffer->next;
+
+fail:
+ gcov_error ("profiling:%s:Function %u %s %u \n", filename, fn_ix,
+ len ? "cannot allocate" : "counter mismatch", len ? len : ix);
+
+ return (struct gcov_fn_buffer **)free_fn_data (gi_ptr, fn_buffer, ix);
+}
+
+/* Determine whether a counter is active. */
+
+static inline int
+gcov_counter_active (const struct gcov_info *info, unsigned int type)
+{
+ return (info->merge[type] != 0);
+}
+
+/* Add an unsigned value to the current crc */
+
+static gcov_unsigned_t
+crc32_unsigned (gcov_unsigned_t crc32, gcov_unsigned_t value)
+{
+ unsigned ix;
+
+ for (ix = 32; ix--; value <<= 1)
+ {
+ unsigned feedback;
+
+ feedback = (value ^ crc32) & 0x80000000 ? 0x04c11db7 : 0;
+ crc32 <<= 1;
+ crc32 ^= feedback;
+ }
+
+ return crc32;
+}
+
+/* Check if VERSION of the info block PTR matches libgcov one.
+ Return 1 on success, or zero in case of versions mismatch.
+ If FILENAME is not NULL, its value used for reporting purposes
+ instead of value from the info block. */
+
+static int
+gcov_version (struct gcov_info *ptr, gcov_unsigned_t version,
+ const char *filename)
+{
+ if (version != GCOV_VERSION)
+ {
+ char v[4], e[4];
+
+ GCOV_UNSIGNED2STRING (v, version);
+ GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
+
+ if (filename)
+ gcov_error ("profiling:%s:Version mismatch - expected %.4s got %.4s\n",
+ filename? filename : ptr->filename, e, v);
+ else
+ gcov_error ("profiling:Version mismatch - expected %.4s got %.4s\n", e, v);
+
+ return 0;
+ }
+ return 1;
+}
+
+/* Insert counter VALUE into HISTOGRAM. */
+
+static void
+gcov_histogram_insert(gcov_bucket_type *histogram, gcov_type value)
+{
+ unsigned i;
+
+ i = gcov_histo_index(value);
+ histogram[i].num_counters++;
+ histogram[i].cum_value += value;
+ if (value < histogram[i].min_value)
+ histogram[i].min_value = value;
+}
+
+/* Computes a histogram of the arc counters to place in the summary SUM. */
+
+static void
+gcov_compute_histogram (struct gcov_summary *sum)
+{
+ struct gcov_info *gi_ptr;
+ const struct gcov_fn_info *gfi_ptr;
+ const struct gcov_ctr_info *ci_ptr;
+ struct gcov_ctr_summary *cs_ptr;
+ unsigned t_ix, f_ix, ctr_info_ix, ix;
+ int h_ix;
+
+ /* This currently only applies to arc counters. */
+ t_ix = GCOV_COUNTER_ARCS;
+
+ /* First check if there are any counts recorded for this counter. */
+ cs_ptr = &(sum->ctrs[t_ix]);
+ if (!cs_ptr->num)
+ return;
+
+ for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
+ {
+ cs_ptr->histogram[h_ix].num_counters = 0;
+ cs_ptr->histogram[h_ix].min_value = cs_ptr->run_max;
+ cs_ptr->histogram[h_ix].cum_value = 0;
+ }
+
+ /* Walk through all the per-object structures and record each of
+ the count values in histogram. */
+ for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
+ {
+ if (!gi_ptr->merge[t_ix])
+ continue;
+
+ /* Find the appropriate index into the gcov_ctr_info array
+ for the counter we are currently working on based on the
+ existence of the merge function pointer for this object. */
+ for (ix = 0, ctr_info_ix = 0; ix < t_ix; ix++)
+ {
+ if (gi_ptr->merge[ix])
+ ctr_info_ix++;
+ }
+ for (f_ix = 0; f_ix != gi_ptr->n_functions; f_ix++)
+ {
+ gfi_ptr = gi_ptr->functions[f_ix];
+
+ if (!gfi_ptr || gfi_ptr->key != gi_ptr)
+ continue;
+
+ ci_ptr = &gfi_ptr->ctrs[ctr_info_ix];
+ for (ix = 0; ix < ci_ptr->num; ix++)
+ gcov_histogram_insert (cs_ptr->histogram, ci_ptr->values[ix]);
+ }
+ }
+}
+
+/* gcda filename. */
+static char *gi_filename;
+/* buffer for the fn_data from another program. */
+static struct gcov_fn_buffer *fn_buffer;
+/* buffer for summary from other programs to be written out. */
+static struct gcov_summary_buffer *sum_buffer;
+/* If application calls fork or exec multiple times, we end up storing
+ profile repeadely. We should not account this as multiple runs or
+ functions executed once may mistakely become cold. */
+static int run_accounted = 0;
+
+/* This funtions computes the program level summary and the histo-gram.
+ It computes and returns CRC32 and stored summary in THIS_PRG. */
+
+static gcov_unsigned_t
+gcov_exit_compute_summary (struct gcov_summary *this_prg)
+{
+ struct gcov_info *gi_ptr;
+ const struct gcov_fn_info *gfi_ptr;
+ struct gcov_ctr_summary *cs_ptr;
+ const struct gcov_ctr_info *ci_ptr;
+ int f_ix;
+ unsigned t_ix;
+ gcov_unsigned_t c_num;
+ gcov_unsigned_t crc32 = 0;
+
+ /* Find the totals for this execution. */
+ memset (this_prg, 0, sizeof (*this_prg));
+ for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
+ {
+ crc32 = crc32_unsigned (crc32, gi_ptr->stamp);
+ crc32 = crc32_unsigned (crc32, gi_ptr->n_functions);
+
+ for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)
+ {
+ gfi_ptr = gi_ptr->functions[f_ix];
+
+ if (gfi_ptr && gfi_ptr->key != gi_ptr)
+ gfi_ptr = 0;
+
+ crc32 = crc32_unsigned (crc32, gfi_ptr ? gfi_ptr->cfg_checksum : 0);
+ crc32 = crc32_unsigned (crc32,
+ gfi_ptr ? gfi_ptr->lineno_checksum : 0);
+ if (!gfi_ptr)
+ continue;
+
+ ci_ptr = gfi_ptr->ctrs;
+ for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)
+ {
+ if (!gi_ptr->merge[t_ix])
+ continue;
+
+ cs_ptr = &(this_prg->ctrs[t_ix]);
+ cs_ptr->num += ci_ptr->num;
+ crc32 = crc32_unsigned (crc32, ci_ptr->num);
+
+ for (c_num = 0; c_num < ci_ptr->num; c_num++)
+ {
+ cs_ptr->sum_all += ci_ptr->values[c_num];
+ if (cs_ptr->run_max < ci_ptr->values[c_num])
+ cs_ptr->run_max = ci_ptr->values[c_num];
+ }
+ ci_ptr++;
+ }
+ }
+ }
+ gcov_compute_histogram (this_prg);
+ return crc32;
+}
+
+/* A struct that bundles all the related information about the
+ gcda filename. */
+struct gcov_filename_aux{
+ char *gi_filename_up;
+ int gcov_prefix_strip;
+ size_t prefix_length;
+};
+
+/* Including system dependent components. */
+#include "libgcov-driver-system.c"
+
+/* Scan through the current open gcda file corresponding to GI_PTR
+ to locate the end position of the last summary, returned in
+ SUMMARY_END_POS_P. Return 0 on success, -1 on error. */
+static int
+gcov_scan_summary_end (struct gcov_info *gi_ptr,
+ gcov_position_t *summary_end_pos_p)
+{
+ gcov_unsigned_t tag, version, stamp;
+ tag = gcov_read_unsigned ();
+ if (tag != GCOV_DATA_MAGIC)
+ {
+ gcov_error ("profiling:%s:Not a gcov data file\n", gi_filename);
+ return -1;
+ }
+
+ version = gcov_read_unsigned ();
+ if (!gcov_version (gi_ptr, version, gi_filename))
+ return -1;
+
+ stamp = gcov_read_unsigned ();
+ if (stamp != gi_ptr->stamp)
+ /* Read from a different compilation. Overwrite the file. */
+ return -1;
+
+ /* Look for program summary. */
+ while (1)
+ {
+ struct gcov_summary tmp;
+
+ *summary_end_pos_p = gcov_position ();
+ tag = gcov_read_unsigned ();
+ if (tag != GCOV_TAG_PROGRAM_SUMMARY)
+ break;
+
+ gcov_read_unsigned ();
+ gcov_read_summary (&tmp);
+ if (gcov_is_error ())
+ return -1;
+ }
+
+ return 0;
+}
+
+/* This function merges counters in GI_PTR to an existing gcda file.
+ Return 0 on success.
+ Return -1 on error. In this case, caller will goto read_fatal. */
+
+static int
+gcov_exit_merge_gcda (struct gcov_info *gi_ptr,
+ struct gcov_summary *prg_p,
+ struct gcov_summary *this_prg,
+ gcov_position_t *summary_pos_p,
+ gcov_position_t *eof_pos_p,
+ gcov_unsigned_t crc32)
+{
+ gcov_unsigned_t tag, length;
+ unsigned t_ix;
+ int f_ix;
+ int error = 0;
+ struct gcov_fn_buffer **fn_tail = &fn_buffer;
+ struct gcov_summary_buffer **sum_tail = &sum_buffer;
+
+ length = gcov_read_unsigned ();
+ if (!gcov_version (gi_ptr, length, gi_filename))
+ return -1;
+
+ length = gcov_read_unsigned ();
+ if (length != gi_ptr->stamp)
+ /* Read from a different compilation. Overwrite the file. */
+ return 0;
+
+ /* Look for program summary. */
+ for (f_ix = 0;;)
+ {
+ struct gcov_summary tmp;
+
+ *eof_pos_p = gcov_position ();
+ tag = gcov_read_unsigned ();
+ if (tag != GCOV_TAG_PROGRAM_SUMMARY)
+ break;
+
+ f_ix--;
+ length = gcov_read_unsigned ();
+ gcov_read_summary (&tmp);
+ if ((error = gcov_is_error ()))
+ goto read_error;
+ if (*summary_pos_p)
+ {
+ /* Save all summaries after the one that will be
+ merged into below. These will need to be rewritten
+ as histogram merging may change the number of non-zero
+ histogram entries that will be emitted, and thus the
+ size of the merged summary. */
+ (*sum_tail) = (struct gcov_summary_buffer *)
+ xmalloc (sizeof(struct gcov_summary_buffer));
+ (*sum_tail)->summary = tmp;
+ (*sum_tail)->next = 0;
+ sum_tail = &((*sum_tail)->next);
+ goto next_summary;
+ }
+ if (tmp.checksum != crc32)
+ goto next_summary;
+
+ for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)
+ if (tmp.ctrs[t_ix].num != this_prg->ctrs[t_ix].num)
+ goto next_summary;
+ *prg_p = tmp;
+ *summary_pos_p = *eof_pos_p;
+
+ next_summary:;
+ }
+
+ /* Merge execution counts for each function. */
+ for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions;
+ f_ix++, tag = gcov_read_unsigned ())
+ {
+ const struct gcov_ctr_info *ci_ptr;
+ const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
+
+ if (tag != GCOV_TAG_FUNCTION)
+ goto read_mismatch;
+
+ length = gcov_read_unsigned ();
+ if (!length)
+ /* This function did not appear in the other program.
+ We have nothing to merge. */
+ continue;
+
+ if (length != GCOV_TAG_FUNCTION_LENGTH)
+ goto read_mismatch;
+
+ if (!gfi_ptr || gfi_ptr->key != gi_ptr)
+ {
+ /* This function appears in the other program. We
+ need to buffer the information in order to write
+ it back out -- we'll be inserting data before
+ this point, so cannot simply keep the data in the
+ file. */
+ fn_tail = buffer_fn_data (gi_filename,
+ gi_ptr, fn_tail, f_ix);
+ if (!fn_tail)
+ goto read_mismatch;
+ continue;
+ }
+
+ length = gcov_read_unsigned ();
+ if (length != gfi_ptr->ident)
+ goto read_mismatch;
+
+ length = gcov_read_unsigned ();
+ if (length != gfi_ptr->lineno_checksum)
+ goto read_mismatch;
+
+ length = gcov_read_unsigned ();
+ if (length != gfi_ptr->cfg_checksum)
+ goto read_mismatch;
+
+ ci_ptr = gfi_ptr->ctrs;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
+ {
+ gcov_merge_fn merge = gi_ptr->merge[t_ix];
+
+ if (!merge)
+ continue;
+
+ tag = gcov_read_unsigned ();
+ length = gcov_read_unsigned ();
+ if (tag != GCOV_TAG_FOR_COUNTER (t_ix)
+ || length != GCOV_TAG_COUNTER_LENGTH (ci_ptr->num))
+ goto read_mismatch;
+ (*merge) (ci_ptr->values, ci_ptr->num);
+ ci_ptr++;
+ }
+ if ((error = gcov_is_error ()))
+ goto read_error;
+ }
+
+ if (tag && tag != GCOV_TAG_MODULE_INFO)
+ {
+ read_mismatch:;
+ gcov_error ("profiling:%s:Merge mismatch for %s %u\n",
+ gi_filename, f_ix >= 0 ? "function" : "summary",
+ f_ix < 0 ? -1 - f_ix : f_ix);
+ return -1;
+ }
+ return 0;
+
+read_error:
+ gcov_error ("profiling:%s:%s merging\n", gi_filename,
+ error < 0 ? "Overflow": "Error");
+ return -1;
+}
+
+/* Write counters in GI_PTR to a gcda file starting from its current
+ location. */
+
+static void
+gcov_write_func_counters (struct gcov_info *gi_ptr)
+{
+ unsigned f_ix;
+
+ /* Write execution counts for each function. */
+ for (f_ix = 0; f_ix != gi_ptr->n_functions; f_ix++)
+ {
+ unsigned buffered = 0;
+ const struct gcov_fn_info *gfi_ptr;
+ const struct gcov_ctr_info *ci_ptr;
+ gcov_unsigned_t length;
+ unsigned t_ix;
+
+ if (fn_buffer && fn_buffer->fn_ix == f_ix)
+ {
+ /* Buffered data from another program. */
+ buffered = 1;
+ gfi_ptr = &fn_buffer->info;
+ length = GCOV_TAG_FUNCTION_LENGTH;
+ }
+ else
+ {
+ gfi_ptr = gi_ptr->functions[f_ix];
+ if (gfi_ptr && gfi_ptr->key == gi_ptr)
+ length = GCOV_TAG_FUNCTION_LENGTH;
+ else
+ length = 0;
+ }
+
+ gcov_write_tag_length (GCOV_TAG_FUNCTION, length);
+ if (!length)
+ continue;
+
+ gcov_write_unsigned (gfi_ptr->ident);
+ gcov_write_unsigned (gfi_ptr->lineno_checksum);
+ gcov_write_unsigned (gfi_ptr->cfg_checksum);
+
+ ci_ptr = gfi_ptr->ctrs;
+ for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
+ {
+ gcov_unsigned_t n_counts;
+ gcov_type *c_ptr;
+
+ if (!gi_ptr->merge[t_ix])
+ continue;
+
+ n_counts = ci_ptr->num;
+ gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
+ GCOV_TAG_COUNTER_LENGTH (n_counts));
+ c_ptr = ci_ptr->values;
+ while (n_counts--)
+ gcov_write_counter (*c_ptr++);
+ ci_ptr++;
+ }
+ if (buffered)
+ fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);
+ }
+
+ gi_ptr->eof_pos = gcov_position ();
+ gcov_write_unsigned (0);
+}
+
+/* Write counters in GI_PTR and the summary in PRG to a gcda file. In
+ the case of appending to an existing file, SUMMARY_POS will be non-zero.
+ We will write the file starting from SUMMAY_POS. */
+
+static void
+gcov_exit_write_gcda (struct gcov_info *gi_ptr,
+ const struct gcov_summary *prg_p,
+ const gcov_position_t eof_pos,
+ const gcov_position_t summary_pos)
+
+{
+ struct gcov_summary_buffer *next_sum_buffer;
+
+ /* Write out the data. */
+ if (!eof_pos)
+ {
+ gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION);
+ gcov_write_unsigned (gi_ptr->stamp);
+ }
+
+ if (summary_pos)
+ gcov_seek (summary_pos);
+ gcc_assert (!summary_pos || summary_pos == gcov_position ());
+
+ /* Generate whole program statistics. */
+ gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, prg_p);
+
+ /* Rewrite all the summaries that were after the summary we merged
+ into. This is necessary as the merged summary may have a different
+ size due to the number of non-zero histogram entries changing after
+ merging. */
+
+ while (sum_buffer)
+ {
+ gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &sum_buffer->summary);
+ next_sum_buffer = sum_buffer->next;
+ free (sum_buffer);
+ sum_buffer = next_sum_buffer;
+ }
+
+ /* Write the counters. */
+ gcov_write_func_counters (gi_ptr);
+}
+
+/* Helper function for merging summary.
+ Return -1 on error. Return 0 on success. */
+
+static int
+gcov_exit_merge_summary (const struct gcov_info *gi_ptr, struct gcov_summary *prg,
+ struct gcov_summary *this_prg, gcov_unsigned_t crc32,
+ struct gcov_summary *all_prg __attribute__ ((unused)))
+{
+ struct gcov_ctr_summary *cs_prg, *cs_tprg;
+ unsigned t_ix;
+#if !GCOV_LOCKED
+ /* summary for all instances of program. */
+ struct gcov_ctr_summary *cs_all;
+#endif
+
+ /* Merge the summaries. */
+ for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)
+ {
+ cs_prg = &(prg->ctrs[t_ix]);
+ cs_tprg = &(this_prg->ctrs[t_ix]);
+
+ if (gi_ptr->merge[t_ix])
+ {
+ int first = !cs_prg->runs;
+
+ if (!run_accounted)
+ cs_prg->runs++;
+ if (first)
+ cs_prg->num = cs_tprg->num;
+ cs_prg->sum_all += cs_tprg->sum_all;
+ if (cs_prg->run_max < cs_tprg->run_max)
+ cs_prg->run_max = cs_tprg->run_max;
+ cs_prg->sum_max += cs_tprg->run_max;
+ if (first)
+ memcpy (cs_prg->histogram, cs_tprg->histogram,
+ sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+ else
+ gcov_histogram_merge (cs_prg->histogram, cs_tprg->histogram);
+ }
+ else if (cs_prg->runs)
+ {
+ gcov_error ("profiling:%s:Merge mismatch for summary.\n",
+ gi_filename);
+ return -1;
+ }
+#if !GCOV_LOCKED
+ cs_all = &all_prg->ctrs[t_ix];
+ if (!cs_all->runs && cs_prg->runs)
+ {
+ cs_all->num = cs_prg->num;
+ cs_all->runs = cs_prg->runs;
+ cs_all->sum_all = cs_prg->sum_all;
+ cs_all->run_max = cs_prg->run_max;
+ cs_all->sum_max = cs_prg->sum_max;
+ }
+ else if (!all_prg->checksum
+ /* Don't compare the histograms, which may have slight
+ variations depending on the order they were updated
+ due to the truncating integer divides used in the
+ merge. */
+ && (cs_all->num != cs_prg->num
+ || cs_all->runs != cs_prg->runs
+ || cs_all->sum_all != cs_prg->sum_all
+ || cs_all->run_max != cs_prg->run_max
+ || cs_all->sum_max != cs_prg->sum_max))
+ {
+ gcov_error ("profiling:%s:Data file mismatch - some "
+ "data files may have been concurrently "
+ "updated without locking support\n", gi_filename);
+ all_prg->checksum = ~0u;
+ }
+#endif
+ }
+
+ prg->checksum = crc32;
+
+ return 0;
+}
+
+/* Sort N entries in VALUE_ARRAY in descending order.
+ Each entry in VALUE_ARRAY has two values. The sorting
+ is based on the second value. */
+
+GCOV_LINKAGE void
+gcov_sort_n_vals (gcov_type *value_array, int n)
+{
+ int j, k;
+ for (j = 2; j < n; j += 2)
+ {
+ gcov_type cur_ent[2];
+ cur_ent[0] = value_array[j];
+ cur_ent[1] = value_array[j + 1];
+ k = j - 2;
+ while (k >= 0 && value_array[k + 1] < cur_ent[1])
+ {
+ value_array[k + 2] = value_array[k];
+ value_array[k + 3] = value_array[k+1];
+ k -= 2;
+ }
+ value_array[k + 2] = cur_ent[0];
+ value_array[k + 3] = cur_ent[1];
+ }
+}
+
+/* Sort the profile counters for all indirect call sites. Counters
+ for each call site are allocated in array COUNTERS. */
+
+static void
+gcov_sort_icall_topn_counter (const struct gcov_ctr_info *counters)
+{
+ int i;
+ gcov_type *values;
+ int n = counters->num;
+ gcc_assert (!(n % GCOV_ICALL_TOPN_NCOUNTS));
+
+ values = counters->values;
+
+ for (i = 0; i < n; i += GCOV_ICALL_TOPN_NCOUNTS)
+ {
+ gcov_type *value_array = &values[i + 1];
+ gcov_sort_n_vals (value_array, GCOV_ICALL_TOPN_NCOUNTS - 1);
+ }
+}
+
+static void
+gcov_sort_topn_counter_arrays (const struct gcov_info *gi_ptr)
+{
+ unsigned int i;
+ int f_ix;
+ const struct gcov_fn_info *gfi_ptr;
+ const struct gcov_ctr_info *ci_ptr;
+
+ for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)
+ {
+ gfi_ptr = gi_ptr->functions[f_ix];
+ ci_ptr = gfi_ptr->ctrs;
+ for (i = 0; i < GCOV_COUNTERS; i++)
+ {
+ if (!gcov_counter_active (gi_ptr, i))
+ continue;
+ if (i == GCOV_COUNTER_ICALL_TOPNV)
+ {
+ gcov_sort_icall_topn_counter (ci_ptr);
+ break;
+ }
+ ci_ptr++;
+ }
+ }
+}
+
+/* Dump the coverage counts for one gcov_info object. We merge with existing
+ counts when possible, to avoid growing the .da files ad infinitum. We use
+ this program's checksum to make sure we only accumulate whole program
+ statistics to the correct summary. An object file might be embedded
+ in two separate programs, and we must keep the two program
+ summaries separate. */
+
+static void
+gcov_exit_dump_gcov (struct gcov_info *gi_ptr, struct gcov_filename_aux *gf,
+ gcov_unsigned_t crc32, struct gcov_summary *all_prg,
+ struct gcov_summary *this_prg)
+{
+ struct gcov_summary prg; /* summary for this object over all program. */
+ int error;
+ gcov_unsigned_t tag;
+ gcov_position_t summary_pos = 0;
+ gcov_position_t eof_pos = 0;
+
+ fn_buffer = 0;
+ sum_buffer = 0;
+
+ gcov_sort_topn_counter_arrays (gi_ptr);
+
+ error = gcov_exit_open_gcda_file (gi_ptr, gf);
+ if (error == -1)
+ return;
+
+ tag = gcov_read_unsigned ();
+ if (tag)
+ {
+ /* Merge data from file. */
+ if (tag != GCOV_DATA_MAGIC)
+ {
+ gcov_error ("profiling:%s:Not a gcov data file\n", gi_filename);
+ goto read_fatal;
+ }
+ error = gcov_exit_merge_gcda (gi_ptr, &prg, this_prg, &summary_pos, &eof_pos,
+ crc32);
+ if (error == -1)
+ goto read_fatal;
+ }
+
+ gcov_rewrite ();
+
+ if (!summary_pos)
+ {
+ memset (&prg, 0, sizeof (prg));
+ summary_pos = eof_pos;
+ }
+
+ error = gcov_exit_merge_summary (gi_ptr, &prg, this_prg, crc32, all_prg);
+ if (error == -1)
+ goto read_fatal;
+
+ gcov_exit_write_gcda (gi_ptr, &prg, eof_pos, summary_pos);
+ /* fall through */
+
+read_fatal:;
+ while (fn_buffer)
+ fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);
+
+ if ((error = gcov_close ()))
+ gcov_error (error < 0 ?
+ "profiling:%s:Overflow writing\n" :
+ "profiling:%s:Error writing\n",
+ gi_filename);
+}
+
+/* Write imported files (auxiliary modules) for primary module GI_PTR
+ into file GI_FILENAME. */
+
+static void
+gcov_write_import_file (char *gi_filename, struct gcov_info *gi_ptr)
+{
+ char *gi_imports_filename;
+ const char *gcov_suffix;
+ FILE *imports_file;
+ size_t prefix_length, suffix_length;
+
+ gcov_suffix = getenv ("GCOV_IMPORTS_SUFFIX");
+ if (!gcov_suffix || !strlen (gcov_suffix))
+ gcov_suffix = ".imports";
+ suffix_length = strlen (gcov_suffix);
+ prefix_length = strlen (gi_filename);
+ gi_imports_filename = (char *) alloca (prefix_length + suffix_length + 1);
+ memset (gi_imports_filename, 0, prefix_length + suffix_length + 1);
+ memcpy (gi_imports_filename, gi_filename, prefix_length);
+ memcpy (gi_imports_filename + prefix_length, gcov_suffix, suffix_length);
+ imports_file = fopen (gi_imports_filename, "w");
+ if (imports_file)
+ {
+ const struct dyn_imp_mod **imp_mods;
+ unsigned i, imp_len;
+ imp_mods = gcov_get_sorted_import_module_array (gi_ptr, &imp_len);
+ if (imp_mods)
+ {
+ for (i = 0; i < imp_len; i++)
+ {
+ fprintf (imports_file, "%s\n",
+ imp_mods[i]->imp_mod->mod_info->source_filename);
+ fprintf (imports_file, "%s%s\n",
+ imp_mods[i]->imp_mod->mod_info->da_filename, GCOV_DATA_SUFFIX);
+ }
+ free (imp_mods);
+ }
+ fclose (imports_file);
+ }
+}
+
+static void
+gcov_dump_module_info (struct gcov_filename_aux *gf)
+{
+ struct gcov_info *gi_ptr;
+
+ /* Compute the module groups and record whether there were any
+ counter fixups applied that require rewriting the counters. */
+ int changed = __gcov_compute_module_groups ();
+
+ /* Now write out module group info. */
+ for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
+ {
+ int error;
+
+ if (gcov_exit_open_gcda_file (gi_ptr, gf) == -1)
+ continue;
+
+ if (changed)
+ {
+ /* Scan file to find the end of the summary section, which is
+ where we will start re-writing the counters. */
+ gcov_position_t summary_end_pos;
+ if (gcov_scan_summary_end (gi_ptr, &summary_end_pos) == -1)
+ gcov_error ("profiling:%s:Error scanning summaries\n",
+ gi_filename);
+ else
+ {
+ gcov_position_t eof_pos = gi_ptr->eof_pos;
+ gcov_rewrite ();
+ gcov_seek (summary_end_pos);
+ gcov_write_func_counters (gi_ptr);
+ gcc_assert (eof_pos == gi_ptr->eof_pos);
+ }
+ }
+ else
+ gcov_rewrite ();
+
+ /* Overwrite the zero word at the of the file. */
+ gcov_seek (gi_ptr->eof_pos);
+
+ gcov_write_module_infos (gi_ptr);
+ /* Write the end marker */
+ gcov_write_unsigned (0);
+ gcov_truncate ();
+
+ if ((error = gcov_close ()))
+ gcov_error (error < 0 ? "profiling:%s:Overflow writing\n" :
+ "profiling:%s:Error writing\n",
+ gi_filename);
+ gcov_write_import_file (gi_filename, gi_ptr);
+ }
+ __gcov_finalize_dyn_callgraph ();
+}
+
+/* Dump all the coverage counts for the program. It first computes program
+ summary and then traverses gcov_list list and dumps the gcov_info
+ objects one by one. */
+
+void
+gcov_exit (void)
+{
+ struct gcov_info *gi_ptr;
+ struct gcov_filename_aux gf;
+ gcov_unsigned_t crc32;
+ int dump_module_info = 0;
+ struct gcov_summary all_prg;
+ struct gcov_summary this_prg;
+
+ /* Prevent the counters from being dumped a second time on exit when the
+ application already wrote out the profile using __gcov_dump(). */
+ if (gcov_dump_complete)
+ return;
+
+ crc32 = gcov_exit_compute_summary (&this_prg);
+
+ allocate_filename_struct (&gf);
+#if !GCOV_LOCKED
+ memset (&all_prg, 0, sizeof (all_prg));
+#endif
+
+ /* Now merge each file. */
+ for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
+ {
+ gcov_exit_dump_gcov (gi_ptr, &gf, crc32, &all_prg, &this_prg);
+
+ /* The IS_PRIMARY field is overloaded to indicate if this module
+ is FDO/LIPO. */
+ dump_module_info |= gi_ptr->mod_info->is_primary;
+ }
+ run_accounted = 1;
+
+ if (dump_module_info)
+ gcov_dump_module_info (&gf);
+
+ if (gi_filename)
+ free (gi_filename);
+}
+
+/* Reset all counters to zero. */
+
+void
+gcov_clear (void)
+{
+ const struct gcov_info *gi_ptr;
+
+ for (gi_ptr = __gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
+ {
+ unsigned f_ix;
+
+ for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
+ {
+ unsigned t_ix;
+ const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
+
+ if (!gfi_ptr || gfi_ptr->key != gi_ptr)
+ continue;
+ const struct gcov_ctr_info *ci_ptr = gfi_ptr->ctrs;
+ for (t_ix = 0; t_ix != GCOV_COUNTERS; t_ix++)
+ {
+ if (!gi_ptr->merge[t_ix])
+ continue;
+
+ memset (ci_ptr->values, 0, sizeof (gcov_type) * ci_ptr->num);
+ ci_ptr++;
+ }
+ }
+ }
+}
+
+/* Add a new object file onto the bb chain. Invoked automatically
+ when running an object file's global ctors. */
+
+void
+__gcov_init (struct gcov_info *info)
+{
+#ifndef IN_GCOV_TOOL
+ if (!gcov_sampling_period_initialized)
+ {
+ const char* env_value_str = getenv ("GCOV_SAMPLING_PERIOD");
+ if (env_value_str)
+ {
+ int env_value_int = atoi(env_value_str);
+ if (env_value_int >= 1)
+ __gcov_sampling_period = env_value_int;
+ }
+ gcov_sampling_period_initialized = 1;
+ }
+#endif
+
+ if (!info->version || !info->n_functions)
+ return;
+ if (gcov_version (info, info->version, 0))
+ {
+ size_t filename_length = strlen(info->filename);
+
+ /* Refresh the longest file name information */
+ if (filename_length > gcov_max_filename)
+ gcov_max_filename = filename_length;
+
+ /* Assign the module ID (starting at 1). */
+ info->mod_info->ident = (++gcov_cur_module_id);
+ gcc_assert (EXTRACT_MODULE_ID_FROM_GLOBAL_ID (GEN_FUNC_GLOBAL_ID (
+ info->mod_info->ident, 0))
+ == info->mod_info->ident);
+
+ if (!__gcov_list)
+ atexit (gcov_exit);
+
+ info->next = __gcov_list;
+ __gcov_list = info;
+ }
+ info->version = 0;
+}
+
+#endif /* L_gcov */
+#endif /* inhibit_libc */
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
deleted file mode 100644
index 5f82a94..0000000
--- a/lib/gcc/mips64el-linux-android/4.9/include-fixed/linux/a.out.h
+++ /dev/null
@@ -1,235 +0,0 @@
-/* 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/libgcc.a b/lib/gcc/mips64el-linux-android/4.9/libgcc.a
index 66c9d95..b1a371d 100644
--- a/lib/gcc/mips64el-linux-android/4.9/libgcc.a
+++ b/lib/gcc/mips64el-linux-android/4.9/libgcc.a
Binary files differ
diff --git a/lib/gcc/mips64el-linux-android/4.9/libgcov.a b/lib/gcc/mips64el-linux-android/4.9/libgcov.a
index ad35edd..9addfd1 100644
--- a/lib/gcc/mips64el-linux-android/4.9/libgcov.a
+++ b/lib/gcc/mips64el-linux-android/4.9/libgcov.a
Binary files differ
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
index cab47b3..8046ada 100644
--- 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 differ
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
index 202c106..8733de2 100644
--- 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 differ
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
index cab47b3..8046ada 100644
--- 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 differ
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
index 8949a37..e0474f4 100644
--- 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 differ
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
index 8949a37..e0474f4 100644
--- 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 differ
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
index b060b5e..c3f3091 100644
--- 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 differ
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
index e506a40..654e3e6 100644
--- 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 differ
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
index 0f46d2c..248ab1b 100644
--- 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 differ
diff --git a/lib/libmips64el-unknown-linux-android-sim.a b/lib/libmips64el-unknown-linux-android-sim.a
index 9fbd1c5..0bbf706 100644
--- a/lib/libmips64el-unknown-linux-android-sim.a
+++ b/lib/libmips64el-unknown-linux-android-sim.a
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/cc1 b/libexec/gcc/mips64el-linux-android/4.9/cc1
index 5bb7669..4e6f32e 100755
--- a/libexec/gcc/mips64el-linux-android/4.9/cc1
+++ b/libexec/gcc/mips64el-linux-android/4.9/cc1
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/cc1plus b/libexec/gcc/mips64el-linux-android/4.9/cc1plus
index 5a29174..5ac9e62 100755
--- a/libexec/gcc/mips64el-linux-android/4.9/cc1plus
+++ b/libexec/gcc/mips64el-linux-android/4.9/cc1plus
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/collect2 b/libexec/gcc/mips64el-linux-android/4.9/collect2
index d8217d5..e290529 100755
--- a/libexec/gcc/mips64el-linux-android/4.9/collect2
+++ b/libexec/gcc/mips64el-linux-android/4.9/collect2
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/libfunction_reordering_plugin.0.so b/libexec/gcc/mips64el-linux-android/4.9/libfunction_reordering_plugin.0.so
new file mode 100755
index 0000000..5f6b362
--- /dev/null
+++ b/libexec/gcc/mips64el-linux-android/4.9/libfunction_reordering_plugin.0.so
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/libfunction_reordering_plugin.so b/libexec/gcc/mips64el-linux-android/4.9/libfunction_reordering_plugin.so
new file mode 120000
index 0000000..14c0289
--- /dev/null
+++ b/libexec/gcc/mips64el-linux-android/4.9/libfunction_reordering_plugin.so
@@ -0,0 +1 @@
+libfunction_reordering_plugin.0.so
\ No newline at end of file
diff --git a/libexec/gcc/mips64el-linux-android/4.9/lto-wrapper b/libexec/gcc/mips64el-linux-android/4.9/lto-wrapper
index e369f5c..4a60867 100755
--- a/libexec/gcc/mips64el-linux-android/4.9/lto-wrapper
+++ b/libexec/gcc/mips64el-linux-android/4.9/lto-wrapper
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/lto1 b/libexec/gcc/mips64el-linux-android/4.9/lto1
index 7825d89..21b0a31 100755
--- a/libexec/gcc/mips64el-linux-android/4.9/lto1
+++ b/libexec/gcc/mips64el-linux-android/4.9/lto1
Binary files differ
diff --git a/libexec/gcc/mips64el-linux-android/4.9/plugin/gengtype b/libexec/gcc/mips64el-linux-android/4.9/plugin/gengtype
index 813b209..be0041d 100755
--- a/libexec/gcc/mips64el-linux-android/4.9/plugin/gengtype
+++ b/libexec/gcc/mips64el-linux-android/4.9/plugin/gengtype
Binary files differ
diff --git a/mips64el-linux-android/lib/ldscripts/elf32btsmip.xr b/mips64el-linux-android/lib/ldscripts/elf32btsmip.xr
index ae675ed..b4412e8 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32btsmip.xr
+++ b/mips64el-linux-android/lib/ldscripts/elf32btsmip.xr
@@ -113,7 +113,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32btsmip.xu b/mips64el-linux-android/lib/ldscripts/elf32btsmip.xu
index 52dcd79..551aead 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32btsmip.xu
+++ b/mips64el-linux-android/lib/ldscripts/elf32btsmip.xu
@@ -113,7 +113,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xr b/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xr
index 210b848..6bdcdb0 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xr
+++ b/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xr
@@ -113,7 +113,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xu b/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xu
index bf8f2ad..dc7f552 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xu
+++ b/mips64el-linux-android/lib/ldscripts/elf32btsmipn32.xu
@@ -113,7 +113,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xr b/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xr
index 03b225c..c84002f 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xr
+++ b/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xr
@@ -112,7 +112,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xu b/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xu
index 6d7c426..8faedf8 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xu
+++ b/mips64el-linux-android/lib/ldscripts/elf32ltsmip.xu
@@ -112,7 +112,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xr b/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xr
index 38b7b0e..47b5a5a 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xr
+++ b/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xr
@@ -113,7 +113,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xu b/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xu
index fdc9fc3..3092702 100644
--- a/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xu
+++ b/mips64el-linux-android/lib/ldscripts/elf32ltsmipn32.xu
@@ -113,7 +113,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.x b/mips64el-linux-android/lib/ldscripts/elf64btsmip.x
index 8d7d75c..9d6b7fe 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.x
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.x
@@ -125,7 +125,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xbn b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xbn
index 7bb664e..b790121 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xbn
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xbn
@@ -124,7 +124,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xc b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xc
index 51db00f..dbca2da 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xc
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xc
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xd b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xd
index 85c97eb..457f0f7 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xd
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xd
@@ -124,7 +124,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdc b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdc
index cdebc8b..93affa0 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdc
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdc
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdw b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdw
index c5a93f6..771cce6 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdw
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xdw
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xn b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xn
index c890fca..10f141d 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xn
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xn
@@ -124,7 +124,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xr b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xr
index d3cd14b..36a3af6 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xr
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xr
@@ -112,7 +112,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xs b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xs
index 926588a..e5575f7 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xs
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xs
@@ -115,7 +115,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
.preinit_array :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsc b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsc
index 380f25b..34c6af3 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsc
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsc
@@ -115,7 +115,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
.preinit_array :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsw b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsw
index 5b2f3c4..b730bc2 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsw
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xsw
@@ -114,7 +114,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
.preinit_array :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xu b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xu
index 9b0c967..d5e6a21 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xu
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xu
@@ -112,7 +112,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xw b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xw
index 362a683..046329b 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64btsmip.xw
+++ b/mips64el-linux-android/lib/ldscripts/elf64btsmip.xw
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.x b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.x
index 14991e4..00ae279 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.x
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.x
@@ -125,7 +125,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xbn b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xbn
index d943779..8c2aed9 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xbn
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xbn
@@ -124,7 +124,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xc b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xc
index ee693ab..413e311 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xc
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xc
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xd b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xd
index 003d77c..b16d799 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xd
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xd
@@ -124,7 +124,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdc b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdc
index 7402d13..8e52acd 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdc
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdc
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdw b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdw
index d5515b3..f525fc6 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdw
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xdw
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xn b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xn
index 9fb968e..3fa65e5 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xn
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xn
@@ -124,7 +124,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xr b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xr
index 245b06c..66560e2 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xr
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xr
@@ -112,7 +112,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xs b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xs
index 325230a..ecfe08a 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xs
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xs
@@ -115,7 +115,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
.preinit_array :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsc b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsc
index 03ca941..8d04ab9 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsc
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsc
@@ -115,7 +115,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
.preinit_array :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsw b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsw
index ca97721..783ad85 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsw
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xsw
@@ -114,7 +114,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
.preinit_array :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xu b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xu
index d2f4653..777d01c 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xu
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xu
@@ -112,7 +112,6 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
.preinit_array 0 :
{
KEEP (*(.preinit_array))
diff --git a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xw b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xw
index b5a3abf..ac9296b 100644
--- a/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xw
+++ b/mips64el-linux-android/lib/ldscripts/elf64ltsmip.xw
@@ -127,7 +127,7 @@
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
- . = ALIGN(32 / 8);
+ . = ALIGN(64 / 8);
PROVIDE_HIDDEN (__preinit_array_start = .);
.preinit_array :
{
diff --git a/mips64el-linux-android/lib/libatomic.a b/mips64el-linux-android/lib/libatomic.a
index 4fb96fc..3c59e15 100644
--- a/mips64el-linux-android/lib/libatomic.a
+++ b/mips64el-linux-android/lib/libatomic.a
Binary files differ
diff --git a/mips64el-linux-android/lib/libgomp.a b/mips64el-linux-android/lib/libgomp.a
index 679b3d9..d5f44fc 100644
--- a/mips64el-linux-android/lib/libgomp.a
+++ b/mips64el-linux-android/lib/libgomp.a
Binary files differ
diff --git a/mips64el-linux-android/lib64/libatomic.a b/mips64el-linux-android/lib64/libatomic.a
index e9002f5..67b9f64 100644
--- a/mips64el-linux-android/lib64/libatomic.a
+++ b/mips64el-linux-android/lib64/libatomic.a
Binary files differ
diff --git a/mips64el-linux-android/lib64/libgomp.a b/mips64el-linux-android/lib64/libgomp.a
index c8c47ce..387b0b4 100644
--- a/mips64el-linux-android/lib64/libgomp.a
+++ b/mips64el-linux-android/lib64/libgomp.a
Binary files differ
diff --git a/mips64el-linux-android/lib64r2/libatomic.a b/mips64el-linux-android/lib64r2/libatomic.a
index e9a8755..4583320 100644
--- a/mips64el-linux-android/lib64r2/libatomic.a
+++ b/mips64el-linux-android/lib64r2/libatomic.a
Binary files differ
diff --git a/mips64el-linux-android/lib64r2/libgomp.a b/mips64el-linux-android/lib64r2/libgomp.a
index 67b36eb..4c1e5be 100644
--- a/mips64el-linux-android/lib64r2/libgomp.a
+++ b/mips64el-linux-android/lib64r2/libgomp.a
Binary files differ
diff --git a/mips64el-linux-android/libr2/libatomic.a b/mips64el-linux-android/libr2/libatomic.a
index 411c452..b618144 100644
--- a/mips64el-linux-android/libr2/libatomic.a
+++ b/mips64el-linux-android/libr2/libatomic.a
Binary files differ
diff --git a/mips64el-linux-android/libr2/libgomp.a b/mips64el-linux-android/libr2/libgomp.a
index c1116c4..168e42d 100644
--- a/mips64el-linux-android/libr2/libgomp.a
+++ b/mips64el-linux-android/libr2/libgomp.a
Binary files differ
diff --git a/mips64el-linux-android/libr6/libatomic.a b/mips64el-linux-android/libr6/libatomic.a
index 194ed18..8ee178d 100644
--- a/mips64el-linux-android/libr6/libatomic.a
+++ b/mips64el-linux-android/libr6/libatomic.a
Binary files differ
diff --git a/mips64el-linux-android/libr6/libgomp.a b/mips64el-linux-android/libr6/libgomp.a
index 3c4e284..b253f33 100644
--- a/mips64el-linux-android/libr6/libgomp.a
+++ b/mips64el-linux-android/libr6/libgomp.a
Binary files differ
