Xen project Mailing List

Re: [LIBGCC/LIBGCOV PATCH 1/2] Port libgcov library

To: Alice Suiu <alicesuiu17@xxxxxxxxx>, minios-devel@xxxxxxxxxxxxx

From: Costin Lupu <costin.lupu@xxxxxxxxx>

Date: Fri, 22 May 2020 19:24:49 +0300

Delivery-date: Fri, 22 May 2020 16:25:36 +0000

List-id: Mini-os development list <minios-devel.lists.xenproject.org>

Hi Alice, Thanks for this work. Here are my comments: 1) First of all, this is a series and you should use a cover letter (--cover-leter parameter when running `git format-patch`) where you should say why you ported this. Some brief explanation should do. Please do that for your v2 series. 2) A patch should generally do just one thing. Please don't try to squeeze several things into one patch only. For example, this patch introduces the gcov port *and* updates the origin version. 3) Why do you copy all these generated headers? Can't you generate them at build time in the prepare step (e.g. `make prepare`) and use them from the origin? 4) What does "existing headers" mean? What's the difference between the "existing" headers and the "generated headers"? Why do we need both? Please add more information in your commit message about that. Please see my 2 other comments inline. On 5/21/20 10:18 PM, Alice Suiu wrote: > This port also adds generated headers which can be found in > include/config/ directory and existing headers which can be located in > include/ directory. > > Signed-off-by: Alice Suiu <alicesuiu17@xxxxxxxxx> > --- > Config.uk | 7 + > Makefile.uk | 20 +- > libgcov/include/ansidecl.h | 355 ++++ > libgcov/include/config/auto-host.h | 2419 ++++++++++++++++++++++++++ > libgcov/include/config/auto-target.h | 80 + > libgcov/include/config/gcov-iov.h | 4 + > libgcov/include/config/libgcc_tm.h | 6 + > libgcov/include/config/tconfig.h | 10 + > libgcov/include/config/tm.h | 52 + > libgcov/include/coretypes.h | 376 ++++ > libgcov/include/defaults.h | 1478 ++++++++++++++++ > libgcov/include/elf-lib.h | 36 + > libgcov/include/filenames.h | 99 ++ > libgcov/include/gcov-counter.def | 54 + > libgcov/include/gcov-io.c | 987 +++++++++++ > libgcov/include/gcov-io.h | 424 +++++ > libgcov/include/gcov.h | 41 + > libgcov/include/gthr-default.h | 889 ++++++++++ > libgcov/include/gthr.h | 154 ++ > libgcov/include/hashtab.h | 204 +++ > libgcov/include/libgcov.h | 346 ++++ > libgcov/include/tsystem.h | 137 ++ > libgcov/include/value-unwind.h | 25 + > 23 files changed, 8202 insertions(+), 1 deletion(-) > create mode 100644 libgcov/include/ansidecl.h > create mode 100644 libgcov/include/config/auto-host.h > create mode 100644 libgcov/include/config/auto-target.h > create mode 100644 libgcov/include/config/gcov-iov.h > create mode 100644 libgcov/include/config/libgcc_tm.h > create mode 100644 libgcov/include/config/tconfig.h > create mode 100644 libgcov/include/config/tm.h > create mode 100644 libgcov/include/coretypes.h > create mode 100644 libgcov/include/defaults.h > create mode 100644 libgcov/include/elf-lib.h > create mode 100644 libgcov/include/filenames.h > create mode 100644 libgcov/include/gcov-counter.def > create mode 100644 libgcov/include/gcov-io.c > create mode 100644 libgcov/include/gcov-io.h > create mode 100644 libgcov/include/gcov.h > create mode 100644 libgcov/include/gthr-default.h > create mode 100644 libgcov/include/gthr.h > create mode 100644 libgcov/include/hashtab.h > create mode 100644 libgcov/include/libgcov.h > create mode 100644 libgcov/include/tsystem.h > create mode 100644 libgcov/include/value-unwind.h > > diff --git a/Config.uk b/Config.uk > index 5aaca7c..89a84b0 100644 > --- a/Config.uk > +++ b/Config.uk > @@ -26,4 +26,11 @@ config LIBFFI > if LIBFFI > endif > > +config LIBGCOV > + bool "libgcov - A Profiling Library" > + default n > + select LIBPTHREAD_EMBEDDED > +if LIBGCOV > +endif > + > endif > diff --git a/Makefile.uk b/Makefile.uk > index d5901e2..fe56ad8 100644 > --- a/Makefile.uk > +++ b/Makefile.uk > @@ -42,11 +42,12 @@ > $(eval $(call addlib_s,libgcc,$(CONFIG_LIBGCC))) > $(eval $(call addlib_s,libbacktrace,$(CONFIG_LIBBACKTRACE))) > $(eval $(call addlib_s,libffi,$(CONFIG_LIBFFI))) > +$(eval $(call addlib_s,libgcov,$(CONFIG_LIBGCOV))) > > > ################################################################################ > # Original sources > > ################################################################################ > -LIBGCC_VERSION=7.3.0 > +LIBGCC_VERSION=7.5.0 As I said, this should come in a standalone patch. We would also need an explanation why you updated it. > > LIBGCC_URL=https://ftp.gnu.org/gnu/gcc/gcc-$(LIBGCC_VERSION)/gcc-$(LIBGCC_VERSION).tar.gz > LIBGCC_SUBDIR=gcc-$(LIBGCC_VERSION) > $(eval $(call fetch,libgcc,$(LIBGCC_URL))) > @@ -57,6 +58,7 @@ $(eval $(call fetch,libgcc,$(LIBGCC_URL))) > LIBGCC_EXTRACTED = $(LIBGCC_ORIGIN)/gcc-$(LIBGCC_VERSION) > LIBBACKTRACE_EXTRACTED = $(LIBGCC_EXTRACTED)/libbacktrace > LIBFFI_EXTRACTED = $(LIBGCC_EXTRACTED)/libffi > +LIBGCOV_EXTRACTED = $(LIBGCC_EXTRACTED)/libgcc > > > ################################################################################ > # Library includes > @@ -70,6 +72,9 @@ CXXINCLUDES-$(CONFIG_LIBBACKTRACE) += > -I$(LIBGCC_BASE)/libbacktrace/include > CINCLUDES-$(CONFIG_LIBFFI) += -I$(LIBGCC_BASE)/libffi/include > CXXINCLUDES-$(CONFIG_LIBFFI) += -I$(LIBGCC_BASE)/libffi/include > > +CINCLUDES-$(CONFIG_LIBGCOV) += -I$(LIBGCC_BASE)/libgcov/include > +CXXINCLUDES-$(CONFIG_LIBGCOV) += -I$(LIBGCC_BASE)/libgcov/include > + > > ################################################################################ > # libbacktrace code > > ################################################################################ > @@ -119,3 +124,16 @@ LIBFFI_SRCS-y += $(LIBFFI_EXTRACTED)/src/raw_api.c > LIBFFI_SRCS-$(CONFIG_ARCH_X86_64) += $(LIBFFI_EXTRACTED)/src/x86/ffi64.c > LIBFFI_SRCS-$(CONFIG_ARCH_X86_64) += $(LIBFFI_EXTRACTED)/src/x86/unix64.S > > +################################################################################ > +# libgcov code > +################################################################################ > +LIBGCOV_CINCLUDES-y = -I$(LIBGCC_BASE)/libgcov/include \ > + -I$(LIBGCC_BASE)/libgcov/include/config > + > +LIBGCOV_CFLAGS-y += -O2 -DIN_LIBGCC2 -fbuilding-libgcc -fno-stack-protector \ > + -DHAVE_CC_TLS You shouldn't add general flags here, so please get rid of '-O2'. This would be selected only if wanted via menuconfig. I saw in the next patch that you are adding more defines here. Is there any reason why you use a separated patch for that? > + > +LIBGCOV_SRCS-y += $(LIBGCOV_EXTRACTED)/libgcov-merge.c > +LIBGCOV_SRCS-y += $(LIBGCOV_EXTRACTED)/libgcov-profiler.c > +LIBGCOV_SRCS-y += $(LIBGCOV_EXTRACTED)/libgcov-interface.c > +LIBGCOV_SRCS-y += $(LIBGCOV_EXTRACTED)/libgcov-driver.c > diff --git a/libgcov/include/ansidecl.h b/libgcov/include/ansidecl.h > new file mode 100644 > index 0000000..25f33da > --- /dev/null > +++ b/libgcov/include/ansidecl.h > @@ -0,0 +1,355 @@ > +/* ANSI and traditional C compatability macros > + Copyright (C) 1991-2017 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > +This program 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 2 of the License, or > +(at your option) any later version. > + > +This program is distributed in the hope that it will be useful, > +but WITHOUT ANY WARRANTY; without even the implied warranty of > +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +GNU General Public License for more details. > + > +You should have received a copy of the GNU General Public License > +along with this program; if not, write to the Free Software > +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, > USA. */ > + > +/* ANSI and traditional C compatibility macros > + > + ANSI C is assumed if __STDC__ is #defined. > + > + Macro ANSI C definition Traditional C definition > + ----- ---- - ---------- ----------- - ---------- > + PTR `void *' `char *' > + const not defined `' > + volatile not defined `' > + signed not defined `' > + > + For ease of writing code which uses GCC extensions but needs to be > + portable to other compilers, we provide the GCC_VERSION macro that > + simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various > + wrappers around __attribute__. Also, __extension__ will be #defined > + to nothing if it doesn't work. See below. */ > + > +#ifndef _ANSIDECL_H > +#define _ANSIDECL_H 1 > + > +#ifdef __cplusplus > +extern "C" { > +#endif > + > +/* Every source file includes this file, > + so they will all get the switch for lint. */ > +/* LINTLIBRARY */ > + > +/* Using MACRO(x,y) in cpp #if conditionals does not work with some > + older preprocessors. Thus we can't define something like this: > + > +#define HAVE_GCC_VERSION(MAJOR, MINOR) \ > + (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR))) > + > +and then test "#if HAVE_GCC_VERSION(2,7)". > + > +So instead we use the macro below and test it against specific values. */ > + > +/* This macro simplifies testing whether we are using gcc, and if it > + is of a particular minimum version. (Both major & minor numbers are > + significant.) This macro will evaluate to 0 if we are not using > + gcc at all. */ > +#ifndef GCC_VERSION > +#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) > +#endif /* GCC_VERSION */ > + > +#if defined (__STDC__) || defined(__cplusplus) || defined (_AIX) || (defined > (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) > +/* All known AIX compilers implement these things (but don't always > + define __STDC__). The RISC/OS MIPS compiler defines these things > + in SVR4 mode, but does not define __STDC__. */ > +/* eraxxon@xxxxxxxxxxxxxxx: The Compaq C++ compiler, unlike many other > + C++ compilers, does not define __STDC__, though it acts as if this > + was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */ > + > +#define PTR void * > + > +#undef const > +#undef volatile > +#undef signed > + > +/* inline requires special treatment; it's in C99, and GCC >=2.7 supports > + it too, but it's not in C89. */ > +#undef inline > +#if __STDC_VERSION__ >= 199901L || defined(__cplusplus) || > (defined(__SUNPRO_C) && defined(__C99FEATURES__)) > +/* it's a keyword */ > +#else > +# if GCC_VERSION >= 2007 > +# define inline __inline__ /* __inline__ prevents -pedantic warnings */ > +# else > +# define inline /* nothing */ > +# endif > +#endif > + > +#else /* Not ANSI C. */ > + > +#define PTR char * > + > +/* some systems define these in header files for non-ansi mode */ > +#undef const > +#undef volatile > +#undef signed > +#undef inline > +#define const > +#define volatile > +#define signed > +#define inline > + > +#endif /* ANSI C. */ > + > +/* Define macros for some gcc attributes. This permits us to use the > + macros freely, and know that they will come into play for the > + version of gcc in which they are supported. */ > + > +#if (GCC_VERSION < 2007) > +# define __attribute__(x) > +#endif > + > +/* Attribute __malloc__ on functions was valid as of gcc 2.96. */ > +#ifndef ATTRIBUTE_MALLOC > +# if (GCC_VERSION >= 2096) > +# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) > +# else > +# define ATTRIBUTE_MALLOC > +# endif /* GNUC >= 2.96 */ > +#endif /* ATTRIBUTE_MALLOC */ > + > +/* Attributes on labels were valid as of gcc 2.93 and g++ 4.5. For > + g++ an attribute on a label must be followed by a semicolon. */ > +#ifndef ATTRIBUTE_UNUSED_LABEL > +# ifndef __cplusplus > +# if GCC_VERSION >= 2093 > +# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED > +# else > +# define ATTRIBUTE_UNUSED_LABEL > +# endif > +# else > +# if GCC_VERSION >= 4005 > +# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED ; > +# else > +# define ATTRIBUTE_UNUSED_LABEL > +# endif > +# endif > +#endif > + > +/* Similarly to ARG_UNUSED below. Prior to GCC 3.4, the C++ frontend > + couldn't parse attributes placed after the identifier name, and now > + the entire compiler is built with C++. */ > +#ifndef ATTRIBUTE_UNUSED > +#if GCC_VERSION >= 3004 > +# define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) > +#else > +#define ATTRIBUTE_UNUSED > +#endif > +#endif /* ATTRIBUTE_UNUSED */ > + > +/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after > the > + identifier name. */ > +#if ! defined(__cplusplus) || (GCC_VERSION >= 3004) > +# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED > +#else /* !__cplusplus || GNUC >= 3.4 */ > +# define ARG_UNUSED(NAME) NAME > +#endif /* !__cplusplus || GNUC >= 3.4 */ > + > +#ifndef ATTRIBUTE_NORETURN > +#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__)) > +#endif /* ATTRIBUTE_NORETURN */ > + > +/* Attribute `nonnull' was valid as of gcc 3.3. */ > +#ifndef ATTRIBUTE_NONNULL > +# if (GCC_VERSION >= 3003) > +# define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m))) > +# else > +# define ATTRIBUTE_NONNULL(m) > +# endif /* GNUC >= 3.3 */ > +#endif /* ATTRIBUTE_NONNULL */ > + > +/* Attribute `returns_nonnull' was valid as of gcc 4.9. */ > +#ifndef ATTRIBUTE_RETURNS_NONNULL > +# if (GCC_VERSION >= 4009) > +# define ATTRIBUTE_RETURNS_NONNULL __attribute__ ((__returns_nonnull__)) > +# else > +# define ATTRIBUTE_RETURNS_NONNULL > +# endif /* GNUC >= 4.9 */ > +#endif /* ATTRIBUTE_RETURNS_NONNULL */ > + > +/* Attribute `pure' was valid as of gcc 3.0. */ > +#ifndef ATTRIBUTE_PURE > +# if (GCC_VERSION >= 3000) > +# define ATTRIBUTE_PURE __attribute__ ((__pure__)) > +# else > +# define ATTRIBUTE_PURE > +# endif /* GNUC >= 3.0 */ > +#endif /* ATTRIBUTE_PURE */ > + > +/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL. > + This was the case for the `printf' format attribute by itself > + before GCC 3.3, but as of 3.3 we need to add the `nonnull' > + attribute to retain this behavior. */ > +#ifndef ATTRIBUTE_PRINTF > +#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, > n))) ATTRIBUTE_NONNULL(m) > +#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2) > +#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3) > +#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4) > +#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5) > +#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6) > +#endif /* ATTRIBUTE_PRINTF */ > + > +/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on > + a function pointer. Format attributes were allowed on function > + pointers as of gcc 3.1. */ > +#ifndef ATTRIBUTE_FPTR_PRINTF > +# if (GCC_VERSION >= 3001) > +# define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n) > +# else > +# define ATTRIBUTE_FPTR_PRINTF(m, n) > +# endif /* GNUC >= 3.1 */ > +# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2) > +# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3) > +# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4) > +# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5) > +# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6) > +#endif /* ATTRIBUTE_FPTR_PRINTF */ > + > +/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL. A > + NULL format specifier was allowed as of gcc 3.3. */ > +#ifndef ATTRIBUTE_NULL_PRINTF > +# if (GCC_VERSION >= 3003) > +# define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ > (__printf__, m, n))) > +# else > +# define ATTRIBUTE_NULL_PRINTF(m, n) > +# endif /* GNUC >= 3.3 */ > +# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2) > +# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3) > +# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4) > +# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5) > +# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6) > +#endif /* ATTRIBUTE_NULL_PRINTF */ > + > +/* Attribute `sentinel' was valid as of gcc 3.5. */ > +#ifndef ATTRIBUTE_SENTINEL > +# if (GCC_VERSION >= 3005) > +# define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__)) > +# else > +# define ATTRIBUTE_SENTINEL > +# endif /* GNUC >= 3.5 */ > +#endif /* ATTRIBUTE_SENTINEL */ > + > + > +#ifndef ATTRIBUTE_ALIGNED_ALIGNOF > +# if (GCC_VERSION >= 3000) > +# define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ > (__alignof__ (m)))) > +# else > +# define ATTRIBUTE_ALIGNED_ALIGNOF(m) > +# endif /* GNUC >= 3.0 */ > +#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */ > + > +/* Useful for structures whose layout must match some binary specification > + regardless of the alignment and padding qualities of the compiler. */ > +#ifndef ATTRIBUTE_PACKED > +# define ATTRIBUTE_PACKED __attribute__ ((packed)) > +#endif > + > +/* Attribute `hot' and `cold' was valid as of gcc 4.3. */ > +#ifndef ATTRIBUTE_COLD > +# if (GCC_VERSION >= 4003) > +# define ATTRIBUTE_COLD __attribute__ ((__cold__)) > +# else > +# define ATTRIBUTE_COLD > +# endif /* GNUC >= 4.3 */ > +#endif /* ATTRIBUTE_COLD */ > +#ifndef ATTRIBUTE_HOT > +# if (GCC_VERSION >= 4003) > +# define ATTRIBUTE_HOT __attribute__ ((__hot__)) > +# else > +# define ATTRIBUTE_HOT > +# endif /* GNUC >= 4.3 */ > +#endif /* ATTRIBUTE_HOT */ > + > +/* Attribute 'no_sanitize_undefined' was valid as of gcc 4.9. */ > +#ifndef ATTRIBUTE_NO_SANITIZE_UNDEFINED > +# if (GCC_VERSION >= 4009) > +# define ATTRIBUTE_NO_SANITIZE_UNDEFINED __attribute__ > ((no_sanitize_undefined)) > +# else > +# define ATTRIBUTE_NO_SANITIZE_UNDEFINED > +# endif /* GNUC >= 4.9 */ > +#endif /* ATTRIBUTE_NO_SANITIZE_UNDEFINED */ > + > +/* We use __extension__ in some places to suppress -pedantic warnings > + about GCC extensions. This feature didn't work properly before > + gcc 2.8. */ > +#if GCC_VERSION < 2008 > +#define __extension__ > +#endif > + > +/* This is used to declare a const variable which should be visible > + outside of the current compilation unit. Use it as > + EXPORTED_CONST int i = 1; > + This is because the semantics of const are different in C and C++. > + "extern const" is permitted in C but it looks strange, and gcc > + warns about it when -Wc++-compat is not used. */ > +#ifdef __cplusplus > +#define EXPORTED_CONST extern const > +#else > +#define EXPORTED_CONST const > +#endif > + > +/* Be conservative and only use enum bitfields with C++ or GCC. > + FIXME: provide a complete autoconf test for buggy enum bitfields. */ > + > +#ifdef __cplusplus > +#define ENUM_BITFIELD(TYPE) enum TYPE > +#elif (GCC_VERSION > 2000) > +#define ENUM_BITFIELD(TYPE) __extension__ enum TYPE > +#else > +#define ENUM_BITFIELD(TYPE) unsigned int > +#endif > + > +/* C++11 adds the ability to add "override" after an implementation of a > + virtual function in a subclass, to: > + (A) document that this is an override of a virtual function > + (B) allow the compiler to issue a warning if it isn't (e.g. a mismatch > + of the type signature). > + > + Similarly, it allows us to add a "final" to indicate that no subclass > + may subsequently override the vfunc. > + > + Provide OVERRIDE and FINAL as macros, allowing us to get these benefits > + when compiling with C++11 support, but without requiring C++11. > + > + For gcc, use "-std=c++11" to enable C++11 support; gcc 6 onwards enables > + this by default (actually GNU++14). */ > + > +#if __cplusplus >= 201103 > +/* C++11 claims to be available: use it. final/override were only > + implemented in 4.7, though. */ > +# if GCC_VERSION < 4007 > +# define OVERRIDE > +# define FINAL > +# else > +# define OVERRIDE override > +# define FINAL final > +# endif > +#elif GCC_VERSION >= 4007 > +/* G++ 4.7 supports __final in C++98. */ > +# define OVERRIDE > +# define FINAL __final > +#else > +/* No C++11 support; leave the macros empty: */ > +# define OVERRIDE > +# define FINAL > +#endif > + > +#ifdef __cplusplus > +} > +#endif > + > +#endif /* ansidecl.h */ > diff --git a/libgcov/include/config/auto-host.h > b/libgcov/include/config/auto-host.h > new file mode 100644 > index 0000000..9b81bf2 > --- /dev/null > +++ b/libgcov/include/config/auto-host.h > @@ -0,0 +1,2419 @@ > +/* auto-host.h. Generated from config.in by configure. */ > +/* config.in. Generated from configure.ac by autoheader. */ > + > +/* Define if this compiler should be built as the offload target compiler. */ > +#ifndef USED_FOR_TARGET > +/* #undef ACCEL_COMPILER */ > +#endif > + > + > +/* Define if building universal (internal helper macro) */ > +#ifndef USED_FOR_TARGET > +/* #undef AC_APPLE_UNIVERSAL_BUILD */ > +#endif > + > + > +/* Define to the assembler option to enable compressed debug sections. */ > +#ifndef USED_FOR_TARGET > +#define AS_COMPRESS_DEBUG_OPTION "" > +#endif > + > + > +/* Define to the assembler option to disable compressed debug sections. */ > +#ifndef USED_FOR_TARGET > +#define AS_NO_COMPRESS_DEBUG_OPTION "" > +#endif > + > + > +/* Define as the number of bits in a byte, if `limits.h' doesn't. */ > +#ifndef USED_FOR_TARGET > +/* #undef CHAR_BIT */ > +#endif > + > + > +/* Define to 0/1 if you want more run-time sanity checks. This one gets a > grab > + bag of miscellaneous but relatively cheap checks. */ > +#ifndef USED_FOR_TARGET > +#define CHECKING_P 0 > +#endif > + > + > +/* Define 0/1 to force the choice for exception handling model. */ > +#ifndef USED_FOR_TARGET > +/* #undef CONFIG_SJLJ_EXCEPTIONS */ > +#endif > + > + > +/* Define to enable the use of a default assembler. */ > +#ifndef USED_FOR_TARGET > +/* #undef DEFAULT_ASSEMBLER */ > +#endif > + > + > +/* Define to enable the use of a default linker. */ > +#ifndef USED_FOR_TARGET > +/* #undef DEFAULT_LINKER */ > +#endif > + > + > +/* Define if you want to use __cxa_atexit, rather than atexit, to register > C++ > + destructors for local statics and global objects. This is essential for > + fully standards-compliant handling of destructors, but requires > + __cxa_atexit in libc. */ > +#ifndef USED_FOR_TARGET > +#define DEFAULT_USE_CXA_ATEXIT 2 > +#endif > + > + > +/* The default for -fdiagnostics-color option */ > +#ifndef USED_FOR_TARGET > +#define DIAGNOSTICS_COLOR_DEFAULT DIAGNOSTICS_COLOR_AUTO > +#endif > + > + > +/* Define if you want assertions enabled. This is a cheap check. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_ASSERT_CHECKING 1 > +#endif > + > + > +/* Define to 1 to specify that we are using the BID decimal floating point > + format instead of DPD */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_DECIMAL_BID_FORMAT 1 > +#endif > + > + > +/* Define to 1 to enable decimal float extension to C. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_DECIMAL_FLOAT 1 > +#endif > + > + > +/* Define if your target supports default PIE and it is enabled. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_DEFAULT_PIE */ > +#endif > + > + > +/* Define if your target supports default stack protector and it is enabled. > + */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_DEFAULT_SSP */ > +#endif > + > + > +/* Define if you want more run-time sanity checks for dataflow. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_DF_CHECKING */ > +#endif > + > + > +/* Define to 0/1 if you want extra run-time checking that might affect code > + generation. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_EXTRA_CHECKING 0 > +#endif > + > + > +/* Define to 1 to enable fixed-point arithmetic extension to C. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_FIXED_POINT 0 > +#endif > + > + > +/* Define if you want fold checked that it never destructs its argument. This > + is quite expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_FOLD_CHECKING */ > +#endif > + > + > +/* Define if you want the garbage collector to operate in maximally paranoid > + mode, validating the entire heap and collecting garbage at every > + opportunity. This is extremely expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_GC_ALWAYS_COLLECT */ > +#endif > + > + > +/* Define if you want the garbage collector to do object poisoning and other > + memory allocation checks. This is quite expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_GC_CHECKING */ > +#endif > + > + > +/* Define if you want operations on GIMPLE (the basic data structure of the > + high-level optimizers) to be checked for dynamic type safety at runtime. > + This is moderately expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_GIMPLE_CHECKING */ > +#endif > + > + > +/* Define this to enable support for generating HSAIL. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_HSA */ > +#endif > + > + > +/* Define if gcc should always pass --build-id to linker. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_LD_BUILDID */ > +#endif > + > + > +/* Define to 1 to enable libquadmath support */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_LIBQUADMATH_SUPPORT 1 > +#endif > + > + > +/* Define to enable LTO support. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_LTO */ > +#endif > + > + > +/* Define to 1 if translation of program messages to the user's native > + language is requested. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_NLS */ > +#endif > + > + > +/* Define this to enable support for offloading. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_OFFLOADING 0 > +#endif > + > + > +/* Define to enable plugin support. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_PLUGIN 1 > +#endif > + > + > +/* Define if you want all operations on RTL (the basic data structure of the > + optimizer and back end) to be checked for dynamic type safety at runtime. > + This is quite expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_RTL_CHECKING */ > +#endif > + > + > +/* Define if you want RTL flag accesses to be checked against the RTL codes > + that are supported for each access macro. This is relatively cheap. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_RTL_FLAG_CHECKING */ > +#endif > + > + > +/* Define if you want runtime assertions enabled. This is a cheap check. */ > +#define ENABLE_RUNTIME_CHECKING 1 > + > +/* Define if you want all operations on trees (the basic data structure of > the > + front ends) to be checked for dynamic type safety at runtime. This is > + moderately expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_TREE_CHECKING */ > +#endif > + > + > +/* Define if you want all gimple types to be verified after gimplifiation. > + This is cheap. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_TYPES_CHECKING */ > +#endif > + > + > +/* Define to get calls to the valgrind runtime enabled. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_VALGRIND_ANNOTATIONS */ > +#endif > + > + > +/* Define if you want to run subprograms and generated programs through > + valgrind (a memory checker). This is extremely expensive. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_VALGRIND_CHECKING */ > +#endif > + > + > +/* Define 0/1 if vtable verification feature is enabled. */ > +#ifndef USED_FOR_TARGET > +#define ENABLE_VTABLE_VERIFY 0 > +#endif > + > + > +/* Define to 1 if installation paths should be looked up in the Windows > + Registry. Ignored on non-Windows hosts. */ > +#ifndef USED_FOR_TARGET > +/* #undef ENABLE_WIN32_REGISTRY */ > +#endif > + > + > +/* Define to the name of a file containing a list of extra machine modes for > + this architecture. */ > +#ifndef USED_FOR_TARGET > +#define EXTRA_MODES_FILE "config/i386/i386-modes.def" > +#endif > + > + > +/* Define to enable detailed memory allocation stats gathering. */ > +#ifndef USED_FOR_TARGET > +#define GATHER_STATISTICS 0 > +#endif > + > + > +/* Define to 1 if `TIOCGWINSZ' requires <sys/ioctl.h>. */ > +#ifndef USED_FOR_TARGET > +#define GWINSZ_IN_SYS_IOCTL 1 > +#endif > + > + > +/* mcontext_t fields start with __ */ > +#ifndef USED_FOR_TARGET > +/* #undef HAS_MCONTEXT_T_UNDERSCORES */ > +#endif > + > + > +/* Define if your assembler supports architecture modifiers. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_ARCHITECTURE_MODIFIERS */ > +#endif > + > + > +/* Define if your avr assembler supports --mlink-relax option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_AVR_MLINK_RELAX_OPTION */ > +#endif > + > + > +/* Define if your avr assembler supports -mrmw option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_AVR_MRMW_OPTION */ > +#endif > + > + > +/* Define if your assembler supports cmpb. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_CMPB */ > +#endif > + > + > +/* Define to the level of your assembler's compressed debug section support. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_COMPRESS_DEBUG no > +#endif > + > + > +/* Define if your assembler supports the DCI/ICI instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DCI */ > +#endif > + > + > +/* Define if your assembler supports the --debug-prefix-map option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DEBUG_PREFIX_MAP */ > +#endif > + > + > +/* Define if your assembler supports DFP instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DFP */ > +#endif > + > + > +/* Define if your assembler supports .module. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DOT_MODULE */ > +#endif > + > + > +/* Define if your assembler supports DSPR1 mult. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DSPR1_MULT */ > +#endif > + > + > +/* Define if your assembler supports .dtprelword. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DTPRELWORD */ > +#endif > + > + > +/* Define if your assembler supports dwarf2 .file/.loc directives, and > + preserves file table indices exactly as given. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_DWARF2_DEBUG_LINE */ > +#endif > + > + > +/* Define if your assembler supports the R_PPC64_ENTRY relocation. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_ENTRY_MARKERS */ > +#endif > + > + > +/* Define if your assembler supports explicit relocations. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_EXPLICIT_RELOCS */ > +#endif > + > + > +/* Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_FMAF_HPC_VIS3 */ > +#endif > + > + > +/* Define if your assembler supports fprnd. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_FPRND */ > +#endif > + > + > +/* Define if your assembler supports the --gdwarf2 option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_GDWARF2_DEBUG_FLAG */ > +#endif > + > + > +/* Define if your assembler supports .gnu_attribute. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_GNU_ATTRIBUTE */ > +#endif > + > + > +/* Define true if the assembler supports '.long foo@GOTOFF'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_GOTOFF_IN_DATA 0 > +#endif > + > + > +/* Define if your assembler supports the --gstabs option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_GSTABS_DEBUG_FLAG */ > +#endif > + > + > +/* Define if your assembler supports the Sun syntax for cmov. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_CMOV_SUN_SYNTAX */ > +#endif > + > + > +/* Define if your assembler supports the subtraction of symbols in different > + sections. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_DIFF_SECT_DELTA */ > +#endif > + > + > +/* Define if your assembler supports the ffreep mnemonic. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_FFREEP */ > +#endif > + > + > +/* Define if your assembler uses fildq and fistq mnemonics. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_FILDQ */ > +#endif > + > + > +/* Define if your assembler uses filds and fists mnemonics. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_FILDS */ > +#endif > + > + > +/* Define 0/1 if your assembler and linker support @GOT. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_IX86_GOT32X 0 > +#endif > + > + > +/* Define if your assembler supports HLE prefixes. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_HLE */ > +#endif > + > + > +/* Define if your assembler supports interunit movq mnemonic. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_IX86_INTERUNIT_MOVQ 0 > +#endif > + > + > +/* Define if your assembler supports the .quad directive. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_QUAD */ > +#endif > + > + > +/* Define if the assembler supports 'rep <insn>, lock <insn>'. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_REP_LOCK_PREFIX */ > +#endif > + > + > +/* Define if your assembler supports the sahf mnemonic in 64bit mode. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_SAHF */ > +#endif > + > + > +/* Define if your assembler supports the swap suffix. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_SWAP */ > +#endif > + > + > +/* Define if your assembler and linker support @tlsgdplt. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_TLSGDPLT */ > +#endif > + > + > +/* Define to 1 if your assembler and linker support @tlsldm. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_IX86_TLSLDM 0 > +#endif > + > + > +/* Define to 1 if your assembler and linker support @tlsldmplt. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_IX86_TLSLDMPLT 0 > +#endif > + > + > +/* Define 0/1 if your assembler and linker support calling ___tls_get_addr > via > + GOT. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_IX86_TLS_GET_ADDR_GOT 0 > +#endif > + > + > +/* Define if your assembler supports the 'ud2' mnemonic. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_IX86_UD2 */ > +#endif > + > + > +/* Define if your assembler supports the lituse_jsrdirect relocation. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_JSRDIRECT_RELOCS */ > +#endif > + > + > +/* Define if your assembler supports .sleb128 and .uleb128. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_AS_LEB128 0 > +#endif > + > + > +/* Define if your assembler supports LEON instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_LEON */ > +#endif > + > + > +/* Define if the assembler won't complain about a line such as # 0 "" 2. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_LINE_ZERO */ > +#endif > + > + > +/* Define if your assembler supports ltoffx and ldxmov relocations. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_LTOFFX_LDXMOV_RELOCS */ > +#endif > + > + > +/* Define if your assembler supports LWSYNC instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_LWSYNC */ > +#endif > + > + > +/* Define if your assembler supports the -mabi option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_MABI_OPTION */ > +#endif > + > + > +/* Define if your assembler supports .machine and .machinemode. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_MACHINE_MACHINEMODE */ > +#endif > + > + > +/* Define if your assembler supports mfcr field. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_MFCRF */ > +#endif > + > + > +/* Define if your assembler supports mffgpr and mftgpr. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_MFPGPR */ > +#endif > + > + > +/* Define if your Mac OS X assembler supports the -mmacos-version-min option. > + */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_MMACOSX_VERSION_MIN_OPTION */ > +#endif > + > + > +/* Define if the assembler understands -mnan=. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_NAN */ > +#endif > + > + > +/* Define if your assembler supports the -no-mul-bug-abort option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_NO_MUL_BUG_ABORT_OPTION */ > +#endif > + > + > +/* Define if the assembler understands -mno-shared. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_NO_SHARED */ > +#endif > + > + > +/* Define if your assembler supports offsetable %lo(). */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_OFFSETABLE_LO10 */ > +#endif > + > + > +/* Define if your assembler supports popcntb field. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_POPCNTB */ > +#endif > + > + > +/* Define if your assembler supports POPCNTD instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_POPCNTD */ > +#endif > + > + > +/* Define if your assembler supports POWER8 instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_POWER8 */ > +#endif > + > + > +/* Define if your assembler supports POWER9 instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_POWER9 */ > +#endif > + > + > +/* Define if your assembler supports .ref */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_REF */ > +#endif > + > + > +/* Define if your assembler supports .register. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_REGISTER_PSEUDO_OP */ > +#endif > + > + > +/* Define if your assembler supports R_PPC_REL16 relocs. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_REL16 */ > +#endif > + > + > +/* Define if your assembler supports -relax option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_RELAX_OPTION */ > +#endif > + > + > +/* Define if your assembler supports relocs needed by -fpic. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SMALL_PIC_RELOCS */ > +#endif > + > + > +/* Define if your assembler supports SPARC4 instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SPARC4 */ > +#endif > + > + > +/* Define if your assembler supports SPARC5 and VIS 4.0 instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SPARC5_VIS4 */ > +#endif > + > +/* Define if your assembler supports SPARC6 instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SPARC6 */ > +#endif > + > +/* Define if your assembler and linker support GOTDATA_OP relocs. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SPARC_GOTDATA_OP */ > +#endif > + > + > +/* Define if your assembler and linker support unaligned PC relative relocs. > + */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SPARC_UA_PCREL */ > +#endif > + > + > +/* Define if your assembler and linker support unaligned PC relative relocs > + against hidden symbols. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_SPARC_UA_PCREL_HIDDEN */ > +#endif > + > + > +/* Define if your assembler supports .stabs. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_STABS_DIRECTIVE */ > +#endif > + > + > +/* Define if your assembler and linker support thread-local storage. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_TLS */ > +#endif > + > + > +/* Define if your assembler supports arg info for __tls_get_addr. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_TLS_MARKERS */ > +#endif > + > + > +/* Define if your assembler supports VSX instructions. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_VSX */ > +#endif > + > + > +/* Define if your assembler supports -xbrace_comment option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_AS_XBRACE_COMMENT_OPTION */ > +#endif > + > + > +/* Define to 1 if you have the `atoq' function. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_ATOQ */ > +#endif > + > + > +/* Define to 1 if you have the `clearerr_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_CLEARERR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `clock' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_CLOCK 1 > +#endif > + > + > +/* Define if <time.h> defines clock_t. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_CLOCK_T 1 > +#endif > + > + > +/* Define 0/1 if your assembler and linker support COMDAT groups. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_COMDAT_GROUP 0 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'abort', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_ABORT 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'asprintf', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_ASPRINTF 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'atof', otherwise define to 0. > */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_ATOF 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'atol', otherwise define to 0. > */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_ATOL 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'atoll', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_ATOLL 1 > +#endif > + > + > +/* Define to 1 if you have the declaration of `basename(const char*)', and to > + 0 if you don't. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_BASENAME 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'calloc', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_CALLOC 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'clearerr_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_CLEARERR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'clock', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_CLOCK 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'errno', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_ERRNO 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'feof_unlocked', otherwise > define > + to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FEOF_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'ferror_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FERROR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fflush_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FFLUSH_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'ffs', otherwise define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FFS 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fgetc_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FGETC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fgets_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FGETS_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fileno_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FILENO_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fprintf_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FPRINTF_UNLOCKED 0 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fputc_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FPUTC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fputs_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FPUTS_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fread_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FREAD_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'free', otherwise define to 0. > */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FREE 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'fwrite_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_FWRITE_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getchar_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETCHAR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getcwd', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETCWD 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getc_unlocked', otherwise > define > + to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getenv', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETENV 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getopt', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETOPT 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getpagesize', otherwise define > + to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETPAGESIZE 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getrlimit', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETRLIMIT 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getrusage', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETRUSAGE 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'getwd', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_GETWD 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'ldgetname', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_LDGETNAME 0 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'madvise', otherwise define to > 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_MADVISE 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'malloc', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_MALLOC 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'putchar_unlocked', otherwise > + define to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_PUTCHAR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'putc_unlocked', otherwise > define > + to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_PUTC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'realloc', otherwise define to > 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_REALLOC 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'sbrk', otherwise define to 0. > */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_SBRK 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'setenv', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_SETENV 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'setrlimit', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_SETRLIMIT 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'sigaltstack', otherwise define > + to 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_SIGALTSTACK 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'snprintf', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_SNPRINTF 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'stpcpy', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STPCPY 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strnlen', otherwise define to > 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRNLEN 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strsignal', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRSIGNAL 1 > +#endif > + > + > +/* Define to 1 if you have the declaration of `strstr(const char*,const > + char*)', and to 0 if you don't. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRSTR 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strtol', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRTOL 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strtoll', otherwise define to > 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRTOLL 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strtoul', otherwise define to > 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRTOUL 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strtoull', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRTOULL 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'strverscmp', otherwise define > to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_STRVERSCMP 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'times', otherwise define to 0. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_TIMES 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'unsetenv', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_UNSETENV 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'vasprintf', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_VASPRINTF 1 > +#endif > + > + > +/* Define to 1 if we found a declaration for 'vsnprintf', otherwise define to > + 0. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DECL_VSNPRINTF 1 > +#endif > + > + > +/* Define to 1 if you have the <direct.h> header file. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_DIRECT_H */ > +#endif > + > + > +/* Define to 1 if you have the <dlfcn.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_DLFCN_H 1 > +#endif > + > + > +/* Define to 1 if you have the <ext/hash_map> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_EXT_HASH_MAP 1 > +#endif > + > + > +/* Define to 1 if you have the <fcntl.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FCNTL_H 1 > +#endif > + > + > +/* Define to 1 if you have the `feof_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FEOF_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `ferror_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FERROR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fflush_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FFLUSH_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fgetc_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FGETC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fgets_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FGETS_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fileno_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FILENO_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fork' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FORK 1 > +#endif > + > + > +/* Define to 1 if you have the `fprintf_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_FPRINTF_UNLOCKED */ > +#endif > + > + > +/* Define to 1 if you have the `fputc_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FPUTC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fputs_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FPUTS_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `fread_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FREAD_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the <ftw.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FTW_H 1 > +#endif > + > + > +/* Define to 1 if you have the `fwrite_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_FWRITE_UNLOCKED 1 > +#endif > + > + > +/* Define if your assembler supports specifying the alignment of objects > + allocated using the GAS .comm command. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_ALIGNED_COMM */ > +#endif > + > + > +/* Define if your assembler supports .balign and .p2align. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_BALIGN_AND_P2ALIGN */ > +#endif > + > + > +/* Define 0/1 if your assembler supports CFI directives. */ > +#define HAVE_GAS_CFI_DIRECTIVE 0 > + > +/* Define 0/1 if your assembler supports .cfi_personality. */ > +#define HAVE_GAS_CFI_PERSONALITY_DIRECTIVE 0 > + > +/* Define 0/1 if your assembler supports .cfi_sections. */ > +#define HAVE_GAS_CFI_SECTIONS_DIRECTIVE 0 > + > +/* Define if your assembler supports the .loc discriminator sub-directive. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_DISCRIMINATOR */ > +#endif > + > + > +/* Define if your assembler supports @gnu_unique_object. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_GNU_UNIQUE_OBJECT */ > +#endif > + > + > +/* Define if your assembler and linker support .hidden. */ > +/* #undef HAVE_GAS_HIDDEN */ > + > +/* Define if your assembler supports .lcomm with an alignment field. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_LCOMM_WITH_ALIGNMENT */ > +#endif > + > + > +/* Define if your assembler supports .literal16. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_LITERAL16 */ > +#endif > + > + > +/* Define if your assembler supports specifying the maximum number of bytes > to > + skip when using the GAS .p2align command. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_MAX_SKIP_P2ALIGN */ > +#endif > + > + > +/* Define if your assembler supports the .set micromips directive */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_MICROMIPS */ > +#endif > + > + > +/* Define if your assembler supports .nsubspa comdat option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_NSUBSPA_COMDAT */ > +#endif > + > + > +/* Define if your assembler and linker support 32-bit section relative relocs > + via '.secrel32 label'. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_PE_SECREL32_RELOC */ > +#endif > + > + > +/* Define if your assembler supports specifying the section flag e. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GAS_SECTION_EXCLUDE 0 > +#endif > + > + > +/* Define 0/1 if your assembler supports marking sections with SHF_MERGE > flag. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GAS_SHF_MERGE 0 > +#endif > + > + > +/* Define if your assembler supports .subsection and .subsection -1 starts > + emitting at the beginning of your section. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_SUBSECTION_ORDERING */ > +#endif > + > + > +/* Define if your assembler supports .weak. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_WEAK */ > +#endif > + > + > +/* Define if your assembler supports .weakref. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GAS_WEAKREF */ > +#endif > + > + > +/* Define to 1 if you have the `getchar_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GETCHAR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `getc_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GETC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `getrlimit' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GETRLIMIT 1 > +#endif > + > + > +/* Define to 1 if you have the `getrusage' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GETRUSAGE 1 > +#endif > + > + > +/* Define to 1 if you have the `gettimeofday' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GETTIMEOFDAY 1 > +#endif > + > + > +/* Define to 1 if using GNU as. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GNU_AS 1 > +#endif > + > + > +/* Define if your system supports gnu indirect functions. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GNU_INDIRECT_FUNCTION 1 > +#endif > + > + > +/* Define to 1 if using GNU ld. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_GNU_LD 1 > +#endif > + > + > +/* Define if the gold linker supports split stack and is available as a > + non-default */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK */ > +#endif > + > + > +/* Define if you have the iconv() function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_ICONV 1 > +#endif > + > + > +/* Define to 1 if you have the <iconv.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_ICONV_H 1 > +#endif > + > + > +/* Define 0/1 if .init_array/.fini_array sections are available and working. > + */ > +#ifndef USED_FOR_TARGET > +#define HAVE_INITFINI_ARRAY_SUPPORT 0 > +#endif > + > + > +/* Define to 1 if the system has the type `intmax_t'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_INTMAX_T 1 > +#endif > + > + > +/* Define to 1 if the system has the type `intptr_t'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_INTPTR_T 1 > +#endif > + > + > +/* Define if you have a working <inttypes.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_INTTYPES_H 1 > +#endif > + > + > +/* Define to 1 if you have the `kill' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_KILL 1 > +#endif > + > + > +/* Define if you have <langinfo.h> and nl_langinfo(CODESET). */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LANGINFO_CODESET 1 > +#endif > + > + > +/* Define to 1 if you have the <langinfo.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LANGINFO_H 1 > +#endif > + > + > +/* Define if your <locale.h> file defines LC_MESSAGES. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LC_MESSAGES 1 > +#endif > + > + > +/* Define to 1 if you have the <ldfcn.h> header file. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LDFCN_H */ > +#endif > + > + > +/* Define if your linker supports --as-needed/--no-as-needed or equivalent > + options. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_AS_NEEDED */ > +#endif > + > + > +/* Define if your linker supports -z bndplt */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_BNDPLT_SUPPORT */ > +#endif > + > + > +/* Define if your linker supports --build-id. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_BUILDID */ > +#endif > + > + > +/* Define if the linker supports clearing hardware capabilities via mapfile. > + */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_CLEARCAP */ > +#endif > + > + > +/* Define to the level of your linker's compressed debug section support. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LD_COMPRESS_DEBUG 0 > +#endif > + > + > +/* Define if your linker supports --demangle option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_DEMANGLE */ > +#endif > + > + > +/* Define 0/1 if your linker supports CIE v3 in .eh_frame. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LD_EH_FRAME_CIEV3 0 > +#endif > + > + > +/* Define if your linker supports .eh_frame_hdr. */ > +/* #undef HAVE_LD_EH_FRAME_HDR */ > + > +/* Define if your linker supports garbage collection of sections in presence > + of EH frames. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_EH_GC_SECTIONS */ > +#endif > + > + > +/* Define if your linker has buggy garbage collection of sections support > when > + .text.startup.foo like sections are used. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_EH_GC_SECTIONS_BUG */ > +#endif > + > + > +/* Define if your PowerPC64 linker supports a large TOC. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_LARGE_TOC */ > +#endif > + > + > +/* Define if your PowerPC64 linker only needs function descriptor syms. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_NO_DOT_SYMS */ > +#endif > + > + > +/* Define if your linker can relax absolute .eh_frame personality pointers > + into PC-relative form. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_PERSONALITY_RELAXATION */ > +#endif > + > + > +/* Define if your linker supports PIE option. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_PIE */ > +#endif > + > + > +/* Define 0/1 if your linker supports -pie option with copy reloc. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LD_PIE_COPYRELOC 0 > +#endif > + > + > +/* Define if your PowerPC linker has .gnu.attributes long double support. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE */ > +#endif > + > + > +/* Define if your linker supports --push-state/--pop-state */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_PUSHPOPSTATE_SUPPORT */ > +#endif > + > + > +/* Define if your linker links a mix of read-only and read-write sections > into > + a read-write section. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_RO_RW_SECTION_MIXING */ > +#endif > + > + > +/* Define if your linker supports the *_sol2 emulations. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_SOL2_EMULATION */ > +#endif > + > + > +/* Define if your linker supports -Bstatic/-Bdynamic or equivalent options. > */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_STATIC_DYNAMIC */ > +#endif > + > + > +/* Define if your linker supports --sysroot. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_LD_SYSROOT */ > +#endif > + > + > +/* Define to 1 if you have the <limits.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LIMITS_H 1 > +#endif > + > + > +/* Define to 1 if you have the <locale.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LOCALE_H 1 > +#endif > + > + > +/* Define to 1 if the system has the type `long long'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LONG_LONG 1 > +#endif > + > + > +/* Define to 1 if the system has the type `long long int'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LONG_LONG_INT 1 > +#endif > + > + > +/* Define to the level of your linker's plugin support. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_LTO_PLUGIN 0 > +#endif > + > + > +/* Define to 1 if you have the `madvise' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MADVISE 1 > +#endif > + > + > +/* Define to 1 if you have the <malloc.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MALLOC_H 1 > +#endif > + > + > +/* Define to 1 if you have the `mbstowcs' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MBSTOWCS 1 > +#endif > + > + > +/* Define if valgrind's memcheck.h header is installed. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_MEMCHECK_H */ > +#endif > + > + > +/* Define to 1 if you have the <memory.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MEMORY_H 1 > +#endif > + > + > +/* Define to 1 if you have the `mmap' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MMAP 1 > +#endif > + > + > +/* Define if mmap with MAP_ANON(YMOUS) works. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MMAP_ANON 1 > +#endif > + > + > +/* Define if mmap of /dev/zero works. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MMAP_DEV_ZERO 1 > +#endif > + > + > +/* Define if read-only mmap of a plain file works. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_MMAP_FILE 1 > +#endif > + > + > +/* Define to 1 if you have the `nl_langinfo' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_NL_LANGINFO 1 > +#endif > + > + > +/* Define to 1 if you have the `popen' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_POPEN 1 > +#endif > + > + > +/* Define to 1 if you have the `putchar_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_PUTCHAR_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `putc_unlocked' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_PUTC_UNLOCKED 1 > +#endif > + > + > +/* Define to 1 if you have the `setlocale' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SETLOCALE 1 > +#endif > + > + > +/* Define to 1 if you have the `setrlimit' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SETRLIMIT 1 > +#endif > + > + > +/* Define if the system-provided CRTs are present on Solaris. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_SOLARIS_CRTS */ > +#endif > + > + > +/* Define to 1 if you have the <stddef.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STDDEF_H 1 > +#endif > + > + > +/* Define to 1 if you have the <stdint.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STDINT_H 1 > +#endif > + > + > +/* Define to 1 if you have the <stdlib.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STDLIB_H 1 > +#endif > + > + > +/* Define to 1 if you have the <strings.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STRINGS_H 1 > +#endif > + > + > +/* Define to 1 if you have the <string.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STRING_H 1 > +#endif > + > + > +/* Define to 1 if you have the `strsignal' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STRSIGNAL 1 > +#endif > + > + > +/* Define if <sys/times.h> defines struct tms. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_STRUCT_TMS 1 > +#endif > + > + > +/* Define if <utility> defines std::swap. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SWAP_IN_UTILITY 1 > +#endif > + > + > +/* Define to 1 if you have the `sysconf' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYSCONF 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/file.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_FILE_H 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/mman.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_MMAN_H 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/param.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_PARAM_H 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/resource.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_RESOURCE_H 1 > +#endif > + > + > +/* Define if your target C library provides sys/sdt.h */ > +/* #undef HAVE_SYS_SDT_H */ > + > +/* Define to 1 if you have the <sys/stat.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_STAT_H 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/times.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_TIMES_H 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/time.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_TIME_H 1 > +#endif > + > + > +/* Define to 1 if you have the <sys/types.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_TYPES_H 1 > +#endif > + > + > +/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_SYS_WAIT_H 1 > +#endif > + > + > +/* Define to 1 if you have the `times' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_TIMES 1 > +#endif > + > + > +/* Define to 1 if you have the <time.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_TIME_H 1 > +#endif > + > + > +/* Define to 1 if you have the <tr1/unordered_map> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_TR1_UNORDERED_MAP 1 > +#endif > + > + > +/* Define to 1 if the system has the type `uintmax_t'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_UINTMAX_T 1 > +#endif > + > + > +/* Define to 1 if the system has the type `uintptr_t'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_UINTPTR_T 1 > +#endif > + > + > +/* Define to 1 if you have the <unistd.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_UNISTD_H 1 > +#endif > + > + > +/* Define to 1 if you have the <unordered_map> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_UNORDERED_MAP 1 > +#endif > + > + > +/* Define to 1 if the system has the type `unsigned long long int'. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_UNSIGNED_LONG_LONG_INT 1 > +#endif > + > + > +/* Define if valgrind's valgrind/memcheck.h header is installed. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_VALGRIND_MEMCHECK_H */ > +#endif > + > + > +/* Define to 1 if you have the `vfork' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_VFORK 1 > +#endif > + > + > +/* Define to 1 if you have the <vfork.h> header file. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_VFORK_H */ > +#endif > + > + > +/* Define to 1 if you have the <wchar.h> header file. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_WCHAR_H 1 > +#endif > + > + > +/* Define to 1 if you have the `wcswidth' function. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_WCSWIDTH 1 > +#endif > + > + > +/* Define to 1 if `fork' works. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_WORKING_FORK 1 > +#endif > + > + > +/* Define this macro if mbstowcs does not crash when its first argument is > + NULL. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_WORKING_MBSTOWCS 1 > +#endif > + > + > +/* Define to 1 if `vfork' works. */ > +#ifndef USED_FOR_TARGET > +#define HAVE_WORKING_VFORK 1 > +#endif > + > + > +/* Define if your assembler supports AIX debug frame section label reference. > + */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_XCOFF_DWARF_EXTRAS */ > +#endif > + > + > +/* Define if isl is in use. */ > +#ifndef USED_FOR_TARGET > +/* #undef HAVE_isl */ > +#endif > + > + > +/* Define if F_SETLKW supported by fcntl. */ > +#ifndef USED_FOR_TARGET > +#define HOST_HAS_F_SETLKW 1 > +#endif > + > + > +/* Define as const if the declaration of iconv() needs const. */ > +#ifndef USED_FOR_TARGET > +#define ICONV_CONST > +#endif > + > + > +/* Define if int64_t uses long as underlying type. */ > +#ifndef USED_FOR_TARGET > +#define INT64_T_IS_LONG 1 > +#endif > + > + > +/* Define to 1 if ld64 supports '-export_dynamic'. */ > +#ifndef USED_FOR_TARGET > +/* #undef LD64_HAS_EXPORT_DYNAMIC */ > +#endif > + > + > +/* Define to ld64 version. */ > +#ifndef USED_FOR_TARGET > +/* #undef LD64_VERSION */ > +#endif > + > + > +/* Define to the linker option to ignore unused dependencies. */ > +#ifndef USED_FOR_TARGET > +/* #undef LD_AS_NEEDED_OPTION */ > +#endif > + > + > +/* Define to the linker option to enable compressed debug sections. */ > +#ifndef USED_FOR_TARGET > +#define LD_COMPRESS_DEBUG_OPTION "" > +#endif > + > + > +/* Define to the linker option to enable use of shared objects. */ > +#ifndef USED_FOR_TARGET > +/* #undef LD_DYNAMIC_OPTION */ > +#endif > + > + > +/* Define to the linker option to keep unused dependencies. */ > +#ifndef USED_FOR_TARGET > +/* #undef LD_NO_AS_NEEDED_OPTION */ > +#endif > + > + > +/* Define to the linker option to disable use of shared objects. */ > +#ifndef USED_FOR_TARGET > +/* #undef LD_STATIC_OPTION */ > +#endif > + > + > +/* The linker hash style */ > +#ifndef USED_FOR_TARGET > +/* #undef LINKER_HASH_STYLE */ > +#endif > + > + > +/* Define to the name of the LTO plugin DSO that must be passed to the > + linker's -plugin=LIB option. */ > +#ifndef USED_FOR_TARGET > +#define LTOPLUGINSONAME "liblto_plugin.so" > +#endif > + > + > +/* Define to the sub-directory in which libtool stores uninstalled libraries. > + */ > +#ifndef USED_FOR_TARGET > +#define LT_OBJDIR ".libs/" > +#endif > + > + > +/* Define if host mkdir takes a single argument. */ > +#ifndef USED_FOR_TARGET > +/* #undef MKDIR_TAKES_ONE_ARG */ > +#endif > + > + > +/* Define to offload targets, separated by commas. */ > +#ifndef USED_FOR_TARGET > +#define OFFLOAD_TARGETS "" > +#endif > + > + > +/* Define to the address where bug reports for this package should be sent. > */ > +#ifndef USED_FOR_TARGET > +#define PACKAGE_BUGREPORT "" > +#endif > + > + > +/* Define to the full name of this package. */ > +#ifndef USED_FOR_TARGET > +#define PACKAGE_NAME "" > +#endif > + > + > +/* Define to the full name and version of this package. */ > +#ifndef USED_FOR_TARGET > +#define PACKAGE_STRING "" > +#endif > + > + > +/* Define to the one symbol short name of this package. */ > +#ifndef USED_FOR_TARGET > +#define PACKAGE_TARNAME "" > +#endif > + > + > +/* Define to the home page for this package. */ > +#ifndef USED_FOR_TARGET > +#define PACKAGE_URL "" > +#endif > + > + > +/* Define to the version of this package. */ > +#ifndef USED_FOR_TARGET > +#define PACKAGE_VERSION "" > +#endif > + > + > +/* Specify plugin linker */ > +#ifndef USED_FOR_TARGET > +#define PLUGIN_LD_SUFFIX "" > +#endif > + > + > +/* Define to .TOC. alignment forced by your linker. */ > +#ifndef USED_FOR_TARGET > +/* #undef POWERPC64_TOC_POINTER_ALIGNMENT */ > +#endif > + > + > +/* Define to PREFIX/include if cpp should also search that directory. */ > +#ifndef USED_FOR_TARGET > +/* #undef PREFIX_INCLUDE_DIR */ > +#endif > + > + > +/* The size of `int', as computed by sizeof. */ > +#ifndef USED_FOR_TARGET > +#define SIZEOF_INT 4 > +#endif > + > + > +/* The size of `long', as computed by sizeof. */ > +#ifndef USED_FOR_TARGET > +#define SIZEOF_LONG 8 > +#endif > + > + > +/* The size of `long long', as computed by sizeof. */ > +#ifndef USED_FOR_TARGET > +#define SIZEOF_LONG_LONG 8 > +#endif > + > + > +/* The size of `short', as computed by sizeof. */ > +#ifndef USED_FOR_TARGET > +#define SIZEOF_SHORT 2 > +#endif > + > + > +/* The size of `void *', as computed by sizeof. */ > +#ifndef USED_FOR_TARGET > +#define SIZEOF_VOID_P 8 > +#endif > + > + > +/* Define to 1 if you have the ANSI C header files. */ > +#ifndef USED_FOR_TARGET > +#define STDC_HEADERS 1 > +#endif > + > + > +/* Define if you can safely include both <string.h> and <strings.h>. */ > +#ifndef USED_FOR_TARGET > +#define STRING_WITH_STRINGS 1 > +#endif > + > + > +/* Define if TFmode long double should be the default */ > +#ifndef USED_FOR_TARGET > +/* #undef TARGET_DEFAULT_LONG_DOUBLE_128 */ > +#endif > + > + > +/* Define if your target C library provides the `dl_iterate_phdr' function. > */ > +/* #undef TARGET_DL_ITERATE_PHDR */ > + > +/* GNU C Library major version number used on the target, or 0. */ > +#ifndef USED_FOR_TARGET > +#define TARGET_GLIBC_MAJOR 2 > +#endif > + > + > +/* GNU C Library minor version number used on the target, or 0. */ > +#ifndef USED_FOR_TARGET > +#define TARGET_GLIBC_MINOR 27 > +#endif > + > + > +/* Define if your target C Library provides the AT_HWCAP value in the TCB */ > +#ifndef USED_FOR_TARGET > +/* #undef TARGET_LIBC_PROVIDES_HWCAP_IN_TCB */ > +#endif > + > + > +/* Define if your target C library provides stack protector support */ > +#ifndef USED_FOR_TARGET > +#define TARGET_LIBC_PROVIDES_SSP 1 > +#endif > + > + > +/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */ > +#ifndef USED_FOR_TARGET > +#define TIME_WITH_SYS_TIME 1 > +#endif > + > + > +/* Define to the flag used to mark TLS sections if the default (`T') doesn't > + work. */ > +#ifndef USED_FOR_TARGET > +/* #undef TLS_SECTION_ASM_FLAG */ > +#endif > + > + > +/* Define if your assembler mis-optimizes .eh_frame data. */ > +#ifndef USED_FOR_TARGET > +/* #undef USE_AS_TRADITIONAL_FORMAT */ > +#endif > + > + > +/* Define if you want to generate code by default that assumes that the > Cygwin > + DLL exports wrappers to support libstdc++ function replacement. */ > +#ifndef USED_FOR_TARGET > +/* #undef USE_CYGWIN_LIBSTDCXX_WRAPPERS */ > +#endif > + > + > +/* Define to 1 if the 'long long' type is wider than 'long' but still > + efficiently supported by the host hardware. */ > +#ifndef USED_FOR_TARGET > +/* #undef USE_LONG_LONG_FOR_WIDEST_FAST_INT */ > +#endif > + > + > +/* Define if we should use leading underscore on 64 bit mingw targets */ > +#ifndef USED_FOR_TARGET > +/* #undef USE_MINGW64_LEADING_UNDERSCORES */ > +#endif > + > + > +/* Enable extensions on AIX 3, Interix. */ > +#ifndef _ALL_SOURCE > +# define _ALL_SOURCE 1 > +#endif > +/* Enable GNU extensions on systems that have them. */ > +#ifndef _GNU_SOURCE > +# define _GNU_SOURCE 1 > +#endif > +/* Enable threading extensions on Solaris. */ > +#ifndef _POSIX_PTHREAD_SEMANTICS > +# define _POSIX_PTHREAD_SEMANTICS 1 > +#endif > +/* Enable extensions on HP NonStop. */ > +#ifndef _TANDEM_SOURCE > +# define _TANDEM_SOURCE 1 > +#endif > +/* Enable general extensions on Solaris. */ > +#ifndef __EXTENSIONS__ > +# define __EXTENSIONS__ 1 > +#endif > + > + > +/* Define to be the last component of the Windows registry key under which to > + look for installation paths. The full key used will be > + HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}. > + The default is the GCC version number. */ > +#ifndef USED_FOR_TARGET > +/* #undef WIN32_REGISTRY_KEY */ > +#endif > + > + > +/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most > + significant byte first (like Motorola and SPARC, unlike Intel). */ > +#if defined AC_APPLE_UNIVERSAL_BUILD > +# if defined __BIG_ENDIAN__ > +# define WORDS_BIGENDIAN 1 > +# endif > +#else > +# ifndef WORDS_BIGENDIAN > +/* # undef WORDS_BIGENDIAN */ > +# endif > +#endif > + > +/* Number of bits in a file offset, on hosts where this is settable. */ > +#ifndef USED_FOR_TARGET > +/* #undef _FILE_OFFSET_BITS */ > +#endif > + > + > +/* Define for large files, on AIX-style hosts. */ > +#ifndef USED_FOR_TARGET > +/* #undef _LARGE_FILES */ > +#endif > + > + > +/* Define to 1 if on MINIX. */ > +#ifndef USED_FOR_TARGET > +/* #undef _MINIX */ > +#endif > + > + > +/* Define to 2 if the system does not provide POSIX.1 features except with > + this defined. */ > +#ifndef USED_FOR_TARGET > +/* #undef _POSIX_1_SOURCE */ > +#endif > + > + > +/* Define to 1 if you need to in order for `stat' and other things to work. > */ > +#ifndef USED_FOR_TARGET > +/* #undef _POSIX_SOURCE */ > +#endif > + > + > +/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>, > + <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, > the > + #define below would cause a syntax error. */ > +#ifndef USED_FOR_TARGET > +/* #undef _UINT32_T */ > +#endif > + > + > +/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>, > + <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, > the > + #define below would cause a syntax error. */ > +#ifndef USED_FOR_TARGET > +/* #undef _UINT64_T */ > +#endif > + > + > +/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>, > + <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, > the > + #define below would cause a syntax error. */ > +#ifndef USED_FOR_TARGET > +/* #undef _UINT8_T */ > +#endif > + > + > +/* Define to `char *' if <sys/types.h> does not define. */ > +#ifndef USED_FOR_TARGET > +/* #undef caddr_t */ > +#endif > + > + > +/* Define to `__inline__' or `__inline' if that's what the C compiler > + calls it, or to nothing if 'inline' is not supported under any name. */ > +#ifndef __cplusplus > +/* #undef inline */ > +#endif > + > +/* Define to the type of a signed integer type of width exactly 16 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef int16_t */ > +#endif > + > + > +/* Define to the type of a signed integer type of width exactly 32 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef int32_t */ > +#endif > + > + > +/* Define to the type of a signed integer type of width exactly 64 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef int64_t */ > +#endif > + > + > +/* Define to the type of a signed integer type of width exactly 8 bits if > such > + a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef int8_t */ > +#endif > + > + > +/* Define to the widest signed integer type if <stdint.h> and <inttypes.h> do > + not define. */ > +#ifndef USED_FOR_TARGET > +/* #undef intmax_t */ > +#endif > + > + > +/* Define to the type of a signed integer type wide enough to hold a pointer, > + if such a type exists, and if the system does not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef intptr_t */ > +#endif > + > + > +/* Define to `int' if <sys/types.h> does not define. */ > +#ifndef USED_FOR_TARGET > +/* #undef pid_t */ > +#endif > + > + > +/* Define to `long' if <sys/resource.h> doesn't define. */ > +#ifndef USED_FOR_TARGET > +/* #undef rlim_t */ > +#endif > + > + > +/* Define to `int' if <sys/types.h> does not define. */ > +#ifndef USED_FOR_TARGET > +/* #undef ssize_t */ > +#endif > + > + > +/* Define to the type of an unsigned integer type of width exactly 16 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef uint16_t */ > +#endif > + > + > +/* Define to the type of an unsigned integer type of width exactly 32 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef uint32_t */ > +#endif > + > + > +/* Define to the type of an unsigned integer type of width exactly 64 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef uint64_t */ > +#endif > + > + > +/* Define to the type of an unsigned integer type of width exactly 8 bits if > + such a type exists and the standard includes do not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef uint8_t */ > +#endif > + > + > +/* Define to the widest unsigned integer type if <stdint.h> and <inttypes.h> > + do not define. */ > +#ifndef USED_FOR_TARGET > +/* #undef uintmax_t */ > +#endif > + > + > +/* Define to the type of an unsigned integer type wide enough to hold a > + pointer, if such a type exists, and if the system does not define it. */ > +#ifndef USED_FOR_TARGET > +/* #undef uintptr_t */ > +#endif > + > + > +/* Define as `fork' if `vfork' does not work. */ > +#ifndef USED_FOR_TARGET > +/* #undef vfork */ > +#endif > + > diff --git a/libgcov/include/config/auto-target.h > b/libgcov/include/config/auto-target.h > new file mode 100644 > index 0000000..1ab0d1b > --- /dev/null > +++ b/libgcov/include/config/auto-target.h > @@ -0,0 +1,80 @@ > +/* auto-target.h. Generated from config.in by configure. */ > +/* config.in. Generated from configure.ac by autoheader. */ > + > +/* Define to 1 if the target assembler supports thread-local storage. */ > +/* #undef HAVE_CC_TLS */ > + > +/* Define to 1 if you have the <ftw.h> header file. */ > +#define HAVE_FTW_H 1 > + > +/* Define if _Unwind_GetIPInfo is available. */ > +#define HAVE_GETIPINFO 1 > + > +/* Define if the compiler supports init priority. */ > +#define HAVE_INIT_PRIORITY 1 > + > +/* Define to 1 if you have the <inttypes.h> header file. */ > +#define HAVE_INTTYPES_H 1 > + > +/* Define to 1 if you have the <memory.h> header file. */ > +#define HAVE_MEMORY_H 1 > + > +/* Define if the system-provided CRTs are present on Solaris. */ > +/* #undef HAVE_SOLARIS_CRTS */ > + > +/* Define to 1 if you have the <stdint.h> header file. */ > +#define HAVE_STDINT_H 1 > + > +/* Define to 1 if you have the <stdlib.h> header file. */ > +#define HAVE_STDLIB_H 1 > + > +/* Define to 1 if you have the <strings.h> header file. */ > +#define HAVE_STRINGS_H 1 > + > +/* Define to 1 if you have the <string.h> header file. */ > +#define HAVE_STRING_H 1 > + > +/* Define to 1 if you have the <sys/stat.h> header file. */ > +#define HAVE_SYS_STAT_H 1 > + > +/* Define to 1 if you have the <sys/types.h> header file. */ > +#define HAVE_SYS_TYPES_H 1 > + > +/* Define to 1 if you have the <unistd.h> header file. */ > +#define HAVE_UNISTD_H 1 > + > +/* Define to the address where bug reports for this package should be sent. > */ > +#define PACKAGE_BUGREPORT "" > + > +/* Define to the full name of this package. */ > +#define PACKAGE_NAME "GNU C Runtime Library" > + > +/* Define to the full name and version of this package. */ > +#define PACKAGE_STRING "GNU C Runtime Library 1.0" > + > +/* Define to the one symbol short name of this package. */ > +#define PACKAGE_TARNAME "libgcc" > + > +/* Define to the home page for this package. */ > +#define PACKAGE_URL "http://www.gnu.org/software/libgcc/"; > + > +/* Define to the version of this package. */ > +#define PACKAGE_VERSION "1.0" > + > +/* The size of `double', as computed by sizeof. */ > +#define SIZEOF_DOUBLE 8 > + > +/* The size of `long double', as computed by sizeof. */ > +#define SIZEOF_LONG_DOUBLE 16 > + > +/* Define to 1 if you have the ANSI C header files. */ > +#define STDC_HEADERS 1 > + > +/* Define to 1 if the target use emutls for thread-local storage. */ > +/* #undef USE_EMUTLS */ > + > +/* Number of bits in a file offset, on hosts where this is settable. */ > +/* #undef _FILE_OFFSET_BITS */ > + > +/* Define for large files, on AIX-style hosts. */ > +/* #undef _LARGE_FILES */ > diff --git a/libgcov/include/config/gcov-iov.h > b/libgcov/include/config/gcov-iov.h > new file mode 100644 > index 0000000..4f4f2f5 > --- /dev/null > +++ b/libgcov/include/config/gcov-iov.h > @@ -0,0 +1,4 @@ > +/* Generated automatically by the program `build/gcov-iov' > + from `7.5.0 (7 5) and (*)'. */ > + > +#define GCOV_VERSION ((gcov_unsigned_t)0x4137352a) /* A75* */ > diff --git a/libgcov/include/config/libgcc_tm.h > b/libgcov/include/config/libgcc_tm.h > new file mode 100644 > index 0000000..491425c > --- /dev/null > +++ b/libgcov/include/config/libgcc_tm.h > @@ -0,0 +1,6 @@ > +#ifndef LIBGCC_TM_H > +#define LIBGCC_TM_H > +/* Automatically generated by mkheader.sh. */ > +#include "elf-lib.h" > +#include "value-unwind.h" > +#endif /* LIBGCC_TM_H */ > diff --git a/libgcov/include/config/tconfig.h > b/libgcov/include/config/tconfig.h > new file mode 100644 > index 0000000..7ec80a1 > --- /dev/null > +++ b/libgcov/include/config/tconfig.h > @@ -0,0 +1,10 @@ > +#ifndef GCC_TCONFIG_H > +#define GCC_TCONFIG_H > +#ifndef USED_FOR_TARGET > +# define USED_FOR_TARGET > +#endif > +#include "auto-host.h" > +#ifdef IN_GCC > +# include "ansidecl.h" > +#endif > +#endif /* GCC_TCONFIG_H */ > diff --git a/libgcov/include/config/tm.h b/libgcov/include/config/tm.h > new file mode 100644 > index 0000000..611fa76 > --- /dev/null > +++ b/libgcov/include/config/tm.h > @@ -0,0 +1,52 @@ > +#ifndef GCC_TM_H > +#define GCC_TM_H > +#ifndef LIBC_GLIBC > +# define LIBC_GLIBC 1 > +#endif > +#ifndef LIBC_UCLIBC > +# define LIBC_UCLIBC 2 > +#endif > +#ifndef LIBC_BIONIC > +# define LIBC_BIONIC 3 > +#endif > +#ifndef LIBC_MUSL > +# define LIBC_MUSL 4 > +#endif > +#ifndef DEFAULT_LIBC > +# define DEFAULT_LIBC LIBC_GLIBC > +#endif > +#ifndef ANDROID_DEFAULT > +# define ANDROID_DEFAULT 0 > +#endif > +#ifdef IN_GCC > +# include "options.h" > +# include "insn-constants.h" > +# include "config/vxworks-dummy.h" > +# include "config/i386/biarch64.h" > +# include "config/i386/i386.h" > +# include "config/i386/unix.h" > +# include "config/i386/att.h" > +# include "config/dbxelf.h" > +# include "config/elfos.h" > +# include "config/gnu-user.h" > +# include "config/glibc-stdint.h" > +# include "config/i386/x86-64.h" > +# include "config/i386/gnu-user-common.h" > +# include "config/i386/gnu-user64.h" > +# include "config/linux.h" > +# include "config/linux-android.h" > +# include "config/i386/linux-common.h" > +# include "config/i386/linux64.h" > +# include "config/initfini-array.h" > +#endif > +#if defined IN_GCC && !defined GENERATOR_FILE && !defined USED_FOR_TARGET > +# include "insn-flags.h" > +#endif > +#if defined IN_GCC && !defined GENERATOR_FILE > +# include "insn-modes.h" > +#endif > +#if defined IN_GCC && defined GENERATOR_FILE && !defined BITS_PER_UNIT > +#include "machmode.h" > +#endif > +# include "defaults.h" > +#endif /* GCC_TM_H */ > diff --git a/libgcov/include/coretypes.h b/libgcov/include/coretypes.h > new file mode 100644 > index 0000000..8eb33cc > --- /dev/null > +++ b/libgcov/include/coretypes.h > @@ -0,0 +1,376 @@ > +/* GCC core type declarations. > + Copyright (C) 2002-2017 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/>. */ > + > +/* Provide forward declarations of core types which are referred to by > + most of the compiler. This allows header files to use these types > + (e.g. in function prototypes) without concern for whether the full > + definitions are visible. Some other declarations that need to be > + universally visible are here, too. > + > + In the context of tconfig.h, most of these have special definitions > + which prevent them from being used except in further type > + declarations. This is a kludge; the right thing is to avoid > + including the "tm.h" header set in the context of tconfig.h, but > + we're not there yet. */ > + > +#ifndef GCC_CORETYPES_H > +#define GCC_CORETYPES_H > + > +#ifndef GTY > +#define GTY(x) /* nothing - marker for gengtype */ > +#endif > + > +#ifndef USED_FOR_TARGET > + > +typedef int64_t gcov_type; > +typedef uint64_t gcov_type_unsigned; > + > +struct bitmap_head; > +typedef struct bitmap_head *bitmap; > +typedef const struct bitmap_head *const_bitmap; > +struct simple_bitmap_def; > +typedef struct simple_bitmap_def *sbitmap; > +typedef const struct simple_bitmap_def *const_sbitmap; > +struct rtx_def; > +typedef struct rtx_def *rtx; > +typedef const struct rtx_def *const_rtx; > + > +/* Subclasses of rtx_def, using indentation to show the class > + hierarchy, along with the relevant invariant. > + Where possible, keep this list in the same order as in rtl.def. */ > +class rtx_def; > + class rtx_expr_list; /* GET_CODE (X) == EXPR_LIST */ > + class rtx_insn_list; /* GET_CODE (X) == INSN_LIST */ > + class rtx_sequence; /* GET_CODE (X) == SEQUENCE */ > + class rtx_insn; > + class rtx_debug_insn; /* DEBUG_INSN_P (X) */ > + class rtx_nonjump_insn; /* NONJUMP_INSN_P (X) */ > + class rtx_jump_insn; /* JUMP_P (X) */ > + class rtx_call_insn; /* CALL_P (X) */ > + class rtx_jump_table_data; /* JUMP_TABLE_DATA_P (X) */ > + class rtx_barrier; /* BARRIER_P (X) */ > + class rtx_code_label; /* LABEL_P (X) */ > + class rtx_note; /* NOTE_P (X) */ > + > +struct rtvec_def; > +typedef struct rtvec_def *rtvec; > +typedef const struct rtvec_def *const_rtvec; > +struct hwivec_def; > +typedef struct hwivec_def *hwivec; > +typedef const struct hwivec_def *const_hwivec; > +union tree_node; > +typedef union tree_node *tree; > +typedef const union tree_node *const_tree; > +struct gimple; > +typedef gimple *gimple_seq; > +struct gimple_stmt_iterator; > + > +/* Forward decls for leaf gimple subclasses (for individual gimple codes). > + Keep this in the same order as the corresponding codes in gimple.def. */ > + > +struct gcond; > +struct gdebug; > +struct ggoto; > +struct glabel; > +struct gswitch; > +struct gassign; > +struct gasm; > +struct gcall; > +struct gtransaction; > +struct greturn; > +struct gbind; > +struct gcatch; > +struct geh_filter; > +struct geh_mnt; > +struct geh_else; > +struct gresx; > +struct geh_dispatch; > +struct gphi; > +struct gtry; > +struct gomp_atomic_load; > +struct gomp_atomic_store; > +struct gomp_continue; > +struct gomp_critical; > +struct gomp_ordered; > +struct gomp_for; > +struct gomp_parallel; > +struct gomp_task; > +struct gomp_sections; > +struct gomp_single; > +struct gomp_target; > +struct gomp_teams; > + > +union section; > +typedef union section section; > +struct gcc_options; > +struct cl_target_option; > +struct cl_optimization; > +struct cl_option; > +struct cl_decoded_option; > +struct cl_option_handlers; > +struct diagnostic_context; > +struct pretty_printer; > + > +/* Address space number for named address space support. */ > +typedef unsigned char addr_space_t; > + > +/* The value of addr_space_t that represents the generic address space. */ > +#define ADDR_SPACE_GENERIC 0 > +#define ADDR_SPACE_GENERIC_P(AS) ((AS) == ADDR_SPACE_GENERIC) > + > +/* The major intermediate representations of GCC. */ > +enum ir_type { > + IR_GIMPLE, > + IR_RTL_CFGRTL, > + IR_RTL_CFGLAYOUT > +}; > + > +/* Provide forward struct declaration so that we don't have to include > + all of cpplib.h whenever a random prototype includes a pointer. > + Note that the cpp_reader and cpp_token typedefs remain part of > + cpplib.h. */ > + > +struct cpp_reader; > +struct cpp_token; > + > +/* The thread-local storage model associated with a given VAR_DECL > + or SYMBOL_REF. This isn't used much, but both trees and RTL refer > + to it, so it's here. */ > +enum tls_model { > + TLS_MODEL_NONE, > + TLS_MODEL_EMULATED, > + TLS_MODEL_REAL, > + TLS_MODEL_GLOBAL_DYNAMIC = TLS_MODEL_REAL, > + TLS_MODEL_LOCAL_DYNAMIC, > + TLS_MODEL_INITIAL_EXEC, > + TLS_MODEL_LOCAL_EXEC > +}; > + > +/* Types of ABI for an offload compiler. */ > +enum offload_abi { > + OFFLOAD_ABI_UNSET, > + OFFLOAD_ABI_LP64, > + OFFLOAD_ABI_ILP32 > +}; > + > +/* Types of profile update methods. */ > +enum profile_update { > + PROFILE_UPDATE_SINGLE, > + PROFILE_UPDATE_ATOMIC, > + PROFILE_UPDATE_PREFER_ATOMIC > +}; > + > +/* Types of unwind/exception handling info that can be generated. */ > + > +enum unwind_info_type > +{ > + UI_NONE, > + UI_SJLJ, > + UI_DWARF2, > + UI_TARGET, > + UI_SEH > +}; > + > +/* Callgraph node profile representation. */ > +enum node_frequency { > + /* This function most likely won't be executed at all. > + (set only when profile feedback is available or via function > attribute). */ > + NODE_FREQUENCY_UNLIKELY_EXECUTED, > + /* For functions that are known to be executed once (i.e. constructors, > destructors > + and main function. */ > + NODE_FREQUENCY_EXECUTED_ONCE, > + /* The default value. */ > + NODE_FREQUENCY_NORMAL, > + /* Optimize this function hard > + (set only when profile feedback is available or via function > attribute). */ > + NODE_FREQUENCY_HOT > +}; > + > +/* Ways of optimizing code. */ > +enum optimization_type { > + /* Prioritize speed over size. */ > + OPTIMIZE_FOR_SPEED, > + > + /* Only do things that are good for both size and speed. */ > + OPTIMIZE_FOR_BOTH, > + > + /* Prioritize size over speed. */ > + OPTIMIZE_FOR_SIZE > +}; > + > +/* Possible initialization status of a variable. When requested > + by the user, this information is tracked and recorded in the DWARF > + debug information, along with the variable's location. */ > +enum var_init_status > +{ > + VAR_INIT_STATUS_UNKNOWN, > + VAR_INIT_STATUS_UNINITIALIZED, > + VAR_INIT_STATUS_INITIALIZED > +}; > + > +/* Names for the different levels of -Wstrict-overflow=N. The numeric > + values here correspond to N. */ > +enum warn_strict_overflow_code > +{ > + /* Overflow warning that should be issued with -Wall: a questionable > + construct that is easy to avoid even when using macros. Example: > + folding (x + CONSTANT > x) to 1. */ > + WARN_STRICT_OVERFLOW_ALL = 1, > + /* Overflow warning about folding a comparison to a constant because > + of undefined signed overflow, other than cases covered by > + WARN_STRICT_OVERFLOW_ALL. Example: folding (abs (x) >= 0) to 1 > + (this is false when x == INT_MIN). */ > + WARN_STRICT_OVERFLOW_CONDITIONAL = 2, > + /* Overflow warning about changes to comparisons other than folding > + them to a constant. Example: folding (x + 1 > 1) to (x > 0). */ > + WARN_STRICT_OVERFLOW_COMPARISON = 3, > + /* Overflow warnings not covered by the above cases. Example: > + folding ((x * 10) / 5) to (x * 2). */ > + WARN_STRICT_OVERFLOW_MISC = 4, > + /* Overflow warnings about reducing magnitude of constants in > + comparison. Example: folding (x + 2 > y) to (x + 1 >= y). */ > + WARN_STRICT_OVERFLOW_MAGNITUDE = 5 > +}; > + > +/* The type of an alias set. Code currently assumes that variables of > + this type can take the values 0 (the alias set which aliases > + everything) and -1 (sometimes indicating that the alias set is > + unknown, sometimes indicating a memory barrier) and -2 (indicating > + that the alias set should be set to a unique value but has not been > + set yet). */ > +typedef int alias_set_type; > + > +struct edge_def; > +typedef struct edge_def *edge; > +typedef const struct edge_def *const_edge; > +struct basic_block_def; > +typedef struct basic_block_def *basic_block; > +typedef const struct basic_block_def *const_basic_block; > + > +#if !defined (GENERATOR_FILE) > +# define OBSTACK_CHUNK_SIZE memory_block_pool::block_size > +# define obstack_chunk_alloc mempool_obstack_chunk_alloc > +# define obstack_chunk_free mempool_obstack_chunk_free > +#else > +# define OBSTACK_CHUNK_SIZE 0 > +# define obstack_chunk_alloc xmalloc > +# define obstack_chunk_free free > +#endif > + > +#define gcc_obstack_init(OBSTACK) \ > + obstack_specify_allocation ((OBSTACK), OBSTACK_CHUNK_SIZE, 0, \ > + obstack_chunk_alloc, \ > + obstack_chunk_free) > + > +/* enum reg_class is target specific, so it should not appear in > + target-independent code or interfaces, like the target hook declarations > + in target.h. */ > +typedef int reg_class_t; > + > +class rtl_opt_pass; > + > +namespace gcc { > + class context; > +} > + > +typedef std::pair <tree, tree> tree_pair; > + > +#else > + > +struct _dont_use_rtx_here_; > +struct _dont_use_rtvec_here_; > +struct _dont_use_rtx_insn_here_; > +union _dont_use_tree_here_; > +#define rtx struct _dont_use_rtx_here_ * > +#define const_rtx struct _dont_use_rtx_here_ * > +#define rtvec struct _dont_use_rtvec_here * > +#define const_rtvec struct _dont_use_rtvec_here * > +#define rtx_insn struct _dont_use_rtx_insn_here_ > +#define tree union _dont_use_tree_here_ * > +#define const_tree union _dont_use_tree_here_ * > + > +#endif > + > +/* Classes of functions that compiler needs to check > + whether they are present at the runtime or not. */ > +enum function_class { > + function_c94, > + function_c99_misc, > + function_c99_math_complex, > + function_sincos, > + function_c11_misc > +}; > + > +/* Enumerate visibility settings. This is deliberately ordered from most > + to least visibility. */ > +enum symbol_visibility > +{ > + VISIBILITY_DEFAULT, > + VISIBILITY_PROTECTED, > + VISIBILITY_HIDDEN, > + VISIBILITY_INTERNAL > +}; > + > +/* enums used by the targetm.excess_precision hook. */ > + > +enum flt_eval_method > +{ > + FLT_EVAL_METHOD_UNPREDICTABLE = -1, > + FLT_EVAL_METHOD_PROMOTE_TO_FLOAT = 0, > + FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE = 1, > + FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE = 2, > + FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16 = 16 > +}; > + > +enum excess_precision_type > +{ > + EXCESS_PRECISION_TYPE_IMPLICIT, > + EXCESS_PRECISION_TYPE_STANDARD, > + EXCESS_PRECISION_TYPE_FAST > +}; > + > +/* Support for user-provided GGC and PCH markers. The first parameter > + is a pointer to a pointer, the second a cookie. */ > +typedef void (*gt_pointer_operator) (void *, void *); > + > +#if !defined (HAVE_UCHAR) > +typedef unsigned char uchar; > +#endif > + > +/* Most host source files will require the following headers. */ > +#if !defined (GENERATOR_FILE) && !defined (USED_FOR_TARGET) > +#include "machmode.h" > +#include "signop.h" > +#include "wide-int.h" > +#include "double-int.h" > +#include "real.h" > +#include "fixed-value.h" > +#include "hash-table.h" > +#include "hash-set.h" > +#include "input.h" > +#include "is-a.h" > +#include "memory-block.h" > +#endif /* GENERATOR_FILE && !USED_FOR_TARGET */ > + > +#endif /* coretypes.h */ > diff --git a/libgcov/include/defaults.h b/libgcov/include/defaults.h > new file mode 100644 > index 0000000..7ad92d9 > --- /dev/null > +++ b/libgcov/include/defaults.h > @@ -0,0 +1,1478 @@ > +/* Definitions of various defaults for tm.h macros. > + Copyright (C) 1992-2017 Free Software Foundation, Inc. > + Contributed by Ron Guilmette (rfg@xxxxxxxxxxx) > + > +This file is part of GCC. > + > +GCC is free software; you can redistribute it and/or modify it under > +the terms of the GNU General Public License as published by the Free > +Software Foundation; either version 3, or (at your option) any later > +version. > + > +GCC is distributed in the hope that it will be useful, but WITHOUT ANY > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > +for more details. > + > +Under Section 7 of GPL version 3, you are granted additional > +permissions described in the GCC Runtime Library Exception, version > +3.1, as published by the Free Software Foundation. > + > +You should have received a copy of the GNU General Public License and > +a copy of the GCC Runtime Library Exception along with this program; > +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +<http://www.gnu.org/licenses/>. */ > + > +#ifndef GCC_DEFAULTS_H > +#define GCC_DEFAULTS_H > + > +/* How to start an assembler comment. */ > +#ifndef ASM_COMMENT_START > +#define ASM_COMMENT_START ";#" > +#endif > + > +/* Store in OUTPUT a string (made with alloca) containing an > + assembler-name for a local static variable or function named NAME. > + LABELNO is an integer which is different for each call. */ > + > +#ifndef ASM_PN_FORMAT > +# ifndef NO_DOT_IN_LABEL > +# define ASM_PN_FORMAT "%s.%lu" > +# else > +# ifndef NO_DOLLAR_IN_LABEL > +# define ASM_PN_FORMAT "%s$%lu" > +# else > +# define ASM_PN_FORMAT "__%s_%lu" > +# endif > +# endif > +#endif /* ! ASM_PN_FORMAT */ > + > +#ifndef ASM_FORMAT_PRIVATE_NAME > +# define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ > + do { const char *const name_ = (NAME); \ > + char *const output_ = (OUTPUT) = \ > + (char *) alloca (strlen (name_) + 32); \ > + sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \ > + } while (0) > +#endif > + > +/* Choose a reasonable default for ASM_OUTPUT_ASCII. */ > + > +#ifndef ASM_OUTPUT_ASCII > +#define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ > + do { > \ > + FILE *_hide_asm_out_file = (MYFILE); \ > + const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); > \ > + int _hide_thissize = (MYLENGTH); \ > + { > \ > + FILE *asm_out_file = _hide_asm_out_file; > \ > + const unsigned char *p = _hide_p; > \ > + int thissize = _hide_thissize; \ > + int i; \ > + fprintf (asm_out_file, "\t.ascii \""); \ > + \ > + for (i = 0; i < thissize; i++) \ > + { \ > + int c = p[i]; \ > + if (c == '\"' || c == '\\') \ > + putc ('\\', asm_out_file); \ > + if (ISPRINT (c)) \ > + putc (c, asm_out_file); \ > + else \ > + { \ > + fprintf (asm_out_file, "\\%o", c); \ > + /* After an octal-escape, if a digit follows, \ > + terminate one string constant and start another. \ > + The VAX assembler fails to stop reading the escape \ > + after three digits, so this is the only way we \ > + can get it to parse the data properly. */ \ > + if (i < thissize - 1 && ISDIGIT (p[i + 1])) \ > + fprintf (asm_out_file, "\"\n\t.ascii \""); \ > + } \ > + } \ > + fprintf (asm_out_file, "\"\n"); > \ > + } > \ > + } \ > + while (0) > +#endif > + > +/* This is how we tell the assembler to equate two values. */ > +#ifdef SET_ASM_OP > +#ifndef ASM_OUTPUT_DEF > +#define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \ > + do { fprintf ((FILE), "%s", SET_ASM_OP); > \ > + assemble_name (FILE, LABEL1); \ > + fprintf (FILE, ","); \ > + assemble_name (FILE, LABEL2); \ > + fprintf (FILE, "\n"); \ > + } while (0) > +#endif > +#endif > + > +#ifndef IFUNC_ASM_TYPE > +#define IFUNC_ASM_TYPE "gnu_indirect_function" > +#endif > + > +#ifndef TLS_COMMON_ASM_OP > +#define TLS_COMMON_ASM_OP ".tls_common" > +#endif > + > +#if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON) > +#define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE) > \ > + do \ > + { > \ > + fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP); \ > + assemble_name ((FILE), (NAME)); > \ > + fprintf ((FILE), "," HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", > \ > + (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT); \ > + } > \ > + while (0) > +#endif > + > +/* Decide whether to defer emitting the assembler output for an equate > + of two values. The default is to not defer output. */ > +#ifndef TARGET_DEFERRED_OUTPUT_DEFS > +#define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false > +#endif > + > +/* This is how to output the definition of a user-level label named > + NAME, such as the label on variable NAME. */ > + > +#ifndef ASM_OUTPUT_LABEL > +#define ASM_OUTPUT_LABEL(FILE,NAME) \ > + do { \ > + assemble_name ((FILE), (NAME)); \ > + fputs (":\n", (FILE)); \ > + } while (0) > +#endif > + > +/* This is how to output the definition of a user-level label named > + NAME, such as the label on a function. */ > + > +#ifndef ASM_OUTPUT_FUNCTION_LABEL > +#define ASM_OUTPUT_FUNCTION_LABEL(FILE, NAME, DECL) \ > + ASM_OUTPUT_LABEL ((FILE), (NAME)) > +#endif > + > +/* Output the definition of a compiler-generated label named NAME. */ > +#ifndef ASM_OUTPUT_INTERNAL_LABEL > +#define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME) \ > + do { \ > + assemble_name_raw ((FILE), (NAME)); \ > + fputs (":\n", (FILE)); \ > + } while (0) > +#endif > + > +/* This is how to output a reference to a user-level label named NAME. */ > + > +#ifndef ASM_OUTPUT_LABELREF > +#define ASM_OUTPUT_LABELREF(FILE,NAME) \ > + do { \ > + fputs (user_label_prefix, (FILE)); \ > + fputs ((NAME), (FILE)); \ > + } while (0); > +#endif > + > +/* Allow target to print debug info labels specially. This is useful for > + VLIW targets, since debug info labels should go into the middle of > + instruction bundles instead of breaking them. */ > + > +#ifndef ASM_OUTPUT_DEBUG_LABEL > +#define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \ > + (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM) > +#endif > + > +/* This is how we tell the assembler that a symbol is weak. */ > +#ifndef ASM_OUTPUT_WEAK_ALIAS > +#if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF) > +#define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE) \ > + do \ > + { \ > + ASM_WEAKEN_LABEL (STREAM, NAME); \ > + if (VALUE) \ > + ASM_OUTPUT_DEF (STREAM, NAME, VALUE); \ > + } \ > + while (0) > +#endif > +#endif > + > +/* This is how we tell the assembler that a symbol is a weak alias to > + another symbol that doesn't require the other symbol to be defined. > + Uses of the former will turn into weak uses of the latter, i.e., > + uses that, in case the latter is undefined, will not cause errors, > + and will add it to the symbol table as weak undefined. However, if > + the latter is referenced directly, a strong reference prevails. */ > +#ifndef ASM_OUTPUT_WEAKREF > +#if defined HAVE_GAS_WEAKREF > +#define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE) \ > + do \ > + { > \ > + fprintf ((FILE), "\t.weakref\t"); > \ > + assemble_name ((FILE), (NAME)); > \ > + fprintf ((FILE), ","); \ > + assemble_name ((FILE), (VALUE)); > \ > + fprintf ((FILE), "\n"); > \ > + } > \ > + while (0) > +#endif > +#endif > + > +/* How to emit a .type directive. */ > +#ifndef ASM_OUTPUT_TYPE_DIRECTIVE > +#if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT > +#define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE) \ > + do \ > + { \ > + fputs (TYPE_ASM_OP, STREAM); \ > + assemble_name (STREAM, NAME); \ > + fputs (", ", STREAM); \ > + fprintf (STREAM, TYPE_OPERAND_FMT, TYPE); \ > + putc ('\n', STREAM); \ > + } \ > + while (0) > +#endif > +#endif > + > +/* How to emit a .size directive. */ > +#ifndef ASM_OUTPUT_SIZE_DIRECTIVE > +#ifdef SIZE_ASM_OP > +#define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE) \ > + do \ > + { \ > + HOST_WIDE_INT size_ = (SIZE); \ > + fputs (SIZE_ASM_OP, STREAM); \ > + assemble_name (STREAM, NAME); \ > + fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \ > + } \ > + while (0) > + > +#define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME) \ > + do \ > + { \ > + fputs (SIZE_ASM_OP, STREAM); \ > + assemble_name (STREAM, NAME); \ > + fputs (", .-", STREAM); \ > + assemble_name (STREAM, NAME); \ > + putc ('\n', STREAM); \ > + } \ > + while (0) > + > +#endif > +#endif > + > +/* This determines whether or not we support weak symbols. SUPPORTS_WEAK > + must be a preprocessor constant. */ > +#ifndef SUPPORTS_WEAK > +#if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) > +#define SUPPORTS_WEAK 1 > +#else > +#define SUPPORTS_WEAK 0 > +#endif > +#endif > + > +/* This determines whether or not we support weak symbols during target > + code generation. TARGET_SUPPORTS_WEAK can be any valid C expression. */ > +#ifndef TARGET_SUPPORTS_WEAK > +#define TARGET_SUPPORTS_WEAK (SUPPORTS_WEAK) > +#endif > + > +/* This determines whether or not we support the discriminator > + attribute in the .loc directive. */ > +#ifndef SUPPORTS_DISCRIMINATOR > +#ifdef HAVE_GAS_DISCRIMINATOR > +#define SUPPORTS_DISCRIMINATOR 1 > +#else > +#define SUPPORTS_DISCRIMINATOR 0 > +#endif > +#endif > + > +/* This determines whether or not we support link-once semantics. */ > +#ifndef SUPPORTS_ONE_ONLY > +#ifdef MAKE_DECL_ONE_ONLY > +#define SUPPORTS_ONE_ONLY 1 > +#else > +#define SUPPORTS_ONE_ONLY 0 > +#endif > +#endif > + > +/* This determines whether weak symbols must be left out of a static > + archive's table of contents. Defining this macro to be nonzero has > + the consequence that certain symbols will not be made weak that > + otherwise would be. The C++ ABI requires this macro to be zero; > + see the documentation. */ > +#ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC > +#define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0 > +#endif > + > +/* This determines whether or not we need linkonce unwind information. */ > +#ifndef TARGET_USES_WEAK_UNWIND_INFO > +#define TARGET_USES_WEAK_UNWIND_INFO 0 > +#endif > + > +/* By default, there is no prefix on user-defined symbols. */ > +#ifndef USER_LABEL_PREFIX > +#define USER_LABEL_PREFIX "" > +#endif > + > +/* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to > + provide a weak attribute. Else define it to nothing. > + > + This would normally belong in ansidecl.h, but SUPPORTS_WEAK is > + not available at that time. > + > + Note, this is only for use by target files which we know are to be > + compiled by GCC. */ > +#ifndef TARGET_ATTRIBUTE_WEAK > +# if SUPPORTS_WEAK > +# define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak)) > +# else > +# define TARGET_ATTRIBUTE_WEAK > +# endif > +#endif > + > +/* By default we can assume that all global symbols are in one namespace, > + across all shared libraries. */ > +#ifndef MULTIPLE_SYMBOL_SPACES > +# define MULTIPLE_SYMBOL_SPACES 0 > +#endif > + > +/* If the target supports init_priority C++ attribute, give > + SUPPORTS_INIT_PRIORITY a nonzero value. */ > +#ifndef SUPPORTS_INIT_PRIORITY > +#define SUPPORTS_INIT_PRIORITY 1 > +#endif /* SUPPORTS_INIT_PRIORITY */ > + > +/* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that > + the rest of the DWARF 2 frame unwind support is also provided. */ > +#if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) > +#define DWARF2_UNWIND_INFO 1 > +#endif > + > +/* If we have named sections, and we're using crtstuff to run ctors, > + use them for registering eh frame information. */ > +#if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ > + && !defined (EH_FRAME_THROUGH_COLLECT2) > +#ifndef EH_FRAME_SECTION_NAME > +#define EH_FRAME_SECTION_NAME ".eh_frame" > +#endif > +#endif > + > +/* On many systems, different EH table encodings are used under > + difference circumstances. Some will require runtime relocations; > + some will not. For those that do not require runtime relocations, > + we would like to make the table read-only. However, since the > + read-only tables may need to be combined with read-write tables > + that do require runtime relocation, it is not safe to make the > + tables read-only unless the linker will merge read-only and > + read-write sections into a single read-write section. If your > + linker does not have this ability, but your system is such that no > + encoding used with non-PIC code will ever require a runtime > + relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in > + your target configuration file. */ > +#ifndef EH_TABLES_CAN_BE_READ_ONLY > +#ifdef HAVE_LD_RO_RW_SECTION_MIXING > +#define EH_TABLES_CAN_BE_READ_ONLY 1 > +#else > +#define EH_TABLES_CAN_BE_READ_ONLY 0 > +#endif > +#endif > + > +/* Provide defaults for stuff that may not be defined when using > + sjlj exceptions. */ > +#ifndef EH_RETURN_DATA_REGNO > +#define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM > +#endif > + > +/* Offset between the eh handler address and entry in eh tables. */ > +#ifndef RETURN_ADDR_OFFSET > +#define RETURN_ADDR_OFFSET 0 > +#endif > + > +#ifndef MASK_RETURN_ADDR > +#define MASK_RETURN_ADDR NULL_RTX > +#endif > + > +/* Number of hardware registers that go into the DWARF-2 unwind info. > + If not defined, equals FIRST_PSEUDO_REGISTER */ > + > +#ifndef DWARF_FRAME_REGISTERS > +#define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER > +#endif > + > +/* Offsets recorded in opcodes are a multiple of this alignment factor. */ > +#ifndef DWARF_CIE_DATA_ALIGNMENT > +#ifdef STACK_GROWS_DOWNWARD > +#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) > +#else > +#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) > +#endif > +#endif > + > +/* The DWARF 2 CFA column which tracks the return address. Normally this > + is the column for PC, or the first column after all of the hard > + registers. */ > +#ifndef DWARF_FRAME_RETURN_COLUMN > +#ifdef PC_REGNUM > +#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) > +#else > +#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS > +#endif > +#endif > + > +/* How to renumber registers for dbx and gdb. If not defined, assume > + no renumbering is necessary. */ > + > +#ifndef DBX_REGISTER_NUMBER > +#define DBX_REGISTER_NUMBER(REGNO) (REGNO) > +#endif > + > +/* The mapping from gcc register number to DWARF 2 CFA column number. > + By default, we just provide columns for all registers. */ > +#ifndef DWARF_FRAME_REGNUM > +#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) > +#endif > + > +/* The mapping from dwarf CFA reg number to internal dwarf reg numbers. */ > +#ifndef DWARF_REG_TO_UNWIND_COLUMN > +#define DWARF_REG_TO_UNWIND_COLUMN(REGNO) (REGNO) > +#endif > + > +/* Map register numbers held in the call frame info that gcc has > + collected using DWARF_FRAME_REGNUM to those that should be output in > + .debug_frame and .eh_frame. */ > +#ifndef DWARF2_FRAME_REG_OUT > +#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) > +#endif > + > +/* The size of addresses as they appear in the Dwarf 2 data. > + Some architectures use word addresses to refer to code locations, > + but Dwarf 2 info always uses byte addresses. On such machines, > + Dwarf 2 addresses need to be larger than the architecture's > + pointers. */ > +#ifndef DWARF2_ADDR_SIZE > +#define DWARF2_ADDR_SIZE ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT) > +#endif > + > +/* The size in bytes of a DWARF field indicating an offset or length > + relative to a debug info section, specified to be 4 bytes in the > + DWARF-2 specification. The SGI/MIPS ABI defines it to be the same > + as PTR_SIZE. */ > +#ifndef DWARF_OFFSET_SIZE > +#define DWARF_OFFSET_SIZE 4 > +#endif > + > +/* The size in bytes of a DWARF 4 type signature. */ > +#ifndef DWARF_TYPE_SIGNATURE_SIZE > +#define DWARF_TYPE_SIGNATURE_SIZE 8 > +#endif > + > +/* Default sizes for base C types. If the sizes are different for > + your target, you should override these values by defining the > + appropriate symbols in your tm.h file. */ > + > +#ifndef BITS_PER_WORD > +#define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD) > +#endif > + > +#ifndef CHAR_TYPE_SIZE > +#define CHAR_TYPE_SIZE BITS_PER_UNIT > +#endif > + > +#ifndef BOOL_TYPE_SIZE > +/* `bool' has size and alignment `1', on almost all platforms. */ > +#define BOOL_TYPE_SIZE CHAR_TYPE_SIZE > +#endif > + > +#ifndef SHORT_TYPE_SIZE > +#define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) > +#endif > + > +#ifndef INT_TYPE_SIZE > +#define INT_TYPE_SIZE BITS_PER_WORD > +#endif > + > +#ifndef LONG_TYPE_SIZE > +#define LONG_TYPE_SIZE BITS_PER_WORD > +#endif > + > +#ifndef LONG_LONG_TYPE_SIZE > +#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) > +#endif > + > +#ifndef WCHAR_TYPE_SIZE > +#define WCHAR_TYPE_SIZE INT_TYPE_SIZE > +#endif > + > +#ifndef FLOAT_TYPE_SIZE > +#define FLOAT_TYPE_SIZE BITS_PER_WORD > +#endif > + > +#ifndef DOUBLE_TYPE_SIZE > +#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) > +#endif > + > +#ifndef LONG_DOUBLE_TYPE_SIZE > +#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) > +#endif > + > +#ifndef DECIMAL32_TYPE_SIZE > +#define DECIMAL32_TYPE_SIZE 32 > +#endif > + > +#ifndef DECIMAL64_TYPE_SIZE > +#define DECIMAL64_TYPE_SIZE 64 > +#endif > + > +#ifndef DECIMAL128_TYPE_SIZE > +#define DECIMAL128_TYPE_SIZE 128 > +#endif > + > +#ifndef SHORT_FRACT_TYPE_SIZE > +#define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT > +#endif > + > +#ifndef FRACT_TYPE_SIZE > +#define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2) > +#endif > + > +#ifndef LONG_FRACT_TYPE_SIZE > +#define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4) > +#endif > + > +#ifndef LONG_LONG_FRACT_TYPE_SIZE > +#define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8) > +#endif > + > +#ifndef SHORT_ACCUM_TYPE_SIZE > +#define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2) > +#endif > + > +#ifndef ACCUM_TYPE_SIZE > +#define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2) > +#endif > + > +#ifndef LONG_ACCUM_TYPE_SIZE > +#define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2) > +#endif > + > +#ifndef LONG_LONG_ACCUM_TYPE_SIZE > +#define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2) > +#endif > + > +/* We let tm.h override the types used here, to handle trivial differences > + such as the choice of unsigned int or long unsigned int for size_t. > + When machines start needing nontrivial differences in the size type, > + it would be best to do something here to figure out automatically > + from other information what type to use. */ > + > +#ifndef SIZE_TYPE > +#define SIZE_TYPE "long unsigned int" > +#endif > + > +#ifndef SIZETYPE > +#define SIZETYPE SIZE_TYPE > +#endif > + > +#ifndef PID_TYPE > +#define PID_TYPE "int" > +#endif > + > +/* If GCC knows the exact uint_least16_t and uint_least32_t types from > + <stdint.h>, use them for char16_t and char32_t. Otherwise, use > + these guesses; getting the wrong type of a given width will not > + affect C++ name mangling because in C++ these are distinct types > + not typedefs. */ > + > +#ifdef UINT_LEAST16_TYPE > +#define CHAR16_TYPE UINT_LEAST16_TYPE > +#else > +#define CHAR16_TYPE "short unsigned int" > +#endif > + > +#ifdef UINT_LEAST32_TYPE > +#define CHAR32_TYPE UINT_LEAST32_TYPE > +#else > +#define CHAR32_TYPE "unsigned int" > +#endif > + > +#ifndef WCHAR_TYPE > +#define WCHAR_TYPE "int" > +#endif > + > +/* WCHAR_TYPE gets overridden by -fshort-wchar. */ > +#define MODIFIED_WCHAR_TYPE \ > + (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE) > + > +#ifndef PTRDIFF_TYPE > +#define PTRDIFF_TYPE "long int" > +#endif > + > +#ifndef WINT_TYPE > +#define WINT_TYPE "unsigned int" > +#endif > + > +#ifndef INTMAX_TYPE > +#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ > + ? "int" \ > + : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ > + ? "long int" \ > + : "long long int")) > +#endif > + > +#ifndef UINTMAX_TYPE > +#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ > + ? "unsigned int" \ > + : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ > + ? "long unsigned int" \ > + : "long long unsigned int")) > +#endif > + > + > +/* There are no default definitions of these <stdint.h> types. */ > + > +#ifndef SIG_ATOMIC_TYPE > +#define SIG_ATOMIC_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT8_TYPE > +#define INT8_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT16_TYPE > +#define INT16_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT32_TYPE > +#define INT32_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT64_TYPE > +#define INT64_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT8_TYPE > +#define UINT8_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT16_TYPE > +#define UINT16_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT32_TYPE > +#define UINT32_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT64_TYPE > +#define UINT64_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_LEAST8_TYPE > +#define INT_LEAST8_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_LEAST16_TYPE > +#define INT_LEAST16_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_LEAST32_TYPE > +#define INT_LEAST32_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_LEAST64_TYPE > +#define INT_LEAST64_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_LEAST8_TYPE > +#define UINT_LEAST8_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_LEAST16_TYPE > +#define UINT_LEAST16_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_LEAST32_TYPE > +#define UINT_LEAST32_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_LEAST64_TYPE > +#define UINT_LEAST64_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_FAST8_TYPE > +#define INT_FAST8_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_FAST16_TYPE > +#define INT_FAST16_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_FAST32_TYPE > +#define INT_FAST32_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INT_FAST64_TYPE > +#define INT_FAST64_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_FAST8_TYPE > +#define UINT_FAST8_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_FAST16_TYPE > +#define UINT_FAST16_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_FAST32_TYPE > +#define UINT_FAST32_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINT_FAST64_TYPE > +#define UINT_FAST64_TYPE ((const char *) NULL) > +#endif > + > +#ifndef INTPTR_TYPE > +#define INTPTR_TYPE ((const char *) NULL) > +#endif > + > +#ifndef UINTPTR_TYPE > +#define UINTPTR_TYPE ((const char *) NULL) > +#endif > + > +/* Width in bits of a pointer. Mind the value of the macro `Pmode'. */ > +#ifndef POINTER_SIZE > +#define POINTER_SIZE BITS_PER_WORD > +#endif > +#ifndef POINTER_SIZE_UNITS > +#define POINTER_SIZE_UNITS ((POINTER_SIZE + BITS_PER_UNIT - 1) / > BITS_PER_UNIT) > +#endif > + > + > +#ifndef PIC_OFFSET_TABLE_REGNUM > +#define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM > +#endif > + > +#ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED > +#define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED 0 > +#endif > + > +#ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES > +#define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0 > +#endif > + > +#ifndef TARGET_DECLSPEC > +#if TARGET_DLLIMPORT_DECL_ATTRIBUTES > +/* If the target supports the "dllimport" attribute, users are > + probably used to the "__declspec" syntax. */ > +#define TARGET_DECLSPEC 1 > +#else > +#define TARGET_DECLSPEC 0 > +#endif > +#endif > + > +/* By default, the preprocessor should be invoked the same way in C++ > + as in C. */ > +#ifndef CPLUSPLUS_CPP_SPEC > +#ifdef CPP_SPEC > +#define CPLUSPLUS_CPP_SPEC CPP_SPEC > +#endif > +#endif > + > +#ifndef ACCUMULATE_OUTGOING_ARGS > +#define ACCUMULATE_OUTGOING_ARGS 0 > +#endif > + > +/* By default, use the GNU runtime for Objective C. */ > +#ifndef NEXT_OBJC_RUNTIME > +#define NEXT_OBJC_RUNTIME 0 > +#endif > + > +/* Supply a default definition for PUSH_ARGS. */ > +#ifndef PUSH_ARGS > +#ifdef PUSH_ROUNDING > +#define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS > +#else > +#define PUSH_ARGS 0 > +#endif > +#endif > + > +/* Decide whether a function's arguments should be processed > + from first to last or from last to first. > + > + They should if the stack and args grow in opposite directions, but > + only if we have push insns. */ > + > +#ifdef PUSH_ROUNDING > + > +#ifndef PUSH_ARGS_REVERSED > +#if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD) > +#define PUSH_ARGS_REVERSED PUSH_ARGS > +#endif > +#endif > + > +#endif > + > +#ifndef PUSH_ARGS_REVERSED > +#define PUSH_ARGS_REVERSED 0 > +#endif > + > +/* Default value for the alignment (in bits) a C conformant malloc has to > + provide. This default is intended to be safe and always correct. */ > +#ifndef MALLOC_ABI_ALIGNMENT > +#define MALLOC_ABI_ALIGNMENT BITS_PER_WORD > +#endif > + > +/* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY. > + STACK_BOUNDARY is required. */ > +#ifndef PREFERRED_STACK_BOUNDARY > +#define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY > +#endif > + > +/* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not > + defined. */ > +#ifndef INCOMING_STACK_BOUNDARY > +#define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY > +#endif > + > +#ifndef TARGET_DEFAULT_PACK_STRUCT > +#define TARGET_DEFAULT_PACK_STRUCT 0 > +#endif > + > +/* By default, the vtable entries are void pointers, the so the alignment > + is the same as pointer alignment. The value of this macro specifies > + the alignment of the vtable entry in bits. It should be defined only > + when special alignment is necessary. */ > +#ifndef TARGET_VTABLE_ENTRY_ALIGN > +#define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE > +#endif > + > +/* There are a few non-descriptor entries in the vtable at offsets below > + zero. If these entries must be padded (say, to preserve the alignment > + specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of > + words in each data entry. */ > +#ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE > +#define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1 > +#endif > + > +/* Decide whether it is safe to use a local alias for a virtual function > + when constructing thunks. */ > +#ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P > +#ifdef ASM_OUTPUT_DEF > +#define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1 > +#else > +#define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0 > +#endif > +#endif > + > +/* Select a format to encode pointers in exception handling data. We > + prefer those that result in fewer dynamic relocations. Assume no > + special support here and encode direct references. */ > +#ifndef ASM_PREFERRED_EH_DATA_FORMAT > +#define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) DW_EH_PE_absptr > +#endif > + > +/* By default, the C++ compiler will use the lowest bit of the pointer > + to function to indicate a pointer-to-member-function points to a > + virtual member function. However, if FUNCTION_BOUNDARY indicates > + function addresses aren't always even, the lowest bit of the delta > + field will be used. */ > +#ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION > +#define TARGET_PTRMEMFUNC_VBIT_LOCATION \ > + (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \ > + ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta) > +#endif > + > +#ifndef DEFAULT_GDB_EXTENSIONS > +#define DEFAULT_GDB_EXTENSIONS 1 > +#endif > + > +#ifndef SDB_DEBUGGING_INFO > +#define SDB_DEBUGGING_INFO 0 > +#endif > + > +/* If more than one debugging type is supported, you must define > + PREFERRED_DEBUGGING_TYPE to choose the default. */ > + > +#if 1 < (defined (DBX_DEBUGGING_INFO) + (SDB_DEBUGGING_INFO) \ > + + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \ > + + defined (VMS_DEBUGGING_INFO)) > +#ifndef PREFERRED_DEBUGGING_TYPE > +#error You must define PREFERRED_DEBUGGING_TYPE > +#endif /* no PREFERRED_DEBUGGING_TYPE */ > + > +/* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE > + here so other code needn't care. */ > +#elif defined DBX_DEBUGGING_INFO > +#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG > + > +#elif SDB_DEBUGGING_INFO > +#define PREFERRED_DEBUGGING_TYPE SDB_DEBUG > + > +#elif defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO > +#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG > + > +#elif defined VMS_DEBUGGING_INFO > +#define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG > + > +#elif defined XCOFF_DEBUGGING_INFO > +#define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG > + > +#else > +/* No debugging format is supported by this target. */ > +#define PREFERRED_DEBUGGING_TYPE NO_DEBUG > +#endif > + > +#ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL > +#define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false > +#endif > + > +/* True if the targets integer-comparison functions return { 0, 1, 2 > + } to indicate { <, ==, > }. False if { -1, 0, 1 } is used > + instead. The libgcc routines are biased. */ > +#ifndef TARGET_LIB_INT_CMP_BIASED > +#define TARGET_LIB_INT_CMP_BIASED (true) > +#endif > + > +/* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files, > + then the word-endianness is the same as for integers. */ > +#ifndef FLOAT_WORDS_BIG_ENDIAN > +#define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN > +#endif > + > +#ifndef REG_WORDS_BIG_ENDIAN > +#define REG_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN > +#endif > + > + > +#ifndef TARGET_DEC_EVAL_METHOD > +#define TARGET_DEC_EVAL_METHOD 2 > +#endif > + > +#ifndef HAS_LONG_COND_BRANCH > +#define HAS_LONG_COND_BRANCH 0 > +#endif > + > +#ifndef HAS_LONG_UNCOND_BRANCH > +#define HAS_LONG_UNCOND_BRANCH 0 > +#endif > + > +/* Determine whether __cxa_atexit, rather than atexit, is used to > + register C++ destructors for local statics and global objects. */ > +#ifndef DEFAULT_USE_CXA_ATEXIT > +#define DEFAULT_USE_CXA_ATEXIT 0 > +#endif > + > +#if GCC_VERSION >= 3000 && defined IN_GCC > +/* These old constraint macros shouldn't appear anywhere in a > + configuration using MD constraint definitions. */ > +#endif > + > +/* Determin whether the target runtime library is Bionic */ > +#ifndef TARGET_HAS_BIONIC > +#define TARGET_HAS_BIONIC 0 > +#endif > + > +/* Indicate that CLZ and CTZ are undefined at zero. */ > +#ifndef CLZ_DEFINED_VALUE_AT_ZERO > +#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 > +#endif > +#ifndef CTZ_DEFINED_VALUE_AT_ZERO > +#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 > +#endif > + > +/* Provide a default value for STORE_FLAG_VALUE. */ > +#ifndef STORE_FLAG_VALUE > +#define STORE_FLAG_VALUE 1 > +#endif > + > +/* This macro is used to determine what the largest unit size that > + move_by_pieces can use is. */ > + > +/* MOVE_MAX_PIECES is the number of bytes at a time which we can > + move efficiently, as opposed to MOVE_MAX which is the maximum > + number of bytes we can move with a single instruction. */ > + > +#ifndef MOVE_MAX_PIECES > +#define MOVE_MAX_PIECES MOVE_MAX > +#endif > + > +/* STORE_MAX_PIECES is the number of bytes at a time that we can > + store efficiently. Due to internal GCC limitations, this is > + MOVE_MAX_PIECES limited by the number of bytes GCC can represent > + for an immediate constant. */ > + > +#ifndef STORE_MAX_PIECES > +#define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT)) > +#endif > + > +/* Likewise for block comparisons. */ > +#ifndef COMPARE_MAX_PIECES > +#define COMPARE_MAX_PIECES MOVE_MAX_PIECES > +#endif > + > +#ifndef MAX_MOVE_MAX > +#define MAX_MOVE_MAX MOVE_MAX > +#endif > + > +#ifndef MIN_UNITS_PER_WORD > +#define MIN_UNITS_PER_WORD UNITS_PER_WORD > +#endif > + > +#ifndef MAX_BITS_PER_WORD > +#define MAX_BITS_PER_WORD BITS_PER_WORD > +#endif > + > +#ifndef STACK_POINTER_OFFSET > +#define STACK_POINTER_OFFSET 0 > +#endif > + > +#ifndef LOCAL_REGNO > +#define LOCAL_REGNO(REGNO) 0 > +#endif > + > +#ifndef HONOR_REG_ALLOC_ORDER > +#define HONOR_REG_ALLOC_ORDER 0 > +#endif > + > +/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, > + the stack pointer does not matter. The value is tested only in > + functions that have frame pointers. */ > +#ifndef EXIT_IGNORE_STACK > +#define EXIT_IGNORE_STACK 0 > +#endif > + > +/* Assume that case vectors are not pc-relative. */ > +#ifndef CASE_VECTOR_PC_RELATIVE > +#define CASE_VECTOR_PC_RELATIVE 0 > +#endif > + > +/* Force minimum alignment to be able to use the least significant bits > + for distinguishing descriptor addresses from code addresses. */ > +#define FUNCTION_ALIGNMENT(ALIGN) \ > + (lang_hooks.custom_function_descriptors \ > + && targetm.calls.custom_function_descriptors > 0 \ > + ? MAX ((ALIGN), \ > + 2 * targetm.calls.custom_function_descriptors * BITS_PER_UNIT)\ > + : (ALIGN)) > + > +/* Assume that trampolines need function alignment. */ > +#ifndef TRAMPOLINE_ALIGNMENT > +#define TRAMPOLINE_ALIGNMENT FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY) > +#endif > + > +/* Register mappings for target machines without register windows. */ > +#ifndef INCOMING_REGNO > +#define INCOMING_REGNO(N) (N) > +#endif > + > +#ifndef OUTGOING_REGNO > +#define OUTGOING_REGNO(N) (N) > +#endif > + > +#ifndef SHIFT_COUNT_TRUNCATED > +#define SHIFT_COUNT_TRUNCATED 0 > +#endif > + > +#ifndef LEGITIMATE_PIC_OPERAND_P > +#define LEGITIMATE_PIC_OPERAND_P(X) 1 > +#endif > + > +#ifndef TARGET_MEM_CONSTRAINT > +#define TARGET_MEM_CONSTRAINT 'm' > +#endif > + > +#ifndef REVERSIBLE_CC_MODE > +#define REVERSIBLE_CC_MODE(MODE) 0 > +#endif > + > +/* Biggest alignment supported by the object file format of this machine. */ > +#ifndef MAX_OFILE_ALIGNMENT > +#define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT > +#endif > + > +#ifndef FRAME_GROWS_DOWNWARD > +#define FRAME_GROWS_DOWNWARD 0 > +#endif > + > +#ifndef RETURN_ADDR_IN_PREVIOUS_FRAME > +#define RETURN_ADDR_IN_PREVIOUS_FRAME 0 > +#endif > + > +/* On most machines, the CFA coincides with the first incoming parm. */ > +#ifndef ARG_POINTER_CFA_OFFSET > +#define ARG_POINTER_CFA_OFFSET(FNDECL) \ > + (FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size) > +#endif > + > +/* On most machines, we use the CFA as DW_AT_frame_base. */ > +#ifndef CFA_FRAME_BASE_OFFSET > +#define CFA_FRAME_BASE_OFFSET(FNDECL) 0 > +#endif > + > +/* The offset from the incoming value of %sp to the top of the stack frame > + for the current function. */ > +#ifndef INCOMING_FRAME_SP_OFFSET > +#define INCOMING_FRAME_SP_OFFSET 0 > +#endif > + > +#ifndef HARD_REGNO_NREGS_HAS_PADDING > +#define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0 > +#define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1 > +#endif > + > +#ifndef OUTGOING_REG_PARM_STACK_SPACE > +#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0 > +#endif > + > +/* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by > + the backend. MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best > + effort stack alignment supported by the backend. If the backend > + supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and > + MAX_STACK_ALIGNMENT are the same. Otherwise, the incoming stack > + boundary will limit the maximum guaranteed stack alignment. */ > +#ifdef MAX_STACK_ALIGNMENT > +#define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT > +#else > +#define MAX_STACK_ALIGNMENT STACK_BOUNDARY > +#define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY > +#endif > + > +#define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY) > + > +#ifndef LOCAL_ALIGNMENT > +#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT > +#endif > + > +#ifndef STACK_SLOT_ALIGNMENT > +#define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \ > + ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN)) > +#endif > + > +#ifndef LOCAL_DECL_ALIGNMENT > +#define LOCAL_DECL_ALIGNMENT(DECL) \ > + LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL)) > +#endif > + > +#ifndef MINIMUM_ALIGNMENT > +#define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN) > +#endif > + > +/* Alignment value for attribute ((aligned)). */ > +#ifndef ATTRIBUTE_ALIGNED_VALUE > +#define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT > +#endif > + > +#ifndef SLOW_UNALIGNED_ACCESS > +#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT > +#endif > + > +/* For most ports anything that evaluates to a constant symbolic > + or integer value is acceptable as a constant address. */ > +#ifndef CONSTANT_ADDRESS_P > +#define CONSTANT_ADDRESS_P(X) (CONSTANT_P (X) && GET_CODE (X) != > CONST_DOUBLE) > +#endif > + > +#ifndef MAX_FIXED_MODE_SIZE > +#define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) > +#endif > + > +/* Nonzero if structures and unions should be returned in memory. > + > + This should only be defined if compatibility with another compiler or > + with an ABI is needed, because it results in slower code. */ > + > +#ifndef DEFAULT_PCC_STRUCT_RETURN > +#define DEFAULT_PCC_STRUCT_RETURN 1 > +#endif > + > +#ifndef PCC_BITFIELD_TYPE_MATTERS > +#define PCC_BITFIELD_TYPE_MATTERS false > +#endif > + > +#ifndef INSN_SETS_ARE_DELAYED > +#define INSN_SETS_ARE_DELAYED(INSN) false > +#endif > + > +#ifndef INSN_REFERENCES_ARE_DELAYED > +#define INSN_REFERENCES_ARE_DELAYED(INSN) false > +#endif > + > +#ifndef NO_FUNCTION_CSE > +#define NO_FUNCTION_CSE false > +#endif > + > +#ifndef HARD_REGNO_RENAME_OK > +#define HARD_REGNO_RENAME_OK(FROM, TO) true > +#endif > + > +#ifndef EPILOGUE_USES > +#define EPILOGUE_USES(REG) false > +#endif > + > +#ifndef ARGS_GROW_DOWNWARD > +#define ARGS_GROW_DOWNWARD 0 > +#endif > + > +#ifndef STACK_GROWS_DOWNWARD > +#define STACK_GROWS_DOWNWARD 0 > +#endif > + > +#ifndef STACK_PUSH_CODE > +#if STACK_GROWS_DOWNWARD > +#define STACK_PUSH_CODE PRE_DEC > +#else > +#define STACK_PUSH_CODE PRE_INC > +#endif > +#endif > + > +/* Default value for flag_pie when flag_pie is initialized to -1: > + --enable-default-pie: Default flag_pie to -fPIE. > + --disable-default-pie: Default flag_pie to 0. > + */ > +#ifdef ENABLE_DEFAULT_PIE > +# ifndef DEFAULT_FLAG_PIE > +# define DEFAULT_FLAG_PIE 2 > +# endif > +#else > +# define DEFAULT_FLAG_PIE 0 > +#endif > + > +#ifndef SWITCHABLE_TARGET > +#define SWITCHABLE_TARGET 0 > +#endif > + > +/* If the target supports integers that are wider than two > + HOST_WIDE_INTs on the host compiler, then the target should define > + TARGET_SUPPORTS_WIDE_INT and make the appropriate fixups. > + Otherwise the compiler really is not robust. */ > +#ifndef TARGET_SUPPORTS_WIDE_INT > +#define TARGET_SUPPORTS_WIDE_INT 0 > +#endif > + > +#ifndef SHORT_IMMEDIATES_SIGN_EXTEND > +#define SHORT_IMMEDIATES_SIGN_EXTEND 0 > +#endif > + > +#ifndef WORD_REGISTER_OPERATIONS > +#define WORD_REGISTER_OPERATIONS 0 > +#endif > + > +#ifndef LOAD_EXTEND_OP > +#define LOAD_EXTEND_OP(M) UNKNOWN > +#endif > + > +#ifndef CONSTANT_ALIGNMENT > +#define CONSTANT_ALIGNMENT(EXP, ALIGN) ALIGN > +#endif > + > +#ifndef INITIAL_FRAME_ADDRESS_RTX > +#define INITIAL_FRAME_ADDRESS_RTX NULL > +#endif > + > +#ifndef SETUP_FRAME_ADDRESSES > +#define SETUP_FRAME_ADDRESSES() do { } while (0) > +#endif > + > +#ifndef DYNAMIC_CHAIN_ADDRESS > +#define DYNAMIC_CHAIN_ADDRESS(x) (x) > +#endif > + > +#ifndef FRAME_ADDR_RTX > +#define FRAME_ADDR_RTX(x) (x) > +#endif > + > +#ifndef REVERSE_CONDITION > +#define REVERSE_CONDITION(code, mode) reverse_condition (code) > +#endif > + > +#ifndef TARGET_PECOFF > +#define TARGET_PECOFF 0 > +#endif > + > +#ifndef EH_RETURN_HANDLER_RTX > +#define EH_RETURN_HANDLER_RTX NULL > +#endif > + > +#ifdef GCC_INSN_FLAGS_H > +/* Dependent default target macro definitions > + > + This section of defaults.h defines target macros that depend on generated > + headers. This is a bit awkward: We want to put all default definitions > + for target macros in defaults.h, but some of the defaults depend on the > + HAVE_* flags defines of insn-flags.h. But insn-flags.h is not always > + included by files that do include defaults.h. > + > + Fortunately, the default macro definitions that depend on the HAVE_* > + macros are also the ones that will only be used inside GCC itself, i.e. > + not in the gen* programs or in target objects like libgcc. > + > + Obviously, it would be best to keep this section of defaults.h as small > + as possible, by converting the macros defined below to target hooks or > + functions. > +*/ > + > +/* The default branch cost is 1. */ > +#ifndef BRANCH_COST > +#define BRANCH_COST(speed_p, predictable_p) 1 > +#endif > + > +/* If a memory-to-memory move would take MOVE_RATIO or more simple > + move-instruction sequences, we will do a movmem or libcall instead. */ > + > +#ifndef MOVE_RATIO > +#if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined > (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti) > +#define MOVE_RATIO(speed) 2 > +#else > +/* If we are optimizing for space (-Os), cut down the default move ratio. */ > +#define MOVE_RATIO(speed) ((speed) ? 15 : 3) > +#endif > +#endif > + > +/* If a clear memory operation would take CLEAR_RATIO or more simple > + move-instruction sequences, we will do a setmem or libcall instead. */ > + > +#ifndef CLEAR_RATIO > +#if defined (HAVE_setmemqi) || defined (HAVE_setmemhi) || defined > (HAVE_setmemsi) || defined (HAVE_setmemdi) || defined (HAVE_setmemti) > +#define CLEAR_RATIO(speed) 2 > +#else > +/* If we are optimizing for space, cut down the default clear ratio. */ > +#define CLEAR_RATIO(speed) ((speed) ? 15 :3) > +#endif > +#endif > + > +/* If a memory set (to value other than zero) operation would take > + SET_RATIO or more simple move-instruction sequences, we will do a movmem > + or libcall instead. */ > +#ifndef SET_RATIO > +#define SET_RATIO(speed) MOVE_RATIO (speed) > +#endif > + > +/* Supply a default definition for FUNCTION_ARG_PADDING: > + usually pad upward, but pad short args downward on > + big-endian machines. */ > + > +#define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE) \ > + (! BYTES_BIG_ENDIAN > \ > + ? upward \ > + : (((MODE) == BLKmode \ > + ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST > \ > + && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ > + : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ > + ? downward : upward)) > + > +#ifndef FUNCTION_ARG_PADDING > +#define FUNCTION_ARG_PADDING(MODE, TYPE) \ > + DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE)) > +#endif > + > +/* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. > + Normally move_insn, so Pmode stack pointer. */ > + > +#ifndef STACK_SAVEAREA_MODE > +#define STACK_SAVEAREA_MODE(LEVEL) Pmode > +#endif > + > +/* Supply a default definition of STACK_SIZE_MODE for > + allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ > + > +#ifndef STACK_SIZE_MODE > +#define STACK_SIZE_MODE word_mode > +#endif > + > +/* Default value for flag_stack_protect when flag_stack_protect is > initialized to -1: > + --enable-default-ssp: Default flag_stack_protect to > -fstack-protector-strong. > + --disable-default-ssp: Default flag_stack_protect to 0. > + */ > +#ifdef ENABLE_DEFAULT_SSP > +# ifndef DEFAULT_FLAG_SSP > +# define DEFAULT_FLAG_SSP 3 > +# endif > +#else > +# define DEFAULT_FLAG_SSP 0 > +#endif > + > +/* Provide default values for the macros controlling stack checking. */ > + > +/* The default is neither full builtin stack checking... */ > +#ifndef STACK_CHECK_BUILTIN > +#define STACK_CHECK_BUILTIN 0 > +#endif > + > +/* ...nor static builtin stack checking. */ > +#ifndef STACK_CHECK_STATIC_BUILTIN > +#define STACK_CHECK_STATIC_BUILTIN 0 > +#endif > + > +/* The default interval is one page (4096 bytes). */ > +#ifndef STACK_CHECK_PROBE_INTERVAL_EXP > +#define STACK_CHECK_PROBE_INTERVAL_EXP 12 > +#endif > + > +/* The default is not to move the stack pointer. */ > +#ifndef STACK_CHECK_MOVING_SP > +#define STACK_CHECK_MOVING_SP 0 > +#endif > + > +/* This is a kludge to try to capture the discrepancy between the old > + mechanism (generic stack checking) and the new mechanism (static > + builtin stack checking). STACK_CHECK_PROTECT needs to be bumped > + for the latter because part of the protection area is effectively > + included in STACK_CHECK_MAX_FRAME_SIZE for the former. */ > +#ifdef STACK_CHECK_PROTECT > +#define STACK_OLD_CHECK_PROTECT STACK_CHECK_PROTECT > +#else > +#define STACK_OLD_CHECK_PROTECT > \ > + (!global_options.x_flag_exceptions \ > + ? 75 * UNITS_PER_WORD > \ > + : targetm_common.except_unwind_info (&global_options) == UI_SJLJ \ > + ? 4 * 1024 > \ > + : 8 * 1024) > +#endif > + > +/* Minimum amount of stack required to recover from an anticipated stack > + overflow detection. The default value conveys an estimate of the amount > + of stack required to propagate an exception. */ > +#ifndef STACK_CHECK_PROTECT > +#define STACK_CHECK_PROTECT \ > + (!global_options.x_flag_exceptions \ > + ? 4 * 1024 \ > + : targetm_common.except_unwind_info (&global_options) == UI_SJLJ \ > + ? 8 * 1024 > \ > + : 12 * 1024) > +#endif > + > +/* Make the maximum frame size be the largest we can and still only need > + one probe per function. */ > +#ifndef STACK_CHECK_MAX_FRAME_SIZE > +#define STACK_CHECK_MAX_FRAME_SIZE \ > + ((1 << STACK_CHECK_PROBE_INTERVAL_EXP) - UNITS_PER_WORD) > +#endif > + > +/* This is arbitrary, but should be large enough everywhere. */ > +#ifndef STACK_CHECK_FIXED_FRAME_SIZE > +#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) > +#endif > + > +/* Provide a reasonable default for the maximum size of an object to > + allocate in the fixed frame. We may need to be able to make this > + controllable by the user at some point. */ > +#ifndef STACK_CHECK_MAX_VAR_SIZE > +#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) > +#endif > + > +/* By default, the C++ compiler will use function addresses in the > + vtable entries. Setting this nonzero tells the compiler to use > + function descriptors instead. The value of this macro says how > + many words wide the descriptor is (normally 2). It is assumed > + that the address of a function descriptor may be treated as a > + pointer to a function. */ > +#ifndef TARGET_VTABLE_USES_DESCRIPTORS > +#define TARGET_VTABLE_USES_DESCRIPTORS 0 > +#endif > + > +#endif /* GCC_INSN_FLAGS_H */ > + > +#ifndef DWARF_GNAT_ENCODINGS_DEFAULT > +#define DWARF_GNAT_ENCODINGS_DEFAULT DWARF_GNAT_ENCODINGS_GDB > +#endif > + > +#endif /* ! GCC_DEFAULTS_H */ > diff --git a/libgcov/include/elf-lib.h b/libgcov/include/elf-lib.h > new file mode 100644 > index 0000000..f50798c > --- /dev/null > +++ b/libgcov/include/elf-lib.h > @@ -0,0 +1,36 @@ > +/* Definitions for Intel 386 ELF systems. > + Copyright (C) 2015-2017 Free Software Foundation, Inc. > + > +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/>. */ > + > +#ifdef __i386__ > +/* Used by crtstuff.c to initialize the base of data-relative relocations. > + These are GOT relative on x86, so return the pic register. */ > +#define CRT_GET_RFIB_DATA(BASE) > \ > + __asm__ ("call\t.LPR%=\n" \ > + ".LPR%=:\n\t" \ > + "pop{l}\t%0\n\t" \ > + /* Due to a GAS bug, this cannot use EAX. That encodes \ > + smaller than the traditional EBX, which results in the \ > + offset being off by one. */ \ > + "add{l}\t{$_GLOBAL_OFFSET_TABLE_+[.-.LPR%=],%0" \ > + "|%0,_GLOBAL_OFFSET_TABLE_+(.-.LPR%=)}" \ > + : "=d"(BASE)) > +#endif > diff --git a/libgcov/include/filenames.h b/libgcov/include/filenames.h > new file mode 100644 > index 0000000..5a2a055 > --- /dev/null > +++ b/libgcov/include/filenames.h > @@ -0,0 +1,99 @@ > +/* Macros for taking apart, interpreting and processing file names. > + > + These are here because some non-Posix (a.k.a. DOSish) systems have > + drive letter brain-damage at the beginning of an absolute file name, > + use forward- and back-slash in path names interchangeably, and > + some of them have case-insensitive file names. > + > + Copyright (C) 2000-2017 Free Software Foundation, Inc. > + > +This file is part of BFD, the Binary File Descriptor library. > + > +This program 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 2 of the License, or > +(at your option) any later version. > + > +This program is distributed in the hope that it will be useful, > +but WITHOUT ANY WARRANTY; without even the implied warranty of > +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +GNU General Public License for more details. > + > +You should have received a copy of the GNU General Public License > +along with this program; if not, write to the Free Software > +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, > USA. */ > + > +#ifndef FILENAMES_H > +#define FILENAMES_H > + > +#include "hashtab.h" /* for hashval_t */ > + > +#ifdef __cplusplus > +extern "C" { > +#endif > + > +#if defined(__MSDOS__) || defined(_WIN32) || defined(__OS2__) || defined > (__CYGWIN__) > +# ifndef HAVE_DOS_BASED_FILE_SYSTEM > +# define HAVE_DOS_BASED_FILE_SYSTEM 1 > +# endif > +# ifndef HAVE_CASE_INSENSITIVE_FILE_SYSTEM > +# define HAVE_CASE_INSENSITIVE_FILE_SYSTEM 1 > +# endif > +# define HAS_DRIVE_SPEC(f) HAS_DOS_DRIVE_SPEC (f) > +# define IS_DIR_SEPARATOR(c) IS_DOS_DIR_SEPARATOR (c) > +# define IS_ABSOLUTE_PATH(f) IS_DOS_ABSOLUTE_PATH (f) > +#else /* not DOSish */ > +# if defined(__APPLE__) > +# ifndef HAVE_CASE_INSENSITIVE_FILE_SYSTEM > +# define HAVE_CASE_INSENSITIVE_FILE_SYSTEM 1 > +# endif > +# endif /* __APPLE__ */ > +# define HAS_DRIVE_SPEC(f) (0) > +# define IS_DIR_SEPARATOR(c) IS_UNIX_DIR_SEPARATOR (c) > +# define IS_ABSOLUTE_PATH(f) IS_UNIX_ABSOLUTE_PATH (f) > +#endif > + > +#define IS_DIR_SEPARATOR_1(dos_based, c) \ > + (((c) == '/') > \ > + || (((c) == '\\') && (dos_based))) > + > +#define HAS_DRIVE_SPEC_1(dos_based, f) \ > + ((f)[0] && ((f)[1] == ':') && (dos_based)) > + > +/* Remove the drive spec from F, assuming HAS_DRIVE_SPEC (f). > + The result is a pointer to the remainder of F. */ > +#define STRIP_DRIVE_SPEC(f) ((f) + 2) > + > +#define IS_DOS_DIR_SEPARATOR(c) IS_DIR_SEPARATOR_1 (1, c) > +#define IS_DOS_ABSOLUTE_PATH(f) IS_ABSOLUTE_PATH_1 (1, f) > +#define HAS_DOS_DRIVE_SPEC(f) HAS_DRIVE_SPEC_1 (1, f) > + > +#define IS_UNIX_DIR_SEPARATOR(c) IS_DIR_SEPARATOR_1 (0, c) > +#define IS_UNIX_ABSOLUTE_PATH(f) IS_ABSOLUTE_PATH_1 (0, f) > + > +/* Note that when DOS_BASED is true, IS_ABSOLUTE_PATH accepts d:foo as > + well, although it is only semi-absolute. This is because the users > + of IS_ABSOLUTE_PATH want to know whether to prepend the current > + working directory to a file name, which should not be done with a > + name like d:foo. */ > +#define IS_ABSOLUTE_PATH_1(dos_based, f) \ > + (IS_DIR_SEPARATOR_1 (dos_based, (f)[0]) \ > + || HAS_DRIVE_SPEC_1 (dos_based, f)) > + > +extern int filename_cmp (const char *s1, const char *s2); > +#define FILENAME_CMP(s1, s2) filename_cmp(s1, s2) > + > +extern int filename_ncmp (const char *s1, const char *s2, > + size_t n); > + > +extern hashval_t filename_hash (const void *s); > + > +extern int filename_eq (const void *s1, const void *s2); > + > +extern int canonical_filename_eq (const char *a, const char *b); > + > +#ifdef __cplusplus > +} > +#endif > + > +#endif /* FILENAMES_H */ > diff --git a/libgcov/include/gcov-counter.def > b/libgcov/include/gcov-counter.def > new file mode 100644 > index 0000000..85dcdae > --- /dev/null > +++ b/libgcov/include/gcov-counter.def > @@ -0,0 +1,54 @@ > +/* Definitions for the gcov counters in the GNU compiler. > + Copyright (C) 2001-2017 Free Software Foundation, Inc. > + > +This file is part of GCC. > + > +GCC is free software; you can redistribute it and/or modify it under > +the terms of the GNU General Public License as published by the Free > +Software Foundation; either version 3, or (at your option) any later > +version. > + > +GCC is distributed in the hope that it will be useful, but WITHOUT ANY > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > +for more details. > + > +You should have received a copy of the GNU General Public License > +along with GCC; see the file COPYING3. If not see > +<http://www.gnu.org/licenses/>. */ > + > +/* Before including this file, define a macro: > + > + DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) > + > + This macro will be expanded to all supported gcov counters, their > + names, or the type of handler functions. FN_TYPE will be > + expanded to a handler function, like in gcov_merge, it is > + expanded to __gcov_merge ## FN_TYPE. */ > + > +/* Arc transitions. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_ARCS, "arcs", _add) > + > +/* Histogram of value inside an interval. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_V_INTERVAL, "interval", _add) > + > +/* Histogram of exact power2 logarithm of a value. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_V_POW2, "pow2", _add) > + > +/* The most common value of expression. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_V_SINGLE, "single", _single) > + > +/* The most common indirect address. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_V_INDIR, "indirect_call", _single) > + > +/* Compute average value passed to the counter. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_AVERAGE, "average", _add) > + > +/* IOR of the all values passed to counter. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_IOR, "ior", _ior) > + > +/* Time profile collecting first run of a function */ > +DEF_GCOV_COUNTER(GCOV_TIME_PROFILER, "time_profiler", _time_profile) > + > +/* Top N value tracking for indirect calls. */ > +DEF_GCOV_COUNTER(GCOV_COUNTER_ICALL_TOPNV, "indirect_call_topn", _icall_topn) > diff --git a/libgcov/include/gcov-io.c b/libgcov/include/gcov-io.c > new file mode 100644 > index 0000000..64dedd5 > --- /dev/null > +++ b/libgcov/include/gcov-io.c > @@ -0,0 +1,987 @@ > +/* File format for coverage information > + Copyright (C) 1996-2017 Free Software Foundation, Inc. > + Contributed by Bob Manson <manson@xxxxxxxxxx>. > + Completely remangled by Nathan Sidwell <nathan@xxxxxxxxxxxxxxxx>. > + > +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) > + > +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) > +{ > + gcov_nonruntime_assert (gcov_var.mode > 0); > + 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) > +{ > + 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, non-zero on success. */ > + > +GCOV_LINKAGE int > +#if IN_LIBGCOV > +gcov_open (const char *name) > +#else > +gcov_open (const char *name, int mode) > +#endif > +{ > +#if IN_LIBGCOV > + 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 > + > + gcov_nonruntime_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 > + { > + /* Write mode - acquire a write-lock. */ > + s_flock.l_type = F_WRLCK; > + /* Truncate if force new mode. */ > + fd = open (name, O_RDWR | O_CREAT | (mode < 0 ? O_TRUNC : 0), 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; > + } > +#else > + if (mode >= 0) > + /* Open an existing file. */ > + gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b"); > + > + if (gcov_var.file) > + mode = 1; > + else if (mode <= 0) > + /* Create a new file. */ > + gcov_var.file = fopen (name, "w+b"); > + > + if (!gcov_var.file) > + return 0; > +#endif > + > + gcov_var.mode = mode ? mode : 1; > + > + 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; > + > + gcov_nonruntime_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) > + { > + 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; > + > + if (alloc > 0) > + { > + buffer[alloc] = 0; /* place nul terminators. */ > + 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; > + > + gcov_nonruntime_assert (gcov_var.mode < 0); > + gcov_nonruntime_assert (position + 2 <= gcov_var.start + gcov_var.offset); > + gcov_nonruntime_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) > + { > + 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; > + > + if (gcov_var.mode <= 0) > + return NULL; > + > + if (excess < words) > + { > + gcov_var.start += gcov_var.offset; > + if (excess) > + { > +#if IN_LIBGCOV > + 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 > + 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; > + if (bv_ix >= GCOV_HISTOGRAM_BITVECTOR_SIZE) > + gcov_error ("corrupted profile info: summary histogram " > + "bitvector is corrupt"); > + cur_bitvector = histo_bitvector[bv_ix++]; > + } > + while (!(cur_bitvector & 0x1)) > + { > + h_ix++; > + cur_bitvector >>= 1; > + } > + if (h_ix >= GCOV_HISTOGRAM_SIZE) > + gcov_error ("corrupted profile info: summary histogram " > + "index is corrupt"); > + > + 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++; > + } > + } > +} > + > +/* 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) > +{ > + gcov_nonruntime_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) > +{ > + 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; > +} > +#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 64 bits and gcov_type_unsigned is 64 bits. */ > + r = floor_log2 (v); > +#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; > + > + gcov_nonruntime_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); > + gcov_nonruntime_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--; > + } > + } > + > + gcov_nonruntime_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. */ > + gcov_nonruntime_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; > + } > + gcov_nonruntime_assert (ws_ix == NUM_GCOV_WORKING_SETS); > +} > +#endif /* IN_GCOV <= 0 && !IN_LIBGCOV */ > diff --git a/libgcov/include/gcov-io.h b/libgcov/include/gcov-io.h > new file mode 100644 > index 0000000..1fb58dd > --- /dev/null > +++ b/libgcov/include/gcov-io.h > @@ -0,0 +1,424 @@ > +/* File format for coverage information > + Copyright (C) 1996-2017 Free Software Foundation, Inc. > + Contributed by Bob Manson <manson@xxxxxxxxxx>. > + Completely remangled by Nathan Sidwell <nathan@xxxxxxxxxxxxxxxx>. > + > +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 a two character major version number > + (first digit starts from 'A' letter to not to clash with the older > + numbering scheme), the single character minor version number, > + 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 17.0 experimental, it would be > + 'B70e' (0x42373065). As we currently do not release more than 5 minor > + releases, the single character should be always fine. Major number > + is currently changed roughly every year, which gives us space > + for next 250 years (maximum allowed number would be 259.9). > + > + 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; > +/* gcov_type is typedef'd elsewhere for the compiler */ > +#if IN_GCOV > +#define GCOV_LINKAGE static > +typedef int64_t gcov_type; > +typedef uint64_t gcov_type_unsigned; > +#if IN_GCOV > 0 > +#include <sys/types.h> > +#endif > +#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 > + > +#if IN_LIBGCOV > +#define gcov_nonruntime_assert(EXPR) ((void)(0 && (EXPR))) > +#else > +#define gcov_nonruntime_assert(EXPR) gcc_assert (EXPR) > +#define gcov_error(...) fatal_error (input_location, __VA_ARGS__) > +#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_AFDO_FILE_NAMES ((gcov_unsigned_t)0xaa000000) > +#define GCOV_TAG_AFDO_FUNCTION ((gcov_unsigned_t)0xac000000) > +#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 - 1) > + > +/* Number of counters used for value profiling. */ > +#define GCOV_N_VALUE_COUNTERS \ > + (GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1) > + > +/* The number of hottest callees to be tracked. */ > +#define GCOV_ICALL_TOPN_VAL 2 > + > +/* The number of counter entries per icall callsite. */ > +#define GCOV_ICALL_TOPN_NCOUNTS (1 + GCOV_ICALL_TOPN_VAL * 4) > + > +/* 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]; > +}; > + > +#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_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/libgcov/include/gcov.h b/libgcov/include/gcov.h > new file mode 100644 > index 0000000..0333ecc > --- /dev/null > +++ b/libgcov/include/gcov.h > @@ -0,0 +1,41 @@ > +/* GCOV interface routines. > + Copyright (C) 2017 Free Software Foundation, Inc. > + > + This file is part of GCC. > + > + GCC is free software; you can redistribute it and/or modify it under > + the terms of the GNU General Public License as published by the Free > + Software Foundation; either version 3, or (at your option) any later > + version. > + > + GCC is distributed in the hope that it will be useful, but WITHOUT ANY > + WARRANTY; without even the implied warranty of MERCHANTABILITY or > + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > + for more details. > + > + Under Section 7 of GPL version 3, you are granted additional > + permissions described in the GCC Runtime Library Exception, version > + 3.1, as published by the Free Software Foundation. > + > + You should have received a copy of the GNU General Public License and > + a copy of the GCC Runtime Library Exception along with this program; > + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > + <http://www.gnu.org/licenses/>. */ > + > +#ifndef GCC_GCOV_H > +#define GCC_GCOV_H > + > +/* Set all counters to zero. */ > + > +extern void __gcov_reset (void); > + > +/* Write profile information to a file. */ > + > +extern void __gcov_dump (void); > + > +/* Write profile information to a file and reset counters to zero. > + The function does operations under a mutex. */ > + > +extern void __gcov_flush (void); > + > +#endif /* GCC_GCOV_H */ > diff --git a/libgcov/include/gthr-default.h b/libgcov/include/gthr-default.h > new file mode 100644 > index 0000000..a54a32e > --- /dev/null > +++ b/libgcov/include/gthr-default.h > @@ -0,0 +1,889 @@ > +/* Threads compatibility routines for libgcc2 and libobjc. */ > +/* Compile this one with gcc. */ > +/* Copyright (C) 1997-2017 Free Software Foundation, Inc. > + > +This file is part of GCC. > + > +GCC is free software; you can redistribute it and/or modify it under > +the terms of the GNU General Public License as published by the Free > +Software Foundation; either version 3, or (at your option) any later > +version. > + > +GCC is distributed in the hope that it will be useful, but WITHOUT ANY > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > +for more details. > + > +Under Section 7 of GPL version 3, you are granted additional > +permissions described in the GCC Runtime Library Exception, version > +3.1, as published by the Free Software Foundation. > + > +You should have received a copy of the GNU General Public License and > +a copy of the GCC Runtime Library Exception along with this program; > +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +<http://www.gnu.org/licenses/>. */ > + > +#ifndef GCC_GTHR_POSIX_H > +#define GCC_GTHR_POSIX_H > + > +/* POSIX threads specific definitions. > + Easy, since the interface is just one-to-one mapping. */ > + > +#define __GTHREADS 1 > +#define __GTHREADS_CXX0X 1 > + > +#include <pthread.h> > + > +#if ((defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)) \ > + || !defined(_GTHREAD_USE_MUTEX_TIMEDLOCK)) > +# include <unistd.h> > +# if defined(_POSIX_TIMEOUTS) && _POSIX_TIMEOUTS >= 0 > +# define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 > +# else > +# define _GTHREAD_USE_MUTEX_TIMEDLOCK 0 > +# endif > +#endif > + > +typedef pthread_t __gthread_t; > +typedef pthread_key_t __gthread_key_t; > +typedef pthread_once_t __gthread_once_t; > +typedef pthread_mutex_t __gthread_mutex_t; > +typedef pthread_mutex_t __gthread_recursive_mutex_t; > +typedef pthread_cond_t __gthread_cond_t; > +typedef struct timespec __gthread_time_t; > + > +/* POSIX like conditional variables are supported. Please look at comments > + in gthr.h for details. */ > +#define __GTHREAD_HAS_COND 1 > + > +#define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER > +#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function > +#define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT > +#if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER) > +#define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER > +#elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) > +#define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP > +#else > +#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION > __gthread_recursive_mutex_init_function > +#endif > +#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER > +#define __GTHREAD_TIME_INIT {0,0} > + > +#ifdef _GTHREAD_USE_MUTEX_INIT_FUNC > +# undef __GTHREAD_MUTEX_INIT > +#endif > +#ifdef _GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC > +# undef __GTHREAD_RECURSIVE_MUTEX_INIT > +# undef __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION > +# define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION > __gthread_recursive_mutex_init_function > +#endif > +#ifdef _GTHREAD_USE_COND_INIT_FUNC > +# undef __GTHREAD_COND_INIT > +# define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function > +#endif > + > +#if SUPPORTS_WEAK && GTHREAD_USE_WEAK > +# ifndef __gthrw_pragma > +# define __gthrw_pragma(pragma) > +# endif > +# define __gthrw2(name,name2,type) \ > + static __typeof(type) name __attribute__ ((__weakref__(#name2))); \ > + __gthrw_pragma(weak type) > +# define __gthrw_(name) __gthrw_ ## name > +#else > +# define __gthrw2(name,name2,type) > +# define __gthrw_(name) name > +#endif > + > +/* Typically, __gthrw_foo is a weak reference to symbol foo. */ > +#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name) > + > +__gthrw(pthread_once) > +__gthrw(pthread_getspecific) > +__gthrw(pthread_setspecific) > + > +__gthrw(pthread_create) > +__gthrw(pthread_join) > +__gthrw(pthread_equal) > +__gthrw(pthread_self) > +__gthrw(pthread_detach) > +#ifndef __BIONIC__ > +__gthrw(pthread_cancel) > +#endif > +__gthrw(sched_yield) > + > +__gthrw(pthread_mutex_lock) > +__gthrw(pthread_mutex_trylock) > +#if _GTHREAD_USE_MUTEX_TIMEDLOCK > +__gthrw(pthread_mutex_timedlock) > +#endif > +__gthrw(pthread_mutex_unlock) > +__gthrw(pthread_mutex_init) > +__gthrw(pthread_mutex_destroy) > + > +__gthrw(pthread_cond_init) > +__gthrw(pthread_cond_broadcast) > +__gthrw(pthread_cond_signal) > +__gthrw(pthread_cond_wait) > +__gthrw(pthread_cond_timedwait) > +__gthrw(pthread_cond_destroy) > + > +__gthrw(pthread_key_create) > +__gthrw(pthread_key_delete) > +__gthrw(pthread_mutexattr_init) > +__gthrw(pthread_mutexattr_settype) > +__gthrw(pthread_mutexattr_destroy) > + > + > +#if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK) > +/* Objective-C. */ > +__gthrw(pthread_exit) > +#ifdef _POSIX_PRIORITY_SCHEDULING > +#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING > +__gthrw(sched_get_priority_max) > +__gthrw(sched_get_priority_min) > +#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ > +#endif /* _POSIX_PRIORITY_SCHEDULING */ > +__gthrw(pthread_attr_destroy) > +__gthrw(pthread_attr_init) > +__gthrw(pthread_attr_setdetachstate) > +#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING > +__gthrw(pthread_getschedparam) > +__gthrw(pthread_setschedparam) > +#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ > +#endif /* _LIBOBJC || _LIBOBJC_WEAK */ > + > +#if SUPPORTS_WEAK && GTHREAD_USE_WEAK > + > +/* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if > + -pthreads is not specified. The functions are dummies and most return an > + error value. However pthread_once returns 0 without invoking the routine > + it is passed so we cannot pretend that the interface is active if > -pthreads > + is not specified. On Solaris 2.5.1, the interface is not exposed at all > so > + we need to play the usual game with weak symbols. On Solaris 10 and up, a > + working interface is always exposed. On FreeBSD 6 and later, libc also > + exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up > + to 9 does. FreeBSD >= 700014 even provides a pthread_cancel stub in libc, > + which means the alternate __gthread_active_p below cannot be used there. > */ > + > +#if defined(__FreeBSD__) || (defined(__sun) && defined(__svr4__)) > + > +static volatile int __gthread_active = -1; > + > +static void > +__gthread_trigger (void) > +{ > + __gthread_active = 1; > +} > + > +static inline int > +__gthread_active_p (void) > +{ > + static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER; > + static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT; > + > + /* Avoid reading __gthread_active twice on the main code path. */ > + int __gthread_active_latest_value = __gthread_active; > + > + /* This test is not protected to avoid taking a lock on the main code > + path so every update of __gthread_active in a threaded program must > + be atomic with regard to the result of the test. */ > + if (__builtin_expect (__gthread_active_latest_value < 0, 0)) > + { > + if (__gthrw_(pthread_once)) > + { > + /* If this really is a threaded program, then we must ensure that > + __gthread_active has been set to 1 before exiting this block. */ > + __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex); > + __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger); > + __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex); > + } > + > + /* Make sure we'll never enter this block again. */ > + if (__gthread_active < 0) > + __gthread_active = 0; > + > + __gthread_active_latest_value = __gthread_active; > + } > + > + return __gthread_active_latest_value != 0; > +} > + > +#else /* neither FreeBSD nor Solaris */ > + > +/* For a program to be multi-threaded the only thing that it certainly must > + be using is pthread_create. However, there may be other libraries that > + intercept pthread_create with their own definitions to wrap pthreads > + functionality for some purpose. In those cases, pthread_create being > + defined might not necessarily mean that libpthread is actually linked > + in. > + > + For the GNU C library, we can use a known internal name. This is always > + available in the ABI, but no other library would define it. That is > + ideal, since any public pthread function might be intercepted just as > + pthread_create might be. __pthread_key_create is an "internal" > + implementation symbol, but it is part of the public exported ABI. Also, > + it's among the symbols that the static libpthread.a always links in > + whenever pthread_create is used, so there is no danger of a false > + negative result in any statically-linked, multi-threaded program. > + > + For others, we choose pthread_cancel as a function that seems unlikely > + to be redefined by an interceptor library. The bionic (Android) C > + library does not provide pthread_cancel, so we do use pthread_create > + there (and interceptor libraries lose). */ > + > +#ifdef __GLIBC__ > +__gthrw2(__gthrw_(__pthread_key_create), > + __pthread_key_create, > + pthread_key_create) > +# define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create) > +#elif defined (__BIONIC__) > +# define GTHR_ACTIVE_PROXY __gthrw_(pthread_create) > +#else > +# define GTHR_ACTIVE_PROXY __gthrw_(pthread_cancel) > +#endif > + > +static inline int > +__gthread_active_p (void) > +{ > + static void *const __gthread_active_ptr > + = __extension__ (void *) &GTHR_ACTIVE_PROXY; > + return __gthread_active_ptr != 0; > +} > + > +#endif /* FreeBSD or Solaris */ > + > +#else /* not SUPPORTS_WEAK */ > + > +/* Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread > + calls in shared flavors of the HP-UX C library. Most of the stubs > + have no functionality. The details are described in the "libc cumulative > + patch" for each subversion of HP-UX 11. There are two special interfaces > + provided for checking whether an application is linked to a shared pthread > + library or not. However, these interfaces aren't available in early > + libpthread libraries. We also need a test that works for archive > + libraries. We can't use pthread_once as some libc versions call the > + init function. We also can't use pthread_create or pthread_attr_init > + as these create a thread and thereby prevent changing the default stack > + size. The function pthread_default_stacksize_np is available in both > + the archive and shared versions of libpthread. It can be used to > + determine the default pthread stack size. There is a stub in some > + shared libc versions which returns a zero size if pthreads are not > + active. We provide an equivalent stub to handle cases where libc > + doesn't provide one. */ > + > +#if defined(__hppa__) && defined(__hpux__) > + > +static volatile int __gthread_active = -1; > + > +static inline int > +__gthread_active_p (void) > +{ > + /* Avoid reading __gthread_active twice on the main code path. */ > + int __gthread_active_latest_value = __gthread_active; > + size_t __s; > + > + if (__builtin_expect (__gthread_active_latest_value < 0, 0)) > + { > + pthread_default_stacksize_np (0, &__s); > + __gthread_active = __s ? 1 : 0; > + __gthread_active_latest_value = __gthread_active; > + } > + > + return __gthread_active_latest_value != 0; > +} > + > +#else /* not hppa-hpux */ > + > +static inline int > +__gthread_active_p (void) > +{ > + return 1; > +} > + > +#endif /* hppa-hpux */ > + > +#endif /* SUPPORTS_WEAK */ > + > +#ifdef _LIBOBJC > + > +/* This is the config.h file in libobjc/ */ > +#include <config.h> > + > +#ifdef HAVE_SCHED_H > +# include <sched.h> > +#endif > + > +/* Key structure for maintaining thread specific storage */ > +static pthread_key_t _objc_thread_storage; > +static pthread_attr_t _objc_thread_attribs; > + > +/* Thread local storage for a single thread */ > +static void *thread_local_storage = NULL; > + > +/* Backend initialization functions */ > + > +/* Initialize the threads subsystem. */ > +static inline int > +__gthread_objc_init_thread_system (void) > +{ > + if (__gthread_active_p ()) > + { > + /* Initialize the thread storage key. */ > + if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0) > + { > + /* The normal default detach state for threads is > + * PTHREAD_CREATE_JOINABLE which causes threads to not die > + * when you think they should. */ > + if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0 > + && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs, > + PTHREAD_CREATE_DETACHED) == 0) > + return 0; > + } > + } > + > + return -1; > +} > + > +/* Close the threads subsystem. */ > +static inline int > +__gthread_objc_close_thread_system (void) > +{ > + if (__gthread_active_p () > + && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0 > + && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0) > + return 0; > + > + return -1; > +} > + > +/* Backend thread functions */ > + > +/* Create a new thread of execution. */ > +static inline objc_thread_t > +__gthread_objc_thread_detach (void (*func)(void *), void *arg) > +{ > + objc_thread_t thread_id; > + pthread_t new_thread_handle; > + > + if (!__gthread_active_p ()) > + return NULL; > + > + if (!(__gthrw_(pthread_create) (&new_thread_handle, &_objc_thread_attribs, > + (void *) func, arg))) > + thread_id = (objc_thread_t) new_thread_handle; > + else > + thread_id = NULL; > + > + return thread_id; > +} > + > +/* Set the current thread's priority. */ > +static inline int > +__gthread_objc_thread_set_priority (int priority) > +{ > + if (!__gthread_active_p ()) > + return -1; > + else > + { > +#ifdef _POSIX_PRIORITY_SCHEDULING > +#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING > + pthread_t thread_id = __gthrw_(pthread_self) (); > + int policy; > + struct sched_param params; > + int priority_min, priority_max; > + > + if (__gthrw_(pthread_getschedparam) (thread_id, &policy, &params) == 0) > + { > + if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1) > + return -1; > + > + if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1) > + return -1; > + > + if (priority > priority_max) > + priority = priority_max; > + else if (priority < priority_min) > + priority = priority_min; > + params.sched_priority = priority; > + > + /* > + * The solaris 7 and several other man pages incorrectly state that > + * this should be a pointer to policy but pthread.h is universally > + * at odds with this. > + */ > + if (__gthrw_(pthread_setschedparam) (thread_id, policy, &params) == 0) > + return 0; > + } > +#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ > +#endif /* _POSIX_PRIORITY_SCHEDULING */ > + return -1; > + } > +} > + > +/* Return the current thread's priority. */ > +static inline int > +__gthread_objc_thread_get_priority (void) > +{ > +#ifdef _POSIX_PRIORITY_SCHEDULING > +#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING > + if (__gthread_active_p ()) > + { > + int policy; > + struct sched_param params; > + > + if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), > &policy, &params) == 0) > + return params.sched_priority; > + else > + return -1; > + } > + else > +#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ > +#endif /* _POSIX_PRIORITY_SCHEDULING */ > + return OBJC_THREAD_INTERACTIVE_PRIORITY; > +} > + > +/* Yield our process time to another thread. */ > +static inline void > +__gthread_objc_thread_yield (void) > +{ > + if (__gthread_active_p ()) > + __gthrw_(sched_yield) (); > +} > + > +/* Terminate the current thread. */ > +static inline int > +__gthread_objc_thread_exit (void) > +{ > + if (__gthread_active_p ()) > + /* exit the thread */ > + __gthrw_(pthread_exit) (&__objc_thread_exit_status); > + > + /* Failed if we reached here */ > + return -1; > +} > + > +/* Returns an integer value which uniquely describes a thread. */ > +static inline objc_thread_t > +__gthread_objc_thread_id (void) > +{ > + if (__gthread_active_p ()) > + return (objc_thread_t) __gthrw_(pthread_self) (); > + else > + return (objc_thread_t) 1; > +} > + > +/* Sets the thread's local storage pointer. */ > +static inline int > +__gthread_objc_thread_set_data (void *value) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_setspecific) (_objc_thread_storage, value); > + else > + { > + thread_local_storage = value; > + return 0; > + } > +} > + > +/* Returns the thread's local storage pointer. */ > +static inline void * > +__gthread_objc_thread_get_data (void) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_getspecific) (_objc_thread_storage); > + else > + return thread_local_storage; > +} > + > +/* Backend mutex functions */ > + > +/* Allocate a mutex. */ > +static inline int > +__gthread_objc_mutex_allocate (objc_mutex_t mutex) > +{ > + if (__gthread_active_p ()) > + { > + mutex->backend = objc_malloc (sizeof (pthread_mutex_t)); > + > + if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, > NULL)) > + { > + objc_free (mutex->backend); > + mutex->backend = NULL; > + return -1; > + } > + } > + > + return 0; > +} > + > +/* Deallocate a mutex. */ > +static inline int > +__gthread_objc_mutex_deallocate (objc_mutex_t mutex) > +{ > + if (__gthread_active_p ()) > + { > + int count; > + > + /* > + * Posix Threads specifically require that the thread be unlocked > + * for __gthrw_(pthread_mutex_destroy) to work. > + */ > + > + do > + { > + count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) > mutex->backend); > + if (count < 0) > + return -1; > + } > + while (count); > + > + if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) > mutex->backend)) > + return -1; > + > + objc_free (mutex->backend); > + mutex->backend = NULL; > + } > + return 0; > +} > + > +/* Grab a lock on a mutex. */ > +static inline int > +__gthread_objc_mutex_lock (objc_mutex_t mutex) > +{ > + if (__gthread_active_p () > + && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) > != 0) > + { > + return -1; > + } > + > + return 0; > +} > + > +/* Try to grab a lock on a mutex. */ > +static inline int > +__gthread_objc_mutex_trylock (objc_mutex_t mutex) > +{ > + if (__gthread_active_p () > + && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) > mutex->backend) != 0) > + { > + return -1; > + } > + > + return 0; > +} > + > +/* Unlock the mutex */ > +static inline int > +__gthread_objc_mutex_unlock (objc_mutex_t mutex) > +{ > + if (__gthread_active_p () > + && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) > != 0) > + { > + return -1; > + } > + > + return 0; > +} > + > +/* Backend condition mutex functions */ > + > +/* Allocate a condition. */ > +static inline int > +__gthread_objc_condition_allocate (objc_condition_t condition) > +{ > + if (__gthread_active_p ()) > + { > + condition->backend = objc_malloc (sizeof (pthread_cond_t)); > + > + if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) > condition->backend, NULL)) > + { > + objc_free (condition->backend); > + condition->backend = NULL; > + return -1; > + } > + } > + > + return 0; > +} > + > +/* Deallocate a condition. */ > +static inline int > +__gthread_objc_condition_deallocate (objc_condition_t condition) > +{ > + if (__gthread_active_p ()) > + { > + if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) > condition->backend)) > + return -1; > + > + objc_free (condition->backend); > + condition->backend = NULL; > + } > + return 0; > +} > + > +/* Wait on the condition */ > +static inline int > +__gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t > mutex) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) > condition->backend, > + (pthread_mutex_t *) mutex->backend); > + else > + return 0; > +} > + > +/* Wake up all threads waiting on this condition. */ > +static inline int > +__gthread_objc_condition_broadcast (objc_condition_t condition) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) > condition->backend); > + else > + return 0; > +} > + > +/* Wake up one thread waiting on this condition. */ > +static inline int > +__gthread_objc_condition_signal (objc_condition_t condition) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) > condition->backend); > + else > + return 0; > +} > + > +#else /* _LIBOBJC */ > + > +static inline int > +__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), > + void *__args) > +{ > + return __gthrw_(pthread_create) (__threadid, NULL, __func, __args); > +} > + > +static inline int > +__gthread_join (__gthread_t __threadid, void **__value_ptr) > +{ > + return __gthrw_(pthread_join) (__threadid, __value_ptr); > +} > + > +static inline int > +__gthread_detach (__gthread_t __threadid) > +{ > + return __gthrw_(pthread_detach) (__threadid); > +} > + > +static inline int > +__gthread_equal (__gthread_t __t1, __gthread_t __t2) > +{ > + return __gthrw_(pthread_equal) (__t1, __t2); > +} > + > +static inline __gthread_t > +__gthread_self (void) > +{ > + return __gthrw_(pthread_self) (); > +} > + > +static inline int > +__gthread_yield (void) > +{ > + return __gthrw_(sched_yield) (); > +} > + > +static inline int > +__gthread_once (__gthread_once_t *__once, void (*__func) (void)) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_once) (__once, __func); > + else > + return -1; > +} > + > +static inline int > +__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) > +{ > + return __gthrw_(pthread_key_create) (__key, __dtor); > +} > + > +static inline int > +__gthread_key_delete (__gthread_key_t __key) > +{ > + return __gthrw_(pthread_key_delete) (__key); > +} > + > +static inline void * > +__gthread_getspecific (__gthread_key_t __key) > +{ > + return __gthrw_(pthread_getspecific) (__key); > +} > + > +static inline int > +__gthread_setspecific (__gthread_key_t __key, const void *__ptr) > +{ > + return __gthrw_(pthread_setspecific) (__key, __ptr); > +} > + > +static inline void > +__gthread_mutex_init_function (__gthread_mutex_t *__mutex) > +{ > + if (__gthread_active_p ()) > + __gthrw_(pthread_mutex_init) (__mutex, NULL); > +} > + > +static inline int > +__gthread_mutex_destroy (__gthread_mutex_t *__mutex) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_mutex_destroy) (__mutex); > + else > + return 0; > +} > + > +static inline int > +__gthread_mutex_lock (__gthread_mutex_t *__mutex) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_mutex_lock) (__mutex); > + else > + return 0; > +} > + > +static inline int > +__gthread_mutex_trylock (__gthread_mutex_t *__mutex) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_mutex_trylock) (__mutex); > + else > + return 0; > +} > + > +#if _GTHREAD_USE_MUTEX_TIMEDLOCK > +static inline int > +__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, > + const __gthread_time_t *__abs_timeout) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_mutex_timedlock) (__mutex, __abs_timeout); > + else > + return 0; > +} > +#endif > + > +static inline int > +__gthread_mutex_unlock (__gthread_mutex_t *__mutex) > +{ > + if (__gthread_active_p ()) > + return __gthrw_(pthread_mutex_unlock) (__mutex); > + else > + return 0; > +} > + > +#if !defined( PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) \ > + || defined(_GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC) > +static inline int > +__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t > *__mutex) > +{ > + if (__gthread_active_p ()) > + { > + pthread_mutexattr_t __attr; > + int __r; > + > + __r = __gthrw_(pthread_mutexattr_init) (&__attr); > + if (!__r) > + __r = __gthrw_(pthread_mutexattr_settype) (&__attr, > + PTHREAD_MUTEX_RECURSIVE); > + if (!__r) > + __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr); > + if (!__r) > + __r = __gthrw_(pthread_mutexattr_destroy) (&__attr); > + return __r; > + } > + return 0; > +} > +#endif > + > +static inline int > +__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) > +{ > + return __gthread_mutex_lock (__mutex); > +} > + > +static inline int > +__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) > +{ > + return __gthread_mutex_trylock (__mutex); > +} > + > +#if _GTHREAD_USE_MUTEX_TIMEDLOCK > +static inline int > +__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, > + const __gthread_time_t *__abs_timeout) > +{ > + return __gthread_mutex_timedlock (__mutex, __abs_timeout); > +} > +#endif > + > +static inline int > +__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) > +{ > + return __gthread_mutex_unlock (__mutex); > +} > + > +static inline int > +__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) > +{ > + return __gthread_mutex_destroy (__mutex); > +} > + > +#ifdef _GTHREAD_USE_COND_INIT_FUNC > +static inline void > +__gthread_cond_init_function (__gthread_cond_t *__cond) > +{ > + if (__gthread_active_p ()) > + __gthrw_(pthread_cond_init) (__cond, NULL); > +} > +#endif > + > +static inline int > +__gthread_cond_broadcast (__gthread_cond_t *__cond) > +{ > + return __gthrw_(pthread_cond_broadcast) (__cond); > +} > + > +static inline int > +__gthread_cond_signal (__gthread_cond_t *__cond) > +{ > + return __gthrw_(pthread_cond_signal) (__cond); > +} > + > +static inline int > +__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) > +{ > + return __gthrw_(pthread_cond_wait) (__cond, __mutex); > +} > + > +static inline int > +__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t > *__mutex, > + const __gthread_time_t *__abs_timeout) > +{ > + return __gthrw_(pthread_cond_timedwait) (__cond, __mutex, __abs_timeout); > +} > + > +static inline int > +__gthread_cond_wait_recursive (__gthread_cond_t *__cond, > + __gthread_recursive_mutex_t *__mutex) > +{ > + return __gthread_cond_wait (__cond, __mutex); > +} > + > +static inline int > +__gthread_cond_destroy (__gthread_cond_t* __cond) > +{ > + return __gthrw_(pthread_cond_destroy) (__cond); > +} > + > +#endif /* _LIBOBJC */ > + > +#endif /* ! GCC_GTHR_POSIX_H */ > diff --git a/libgcov/include/gthr.h b/libgcov/include/gthr.h > new file mode 100644 > index 0000000..ed22dc9 > --- /dev/null > +++ b/libgcov/include/gthr.h > @@ -0,0 +1,154 @@ > +/* Threads compatibility routines for libgcc2. */ > +/* Compile this one with gcc. */ > +/* Copyright (C) 1997-2017 Free Software Foundation, Inc. > + > +This file is part of GCC. > + > +GCC is free software; you can redistribute it and/or modify it under > +the terms of the GNU General Public License as published by the Free > +Software Foundation; either version 3, or (at your option) any later > +version. > + > +GCC is distributed in the hope that it will be useful, but WITHOUT ANY > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > +for more details. > + > +Under Section 7 of GPL version 3, you are granted additional > +permissions described in the GCC Runtime Library Exception, version > +3.1, as published by the Free Software Foundation. > + > +You should have received a copy of the GNU General Public License and > +a copy of the GCC Runtime Library Exception along with this program; > +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +<http://www.gnu.org/licenses/>. */ > + > +#ifndef GCC_GTHR_H > +#define GCC_GTHR_H > + > +#ifndef HIDE_EXPORTS > +#pragma GCC visibility push(default) > +#endif > + > +/* If this file is compiled with threads support, it must > + #define __GTHREADS 1 > + to indicate that threads support is present. Also it has define > + function > + int __gthread_active_p () > + that returns 1 if thread system is active, 0 if not. > + > + The threads interface must define the following types: > + __gthread_key_t > + __gthread_once_t > + __gthread_mutex_t > + __gthread_recursive_mutex_t > + > + The threads interface must define the following macros: > + > + __GTHREAD_ONCE_INIT > + to initialize __gthread_once_t > + __GTHREAD_MUTEX_INIT > + to initialize __gthread_mutex_t to get a fast > + non-recursive mutex. > + __GTHREAD_MUTEX_INIT_FUNCTION > + to initialize __gthread_mutex_t to get a fast > + non-recursive mutex. > + Define this to a function which looks like this: > + void __GTHREAD_MUTEX_INIT_FUNCTION (__gthread_mutex_t *) > + Some systems can't initialize a mutex without a > + function call. Don't define __GTHREAD_MUTEX_INIT in this case. > + __GTHREAD_RECURSIVE_MUTEX_INIT > + __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION > + as above, but for a recursive mutex. > + > + The threads interface must define the following static functions: > + > + int __gthread_once (__gthread_once_t *once, void (*func) ()) > + > + int __gthread_key_create (__gthread_key_t *keyp, void (*dtor) (void *)) > + int __gthread_key_delete (__gthread_key_t key) > + > + void *__gthread_getspecific (__gthread_key_t key) > + int __gthread_setspecific (__gthread_key_t key, const void *ptr) > + > + int __gthread_mutex_destroy (__gthread_mutex_t *mutex); > + int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t > *mutex); > + > + int __gthread_mutex_lock (__gthread_mutex_t *mutex); > + int __gthread_mutex_trylock (__gthread_mutex_t *mutex); > + int __gthread_mutex_unlock (__gthread_mutex_t *mutex); > + > + int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex); > + int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t > *mutex); > + int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t > *mutex); > + > + The following are supported in POSIX threads only. They are required to > + fix a deadlock in static initialization inside libsupc++. The header file > + gthr-posix.h defines a symbol __GTHREAD_HAS_COND to signify that these > extra > + features are supported. > + > + Types: > + __gthread_cond_t > + > + Macros: > + __GTHREAD_COND_INIT > + __GTHREAD_COND_INIT_FUNCTION > + > + Interface: > + int __gthread_cond_broadcast (__gthread_cond_t *cond); > + int __gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t > *mutex); > + int __gthread_cond_wait_recursive (__gthread_cond_t *cond, > + __gthread_recursive_mutex_t *mutex); > + > + All functions returning int should return zero on success or the error > + number. If the operation is not supported, -1 is returned. > + > + If the following are also defined, you should > + #define __GTHREADS_CXX0X 1 > + to enable the c++0x thread library. > + > + Types: > + __gthread_t > + __gthread_time_t > + > + Interface: > + int __gthread_create (__gthread_t *thread, void *(*func) (void*), > + void *args); > + int __gthread_join (__gthread_t thread, void **value_ptr); > + int __gthread_detach (__gthread_t thread); > + int __gthread_equal (__gthread_t t1, __gthread_t t2); > + __gthread_t __gthread_self (void); > + int __gthread_yield (void); > + > + int __gthread_mutex_timedlock (__gthread_mutex_t *m, > + const __gthread_time_t *abs_timeout); > + int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *m, > + const __gthread_time_t *abs_time); > + > + int __gthread_cond_signal (__gthread_cond_t *cond); > + int __gthread_cond_timedwait (__gthread_cond_t *cond, > + __gthread_mutex_t *mutex, > + const __gthread_time_t *abs_timeout); > + > +*/ > + > +#if SUPPORTS_WEAK > +/* The pe-coff weak support isn't fully compatible to ELF's weak. > + For static libraries it might would work, but as we need to deal > + with shared versions too, we disable it for mingw-targets. */ > +#ifdef __MINGW32__ > +#undef GTHREAD_USE_WEAK > +#define GTHREAD_USE_WEAK 0 > +#endif > + > +#ifndef GTHREAD_USE_WEAK > +#define GTHREAD_USE_WEAK 1 > +#endif > +#endif > +#include "gthr-default.h" > + > +#ifndef HIDE_EXPORTS > +#pragma GCC visibility pop > +#endif > + > +#endif /* ! GCC_GTHR_H */ > diff --git a/libgcov/include/hashtab.h b/libgcov/include/hashtab.h > new file mode 100644 > index 0000000..b5682f8 > --- /dev/null > +++ b/libgcov/include/hashtab.h > @@ -0,0 +1,204 @@ > +/* An expandable hash tables datatype. > + Copyright (C) 1999-2017 Free Software Foundation, Inc. > + Contributed by Vladimir Makarov (vmakarov@xxxxxxxxxx). > + > +This program 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 2 of the License, or > +(at your option) any later version. > + > +This program is distributed in the hope that it will be useful, > +but WITHOUT ANY WARRANTY; without even the implied warranty of > +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +GNU General Public License for more details. > + > +You should have received a copy of the GNU General Public License > +along with this program; if not, write to the Free Software > +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, > USA. */ > + > +/* This package implements basic hash table functionality. It is possible > + to search for an entry, create an entry and destroy an entry. > + > + Elements in the table are generic pointers. > + > + The size of the table is not fixed; if the occupancy of the table > + grows too high the hash table will be expanded. > + > + The abstract data implementation is based on generalized Algorithm D > + from Knuth's book "The art of computer programming". Hash table is > + expanded by creation of new hash table and transferring elements from > + the old table to the new table. */ > + > +#ifndef __HASHTAB_H__ > +#define __HASHTAB_H__ > + > +#ifdef __cplusplus > +extern "C" { > +#endif /* __cplusplus */ > + > +#include "ansidecl.h" > + > +/* The type for a hash code. */ > +typedef unsigned int hashval_t; > + > +/* Callback function pointer types. */ > + > +/* Calculate hash of a table entry. */ > +typedef hashval_t (*htab_hash) (const void *); > + > +/* Compare a table entry with a possible entry. The entry already in > + the table always comes first, so the second element can be of a > + different type (but in this case htab_find and htab_find_slot > + cannot be used; instead the variants that accept a hash value > + must be used). */ > +typedef int (*htab_eq) (const void *, const void *); > + > +/* Cleanup function called whenever a live element is removed from > + the hash table. */ > +typedef void (*htab_del) (void *); > + > +/* Function called by htab_traverse for each live element. The first > + arg is the slot of the element (which can be passed to htab_clear_slot > + if desired), the second arg is the auxiliary pointer handed to > + htab_traverse. Return 1 to continue scan, 0 to stop. */ > +typedef int (*htab_trav) (void **, void *); > + > +/* Memory-allocation function, with the same functionality as calloc(). > + Iff it returns NULL, the hash table implementation will pass an error > + code back to the user, so if your code doesn't handle errors, > + best if you use xcalloc instead. */ > +typedef void *(*htab_alloc) (size_t, size_t); > + > +/* We also need a free() routine. */ > +typedef void (*htab_free) (void *); > + > +/* Memory allocation and deallocation; variants which take an extra > + argument. */ > +typedef void *(*htab_alloc_with_arg) (void *, size_t, size_t); > +typedef void (*htab_free_with_arg) (void *, void *); > + > +/* This macro defines reserved value for empty table entry. */ > + > +#define HTAB_EMPTY_ENTRY ((PTR) 0) > + > +/* This macro defines reserved value for table entry which contained > + a deleted element. */ > + > +#define HTAB_DELETED_ENTRY ((PTR) 1) > + > +/* Hash tables are of the following type. The structure > + (implementation) of this type is not needed for using the hash > + tables. All work with hash table should be executed only through > + functions mentioned below. The size of this structure is subject to > + change. */ > + > +struct htab { > + /* Pointer to hash function. */ > + htab_hash hash_f; > + > + /* Pointer to comparison function. */ > + htab_eq eq_f; > + > + /* Pointer to cleanup function. */ > + htab_del del_f; > + > + /* Table itself. */ > + void **entries; > + > + /* Current size (in entries) of the hash table. */ > + size_t size; > + > + /* Current number of elements including also deleted elements. */ > + size_t n_elements; > + > + /* Current number of deleted elements in the table. */ > + size_t n_deleted; > + > + /* The following member is used for debugging. Its value is number > + of all calls of `htab_find_slot' for the hash table. */ > + unsigned int searches; > + > + /* The following member is used for debugging. Its value is number > + of collisions fixed for time of work with the hash table. */ > + unsigned int collisions; > + > + /* Pointers to allocate/free functions. */ > + htab_alloc alloc_f; > + htab_free free_f; > + > + /* Alternate allocate/free functions, which take an extra argument. */ > + void *alloc_arg; > + htab_alloc_with_arg alloc_with_arg_f; > + htab_free_with_arg free_with_arg_f; > + > + /* Current size (in entries) of the hash table, as an index into the > + table of primes. */ > + unsigned int size_prime_index; > +}; > + > +typedef struct htab *htab_t; > + > +/* An enum saying whether we insert into the hash table or not. */ > +enum insert_option {NO_INSERT, INSERT}; > + > +/* The prototypes of the package functions. */ > + > +extern htab_t htab_create_alloc (size_t, htab_hash, > + htab_eq, htab_del, > + htab_alloc, htab_free); > + > +extern htab_t htab_create_alloc_ex (size_t, htab_hash, > + htab_eq, htab_del, > + void *, htab_alloc_with_arg, > + htab_free_with_arg); > + > +extern htab_t htab_create_typed_alloc (size_t, htab_hash, htab_eq, htab_del, > + htab_alloc, htab_alloc, htab_free); > + > +/* Backward-compatibility functions. */ > +extern htab_t htab_create (size_t, htab_hash, htab_eq, htab_del); > +extern htab_t htab_try_create (size_t, htab_hash, htab_eq, htab_del); > + > +extern void htab_set_functions_ex (htab_t, htab_hash, > + htab_eq, htab_del, > + void *, htab_alloc_with_arg, > + htab_free_with_arg); > + > +extern void htab_delete (htab_t); > +extern void htab_empty (htab_t); > + > +extern void * htab_find (htab_t, const void *); > +extern void ** htab_find_slot (htab_t, const void *, enum > insert_option); > +extern void * htab_find_with_hash (htab_t, const void *, hashval_t); > +extern void ** htab_find_slot_with_hash (htab_t, const void *, > + hashval_t, enum insert_option); > +extern void htab_clear_slot (htab_t, void **); > +extern void htab_remove_elt (htab_t, void *); > +extern void htab_remove_elt_with_hash (htab_t, void *, hashval_t); > + > +extern void htab_traverse (htab_t, htab_trav, void *); > +extern void htab_traverse_noresize (htab_t, htab_trav, void *); > + > +extern size_t htab_size (htab_t); > +extern size_t htab_elements (htab_t); > +extern double htab_collisions (htab_t); > + > +/* A hash function for pointers. */ > +extern htab_hash htab_hash_pointer; > + > +/* An equality function for pointers. */ > +extern htab_eq htab_eq_pointer; > + > +/* A hash function for null-terminated strings. */ > +extern hashval_t htab_hash_string (const void *); > + > +/* An iterative hash function for arbitrary data. */ > +extern hashval_t iterative_hash (const void *, size_t, hashval_t); > +/* Shorthand for hashing something with an intrinsic size. */ > +#define iterative_hash_object(OB,INIT) iterative_hash (&OB, sizeof (OB), > INIT) > + > +#ifdef __cplusplus > +} > +#endif /* __cplusplus */ > + > +#endif /* __HASHTAB_H */ > diff --git a/libgcov/include/libgcov.h b/libgcov/include/libgcov.h > new file mode 100644 > index 0000000..eb5a914 > --- /dev/null > +++ b/libgcov/include/libgcov.h > @@ -0,0 +1,346 @@ > +/* Header file for libgcov-*.c. > + Copyright (C) 1996-2017 Free Software Foundation, Inc. > + > + This file is part of GCC. > + > + GCC is free software; you can redistribute it and/or modify it under > + the terms of the GNU General Public License as published by the Free > + Software Foundation; either version 3, or (at your option) any later > + version. > + > + GCC is distributed in the hope that it will be useful, but WITHOUT ANY > + WARRANTY; without even the implied warranty of MERCHANTABILITY or > + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > + for more details. > + > + Under Section 7 of GPL version 3, you are granted additional > + permissions described in the GCC Runtime Library Exception, version > + 3.1, as published by the Free Software Foundation. > + > + You should have received a copy of the GNU General Public License and > + a copy of the GCC Runtime Library Exception along with this program; > + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > + <http://www.gnu.org/licenses/>. */ > + > +#ifndef GCC_LIBGCOV_H > +#define GCC_LIBGCOV_H > + > +/* work around the poisoned malloc/calloc in system.h. */ > +#ifndef xmalloc > +#define xmalloc malloc > +#endif > +#ifndef xcalloc > +#define xcalloc calloc > +#endif > + > +#ifndef IN_GCOV_TOOL > +/* About the target. */ > +/* This path will be used by libgcov runtime. */ > + > +#include "tconfig.h" > +#include "auto-target.h" > +#include "tsystem.h" > +#include "coretypes.h" > +#include "tm.h" > +#include "libgcc_tm.h" > +#include "gcov.h" > + > +#if __CHAR_BIT__ == 8 > +typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI))); > +typedef unsigned gcov_position_t __attribute__ ((mode (SI))); > +#if LONG_LONG_TYPE_SIZE > 32 > +typedef signed gcov_type __attribute__ ((mode (DI))); > +typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI))); > +#else > +typedef signed gcov_type __attribute__ ((mode (SI))); > +typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI))); > +#endif > +#else > +#if __CHAR_BIT__ == 16 > +typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI))); > +typedef unsigned gcov_position_t __attribute__ ((mode (HI))); > +#if LONG_LONG_TYPE_SIZE > 32 > +typedef signed gcov_type __attribute__ ((mode (SI))); > +typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI))); > +#else > +typedef signed gcov_type __attribute__ ((mode (HI))); > +typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI))); > +#endif > +#else > +typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI))); > +typedef unsigned gcov_position_t __attribute__ ((mode (QI))); > +#if LONG_LONG_TYPE_SIZE > 32 > +typedef signed gcov_type __attribute__ ((mode (HI))); > +typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI))); > +#else > +typedef signed gcov_type __attribute__ ((mode (QI))); > +typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI))); > +#endif > +#endif > +#endif > + > +#if defined (TARGET_POSIX_IO) > +#define GCOV_LOCKED 1 > +#else > +#define GCOV_LOCKED 0 > +#endif > + > +/* In libgcov we need these functions to be extern, so prefix them with > + __gcov. In libgcov they must also be hidden so that the instance in > + the executable is not also used in a DSO. */ > +#define gcov_var __gcov_var > +#define gcov_open __gcov_open > +#define gcov_close __gcov_close > +#define gcov_write_tag_length __gcov_write_tag_length > +#define gcov_position __gcov_position > +#define gcov_seek __gcov_seek > +#define gcov_rewrite __gcov_rewrite > +#define gcov_is_error __gcov_is_error > +#define gcov_write_unsigned __gcov_write_unsigned > +#define gcov_write_counter __gcov_write_counter > +#define gcov_write_summary __gcov_write_summary > +#define gcov_read_unsigned __gcov_read_unsigned > +#define gcov_read_counter __gcov_read_counter > +#define gcov_read_summary __gcov_read_summary > +#define gcov_sort_n_vals __gcov_sort_n_vals > + > +#else /* IN_GCOV_TOOL */ > +/* About the host. */ > +/* This path will be compiled for the host and linked into > + gcov-tool binary. */ > + > +#include "config.h" > +#include "system.h" > +#include "coretypes.h" > +#include "tm.h" > + > +typedef unsigned gcov_unsigned_t; > +typedef unsigned gcov_position_t; > +/* gcov_type is typedef'd elsewhere for the compiler */ > +#if defined (HOST_HAS_F_SETLKW) > +#define GCOV_LOCKED 1 > +#else > +#define GCOV_LOCKED 0 > +#endif > + > +/* Some Macros specific to gcov-tool. */ > + > +#define L_gcov 1 > +#define L_gcov_merge_add 1 > +#define L_gcov_merge_single 1 > +#define L_gcov_merge_ior 1 > +#define L_gcov_merge_time_profile 1 > +#define L_gcov_merge_icall_topn 1 > + > +extern gcov_type gcov_read_counter_mem (); > +extern unsigned gcov_get_merge_weight (); > +extern struct gcov_info *gcov_list; > + > +#endif /* !IN_GCOV_TOOL */ > + > +#if defined(inhibit_libc) > +#define IN_LIBGCOV (-1) > +#else > +#define IN_LIBGCOV 1 > +#if defined(L_gcov) > +#define GCOV_LINKAGE /* nothing */ > +#endif > +#endif > + > +/* Poison these, so they don't accidentally slip in. */ > +#pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length > +#pragma GCC poison gcov_time gcov_magic > + > +#ifdef HAVE_GAS_HIDDEN > +#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) > +#else > +#define ATTRIBUTE_HIDDEN > +#endif > + > +#include "gcov-io.h" > + > +/* Structures embedded in coveraged program. The structures generated > + by write_profile must match these. */ > + > +/* Information about counters for a single function. */ > +struct gcov_ctr_info > +{ > + gcov_unsigned_t num; /* number of counters. */ > + gcov_type *values; /* their values. */ > +}; > + > +/* Information about a single function. This uses the trailing array > + idiom. The number of counters is determined from the merge pointer > + array in gcov_info. The key is used to detect which of a set of > + comdat functions was selected -- it points to the gcov_info object > + of the object file containing the selected comdat function. */ > + > +struct gcov_fn_info > +{ > + const struct gcov_info *key; /* comdat key */ > + gcov_unsigned_t ident; /* unique ident of function */ > + gcov_unsigned_t lineno_checksum; /* function lineo_checksum */ > + gcov_unsigned_t cfg_checksum; /* function cfg checksum */ > + struct gcov_ctr_info ctrs[1]; /* instrumented counters */ > +}; > + > +/* Type of function used to merge counters. */ > +typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t); > + > +/* Information about a single object file. */ > +struct gcov_info > +{ > + gcov_unsigned_t version; /* expected version number */ > + struct gcov_info *next; /* link to next, used by libgcov */ > + > + gcov_unsigned_t stamp; /* uniquifying time stamp */ > + const char *filename; /* output file name */ > + > + gcov_merge_fn merge[GCOV_COUNTERS]; /* merge functions (null for > + unused) */ > + > + unsigned n_functions; /* number of functions */ > + > +#ifndef IN_GCOV_TOOL > + const struct gcov_fn_info *const *functions; /* pointer to pointers > + to function information */ > +#else > + const struct gcov_fn_info **functions; > +#endif /* !IN_GCOV_TOOL */ > +}; > + > +/* Root of a program/shared-object state */ > +struct gcov_root > +{ > + struct gcov_info *list; > + unsigned dumped : 1; /* counts have been dumped. */ > + unsigned run_counted : 1; /* run has been accounted for. */ > + struct gcov_root *next; > + struct gcov_root *prev; > +}; > + > +extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN; > + > +struct gcov_master > +{ > + gcov_unsigned_t version; > + struct gcov_root *root; > +}; > + > +/* Exactly one of these will be active in the process. */ > +extern struct gcov_master __gcov_master; > + > +/* Dump a set of gcov objects. */ > +extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN; > + > +/* Register a new object file module. */ > +extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN; > + > +/* GCOV exit function registered via a static destructor. */ > +extern void __gcov_exit (void) ATTRIBUTE_HIDDEN; > + > +/* Function to reset all counters to 0. Both externally visible (and > + overridable) and internal version. */ > +extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN; > + > +/* User function to enable early write of profile information so far. */ > +extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN; > + > +/* The merge function that just sums the counters. */ > +extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; > + > +/* The merge function to select the minimum valid counter value. */ > +extern void __gcov_merge_time_profile (gcov_type *, unsigned) > ATTRIBUTE_HIDDEN; > + > +/* The merge function to choose the most common value. */ > +extern void __gcov_merge_single (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; > + > +/* The merge function that just ors the counters together. */ > +extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; > + > +/* The merge function is used for topn indirect call counters. */ > +extern void __gcov_merge_icall_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; > + > +/* The profiler functions. */ > +extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned); > +extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int, > + unsigned); > +extern void __gcov_pow2_profiler (gcov_type *, gcov_type); > +extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type); > +extern void __gcov_one_value_profiler (gcov_type *, gcov_type); > +extern void __gcov_one_value_profiler_atomic (gcov_type *, gcov_type); > +extern void __gcov_indirect_call_profiler_v2 (gcov_type, void *); > +extern void __gcov_time_profiler (gcov_type *); > +extern void __gcov_time_profiler_atomic (gcov_type *); > +extern void __gcov_average_profiler (gcov_type *, gcov_type); > +extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type); > +extern void __gcov_ior_profiler (gcov_type *, gcov_type); > +extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type); > +extern void __gcov_indirect_call_topn_profiler (gcov_type, void *); > +extern void gcov_sort_n_vals (gcov_type *, int); > + > +#ifndef inhibit_libc > +/* The wrappers around some library functions.. */ > +extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN; > +extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN; > +extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN; > +extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN; > +extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN; > +extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN; > +extern int __gcov_execve (const char *, char *const [], char *const []) > + ATTRIBUTE_HIDDEN; > + > +/* Functions that only available in libgcov. */ > +GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN; > +GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN; > +GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t) > + ATTRIBUTE_HIDDEN; > +GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/, > + const struct gcov_summary *) > + ATTRIBUTE_HIDDEN; > +GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; > +GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN; > + > +/* "Counts" stored in gcda files can be a real counter value, or > + an target address. When differentiate these two types because > + when manipulating counts, we should only change real counter values, > + rather target addresses. */ > + > +static inline gcov_type > +gcov_get_counter (void) > +{ > +#ifndef IN_GCOV_TOOL > + /* This version is for reading count values in libgcov runtime: > + we read from gcda files. */ > + > + return gcov_read_counter (); > +#else > + /* This version is for gcov-tool. We read the value from memory and > + multiply it by the merge weight. */ > + > + return gcov_read_counter_mem () * gcov_get_merge_weight (); > +#endif > +} > + > +/* Similar function as gcov_get_counter(), but handles target address > + counters. */ > + > +static inline gcov_type > +gcov_get_counter_target (void) > +{ > +#ifndef IN_GCOV_TOOL > + /* This version is for reading count target values in libgcov runtime: > + we read from gcda files. */ > + > + return gcov_read_counter (); > +#else > + /* This version is for gcov-tool. We read the value from memory and we do > NOT > + multiply it by the merge weight. */ > + > + return gcov_read_counter_mem (); > +#endif > +} > + > +#endif /* !inhibit_libc */ > + > +#endif /* GCC_LIBGCOV_H */ > diff --git a/libgcov/include/tsystem.h b/libgcov/include/tsystem.h > new file mode 100644 > index 0000000..37c941b > --- /dev/null > +++ b/libgcov/include/tsystem.h > @@ -0,0 +1,137 @@ > +/* Get common system includes and various definitions and declarations > + based on target macros. > + Copyright (C) 2000-2017 Free Software Foundation, Inc. > + > +This file is part of GCC. > + > +GCC is free software; you can redistribute it and/or modify it under > +the terms of the GNU General Public License as published by the Free > +Software Foundation; either version 3, or (at your option) any later > +version. > + > +GCC is distributed in the hope that it will be useful, but WITHOUT ANY > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License > +for more details. > + > +Under Section 7 of GPL version 3, you are granted additional > +permissions described in the GCC Runtime Library Exception, version > +3.1, as published by the Free Software Foundation. > + > +You should have received a copy of the GNU General Public License and > +a copy of the GCC Runtime Library Exception along with this program; > +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see > +<http://www.gnu.org/licenses/>. */ > + > +#ifndef GCC_TSYSTEM_H > +#define GCC_TSYSTEM_H > + > +/* System headers (e.g. stdio.h, stdlib.h, unistd.h) sometimes > + indirectly include getopt.h. Our -I flags will cause gcc's gnu > + getopt.h to be included, not the platform's copy. In the default > + case, gnu getopt.h will provide us with a no-argument prototype > + which will generate -Wstrict-prototypes warnings. None of the > + target files actually use getopt, so it is safe to tell gnu > + getopt.h we never need this prototype. */ > +#ifndef HAVE_DECL_GETOPT > +#define HAVE_DECL_GETOPT 1 > +#endif > + > +/* We want everything from the glibc headers. */ > +#define _GNU_SOURCE 1 > + > +/* GCC supplies these headers. */ > +#include <stddef.h> > +#include <float.h> > + > +#ifdef inhibit_libc > + > +#ifndef malloc > +extern void *malloc (size_t); > +#endif > + > +#ifndef free > +extern void free (void *); > +#endif > + > +#ifndef atexit > +extern int atexit (void (*)(void)); > +#endif > + > +#ifndef abort > +extern void abort (void) __attribute__ ((__noreturn__)); > +#endif > + > +#ifndef strlen > +extern size_t strlen (const char *); > +#endif > + > +#ifndef memcpy > +extern void *memcpy (void *, const void *, size_t); > +#endif > + > +#ifndef memset > +extern void *memset (void *, int, size_t); > +#endif > + > +#else /* ! inhibit_libc */ > +/* We disable this when inhibit_libc, so that gcc can still be built without > + needing header files first. */ > +/* ??? This is not a good solution, since prototypes may be required in > + some cases for correct code. */ > + > +/* GCC supplies this header. */ > +#include <stdarg.h> > + > +/* All systems have this header. */ > +#include <stdio.h> > + > +/* All systems have this header. */ > +#include <sys/types.h> > + > +/* All systems have this header. */ > +#include <errno.h> > + > +#ifndef errno > +extern int errno; > +#endif > + > +/* If these system headers do not exist, fixincludes must create them. */ > +#include <string.h> > +#include <stdlib.h> > +#include <unistd.h> > + > +/* GCC supplies this header. */ > +#include <limits.h> > + > +/* If these system headers do not exist, fixincludes must create them. */ > +#include <time.h> > + > +#endif /* inhibit_libc */ > + > +/* Define a generic NULL if one hasn't already been defined. */ > +#ifndef NULL > +#define NULL 0 > +#endif > + > +/* GCC always provides __builtin_alloca(x). */ > +#undef alloca > +#define alloca(x) __builtin_alloca(x) > + > +#ifdef ENABLE_RUNTIME_CHECKING > +#define gcc_assert(EXPR) ((void)(!(EXPR) ? abort (), 0 : 0)) > +#else > +/* Include EXPR, so that unused variable warnings do not occur. */ > +#define gcc_assert(EXPR) ((void)(0 && (EXPR))) > +#endif > +/* Use gcc_unreachable() to mark unreachable locations (like an > + unreachable default case of a switch. Do not use gcc_assert(0). */ > +#define gcc_unreachable() (abort ()) > + > +#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; > TOTYPE _nq;})(X))._nq) > +#define CONST_CAST(TYPE,X) CONST_CAST2 (TYPE, const TYPE, (X)) > + > +/* Filename handling macros. */ > +#include "filenames.h" > + > +#endif /* ! GCC_TSYSTEM_H */ > diff --git a/libgcov/include/value-unwind.h b/libgcov/include/value-unwind.h > new file mode 100644 > index 0000000..a4c32e0 > --- /dev/null > +++ b/libgcov/include/value-unwind.h > @@ -0,0 +1,25 @@ > +/* Store register values as _Unwind_Word type in DWARF2 EH unwind context. > + Copyright (C) 2011-2017 Free Software Foundation, Inc. > + > + This file is part of GCC. > + > + GCC is free software; you can redistribute it and/or modify it > + under the terms of the GNU General Public License as published > + by the Free Software Foundation; either version 3, or (at your > + option) any later version. > + > + GCC is distributed in the hope that it will be useful, but WITHOUT > + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY > + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public > + License for more details. > + > + You should have received a copy of the GNU General Public License 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/>. */ > + > +/* Define this macro if the target stores register values as _Unwind_Word > + type in unwind context. Only enable it for x32. */ > +#if defined __x86_64 && !defined __LP64__ > +# define REG_VALUE_IN_UNWIND_CONTEXT > +#endif >

©2013 Xen Project, A Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation.
Xen Project is a trademark of The Linux Foundation.