diff options
Diffstat (limited to 'lib/gcc/arm-eabi/4.6.x-google/plugin/include')
135 files changed, 80772 insertions, 0 deletions
diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ada/gcc-interface/ada-tree.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ada/gcc-interface/ada-tree.def new file mode 100644 index 0000000..93967b5 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ada/gcc-interface/ada-tree.def @@ -0,0 +1,74 @@ +/**************************************************************************** + * * + * GNAT COMPILER COMPONENTS * + * * + * GNAT-SPECIFIC GCC TREE CODES * + * * + * Specification * + * * + * Copyright (C) 1992-2009, Free Software Foundation, Inc. * + * * + * GNAT is free software; you can redistribute it and/or modify it under * + * terms of the GNU General Public License as published by the Free Soft- * + * ware Foundation; either version 3, or (at your option) any later ver- * + * sion. GNAT is distributed in the hope that it will be useful, but WITH- * + * OUT 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/>. * + * * + * GNAT was originally developed by the GNAT team at New York University. * + * Extensive contributions were provided by Ada Core Technologies Inc. * + * * + ****************************************************************************/ + +/* A type that is an unconstrained array. This node is never passed to GCC. + TREE_TYPE is the type of the fat pointer and TYPE_OBJECT_RECORD_TYPE is + the type of a record containing the template and data. */ +DEFTREECODE (UNCONSTRAINED_ARRAY_TYPE, "unconstrained_array_type", tcc_type, 0) + +/* A reference to an unconstrained array. This node only exists as an + intermediate node during the translation of a GNAT tree to a GCC tree; + it is never passed to GCC. The only field used is operand 0, which + is the fat pointer object. */ +DEFTREECODE (UNCONSTRAINED_ARRAY_REF, "unconstrained_array_ref", + tcc_reference, 1) + +/* An expression that returns an RTL suitable for its type. Operand 0 + is an expression to be evaluated for side effects only. */ +DEFTREECODE (NULL_EXPR, "null_expr", tcc_expression, 1) + +/* Same as PLUS_EXPR, except that no modulo reduction is applied. + This is used for loops and never shows up in the tree. */ +DEFTREECODE (PLUS_NOMOD_EXPR, "plus_nomod_expr", tcc_binary, 2) + +/* Same as MINUS_EXPR, except that no modulo reduction is applied. + This is used for loops and never shows up in the tree. */ +DEFTREECODE (MINUS_NOMOD_EXPR, "minus_nomod_expr", tcc_binary, 2) + +/* Same as ADDR_EXPR, except that if the operand represents a bit field, + return the address of the byte containing the bit. This is used + for the Address attribute and never shows up in the tree. */ +DEFTREECODE (ATTR_ADDR_EXPR, "attr_addr_expr", tcc_reference, 1) + +/* Here are the tree codes for the statement types known to Ada. These + must be at the end of this file to allow IS_ADA_STMT to work. */ + +/* This is how record_code_position and insert_code_for work. The former + makes this tree node, whose operand is a statement. The latter inserts + the actual statements into this node. Gimplification consists of + just returning the inner statement. */ +DEFTREECODE (STMT_STMT, "stmt_stmt", tcc_statement, 1) + +/* A loop. LOOP_STMT_COND is the test to exit the loop. LOOP_STMT_UPDATE + is the statement to update the loop iteration variable at the continue + point. LOOP_STMT_BODY are the statements in the body of the loop. And + LOOP_STMT_LABEL points to the LABEL_DECL of the end label of the loop. */ +DEFTREECODE (LOOP_STMT, "loop_stmt", tcc_statement, 4) + +/* Conditionally exit a loop. EXIT_STMT_COND is the condition, which, if + true, will cause the loop to be exited. If no condition is specified, + the loop is unconditionally exited. EXIT_STMT_LABEL is the end label + corresponding to the loop to exit. */ +DEFTREECODE (EXIT_STMT, "exit_stmt", tcc_statement, 2) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/alias.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/alias.h new file mode 100644 index 0000000..49905b1 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/alias.h @@ -0,0 +1,53 @@ +/* Exported functions from alias.c + Copyright (C) 2004, 2007, 2008, 2009, 2010 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/>. */ + +#ifndef GCC_ALIAS_H +#define GCC_ALIAS_H + +#include "coretypes.h" + +/* 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; + +extern alias_set_type new_alias_set (void); +extern alias_set_type get_alias_set (tree); +extern alias_set_type get_deref_alias_set (tree); +extern alias_set_type get_varargs_alias_set (void); +extern alias_set_type get_frame_alias_set (void); +extern bool component_uses_parent_alias_set (const_tree); +extern bool alias_set_subset_of (alias_set_type, alias_set_type); +extern void record_alias_subset (alias_set_type, alias_set_type); +extern void record_component_aliases (tree); +extern int alias_sets_conflict_p (alias_set_type, alias_set_type); +extern int alias_sets_must_conflict_p (alias_set_type, alias_set_type); +extern int objects_must_conflict_p (tree, tree); +extern int nonoverlapping_memrefs_p (const_rtx, const_rtx, bool); + +/* This alias set can be used to force a memory to conflict with all + other memories, creating a barrier across which no memory reference + can move. Note that there are other legacy ways to create such + memory barriers, including an address of SCRATCH. */ +#define ALIAS_SET_MEMORY_BARRIER ((alias_set_type) -1) + +#endif /* GCC_ALIAS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/all-tree.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/all-tree.def new file mode 100644 index 0000000..8a2da69 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/all-tree.def @@ -0,0 +1,7 @@ +#include "tree.def" +END_OF_BASE_TREE_CODES +#include "c-family/c-common.def" +#include "ada/gcc-interface/ada-tree.def" +#include "cp/cp-tree.def" +#include "java/java-tree.def" +#include "objc/objc-tree.def" diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ansidecl.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ansidecl.h new file mode 100644 index 0000000..8b76647 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ansidecl.h @@ -0,0 +1,423 @@ +/* ANSI and traditional C compatability macros + Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, + 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010 + 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 + ----- ---- - ---------- ----------- - ---------- + ANSI_PROTOTYPES 1 not defined + PTR `void *' `char *' + PTRCONST `void *const' `char *' + LONG_DOUBLE `long double' `double' + const not defined `' + volatile not defined `' + signed not defined `' + VA_START(ap, var) va_start(ap, var) va_start(ap) + + Note that it is safe to write "void foo();" indicating a function + with no return value, in all K+R compilers we have been able to test. + + For declaring functions with prototypes, we also provide these: + + PARAMS ((prototype)) + -- for functions which take a fixed number of arguments. Use this + when declaring the function. When defining the function, write a + K+R style argument list. For example: + + char *strcpy PARAMS ((char *dest, char *source)); + ... + char * + strcpy (dest, source) + char *dest; + char *source; + { ... } + + + VPARAMS ((prototype, ...)) + -- for functions which take a variable number of arguments. Use + PARAMS to declare the function, VPARAMS to define it. For example: + + int printf PARAMS ((const char *format, ...)); + ... + int + printf VPARAMS ((const char *format, ...)) + { + ... + } + + For writing functions which take variable numbers of arguments, we + also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros. These + hide the differences between K+R <varargs.h> and C89 <stdarg.h> more + thoroughly than the simple VA_START() macro mentioned above. + + VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end. + Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls + corresponding to the list of fixed arguments. Then use va_arg + normally to get the variable arguments, or pass your va_list object + around. You do not declare the va_list yourself; VA_OPEN does it + for you. + + Here is a complete example: + + int + printf VPARAMS ((const char *format, ...)) + { + int result; + + VA_OPEN (ap, format); + VA_FIXEDARG (ap, const char *, format); + + result = vfprintf (stdout, format, ap); + VA_CLOSE (ap); + + return result; + } + + + You can declare variables either before or after the VA_OPEN, + VA_FIXEDARG sequence. Also, VA_OPEN and VA_CLOSE are the beginning + and end of a block. They must appear at the same nesting level, + and any variables declared after VA_OPEN go out of scope at + VA_CLOSE. Unfortunately, with a K+R compiler, that includes the + argument list. You can have multiple instances of VA_OPEN/VA_CLOSE + pairs in a single function in case you need to traverse the + argument list more than once. + + 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. + + This header also defines a lot of obsolete macros: + CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID, + AND, DOTS, NOARGS. Don't use them. */ + +#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@alumni.rice.edu: 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 ANSI_PROTOTYPES 1 +#define PTR void * +#define PTRCONST void *const +#define LONG_DOUBLE long double + +/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in + a #ifndef. */ +#ifndef PARAMS +#define PARAMS(ARGS) ARGS +#endif + +#define VPARAMS(ARGS) ARGS +#define VA_START(VA_LIST, VAR) va_start(VA_LIST, VAR) + +/* variadic function helper macros */ +/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's + use without inhibiting further decls and without declaring an + actual variable. */ +#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP, VAR); { struct Qdmy +#define VA_CLOSE(AP) } va_end(AP); } +#define VA_FIXEDARG(AP, T, N) struct Qdmy + +#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 + +/* These are obsolete. Do not use. */ +#ifndef IN_GCC +#define CONST const +#define VOLATILE volatile +#define SIGNED signed + +#define PROTO(type, name, arglist) type name arglist +#define EXFUN(name, proto) name proto +#define DEFUN(name, arglist, args) name(args) +#define DEFUN_VOID(name) name(void) +#define AND , +#define DOTS , ... +#define NOARGS void +#endif /* ! IN_GCC */ + +#else /* Not ANSI C. */ + +#undef ANSI_PROTOTYPES +#define PTR char * +#define PTRCONST PTR +#define LONG_DOUBLE double + +#define PARAMS(args) () +#define VPARAMS(args) (va_alist) va_dcl +#define VA_START(va_list, var) va_start(va_list) + +#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP); { struct Qdmy +#define VA_CLOSE(AP) } va_end(AP); } +#define VA_FIXEDARG(AP, TYPE, NAME) TYPE NAME = va_arg(AP, TYPE) + +/* 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 + +#ifndef IN_GCC +#define CONST +#define VOLATILE +#define SIGNED + +#define PROTO(type, name, arglist) type name () +#define EXFUN(name, proto) name() +#define DEFUN(name, arglist, args) name arglist args; +#define DEFUN_VOID(name) name() +#define AND ; +#define DOTS +#define NOARGS +#endif /* ! IN_GCC */ + +#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 + +#ifndef ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +#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 `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 much 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 */ + +/* 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 + +#ifdef __cplusplus +} +#endif + +#endif /* ansidecl.h */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/auto-host.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/auto-host.h new file mode 100644 index 0000000..9f02010 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/auto-host.h @@ -0,0 +1,1991 @@ +/* auto-host.h. Generated from config.in by configure. */ +/* config.in. Generated from configure.ac by autoheader. */ + +/* Define if building universal (internal helper macro) */ +#ifndef USED_FOR_TARGET +/* #undef AC_APPLE_UNIVERSAL_BUILD */ +#endif + + +/* Define as the number of bits in a byte, if `limits.h' doesn't. */ +#ifndef USED_FOR_TARGET +/* #undef CHAR_BIT */ +#endif + + +/* Define 0/1 to force the choice for exception handling model. */ +#ifndef USED_FOR_TARGET +#define CONFIG_SJLJ_EXCEPTIONS 0 +#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 + + +/* Define if you want assertions enabled. This is a cheap check. */ +#ifndef USED_FOR_TARGET +#define ENABLE_ASSERT_CHECKING 1 +#endif + + +/* Define if building with C++. */ +#ifndef USED_FOR_TARGET +/* #undef ENABLE_BUILD_WITH_CXX */ +#endif + + +/* Define to enable prefix canonicalization. */ +#ifndef USED_FOR_TARGET +#define ENABLE_CANONICAL_PREFIXES 1 +#endif + + +/* Define if you want more run-time sanity checks. This one gets a grab bag of + miscellaneous but relatively cheap checks. */ +#ifndef USED_FOR_TARGET +/* #undef ENABLE_CHECKING */ +#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 0 +#endif + + +/* Define to 1 to enable decimal float extension to C. */ +#ifndef USED_FOR_TARGET +#define ENABLE_DECIMAL_FLOAT 0 +#endif + + +/* Define if you want more run-time sanity checks for dataflow. */ +#ifndef USED_FOR_TARGET +/* #undef ENABLE_DF_CHECKING */ +#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 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 +#define ENABLE_LTO 1 +#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 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. The tree browser debugging routines will also be + enabled by this option. */ +#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 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 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/arm/arm-modes.def" +#endif + + +/* Define to enable detailed memory allocation stats gathering. */ +#ifndef USED_FOR_TARGET +/* #undef GATHER_STATISTICS */ +#endif + + +/* Define if the zone collector is in use */ +#ifndef USED_FOR_TARGET +/* #undef GGC_ZONE */ +#endif + + +/* mcontext_t fields start with __ */ +#ifndef USED_FOR_TARGET +/* #undef HAS_MCONTEXT_T_UNDERSCORES */ +#endif + + +/* Define if your assembler supports cmpb. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_AS_CMPB */ +#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 +#define HAVE_AS_DEBUG_PREFIX_MAP 1 +#endif + + +/* Define if your assembler supports DFP instructions. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_AS_DFP */ +#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 +#define HAVE_AS_DWARF2_DEBUG_LINE 1 +#endif + + +/* Define if your assembler supports explicit relocations. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_AS_EXPLICIT_RELOCS */ +#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 +#define HAVE_AS_GDWARF2_DEBUG_FLAG 1 +#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 +/* #undef HAVE_AS_GOTOFF_IN_DATA */ +#endif + + +/* Define if your assembler supports the --gstabs option. */ +#ifndef USED_FOR_TARGET +#define HAVE_AS_GSTABS_DEBUG_FLAG 1 +#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 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 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 1 +#endif + + +/* Define if the assembler won't complain about a line such as # 0 "" 2. */ +#ifndef USED_FOR_TARGET +#define HAVE_AS_LINE_ZERO 1 +#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 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 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 .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 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 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 to 1 if you have the `atoll' function. */ +#ifndef USED_FOR_TARGET +#define HAVE_ATOLL 1 +#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 1 +#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 'basename', otherwise define to + 0. */ +#ifndef USED_FOR_TARGET +#define HAVE_DECL_BASENAME 0 +#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 0 +#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 0 +#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 0 +#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 0 +#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 0 +#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 0 +#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 0 +#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 '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 '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 'strsignal', otherwise define to + 0. */ +#ifndef USED_FOR_TARGET +#define HAVE_DECL_STRSIGNAL 1 +#endif + + +/* Define to 1 if we found a declaration for 'strstr', otherwise define to 0. + */ +#ifndef USED_FOR_TARGET +#define HAVE_DECL_STRSTR 1 +#endif + + +/* Define to 1 if we found a declaration for 'strverscmp', otherwise define to + 0. */ +#ifndef USED_FOR_TARGET +#define HAVE_DECL_STRVERSCMP 0 +#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 '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 +/* #undef HAVE_FFLUSH_UNLOCKED */ +#endif + + +/* Define to 1 if you have the `fgetc_unlocked' function. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_FGETC_UNLOCKED */ +#endif + + +/* Define to 1 if you have the `fgets_unlocked' function. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_FGETS_UNLOCKED */ +#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 +/* #undef HAVE_FPUTC_UNLOCKED */ +#endif + + +/* Define to 1 if you have the `fputs_unlocked' function. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_FPUTS_UNLOCKED */ +#endif + + +/* Define to 1 if you have the `fread_unlocked' function. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_FREAD_UNLOCKED */ +#endif + + +/* Define to 1 if you have the `fwrite_unlocked' function. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_FWRITE_UNLOCKED */ +#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 +#define HAVE_GAS_BALIGN_AND_P2ALIGN 1 +#endif + + +/* Define 0/1 if your assembler supports CFI directives. */ +#define HAVE_GAS_CFI_DIRECTIVE 1 + +/* Define 0/1 if your assembler supports .cfi_personality. */ +#define HAVE_GAS_CFI_PERSONALITY_DIRECTIVE 1 + +/* Define 0/1 if your assembler supports .cfi_sections. */ +#define HAVE_GAS_CFI_SECTIONS_DIRECTIVE 1 + +/* Define if your assembler supports the .loc discriminator sub-directive. */ +#ifndef USED_FOR_TARGET +#define HAVE_GAS_DISCRIMINATOR 1 +#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. */ +#define HAVE_GAS_HIDDEN 1 + +/* 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 +#define HAVE_GAS_MAX_SKIP_P2ALIGN 1 +#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 0/1 if your assembler supports marking sections with SHF_MERGE flag. + */ +#ifndef USED_FOR_TARGET +#define HAVE_GAS_SHF_MERGE 1 +#endif + + +/* Define if your assembler supports .subsection and .subsection -1 starts + emitting at the beginning of your section. */ +#ifndef USED_FOR_TARGET +#define HAVE_GAS_SUBSECTION_ORDERING 1 +#endif + + +/* Define if your assembler supports .weak. */ +#ifndef USED_FOR_TARGET +#define HAVE_GAS_WEAK 1 +#endif + + +/* Define if your assembler supports .weakref. */ +#ifndef USED_FOR_TARGET +#define HAVE_GAS_WEAKREF 1 +#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 if _Unwind_GetIPInfo is available. */ +#ifndef USED_FOR_TARGET +#define HAVE_GETIPINFO 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 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 +/* #undef HAVE_GNU_INDIRECT_FUNCTION */ +#endif + + +/* Define if using GNU ld. */ +#ifndef USED_FOR_TARGET +#define HAVE_GNU_LD 1 +#endif + + +/* Define if you have the iconv() function. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_ICONV */ +#endif + + +/* Define to 1 if you have the <iconv.h> header file. */ +#ifndef USED_FOR_TARGET +#define HAVE_ICONV_H 1 +#endif + + +/* Define .init_array/.fini_array sections are available and working. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_INITFINI_ARRAY */ +#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 and --no-as-needed options. */ +#ifndef USED_FOR_TARGET +#define HAVE_LD_AS_NEEDED 1 +#endif + + +/* Define if your linker supports --build-id. */ +#ifndef USED_FOR_TARGET +#define HAVE_LD_BUILDID 1 +#endif + + +/* Define if your linker supports --demangle option. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_LD_DEMANGLE */ +#endif + + +/* Define if your linker supports .eh_frame_hdr. */ +#define HAVE_LD_EH_FRAME_HDR 1 + +/* 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 +#define HAVE_LD_PIE 1 +#endif + + +/* Define if your linker links a mix of read-only and read-write sections into + a read-write section. */ +#ifndef USED_FOR_TARGET +#define HAVE_LD_RO_RW_SECTION_MIXING 1 +#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 +#define HAVE_LD_STATIC_DYNAMIC 1 +#endif + + +/* Define if your linker supports --sysroot. */ +#ifndef USED_FOR_TARGET +#define HAVE_LD_SYSROOT 1 +#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 if your linker supports plugin. */ +#ifndef USED_FOR_TARGET +#define HAVE_LTO_PLUGIN 1 +#endif + + +/* Define to 1 if you have the <malloc.h> header file. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_MALLOC_H */ +#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 +/* #undef HAVE_MMAP_DEV_ZERO */ +#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 `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 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 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 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 +/* #undef HAVE_UNORDERED_MAP */ +#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 to 1 if the system has the type `__int64'. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE___INT64 */ +#endif + + +/* Define if cloog is in use. */ +#ifndef USED_FOR_TARGET +/* #undef HAVE_cloog */ +#endif + + +/* Define as const if the declaration of iconv() needs const. */ +#ifndef USED_FOR_TARGET +/* #undef ICONV_CONST */ +#endif + + +/* Define to the linker option to enable use of shared objects. */ +#ifndef USED_FOR_TARGET +#define LD_DYNAMIC_OPTION "-Bdynamic" +#endif + + +/* Define to the linker option to disable use of shared objects. */ +#ifndef USED_FOR_TARGET +#define LD_STATIC_OPTION "-Bstatic" +#endif + + +/* Define to the linker flags to use for -pthread. */ +#ifndef USED_FOR_TARGET +/* #undef LIB_THREAD_LDFLAGS_SPEC */ +#endif + + +/* Define to the library containing __tls_get_addr/___tls_get_addr. */ +#ifndef USED_FOR_TARGET +/* #undef LIB_TLS_SPEC */ +#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 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h). */ +#ifndef USED_FOR_TARGET +#define NEED_64BIT_HOST_WIDE_INT 1 +#endif + + +/* Define to 1 if your C compiler doesn't accept -c and -o together. */ +#ifndef USED_FOR_TARGET +/* #undef NO_MINUS_C_MINUS_O */ +#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 "ld-new" +#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 + + +/* The size of `__int64', as computed by sizeof. */ +#ifndef USED_FOR_TARGET +/* #undef SIZEOF___INT64 */ +#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 */ + +/* Define if your target C library provides stack protector support */ +#ifndef USED_FOR_TARGET +/* #undef TARGET_LIBC_PROVIDES_SSP */ +#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' (or '__int64') 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 extra text for frame size warnings. */ +#ifndef USED_FOR_TARGET +#define WARN_FRAME_LARGER_THAN_EXTRA_TEXT "" +#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/lib/gcc/arm-eabi/4.6.x-google/plugin/include/b-header-vars b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/b-header-vars new file mode 100644 index 0000000..a2770b4 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/b-header-vars @@ -0,0 +1,106 @@ +USER_H=tgmath.h +UNWIND_H=config/arm/unwind-arm.h +HASHTAB_H=hashtab.h +OBSTACK_H=obstack.h +SPLAY_TREE_H=splay-tree.h +FIBHEAP_H=fibheap.h +PARTITION_H=partition.h +DWARF2_H=dwarf2.h +XREGEX_H=xregex.h +LINKER_PLUGIN_API_H=plugin-api.h +LTO_SYMTAB_H=lto-symtab.h +BCONFIG_H=bconfig.h auto-host.h ansidecl.h +CONFIG_H=config.h auto-host.h ansidecl.h +TCONFIG_H=tconfig.h auto-host.h ansidecl.h +TM_P_H=tm_p.h config/arm/arm-protos.h tm-preds.h +GTM_H=tm.h options.h config/dbxelf.h defaults.h insn-constants.h +TM_H=tm.h options.h config/dbxelf.h defaults.h insn-constants.h insn-flags.h options.h flag-types.h +VEC_H=vec.h statistics.h +EXCEPT_H=except.h hashtab.h vecprim.h vecir.h +TARGET_H=tm.h options.h config/dbxelf.h defaults.h insn-constants.h insn-flags.h options.h flag-types.h target.h target.def insn-modes.h +MACHMODE_H=machmode.h mode-classes.def insn-modes.h +HOOKS_H=hooks.h machmode.h mode-classes.def insn-modes.h +HOSTHOOKS_DEF_H=hosthooks-def.h hooks.h machmode.h mode-classes.def insn-modes.h +LANGHOOKS_DEF_H=langhooks-def.h hooks.h machmode.h mode-classes.def insn-modes.h +TARGET_DEF_H=target-def.h target-hooks-def.h hooks.h machmode.h mode-classes.def insn-modes.h targhooks.h +RTL_BASE_H=rtl.h rtl.def machmode.h mode-classes.def insn-modes.h reg-notes.def insn-notes.def hashtab.h +FIXED_VALUE_H=fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h +RTL_H=rtl.h rtl.def machmode.h mode-classes.def insn-modes.h reg-notes.def insn-notes.def hashtab.h genrtl.h vecir.h +RTL_ERROR_H=rtl.h rtl.def machmode.h mode-classes.def insn-modes.h reg-notes.def insn-notes.def line-map.h input.h bversion.h diagnostic.def +READ_MD_H=hashtab.h read-md.h +PARAMS_H=params.h params.def +TREE_H=tree.h all-tree.def tree.def c-family/c-common.def obstack.h flags.h coretypes.h flag-types.h options.h flag-types.h vecir.h real.h machmode.h mode-classes.def insn-modes.h fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h +REGSET_H=regset.h bitmap.h hashtab.h statistics.h hard-reg-set.h +BASIC_BLOCK_H=basic-block.h predict.h predict.def vec.h statistics.h function.h tree.h all-tree.def tree.def c-family/c-common.def defaults.h insn-constants.h insn-flags.h options.h flag-types.h hard-reg-set.h cfghooks.h +GIMPLE_H=gimple.h gimple.def gsstruct.def pointer-set.h vec.h statistics.h ggc.h gtype-desc.h statistics.h basic-block.h predict.h predict.def vec.h statistics.h function.h tree.h all-tree.def tree.def c-family/c-common.def defaults.h insn-constants.h insn-flags.h options.h flag-types.h target.h target.def insn-modes.h tree-ssa-operands.h tree-ssa-alias.h vecir.h +GCOV_IO_H=gcov-io.h gcov-iov.h auto-host.h +COVERAGE_H=coverage.h gcov-io.h gcov-iov.h auto-host.h +DEMANGLE_H=demangle.h +RECOG_H=recog.h +ALIAS_H=alias.h coretypes.h +EMIT_RTL_H=emit-rtl.h +FLAGS_H=flags.h coretypes.h flag-types.h options.h flag-types.h +OPTIONS_H=options.h flag-types.h +FUNCTION_H=function.h tree.h all-tree.def tree.def c-family/c-common.def defaults.h insn-constants.h insn-flags.h options.h flag-types.h hard-reg-set.h +EXPR_H=expr.h insn-config.h function.h tree.h all-tree.def tree.def c-family/c-common.def obstack.h flags.h coretypes.h flag-types.h options.h flag-types.h vecir.h real.h machmode.h mode-classes.def insn-modes.h fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h machmode.h mode-classes.def insn-modes.h emit-rtl.h +OPTABS_H=optabs.h insn-codes.h +REGS_H=regs.h machmode.h mode-classes.def insn-modes.h hard-reg-set.h +SCHED_INT_H=sched-int.h insn-attr.h hashtab.h statistics.h hard-reg-set.h +SEL_SCHED_IR_H=sel-sched-ir.h insn-attr.h hashtab.h statistics.h hard-reg-set.h +SEL_SCHED_DUMP_H=sel-sched-dump.h sel-sched-ir.h insn-attr.h hashtab.h statistics.h hard-reg-set.h +INTEGRATE_H=integrate.h +CFGLAYOUT_H=cfglayout.h basic-block.h predict.h predict.def vec.h statistics.h function.h tree.h all-tree.def tree.def c-family/c-common.def defaults.h insn-constants.h insn-flags.h options.h flag-types.h hard-reg-set.h cfghooks.h +CFGLOOP_H=cfgloop.h basic-block.h predict.h predict.def vec.h statistics.h function.h tree.h all-tree.def tree.def c-family/c-common.def hashtab.h statistics.h sbitmap.h +IPA_UTILS_H=ipa-utils.h tree.h all-tree.def tree.def c-family/c-common.def plugin-api.h +IPA_REFERENCE_H=ipa-reference.h bitmap.h obstack.h flags.h coretypes.h flag-types.h options.h flag-types.h vecir.h real.h machmode.h mode-classes.def insn-modes.h fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h +IPA_TYPE_ESCAPE_H=ipa-type-escape.h tree.h all-tree.def tree.def c-family/c-common.def obstack.h flags.h coretypes.h flag-types.h options.h flag-types.h vecir.h real.h machmode.h mode-classes.def insn-modes.h fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h +CGRAPH_H=cgraph.h vec.h statistics.h tree.h all-tree.def tree.def c-family/c-common.def plugin-api.h +DF_H=df.h bitmap.h defaults.h insn-constants.h insn-flags.h options.h flag-types.h hard-reg-set.h cfghooks.h alloc-pool.h timevar.h timevar.def +RESOURCE_H=resource.h hard-reg-set.h df.h bitmap.h defaults.h insn-constants.h insn-flags.h options.h flag-types.h hard-reg-set.h cfghooks.h alloc-pool.h timevar.h timevar.def +DDG_H=ddg.h sbitmap.h df.h bitmap.h defaults.h insn-constants.h insn-flags.h options.h flag-types.h hard-reg-set.h cfghooks.h alloc-pool.h timevar.h timevar.def +GCC_H=gcc.h version.h diagnostic-core.h line-map.h input.h bversion.h diagnostic.def +GGC_H=ggc.h gtype-desc.h statistics.h +GGC_INTERNAL_H=ggc-internal.h ggc.h gtype-desc.h statistics.h +TIMEVAR_H=timevar.h timevar.def +INSN_ATTR_H=insn-attr.h insn-addr.h vecprim.h +INSN_ADDR_H=insn-addr.h vecprim.h +C_COMMON_H=c-family/c-common.h c-family/c-common.def line-map.h input.h bversion.h diagnostic.def +C_PRAGMA_H=c-family/c-pragma.h cpplib.h +C_TREE_H=c-tree.h c-family/c-common.h c-family/c-common.def obstack.h +SYSTEM_H=system.h hwint.h filenames.h +PREDICT_H=predict.h predict.def +CPPLIB_H=cpplib.h +INPUT_H=line-map.h input.h +OPTS_H=line-map.h input.h vec.h statistics.h opts.h +DECNUM_H=decimal128Local.h +MKDEPS_H=mkdeps.h +SYMTAB_H=obstack.h +CPP_ID_DATA_H=cpp-id-data.h +CPP_INTERNAL_H=cpp-id-data.h +TREE_PASS_H=tree-pass.h timevar.h timevar.def +TREE_DUMP_H=tree-dump.h splay-tree.h tree-pass.h timevar.h timevar.def +TREE_FLOW_H=tree-flow.h tree-flow-inline.h tree-ssa-operands.h bitmap.h obstack.h flags.h coretypes.h flag-types.h options.h flag-types.h vecir.h real.h machmode.h mode-classes.def insn-modes.h fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h tree-ssa-alias.h +TREE_SSA_LIVE_H=tree-ssa-live.h partition.h vecprim.h +SSAEXPAND_H=ssaexpand.h tree-ssa-live.h partition.h vecprim.h +PRETTY_PRINT_H=pretty-print.h obstack.h +DIAGNOSTIC_CORE_H=diagnostic-core.h line-map.h input.h bversion.h diagnostic.def +DIAGNOSTIC_H=diagnostic.h diagnostic-core.h obstack.h +C_PRETTY_PRINT_H=c-family/c-pretty-print.h pretty-print.h obstack.h flags.h coretypes.h flag-types.h options.h flag-types.h vecir.h real.h machmode.h mode-classes.def insn-modes.h fixed-value.h machmode.h mode-classes.def insn-modes.h double-int.h +SCEV_H=tree-scalar-evolution.h ggc.h gtype-desc.h statistics.h tree-chrec.h params.h params.def +TREE_DATA_REF_H=tree-data-ref.h omega.h graphds.h tree-scalar-evolution.h ggc.h gtype-desc.h statistics.h tree-chrec.h params.h params.def +TREE_INLINE_H=tree-inline.h vecir.h +REAL_H=real.h machmode.h mode-classes.def insn-modes.h +IRA_INT_H=ira.h ira-int.h cfgloop.h basic-block.h predict.h predict.def vec.h statistics.h function.h tree.h all-tree.def tree.def c-family/c-common.def hashtab.h statistics.h sbitmap.h alloc-pool.h +DBGCNT_H=dbgcnt.h dbgcnt.def +EBITMAP_H=ebitmap.h sbitmap.h +LTO_STREAMER_H=lto-streamer.h defaults.h insn-constants.h insn-flags.h options.h flag-types.h target.h target.def insn-modes.h tree-ssa-operands.h tree-ssa-alias.h vecir.h gcov-io.h gcov-iov.h auto-host.h +TREE_VECTORIZER_H=tree-vectorizer.h tree-data-ref.h omega.h graphds.h tree-scalar-evolution.h ggc.h gtype-desc.h statistics.h tree-chrec.h params.h params.def +IPA_PROP_H=ipa-prop.h tree.h all-tree.def tree.def c-family/c-common.def defaults.h insn-constants.h insn-flags.h options.h flag-types.h target.h target.def insn-modes.h tree-ssa-operands.h tree-ssa-alias.h vecir.h +GSTAB_H=gstab.h stab.def +BITMAP_H=bitmap.h hashtab.h statistics.h +GCC_PLUGIN_H=gcc-plugin.h highlev-plugin-common.h config.h auto-host.h hashtab.h +PLUGIN_H=plugin.h gcc-plugin.h highlev-plugin-common.h config.h auto-host.h hashtab.h +PLUGIN_VERSION_H=plugin-version.h configargs.h +LIBFUNCS_H=libfuncs.h hashtab.h +GTFILES_H=gt-coverage.h gt-caller-save.h gt-alias.h gt-bitmap.h gt-cselib.h gt-cgraph.h gt-ipa-prop.h gt-ipa-cp.h gt-ipa-inline.h gt-matrix-reorg.h gt-dbxout.h gt-ipa-struct-reorg.h gt-dwarf2out.h gt-dwarf2asm.h gt-tree-vect-generic.h gt-dojump.h gt-l-ipo.h gt-emit-rtl.h gt-explow.h gt-expr.h gt-function.h gt-except.h gt-gcse.h gt-godump.h gt-integrate.h gt-lists.h gt-optabs.h gt-profile.h gt-mcf.h gt-reg-stack.h gt-cfglayout.h gt-sdbout.h gt-stor-layout.h gt-stringpool.h gt-tree.h gt-varasm.h gt-gimple.h gt-tree-mudflap.h gt-tree-ssanames.h gt-tree-eh.h gt-tree-ssa-address.h gt-tree-cfg.h gt-tree-dfa.h gt-tree-iterator.h gt-gimplify.h gt-tree-scalar-evolution.h gt-tree-threadsafe-analyze.h gt-tree-profile.h gt-tree-nested.h gt-varpool.h gt-tree-parloops.h gt-omp-low.h gt-targhooks.h gt-arm.h gt-passes.h gt-cgraphunit.h gt-tree-ssa-propagate.h gt-tree-phinodes.h gt-tree-ssa-structalias.h gt-lto-symtab.h gt-ada-decl.h gt-ada-trans.h gt-ada-utils.h gt-ada-misc.h gt-cp-rtti.h gt-cp-mangle.h gt-cp-name-lookup.h gt-cp-call.h gt-cp-decl.h gt-cp-decl2.h gt-cp-pt.h gt-cp-repo.h gt-cp-semantics.h gt-cp-tree.h gt-cp-parser.h gt-cp-method.h gt-cp-typeck2.h gt-c-family-c-common.h gt-c-family-c-lex.h gt-c-family-c-pragma.h gt-cp-class.h gt-cp-cp-objcp-common.h gt-cp-cp-lang.h gt-fortran-f95-lang.h gt-fortran-trans-decl.h gt-fortran-trans-intrinsic.h gt-fortran-trans-io.h gt-fortran-trans-stmt.h gt-fortran-trans-types.h gt-go-go-lang.h gt-java-builtins.h gt-java-class.h gt-java-constants.h gt-java-decl.h gt-java-expr.h gt-java-jcf-parse.h gt-java-lang.h gt-java-mangle.h gt-java-resource.h gt-lto-lto-lang.h gt-lto-lto.h gt-objc-objc-act.h gt-objc-objc-runtime-shared-support.h gt-objc-objc-gnu-runtime-abi-01.h gt-objc-objc-next-runtime-abi-01.h gt-objc-objc-next-runtime-abi-02.h gt-c-parser.h gt-c-decl.h gt-c-objc-common.h gt-c-family-c-common.h gt-c-family-c-cppbuiltin.h gt-c-family-c-pragma.h gt-objc-objc-act.h gt-objc-objc-runtime-shared-support.h gt-objc-objc-gnu-runtime-abi-01.h gt-objc-objc-next-runtime-abi-01.h gt-objc-objc-next-runtime-abi-02.h gt-cp-call.h gt-cp-class.h gt-cp-decl.h gt-cp-decl2.h gt-cp-mangle.h gt-cp-method.h gt-cp-name-lookup.h gt-cp-cp-objcp-common.h gt-cp-parser.h gt-cp-pt.h gt-cp-repo.h gt-cp-rtti.h gt-cp-semantics.h gt-cp-tree.h gt-cp-typeck2.h gt-c-family-c-common.h gt-c-family-c-lex.h gt-c-family-c-cppbuiltin.h gt-c-family-c-pragma.h gt-c-lang.h gt-c-decl.h gt-c-family-c-common.h gt-c-family-c-cppbuiltin.h gt-c-family-c-pragma.h gt-c-objc-common.h gt-c-parser.h +GTFILES_LANG_H=gtype-ada.h gtype-cp.h gtype-fortran.h gtype-go.h gtype-java.h gtype-lto.h gtype-objc.h gtype-objcp.h gtype-c.h diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/basic-block.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/basic-block.h new file mode 100644 index 0000000..4de6a50 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/basic-block.h @@ -0,0 +1,936 @@ +/* Define control flow data structures for the CFG. + Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, + 2005, 2006, 2007, 2008, 2009, 2010 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/>. */ + +#ifndef GCC_BASIC_BLOCK_H +#define GCC_BASIC_BLOCK_H + +#include "predict.h" +#include "vec.h" +#include "function.h" + +/* Type we use to hold basic block counters. Should be at least + 64bit. Although a counter cannot be negative, we use a signed + type, because erroneous negative counts can be generated when the + flow graph is manipulated by various optimizations. A signed type + makes those easy to detect. */ +typedef HOST_WIDEST_INT gcov_type; + +/* Control flow edge information. */ +struct GTY(()) edge_def { + /* The two blocks at the ends of the edge. */ + struct basic_block_def *src; + struct basic_block_def *dest; + + /* Instructions queued on the edge. */ + union edge_def_insns { + gimple_seq GTY ((tag ("true"))) g; + rtx GTY ((tag ("false"))) r; + } GTY ((desc ("current_ir_type () == IR_GIMPLE"))) insns; + + /* Auxiliary info specific to a pass. */ + PTR GTY ((skip (""))) aux; + + /* Location of any goto implicit in the edge and associated BLOCK. */ + tree goto_block; + location_t goto_locus; + + /* The index number corresponding to this edge in the edge vector + dest->preds. */ + unsigned int dest_idx; + + int flags; /* see EDGE_* below */ + int probability; /* biased by REG_BR_PROB_BASE */ + gcov_type count; /* Expected number of executions calculated + in profile.c */ +}; + +DEF_VEC_P(edge); +DEF_VEC_ALLOC_P(edge,gc); +DEF_VEC_ALLOC_P(edge,heap); + +#define EDGE_FALLTHRU 1 /* 'Straight line' flow */ +#define EDGE_ABNORMAL 2 /* Strange flow, like computed + label, or eh */ +#define EDGE_ABNORMAL_CALL 4 /* Call with abnormal exit + like an exception, or sibcall */ +#define EDGE_EH 8 /* Exception throw */ +#define EDGE_FAKE 16 /* Not a real edge (profile.c) */ +#define EDGE_DFS_BACK 32 /* A backwards edge */ +#define EDGE_CAN_FALLTHRU 64 /* Candidate for straight line + flow. */ +#define EDGE_IRREDUCIBLE_LOOP 128 /* Part of irreducible loop. */ +#define EDGE_SIBCALL 256 /* Edge from sibcall to exit. */ +#define EDGE_LOOP_EXIT 512 /* Exit of a loop. */ +#define EDGE_TRUE_VALUE 1024 /* Edge taken when controlling + predicate is nonzero. */ +#define EDGE_FALSE_VALUE 2048 /* Edge taken when controlling + predicate is zero. */ +#define EDGE_EXECUTABLE 4096 /* Edge is executable. Only + valid during SSA-CCP. */ +#define EDGE_CROSSING 8192 /* Edge crosses between hot + and cold sections, when we + do partitioning. */ +#define EDGE_ALL_FLAGS 16383 + +#define EDGE_COMPLEX (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH) + +/* Counter summary from the last set of coverage counts read by + profile.c. */ +extern const struct gcov_ctr_summary *profile_info; + +/* Declared in cfgloop.h. */ +struct loop; + +/* Declared in tree-flow.h. */ +struct rtl_bb_info; + +/* A basic block is a sequence of instructions with only entry and + only one exit. If any one of the instructions are executed, they + will all be executed, and in sequence from first to last. + + There may be COND_EXEC instructions in the basic block. The + COND_EXEC *instructions* will be executed -- but if the condition + is false the conditionally executed *expressions* will of course + not be executed. We don't consider the conditionally executed + expression (which might have side-effects) to be in a separate + basic block because the program counter will always be at the same + location after the COND_EXEC instruction, regardless of whether the + condition is true or not. + + Basic blocks need not start with a label nor end with a jump insn. + For example, a previous basic block may just "conditionally fall" + into the succeeding basic block, and the last basic block need not + end with a jump insn. Block 0 is a descendant of the entry block. + + A basic block beginning with two labels cannot have notes between + the labels. + + Data for jump tables are stored in jump_insns that occur in no + basic block even though these insns can follow or precede insns in + basic blocks. */ + +/* Basic block information indexed by block number. */ +struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_def { + /* The edges into and out of the block. */ + VEC(edge,gc) *preds; + VEC(edge,gc) *succs; + + /* Auxiliary info specific to a pass. */ + PTR GTY ((skip (""))) aux; + + /* Innermost loop containing the block. */ + struct loop *loop_father; + + /* The dominance and postdominance information node. */ + struct et_node * GTY ((skip (""))) dom[2]; + + /* Previous and next blocks in the chain. */ + struct basic_block_def *prev_bb; + struct basic_block_def *next_bb; + + union basic_block_il_dependent { + struct gimple_bb_info * GTY ((tag ("0"))) gimple; + struct rtl_bb_info * GTY ((tag ("1"))) rtl; + } GTY ((desc ("((%1.flags & BB_RTL) != 0)"))) il; + + /* Expected number of executions: calculated in profile.c. */ + gcov_type count; + + /* The index of this block. */ + int index; + + /* The loop depth of this block. */ + int loop_depth; + + /* Expected frequency. Normalized to be in range 0 to BB_FREQ_MAX. */ + int frequency; + + /* Various flags. See BB_* below. */ + int flags; +}; + +struct GTY(()) rtl_bb_info { + /* The first and last insns of the block. */ + rtx head_; + rtx end_; + + /* In CFGlayout mode points to insn notes/jumptables to be placed just before + and after the block. */ + rtx header; + rtx footer; + + /* This field is used by the bb-reorder and tracer passes. */ + int visited; +}; + +struct GTY(()) gimple_bb_info { + /* Sequence of statements in this block. */ + gimple_seq seq; + + /* PHI nodes for this block. */ + gimple_seq phi_nodes; +}; + +DEF_VEC_P(basic_block); +DEF_VEC_ALLOC_P(basic_block,gc); +DEF_VEC_ALLOC_P(basic_block,heap); + +#define BB_FREQ_MAX 10000 + +/* Masks for basic_block.flags. + + BB_HOT_PARTITION and BB_COLD_PARTITION should be preserved throughout + the compilation, so they are never cleared. + + All other flags may be cleared by clear_bb_flags(). It is generally + a bad idea to rely on any flags being up-to-date. */ + +enum bb_flags +{ + /* Only set on blocks that have just been created by create_bb. */ + BB_NEW = 1 << 0, + + /* Set by find_unreachable_blocks. Do not rely on this being set in any + pass. */ + BB_REACHABLE = 1 << 1, + + /* Set for blocks in an irreducible loop by loop analysis. */ + BB_IRREDUCIBLE_LOOP = 1 << 2, + + /* Set on blocks that may actually not be single-entry single-exit block. */ + BB_SUPERBLOCK = 1 << 3, + + /* Set on basic blocks that the scheduler should not touch. This is used + by SMS to prevent other schedulers from messing with the loop schedule. */ + BB_DISABLE_SCHEDULE = 1 << 4, + + /* Set on blocks that should be put in a hot section. */ + BB_HOT_PARTITION = 1 << 5, + + /* Set on blocks that should be put in a cold section. */ + BB_COLD_PARTITION = 1 << 6, + + /* Set on block that was duplicated. */ + BB_DUPLICATED = 1 << 7, + + /* Set if the label at the top of this block is the target of a non-local goto. */ + BB_NON_LOCAL_GOTO_TARGET = 1 << 8, + + /* Set on blocks that are in RTL format. */ + BB_RTL = 1 << 9 , + + /* Set on blocks that are forwarder blocks. + Only used in cfgcleanup.c. */ + BB_FORWARDER_BLOCK = 1 << 10, + + /* Set on blocks that cannot be threaded through. + Only used in cfgcleanup.c. */ + BB_NONTHREADABLE_BLOCK = 1 << 11, + + /* Set on blocks that were modified in some way. This bit is set in + df_set_bb_dirty, but not cleared by df_analyze, so it can be used + to test whether a block has been modified prior to a df_analyze + call. */ + BB_MODIFIED = 1 << 12 +}; + +/* Dummy flag for convenience in the hot/cold partitioning code. */ +#define BB_UNPARTITIONED 0 + +/* Partitions, to be used when partitioning hot and cold basic blocks into + separate sections. */ +#define BB_PARTITION(bb) ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION)) +#define BB_SET_PARTITION(bb, part) do { \ + basic_block bb_ = (bb); \ + bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) \ + | (part)); \ +} while (0) + +#define BB_COPY_PARTITION(dstbb, srcbb) \ + BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb)) + +/* State of dominance information. */ + +enum dom_state +{ + DOM_NONE, /* Not computed at all. */ + DOM_NO_FAST_QUERY, /* The data is OK, but the fast query data are not usable. */ + DOM_OK /* Everything is ok. */ +}; + +/* What sort of profiling information we have. */ +enum profile_status_d +{ + PROFILE_ABSENT, + PROFILE_GUESSED, + PROFILE_READ +}; + +/* A structure to group all the per-function control flow graph data. + The x_* prefixing is necessary because otherwise references to the + fields of this struct are interpreted as the defines for backward + source compatibility following the definition of this struct. */ +struct GTY(()) control_flow_graph { + /* Block pointers for the exit and entry of a function. + These are always the head and tail of the basic block list. */ + basic_block x_entry_block_ptr; + basic_block x_exit_block_ptr; + + /* Index by basic block number, get basic block struct info. */ + VEC(basic_block,gc) *x_basic_block_info; + + /* Number of basic blocks in this flow graph. */ + int x_n_basic_blocks; + + /* Number of edges in this flow graph. */ + int x_n_edges; + + /* The first free basic block number. */ + int x_last_basic_block; + + /* UIDs for LABEL_DECLs. */ + int last_label_uid; + + /* Mapping of labels to their associated blocks. At present + only used for the gimple CFG. */ + VEC(basic_block,gc) *x_label_to_block_map; + + enum profile_status_d x_profile_status; + + /* Whether the dominators and the postdominators are available. */ + enum dom_state x_dom_computed[2]; + + /* Number of basic blocks in the dominance tree. */ + unsigned x_n_bbs_in_dom_tree[2]; + + /* Maximal number of entities in the single jumptable. Used to estimate + final flowgraph size. */ + int max_jumptable_ents; +}; + +/* Defines for accessing the fields of the CFG structure for function FN. */ +#define ENTRY_BLOCK_PTR_FOR_FUNCTION(FN) ((FN)->cfg->x_entry_block_ptr) +#define EXIT_BLOCK_PTR_FOR_FUNCTION(FN) ((FN)->cfg->x_exit_block_ptr) +#define basic_block_info_for_function(FN) ((FN)->cfg->x_basic_block_info) +#define n_basic_blocks_for_function(FN) ((FN)->cfg->x_n_basic_blocks) +#define n_edges_for_function(FN) ((FN)->cfg->x_n_edges) +#define last_basic_block_for_function(FN) ((FN)->cfg->x_last_basic_block) +#define label_to_block_map_for_function(FN) ((FN)->cfg->x_label_to_block_map) +#define profile_status_for_function(FN) ((FN)->cfg->x_profile_status) + +#define BASIC_BLOCK_FOR_FUNCTION(FN,N) \ + (VEC_index (basic_block, basic_block_info_for_function(FN), (N))) +#define SET_BASIC_BLOCK_FOR_FUNCTION(FN,N,BB) \ + (VEC_replace (basic_block, basic_block_info_for_function(FN), (N), (BB))) + +/* Defines for textual backward source compatibility. */ +#define ENTRY_BLOCK_PTR (cfun->cfg->x_entry_block_ptr) +#define EXIT_BLOCK_PTR (cfun->cfg->x_exit_block_ptr) +#define basic_block_info (cfun->cfg->x_basic_block_info) +#define n_basic_blocks (cfun->cfg->x_n_basic_blocks) +#define n_edges (cfun->cfg->x_n_edges) +#define last_basic_block (cfun->cfg->x_last_basic_block) +#define label_to_block_map (cfun->cfg->x_label_to_block_map) +#define profile_status (cfun->cfg->x_profile_status) + +#define BASIC_BLOCK(N) (VEC_index (basic_block, basic_block_info, (N))) +#define SET_BASIC_BLOCK(N,BB) (VEC_replace (basic_block, basic_block_info, (N), (BB))) + +/* For iterating over basic blocks. */ +#define FOR_BB_BETWEEN(BB, FROM, TO, DIR) \ + for (BB = FROM; BB != TO; BB = BB->DIR) + +#define FOR_EACH_BB_FN(BB, FN) \ + FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb) + +#define FOR_EACH_BB(BB) FOR_EACH_BB_FN (BB, cfun) + +#define FOR_EACH_BB_REVERSE_FN(BB, FN) \ + FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb) + +#define FOR_EACH_BB_REVERSE(BB) FOR_EACH_BB_REVERSE_FN(BB, cfun) + +/* For iterating over insns in basic block. */ +#define FOR_BB_INSNS(BB, INSN) \ + for ((INSN) = BB_HEAD (BB); \ + (INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \ + (INSN) = NEXT_INSN (INSN)) + +/* For iterating over insns in basic block when we might remove the + current insn. */ +#define FOR_BB_INSNS_SAFE(BB, INSN, CURR) \ + for ((INSN) = BB_HEAD (BB), (CURR) = (INSN) ? NEXT_INSN ((INSN)): NULL; \ + (INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \ + (INSN) = (CURR), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL) + +#define FOR_BB_INSNS_REVERSE(BB, INSN) \ + for ((INSN) = BB_END (BB); \ + (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \ + (INSN) = PREV_INSN (INSN)) + +#define FOR_BB_INSNS_REVERSE_SAFE(BB, INSN, CURR) \ + for ((INSN) = BB_END (BB),(CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL; \ + (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \ + (INSN) = (CURR), (CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL) + +/* Cycles through _all_ basic blocks, even the fake ones (entry and + exit block). */ + +#define FOR_ALL_BB(BB) \ + for (BB = ENTRY_BLOCK_PTR; BB; BB = BB->next_bb) + +#define FOR_ALL_BB_FN(BB, FN) \ + for (BB = ENTRY_BLOCK_PTR_FOR_FUNCTION (FN); BB; BB = BB->next_bb) + + +/* Stuff for recording basic block info. */ + +#define BB_HEAD(B) (B)->il.rtl->head_ +#define BB_END(B) (B)->il.rtl->end_ + +/* Special block numbers [markers] for entry and exit. + Neither of them is supposed to hold actual statements. */ +#define ENTRY_BLOCK (0) +#define EXIT_BLOCK (1) + +/* The two blocks that are always in the cfg. */ +#define NUM_FIXED_BLOCKS (2) + +#define set_block_for_insn(INSN, BB) (BLOCK_FOR_INSN (INSN) = BB) + +extern void compute_bb_for_insn (void); +extern unsigned int free_bb_for_insn (void); +extern void update_bb_for_insn (basic_block); + +extern void insert_insn_on_edge (rtx, edge); +basic_block split_edge_and_insert (edge, rtx); + +extern void commit_one_edge_insertion (edge e); +extern void commit_edge_insertions (void); + +extern void remove_fake_edges (void); +extern void remove_fake_exit_edges (void); +extern void add_noreturn_fake_exit_edges (void); +extern void connect_infinite_loops_to_exit (void); +extern edge unchecked_make_edge (basic_block, basic_block, int); +extern edge cached_make_edge (sbitmap, basic_block, basic_block, int); +extern edge make_edge (basic_block, basic_block, int); +extern edge make_single_succ_edge (basic_block, basic_block, int); +extern void remove_edge_raw (edge); +extern void redirect_edge_succ (edge, basic_block); +extern edge redirect_edge_succ_nodup (edge, basic_block); +extern void redirect_edge_pred (edge, basic_block); +extern basic_block create_basic_block_structure (rtx, rtx, rtx, basic_block); +extern void clear_bb_flags (void); +extern int post_order_compute (int *, bool, bool); +extern int inverted_post_order_compute (int *); +extern int pre_and_rev_post_order_compute (int *, int *, bool); +extern int dfs_enumerate_from (basic_block, int, + bool (*)(const_basic_block, const void *), + basic_block *, int, const void *); +extern void compute_dominance_frontiers (struct bitmap_head_def *); +extern bitmap compute_idf (bitmap, struct bitmap_head_def *); +extern void dump_bb_info (basic_block, bool, bool, int, const char *, FILE *); +extern void dump_edge_info (FILE *, edge, int); +extern void brief_dump_cfg (FILE *); +extern void clear_edges (void); +extern void scale_bbs_frequencies_int (basic_block *, int, int, int); +extern void scale_bbs_frequencies_gcov_type (basic_block *, int, gcov_type, + gcov_type); + +/* Structure to group all of the information to process IF-THEN and + IF-THEN-ELSE blocks for the conditional execution support. This + needs to be in a public file in case the IFCVT macros call + functions passing the ce_if_block data structure. */ + +typedef struct ce_if_block +{ + basic_block test_bb; /* First test block. */ + basic_block then_bb; /* THEN block. */ + basic_block else_bb; /* ELSE block or NULL. */ + basic_block join_bb; /* Join THEN/ELSE blocks. */ + basic_block last_test_bb; /* Last bb to hold && or || tests. */ + int num_multiple_test_blocks; /* # of && and || basic blocks. */ + int num_and_and_blocks; /* # of && blocks. */ + int num_or_or_blocks; /* # of || blocks. */ + int num_multiple_test_insns; /* # of insns in && and || blocks. */ + int and_and_p; /* Complex test is &&. */ + int num_then_insns; /* # of insns in THEN block. */ + int num_else_insns; /* # of insns in ELSE block. */ + int pass; /* Pass number. */ + +#ifdef IFCVT_EXTRA_FIELDS + IFCVT_EXTRA_FIELDS /* Any machine dependent fields. */ +#endif + +} ce_if_block_t; + +/* This structure maintains an edge list vector. */ +struct edge_list +{ + int num_blocks; + int num_edges; + edge *index_to_edge; +}; + +/* The base value for branch probability notes and edge probabilities. */ +#define REG_BR_PROB_BASE 10000 + +/* This is the value which indicates no edge is present. */ +#define EDGE_INDEX_NO_EDGE -1 + +/* EDGE_INDEX returns an integer index for an edge, or EDGE_INDEX_NO_EDGE + if there is no edge between the 2 basic blocks. */ +#define EDGE_INDEX(el, pred, succ) (find_edge_index ((el), (pred), (succ))) + +/* INDEX_EDGE_PRED_BB and INDEX_EDGE_SUCC_BB return a pointer to the basic + block which is either the pred or succ end of the indexed edge. */ +#define INDEX_EDGE_PRED_BB(el, index) ((el)->index_to_edge[(index)]->src) +#define INDEX_EDGE_SUCC_BB(el, index) ((el)->index_to_edge[(index)]->dest) + +/* INDEX_EDGE returns a pointer to the edge. */ +#define INDEX_EDGE(el, index) ((el)->index_to_edge[(index)]) + +/* Number of edges in the compressed edge list. */ +#define NUM_EDGES(el) ((el)->num_edges) + +/* BB is assumed to contain conditional jump. Return the fallthru edge. */ +#define FALLTHRU_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \ + ? EDGE_SUCC ((bb), 0) : EDGE_SUCC ((bb), 1)) + +/* BB is assumed to contain conditional jump. Return the branch edge. */ +#define BRANCH_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \ + ? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0)) + +/* Return expected execution frequency of the edge E. */ +#define EDGE_FREQUENCY(e) (((e)->src->frequency \ + * (e)->probability \ + + REG_BR_PROB_BASE / 2) \ + / REG_BR_PROB_BASE) + +/* Return nonzero if edge is critical. */ +#define EDGE_CRITICAL_P(e) (EDGE_COUNT ((e)->src->succs) >= 2 \ + && EDGE_COUNT ((e)->dest->preds) >= 2) + +#define EDGE_COUNT(ev) VEC_length (edge, (ev)) +#define EDGE_I(ev,i) VEC_index (edge, (ev), (i)) +#define EDGE_PRED(bb,i) VEC_index (edge, (bb)->preds, (i)) +#define EDGE_SUCC(bb,i) VEC_index (edge, (bb)->succs, (i)) + +/* Returns true if BB has precisely one successor. */ + +static inline bool +single_succ_p (const_basic_block bb) +{ + return EDGE_COUNT (bb->succs) == 1; +} + +/* Returns true if BB has precisely one predecessor. */ + +static inline bool +single_pred_p (const_basic_block bb) +{ + return EDGE_COUNT (bb->preds) == 1; +} + +/* Returns the single successor edge of basic block BB. Aborts if + BB does not have exactly one successor. */ + +static inline edge +single_succ_edge (const_basic_block bb) +{ + gcc_checking_assert (single_succ_p (bb)); + return EDGE_SUCC (bb, 0); +} + +/* Returns the single predecessor edge of basic block BB. Aborts + if BB does not have exactly one predecessor. */ + +static inline edge +single_pred_edge (const_basic_block bb) +{ + gcc_checking_assert (single_pred_p (bb)); + return EDGE_PRED (bb, 0); +} + +/* Returns the single successor block of basic block BB. Aborts + if BB does not have exactly one successor. */ + +static inline basic_block +single_succ (const_basic_block bb) +{ + return single_succ_edge (bb)->dest; +} + +/* Returns the single predecessor block of basic block BB. Aborts + if BB does not have exactly one predecessor.*/ + +static inline basic_block +single_pred (const_basic_block bb) +{ + return single_pred_edge (bb)->src; +} + +/* Iterator object for edges. */ + +typedef struct { + unsigned index; + VEC(edge,gc) **container; +} edge_iterator; + +static inline VEC(edge,gc) * +ei_container (edge_iterator i) +{ + gcc_checking_assert (i.container); + return *i.container; +} + +#define ei_start(iter) ei_start_1 (&(iter)) +#define ei_last(iter) ei_last_1 (&(iter)) + +/* Return an iterator pointing to the start of an edge vector. */ +static inline edge_iterator +ei_start_1 (VEC(edge,gc) **ev) +{ + edge_iterator i; + + i.index = 0; + i.container = ev; + + return i; +} + +/* Return an iterator pointing to the last element of an edge + vector. */ +static inline edge_iterator +ei_last_1 (VEC(edge,gc) **ev) +{ + edge_iterator i; + + i.index = EDGE_COUNT (*ev) - 1; + i.container = ev; + + return i; +} + +/* Is the iterator `i' at the end of the sequence? */ +static inline bool +ei_end_p (edge_iterator i) +{ + return (i.index == EDGE_COUNT (ei_container (i))); +} + +/* Is the iterator `i' at one position before the end of the + sequence? */ +static inline bool +ei_one_before_end_p (edge_iterator i) +{ + return (i.index + 1 == EDGE_COUNT (ei_container (i))); +} + +/* Advance the iterator to the next element. */ +static inline void +ei_next (edge_iterator *i) +{ + gcc_checking_assert (i->index < EDGE_COUNT (ei_container (*i))); + i->index++; +} + +/* Move the iterator to the previous element. */ +static inline void +ei_prev (edge_iterator *i) +{ + gcc_checking_assert (i->index > 0); + i->index--; +} + +/* Return the edge pointed to by the iterator `i'. */ +static inline edge +ei_edge (edge_iterator i) +{ + return EDGE_I (ei_container (i), i.index); +} + +/* Return an edge pointed to by the iterator. Do it safely so that + NULL is returned when the iterator is pointing at the end of the + sequence. */ +static inline edge +ei_safe_edge (edge_iterator i) +{ + return !ei_end_p (i) ? ei_edge (i) : NULL; +} + +/* Return 1 if we should continue to iterate. Return 0 otherwise. + *Edge P is set to the next edge if we are to continue to iterate + and NULL otherwise. */ + +static inline bool +ei_cond (edge_iterator ei, edge *p) +{ + if (!ei_end_p (ei)) + { + *p = ei_edge (ei); + return 1; + } + else + { + *p = NULL; + return 0; + } +} + +/* This macro serves as a convenient way to iterate each edge in a + vector of predecessor or successor edges. It must not be used when + an element might be removed during the traversal, otherwise + elements will be missed. Instead, use a for-loop like that shown + in the following pseudo-code: + + FOR (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); ) + { + IF (e != taken_edge) + remove_edge (e); + ELSE + ei_next (&ei); + } +*/ + +#define FOR_EACH_EDGE(EDGE,ITER,EDGE_VEC) \ + for ((ITER) = ei_start ((EDGE_VEC)); \ + ei_cond ((ITER), &(EDGE)); \ + ei_next (&(ITER))) + +struct edge_list * create_edge_list (void); +void free_edge_list (struct edge_list *); +void print_edge_list (FILE *, struct edge_list *); +void verify_edge_list (FILE *, struct edge_list *); +int find_edge_index (struct edge_list *, basic_block, basic_block); +edge find_edge (basic_block, basic_block); + +#define CLEANUP_EXPENSIVE 1 /* Do relatively expensive optimizations + except for edge forwarding */ +#define CLEANUP_CROSSJUMP 2 /* Do crossjumping. */ +#define CLEANUP_POST_REGSTACK 4 /* We run after reg-stack and need + to care REG_DEAD notes. */ +#define CLEANUP_THREADING 8 /* Do jump threading. */ +#define CLEANUP_NO_INSN_DEL 16 /* Do not try to delete trivially dead + insns. */ +#define CLEANUP_CFGLAYOUT 32 /* Do cleanup in cfglayout mode. */ + +/* In lcm.c */ +extern struct edge_list *pre_edge_lcm (int, sbitmap *, sbitmap *, + sbitmap *, sbitmap *, sbitmap **, + sbitmap **); +extern struct edge_list *pre_edge_rev_lcm (int, sbitmap *, + sbitmap *, sbitmap *, + sbitmap *, sbitmap **, + sbitmap **); +extern void compute_available (sbitmap *, sbitmap *, sbitmap *, sbitmap *); + +/* In predict.c */ +extern bool maybe_hot_count_p (gcov_type); +extern bool maybe_hot_bb_p (const_basic_block); +extern bool maybe_hot_edge_p (edge); +extern bool probably_never_executed_bb_p (const_basic_block); +extern bool optimize_bb_for_size_p (const_basic_block); +extern bool optimize_bb_for_speed_p (const_basic_block); +extern bool optimize_edge_for_size_p (edge); +extern bool optimize_edge_for_speed_p (edge); +extern bool optimize_loop_for_size_p (struct loop *); +extern bool optimize_loop_for_speed_p (struct loop *); +extern bool optimize_loop_nest_for_size_p (struct loop *); +extern bool optimize_loop_nest_for_speed_p (struct loop *); +extern bool gimple_predicted_by_p (const_basic_block, enum br_predictor); +extern bool rtl_predicted_by_p (const_basic_block, enum br_predictor); +extern void gimple_predict_edge (edge, enum br_predictor, int); +extern void rtl_predict_edge (edge, enum br_predictor, int); +extern void predict_edge_def (edge, enum br_predictor, enum prediction); +extern void guess_outgoing_edge_probabilities (basic_block); +extern void remove_predictions_associated_with_edge (edge); +extern bool edge_probability_reliable_p (const_edge); +extern bool br_prob_note_reliable_p (const_rtx); +extern bool predictable_edge_p (edge); + +/* In cfg.c */ +extern void init_flow (struct function *); +extern void debug_bb (basic_block); +extern basic_block debug_bb_n (int); +extern void expunge_block (basic_block); +extern void link_block (basic_block, basic_block); +extern void unlink_block (basic_block); +extern void compact_blocks (void); +extern basic_block alloc_block (void); +extern void alloc_aux_for_blocks (int); +extern void clear_aux_for_blocks (void); +extern void free_aux_for_blocks (void); +extern void alloc_aux_for_edges (int); +extern void clear_aux_for_edges (void); +extern void free_aux_for_edges (void); + +/* In cfganal.c */ +extern void find_unreachable_blocks (void); +extern bool forwarder_block_p (const_basic_block); +extern bool can_fallthru (basic_block, basic_block); +extern bool could_fall_through (basic_block, basic_block); +extern void flow_nodes_print (const char *, const_sbitmap, FILE *); +extern void flow_edge_list_print (const char *, const edge *, int, FILE *); + +/* In cfgrtl.c */ +extern basic_block force_nonfallthru (edge); +extern rtx block_label (basic_block); +extern bool purge_all_dead_edges (void); +extern bool purge_dead_edges (basic_block); + +/* In cfgbuild.c. */ +extern void find_many_sub_basic_blocks (sbitmap); +extern void rtl_make_eh_edge (sbitmap, basic_block, rtx); + +/* In cfgcleanup.c. */ +extern bool cleanup_cfg (int); +extern int flow_find_cross_jump (basic_block, basic_block, rtx *, rtx *); +extern int flow_find_head_matching_sequence (basic_block, basic_block, + rtx *, rtx *, int); + +extern bool delete_unreachable_blocks (void); + +extern bool mark_dfs_back_edges (void); +extern void set_edge_can_fallthru_flag (void); +extern void update_br_prob_note (basic_block); +extern void fixup_abnormal_edges (void); +extern bool inside_basic_block_p (const_rtx); +extern bool control_flow_insn_p (const_rtx); +extern rtx get_last_bb_insn (basic_block); + +/* In bb-reorder.c */ +extern void reorder_basic_blocks (void); + +/* In dominance.c */ + +enum cdi_direction +{ + CDI_DOMINATORS = 1, + CDI_POST_DOMINATORS = 2 +}; + +extern enum dom_state dom_info_state (enum cdi_direction); +extern void set_dom_info_availability (enum cdi_direction, enum dom_state); +extern bool dom_info_available_p (enum cdi_direction); +extern void calculate_dominance_info (enum cdi_direction); +extern void free_dominance_info (enum cdi_direction); +extern basic_block nearest_common_dominator (enum cdi_direction, + basic_block, basic_block); +extern basic_block nearest_common_dominator_for_set (enum cdi_direction, + bitmap); +extern void set_immediate_dominator (enum cdi_direction, basic_block, + basic_block); +extern basic_block get_immediate_dominator (enum cdi_direction, basic_block); +extern bool dominated_by_p (enum cdi_direction, const_basic_block, const_basic_block); +extern VEC (basic_block, heap) *get_dominated_by (enum cdi_direction, basic_block); +extern VEC (basic_block, heap) *get_dominated_by_region (enum cdi_direction, + basic_block *, + unsigned); +extern VEC (basic_block, heap) *get_dominated_to_depth (enum cdi_direction, + basic_block, int); +extern VEC (basic_block, heap) *get_all_dominated_blocks (enum cdi_direction, + basic_block); +extern void add_to_dominance_info (enum cdi_direction, basic_block); +extern void delete_from_dominance_info (enum cdi_direction, basic_block); +basic_block recompute_dominator (enum cdi_direction, basic_block); +extern void redirect_immediate_dominators (enum cdi_direction, basic_block, + basic_block); +extern void iterate_fix_dominators (enum cdi_direction, + VEC (basic_block, heap) *, bool); +extern void verify_dominators (enum cdi_direction); +extern basic_block first_dom_son (enum cdi_direction, basic_block); +extern basic_block next_dom_son (enum cdi_direction, basic_block); +unsigned bb_dom_dfs_in (enum cdi_direction, basic_block); +unsigned bb_dom_dfs_out (enum cdi_direction, basic_block); + +extern edge try_redirect_by_replacing_jump (edge, basic_block, bool); +extern void break_superblocks (void); +extern void relink_block_chain (bool); +extern void check_bb_profile (basic_block, FILE *); +extern void update_bb_profile_for_threading (basic_block, int, gcov_type, edge); +extern void init_rtl_bb_info (basic_block); + +extern void initialize_original_copy_tables (void); +extern void free_original_copy_tables (void); +extern void set_bb_original (basic_block, basic_block); +extern basic_block get_bb_original (basic_block); +extern void set_bb_copy (basic_block, basic_block); +extern basic_block get_bb_copy (basic_block); +void set_loop_copy (struct loop *, struct loop *); +struct loop *get_loop_copy (struct loop *); + +#include "cfghooks.h" + +/* Return true when one of the predecessor edges of BB is marked with EDGE_EH. */ +static inline bool +bb_has_eh_pred (basic_block bb) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, bb->preds) + { + if (e->flags & EDGE_EH) + return true; + } + return false; +} + +/* Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL. */ +static inline bool +bb_has_abnormal_pred (basic_block bb) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, bb->preds) + { + if (e->flags & EDGE_ABNORMAL) + return true; + } + return false; +} + +/* Return the fallthru edge in EDGES if it exists, NULL otherwise. */ +static inline edge +find_fallthru_edge (VEC(edge,gc) *edges) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, edges) + if (e->flags & EDGE_FALLTHRU) + break; + + return e; +} + +/* In cfgloopmanip.c. */ +extern edge mfb_kj_edge; +extern bool mfb_keep_just (edge); + +/* In cfgexpand.c. */ +extern void rtl_profile_for_bb (basic_block); +extern void rtl_profile_for_edge (edge); +extern void default_rtl_profile (void); + +#endif /* GCC_BASIC_BLOCK_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/bitmap.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/bitmap.h new file mode 100644 index 0000000..411443f --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/bitmap.h @@ -0,0 +1,597 @@ +/* Functions to support general ended bitmaps. + Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007, 2008, 2009, 2010 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/>. */ + +#ifndef GCC_BITMAP_H +#define GCC_BITMAP_H +#include "hashtab.h" +#include "statistics.h" +#include "obstack.h" + +/* Fundamental storage type for bitmap. */ + +typedef unsigned long BITMAP_WORD; +/* BITMAP_WORD_BITS needs to be unsigned, but cannot contain casts as + it is used in preprocessor directives -- hence the 1u. */ +#define BITMAP_WORD_BITS (CHAR_BIT * SIZEOF_LONG * 1u) + +/* Number of words to use for each element in the linked list. */ + +#ifndef BITMAP_ELEMENT_WORDS +#define BITMAP_ELEMENT_WORDS ((128 + BITMAP_WORD_BITS - 1) / BITMAP_WORD_BITS) +#endif + +/* Number of bits in each actual element of a bitmap. */ + +#define BITMAP_ELEMENT_ALL_BITS (BITMAP_ELEMENT_WORDS * BITMAP_WORD_BITS) + +/* Obstack for allocating bitmaps and elements from. */ +typedef struct GTY (()) bitmap_obstack { + struct bitmap_element_def *elements; + struct bitmap_head_def *heads; + struct obstack GTY ((skip)) obstack; +} bitmap_obstack; + +/* Bitmap set element. We use a linked list to hold only the bits that + are set. This allows for use to grow the bitset dynamically without + having to realloc and copy a giant bit array. + + The free list is implemented as a list of lists. There is one + outer list connected together by prev fields. Each element of that + outer is an inner list (that may consist only of the outer list + element) that are connected by the next fields. The prev pointer + is undefined for interior elements. This allows + bitmap_elt_clear_from to be implemented in unit time rather than + linear in the number of elements to be freed. */ + +typedef struct GTY(()) bitmap_element_def { + struct bitmap_element_def *next; /* Next element. */ + struct bitmap_element_def *prev; /* Previous element. */ + unsigned int indx; /* regno/BITMAP_ELEMENT_ALL_BITS. */ + BITMAP_WORD bits[BITMAP_ELEMENT_WORDS]; /* Bits that are set. */ +} bitmap_element; + +struct bitmap_descriptor; +/* Head of bitmap linked list. gengtype ignores ifdefs, but for + statistics we need to add a bitmap descriptor pointer. As it is + not collected, we can just GTY((skip)) it. */ + +typedef struct GTY(()) bitmap_head_def { + bitmap_element *first; /* First element in linked list. */ + bitmap_element *current; /* Last element looked at. */ + unsigned int indx; /* Index of last element looked at. */ + bitmap_obstack *obstack; /* Obstack to allocate elements from. + If NULL, then use GGC allocation. */ +#ifdef GATHER_STATISTICS + struct bitmap_descriptor GTY((skip)) *desc; +#endif +} bitmap_head; + +/* Global data */ +extern bitmap_element bitmap_zero_bits; /* Zero bitmap element */ +extern bitmap_obstack bitmap_default_obstack; /* Default bitmap obstack */ + +/* Clear a bitmap by freeing up the linked list. */ +extern void bitmap_clear (bitmap); + +/* Copy a bitmap to another bitmap. */ +extern void bitmap_copy (bitmap, const_bitmap); + +/* True if two bitmaps are identical. */ +extern bool bitmap_equal_p (const_bitmap, const_bitmap); + +/* True if the bitmaps intersect (their AND is non-empty). */ +extern bool bitmap_intersect_p (const_bitmap, const_bitmap); + +/* True if the complement of the second intersects the first (their + AND_COMPL is non-empty). */ +extern bool bitmap_intersect_compl_p (const_bitmap, const_bitmap); + +/* True if MAP is an empty bitmap. */ +#define bitmap_empty_p(MAP) (!(MAP)->first) + +/* True if the bitmap has only a single bit set. */ +extern bool bitmap_single_bit_set_p (const_bitmap); + +/* Count the number of bits set in the bitmap. */ +extern unsigned long bitmap_count_bits (const_bitmap); + +/* Boolean operations on bitmaps. The _into variants are two operand + versions that modify the first source operand. The other variants + are three operand versions that to not destroy the source bitmaps. + The operations supported are &, & ~, |, ^. */ +extern void bitmap_and (bitmap, const_bitmap, const_bitmap); +extern void bitmap_and_into (bitmap, const_bitmap); +extern bool bitmap_and_compl (bitmap, const_bitmap, const_bitmap); +extern bool bitmap_and_compl_into (bitmap, const_bitmap); +#define bitmap_compl_and(DST, A, B) bitmap_and_compl (DST, B, A) +extern void bitmap_compl_and_into (bitmap, const_bitmap); +extern void bitmap_clear_range (bitmap, unsigned int, unsigned int); +extern void bitmap_set_range (bitmap, unsigned int, unsigned int); +extern bool bitmap_ior (bitmap, const_bitmap, const_bitmap); +extern bool bitmap_ior_into (bitmap, const_bitmap); +extern void bitmap_xor (bitmap, const_bitmap, const_bitmap); +extern void bitmap_xor_into (bitmap, const_bitmap); + +/* DST = A | (B & C). Return true if DST changes. */ +extern bool bitmap_ior_and_into (bitmap DST, const_bitmap B, const_bitmap C); +/* DST = A | (B & ~C). Return true if DST changes. */ +extern bool bitmap_ior_and_compl (bitmap DST, const_bitmap A, const_bitmap B, const_bitmap C); +/* A |= (B & ~C). Return true if A changes. */ +extern bool bitmap_ior_and_compl_into (bitmap DST, const_bitmap B, const_bitmap C); + +/* Clear a single bit in a bitmap. Return true if the bit changed. */ +extern bool bitmap_clear_bit (bitmap, int); + +/* Set a single bit in a bitmap. Return true if the bit changed. */ +extern bool bitmap_set_bit (bitmap, int); + +/* Return true if a register is set in a register set. */ +extern int bitmap_bit_p (bitmap, int); + +/* Debug functions to print a bitmap linked list. */ +extern void debug_bitmap (const_bitmap); +extern void debug_bitmap_file (FILE *, const_bitmap); + +/* Print a bitmap. */ +extern void bitmap_print (FILE *, const_bitmap, const char *, const char *); + +/* Initialize and release a bitmap obstack. */ +extern void bitmap_obstack_initialize (bitmap_obstack *); +extern void bitmap_obstack_release (bitmap_obstack *); +extern void bitmap_register (bitmap MEM_STAT_DECL); +extern void dump_bitmap_statistics (void); + +/* Initialize a bitmap header. OBSTACK indicates the bitmap obstack + to allocate from, NULL for GC'd bitmap. */ + +static inline void +bitmap_initialize_stat (bitmap head, bitmap_obstack *obstack MEM_STAT_DECL) +{ + head->first = head->current = NULL; + head->obstack = obstack; +#ifdef GATHER_STATISTICS + bitmap_register (head PASS_MEM_STAT); +#endif +} +#define bitmap_initialize(h,o) bitmap_initialize_stat (h,o MEM_STAT_INFO) + +/* Allocate and free bitmaps from obstack, malloc and gc'd memory. */ +extern bitmap bitmap_obstack_alloc_stat (bitmap_obstack *obstack MEM_STAT_DECL); +#define bitmap_obstack_alloc(t) bitmap_obstack_alloc_stat (t MEM_STAT_INFO) +extern bitmap bitmap_gc_alloc_stat (ALONE_MEM_STAT_DECL); +#define bitmap_gc_alloc() bitmap_gc_alloc_stat (ALONE_MEM_STAT_INFO) +extern void bitmap_obstack_free (bitmap); + +/* A few compatibility/functions macros for compatibility with sbitmaps */ +#define dump_bitmap(file, bitmap) bitmap_print (file, bitmap, "", "\n") +#define bitmap_zero(a) bitmap_clear (a) +extern unsigned bitmap_first_set_bit (const_bitmap); +extern unsigned bitmap_last_set_bit (const_bitmap); + +/* Compute bitmap hash (for purposes of hashing etc.) */ +extern hashval_t bitmap_hash(const_bitmap); + +/* Allocate a bitmap from a bit obstack. */ +#define BITMAP_ALLOC(OBSTACK) bitmap_obstack_alloc (OBSTACK) + +/* Allocate a gc'd bitmap. */ +#define BITMAP_GGC_ALLOC() bitmap_gc_alloc () + +/* Do any cleanup needed on a bitmap when it is no longer used. */ +#define BITMAP_FREE(BITMAP) \ + ((void) (bitmap_obstack_free ((bitmap) BITMAP), (BITMAP) = (bitmap) NULL)) + +/* Iterator for bitmaps. */ + +typedef struct +{ + /* Pointer to the current bitmap element. */ + bitmap_element *elt1; + + /* Pointer to 2nd bitmap element when two are involved. */ + bitmap_element *elt2; + + /* Word within the current element. */ + unsigned word_no; + + /* Contents of the actually processed word. When finding next bit + it is shifted right, so that the actual bit is always the least + significant bit of ACTUAL. */ + BITMAP_WORD bits; +} bitmap_iterator; + +/* Initialize a single bitmap iterator. START_BIT is the first bit to + iterate from. */ + +static inline void +bmp_iter_set_init (bitmap_iterator *bi, const_bitmap map, + unsigned start_bit, unsigned *bit_no) +{ + bi->elt1 = map->first; + bi->elt2 = NULL; + + /* Advance elt1 until it is not before the block containing start_bit. */ + while (1) + { + if (!bi->elt1) + { + bi->elt1 = &bitmap_zero_bits; + break; + } + + if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS) + break; + bi->elt1 = bi->elt1->next; + } + + /* We might have gone past the start bit, so reinitialize it. */ + if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS) + start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS; + + /* Initialize for what is now start_bit. */ + bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS; + bi->bits = bi->elt1->bits[bi->word_no]; + bi->bits >>= start_bit % BITMAP_WORD_BITS; + + /* If this word is zero, we must make sure we're not pointing at the + first bit, otherwise our incrementing to the next word boundary + will fail. It won't matter if this increment moves us into the + next word. */ + start_bit += !bi->bits; + + *bit_no = start_bit; +} + +/* Initialize an iterator to iterate over the intersection of two + bitmaps. START_BIT is the bit to commence from. */ + +static inline void +bmp_iter_and_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2, + unsigned start_bit, unsigned *bit_no) +{ + bi->elt1 = map1->first; + bi->elt2 = map2->first; + + /* Advance elt1 until it is not before the block containing + start_bit. */ + while (1) + { + if (!bi->elt1) + { + bi->elt2 = NULL; + break; + } + + if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS) + break; + bi->elt1 = bi->elt1->next; + } + + /* Advance elt2 until it is not before elt1. */ + while (1) + { + if (!bi->elt2) + { + bi->elt1 = bi->elt2 = &bitmap_zero_bits; + break; + } + + if (bi->elt2->indx >= bi->elt1->indx) + break; + bi->elt2 = bi->elt2->next; + } + + /* If we're at the same index, then we have some intersecting bits. */ + if (bi->elt1->indx == bi->elt2->indx) + { + /* We might have advanced beyond the start_bit, so reinitialize + for that. */ + if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS) + start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS; + + bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS; + bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no]; + bi->bits >>= start_bit % BITMAP_WORD_BITS; + } + else + { + /* Otherwise we must immediately advance elt1, so initialize for + that. */ + bi->word_no = BITMAP_ELEMENT_WORDS - 1; + bi->bits = 0; + } + + /* If this word is zero, we must make sure we're not pointing at the + first bit, otherwise our incrementing to the next word boundary + will fail. It won't matter if this increment moves us into the + next word. */ + start_bit += !bi->bits; + + *bit_no = start_bit; +} + +/* Initialize an iterator to iterate over the bits in MAP1 & ~MAP2. + */ + +static inline void +bmp_iter_and_compl_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2, + unsigned start_bit, unsigned *bit_no) +{ + bi->elt1 = map1->first; + bi->elt2 = map2->first; + + /* Advance elt1 until it is not before the block containing start_bit. */ + while (1) + { + if (!bi->elt1) + { + bi->elt1 = &bitmap_zero_bits; + break; + } + + if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS) + break; + bi->elt1 = bi->elt1->next; + } + + /* Advance elt2 until it is not before elt1. */ + while (bi->elt2 && bi->elt2->indx < bi->elt1->indx) + bi->elt2 = bi->elt2->next; + + /* We might have advanced beyond the start_bit, so reinitialize for + that. */ + if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS) + start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS; + + bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS; + bi->bits = bi->elt1->bits[bi->word_no]; + if (bi->elt2 && bi->elt1->indx == bi->elt2->indx) + bi->bits &= ~bi->elt2->bits[bi->word_no]; + bi->bits >>= start_bit % BITMAP_WORD_BITS; + + /* If this word is zero, we must make sure we're not pointing at the + first bit, otherwise our incrementing to the next word boundary + will fail. It won't matter if this increment moves us into the + next word. */ + start_bit += !bi->bits; + + *bit_no = start_bit; +} + +/* Advance to the next bit in BI. We don't advance to the next + nonzero bit yet. */ + +static inline void +bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no) +{ + bi->bits >>= 1; + *bit_no += 1; +} + +/* Advance to first set bit in BI. */ + +static inline void +bmp_iter_next_bit (bitmap_iterator * bi, unsigned *bit_no) +{ +#if (GCC_VERSION >= 3004) + { + unsigned int n = __builtin_ctzl (bi->bits); + gcc_assert (sizeof (unsigned long) == sizeof (BITMAP_WORD)); + bi->bits >>= n; + *bit_no += n; + } +#else + while (!(bi->bits & 1)) + { + bi->bits >>= 1; + *bit_no += 1; + } +#endif +} + +/* Advance to the next nonzero bit of a single bitmap, we will have + already advanced past the just iterated bit. Return true if there + is a bit to iterate. */ + +static inline bool +bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no) +{ + /* If our current word is nonzero, it contains the bit we want. */ + if (bi->bits) + { + next_bit: + bmp_iter_next_bit (bi, bit_no); + return true; + } + + /* Round up to the word boundary. We might have just iterated past + the end of the last word, hence the -1. It is not possible for + bit_no to point at the beginning of the now last word. */ + *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1) + / BITMAP_WORD_BITS * BITMAP_WORD_BITS); + bi->word_no++; + + while (1) + { + /* Find the next nonzero word in this elt. */ + while (bi->word_no != BITMAP_ELEMENT_WORDS) + { + bi->bits = bi->elt1->bits[bi->word_no]; + if (bi->bits) + goto next_bit; + *bit_no += BITMAP_WORD_BITS; + bi->word_no++; + } + + /* Advance to the next element. */ + bi->elt1 = bi->elt1->next; + if (!bi->elt1) + return false; + *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS; + bi->word_no = 0; + } +} + +/* Advance to the next nonzero bit of an intersecting pair of + bitmaps. We will have already advanced past the just iterated bit. + Return true if there is a bit to iterate. */ + +static inline bool +bmp_iter_and (bitmap_iterator *bi, unsigned *bit_no) +{ + /* If our current word is nonzero, it contains the bit we want. */ + if (bi->bits) + { + next_bit: + bmp_iter_next_bit (bi, bit_no); + return true; + } + + /* Round up to the word boundary. We might have just iterated past + the end of the last word, hence the -1. It is not possible for + bit_no to point at the beginning of the now last word. */ + *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1) + / BITMAP_WORD_BITS * BITMAP_WORD_BITS); + bi->word_no++; + + while (1) + { + /* Find the next nonzero word in this elt. */ + while (bi->word_no != BITMAP_ELEMENT_WORDS) + { + bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no]; + if (bi->bits) + goto next_bit; + *bit_no += BITMAP_WORD_BITS; + bi->word_no++; + } + + /* Advance to the next identical element. */ + do + { + /* Advance elt1 while it is less than elt2. We always want + to advance one elt. */ + do + { + bi->elt1 = bi->elt1->next; + if (!bi->elt1) + return false; + } + while (bi->elt1->indx < bi->elt2->indx); + + /* Advance elt2 to be no less than elt1. This might not + advance. */ + while (bi->elt2->indx < bi->elt1->indx) + { + bi->elt2 = bi->elt2->next; + if (!bi->elt2) + return false; + } + } + while (bi->elt1->indx != bi->elt2->indx); + + *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS; + bi->word_no = 0; + } +} + +/* Advance to the next nonzero bit in the intersection of + complemented bitmaps. We will have already advanced past the just + iterated bit. */ + +static inline bool +bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no) +{ + /* If our current word is nonzero, it contains the bit we want. */ + if (bi->bits) + { + next_bit: + bmp_iter_next_bit (bi, bit_no); + return true; + } + + /* Round up to the word boundary. We might have just iterated past + the end of the last word, hence the -1. It is not possible for + bit_no to point at the beginning of the now last word. */ + *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1) + / BITMAP_WORD_BITS * BITMAP_WORD_BITS); + bi->word_no++; + + while (1) + { + /* Find the next nonzero word in this elt. */ + while (bi->word_no != BITMAP_ELEMENT_WORDS) + { + bi->bits = bi->elt1->bits[bi->word_no]; + if (bi->elt2 && bi->elt2->indx == bi->elt1->indx) + bi->bits &= ~bi->elt2->bits[bi->word_no]; + if (bi->bits) + goto next_bit; + *bit_no += BITMAP_WORD_BITS; + bi->word_no++; + } + + /* Advance to the next element of elt1. */ + bi->elt1 = bi->elt1->next; + if (!bi->elt1) + return false; + + /* Advance elt2 until it is no less than elt1. */ + while (bi->elt2 && bi->elt2->indx < bi->elt1->indx) + bi->elt2 = bi->elt2->next; + + *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS; + bi->word_no = 0; + } +} + +/* Loop over all bits set in BITMAP, starting with MIN and setting + BITNUM to the bit number. ITER is a bitmap iterator. BITNUM + should be treated as a read-only variable as it contains loop + state. */ + +#define EXECUTE_IF_SET_IN_BITMAP(BITMAP, MIN, BITNUM, ITER) \ + for (bmp_iter_set_init (&(ITER), (BITMAP), (MIN), &(BITNUM)); \ + bmp_iter_set (&(ITER), &(BITNUM)); \ + bmp_iter_next (&(ITER), &(BITNUM))) + +/* Loop over all the bits set in BITMAP1 & BITMAP2, starting with MIN + and setting BITNUM to the bit number. ITER is a bitmap iterator. + BITNUM should be treated as a read-only variable as it contains + loop state. */ + +#define EXECUTE_IF_AND_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER) \ + for (bmp_iter_and_init (&(ITER), (BITMAP1), (BITMAP2), (MIN), \ + &(BITNUM)); \ + bmp_iter_and (&(ITER), &(BITNUM)); \ + bmp_iter_next (&(ITER), &(BITNUM))) + +/* Loop over all the bits set in BITMAP1 & ~BITMAP2, starting with MIN + and setting BITNUM to the bit number. ITER is a bitmap iterator. + BITNUM should be treated as a read-only variable as it contains + loop state. */ + +#define EXECUTE_IF_AND_COMPL_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER) \ + for (bmp_iter_and_compl_init (&(ITER), (BITMAP1), (BITMAP2), (MIN), \ + &(BITNUM)); \ + bmp_iter_and_compl (&(ITER), &(BITNUM)); \ + bmp_iter_next (&(ITER), &(BITNUM))) + +#endif /* GCC_BITMAP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/builtins.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/builtins.def new file mode 100644 index 0000000..e8169ec --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/builtins.def @@ -0,0 +1,777 @@ +/* This file contains the definitions and documentation for the + builtins used in the GNU compiler. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, + 2010 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, you should define a macro: + + DEF_BUILTIN (ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, + FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) + + This macro will be called once for each builtin function. The + ENUM will be of type `enum built_in_function', and will indicate + which builtin function is being processed. The NAME of the builtin + function (which will always start with `__builtin_') is a string + literal. The CLASS is of type `enum built_in_class' and indicates + what kind of builtin is being processed. + + Some builtins are actually two separate functions. For example, + for `strcmp' there are two builtin functions; `__builtin_strcmp' + and `strcmp' itself. Both behave identically. Other builtins + define only the `__builtin' variant. If BOTH_P is TRUE, then this + builtin has both variants; otherwise, it is has only the first + variant. + + TYPE indicates the type of the function. The symbols correspond to + enumerals from builtin-types.def. If BOTH_P is true, then LIBTYPE + is the type of the non-`__builtin_' variant. Otherwise, LIBTYPE + should be ignored. + + If FALLBACK_P is true then, if for some reason, the compiler cannot + expand the builtin function directly, it will call the + corresponding library function (which does not have the + `__builtin_' prefix. + + If NONANSI_P is true, then the non-`__builtin_' variant is not an + ANSI/ISO library function, and so we should pretend it does not + exist when compiling in ANSI conformant mode. + + ATTRs is an attribute list as defined in builtin-attrs.def that + describes the attributes of this builtin function. + + IMPLICIT specifies condition when the builtin can be produced by + compiler. For instance C90 reserves floorf function, but does not + define it's meaning. When user uses floorf we may assume that the + floorf has the meaning we expect, but we can't produce floorf by + simplifying floor((double)float) since the runtime need not implement + it. + + The builtins is registered only if COND is true. */ + +/* A GCC builtin (like __builtin_saveregs) is provided by the + compiler, but does not correspond to a function in the standard + library. */ +#undef DEF_GCC_BUILTIN +#define DEF_GCC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \ + false, false, false, ATTRS, true, true) + +/* Like DEF_GCC_BUILTIN, except we don't prepend "__builtin_". */ +#undef DEF_SYNC_BUILTIN +#define DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \ + false, false, false, ATTRS, true, true) + +/* A library builtin (like __builtin_strchr) is a builtin equivalent + of an ANSI/ISO standard library function. In addition to the + `__builtin' version, we will create an ordinary version (e.g, + `strchr') as well. If we cannot compute the answer using the + builtin function, we will fall back to the standard library + version. */ +#undef DEF_LIB_BUILTIN +#define DEF_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, false, ATTRS, true, true) + +/* Like DEF_LIB_BUILTIN, except that the function is not one that is + specified by ANSI/ISO C. So, when we're being fully conformant we + ignore the version of these builtins that does not begin with + __builtin. */ +#undef DEF_EXT_LIB_BUILTIN +#define DEF_EXT_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, true, ATTRS, false, true) + +/* Like DEF_LIB_BUILTIN, except that the function is only a part of + the standard in C94 or above. */ +#undef DEF_C94_BUILTIN +#define DEF_C94_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, !flag_isoc94, ATTRS, TARGET_C99_FUNCTIONS, true) + +/* Like DEF_LIB_BUILTIN, except that the function is only a part of + the standard in C99 or above. */ +#undef DEF_C99_BUILTIN +#define DEF_C99_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, !flag_isoc99, ATTRS, TARGET_C99_FUNCTIONS, true) + +/* Builtin that is specified by C99 and C90 reserve the name for future use. + We can still recognize the builtin in C90 mode but we can't produce it + implicitly. */ +#undef DEF_C99_C90RES_BUILTIN +#define DEF_C99_C90RES_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, !flag_isoc99, ATTRS, TARGET_C99_FUNCTIONS, true) + +/* Builtin that C99 reserve the name for future use. We can still recognize + the builtin in C99 mode but we can't produce it implicitly. */ +#undef DEF_EXT_C99RES_BUILTIN +#define DEF_EXT_C99RES_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + true, true, true, ATTRS, false, true) + +/* Allocate the enum and the name for a builtin, but do not actually + define it here at all. */ +#undef DEF_BUILTIN_STUB +#define DEF_BUILTIN_STUB(ENUM, NAME) \ + DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, 0, 0, false, false, \ + false, 0, false, false) + +/* Builtin used by the implementation of GNU OpenMP. None of these are + actually implemented in the compiler; they're all in libgomp. */ +#undef DEF_GOMP_BUILTIN +#define DEF_GOMP_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ + DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \ + false, true, true, ATTRS, false, \ + (flag_openmp || flag_tree_parallelize_loops)) + +/* Define an attribute list for math functions that are normally + "impure" because some of them may write into global memory for + `errno'. If !flag_errno_math they are instead "const". */ +#undef ATTR_MATHFN_ERRNO +#define ATTR_MATHFN_ERRNO (flag_errno_math ? \ + ATTR_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST) + +/* Define an attribute list for math functions that are normally + "const" but if flag_rounding_math is set they are instead "pure". + This distinction accounts for the fact that some math functions + check the rounding mode which is akin to examining global + memory. */ +#undef ATTR_MATHFN_FPROUNDING +#define ATTR_MATHFN_FPROUNDING (flag_rounding_math ? \ + ATTR_PURE_NOTHROW_NOVOPS_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST) + +/* Define an attribute list for math functions that are normally + "impure" because some of them may write into global memory for + `errno'. If !flag_errno_math, we can possibly use "pure" or + "const" depending on whether we care about FP rounding. */ +#undef ATTR_MATHFN_FPROUNDING_ERRNO +#define ATTR_MATHFN_FPROUNDING_ERRNO (flag_errno_math ? \ + ATTR_NOTHROW_LEAF_LIST : ATTR_MATHFN_FPROUNDING) + +/* Define an attribute list for math functions that need to mind FP + rounding, but because they store into memory they are never "const" + or "pure". Use of this macro is mainly for documentation and + maintenance purposes. */ +#undef ATTR_MATHFN_FPROUNDING_STORE +#define ATTR_MATHFN_FPROUNDING_STORE ATTR_NOTHROW_LEAF_LIST + +/* Category: math builtins. */ +DEF_LIB_BUILTIN (BUILT_IN_ACOS, "acos", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ACOSF, "acosf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ACOSH, "acosh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ACOSHF, "acoshf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ACOSHL, "acoshl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ACOSL, "acosl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_ASIN, "asin", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ASINF, "asinf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ASINH, "asinh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_ASINHF, "asinhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_ASINHL, "asinhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ASINL, "asinl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_ATAN, "atan", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_ATAN2, "atan2", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ATAN2F, "atan2f", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ATAN2L, "atan2l", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ATANF, "atanf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_ATANH, "atanh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ATANHF, "atanhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ATANHL, "atanhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ATANL, "atanl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CBRT, "cbrt", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CBRTF, "cbrtf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CBRTL, "cbrtl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_CEIL, "ceil", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_CEILF, "ceilf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_CEILL, "ceill", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_COPYSIGN, "copysign", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_COPYSIGNF, "copysignf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_COPYSIGNL, "copysignl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_COS, "cos", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_COSF, "cosf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_COSH, "cosh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_COSHF, "coshf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_COSHL, "coshl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_COSL, "cosl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_EXT_LIB_BUILTIN (BUILT_IN_DREM, "drem", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_DREMF, "dremf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_DREML, "dreml", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ERF, "erf", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_ERFC, "erfc", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ERFCF, "erfcf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ERFCL, "erfcl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ERFF, "erff", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_ERFL, "erfl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_EXP, "exp", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXP10, "exp10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXP10F, "exp10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXP10L, "exp10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_EXP2, "exp2", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_EXP2F, "exp2f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_EXP2L, "exp2l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_EXPF, "expf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_EXPL, "expl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_EXPM1, "expm1", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_EXPM1F, "expm1f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_EXPM1L, "expm1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_FABS, "fabs", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FABSF, "fabsf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FABSL, "fabsl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FDIM, "fdim", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_FDIMF, "fdimf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_FDIML, "fdiml", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_FLOOR, "floor", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FLOORF, "floorf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FLOORL, "floorl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FMA, "fma", BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_FMAF, "fmaf", BT_FN_FLOAT_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_FMAL, "fmal", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_FMAX, "fmax", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FMAXF, "fmaxf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FMAXL, "fmaxl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FMIN, "fmin", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FMINF, "fminf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_FMINL, "fminl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_FMOD, "fmod", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FMODF, "fmodf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FMODL, "fmodl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_FREXP, "frexp", BT_FN_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FREXPF, "frexpf", BT_FN_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_C90RES_BUILTIN (BUILT_IN_FREXPL, "frexpl", BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMA, "gamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAF, "gammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAL, "gammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMA_R, "gamma_r", BT_FN_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAF_R, "gammaf_r", BT_FN_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAL_R, "gammal_r", BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_GCC_BUILTIN (BUILT_IN_HUGE_VAL, "huge_val", BT_FN_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_HUGE_VALF, "huge_valf", BT_FN_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_HUGE_VALL, "huge_vall", BT_FN_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_HYPOT, "hypot", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_HYPOTF, "hypotf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_HYPOTL, "hypotl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ILOGB, "ilogb", BT_FN_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ILOGBF, "ilogbf", BT_FN_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ILOGBL, "ilogbl", BT_FN_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_GCC_BUILTIN (BUILT_IN_INF, "inf", BT_FN_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_INFF, "inff", BT_FN_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_INFL, "infl", BT_FN_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_INFD32, "infd32", BT_FN_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_INFD64, "infd64", BT_FN_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_INFD128, "infd128", BT_FN_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_J0, "j0", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_J0F, "j0f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_J0L, "j0l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_J1, "j1", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_J1F, "j1f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_J1L, "j1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_JN, "jn", BT_FN_DOUBLE_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_JNF, "jnf", BT_FN_FLOAT_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_JNL, "jnl", BT_FN_LONGDOUBLE_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_GCC_BUILTIN (BUILT_IN_LCEIL, "lceil", BT_FN_LONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LCEILF, "lceilf", BT_FN_LONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LCEILL, "lceill", BT_FN_LONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_LDEXP, "ldexp", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_LDEXPF, "ldexpf", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_LDEXPL, "ldexpl", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_GCC_BUILTIN (BUILT_IN_LFLOOR, "lfloor", BT_FN_LONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LFLOORF, "lfloorf", BT_FN_LONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LFLOORL, "lfloorl", BT_FN_LONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_LGAMMA, "lgamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_BUILTIN (BUILT_IN_LGAMMAF, "lgammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_BUILTIN (BUILT_IN_LGAMMAL, "lgammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_LGAMMA_R, "lgamma_r", BT_FN_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_LGAMMAF_R, "lgammaf_r", BT_FN_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_LGAMMAL_R, "lgammal_r", BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_GCC_BUILTIN (BUILT_IN_LLCEIL, "llceil", BT_FN_LONGLONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LLCEILF, "llceilf", BT_FN_LONGLONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LLCEILL, "llceill", BT_FN_LONGLONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LLFLOOR, "llfloor", BT_FN_LONGLONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LLFLOORF, "llfloorf", BT_FN_LONGLONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LLFLOORL, "llfloorl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_LLRINT, "llrint", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LLRINTF, "llrintf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LLRINTL, "llrintl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LLROUND, "llround", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LLROUNDF, "llroundf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LLROUNDL, "llroundl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_LOG, "log", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_LOG10, "log10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_LOG10F, "log10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_LOG10L, "log10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOG1P, "log1p", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOG1PF, "log1pf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOG1PL, "log1pl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOG2, "log2", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOG2F, "log2f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOG2L, "log2l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOGB, "logb", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOGBF, "logbf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LOGBL, "logbl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_LOGF, "logf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_LOGL, "logl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LRINT, "lrint", BT_FN_LONG_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LRINTF, "lrintf", BT_FN_LONG_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LRINTL, "lrintl", BT_FN_LONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LROUND, "lround", BT_FN_LONG_DOUBLE, ATTR_MATHFN_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LROUNDF, "lroundf", BT_FN_LONG_FLOAT, ATTR_MATHFN_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_LROUNDL, "lroundl", BT_FN_LONG_LONGDOUBLE, ATTR_MATHFN_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_MODF, "modf", BT_FN_DOUBLE_DOUBLE_DOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_C90RES_BUILTIN (BUILT_IN_MODFF, "modff", BT_FN_FLOAT_FLOAT_FLOATPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_C90RES_BUILTIN (BUILT_IN_MODFL, "modfl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_BUILTIN (BUILT_IN_NAN, "nan", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_C99_BUILTIN (BUILT_IN_NANF, "nanf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_C99_BUILTIN (BUILT_IN_NANL, "nanl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_GCC_BUILTIN (BUILT_IN_NAND32, "nand32", BT_FN_DFLOAT32_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_GCC_BUILTIN (BUILT_IN_NAND64, "nand64", BT_FN_DFLOAT64_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_GCC_BUILTIN (BUILT_IN_NAND128, "nand128", BT_FN_DFLOAT128_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_GCC_BUILTIN (BUILT_IN_NANS, "nans", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_GCC_BUILTIN (BUILT_IN_NANSF, "nansf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_GCC_BUILTIN (BUILT_IN_NANSL, "nansl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL) +DEF_C99_BUILTIN (BUILT_IN_NEARBYINT, "nearbyint", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_NEARBYINTF, "nearbyintf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_NEARBYINTL, "nearbyintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_NEXTAFTER, "nextafter", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_NEXTAFTERF, "nextafterf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_NEXTAFTERL, "nextafterl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_NEXTTOWARD, "nexttoward", BT_FN_DOUBLE_DOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_NEXTTOWARDF, "nexttowardf", BT_FN_FLOAT_FLOAT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_NEXTTOWARDL, "nexttowardl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_POW, "pow", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_POW10, "pow10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_POW10F, "pow10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_POW10L, "pow10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_POWF, "powf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_GCC_BUILTIN (BUILT_IN_POWI, "powi", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING) +DEF_GCC_BUILTIN (BUILT_IN_POWIF, "powif", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING) +DEF_GCC_BUILTIN (BUILT_IN_POWIL, "powil", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_POWL, "powl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_REMAINDER, "remainder", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_REMAINDERF, "remainderf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_REMAINDERL, "remainderl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_REMQUO, "remquo", BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_BUILTIN (BUILT_IN_REMQUOF, "remquof", BT_FN_FLOAT_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_BUILTIN (BUILT_IN_REMQUOL, "remquol", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_BUILTIN (BUILT_IN_RINT, "rint", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_RINTF, "rintf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_RINTL, "rintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_ROUND, "round", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_ROUNDF, "roundf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_ROUNDL, "roundl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALB, "scalb", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALBF, "scalbf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALBL, "scalbl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_SCALBLN, "scalbln", BT_FN_DOUBLE_DOUBLE_LONG, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_SCALBLNF, "scalblnf", BT_FN_FLOAT_FLOAT_LONG, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_SCALBLNL, "scalblnl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONG, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_SCALBN, "scalbn", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_SCALBNF, "scalbnf", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_SCALBNL, "scalbnl", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBIT, "signbit", BT_FN_INT_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITF, "signbitf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITL, "signbitl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITD32, "signbitd32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITD64, "signbitd64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITD128, "signbitd128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNIFICAND, "significand", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNIFICANDF, "significandf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNIFICANDL, "significandl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_SIN, "sin", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SINCOS, "sincos", BT_FN_VOID_DOUBLE_DOUBLEPTR_DOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SINCOSF, "sincosf", BT_FN_VOID_FLOAT_FLOATPTR_FLOATPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SINCOSL, "sincosl", BT_FN_VOID_LONGDOUBLE_LONGDOUBLEPTR_LONGDOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE) +DEF_C99_C90RES_BUILTIN (BUILT_IN_SINF, "sinf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_SINH, "sinh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_SINHF, "sinhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_SINHL, "sinhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_SINL, "sinl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_SQRT, "sqrt", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_SQRTF, "sqrtf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_C90RES_BUILTIN (BUILT_IN_SQRTL, "sqrtl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_LIB_BUILTIN (BUILT_IN_TAN, "tan", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_TANF, "tanf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_LIB_BUILTIN (BUILT_IN_TANH, "tanh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_TANHF, "tanhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_TANHL, "tanhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_C90RES_BUILTIN (BUILT_IN_TANL, "tanl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_TGAMMA, "tgamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_TGAMMAF, "tgammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_TGAMMAL, "tgammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_C99_BUILTIN (BUILT_IN_TRUNC, "trunc", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_TRUNCF, "truncf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_TRUNCL, "truncl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_Y0, "y0", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_Y0F, "y0f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_Y0L, "y0l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_Y1, "y1", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_Y1F, "y1f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_Y1L, "y1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_YN, "yn", BT_FN_DOUBLE_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_YNF, "ynf", BT_FN_FLOAT_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) +DEF_EXT_LIB_BUILTIN (BUILT_IN_YNL, "ynl", BT_FN_LONGDOUBLE_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) + +/* Category: _Complex math builtins. */ +DEF_C99_BUILTIN (BUILT_IN_CABS, "cabs", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CABSF, "cabsf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CABSL, "cabsl", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CACOS, "cacos", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CACOSF, "cacosf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CACOSH, "cacosh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CACOSHF, "cacoshf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CACOSHL, "cacoshl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CACOSL, "cacosl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CARG, "carg", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CARGF, "cargf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CARGL, "cargl", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CASIN, "casin", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CASINF, "casinf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CASINH, "casinh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CASINHF, "casinhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CASINHL, "casinhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CASINL, "casinl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CATAN, "catan", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CATANF, "catanf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CATANH, "catanh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CATANHF, "catanhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CATANHL, "catanhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CATANL, "catanl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CCOS, "ccos", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CCOSF, "ccosf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CCOSH, "ccosh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CCOSHF, "ccoshf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CCOSHL, "ccoshl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CCOSL, "ccosl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CEXP, "cexp", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CEXPF, "cexpf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CEXPL, "cexpl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_GCC_BUILTIN (BUILT_IN_CEXPI, "cexpi", BT_FN_COMPLEX_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_GCC_BUILTIN (BUILT_IN_CEXPIF, "cexpif", BT_FN_COMPLEX_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_GCC_BUILTIN (BUILT_IN_CEXPIL, "cexpil", BT_FN_COMPLEX_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CIMAG, "cimag", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CIMAGF, "cimagf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CIMAGL, "cimagl", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CLOG, "clog", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CLOGF, "clogf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CLOGL, "clogl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_EXT_C99RES_BUILTIN (BUILT_IN_CLOG10, "clog10", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_EXT_C99RES_BUILTIN (BUILT_IN_CLOG10F, "clog10f", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_EXT_C99RES_BUILTIN (BUILT_IN_CLOG10L, "clog10l", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CONJ, "conj", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CONJF, "conjf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CONJL, "conjl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CPOW, "cpow", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CPOWF, "cpowf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CPOWL, "cpowl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CPROJ, "cproj", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CPROJF, "cprojf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CPROJL, "cprojl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CREAL, "creal", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CREALF, "crealf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CREALL, "creall", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_CSIN, "csin", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSINF, "csinf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSINH, "csinh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSINHF, "csinhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSINHL, "csinhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSINL, "csinl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSQRT, "csqrt", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSQRTF, "csqrtf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CSQRTL, "csqrtl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CTAN, "ctan", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CTANF, "ctanf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CTANH, "ctanh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CTANHF, "ctanhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CTANHL, "ctanhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CTANL, "ctanl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) + +/* Category: string/memory builtins. */ +/* bcmp, bcopy and bzero have traditionally accepted NULL pointers + when the length parameter is zero, so don't apply attribute "nonnull". */ +DEF_EXT_LIB_BUILTIN (BUILT_IN_BCMP, "bcmp", BT_FN_INT_CONST_PTR_CONST_PTR_SIZE, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_BCOPY, "bcopy", BT_FN_VOID_CONST_PTR_PTR_SIZE, ATTR_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_BZERO, "bzero", BT_FN_VOID_PTR_SIZE, ATTR_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_INDEX, "index", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_MEMCHR, "memchr", BT_FN_PTR_CONST_PTR_INT_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_MEMCMP, "memcmp", BT_FN_INT_CONST_PTR_CONST_PTR_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_MEMCPY, "memcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_MEMMOVE, "memmove", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMPCPY, "mempcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_MEMSET, "memset", BT_FN_PTR_PTR_INT_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_RINDEX, "rindex", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STPCPY, "stpcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STPNCPY, "stpncpy", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCASECMP, "strcasecmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRCAT, "strcat", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRCHR, "strchr", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRCMP, "strcmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRCPY, "strcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRCSPN, "strcspn", BT_FN_SIZE_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRDUP, "strdup", BT_FN_STRING_CONST_STRING, ATTR_MALLOC_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNDUP, "strndup", BT_FN_STRING_CONST_STRING_SIZE, ATTR_MALLOC_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRLEN, "strlen", BT_FN_SIZE_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCASECMP, "strncasecmp", BT_FN_INT_CONST_STRING_CONST_STRING_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRNCAT, "strncat", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRNCMP, "strncmp", BT_FN_INT_CONST_STRING_CONST_STRING_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRNCPY, "strncpy", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRPBRK, "strpbrk", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRRCHR, "strrchr", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRSPN, "strspn", BT_FN_SIZE_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_STRSTR, "strstr", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF) + +/* Category: stdio builtins. */ +DEF_LIB_BUILTIN (BUILT_IN_FPRINTF, "fprintf", BT_FN_INT_FILEPTR_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FPRINTF_UNLOCKED, "fprintf_unlocked", BT_FN_INT_FILEPTR_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3) +DEF_LIB_BUILTIN (BUILT_IN_PUTC, "putc", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTC_UNLOCKED, "putc_unlocked", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST) +DEF_LIB_BUILTIN (BUILT_IN_FPUTC, "fputc", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FPUTC_UNLOCKED, "fputc_unlocked", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST) +DEF_LIB_BUILTIN (BUILT_IN_FPUTS, "fputs", BT_FN_INT_CONST_STRING_FILEPTR, ATTR_NONNULL_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FPUTS_UNLOCKED, "fputs_unlocked", BT_FN_INT_CONST_STRING_FILEPTR, ATTR_NONNULL_LIST) +DEF_LIB_BUILTIN (BUILT_IN_FSCANF, "fscanf", BT_FN_INT_FILEPTR_CONST_STRING_VAR, ATTR_FORMAT_SCANF_2_3) +DEF_LIB_BUILTIN (BUILT_IN_FWRITE, "fwrite", BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR, ATTR_NONNULL_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FWRITE_UNLOCKED, "fwrite_unlocked", BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR, ATTR_NONNULL_LIST) +DEF_LIB_BUILTIN (BUILT_IN_PRINTF, "printf", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_1_2) +DEF_EXT_LIB_BUILTIN (BUILT_IN_PRINTF_UNLOCKED, "printf_unlocked", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_1_2) +DEF_LIB_BUILTIN (BUILT_IN_PUTCHAR, "putchar", BT_FN_INT_INT, ATTR_NULL) +DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTCHAR_UNLOCKED, "putchar_unlocked", BT_FN_INT_INT, ATTR_NULL) +DEF_LIB_BUILTIN (BUILT_IN_PUTS, "puts", BT_FN_INT_CONST_STRING, ATTR_NONNULL_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTS_UNLOCKED, "puts_unlocked", BT_FN_INT_CONST_STRING, ATTR_NONNULL_LIST) +DEF_LIB_BUILTIN (BUILT_IN_SCANF, "scanf", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_SCANF_1_2) +DEF_C99_BUILTIN (BUILT_IN_SNPRINTF, "snprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_3_4) +DEF_LIB_BUILTIN (BUILT_IN_SPRINTF, "sprintf", BT_FN_INT_STRING_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_2_3) +DEF_LIB_BUILTIN (BUILT_IN_SSCANF, "sscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_FORMAT_SCANF_NOTHROW_2_3) +DEF_LIB_BUILTIN (BUILT_IN_VFPRINTF, "vfprintf", BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_2_0) +DEF_C99_BUILTIN (BUILT_IN_VFSCANF, "vfscanf", BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_2_0) +DEF_LIB_BUILTIN (BUILT_IN_VPRINTF, "vprintf", BT_FN_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_1_0) +DEF_C99_BUILTIN (BUILT_IN_VSCANF, "vscanf", BT_FN_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_1_0) +DEF_C99_BUILTIN (BUILT_IN_VSNPRINTF, "vsnprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_3_0) +DEF_LIB_BUILTIN (BUILT_IN_VSPRINTF, "vsprintf", BT_FN_INT_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_2_0) +DEF_C99_BUILTIN (BUILT_IN_VSSCANF, "vsscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_NOTHROW_2_0) + +/* Category: ctype builtins. */ +DEF_LIB_BUILTIN (BUILT_IN_ISALNUM, "isalnum", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISALPHA, "isalpha", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISASCII, "isascii", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_ISBLANK, "isblank", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISCNTRL, "iscntrl", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISDIGIT, "isdigit", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISGRAPH, "isgraph", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISLOWER, "islower", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISPRINT, "isprint", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISPUNCT, "ispunct", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISSPACE, "isspace", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISUPPER, "isupper", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ISXDIGIT, "isxdigit", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_TOASCII, "toascii", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_TOLOWER, "tolower", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_TOUPPER, "toupper", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST) + +/* Category: wctype builtins. */ +DEF_C94_BUILTIN (BUILT_IN_ISWALNUM, "iswalnum", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWALPHA, "iswalpha", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_ISWBLANK, "iswblank", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWCNTRL, "iswcntrl", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWDIGIT, "iswdigit", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWGRAPH, "iswgraph", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWLOWER, "iswlower", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWPRINT, "iswprint", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWPUNCT, "iswpunct", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWSPACE, "iswspace", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWUPPER, "iswupper", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_ISWXDIGIT, "iswxdigit", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_TOWLOWER, "towlower", BT_FN_WINT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_C94_BUILTIN (BUILT_IN_TOWUPPER, "towupper", BT_FN_WINT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST) + +/* Category: miscellaneous builtins. */ +DEF_LIB_BUILTIN (BUILT_IN_ABORT, "abort", BT_FN_VOID, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_ABS, "abs", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_AGGREGATE_INCOMING_ADDRESS, "aggregate_incoming_address", BT_FN_PTR_VAR, ATTR_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ALLOCA, "alloca", BT_FN_PTR_SIZE, ATTR_MALLOC_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_APPLY, "apply", BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE, ATTR_NULL) +DEF_GCC_BUILTIN (BUILT_IN_APPLY_ARGS, "apply_args", BT_FN_PTR_VAR, ATTR_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_BSWAP32, "bswap32", BT_FN_UINT32_UINT32, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_BSWAP64, "bswap64", BT_FN_UINT64_UINT64, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_CLEAR_CACHE, "__clear_cache", BT_FN_VOID_PTR_PTR, ATTR_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_CALLOC, "calloc", BT_FN_PTR_SIZE_SIZE, ATTR_MALLOC_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CLASSIFY_TYPE, "classify_type", BT_FN_INT_VAR, ATTR_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CLZ, "clz", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CLZIMAX, "clzimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CLZL, "clzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CLZLL, "clzll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CONSTANT_P, "constant_p", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CTZ, "ctz", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CTZIMAX, "ctzimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CTZL, "ctzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_CTZLL, "ctzll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_DCGETTEXT, "dcgettext", BT_FN_STRING_CONST_STRING_CONST_STRING_INT, ATTR_FORMAT_ARG_2) +DEF_EXT_LIB_BUILTIN (BUILT_IN_DGETTEXT, "dgettext", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_FORMAT_ARG_2) +DEF_GCC_BUILTIN (BUILT_IN_DWARF_CFA, "dwarf_cfa", BT_FN_PTR, ATTR_NULL) +DEF_GCC_BUILTIN (BUILT_IN_DWARF_SP_COLUMN, "dwarf_sp_column", BT_FN_UINT, ATTR_NULL) +DEF_GCC_BUILTIN (BUILT_IN_EH_RETURN, "eh_return", BT_FN_VOID_PTRMODE_PTR, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_EH_RETURN_DATA_REGNO, "eh_return_data_regno", BT_FN_INT_INT, ATTR_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECL, "execl", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_SENTINEL_NOTHROW_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECLP, "execlp", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_SENTINEL_NOTHROW_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECLE, "execle", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_NOTHROW_SENTINEL_1) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECV, "execv", BT_FN_INT_CONST_STRING_PTR_CONST_STRING, ATTR_NOTHROW_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECVP, "execvp", BT_FN_INT_CONST_STRING_PTR_CONST_STRING, ATTR_NOTHROW_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECVE, "execve", BT_FN_INT_CONST_STRING_PTR_CONST_STRING_PTR_CONST_STRING, ATTR_NOTHROW_LIST) +DEF_LIB_BUILTIN (BUILT_IN_EXIT, "exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LIST) +DEF_GCC_BUILTIN (BUILT_IN_EXPECT, "expect", BT_FN_LONG_LONG_LONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_EXTEND_POINTER, "extend_pointer", BT_FN_UNWINDWORD_PTR, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_EXTRACT_RETURN_ADDR, "extract_return_addr", BT_FN_PTR_PTR, ATTR_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FFS, "ffs", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FFSIMAX, "ffsimax", BT_FN_INT_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FFSL, "ffsl", BT_FN_INT_LONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FFSLL, "ffsll", BT_FN_INT_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FORK, "fork", BT_FN_PID, ATTR_NOTHROW_LIST) +DEF_GCC_BUILTIN (BUILT_IN_FRAME_ADDRESS, "frame_address", BT_FN_PTR_UINT, ATTR_NULL) +DEF_LIB_BUILTIN (BUILT_IN_FREE, "free", BT_FN_VOID_PTR, ATTR_NOTHROW_LIST) +DEF_GCC_BUILTIN (BUILT_IN_FROB_RETURN_ADDR, "frob_return_addr", BT_FN_PTR_PTR, ATTR_NULL) +DEF_EXT_LIB_BUILTIN (BUILT_IN_GETTEXT, "gettext", BT_FN_STRING_CONST_STRING, ATTR_FORMAT_ARG_1) +DEF_C99_BUILTIN (BUILT_IN_IMAXABS, "imaxabs", BT_FN_INTMAX_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_INIT_DWARF_REG_SIZES, "init_dwarf_reg_size_table", BT_FN_VOID_PTR, ATTR_NULL) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITE, "finite", BT_FN_INT_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITEF, "finitef", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITEL, "finitel", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITED32, "finited32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITED64, "finited64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITED128, "finited128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_FPCLASSIFY, "fpclassify", BT_FN_INT_INT_INT_INT_INT_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISFINITE, "isfinite", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISINF_SIGN, "isinf_sign", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ISINF, "isinf", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFF, "isinff", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFL, "isinfl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFD32, "isinfd32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFD64, "isinfd64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFD128, "isinfd128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_C90RES_BUILTIN (BUILT_IN_ISNAN, "isnan", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNANF, "isnanf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNANL, "isnanl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNAND32, "isnand32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNAND64, "isnand64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNAND128, "isnand128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_ISNORMAL, "isnormal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISGREATER, "isgreater", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISGREATEREQUAL, "isgreaterequal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISLESS, "isless", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISLESSEQUAL, "islessequal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISLESSGREATER, "islessgreater", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_GCC_BUILTIN (BUILT_IN_ISUNORDERED, "isunordered", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF) +DEF_LIB_BUILTIN (BUILT_IN_LABS, "labs", BT_FN_LONG_LONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN_LLABS, "llabs", BT_FN_LONGLONG_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_LONGJMP, "longjmp", BT_FN_VOID_PTR_INT, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_MALLOC, "malloc", BT_FN_PTR_SIZE, ATTR_MALLOC_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_NEXT_ARG, "next_arg", BT_FN_PTR_VAR, ATTR_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_PARITY, "parity", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_PARITYIMAX, "parityimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_PARITYL, "parityl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_PARITYLL, "parityll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_POPCOUNT, "popcount", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_POPCOUNTIMAX, "popcountimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_POPCOUNTL, "popcountl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_POPCOUNTLL, "popcountll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_PREFETCH, "prefetch", BT_FN_VOID_CONST_PTR_VAR, ATTR_NOVOPS_LEAF_LIST) +DEF_LIB_BUILTIN (BUILT_IN_REALLOC, "realloc", BT_FN_PTR_PTR_SIZE, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_RETURN, "return", BT_FN_VOID_PTR, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_RETURN_ADDRESS, "return_address", BT_FN_PTR_UINT, ATTR_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_SAVEREGS, "saveregs", BT_FN_PTR_VAR, ATTR_NULL) +DEF_GCC_BUILTIN (BUILT_IN_SETJMP, "setjmp", BT_FN_INT_PTR, ATTR_NULL) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRFMON, "strfmon", BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_STRFMON_NOTHROW_3_4) +DEF_LIB_BUILTIN (BUILT_IN_STRFTIME, "strftime", BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR, ATTR_FORMAT_STRFTIME_NOTHROW_3_0) +DEF_GCC_BUILTIN (BUILT_IN_TRAP, "trap", BT_FN_VOID, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UNREACHABLE, "unreachable", BT_FN_VOID, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_UNWIND_INIT, "unwind_init", BT_FN_VOID, ATTR_NULL) +DEF_GCC_BUILTIN (BUILT_IN_UPDATE_SETJMP_BUF, "update_setjmp_buf", BT_FN_VOID_PTR_INT, ATTR_NULL) +DEF_GCC_BUILTIN (BUILT_IN_VA_COPY, "va_copy", BT_FN_VOID_VALIST_REF_VALIST_ARG, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_VA_END, "va_end", BT_FN_VOID_VALIST_REF, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_VA_START, "va_start", BT_FN_VOID_VALIST_REF_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_VA_ARG_PACK, "va_arg_pack", BT_FN_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_GCC_BUILTIN (BUILT_IN_VA_ARG_PACK_LEN, "va_arg_pack_len", BT_FN_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN__EXIT, "_exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LEAF_LIST) +DEF_C99_BUILTIN (BUILT_IN__EXIT2, "_Exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LEAF_LIST) + +/* Implementing nested functions. */ +DEF_BUILTIN_STUB (BUILT_IN_INIT_TRAMPOLINE, "__builtin_init_trampoline") +DEF_BUILTIN_STUB (BUILT_IN_ADJUST_TRAMPOLINE, "__builtin_adjust_trampoline") +DEF_BUILTIN_STUB (BUILT_IN_NONLOCAL_GOTO, "__builtin_nonlocal_goto") + +/* Implementing __builtin_setjmp. */ +DEF_BUILTIN_STUB (BUILT_IN_SETJMP_SETUP, "__builtin_setjmp_setup") +DEF_BUILTIN_STUB (BUILT_IN_SETJMP_DISPATCHER, "__builtin_setjmp_dispatcher") +DEF_BUILTIN_STUB (BUILT_IN_SETJMP_RECEIVER, "__builtin_setjmp_receiver") + +/* Implementing variable sized local variables. */ +DEF_BUILTIN_STUB (BUILT_IN_STACK_SAVE, "__builtin_stack_save") +DEF_BUILTIN_STUB (BUILT_IN_STACK_RESTORE, "__builtin_stack_restore") + +/* Object size checking builtins. */ +DEF_GCC_BUILTIN (BUILT_IN_OBJECT_SIZE, "object_size", BT_FN_SIZE_CONST_PTR_INT, ATTR_PURE_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMCPY_CHK, "__memcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMMOVE_CHK, "__memmove_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMPCPY_CHK, "__mempcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMSET_CHK, "__memset_chk", BT_FN_PTR_PTR_INT_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STPCPY_CHK, "__stpcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCAT_CHK, "__strcat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCPY_CHK, "__strcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCAT_CHK, "__strncat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCPY_CHK, "__strncpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SNPRINTF_CHK, "__snprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_5_6) +DEF_EXT_LIB_BUILTIN (BUILT_IN_SPRINTF_CHK, "__sprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_4_5) +DEF_EXT_LIB_BUILTIN (BUILT_IN_VSNPRINTF_CHK, "__vsnprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_5_0) +DEF_EXT_LIB_BUILTIN (BUILT_IN_VSPRINTF_CHK, "__vsprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_4_0) +DEF_EXT_LIB_BUILTIN (BUILT_IN_FPRINTF_CHK, "__fprintf_chk", BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_3_4) +DEF_EXT_LIB_BUILTIN (BUILT_IN_PRINTF_CHK, "__printf_chk", BT_FN_INT_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3) +DEF_EXT_LIB_BUILTIN (BUILT_IN_VFPRINTF_CHK, "__vfprintf_chk", BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_3_0) +DEF_EXT_LIB_BUILTIN (BUILT_IN_VPRINTF_CHK, "__vprintf_chk", BT_FN_INT_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_2_0) + +/* Profiling hooks. */ +DEF_BUILTIN (BUILT_IN_PROFILE_FUNC_ENTER, "__cyg_profile_func_enter", BUILT_IN_NORMAL, BT_FN_VOID_PTR_PTR, BT_LAST, + false, false, false, ATTR_NULL, true, true) +DEF_BUILTIN (BUILT_IN_PROFILE_FUNC_EXIT, "__cyg_profile_func_exit", BUILT_IN_NORMAL, BT_FN_VOID_PTR_PTR, BT_LAST, + false, false, false, ATTR_NULL, true, true) + +/* TLS emulation. */ +DEF_BUILTIN (BUILT_IN_EMUTLS_GET_ADDRESS, targetm.emutls.get_address, + BUILT_IN_NORMAL, + BT_FN_PTR_PTR, BT_FN_PTR_PTR, + true, true, true, ATTR_CONST_NOTHROW_NONNULL_LEAF, false, + !targetm.have_tls) +DEF_BUILTIN (BUILT_IN_EMUTLS_REGISTER_COMMON, + targetm.emutls.register_common, BUILT_IN_NORMAL, + BT_FN_VOID_PTR_WORD_WORD_PTR, BT_FN_VOID_PTR_WORD_WORD_PTR, + true, true, true, ATTR_NOTHROW_LEAF_LIST, false, + !targetm.have_tls) + +/* Multiversioning builtin dispatch hook. */ +DEF_GCC_BUILTIN (BUILT_IN_DISPATCH, "dispatch", BT_FN_INT_PTR_FN_INT_PTR_PTR_VAR, ATTR_NULL) + +/* Exception support. */ +DEF_BUILTIN_STUB (BUILT_IN_UNWIND_RESUME, "__builtin_unwind_resume") +DEF_BUILTIN_STUB (BUILT_IN_CXA_END_CLEANUP, "__builtin_cxa_end_cleanup") +DEF_BUILTIN_STUB (BUILT_IN_EH_POINTER, "__builtin_eh_pointer") +DEF_BUILTIN_STUB (BUILT_IN_EH_FILTER, "__builtin_eh_filter") +DEF_BUILTIN_STUB (BUILT_IN_EH_COPY_VALUES, "__builtin_eh_copy_values") + +/* Synchronization Primitives. */ +#include "sync-builtins.def" + +/* OpenMP builtins. */ +#include "omp-builtins.def" diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/bversion.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/bversion.h new file mode 100644 index 0000000..2e0f9d7 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/bversion.h @@ -0,0 +1,4 @@ +#define BUILDING_GCC_MAJOR 4 +#define BUILDING_GCC_MINOR 6 +#define BUILDING_GCC_PATCHLEVEL 4.6.x-google +#define BUILDING_GCC_VERSION (BUILDING_GCC_MAJOR * 1000 + BUILDING_GCC_MINOR) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-common.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-common.def new file mode 100644 index 0000000..c7e01b6 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-common.def @@ -0,0 +1,54 @@ +/* This file contains the definitions and documentation for the + additional tree codes used in the GNU C compiler (see tree.def + for the standard codes). + Copyright (C) 1987, 1988, 1990, 1993, 1997, 1998, + 1999, 2000, 2001, 2004, 2005, 2007, 2009, 2010 + Free Software Foundation, Inc. + Written by Benjamin Chelf <chelf@codesourcery.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* Tree nodes used in the C frontend. These are also shared with the + C++ and Objective C frontends. */ + +/* A C_MAYBE_CONST_EXPR, currently only used for C and Objective C, + tracks information about constancy of an expression and VLA type + sizes or VM expressions from typeof that need to be evaluated + before the main expression. It is used during parsing and removed + in c_fully_fold. C_MAYBE_CONST_EXPR_PRE is the expression to + evaluate first, if not NULL; C_MAYBE_CONST_EXPR_EXPR is the main + expression. If C_MAYBE_CONST_EXPR_INT_OPERANDS is set then the + expression may be used in an unevaluated part of an integer + constant expression, but not in an evaluated part. If + C_MAYBE_CONST_EXPR_NON_CONST is set then the expression contains + something that cannot occur in an evaluated part of a constant + expression (or outside of sizeof in C90 mode); otherwise it does + not. */ +DEFTREECODE (C_MAYBE_CONST_EXPR, "c_maybe_const_expr", tcc_expression, 2) + +/* An EXCESS_PRECISION_EXPR, currently only used for C and Objective + C, represents an expression evaluated in greater range or precision + than its type. The type of the EXCESS_PRECISION_EXPR is the + semantic type while the operand represents what is actually being + evaluated. */ +DEFTREECODE (EXCESS_PRECISION_EXPR, "excess_precision_expr", tcc_expression, 1) + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-common.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-common.h new file mode 100644 index 0000000..0bddae1 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-common.h @@ -0,0 +1,1013 @@ +/* Definitions for c-common.c. + Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998, + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 + 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/>. */ + +#ifndef GCC_C_COMMON_H +#define GCC_C_COMMON_H + +#include "splay-tree.h" +#include "cpplib.h" +#include "ggc.h" + +/* In order for the format checking to accept the C frontend + diagnostic framework extensions, you must include this file before + diagnostic-core.h, not after. The C front end formats are a subset of those + for C++, so they are the appropriate set to use in common code; + cp-tree.h overrides this for C++. */ +#if defined(GCC_DIAGNOSTIC_CORE_H) +#error \ +In order for the format checking to accept the C front end diagnostic \ +framework extensions, you must include this file before diagnostic-core.h \ +never after. +#endif +#ifndef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_cdiag__ +#endif +#include "diagnostic-core.h" + +/* Usage of TREE_LANG_FLAG_?: + 0: TREE_NEGATED_INT (in INTEGER_CST). + IDENTIFIER_MARKED (used by search routines). + DECL_PRETTY_FUNCTION_P (in VAR_DECL) + C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C) + 1: C_DECLARED_LABEL_FLAG (in LABEL_DECL) + STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST) + C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C) + 2: unused + 3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST) + 4: unused +*/ + +/* Reserved identifiers. This is the union of all the keywords for C, + C++, and Objective-C. All the type modifiers have to be in one + block at the beginning, because they are used as mask bits. There + are 27 type modifiers; if we add many more we will have to redesign + the mask mechanism. */ + +enum rid +{ + /* Modifiers: */ + /* C, in empirical order of frequency. */ + RID_STATIC = 0, + RID_UNSIGNED, RID_LONG, RID_CONST, RID_EXTERN, + RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE, + RID_VOLATILE, RID_SIGNED, RID_AUTO, RID_RESTRICT, + + /* C extensions */ + RID_COMPLEX, RID_THREAD, RID_SAT, + + /* C++ */ + RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE, + + /* ObjC ("PQ" reserved words - they do not appear after a '@' and + are keywords only in specific contexts) */ + RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY, + + /* ObjC ("PATTR" reserved words - they do not appear after a '@' + and are keywords only as property attributes) */ + RID_GETTER, RID_SETTER, + RID_READONLY, RID_READWRITE, + RID_ASSIGN, RID_RETAIN, RID_COPY, + RID_NONATOMIC, + + /* C (reserved and imaginary types not implemented, so any use is a + syntax error) */ + RID_IMAGINARY, + + /* C */ + RID_INT, RID_CHAR, RID_FLOAT, RID_DOUBLE, RID_VOID, + RID_INT128, + RID_ENUM, RID_STRUCT, RID_UNION, RID_IF, RID_ELSE, + RID_WHILE, RID_DO, RID_FOR, RID_SWITCH, RID_CASE, + RID_DEFAULT, RID_BREAK, RID_CONTINUE, RID_RETURN, RID_GOTO, + RID_SIZEOF, + + /* C extensions */ + RID_ASM, RID_TYPEOF, RID_ALIGNOF, RID_ATTRIBUTE, RID_VA_ARG, + RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL, RID_CHOOSE_EXPR, + RID_TYPES_COMPATIBLE_P, + RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128, + RID_FRACT, RID_ACCUM, + + /* This means to warn that this is a C++ keyword, and then treat it + as a normal identifier. */ + RID_CXX_COMPAT_WARN, + + /* Too many ways of getting the name of a function as a string */ + RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME, + + /* C++ (some of these are keywords in Objective-C as well, but only + if they appear after a '@') */ + RID_BOOL, RID_WCHAR, RID_CLASS, + RID_PUBLIC, RID_PRIVATE, RID_PROTECTED, + RID_TEMPLATE, RID_NULL, RID_CATCH, + RID_DELETE, RID_FALSE, RID_NAMESPACE, + RID_NEW, RID_OFFSETOF, RID_OPERATOR, + RID_THIS, RID_THROW, RID_TRUE, + RID_TRY, RID_TYPENAME, RID_TYPEID, + RID_USING, RID_CHAR16, RID_CHAR32, + + /* casts */ + RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST, + + /* C++ extensions */ + RID_HAS_NOTHROW_ASSIGN, RID_HAS_NOTHROW_CONSTRUCTOR, + RID_HAS_NOTHROW_COPY, RID_HAS_TRIVIAL_ASSIGN, + RID_HAS_TRIVIAL_CONSTRUCTOR, RID_HAS_TRIVIAL_COPY, + RID_HAS_TRIVIAL_DESTRUCTOR, RID_HAS_VIRTUAL_DESTRUCTOR, + RID_IS_ABSTRACT, RID_IS_BASE_OF, + RID_IS_CONVERTIBLE_TO, RID_IS_CLASS, + RID_IS_EMPTY, RID_IS_ENUM, + RID_IS_POD, RID_IS_POLYMORPHIC, + RID_IS_STD_LAYOUT, RID_IS_TRIVIAL, + RID_IS_UNION, RID_IS_LITERAL_TYPE, + + /* C++0x */ + RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT, + + /* Objective-C ("AT" reserved words - they are only keywords when + they follow '@') */ + RID_AT_ENCODE, RID_AT_END, + RID_AT_CLASS, RID_AT_ALIAS, RID_AT_DEFS, + RID_AT_PRIVATE, RID_AT_PROTECTED, RID_AT_PUBLIC, RID_AT_PACKAGE, + RID_AT_PROTOCOL, RID_AT_SELECTOR, + RID_AT_THROW, RID_AT_TRY, RID_AT_CATCH, + RID_AT_FINALLY, RID_AT_SYNCHRONIZED, + RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY, + RID_AT_SYNTHESIZE, RID_AT_DYNAMIC, + RID_AT_INTERFACE, + RID_AT_IMPLEMENTATION, + + /* Named address support, mapping the keyword to a particular named address + number. Named address space 0 is reserved for the generic address. If + there are more than 254 named addresses, the addr_space_t type will need + to be grown from an unsigned char to unsigned short. */ + RID_ADDR_SPACE_0, /* generic address */ + RID_ADDR_SPACE_1, + RID_ADDR_SPACE_2, + RID_ADDR_SPACE_3, + RID_ADDR_SPACE_4, + RID_ADDR_SPACE_5, + RID_ADDR_SPACE_6, + RID_ADDR_SPACE_7, + RID_ADDR_SPACE_8, + RID_ADDR_SPACE_9, + RID_ADDR_SPACE_10, + RID_ADDR_SPACE_11, + RID_ADDR_SPACE_12, + RID_ADDR_SPACE_13, + RID_ADDR_SPACE_14, + RID_ADDR_SPACE_15, + + RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0, + RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15, + + RID_MAX, + + RID_FIRST_MODIFIER = RID_STATIC, + RID_LAST_MODIFIER = RID_ONEWAY, + + RID_FIRST_CXX0X = RID_CONSTEXPR, + RID_LAST_CXX0X = RID_STATIC_ASSERT, + RID_FIRST_AT = RID_AT_ENCODE, + RID_LAST_AT = RID_AT_IMPLEMENTATION, + RID_FIRST_PQ = RID_IN, + RID_LAST_PQ = RID_ONEWAY, + RID_FIRST_PATTR = RID_GETTER, + RID_LAST_PATTR = RID_NONATOMIC +}; + +#define OBJC_IS_AT_KEYWORD(rid) \ + ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \ + (unsigned int) (rid) <= (unsigned int) RID_LAST_AT) + +#define OBJC_IS_PQ_KEYWORD(rid) \ + ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \ + (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ) + +#define OBJC_IS_PATTR_KEYWORD(rid) \ + ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \ + (unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR) + +/* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as + 'class') which are shared in a subtle way between Objective-C and + C++. When the lexer is lexing in Objective-C/Objective-C++, if it + finds '@' followed by one of these identifiers (eg, '@class'), it + recognizes the whole as an Objective-C keyword. If the identifier + is found elsewhere, it follows the rules of the C/C++ language. + */ +#define OBJC_IS_CXX_KEYWORD(rid) \ + (rid == RID_CLASS \ + || rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE \ + || rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH) + +/* The elements of `ridpointers' are identifier nodes for the reserved + type names and storage classes. It is indexed by a RID_... value. */ +extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers; + +/* Standard named or nameless data types of the C compiler. */ + +enum c_tree_index +{ + CTI_CHAR16_TYPE, + CTI_CHAR32_TYPE, + CTI_WCHAR_TYPE, + CTI_UNDERLYING_WCHAR_TYPE, + CTI_WINT_TYPE, + CTI_SIGNED_SIZE_TYPE, /* For format checking only. */ + CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only. */ + CTI_INTMAX_TYPE, + CTI_UINTMAX_TYPE, + CTI_WIDEST_INT_LIT_TYPE, + CTI_WIDEST_UINT_LIT_TYPE, + + /* Types for <stdint.h>, that may not be defined on all + targets. */ + CTI_SIG_ATOMIC_TYPE, + CTI_INT8_TYPE, + CTI_INT16_TYPE, + CTI_INT32_TYPE, + CTI_INT64_TYPE, + CTI_UINT8_TYPE, + CTI_UINT16_TYPE, + CTI_UINT32_TYPE, + CTI_UINT64_TYPE, + CTI_INT_LEAST8_TYPE, + CTI_INT_LEAST16_TYPE, + CTI_INT_LEAST32_TYPE, + CTI_INT_LEAST64_TYPE, + CTI_UINT_LEAST8_TYPE, + CTI_UINT_LEAST16_TYPE, + CTI_UINT_LEAST32_TYPE, + CTI_UINT_LEAST64_TYPE, + CTI_INT_FAST8_TYPE, + CTI_INT_FAST16_TYPE, + CTI_INT_FAST32_TYPE, + CTI_INT_FAST64_TYPE, + CTI_UINT_FAST8_TYPE, + CTI_UINT_FAST16_TYPE, + CTI_UINT_FAST32_TYPE, + CTI_UINT_FAST64_TYPE, + CTI_INTPTR_TYPE, + CTI_UINTPTR_TYPE, + + CTI_CHAR_ARRAY_TYPE, + CTI_CHAR16_ARRAY_TYPE, + CTI_CHAR32_ARRAY_TYPE, + CTI_WCHAR_ARRAY_TYPE, + CTI_INT_ARRAY_TYPE, + CTI_STRING_TYPE, + CTI_CONST_STRING_TYPE, + + /* Type for boolean expressions (bool in C++, int in C). */ + CTI_TRUTHVALUE_TYPE, + CTI_TRUTHVALUE_TRUE, + CTI_TRUTHVALUE_FALSE, + + CTI_DEFAULT_FUNCTION_TYPE, + + /* These are not types, but we have to look them up all the time. */ + CTI_FUNCTION_NAME_DECL, + CTI_PRETTY_FUNCTION_NAME_DECL, + CTI_C99_FUNCTION_NAME_DECL, + CTI_SAVED_FUNCTION_NAME_DECLS, + + CTI_VOID_ZERO, + + CTI_NULL, + + CTI_MAX +}; + +#define C_CPP_HASHNODE(id) \ + (&(((struct c_common_identifier *) (id))->node)) +#define C_RID_CODE(id) \ + ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code)) +#define C_SET_RID_CODE(id, code) \ + (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code) + +/* Identifier part common to the C front ends. Inherits from + tree_identifier, despite appearances. */ +struct GTY(()) c_common_identifier { + struct tree_common common; + struct cpp_hashnode node; +}; + +/* An entry in the reserved keyword table. */ + +struct c_common_resword +{ + const char *const word; + ENUM_BITFIELD(rid) const rid : 16; + const unsigned int disable : 16; +}; + +/* Disable mask. Keywords are disabled if (reswords[i].disable & + mask) is _true_. Thus for keywords which are present in all + languages the disable field is zero. */ + +#define D_CONLY 0x001 /* C only (not in C++). */ +#define D_CXXONLY 0x002 /* C++ only (not in C). */ +#define D_C99 0x004 /* In C, C99 only. */ +#define D_CXX0X 0x008 /* In C++, C++0X only. */ +#define D_EXT 0x010 /* GCC extension. */ +#define D_EXT89 0x020 /* GCC extension incorporated in C99. */ +#define D_ASM 0x040 /* Disabled by -fno-asm. */ +#define D_OBJC 0x080 /* In Objective C and neither C nor C++. */ +#define D_CXX_OBJC 0x100 /* In Objective C, and C++, but not C. */ +#define D_CXXWARN 0x200 /* In C warn with -Wcxx-compat. */ + +/* The reserved keyword table. */ +extern const struct c_common_resword c_common_reswords[]; + +/* The number of items in the reserved keyword table. */ +extern const unsigned int num_c_common_reswords; + +#define char16_type_node c_global_trees[CTI_CHAR16_TYPE] +#define char32_type_node c_global_trees[CTI_CHAR32_TYPE] +#define wchar_type_node c_global_trees[CTI_WCHAR_TYPE] +#define underlying_wchar_type_node c_global_trees[CTI_UNDERLYING_WCHAR_TYPE] +#define wint_type_node c_global_trees[CTI_WINT_TYPE] +#define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE] +#define unsigned_ptrdiff_type_node c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE] +#define intmax_type_node c_global_trees[CTI_INTMAX_TYPE] +#define uintmax_type_node c_global_trees[CTI_UINTMAX_TYPE] +#define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE] +#define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE] + +#define sig_atomic_type_node c_global_trees[CTI_SIG_ATOMIC_TYPE] +#define int8_type_node c_global_trees[CTI_INT8_TYPE] +#define int16_type_node c_global_trees[CTI_INT16_TYPE] +#define int32_type_node c_global_trees[CTI_INT32_TYPE] +#define int64_type_node c_global_trees[CTI_INT64_TYPE] +#define uint8_type_node c_global_trees[CTI_UINT8_TYPE] +#define uint16_type_node c_global_trees[CTI_UINT16_TYPE] +#define c_uint32_type_node c_global_trees[CTI_UINT32_TYPE] +#define c_uint64_type_node c_global_trees[CTI_UINT64_TYPE] +#define int_least8_type_node c_global_trees[CTI_INT_LEAST8_TYPE] +#define int_least16_type_node c_global_trees[CTI_INT_LEAST16_TYPE] +#define int_least32_type_node c_global_trees[CTI_INT_LEAST32_TYPE] +#define int_least64_type_node c_global_trees[CTI_INT_LEAST64_TYPE] +#define uint_least8_type_node c_global_trees[CTI_UINT_LEAST8_TYPE] +#define uint_least16_type_node c_global_trees[CTI_UINT_LEAST16_TYPE] +#define uint_least32_type_node c_global_trees[CTI_UINT_LEAST32_TYPE] +#define uint_least64_type_node c_global_trees[CTI_UINT_LEAST64_TYPE] +#define int_fast8_type_node c_global_trees[CTI_INT_FAST8_TYPE] +#define int_fast16_type_node c_global_trees[CTI_INT_FAST16_TYPE] +#define int_fast32_type_node c_global_trees[CTI_INT_FAST32_TYPE] +#define int_fast64_type_node c_global_trees[CTI_INT_FAST64_TYPE] +#define uint_fast8_type_node c_global_trees[CTI_UINT_FAST8_TYPE] +#define uint_fast16_type_node c_global_trees[CTI_UINT_FAST16_TYPE] +#define uint_fast32_type_node c_global_trees[CTI_UINT_FAST32_TYPE] +#define uint_fast64_type_node c_global_trees[CTI_UINT_FAST64_TYPE] +#define intptr_type_node c_global_trees[CTI_INTPTR_TYPE] +#define uintptr_type_node c_global_trees[CTI_UINTPTR_TYPE] + +#define truthvalue_type_node c_global_trees[CTI_TRUTHVALUE_TYPE] +#define truthvalue_true_node c_global_trees[CTI_TRUTHVALUE_TRUE] +#define truthvalue_false_node c_global_trees[CTI_TRUTHVALUE_FALSE] + +#define char_array_type_node c_global_trees[CTI_CHAR_ARRAY_TYPE] +#define char16_array_type_node c_global_trees[CTI_CHAR16_ARRAY_TYPE] +#define char32_array_type_node c_global_trees[CTI_CHAR32_ARRAY_TYPE] +#define wchar_array_type_node c_global_trees[CTI_WCHAR_ARRAY_TYPE] +#define int_array_type_node c_global_trees[CTI_INT_ARRAY_TYPE] +#define string_type_node c_global_trees[CTI_STRING_TYPE] +#define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE] + +#define default_function_type c_global_trees[CTI_DEFAULT_FUNCTION_TYPE] + +#define function_name_decl_node c_global_trees[CTI_FUNCTION_NAME_DECL] +#define pretty_function_name_decl_node c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL] +#define c99_function_name_decl_node c_global_trees[CTI_C99_FUNCTION_NAME_DECL] +#define saved_function_name_decls c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS] + +/* A node for `((void) 0)'. */ +#define void_zero_node c_global_trees[CTI_VOID_ZERO] + +/* The node for C++ `__null'. */ +#define null_node c_global_trees[CTI_NULL] + +extern GTY(()) tree c_global_trees[CTI_MAX]; + +/* In a RECORD_TYPE, a sorted array of the fields of the type, not a + tree for size reasons. */ +struct GTY((variable_size)) sorted_fields_type { + int len; + tree GTY((length ("%h.len"))) elts[1]; +}; + +/* Mark which labels are explicitly declared. + These may be shadowed, and may be referenced from nested functions. */ +#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label) + +typedef enum c_language_kind +{ + clk_c = 0, /* C90, C94 or C99 */ + clk_objc = 1, /* clk_c with ObjC features. */ + clk_cxx = 2, /* ANSI/ISO C++ */ + clk_objcxx = 3 /* clk_cxx with ObjC features. */ +} +c_language_kind; + +/* To test for a specific language use c_language, defined by each + front end. For "ObjC features" or "not C++" use the macros. */ +extern c_language_kind c_language; + +#define c_dialect_cxx() ((c_language & clk_cxx) != 0) +#define c_dialect_objc() ((c_language & clk_objc) != 0) + +/* The various name of operator that appears in error messages. */ +typedef enum ref_operator { + /* NULL */ + RO_NULL, + /* array indexing */ + RO_ARRAY_INDEXING, + /* unary * */ + RO_UNARY_STAR, + /* -> */ + RO_ARROW, + /* implicit conversion */ + RO_IMPLICIT_CONVERSION +} ref_operator; + +/* Information about a statement tree. */ + +struct GTY(()) stmt_tree_s { + /* The current statement list being collected. */ + tree x_cur_stmt_list; + + /* In C++, Nonzero if we should treat statements as full + expressions. In particular, this variable is no-zero if at the + end of a statement we should destroy any temporaries created + during that statement. Similarly, if, at the end of a block, we + should destroy any local variables in this block. Normally, this + variable is nonzero, since those are the normal semantics of + C++. + + However, in order to represent aggregate initialization code as + tree structure, we use statement-expressions. The statements + within the statement expression should not result in cleanups + being run until the entire enclosing statement is complete. + + This flag has no effect in C. */ + int stmts_are_full_exprs_p; +}; + +typedef struct stmt_tree_s *stmt_tree; + +/* Global state pertinent to the current function. Some C dialects + extend this structure with additional fields. */ + +struct GTY(()) c_language_function { + /* While we are parsing the function, this contains information + about the statement-tree that we are building. */ + struct stmt_tree_s x_stmt_tree; +}; + +/* When building a statement-tree, this is the current statement list + being collected. It's TREE_CHAIN is a back-pointer to the previous + statement list. */ + +#define cur_stmt_list (current_stmt_tree ()->x_cur_stmt_list) + +/* Language-specific hooks. */ + +/* If non-NULL, this function is called after a precompile header file + is loaded. */ +extern void (*lang_post_pch_load) (void); + +extern void push_file_scope (void); +extern void pop_file_scope (void); +extern stmt_tree current_stmt_tree (void); +extern tree push_stmt_list (void); +extern tree pop_stmt_list (tree); +extern tree add_stmt (tree); +extern void push_cleanup (tree, tree, bool); +extern tree pushdecl_top_level (tree); +extern tree pushdecl (tree); +extern tree build_modify_expr (location_t, tree, tree, enum tree_code, + location_t, tree, tree); +extern tree build_indirect_ref (location_t, tree, ref_operator); + +extern int c_expand_decl (tree); + +extern int field_decl_cmp (const void *, const void *); +extern void resort_sorted_fields (void *, void *, gt_pointer_operator, + void *); +extern bool has_c_linkage (const_tree decl); + +/* Switches common to the C front ends. */ + +/* Nonzero means don't output line number information. */ + +extern char flag_no_line_commands; + +/* Nonzero causes -E output not to be done, but directives such as + #define that have side effects are still obeyed. */ + +extern char flag_no_output; + +/* Nonzero means dump macros in some fashion; contains the 'D', 'M', + 'N' or 'U' of the command line switch. */ + +extern char flag_dump_macros; + +/* Nonzero means pass #include lines through to the output. */ + +extern char flag_dump_includes; + +/* Nonzero means process PCH files while preprocessing. */ + +extern bool flag_pch_preprocess; + +/* The file name to which we should write a precompiled header, or + NULL if no header will be written in this compile. */ + +extern const char *pch_file; + +/* Nonzero if an ISO standard was selected. It rejects macros in the + user's namespace. */ + +extern int flag_iso; + +/* Warn about #pragma directives that are not recognized. */ + +extern int warn_unknown_pragmas; /* Tri state variable. */ + +/* Warn about format/argument anomalies in calls to formatted I/O functions + (*printf, *scanf, strftime, strfmon, etc.). */ + +extern int warn_format; + + +/* C/ObjC language option variables. */ + + +/* Nonzero means allow type mismatches in conditional expressions; + just make their values `void'. */ + +extern int flag_cond_mismatch; + +/* Nonzero means enable C89 Amendment 1 features. */ + +extern int flag_isoc94; + +/* Nonzero means use the ISO C99 (or C1X) dialect of C. */ + +extern int flag_isoc99; + +/* Nonzero means use the ISO C1X dialect of C. */ + +extern int flag_isoc1x; + +/* Nonzero means that we have builtin functions, and main is an int. */ + +extern int flag_hosted; + +/* ObjC language option variables. */ + + +/* Tells the compiler that this is a special run. Do not perform any + compiling, instead we are to test some platform dependent features + and output a C header file with appropriate definitions. */ + +extern int print_struct_values; + +/* Tells the compiler what is the constant string class for ObjC. */ + +extern const char *constant_string_class_name; + + +/* C++ language option variables. */ + + +/* Nonzero means generate separate instantiation control files and + juggle them at link time. */ + +extern int flag_use_repository; + +/* The supported C++ dialects. */ + +enum cxx_dialect { + /* C++98 with TC1 */ + cxx98, + cxx03 = cxx98, + /* C++11 */ + cxx0x, + cxx11 = cxx0x +}; + +/* The C++ dialect being used. C++98 is the default. */ +extern enum cxx_dialect cxx_dialect; + +/* Maximum template instantiation depth. This limit is rather + arbitrary, but it exists to limit the time it takes to notice + infinite template instantiations. */ + +extern int max_tinst_depth; + +/* Nonzero means that we should not issue warnings about problems that + occur when the code is executed, because the code being processed + is not expected to be executed. This is set during parsing. This + is used for cases like sizeof() and "0 ? a : b". This is a count, + not a bool, because unexecuted expressions can nest. */ + +extern int c_inhibit_evaluation_warnings; + +/* Whether lexing has been completed, so subsequent preprocessor + errors should use the compiler's input_location. */ + +extern bool done_lexing; + +/* C types are partitioned into three subsets: object, function, and + incomplete types. */ +#define C_TYPE_OBJECT_P(type) \ + (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type)) + +#define C_TYPE_INCOMPLETE_P(type) \ + (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0) + +#define C_TYPE_FUNCTION_P(type) \ + (TREE_CODE (type) == FUNCTION_TYPE) + +/* For convenience we define a single macro to identify the class of + object or incomplete types. */ +#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \ + (!C_TYPE_FUNCTION_P (type)) + +struct visibility_flags +{ + unsigned inpragma : 1; /* True when in #pragma GCC visibility. */ + unsigned inlines_hidden : 1; /* True when -finlineshidden in effect. */ +}; + +/* Global visibility options. */ +extern struct visibility_flags visibility_options; + +/* Attribute table common to the C front ends. */ +extern const struct attribute_spec c_common_attribute_table[]; +extern const struct attribute_spec c_common_format_attribute_table[]; + +/* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc. + ID is the identifier to use, NAME is the string. + TYPE_DEP indicates whether it depends on type of the function or not + (i.e. __PRETTY_FUNCTION__). */ + +extern tree (*make_fname_decl) (location_t, tree, int); + +/* In c-decl.c and cp/tree.c. FIXME. */ +extern void c_register_addr_space (const char *str, addr_space_t as); + +/* In c-common.c. */ +extern bool in_late_binary_op; +extern const char *c_addr_space_name (addr_space_t as); +extern tree identifier_global_value (tree); +extern void record_builtin_type (enum rid, const char *, tree); +extern tree build_void_list_node (void); +extern void start_fname_decls (void); +extern void finish_fname_decls (void); +extern const char *fname_as_string (int); +extern tree fname_decl (location_t, unsigned, tree); + +extern void check_function_arguments (tree, int, tree *, tree); +extern void check_function_arguments_recurse (void (*) + (void *, tree, + unsigned HOST_WIDE_INT), + void *, tree, + unsigned HOST_WIDE_INT); +extern bool check_builtin_function_arguments (tree, int, tree *); +extern void check_function_format (tree, int, tree *); +extern void set_Wformat (int); +extern tree handle_format_attribute (tree *, tree, tree, int, bool *); +extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *); +extern bool attribute_takes_identifier_p (const_tree); +extern bool c_common_handle_option (size_t, const char *, int, int, location_t, + const struct cl_option_handlers *); +extern tree c_common_type_for_mode (enum machine_mode, int); +extern tree c_common_type_for_size (unsigned int, int); +extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int, + int, int); +extern tree c_common_unsigned_type (tree); +extern tree c_common_signed_type (tree); +extern tree c_common_signed_or_unsigned_type (int, tree); +extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int); +extern bool decl_with_nonnull_addr_p (const_tree); +extern tree c_fully_fold (tree, bool, bool *); +extern tree decl_constant_value_for_optimization (tree); +extern tree c_wrap_maybe_const (tree, bool); +extern tree c_save_expr (tree); +extern tree c_common_truthvalue_conversion (location_t, tree); +extern void c_apply_type_quals_to_decl (int, tree); +extern tree c_sizeof_or_alignof_type (location_t, tree, bool, int); +extern tree c_alignof_expr (location_t, tree); +/* Print an error message for invalid operands to arith operation CODE. + NOP_EXPR is used as a special case (see truthvalue_conversion). */ +extern void binary_op_error (location_t, enum tree_code, tree, tree); +extern tree fix_string_type (tree); +extern void constant_expression_warning (tree); +extern void constant_expression_error (tree); +extern bool strict_aliasing_warning (tree, tree, tree); +extern void warnings_for_convert_and_check (tree, tree, tree); +extern tree convert_and_check (tree, tree); +extern void overflow_warning (location_t, tree); +extern void warn_logical_operator (location_t, enum tree_code, tree, + enum tree_code, tree, enum tree_code, tree); +extern void check_main_parameter_types (tree decl); +extern bool c_determine_visibility (tree); +extern bool same_scalar_type_ignoring_signedness (tree, tree); +extern void mark_valid_location_for_stdc_pragma (bool); +extern bool valid_location_for_stdc_pragma_p (void); +extern void set_float_const_decimal64 (void); +extern void clear_float_const_decimal64 (void); +extern bool float_const_decimal64_p (void); + +extern bool keyword_begins_type_specifier (enum rid); +extern bool keyword_is_storage_class_specifier (enum rid); +extern bool keyword_is_type_qualifier (enum rid); +extern bool keyword_is_decl_specifier (enum rid); + +#define c_sizeof(LOC, T) c_sizeof_or_alignof_type (LOC, T, true, 1) +#define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, 1) + +/* Subroutine of build_binary_op, used for certain operations. */ +extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise); + +/* Subroutine of build_binary_op, used for comparison operations. + See if the operands have both been converted from subword integer types + and, if so, perhaps change them both back to their original type. */ +extern tree shorten_compare (tree *, tree *, tree *, enum tree_code *); + +extern tree pointer_int_sum (location_t, enum tree_code, tree, tree); + +/* Add qualifiers to a type, in the fashion for C. */ +extern tree c_build_qualified_type (tree, int); + +/* Build tree nodes and builtin functions common to both C and C++ language + frontends. */ +extern void c_common_nodes_and_builtins (void); + +extern void disable_builtin_function (const char *); + +extern void set_compound_literal_name (tree decl); + +extern tree build_va_arg (location_t, tree, tree); + +extern const unsigned int c_family_lang_mask; +extern unsigned int c_common_option_lang_mask (void); +extern void c_common_initialize_diagnostics (diagnostic_context *); +extern bool c_common_complain_wrong_lang_p (const struct cl_option *); +extern void c_common_init_options_struct (struct gcc_options *); +extern void c_common_init_options (unsigned int, struct cl_decoded_option *); +extern bool c_common_post_options (const char **); +extern bool c_common_init (void); +extern void c_common_finish (void); +extern void c_common_parse_file (void); +extern alias_set_type c_common_get_alias_set (tree); +extern void c_register_builtin_type (tree, const char*); +extern bool c_promoting_integer_type_p (const_tree); +extern int self_promoting_args_p (const_tree); +extern tree strip_pointer_operator (tree); +extern tree strip_pointer_or_array_types (tree); +extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT); + +/* This is the basic parsing function. */ +extern void c_parse_file (void); + +extern void warn_for_omitted_condop (location_t, tree); + +/* These macros provide convenient access to the various _STMT nodes. */ + +/* Nonzero if a given STATEMENT_LIST represents the outermost binding + if a statement expression. */ +#define STATEMENT_LIST_STMT_EXPR(NODE) \ + TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE)) + +/* Nonzero if a label has been added to the statement list. */ +#define STATEMENT_LIST_HAS_LABEL(NODE) \ + TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE)) + +/* C_MAYBE_CONST_EXPR accessors. */ +#define C_MAYBE_CONST_EXPR_PRE(NODE) \ + TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0) +#define C_MAYBE_CONST_EXPR_EXPR(NODE) \ + TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1) +#define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE) \ + TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE)) +#define C_MAYBE_CONST_EXPR_NON_CONST(NODE) \ + TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE)) +#define EXPR_INT_CONST_OPERANDS(EXPR) \ + (INTEGRAL_TYPE_P (TREE_TYPE (EXPR)) \ + && (TREE_CODE (EXPR) == INTEGER_CST \ + || (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR \ + && C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR)))) + +/* In a FIELD_DECL, nonzero if the decl was originally a bitfield. */ +#define DECL_C_BIT_FIELD(NODE) \ + (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1) +#define SET_DECL_C_BIT_FIELD(NODE) \ + (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1) +#define CLEAR_DECL_C_BIT_FIELD(NODE) \ + (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0) + +extern tree do_case (location_t, tree, tree); +extern tree build_stmt (location_t, enum tree_code, ...); +extern tree build_case_label (location_t, tree, tree, tree); +extern tree build_real_imag_expr (location_t, enum tree_code, tree); + +/* These functions must be defined by each front-end which implements + a variant of the C language. They are used in c-common.c. */ + +extern tree build_unary_op (location_t, enum tree_code, tree, int); +extern tree build_binary_op (location_t, enum tree_code, tree, tree, int); +extern tree perform_integral_promotions (tree); + +/* These functions must be defined by each front-end which implements + a variant of the C language. They are used by port files. */ + +extern tree default_conversion (tree); + +/* Given two integer or real types, return the type for their sum. + Given two compatible ANSI C types, returns the merged type. */ + +extern tree common_type (tree, tree); + +extern tree decl_constant_value (tree); + +/* Handle increment and decrement of boolean types. */ +extern tree boolean_increment (enum tree_code, tree); + +extern int case_compare (splay_tree_key, splay_tree_key); + +extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree, tree); + +extern void c_do_switch_warnings (splay_tree, location_t, tree, tree); + +extern tree build_function_call (location_t, tree, tree); + +extern tree build_function_call_vec (location_t, tree, + VEC(tree,gc) *, VEC(tree,gc) *); + +extern tree resolve_overloaded_builtin (location_t, tree, VEC(tree,gc) *); + +extern tree finish_label_address_expr (tree, location_t); + +/* Same function prototype, but the C and C++ front ends have + different implementations. Used in c-common.c. */ +extern tree lookup_label (tree); +extern tree lookup_name (tree); +extern bool lvalue_p (const_tree); + +extern bool vector_targets_convertible_p (const_tree t1, const_tree t2); +extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note); + +extern rtx c_expand_expr (tree, rtx, enum machine_mode, int, rtx *); + +extern void init_c_lex (void); + +extern void c_cpp_builtins (cpp_reader *); +extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree); +extern bool c_cpp_error (cpp_reader *, int, int, location_t, unsigned int, + const char *, va_list *) + ATTRIBUTE_GCC_DIAG(6,0); + +extern bool parse_optimize_options (tree, bool); + +/* Positive if an implicit `extern "C"' scope has just been entered; + negative if such a scope has just been exited. */ +extern GTY(()) int pending_lang_change; + +/* Information recorded about each file examined during compilation. */ + +struct c_fileinfo +{ + int time; /* Time spent in the file. */ + + /* Flags used only by C++. + INTERFACE_ONLY nonzero means that we are in an "interface" section + of the compiler. INTERFACE_UNKNOWN nonzero means we cannot trust + the value of INTERFACE_ONLY. If INTERFACE_UNKNOWN is zero and + INTERFACE_ONLY is zero, it means that we are responsible for + exporting definitions that others might need. */ + short interface_only; + short interface_unknown; +}; + +struct c_fileinfo *get_fileinfo (const char *); +extern void dump_time_statistics (void); + +extern bool c_dump_tree (void *, tree); + +extern void verify_sequence_points (tree); + +extern tree fold_offsetof_1 (tree); +extern tree fold_offsetof (tree); + +/* Places where an lvalue, or modifiable lvalue, may be required. + Used to select diagnostic messages in lvalue_error and + readonly_error. */ +enum lvalue_use { + lv_assign, + lv_increment, + lv_decrement, + lv_addressof, + lv_asm +}; + +extern void readonly_error (tree, enum lvalue_use); +extern void lvalue_error (location_t, enum lvalue_use); +extern void invalid_indirection_error (location_t, tree, ref_operator); + +extern int complete_array_type (tree *, tree, bool); + +extern tree builtin_type_for_size (int, bool); + +extern void c_common_mark_addressable_vec (tree); + +extern void warn_array_subscript_with_type_char (tree); +extern void warn_about_parentheses (enum tree_code, + enum tree_code, tree, + enum tree_code, tree); +extern void warn_for_unused_label (tree label); +extern void warn_for_div_by_zero (location_t, tree divisor); +extern void warn_for_sign_compare (location_t, + tree orig_op0, tree orig_op1, + tree op0, tree op1, + tree result_type, + enum tree_code resultcode); +extern void do_warn_double_promotion (tree, tree, tree, const char *, + location_t); +extern void set_underlying_type (tree x); +extern VEC(tree,gc) *make_tree_vector (void); +extern void release_tree_vector (VEC(tree,gc) *); +extern VEC(tree,gc) *make_tree_vector_single (tree); +extern VEC(tree,gc) *make_tree_vector_copy (const VEC(tree,gc) *); +extern void check_for_self_assign (location_t, tree, tree); + +/* In c-gimplify.c */ +extern void c_genericize (tree); +extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *); +extern tree c_build_bind_expr (location_t, tree, tree); + +/* In c-pch.c */ +extern void pch_init (void); +extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd); +extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd, + const char *orig); +extern void c_common_write_pch (void); +extern void c_common_no_more_pch (void); +extern void c_common_pch_pragma (cpp_reader *pfile, const char *); +extern void c_common_print_pch_checksum (FILE *f); + +/* In *-checksum.c */ +extern const unsigned char executable_checksum[16]; + +/* In c-cppbuiltin.c */ +extern void builtin_define_std (const char *macro); +extern void builtin_define_with_value (const char *, const char *, int); +extern void c_stddef_cpp_builtins (void); +extern void fe_file_change (const struct line_map *); +extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char); + +/* In c-ppoutput.c */ +extern void init_pp_output (FILE *); +extern void preprocess_file (cpp_reader *); +extern void pp_file_change (const struct line_map *); +extern void pp_dir_change (cpp_reader *, const char *); +extern bool check_missing_format_attribute (tree, tree); + +/* In c-omp.c */ +extern tree c_finish_omp_master (location_t, tree); +extern tree c_finish_omp_critical (location_t, tree, tree); +extern tree c_finish_omp_ordered (location_t, tree); +extern void c_finish_omp_barrier (location_t); +extern tree c_finish_omp_atomic (location_t, enum tree_code, tree, tree); +extern void c_finish_omp_flush (location_t); +extern void c_finish_omp_taskwait (location_t); +extern tree c_finish_omp_for (location_t, tree, tree, tree, tree, tree, tree); +extern void c_split_parallel_clauses (location_t, tree, tree *, tree *); +extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree); + +/* Not in c-omp.c; provided by the front end. */ +extern bool c_omp_sharing_predetermined (tree); +extern tree c_omp_remap_decl (tree, bool); +extern void record_types_used_by_current_var_decl (tree); + +#endif /* ! GCC_C_COMMON_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-objc.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-objc.h new file mode 100644 index 0000000..e67eede --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-objc.h @@ -0,0 +1,116 @@ +/* Definitions of Objective-C front-end entry points used for C and C++. + Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998, + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_C_COMMON_OBJC_H +#define GCC_C_COMMON_OBJC_H + +/* ObjC ivar visibility types. */ +typedef enum objc_ivar_visibility_kind { + OBJC_IVAR_VIS_PROTECTED = 0, + OBJC_IVAR_VIS_PUBLIC = 1, + OBJC_IVAR_VIS_PRIVATE = 2, + OBJC_IVAR_VIS_PACKAGE = 3 +} objc_ivar_visibility_kind; + +/* Objective-C / Objective-C++ entry points. */ + +/* The following ObjC/ObjC++ functions are called by the C and/or C++ + front-ends; they all must have corresponding stubs in stub-objc.c. */ +extern void objc_write_global_declarations (void); +extern tree objc_is_class_name (tree); +extern tree objc_is_object_ptr (tree); +extern void objc_check_decl (tree); +extern void objc_check_global_decl (tree); +extern tree objc_common_type (tree, tree); +extern bool objc_compare_types (tree, tree, int, tree); +extern bool objc_have_common_type (tree, tree, int, tree); +extern bool objc_diagnose_private_ivar (tree); +extern void objc_volatilize_decl (tree); +extern tree objc_rewrite_function_call (tree, tree); +extern tree objc_message_selector (void); +extern tree objc_lookup_ivar (tree, tree); +extern void objc_clear_super_receiver (void); +extern int objc_is_public (tree, tree); +extern tree objc_is_id (tree); +extern void objc_declare_alias (tree, tree); +extern void objc_declare_class (tree); +extern void objc_declare_protocols (tree, tree); +extern tree objc_build_message_expr (tree); +extern tree objc_finish_message_expr (tree, tree, tree, tree*); +extern tree objc_build_selector_expr (location_t, tree); +extern tree objc_build_protocol_expr (tree); +extern tree objc_build_encode_expr (tree); +extern tree objc_build_string_object (tree); +extern tree objc_get_protocol_qualified_type (tree, tree); +extern tree objc_get_class_reference (tree); +extern tree objc_get_class_ivars (tree); +extern tree objc_get_interface_ivars (tree); +extern void objc_start_class_interface (tree, tree, tree, tree); +extern void objc_start_category_interface (tree, tree, tree, tree); +extern void objc_start_protocol (tree, tree, tree); +extern void objc_continue_interface (void); +extern void objc_finish_interface (void); +extern void objc_start_class_implementation (tree, tree); +extern void objc_start_category_implementation (tree, tree); +extern void objc_continue_implementation (void); +extern void objc_finish_implementation (void); +extern void objc_set_visibility (objc_ivar_visibility_kind); +extern tree objc_build_method_signature (bool, tree, tree, tree, bool); +extern void objc_add_method_declaration (bool, tree, tree); +extern bool objc_start_method_definition (bool, tree, tree); +extern void objc_finish_method_definition (tree); +extern void objc_add_instance_variable (tree); +extern tree objc_build_keyword_decl (tree, tree, tree, tree); +extern tree objc_build_throw_stmt (location_t, tree); +extern void objc_begin_try_stmt (location_t, tree); +extern tree objc_finish_try_stmt (void); +extern void objc_begin_catch_clause (tree); +extern void objc_finish_catch_clause (void); +extern void objc_build_finally_clause (location_t, tree); +extern tree objc_build_synchronized (location_t, tree, tree); +extern int objc_static_init_needed_p (void); +extern tree objc_generate_static_init_call (tree); +extern tree objc_generate_write_barrier (tree, enum tree_code, tree); +extern void objc_set_method_opt (bool); +extern void objc_finish_foreach_loop (location_t, tree, tree, tree, tree, tree); +extern bool objc_method_decl (enum tree_code); +extern void objc_add_property_declaration (location_t, tree, bool, bool, bool, + bool, bool, bool, tree, tree); +extern tree objc_maybe_build_component_ref (tree, tree); +extern tree objc_build_class_component_ref (tree, tree); +extern tree objc_maybe_build_modify_expr (tree, tree); +extern tree objc_build_incr_expr_for_property_ref (location_t, enum tree_code, + tree, tree); +extern void objc_add_synthesize_declaration (location_t, tree); +extern void objc_add_dynamic_declaration (location_t, tree); +extern const char * objc_maybe_printable_name (tree, int); +extern bool objc_is_property_ref (tree); +extern bool objc_string_ref_type_p (tree); +extern void objc_check_format_arg (tree, tree); +extern void objc_finish_function (void); +extern void objc_maybe_warn_exceptions (location_t); + +/* The following are provided by the C and C++ front-ends, and called by + ObjC/ObjC++. */ +extern void *objc_get_current_scope (void); +extern void objc_mark_locals_volatile (void *); + +#endif /* ! GCC_C_COMMON_OBJC_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-pragma.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-pragma.h new file mode 100644 index 0000000..cec9cd1 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-pragma.h @@ -0,0 +1,116 @@ +/* Pragma related interfaces. + Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, + 2007, 2008, 2009, 2010 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/>. */ + +#ifndef GCC_C_PRAGMA_H +#define GCC_C_PRAGMA_H + +#include "cpplib.h" /* For enum cpp_ttype. */ + +/* Pragma identifiers built in to the front end parsers. Identifiers + for ancillary handlers will follow these. */ +typedef enum pragma_kind { + PRAGMA_NONE = 0, + + PRAGMA_OMP_ATOMIC, + PRAGMA_OMP_BARRIER, + PRAGMA_OMP_CRITICAL, + PRAGMA_OMP_FLUSH, + PRAGMA_OMP_FOR, + PRAGMA_OMP_MASTER, + PRAGMA_OMP_ORDERED, + PRAGMA_OMP_PARALLEL, + PRAGMA_OMP_PARALLEL_FOR, + PRAGMA_OMP_PARALLEL_SECTIONS, + PRAGMA_OMP_SECTION, + PRAGMA_OMP_SECTIONS, + PRAGMA_OMP_SINGLE, + PRAGMA_OMP_TASK, + PRAGMA_OMP_TASKWAIT, + PRAGMA_OMP_THREADPRIVATE, + + PRAGMA_GCC_PCH_PREPROCESS, + + PRAGMA_FIRST_EXTERNAL +} pragma_kind; + + +/* All clauses defined by OpenMP 2.5 and 3.0. + Used internally by both C and C++ parsers. */ +typedef enum pragma_omp_clause { + PRAGMA_OMP_CLAUSE_NONE = 0, + + PRAGMA_OMP_CLAUSE_COLLAPSE, + PRAGMA_OMP_CLAUSE_COPYIN, + PRAGMA_OMP_CLAUSE_COPYPRIVATE, + PRAGMA_OMP_CLAUSE_DEFAULT, + PRAGMA_OMP_CLAUSE_FIRSTPRIVATE, + PRAGMA_OMP_CLAUSE_IF, + PRAGMA_OMP_CLAUSE_LASTPRIVATE, + PRAGMA_OMP_CLAUSE_NOWAIT, + PRAGMA_OMP_CLAUSE_NUM_THREADS, + PRAGMA_OMP_CLAUSE_ORDERED, + PRAGMA_OMP_CLAUSE_PRIVATE, + PRAGMA_OMP_CLAUSE_REDUCTION, + PRAGMA_OMP_CLAUSE_SCHEDULE, + PRAGMA_OMP_CLAUSE_SHARED, + PRAGMA_OMP_CLAUSE_UNTIED +} pragma_omp_clause; + +extern struct cpp_reader* parse_in; + +/* It's safe to always leave visibility pragma enabled as if + visibility is not supported on the host OS platform the + statements are ignored. */ +extern void push_visibility (const char *, int); +extern bool pop_visibility (int); + +extern void init_pragma (void); + +/* Front-end wrappers for pragma registration. */ +typedef void (*pragma_handler)(struct cpp_reader *); +extern void c_register_pragma (const char *, const char *, pragma_handler); +extern void c_register_pragma_with_expansion (const char *, const char *, + pragma_handler); +extern void c_invoke_pragma_handler (unsigned int); + +extern void maybe_apply_pragma_weak (tree); +extern void maybe_apply_pending_pragma_weaks (void); +extern tree maybe_apply_renaming_pragma (tree, tree); +extern void add_to_renaming_pragma_list (tree, tree); + +extern enum cpp_ttype pragma_lex (tree *); + +/* Flags for use with c_lex_with_flags. The values here were picked + so that 0 means to translate and join strings. */ +#define C_LEX_STRING_NO_TRANSLATE 1 /* Do not lex strings into + execution character set. */ +#define C_LEX_STRING_NO_JOIN 2 /* Do not concatenate strings + nor translate them into execution + character set. */ + +/* This is not actually available to pragma parsers. It's merely a + convenient location to declare this function for c-lex, after + having enum cpp_ttype declared. */ +extern enum cpp_ttype c_lex_with_flags (tree *, location_t *, unsigned char *, + int); + +extern void c_pp_lookup_pragma (unsigned int, const char **, const char **); + +#endif /* GCC_C_PRAGMA_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-pretty-print.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-pretty-print.h new file mode 100644 index 0000000..ed6e9b5 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/c-family/c-pretty-print.h @@ -0,0 +1,214 @@ +/* Various declarations for the C and C++ pretty-printers. + Copyright (C) 2002, 2003, 2004, 2007, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> + +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/>. */ + +#ifndef GCC_C_PRETTY_PRINTER +#define GCC_C_PRETTY_PRINTER + +#include "tree.h" +#include "c-family/c-common.h" +#include "pretty-print.h" + + +typedef enum + { + pp_c_flag_abstract = 1 << 1, + pp_c_flag_last_bit = 2 + } pp_c_pretty_print_flags; + + +/* The data type used to bundle information necessary for pretty-printing + a C or C++ entity. */ +typedef struct c_pretty_print_info c_pretty_printer; + +/* The type of a C pretty-printer 'member' function. */ +typedef void (*c_pretty_print_fn) (c_pretty_printer *, tree); + +/* The datatype that contains information necessary for pretty-printing + a tree that represents a C construct. Any pretty-printer for a + language using C/c++ syntax can derive from this datatype and reuse + facilities provided here. It can do so by having a subobject of type + c_pretty_printer and override the macro pp_c_base to return a pointer + to that subobject. Such a pretty-printer has the responsibility to + initialize the pp_base() part, then call pp_c_pretty_printer_init + to set up the components that are specific to the C pretty-printer. + A derived pretty-printer can override any function listed in the + vtable below. See cp/cxx-pretty-print.h and cp/cxx-pretty-print.c + for an example of derivation. */ +struct c_pretty_print_info +{ + pretty_printer base; + /* Points to the first element of an array of offset-list. + Not used yet. */ + int *offset_list; + + pp_flags flags; + + /* These must be overridden by each of the C and C++ front-end to + reflect their understanding of syntactic productions when they differ. */ + c_pretty_print_fn declaration; + c_pretty_print_fn declaration_specifiers; + c_pretty_print_fn declarator; + c_pretty_print_fn abstract_declarator; + c_pretty_print_fn direct_abstract_declarator; + c_pretty_print_fn type_specifier_seq; + c_pretty_print_fn direct_declarator; + c_pretty_print_fn ptr_operator; + c_pretty_print_fn parameter_list; + c_pretty_print_fn type_id; + c_pretty_print_fn simple_type_specifier; + c_pretty_print_fn function_specifier; + c_pretty_print_fn storage_class_specifier; + c_pretty_print_fn initializer; + + c_pretty_print_fn statement; + + c_pretty_print_fn constant; + c_pretty_print_fn id_expression; + c_pretty_print_fn primary_expression; + c_pretty_print_fn postfix_expression; + c_pretty_print_fn unary_expression; + c_pretty_print_fn multiplicative_expression; + c_pretty_print_fn conditional_expression; + c_pretty_print_fn assignment_expression; + c_pretty_print_fn expression; +}; + +/* Override the pp_base macro. Derived pretty-printers should not + touch this macro. Instead they should override pp_c_base instead. */ +#undef pp_base +#define pp_base(PP) (&pp_c_base (PP)->base) + + +#define pp_c_tree_identifier(PPI, ID) \ + pp_c_identifier (PPI, IDENTIFIER_POINTER (ID)) + +#define pp_declaration(PPI, T) \ + pp_c_base (PPI)->declaration (pp_c_base (PPI), T) +#define pp_declaration_specifiers(PPI, D) \ + pp_c_base (PPI)->declaration_specifiers (pp_c_base (PPI), D) +#define pp_abstract_declarator(PP, D) \ + pp_c_base (PP)->abstract_declarator (pp_c_base (PP), D) +#define pp_type_specifier_seq(PPI, D) \ + pp_c_base (PPI)->type_specifier_seq (pp_c_base (PPI), D) +#define pp_declarator(PPI, D) \ + pp_c_base (PPI)->declarator (pp_c_base (PPI), D) +#define pp_direct_declarator(PPI, D) \ + pp_c_base (PPI)->direct_declarator (pp_c_base (PPI), D) +#define pp_direct_abstract_declarator(PP, D) \ + pp_c_base (PP)->direct_abstract_declarator (pp_c_base (PP), D) +#define pp_ptr_operator(PP, D) \ + pp_c_base (PP)->ptr_operator (pp_c_base (PP), D) +#define pp_parameter_list(PPI, T) \ + pp_c_base (PPI)->parameter_list (pp_c_base (PPI), T) +#define pp_type_id(PPI, D) \ + pp_c_base (PPI)->type_id (pp_c_base (PPI), D) +#define pp_simple_type_specifier(PP, T) \ + pp_c_base (PP)->simple_type_specifier (pp_c_base (PP), T) +#define pp_function_specifier(PP, D) \ + pp_c_base (PP)->function_specifier (pp_c_base (PP), D) +#define pp_storage_class_specifier(PP, D) \ + pp_c_base (PP)->storage_class_specifier (pp_c_base (PP), D); + +#define pp_statement(PPI, S) \ + pp_c_base (PPI)->statement (pp_c_base (PPI), S) + +#define pp_constant(PP, E) \ + pp_c_base (PP)->constant (pp_c_base (PP), E) +#define pp_id_expression(PP, E) \ + pp_c_base (PP)->id_expression (pp_c_base (PP), E) +#define pp_primary_expression(PPI, E) \ + pp_c_base (PPI)->primary_expression (pp_c_base (PPI), E) +#define pp_postfix_expression(PPI, E) \ + pp_c_base (PPI)->postfix_expression (pp_c_base (PPI), E) +#define pp_unary_expression(PPI, E) \ + pp_c_base (PPI)->unary_expression (pp_c_base (PPI), E) +#define pp_initializer(PPI, E) \ + pp_c_base (PPI)->initializer (pp_c_base (PPI), E) +#define pp_multiplicative_expression(PPI, E) \ + pp_c_base (PPI)->multiplicative_expression (pp_c_base (PPI), E) +#define pp_conditional_expression(PPI, E) \ + pp_c_base (PPI)->conditional_expression (pp_c_base (PPI), E) +#define pp_assignment_expression(PPI, E) \ + pp_c_base (PPI)->assignment_expression (pp_c_base (PPI), E) +#define pp_expression(PP, E) \ + pp_c_base (PP)->expression (pp_c_base (PP), E) + + +/* Returns the c_pretty_printer base object of PRETTY-PRINTER. This + macro must be overridden by any subclass of c_pretty_print_info. */ +#define pp_c_base(PP) (PP) + +extern void pp_c_pretty_printer_init (c_pretty_printer *); +void pp_c_whitespace (c_pretty_printer *); +void pp_c_left_paren (c_pretty_printer *); +void pp_c_right_paren (c_pretty_printer *); +void pp_c_left_brace (c_pretty_printer *); +void pp_c_right_brace (c_pretty_printer *); +void pp_c_left_bracket (c_pretty_printer *); +void pp_c_right_bracket (c_pretty_printer *); +void pp_c_dot (c_pretty_printer *); +void pp_c_ampersand (c_pretty_printer *); +void pp_c_star (c_pretty_printer *); +void pp_c_arrow (c_pretty_printer *); +void pp_c_semicolon (c_pretty_printer *); +void pp_c_complement (c_pretty_printer *); +void pp_c_exclamation (c_pretty_printer *); +void pp_c_space_for_pointer_operator (c_pretty_printer *, tree); + +/* Declarations. */ +void pp_c_tree_decl_identifier (c_pretty_printer *, tree); +void pp_c_function_definition (c_pretty_printer *, tree); +void pp_c_attributes (c_pretty_printer *, tree); +void pp_c_cv_qualifiers (c_pretty_printer *pp, int qualifiers, bool func_type); +void pp_c_type_qualifier_list (c_pretty_printer *, tree); +void pp_c_parameter_type_list (c_pretty_printer *, tree); +void pp_c_declaration (c_pretty_printer *, tree); +void pp_c_declaration_specifiers (c_pretty_printer *, tree); +void pp_c_declarator (c_pretty_printer *, tree); +void pp_c_direct_declarator (c_pretty_printer *, tree); +void pp_c_specifier_qualifier_list (c_pretty_printer *, tree); +void pp_c_function_specifier (c_pretty_printer *, tree); +void pp_c_type_id (c_pretty_printer *, tree); +void pp_c_direct_abstract_declarator (c_pretty_printer *, tree); +void pp_c_type_specifier (c_pretty_printer *, tree); +void pp_c_storage_class_specifier (c_pretty_printer *, tree); +/* Statements. */ +void pp_c_statement (c_pretty_printer *, tree); +/* Expressions. */ +void pp_c_expression (c_pretty_printer *, tree); +void pp_c_logical_or_expression (c_pretty_printer *, tree); +void pp_c_expression_list (c_pretty_printer *, tree); +void pp_c_constructor_elts (c_pretty_printer *, VEC(constructor_elt,gc) *); +void pp_c_call_argument_list (c_pretty_printer *, tree); +void pp_c_unary_expression (c_pretty_printer *, tree); +void pp_c_cast_expression (c_pretty_printer *, tree); +void pp_c_postfix_expression (c_pretty_printer *, tree); +void pp_c_primary_expression (c_pretty_printer *, tree); +void pp_c_init_declarator (c_pretty_printer *, tree); +void pp_c_constant (c_pretty_printer *, tree); +void pp_c_id_expression (c_pretty_printer *, tree); +void pp_c_ws_string (c_pretty_printer *, const char *); +void pp_c_identifier (c_pretty_printer *, const char *); +void pp_c_string_literal (c_pretty_printer *, tree); + +void print_c_tree (FILE *file, tree t); + +#endif /* GCC_C_PRETTY_PRINTER */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cfghooks.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cfghooks.h new file mode 100644 index 0000000..5741768 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cfghooks.h @@ -0,0 +1,197 @@ +/* Hooks for cfg representation specific functions. + Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 + Free Software Foundation, Inc. + Contributed by Sebastian Pop <s.pop@laposte.net> + +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/>. */ + +#ifndef GCC_CFGHOOKS_H +#define GCC_CFGHOOKS_H + +struct cfg_hooks +{ + /* Name of the corresponding ir. */ + const char *name; + + /* Debugging. */ + int (*verify_flow_info) (void); + void (*dump_bb) (basic_block, FILE *, int, int); + + /* Basic CFG manipulation. */ + + /* Return new basic block. */ + basic_block (*create_basic_block) (void *head, void *end, basic_block after); + + /* Redirect edge E to the given basic block B and update underlying program + representation. Returns edge representing redirected branch (that may not + be equivalent to E in the case of duplicate edges being removed) or NULL + if edge is not easily redirectable for whatever reason. */ + edge (*redirect_edge_and_branch) (edge e, basic_block b); + + /* Same as the above but allows redirecting of fallthru edges. In that case + newly created forwarder basic block is returned. The edge must + not be abnormal. */ + basic_block (*redirect_edge_and_branch_force) (edge, basic_block); + + /* Returns true if it is possible to remove the edge by redirecting it + to the destination of the other edge going from its source. */ + bool (*can_remove_branch_p) (const_edge); + + /* Remove statements corresponding to a given basic block. */ + void (*delete_basic_block) (basic_block); + + /* Creates a new basic block just after basic block B by splitting + everything after specified instruction I. */ + basic_block (*split_block) (basic_block b, void * i); + + /* Move block B immediately after block A. */ + bool (*move_block_after) (basic_block b, basic_block a); + + /* Return true when blocks A and B can be merged into single basic block. */ + bool (*can_merge_blocks_p) (basic_block a, basic_block b); + + /* Merge blocks A and B. */ + void (*merge_blocks) (basic_block a, basic_block b); + + /* Predict edge E using PREDICTOR to given PROBABILITY. */ + void (*predict_edge) (edge e, enum br_predictor predictor, int probability); + + /* Return true if the one of outgoing edges is already predicted by + PREDICTOR. */ + bool (*predicted_by_p) (const_basic_block bb, enum br_predictor predictor); + + /* Return true when block A can be duplicated. */ + bool (*can_duplicate_block_p) (const_basic_block a); + + /* Duplicate block A. */ + basic_block (*duplicate_block) (basic_block a); + + /* Higher level functions representable by primitive operations above if + we didn't have some oddities in RTL and Tree representations. */ + basic_block (*split_edge) (edge); + void (*make_forwarder_block) (edge); + + /* Tries to make the edge fallthru. */ + void (*tidy_fallthru_edge) (edge); + + /* Say whether a block ends with a call, possibly followed by some + other code that must stay with the call. */ + bool (*block_ends_with_call_p) (basic_block); + + /* Say whether a block ends with a conditional branch. Switches + and unconditional branches do not qualify. */ + bool (*block_ends_with_condjump_p) (const_basic_block); + + /* Add fake edges to the function exit for any non constant and non noreturn + calls, volatile inline assembly in the bitmap of blocks specified by + BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks + that were split. + + The goal is to expose cases in which entering a basic block does not imply + that all subsequent instructions must be executed. */ + int (*flow_call_edges_add) (sbitmap); + + /* This function is called immediately after edge E is added to the + edge vector E->dest->preds. */ + void (*execute_on_growing_pred) (edge); + + /* This function is called immediately before edge E is removed from + the edge vector E->dest->preds. */ + void (*execute_on_shrinking_pred) (edge); + + /* A hook for duplicating loop in CFG, currently this is used + in loop versioning. */ + bool (*cfg_hook_duplicate_loop_to_header_edge) (struct loop *, edge, + unsigned, sbitmap, + edge, VEC (edge, heap) **, + int); + + /* Add condition to new basic block and update CFG used in loop + versioning. */ + void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block, + void *); + /* Update the PHI nodes in case of loop versioning. */ + void (*lv_adjust_loop_header_phi) (basic_block, basic_block, + basic_block, edge); + + /* Given a condition BB extract the true/false taken/not taken edges + (depending if we are on tree's or RTL). */ + void (*extract_cond_bb_edges) (basic_block, edge *, edge *); + + + /* Add PHI arguments queued in PENDINT_STMT list on edge E to edge + E->dest (only in tree-ssa loop versioning. */ + void (*flush_pending_stmts) (edge); +}; + +extern void verify_flow_info (void); +extern void dump_bb (basic_block, FILE *, int); +extern edge redirect_edge_and_branch (edge, basic_block); +extern basic_block redirect_edge_and_branch_force (edge, basic_block); +extern bool can_remove_branch_p (const_edge); +extern void remove_branch (edge); +extern void remove_edge (edge); +extern edge split_block (basic_block, void *); +extern edge split_block_after_labels (basic_block); +extern bool move_block_after (basic_block, basic_block); +extern void delete_basic_block (basic_block); +extern basic_block split_edge (edge); +extern basic_block create_basic_block (void *, void *, basic_block); +extern basic_block create_empty_bb (basic_block); +extern bool can_merge_blocks_p (basic_block, basic_block); +extern void merge_blocks (basic_block, basic_block); +extern edge make_forwarder_block (basic_block, bool (*)(edge), + void (*) (basic_block)); +extern void tidy_fallthru_edge (edge); +extern void tidy_fallthru_edges (void); +extern void predict_edge (edge e, enum br_predictor predictor, int probability); +extern bool predicted_by_p (const_basic_block bb, enum br_predictor predictor); +extern bool can_duplicate_block_p (const_basic_block); +extern basic_block duplicate_block (basic_block, edge, basic_block); +extern bool block_ends_with_call_p (basic_block bb); +extern bool block_ends_with_condjump_p (const_basic_block bb); +extern int flow_call_edges_add (sbitmap); +extern void execute_on_growing_pred (edge); +extern void execute_on_shrinking_pred (edge); +extern bool cfg_hook_duplicate_loop_to_header_edge (struct loop *loop, edge, + unsigned int ndupl, + sbitmap wont_exit, + edge orig, + VEC (edge, heap) **to_remove, + int flags); + +extern void lv_flush_pending_stmts (edge); +extern void extract_cond_bb_edges (basic_block, edge *, edge*); +extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block, + edge); +extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block, + void *); + +/* Hooks containers. */ +extern struct cfg_hooks gimple_cfg_hooks; +extern struct cfg_hooks rtl_cfg_hooks; +extern struct cfg_hooks cfg_layout_rtl_cfg_hooks; + +/* Declarations. */ +extern enum ir_type current_ir_type (void); +extern void rtl_register_cfg_hooks (void); +extern void cfg_layout_rtl_register_cfg_hooks (void); +extern void gimple_register_cfg_hooks (void); +extern struct cfg_hooks get_cfg_hooks (void); +extern void set_cfg_hooks (struct cfg_hooks); + +#endif /* GCC_CFGHOOKS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cfgloop.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cfgloop.h new file mode 100644 index 0000000..c6178e8 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cfgloop.h @@ -0,0 +1,694 @@ +/* Natural loop functions + Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, + 2005, 2006, 2007, 2008, 2009, 2010 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/>. */ + +#ifndef GCC_CFGLOOP_H +#define GCC_CFGLOOP_H + +#include "basic-block.h" +/* For rtx_code. */ +#include "rtl.h" +#include "vecprim.h" +#include "double-int.h" + +#include "bitmap.h" +#include "sbitmap.h" + +/* Structure to hold decision about unrolling/peeling. */ +enum lpt_dec +{ + LPT_NONE, + LPT_PEEL_COMPLETELY, + LPT_PEEL_SIMPLE, + LPT_UNROLL_CONSTANT, + LPT_UNROLL_RUNTIME, + LPT_UNROLL_STUPID +}; + +struct GTY (()) lpt_decision { + enum lpt_dec decision; + unsigned times; +}; + +/* The structure describing a bound on number of iterations of a loop. */ + +struct GTY ((chain_next ("%h.next"))) nb_iter_bound { + /* The statement STMT is executed at most ... */ + gimple stmt; + + /* ... BOUND + 1 times (BOUND must be an unsigned constant). + The + 1 is added for the following reasons: + + a) 0 would otherwise be unused, while we would need to care more about + overflows (as MAX + 1 is sometimes produced as the estimate on number + of executions of STMT). + b) it is consistent with the result of number_of_iterations_exit. */ + double_int bound; + + /* True if the statement will cause the loop to be leaved the (at most) + BOUND + 1-st time it is executed, that is, all the statements after it + are executed at most BOUND times. */ + bool is_exit; + + /* The next bound in the list. */ + struct nb_iter_bound *next; +}; + +/* Description of the loop exit. */ + +struct GTY (()) loop_exit { + /* The exit edge. */ + struct edge_def *e; + + /* Previous and next exit in the list of the exits of the loop. */ + struct loop_exit *prev; + struct loop_exit *next; + + /* Next element in the list of loops from that E exits. */ + struct loop_exit *next_e; +}; + +typedef struct loop *loop_p; +DEF_VEC_P (loop_p); +DEF_VEC_ALLOC_P (loop_p, heap); +DEF_VEC_ALLOC_P (loop_p, gc); + +/* An integer estimation of the number of iterations. Estimate_state + describes what is the state of the estimation. */ +enum loop_estimation +{ + /* Estimate was not computed yet. */ + EST_NOT_COMPUTED, + /* Estimate is ready. */ + EST_AVAILABLE +}; + +/* Structure to hold information for each natural loop. */ +struct GTY ((chain_next ("%h.next"))) loop { + /* Index into loops array. */ + int num; + + /* Number of loop insns. */ + unsigned ninsns; + + /* Basic block of loop header. */ + struct basic_block_def *header; + + /* Basic block of loop latch. */ + struct basic_block_def *latch; + + /* For loop unrolling/peeling decision. */ + struct lpt_decision lpt_decision; + + /* Average number of executed insns per iteration. */ + unsigned av_ninsns; + + /* Number of blocks contained within the loop. */ + unsigned num_nodes; + + /* Superloops of the loop, starting with the outermost loop. */ + VEC (loop_p, gc) *superloops; + + /* The first inner (child) loop or NULL if innermost loop. */ + struct loop *inner; + + /* Link to the next (sibling) loop. */ + struct loop *next; + + /* Auxiliary info specific to a pass. */ + PTR GTY ((skip (""))) aux; + + /* The number of times the latch of the loop is executed. This can be an + INTEGER_CST, or a symbolic expression representing the number of + iterations like "N - 1", or a COND_EXPR containing the runtime + conditions under which the number of iterations is non zero. + + Don't access this field directly: number_of_latch_executions + computes and caches the computed information in this field. */ + tree nb_iterations; + + /* An integer guaranteed to bound the number of iterations of the loop + from above. */ + double_int nb_iterations_upper_bound; + + /* An integer giving the expected number of iterations of the loop. */ + double_int nb_iterations_estimate; + + bool any_upper_bound; + bool any_estimate; + + /* True if the loop can be parallel. */ + bool can_be_parallel; + + /* An integer estimation of the number of iterations. Estimate_state + describes what is the state of the estimation. */ + enum loop_estimation estimate_state; + + /* Upper bound on number of iterations of a loop. */ + struct nb_iter_bound *bounds; + + /* Head of the cyclic list of the exits of the loop. */ + struct loop_exit *exits; +}; + +/* Flags for state of loop structure. */ +enum +{ + LOOPS_HAVE_PREHEADERS = 1, + LOOPS_HAVE_SIMPLE_LATCHES = 2, + LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS = 4, + LOOPS_HAVE_RECORDED_EXITS = 8, + LOOPS_MAY_HAVE_MULTIPLE_LATCHES = 16, + LOOP_CLOSED_SSA = 32, + LOOPS_NEED_FIXUP = 64, + LOOPS_HAVE_FALLTHRU_PREHEADERS = 128 +}; + +#define LOOPS_NORMAL (LOOPS_HAVE_PREHEADERS | LOOPS_HAVE_SIMPLE_LATCHES \ + | LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS) +#define AVOID_CFG_MODIFICATIONS (LOOPS_MAY_HAVE_MULTIPLE_LATCHES) + +/* Structure to hold CFG information about natural loops within a function. */ +struct GTY (()) loops { + /* State of loops. */ + int state; + + /* Array of the loops. */ + VEC (loop_p, gc) *larray; + + /* Maps edges to the list of their descriptions as loop exits. Edges + whose sources or destinations have loop_father == NULL (which may + happen during the cfg manipulations) should not appear in EXITS. */ + htab_t GTY((param_is (struct loop_exit))) exits; + + /* Pointer to root of loop hierarchy tree. */ + struct loop *tree_root; +}; + +/* Loop recognition. */ +extern int flow_loops_find (struct loops *); +extern void disambiguate_loops_with_multiple_latches (void); +extern void flow_loops_free (struct loops *); +extern void flow_loops_dump (FILE *, + void (*)(const struct loop *, FILE *, int), int); +extern void flow_loop_dump (const struct loop *, FILE *, + void (*)(const struct loop *, FILE *, int), int); +struct loop *alloc_loop (void); +extern void flow_loop_free (struct loop *); +int flow_loop_nodes_find (basic_block, struct loop *); +void fix_loop_structure (bitmap changed_bbs); +bool mark_irreducible_loops (void); +void release_recorded_exits (void); +void record_loop_exits (void); +void rescan_loop_exit (edge, bool, bool); + +/* Loop data structure manipulation/querying. */ +extern void flow_loop_tree_node_add (struct loop *, struct loop *); +extern void flow_loop_tree_node_remove (struct loop *); +extern void add_loop (struct loop *, struct loop *); +extern bool flow_loop_nested_p (const struct loop *, const struct loop *); +extern bool flow_bb_inside_loop_p (const struct loop *, const_basic_block); +extern struct loop * find_common_loop (struct loop *, struct loop *); +struct loop *superloop_at_depth (struct loop *, unsigned); +struct eni_weights_d; +extern unsigned tree_num_loop_insns (struct loop *, struct eni_weights_d *); +extern int num_loop_insns (const struct loop *); +extern int average_num_loop_insns (const struct loop *); +extern unsigned get_loop_level (const struct loop *); +extern bool loop_exit_edge_p (const struct loop *, const_edge); +extern bool loop_exits_to_bb_p (struct loop *, basic_block); +extern bool loop_exits_from_bb_p (struct loop *, basic_block); +extern void mark_loop_exit_edges (void); +extern location_t get_loop_location (struct loop *loop); + +/* Loops & cfg manipulation. */ +extern basic_block *get_loop_body (const struct loop *); +extern unsigned get_loop_body_with_size (const struct loop *, basic_block *, + unsigned); +extern basic_block *get_loop_body_in_dom_order (const struct loop *); +extern basic_block *get_loop_body_in_bfs_order (const struct loop *); +extern basic_block *get_loop_body_in_custom_order (const struct loop *, + int (*) (const void *, const void *)); + +extern VEC (edge, heap) *get_loop_exit_edges (const struct loop *); +edge single_exit (const struct loop *); +extern unsigned num_loop_branches (const struct loop *); + +extern edge loop_preheader_edge (const struct loop *); +extern edge loop_latch_edge (const struct loop *); + +extern void add_bb_to_loop (basic_block, struct loop *); +extern void remove_bb_from_loops (basic_block); + +extern void cancel_loop_tree (struct loop *); +extern void delete_loop (struct loop *); + +enum +{ + CP_SIMPLE_PREHEADERS = 1, + CP_FALLTHRU_PREHEADERS = 2 +}; + +basic_block create_preheader (struct loop *, int); +extern void create_preheaders (int); +extern void force_single_succ_latches (void); + +extern void verify_loop_structure (void); + +/* Loop analysis. */ +extern bool just_once_each_iteration_p (const struct loop *, const_basic_block); +gcov_type expected_loop_iterations_unbounded (const struct loop *); +extern unsigned expected_loop_iterations (const struct loop *); +extern rtx doloop_condition_get (rtx); + +void estimate_numbers_of_iterations_loop (struct loop *, bool); +HOST_WIDE_INT estimated_loop_iterations_int (struct loop *, bool); +bool estimated_loop_iterations (struct loop *, bool, double_int *); + +/* Loop manipulation. */ +extern bool can_duplicate_loop_p (const struct loop *loop); + +#define DLTHE_FLAG_UPDATE_FREQ 1 /* Update frequencies in + duplicate_loop_to_header_edge. */ +#define DLTHE_RECORD_COPY_NUMBER 2 /* Record copy number in the aux + field of newly create BB. */ +#define DLTHE_FLAG_COMPLETTE_PEEL 4 /* Update frequencies expecting + a complete peeling. */ + +extern edge create_empty_if_region_on_edge (edge, tree); +extern struct loop *create_empty_loop_on_edge (edge, tree, tree, tree, tree, + tree *, tree *, struct loop *); +extern struct loop * duplicate_loop (struct loop *, struct loop *); +extern void duplicate_subloops (struct loop *, struct loop *); +extern bool duplicate_loop_to_header_edge (struct loop *, edge, + unsigned, sbitmap, edge, + VEC (edge, heap) **, int); +extern struct loop *loopify (edge, edge, + basic_block, edge, edge, bool, + unsigned, unsigned); +struct loop * loop_version (struct loop *, void *, + basic_block *, unsigned, unsigned, unsigned, bool); +extern bool remove_path (edge); +void scale_loop_frequencies (struct loop *, int, int); + +/* Induction variable analysis. */ + +/* The description of induction variable. The things are a bit complicated + due to need to handle subregs and extends. The value of the object described + by it can be obtained as follows (all computations are done in extend_mode): + + Value in i-th iteration is + delta + mult * extend_{extend_mode} (subreg_{mode} (base + i * step)). + + If first_special is true, the value in the first iteration is + delta + mult * base + + If extend = UNKNOWN, first_special must be false, delta 0, mult 1 and value is + subreg_{mode} (base + i * step) + + The get_iv_value function can be used to obtain these expressions. + + ??? Add a third mode field that would specify the mode in that inner + computation is done, which would enable it to be different from the + outer one? */ + +struct rtx_iv +{ + /* Its base and step (mode of base and step is supposed to be extend_mode, + see the description above). */ + rtx base, step; + + /* The type of extend applied to it (SIGN_EXTEND, ZERO_EXTEND or UNKNOWN). */ + enum rtx_code extend; + + /* Operations applied in the extended mode. */ + rtx delta, mult; + + /* The mode it is extended to. */ + enum machine_mode extend_mode; + + /* The mode the variable iterates in. */ + enum machine_mode mode; + + /* Whether the first iteration needs to be handled specially. */ + unsigned first_special : 1; +}; + +/* The description of an exit from the loop and of the number of iterations + till we take the exit. */ + +struct niter_desc +{ + /* The edge out of the loop. */ + edge out_edge; + + /* The other edge leading from the condition. */ + edge in_edge; + + /* True if we are able to say anything about number of iterations of the + loop. */ + bool simple_p; + + /* True if the loop iterates the constant number of times. */ + bool const_iter; + + /* Number of iterations if constant. */ + unsigned HOST_WIDEST_INT niter; + + /* Upper bound on the number of iterations. */ + unsigned HOST_WIDEST_INT niter_max; + + /* Assumptions under that the rest of the information is valid. */ + rtx assumptions; + + /* Assumptions under that the loop ends before reaching the latch, + even if value of niter_expr says otherwise. */ + rtx noloop_assumptions; + + /* Condition under that the loop is infinite. */ + rtx infinite; + + /* Whether the comparison is signed. */ + bool signed_p; + + /* The mode in that niter_expr should be computed. */ + enum machine_mode mode; + + /* The number of iterations of the loop. */ + rtx niter_expr; +}; + +extern void iv_analysis_loop_init (struct loop *); +extern bool iv_analyze (rtx, rtx, struct rtx_iv *); +extern bool iv_analyze_result (rtx, rtx, struct rtx_iv *); +extern bool iv_analyze_expr (rtx, rtx, enum machine_mode, struct rtx_iv *); +extern rtx get_iv_value (struct rtx_iv *, rtx); +extern bool biv_p (rtx, rtx); +extern void find_simple_exit (struct loop *, struct niter_desc *); +extern void iv_analysis_done (void); + +extern struct niter_desc *get_simple_loop_desc (struct loop *loop); +extern void free_simple_loop_desc (struct loop *loop); + +static inline struct niter_desc * +simple_loop_desc (struct loop *loop) +{ + return (struct niter_desc *) loop->aux; +} + +/* Accessors for the loop structures. */ + +/* Returns the loop with index NUM from current_loops. */ + +static inline struct loop * +get_loop (unsigned num) +{ + return VEC_index (loop_p, current_loops->larray, num); +} + +/* Returns the number of superloops of LOOP. */ + +static inline unsigned +loop_depth (const struct loop *loop) +{ + return VEC_length (loop_p, loop->superloops); +} + +/* Returns the immediate superloop of LOOP, or NULL if LOOP is the outermost + loop. */ + +static inline struct loop * +loop_outer (const struct loop *loop) +{ + unsigned n = VEC_length (loop_p, loop->superloops); + + if (n == 0) + return NULL; + + return VEC_index (loop_p, loop->superloops, n - 1); +} + +/* Returns true if LOOP has at least one exit edge. */ + +static inline bool +loop_has_exit_edges (const struct loop *loop) +{ + return loop->exits->next->e != NULL; +} + +/* Returns the list of loops in current_loops. */ + +static inline VEC (loop_p, gc) * +get_loops (void) +{ + if (!current_loops) + return NULL; + + return current_loops->larray; +} + +/* Returns the number of loops in current_loops (including the removed + ones and the fake loop that forms the root of the loop tree). */ + +static inline unsigned +number_of_loops (void) +{ + if (!current_loops) + return 0; + + return VEC_length (loop_p, current_loops->larray); +} + +/* Returns true if state of the loops satisfies all properties + described by FLAGS. */ + +static inline bool +loops_state_satisfies_p (unsigned flags) +{ + return (current_loops->state & flags) == flags; +} + +/* Sets FLAGS to the loops state. */ + +static inline void +loops_state_set (unsigned flags) +{ + current_loops->state |= flags; +} + +/* Clears FLAGS from the loops state. */ + +static inline void +loops_state_clear (unsigned flags) +{ + if (!current_loops) + return; + current_loops->state &= ~flags; +} + +/* Loop iterators. */ + +/* Flags for loop iteration. */ + +enum li_flags +{ + LI_INCLUDE_ROOT = 1, /* Include the fake root of the loop tree. */ + LI_FROM_INNERMOST = 2, /* Iterate over the loops in the reverse order, + starting from innermost ones. */ + LI_ONLY_INNERMOST = 4 /* Iterate only over innermost loops. */ +}; + +/* The iterator for loops. */ + +typedef struct +{ + /* The list of loops to visit. */ + VEC(int,heap) *to_visit; + + /* The index of the actual loop. */ + unsigned idx; +} loop_iterator; + +static inline void +fel_next (loop_iterator *li, loop_p *loop) +{ + int anum; + + while (VEC_iterate (int, li->to_visit, li->idx, anum)) + { + li->idx++; + *loop = get_loop (anum); + if (*loop) + return; + } + + VEC_free (int, heap, li->to_visit); + *loop = NULL; +} + +static inline void +fel_init (loop_iterator *li, loop_p *loop, unsigned flags) +{ + struct loop *aloop; + unsigned i; + int mn; + + li->idx = 0; + if (!current_loops) + { + li->to_visit = NULL; + *loop = NULL; + return; + } + + li->to_visit = VEC_alloc (int, heap, number_of_loops ()); + mn = (flags & LI_INCLUDE_ROOT) ? 0 : 1; + + if (flags & LI_ONLY_INNERMOST) + { + for (i = 0; VEC_iterate (loop_p, current_loops->larray, i, aloop); i++) + if (aloop != NULL + && aloop->inner == NULL + && aloop->num >= mn) + VEC_quick_push (int, li->to_visit, aloop->num); + } + else if (flags & LI_FROM_INNERMOST) + { + /* Push the loops to LI->TO_VISIT in postorder. */ + for (aloop = current_loops->tree_root; + aloop->inner != NULL; + aloop = aloop->inner) + continue; + + while (1) + { + if (aloop->num >= mn) + VEC_quick_push (int, li->to_visit, aloop->num); + + if (aloop->next) + { + for (aloop = aloop->next; + aloop->inner != NULL; + aloop = aloop->inner) + continue; + } + else if (!loop_outer (aloop)) + break; + else + aloop = loop_outer (aloop); + } + } + else + { + /* Push the loops to LI->TO_VISIT in preorder. */ + aloop = current_loops->tree_root; + while (1) + { + if (aloop->num >= mn) + VEC_quick_push (int, li->to_visit, aloop->num); + + if (aloop->inner != NULL) + aloop = aloop->inner; + else + { + while (aloop != NULL && aloop->next == NULL) + aloop = loop_outer (aloop); + if (aloop == NULL) + break; + aloop = aloop->next; + } + } + } + + fel_next (li, loop); +} + +#define FOR_EACH_LOOP(LI, LOOP, FLAGS) \ + for (fel_init (&(LI), &(LOOP), FLAGS); \ + (LOOP); \ + fel_next (&(LI), &(LOOP))) + +#define FOR_EACH_LOOP_BREAK(LI) \ + { \ + VEC_free (int, heap, (LI)->to_visit); \ + break; \ + } + +/* The properties of the target. */ +struct target_cfgloop { + /* Number of available registers. */ + unsigned x_target_avail_regs; + + /* Number of available registers that are call-clobbered. */ + unsigned x_target_clobbered_regs; + + /* Number of registers reserved for temporary expressions. */ + unsigned x_target_res_regs; + + /* The cost for register when there still is some reserve, but we are + approaching the number of available registers. */ + unsigned x_target_reg_cost[2]; + + /* The cost for register when we need to spill. */ + unsigned x_target_spill_cost[2]; +}; + +extern struct target_cfgloop default_target_cfgloop; +#if SWITCHABLE_TARGET +extern struct target_cfgloop *this_target_cfgloop; +#else +#define this_target_cfgloop (&default_target_cfgloop) +#endif + +#define target_avail_regs \ + (this_target_cfgloop->x_target_avail_regs) +#define target_clobbered_regs \ + (this_target_cfgloop->x_target_clobbered_regs) +#define target_res_regs \ + (this_target_cfgloop->x_target_res_regs) +#define target_reg_cost \ + (this_target_cfgloop->x_target_reg_cost) +#define target_spill_cost \ + (this_target_cfgloop->x_target_spill_cost) + +/* Register pressure estimation for induction variable optimizations & loop + invariant motion. */ +extern unsigned estimate_reg_pressure_cost (unsigned, unsigned, bool, bool); +extern void init_set_costs (void); + +/* Loop optimizer initialization. */ +extern void loop_optimizer_init (unsigned); +extern void loop_optimizer_finalize (void); + +/* Optimization passes. */ +extern void unswitch_loops (void); + +enum +{ + UAP_PEEL = 1, /* Enables loop peeling. */ + UAP_UNROLL = 2, /* Enables unrolling of loops if it seems profitable. */ + UAP_UNROLL_ALL = 4 /* Enables unrolling of all loops. */ +}; + +extern void unroll_and_peel_loops (int); +extern void doloop_optimize_loops (void); +extern void move_loop_invariants (void); +extern bool finite_loop_p (struct loop *); + +#endif /* GCC_CFGLOOP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cgraph.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cgraph.h new file mode 100644 index 0000000..4a12b59 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cgraph.h @@ -0,0 +1,1009 @@ +/* Callgraph handling code. + Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Jan Hubicka + +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/>. */ + +#ifndef GCC_CGRAPH_H +#define GCC_CGRAPH_H + +#include "plugin-api.h" +#include "vec.h" +#include "tree.h" +#include "basic-block.h" +#include "function.h" +#include "ipa-ref.h" /* FIXME: inappropriate dependency of cgraph on IPA. */ + +enum availability +{ + /* Not yet set by cgraph_function_body_availability. */ + AVAIL_UNSET, + /* Function body/variable initializer is unknown. */ + AVAIL_NOT_AVAILABLE, + /* Function body/variable initializer is known but might be replaced + by a different one from other compilation unit and thus needs to + be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have + arbitrary side effects on escaping variables and functions, while + like AVAILABLE it might access static variables. */ + AVAIL_OVERWRITABLE, + /* Function body/variable initializer is known and will be used in final + program. */ + AVAIL_AVAILABLE, + /* Function body/variable initializer is known and all it's uses are explicitly + visible within current unit (ie it's address is never taken and it is not + exported to other units). + Currently used only for functions. */ + AVAIL_LOCAL +}; + +/* This is the information that is put into the cgraph local structure + to recover a function. */ +struct lto_file_decl_data; + +extern const char * const cgraph_availability_names[]; +extern const char * const ld_plugin_symbol_resolution_names[]; + +/* Function inlining information. */ + +struct GTY(()) inline_summary +{ + /* Estimated stack frame consumption by the function. */ + HOST_WIDE_INT estimated_self_stack_size; + + /* Size of the function body. */ + int self_size; + /* How many instructions are likely going to disappear after inlining. */ + int size_inlining_benefit; + /* Estimated time spent executing the function body. */ + int self_time; + /* How much time is going to be saved by inlining. */ + int time_inlining_benefit; +}; + +/* Information about thunk, used only for same body aliases. */ + +struct GTY(()) cgraph_thunk_info { + /* Information about the thunk. */ + HOST_WIDE_INT fixed_offset; + HOST_WIDE_INT virtual_value; + tree alias; + bool this_adjusting; + bool virtual_offset_p; + /* Set to true when alias node is thunk. */ + bool thunk_p; +}; + +/* Information about the function collected locally. + Available after function is analyzed. */ + +struct GTY(()) cgraph_local_info { + /* File stream where this node is being written to. */ + struct lto_file_decl_data * lto_file_data; + + struct inline_summary inline_summary; + + /* Set when function function is visible in current compilation unit only + and its address is never taken. */ + unsigned local : 1; + + /* Set when function is visible by other units. */ + unsigned externally_visible : 1; + + /* Set once it has been finalized so we consider it to be output. */ + unsigned finalized : 1; + + /* False when there something makes inlining impossible (such as va_arg). */ + unsigned inlinable : 1; + + /* False when there something makes versioning impossible. + Currently computed and used only by ipa-cp. */ + unsigned versionable : 1; + + /* False when function calling convention and signature can not be changed. + This is the case when __builtin_apply_args is used. */ + unsigned can_change_signature : 1; + + /* True when function should be inlined independently on its size. */ + unsigned disregard_inline_limits : 1; + + /* True when the function has been originally extern inline, but it is + redefined now. */ + unsigned redefined_extern_inline : 1; + + /* True if the function is going to be emitted in some other translation + unit, referenced from vtable. */ + unsigned vtable_method : 1; +}; + +/* Information about the function that needs to be computed globally + once compilation is finished. Available only with -funit-at-a-time. */ + +struct GTY(()) cgraph_global_info { + /* Estimated stack frame consumption by the function. */ + HOST_WIDE_INT estimated_stack_size; + + /* For inline clones this points to the function they will be + inlined into. */ + struct cgraph_node *inlined_to; + + /* Estimated size of the function after inlining. */ + int time; + int size; + + /* Estimated growth after inlining. INT_MIN if not computed. */ + int estimated_growth; +}; + +/* Information about the function that is propagated by the RTL backend. + Available only for functions that has been already assembled. */ + +struct GTY(()) cgraph_rtl_info { + unsigned int preferred_incoming_stack_boundary; +}; + +/* Represent which DECL tree (or reference to such tree) + will be replaced by another tree while versioning. */ +struct GTY(()) ipa_replace_map +{ + /* The tree that will be replaced. */ + tree old_tree; + /* The new (replacing) tree. */ + tree new_tree; + /* Parameter number to replace, when old_tree is NULL. */ + int parm_num; + /* True when a substitution should be done, false otherwise. */ + bool replace_p; + /* True when we replace a reference to old_tree. */ + bool ref_p; +}; +typedef struct ipa_replace_map *ipa_replace_map_p; +DEF_VEC_P(ipa_replace_map_p); +DEF_VEC_ALLOC_P(ipa_replace_map_p,gc); + +struct GTY(()) cgraph_clone_info +{ + VEC(ipa_replace_map_p,gc)* tree_map; + bitmap args_to_skip; + bitmap combined_args_to_skip; +}; + + +/* The cgraph data structure. + Each function decl has assigned cgraph_node listing callees and callers. */ + +struct GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) cgraph_node { + tree decl; + struct cgraph_edge *callees; + struct cgraph_edge *callers; + struct cgraph_node *next; + struct cgraph_node *previous; + /* List of edges representing indirect calls with a yet undetermined + callee. */ + struct cgraph_edge *indirect_calls; + /* For nested functions points to function the node is nested in. */ + struct cgraph_node *origin; + /* Points to first nested function, if any. */ + struct cgraph_node *nested; + /* Pointer to the next function with same origin, if any. */ + struct cgraph_node *next_nested; + /* Pointer to the next function in cgraph_nodes_queue. */ + struct cgraph_node *next_needed; + /* Pointer to the next clone. */ + struct cgraph_node *next_sibling_clone; + struct cgraph_node *prev_sibling_clone; + struct cgraph_node *clones; + struct cgraph_node *clone_of; + /* For normal nodes pointer to the list of alias and thunk nodes, + in alias/thunk nodes pointer to the normal node. */ + struct cgraph_node *same_body; + /* Circular list of nodes in the same comdat group if non-NULL. */ + struct cgraph_node *same_comdat_group; + /* For functions with many calls sites it holds map from call expression + to the edge to speed up cgraph_edge function. */ + htab_t GTY((param_is (struct cgraph_edge))) call_site_hash; + /* Declaration node used to be clone of. */ + tree former_clone_of; + + PTR GTY ((skip)) aux; + + /* Interprocedural passes scheduled to have their transform functions + applied next time we execute local pass on them. We maintain it + per-function in order to allow IPA passes to introduce new functions. */ + VEC(ipa_opt_pass,heap) * GTY((skip)) ipa_transforms_to_apply; + + struct ipa_ref_list ref_list; + struct cgraph_local_info local; + struct cgraph_global_info global; + struct cgraph_rtl_info rtl; + struct cgraph_clone_info clone; + struct cgraph_thunk_info thunk; + + /* Expected number of executions: calculated in profile.c. */ + gcov_type count; + /* Maximum count of any basic block in the function. */ + gcov_type max_bb_count; + /* How to scale counts at materialization time; used to merge + LTO units with different number of profile runs. */ + int count_materialization_scale; + /* Unique id of the node. */ + int uid; + /* Ordering of all cgraph nodes. */ + int order; + + enum ld_plugin_symbol_resolution resolution; + + /* Set when function must be output for some reason. The primary + use of this flag is to mark functions needed to be output for + non-standard reason. Functions that are externally visible + or reachable from functions needed to be output are marked + by specialized flags. */ + unsigned needed : 1; + /* Set when function has address taken. + In current implementation it imply needed flag. */ + unsigned address_taken : 1; + /* Set when decl is an abstract function pointed to by the + ABSTRACT_DECL_ORIGIN of a reachable function. */ + unsigned abstract_and_needed : 1; + /* Set when function is reachable by call from other function + that is either reachable or needed. + This flag is computed at original cgraph construction and then + updated in cgraph_remove_unreachable_nodes. Note that after + cgraph_remove_unreachable_nodes cgraph still can contain unreachable + nodes when they are needed for virtual clone instantiation. */ + unsigned reachable : 1; + /* Set when function is reachable by call from other LTRANS partition. */ + unsigned reachable_from_other_partition : 1; + /* Set once the function is lowered (i.e. its CFG is built). */ + unsigned lowered : 1; + /* Set once the function has been instantiated and its callee + lists created. */ + unsigned analyzed : 1; + /* Set when function is available in the other LTRANS partition. + During WPA output it is used to mark nodes that are present in + multiple partitions. */ + unsigned in_other_partition : 1; + /* Set when function is scheduled to be processed by local passes. */ + unsigned process : 1; + /* Set for aliases once they got through assemble_alias. */ + unsigned alias : 1; + /* Set for nodes that was constructed and finalized by frontend. */ + unsigned finalized_by_frontend : 1; + /* Is this function cloned during versioning ? */ + unsigned is_versioned_clone : 1; + /* Set for alias and thunk nodes, same_body points to the node they are alias + of and they are linked through the next/previous pointers. */ + unsigned same_body_alias : 1; + /* How commonly executed the node is. Initialized during branch + probabilities pass. */ + ENUM_BITFIELD (node_frequency) frequency : 2; + /* True when function can only be called at startup (from static ctor). */ + unsigned only_called_at_startup : 1; + /* True when function can only be called at startup (from static dtor). */ + unsigned only_called_at_exit : 1; +}; + +typedef struct cgraph_node *cgraph_node_ptr; + +DEF_VEC_P(cgraph_node_ptr); +DEF_VEC_ALLOC_P(cgraph_node_ptr,heap); +DEF_VEC_ALLOC_P(cgraph_node_ptr,gc); + +/* A cgraph node set is a collection of cgraph nodes. A cgraph node + can appear in multiple sets. */ +struct GTY(()) cgraph_node_set_def +{ + htab_t GTY((param_is (struct cgraph_node_set_element_def))) hashtab; + VEC(cgraph_node_ptr, gc) *nodes; +}; + +typedef struct varpool_node *varpool_node_ptr; + +DEF_VEC_P(varpool_node_ptr); +DEF_VEC_ALLOC_P(varpool_node_ptr,heap); +DEF_VEC_ALLOC_P(varpool_node_ptr,gc); + +/* A varpool node set is a collection of varpool nodes. A varpool node + can appear in multiple sets. */ +struct GTY(()) varpool_node_set_def +{ + htab_t GTY((param_is (struct varpool_node_set_element_def))) hashtab; + VEC(varpool_node_ptr, gc) *nodes; +}; + +typedef struct cgraph_node_set_def *cgraph_node_set; + +DEF_VEC_P(cgraph_node_set); +DEF_VEC_ALLOC_P(cgraph_node_set,gc); +DEF_VEC_ALLOC_P(cgraph_node_set,heap); + +typedef struct varpool_node_set_def *varpool_node_set; + +DEF_VEC_P(varpool_node_set); +DEF_VEC_ALLOC_P(varpool_node_set,gc); +DEF_VEC_ALLOC_P(varpool_node_set,heap); + +/* A cgraph node set element contains an index in the vector of nodes in + the set. */ +struct GTY(()) cgraph_node_set_element_def +{ + struct cgraph_node *node; + HOST_WIDE_INT index; +}; + +typedef struct cgraph_node_set_element_def *cgraph_node_set_element; +typedef const struct cgraph_node_set_element_def *const_cgraph_node_set_element; + +/* Iterator structure for cgraph node sets. */ +typedef struct +{ + cgraph_node_set set; + unsigned index; +} cgraph_node_set_iterator; + +/* A varpool node set element contains an index in the vector of nodes in + the set. */ +struct GTY(()) varpool_node_set_element_def +{ + struct varpool_node *node; + HOST_WIDE_INT index; +}; + +typedef struct varpool_node_set_element_def *varpool_node_set_element; +typedef const struct varpool_node_set_element_def *const_varpool_node_set_element; + +/* Iterator structure for varpool node sets. */ +typedef struct +{ + varpool_node_set set; + unsigned index; +} varpool_node_set_iterator; + +#define DEFCIFCODE(code, string) CIF_ ## code, +/* Reasons for inlining failures. */ +typedef enum { +#include "cif-code.def" + CIF_N_REASONS +} cgraph_inline_failed_t; + +/* Structure containing additional information about an indirect call. */ + +struct GTY(()) cgraph_indirect_call_info +{ + /* Offset accumulated from ancestor jump functions of inlined call graph + edges. */ + HOST_WIDE_INT anc_offset; + /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */ + HOST_WIDE_INT otr_token; + /* Delta by which must be added to this parameter to compensate for a skipped + this adjusting thunk. */ + HOST_WIDE_INT thunk_delta; + /* Type of the object from OBJ_TYPE_REF_OBJECT. */ + tree otr_type; + /* Index of the parameter that is called. */ + int param_index; + /* ECF flags determined from the caller. */ + int ecf_flags; + + /* Set when the call is a virtual call with the parameter being the + associated object pointer rather than a simple direct call. */ + unsigned polymorphic : 1; +}; + +struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge { + /* Expected number of executions: calculated in profile.c. */ + gcov_type count; + struct cgraph_node *caller; + struct cgraph_node *callee; + struct cgraph_edge *prev_caller; + struct cgraph_edge *next_caller; + struct cgraph_edge *prev_callee; + struct cgraph_edge *next_callee; + gimple call_stmt; + /* Additional information about an indirect call. Not cleared when an edge + becomes direct. */ + struct cgraph_indirect_call_info *indirect_info; + PTR GTY ((skip (""))) aux; + /* When equal to CIF_OK, inline this call. Otherwise, points to the + explanation why function was not inlined. */ + cgraph_inline_failed_t inline_failed; + /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt + when the function is serialized in. */ + unsigned int lto_stmt_uid; + /* Expected frequency of executions within the function. + When set to CGRAPH_FREQ_BASE, the edge is expected to be called once + per function call. The range is 0 to CGRAPH_FREQ_MAX. */ + int frequency; + /* Unique id of the edge. */ + int uid; + /* Depth of loop nest, 1 means no loop nest. */ + unsigned short int loop_nest; + /* Whether this edge was made direct by indirect inlining. */ + unsigned int indirect_inlining_edge : 1; + /* Whether this edge describes an indirect call with an undetermined + callee. */ + unsigned int indirect_unknown_callee : 1; + /* Whether this edge is still a dangling */ + /* True if the corresponding CALL stmt cannot be inlined. */ + unsigned int call_stmt_cannot_inline_p : 1; + /* Can this call throw externally? */ + unsigned int can_throw_external : 1; +}; + +#define CGRAPH_FREQ_BASE 1000 +#define CGRAPH_FREQ_MAX 100000 + +typedef struct cgraph_edge *cgraph_edge_p; + +DEF_VEC_P(cgraph_edge_p); +DEF_VEC_ALLOC_P(cgraph_edge_p,heap); + +/* The varpool data structure. + Each static variable decl has assigned varpool_node. */ + +struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) varpool_node { + tree decl; + /* Pointer to the next function in varpool_nodes. */ + struct varpool_node *next, *prev; + /* Pointer to the next function in varpool_nodes_queue. */ + struct varpool_node *next_needed, *prev_needed; + /* For normal nodes a pointer to the first extra name alias. For alias + nodes a pointer to the normal node. */ + struct varpool_node *extra_name; + /* Circular list of nodes in the same comdat group if non-NULL. */ + struct varpool_node *same_comdat_group; + struct ipa_ref_list ref_list; + /* File stream where this node is being written to. */ + struct lto_file_decl_data * lto_file_data; + PTR GTY ((skip)) aux; + /* Ordering of all cgraph nodes. */ + int order; + enum ld_plugin_symbol_resolution resolution; + + /* The module in which it is first declared. */ + unsigned module_id; + /* Set when function must be output - it is externally visible + or its address is taken. */ + unsigned needed : 1; + /* Needed variables might become dead by optimization. This flag + forces the variable to be output even if it appears dead otherwise. */ + unsigned force_output : 1; + /* Set once the variable has been instantiated and its callee + lists created. */ + unsigned analyzed : 1; + /* Set once it has been finalized so we consider it to be output. */ + unsigned finalized : 1; + /* Set when variable is scheduled to be assembled. */ + unsigned output : 1; + /* Set when function is visible by other units. */ + unsigned externally_visible : 1; + /* Set for aliases once they got through assemble_alias. Also set for + extra name aliases in varpool_extra_name_alias. */ + unsigned alias : 1; + /* Set when variable is used from other LTRANS partition. */ + unsigned used_from_other_partition : 1; + /* Set when variable is available in the other LTRANS partition. + During WPA output it is used to mark nodes that are present in + multiple partitions. */ + unsigned in_other_partition : 1; +}; + +/* Every top level asm statement is put into a cgraph_asm_node. */ + +struct GTY(()) cgraph_asm_node { + /* Next asm node. */ + struct cgraph_asm_node *next; + /* String for this asm node. */ + tree asm_str; + /* Ordering of all cgraph nodes. */ + int order; +}; + +extern GTY(()) struct cgraph_node *cgraph_nodes; +extern GTY(()) int cgraph_n_nodes; +extern GTY(()) int cgraph_max_uid; +extern GTY(()) int cgraph_edge_max_uid; +extern bool cgraph_global_info_ready; +enum cgraph_state +{ + /* Callgraph is being constructed. It is safe to add new functions. */ + CGRAPH_STATE_CONSTRUCTION, + /* Callgraph is built and IPA passes are being run. */ + CGRAPH_STATE_IPA, + /* Callgraph is built and all functions are transformed to SSA form. */ + CGRAPH_STATE_IPA_SSA, + /* Functions are now ordered and being passed to RTL expanders. */ + CGRAPH_STATE_EXPANSION, + /* All cgraph expansion is done. */ + CGRAPH_STATE_FINISHED +}; +extern enum cgraph_state cgraph_state; +extern bool cgraph_function_flags_ready; +extern GTY(()) struct cgraph_node *cgraph_nodes_queue; +extern GTY(()) struct cgraph_node *cgraph_new_nodes; + +extern GTY(()) struct cgraph_asm_node *cgraph_asm_nodes; +extern GTY(()) int cgraph_order; + +/* In cgraph.c */ +void dump_cgraph (FILE *); +void debug_cgraph (void); +void dump_cgraph_node (FILE *, struct cgraph_node *); +void debug_cgraph_node (struct cgraph_node *); +void cgraph_insert_node_to_hashtable (struct cgraph_node *node); +void cgraph_remove_edge (struct cgraph_edge *); +void cgraph_remove_node (struct cgraph_node *); +void cgraph_add_assembler_hash_node (struct cgraph_node *); +void cgraph_remove_assembler_hash_node (struct cgraph_node *); +void cgraph_remove_fake_indirect_call_in_edges (struct cgraph_node *); +extern bool cgraph_pre_profiling_inlining_done; +extern bool cgraph_is_fake_indirect_call_edge (struct cgraph_edge *e); +void cgraph_remove_node_and_inline_clones (struct cgraph_node *); +void cgraph_release_function_body (struct cgraph_node *); +void cgraph_node_remove_callees (struct cgraph_node *node); +struct cgraph_edge *cgraph_create_edge (struct cgraph_node *, + struct cgraph_node *, + gimple, gcov_type, int, int); +struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple, + int, gcov_type, int, int); +struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void); +struct cgraph_node * cgraph_get_node (const_tree); +struct cgraph_node * cgraph_get_node_or_alias (const_tree); +struct cgraph_node * cgraph_node (tree); +struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree); +struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT, + HOST_WIDE_INT, tree, tree); +void cgraph_remove_same_body_alias (struct cgraph_node *); +struct cgraph_node *cgraph_node_for_asm (tree); +struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple); +void cgraph_set_call_stmt (struct cgraph_edge *, gimple); +void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple, gimple); +void cgraph_create_edge_including_clones (struct cgraph_node *, + struct cgraph_node *, + gimple, gimple, gcov_type, int, int, + cgraph_inline_failed_t); +void cgraph_update_edges_for_call_stmt (gimple, tree, gimple); +struct cgraph_local_info *cgraph_local_info (tree); +struct cgraph_global_info *cgraph_global_info (tree); +struct cgraph_rtl_info *cgraph_rtl_info (tree); +const char * cgraph_node_name (struct cgraph_node *); +struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *, + struct cgraph_node *, gimple, + unsigned, gcov_type, int, int, bool); +struct cgraph_node * cgraph_clone_node (struct cgraph_node *, tree, gcov_type, int, + int, bool, VEC(cgraph_edge_p,heap) *); + +void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *); +void cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *, + HOST_WIDE_INT); + +struct cgraph_asm_node *cgraph_add_asm_node (tree); + +bool cgraph_function_possibly_inlined_p (tree); +void cgraph_unnest_node (struct cgraph_node *); + +enum availability cgraph_function_body_availability (struct cgraph_node *); +void cgraph_add_new_function (tree, bool); +const char* cgraph_inline_failed_string (cgraph_inline_failed_t); +struct cgraph_node * cgraph_create_virtual_clone (struct cgraph_node *old_node, + VEC(cgraph_edge_p,heap)*, + VEC(ipa_replace_map_p,gc)* tree_map, + bitmap args_to_skip, + const char *clone_name); + +void cgraph_set_nothrow_flag (struct cgraph_node *, bool); +void cgraph_set_const_flag (struct cgraph_node *, bool, bool); +void cgraph_set_pure_flag (struct cgraph_node *, bool, bool); +tree clone_function_name (tree decl, const char *); +bool cgraph_node_cannot_return (struct cgraph_node *); +bool cgraph_edge_cannot_lead_to_return (struct cgraph_edge *); +bool cgraph_will_be_removed_from_program_if_no_direct_calls + (struct cgraph_node *node); +bool cgraph_can_remove_if_no_direct_calls_and_refs_p + (struct cgraph_node *node); +bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution); +bool cgraph_used_from_object_file_p (struct cgraph_node *node); +bool varpool_used_from_object_file_p (struct varpool_node *node); + +/* In cgraphunit.c */ +extern FILE *cgraph_dump_file; +void cgraph_finalize_function (tree, bool); +void cgraph_mark_if_needed (tree); +void cgraph_finalize_compilation_unit (void); +void cgraph_optimize (void); +void cgraph_mark_needed_node (struct cgraph_node *); +void cgraph_mark_address_taken_node (struct cgraph_node *); +void cgraph_mark_reachable_node (struct cgraph_node *); +bool cgraph_inline_p (struct cgraph_edge *, cgraph_inline_failed_t *reason); +bool cgraph_preserve_function_body_p (tree); +void verify_cgraph (void); +void verify_cgraph_node (struct cgraph_node *); +void cgraph_build_static_cdtor (char which, tree body, int priority); +void cgraph_reset_static_var_maps (void); +void init_cgraph (void); +struct cgraph_node *cgraph_function_versioning (struct cgraph_node *, + VEC(cgraph_edge_p,heap)*, + VEC(ipa_replace_map_p,gc)*, + bitmap, bitmap, basic_block, + const char *); +void tree_function_versioning (tree, tree, VEC (ipa_replace_map_p,gc)*, bool, bitmap, + bitmap, basic_block); +struct cgraph_node *save_inline_function_body (struct cgraph_node *); +void record_references_in_initializer (tree, bool); +bool cgraph_process_new_functions (void); + +/* Module info structure. */ +struct GTY (()) cgraph_mod_info +{ + unsigned module_id; +}; + +/* LIPO linker symbol table entry for function symbols. */ +struct GTY (()) cgraph_sym +{ + tree assembler_name; + struct cgraph_node *rep_node; + tree rep_decl; + htab_t GTY ((param_is (struct cgraph_mod_info))) def_module_hash; + bool is_promoted_static; +}; + +void cgraph_init_gid_map (void); +void cgraph_add_fake_indirect_call_edges (void); +void cgraph_remove_zero_count_fake_edges (void); +void cgraph_do_link (void); +struct cgraph_sym *cgraph_link_node (struct cgraph_node *); +tree cgraph_find_decl (tree asm_name); +void cgraph_remove_link_node (struct cgraph_node *node); +struct cgraph_node *cgraph_lipo_get_resolved_node (tree decl); +struct cgraph_node *cgraph_lipo_get_resolved_node_1 (tree decl, bool); +unsigned cgraph_get_module_id (tree fndecl); +bool cgraph_is_auxiliary (tree fndecl); +void cgraph_process_module_scope_statics (void); +bool cgraph_is_promoted_static_func (tree fndecl); +bool cgraph_is_inline_body_available_in_module (tree fndecl, unsigned module_id); +bool cgraph_is_aux_decl_external (struct cgraph_node *); +void cgraph_unify_type_alias_sets (void); +void varpool_do_link (void); +void varpool_link_node (struct varpool_node *); +void varpool_remove_link_node (struct varpool_node *node); +struct varpool_node *real_varpool_node (tree decl); +bool varpool_is_auxiliary (struct varpool_node *node); +void varpool_get_referenced_asm_ids (VEC(tree, gc) **); +void varpool_clear_asm_id_reference_bit (void); +void varpool_reset_queue (void); +void varpool_remove_duplicate_weak_decls (void); + +bool cgraph_decide_is_function_needed (struct cgraph_node *, tree); + +typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *); +typedef void (*cgraph_node_hook)(struct cgraph_node *, void *); +typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *, + void *); +typedef void (*cgraph_2node_hook)(struct cgraph_node *, struct cgraph_node *, + void *); +struct cgraph_edge_hook_list; +struct cgraph_node_hook_list; +struct cgraph_2edge_hook_list; +struct cgraph_2node_hook_list; +struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *); +void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *); +struct cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook, + void *); +void cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *); +struct cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook, + void *); +void cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *); +void cgraph_call_function_insertion_hooks (struct cgraph_node *node); +struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *); +void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *); +struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *); +void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *); +void cgraph_materialize_all_clones (void); +gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *); +bool cgraph_propagate_frequency (struct cgraph_node *node); +/* In cgraphbuild.c */ +unsigned int rebuild_cgraph_edges (void); +void cgraph_rebuild_references (void); +void reset_inline_failed (struct cgraph_node *); +int compute_call_stmt_bb_frequency (tree, basic_block bb); + +/* In ipa.c */ +bool cgraph_remove_unreachable_nodes (bool, FILE *); +int cgraph_postorder (struct cgraph_node **); +cgraph_node_set cgraph_node_set_new (void); +cgraph_node_set_iterator cgraph_node_set_find (cgraph_node_set, + struct cgraph_node *); +void cgraph_node_set_add (cgraph_node_set, struct cgraph_node *); +void cgraph_node_set_remove (cgraph_node_set, struct cgraph_node *); +void dump_cgraph_node_set (FILE *, cgraph_node_set); +void debug_cgraph_node_set (cgraph_node_set); + +varpool_node_set varpool_node_set_new (void); +varpool_node_set_iterator varpool_node_set_find (varpool_node_set, + struct varpool_node *); +void varpool_node_set_add (varpool_node_set, struct varpool_node *); +void varpool_node_set_remove (varpool_node_set, struct varpool_node *); +void dump_varpool_node_set (FILE *, varpool_node_set); +void debug_varpool_node_set (varpool_node_set); +void ipa_discover_readonly_nonaddressable_vars (void); +bool cgraph_comdat_can_be_unshared_p (struct cgraph_node *); + +/* In predict.c */ +bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e); + +/* In varpool.c */ +extern GTY(()) struct varpool_node *varpool_nodes_queue; +extern GTY(()) struct varpool_node *varpool_nodes; + +struct varpool_node *varpool_node (tree); +struct varpool_node *varpool_node_for_asm (tree asmname); +void varpool_mark_needed_node (struct varpool_node *); +void debug_varpool (void); +void dump_varpool (FILE *); +void dump_varpool_node (FILE *, struct varpool_node *); + +void varpool_finalize_decl (tree); +bool decide_is_variable_needed (struct varpool_node *, tree); +enum availability cgraph_variable_initializer_availability (struct varpool_node *); +void cgraph_make_decl_local (tree); +void cgraph_make_node_local (struct cgraph_node *); +bool cgraph_node_can_be_local_p (struct cgraph_node *); + + +struct varpool_node * varpool_get_node (const_tree decl); +void varpool_remove_node (struct varpool_node *node); +void varpool_finalize_named_section_flags (struct varpool_node *node); +bool varpool_assemble_pending_decls (void); +bool varpool_assemble_decl (struct varpool_node *node); +bool varpool_analyze_pending_decls (void); +void varpool_remove_unreferenced_decls (void); +void varpool_empty_needed_queue (void); +struct varpool_node * varpool_extra_name_alias (tree, tree); +const char * varpool_node_name (struct varpool_node *node); +void varpool_reset_queue (void); +bool const_value_known_p (tree); + +/* Walk all reachable static variables. */ +#define FOR_EACH_STATIC_VARIABLE(node) \ + for ((node) = varpool_nodes_queue; (node); (node) = (node)->next_needed) + +/* Return first reachable static variable with initializer. */ +static inline struct varpool_node * +varpool_first_static_initializer (void) +{ + struct varpool_node *node; + for (node = varpool_nodes_queue; node; node = node->next_needed) + { + gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL); + if (DECL_INITIAL (node->decl)) + return node; + } + return NULL; +} + +/* Return next reachable static variable with initializer after NODE. */ +static inline struct varpool_node * +varpool_next_static_initializer (struct varpool_node *node) +{ + for (node = node->next_needed; node; node = node->next_needed) + { + gcc_checking_assert (TREE_CODE (node->decl) == VAR_DECL); + if (DECL_INITIAL (node->decl)) + return node; + } + return NULL; +} + +/* Walk all static variables with initializer set. */ +#define FOR_EACH_STATIC_INITIALIZER(node) \ + for ((node) = varpool_first_static_initializer (); (node); \ + (node) = varpool_next_static_initializer (node)) + +/* In ipa-inline.c */ +void cgraph_clone_inlined_nodes (struct cgraph_edge *, bool, bool); +void compute_inline_parameters (struct cgraph_node *); + +/* Create a new static variable of type TYPE. */ +tree add_new_static_var (tree type); + +/* Return true if iterator CSI points to nothing. */ +static inline bool +csi_end_p (cgraph_node_set_iterator csi) +{ + return csi.index >= VEC_length (cgraph_node_ptr, csi.set->nodes); +} + +/* Advance iterator CSI. */ +static inline void +csi_next (cgraph_node_set_iterator *csi) +{ + csi->index++; +} + +/* Return the node pointed to by CSI. */ +static inline struct cgraph_node * +csi_node (cgraph_node_set_iterator csi) +{ + return VEC_index (cgraph_node_ptr, csi.set->nodes, csi.index); +} + +/* Return an iterator to the first node in SET. */ +static inline cgraph_node_set_iterator +csi_start (cgraph_node_set set) +{ + cgraph_node_set_iterator csi; + + csi.set = set; + csi.index = 0; + return csi; +} + +/* Return true if SET contains NODE. */ +static inline bool +cgraph_node_in_set_p (struct cgraph_node *node, cgraph_node_set set) +{ + cgraph_node_set_iterator csi; + csi = cgraph_node_set_find (set, node); + return !csi_end_p (csi); +} + +/* Return number of nodes in SET. */ +static inline size_t +cgraph_node_set_size (cgraph_node_set set) +{ + return htab_elements (set->hashtab); +} + +/* Return true if iterator VSI points to nothing. */ +static inline bool +vsi_end_p (varpool_node_set_iterator vsi) +{ + return vsi.index >= VEC_length (varpool_node_ptr, vsi.set->nodes); +} + +/* Advance iterator VSI. */ +static inline void +vsi_next (varpool_node_set_iterator *vsi) +{ + vsi->index++; +} + +/* Return the node pointed to by VSI. */ +static inline struct varpool_node * +vsi_node (varpool_node_set_iterator vsi) +{ + return VEC_index (varpool_node_ptr, vsi.set->nodes, vsi.index); +} + +/* Return an iterator to the first node in SET. */ +static inline varpool_node_set_iterator +vsi_start (varpool_node_set set) +{ + varpool_node_set_iterator vsi; + + vsi.set = set; + vsi.index = 0; + return vsi; +} + +/* Return true if SET contains NODE. */ +static inline bool +varpool_node_in_set_p (struct varpool_node *node, varpool_node_set set) +{ + varpool_node_set_iterator vsi; + vsi = varpool_node_set_find (set, node); + return !vsi_end_p (vsi); +} + +/* Return number of nodes in SET. */ +static inline size_t +varpool_node_set_size (varpool_node_set set) +{ + return htab_elements (set->hashtab); +} + +/* Uniquize all constants that appear in memory. + Each constant in memory thus far output is recorded + in `const_desc_table'. */ + +struct GTY(()) constant_descriptor_tree { + /* A MEM for the constant. */ + rtx rtl; + + /* The value of the constant. */ + tree value; + + /* Hash of value. Computing the hash from value each time + hashfn is called can't work properly, as that means recursive + use of the hash table during hash table expansion. */ + hashval_t hash; +}; + +/* Return true if set is nonempty. */ +static inline bool +cgraph_node_set_nonempty_p (cgraph_node_set set) +{ + return !VEC_empty (cgraph_node_ptr, set->nodes); +} + +/* Return true if set is nonempty. */ +static inline bool +varpool_node_set_nonempty_p (varpool_node_set set) +{ + return !VEC_empty (varpool_node_ptr, set->nodes); +} + +/* Return true when function NODE is only called directly. + i.e. it is not externally visible, address was not taken and + it is not used in any other non-standard way. */ + +static inline bool +cgraph_only_called_directly_p (struct cgraph_node *node) +{ + gcc_assert (!node->global.inlined_to); + return (!node->needed && !node->address_taken + && !node->reachable_from_other_partition + && !DECL_STATIC_CONSTRUCTOR (node->decl) + && !DECL_STATIC_DESTRUCTOR (node->decl) + && !node->local.externally_visible); +} + +/* Return true when function NODE can be removed from callgraph + if all direct calls are eliminated. */ + +static inline bool +cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node) +{ + /* Extern inlines can always go, we will use the external definition. */ + if (DECL_EXTERNAL (node->decl)) + return true; + return !node->address_taken && cgraph_can_remove_if_no_direct_calls_and_refs_p (node); +} + +/* Return true when function NODE can be removed from callgraph + if all direct calls are eliminated. */ + +static inline bool +varpool_can_remove_if_no_refs (struct varpool_node *node) +{ + return (!node->force_output && !node->used_from_other_partition + && (flag_toplevel_reorder || DECL_COMDAT (node->decl) + || DECL_ARTIFICIAL (node->decl)) + && (DECL_COMDAT (node->decl) || !node->externally_visible)); +} + +/* Return true when all references to VNODE must be visible in ipa_ref_list. + i.e. if the variable is not externally visible or not used in some magic + way (asm statement or such). + The magic uses are all summarized in force_output flag. */ + +static inline bool +varpool_all_refs_explicit_p (struct varpool_node *vnode) +{ + return (!vnode->externally_visible + && !vnode->used_from_other_partition + && !vnode->force_output); +} + +/* Constant pool accessor function. */ +htab_t constant_pool_htab (void); + +/* FIXME: inappropriate dependency of cgraph on IPA. */ +#include "ipa-ref-inline.h" + +#endif /* GCC_CGRAPH_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cif-code.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cif-code.def new file mode 100644 index 0000000..7d1bbe8 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cif-code.def @@ -0,0 +1,100 @@ +/* This file contains the definitions of the cgraph_inline_failed_t + enums used in GCC. + + Copyright (C) 2008, 2010 Free Software Foundation, Inc. + Contributed by Doug Kwan <dougkwan@google.com> + +This file is part of GCC. + +GCC is free software you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* The format of this file is + DEFCIFCODE(code, string). + + Where symbol is the enumeration name without the ``''. + The argument STRING is a explain the failure. Except for OK, + which is a NULL pointer. */ + +/* Inlining successful. This must be the first code. */ +DEFCIFCODE(OK , NULL) + +/* Inlining failed for an unspecified reason. */ +DEFCIFCODE(UNSPECIFIED , "") + +/* Function has not be considered for inlining. This is the code for + functions that have not been rejected for inlining yet. */ +DEFCIFCODE(FUNCTION_NOT_CONSIDERED, + N_("function not considered for inlining")) + +/* Inlining failed owing to unavailable function body. */ +DEFCIFCODE(BODY_NOT_AVAILABLE, N_("function body not available")) + +DEFCIFCODE(REDEFINED_EXTERN_INLINE, + N_("redefined extern inline functions are not considered for " + "inlining")) + +/* Function is not inlinable. */ +DEFCIFCODE(FUNCTION_NOT_INLINABLE, N_("function not inlinable")) + +/* Function is not an inlining candidate. */ +DEFCIFCODE(FUNCTION_NOT_INLINE_CANDIDATE, N_("function not inline candidate")) + +/* Inlining failed because of various limit parameters. */ +DEFCIFCODE(LARGE_FUNCTION_GROWTH_LIMIT, + N_("--param large-function-growth limit reached")) +DEFCIFCODE(LARGE_STACK_FRAME_GROWTH_LIMIT, + N_("--param large-stack-frame-growth limit reached")) +DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_LIMIT, + N_("--param max-inline-insns-single limit reached")) +DEFCIFCODE(MAX_INLINE_INSNS_AUTO_LIMIT, + N_("--param max-inline-insns-auto limit reached")) +DEFCIFCODE(INLINE_UNIT_GROWTH_LIMIT, + N_("--param inline-unit-growth limit reached")) + +/* Recursive inlining. */ +DEFCIFCODE(RECURSIVE_INLINING, N_("recursive inlining")) + +/* Call is unlikely. */ +DEFCIFCODE(UNLIKELY_CALL, N_("call is unlikely and code size would grow")) + +/* Function is not declared as an inline. */ +DEFCIFCODE(NOT_DECLARED_INLINED, + N_("function not declared inline and code size would grow")) + +/* Inlining suppressed due to size optimization. */ +DEFCIFCODE(OPTIMIZING_FOR_SIZE, + N_("optimizing for size and code size would grow")) + +/* Inlining failed because of mismatched options or arguments. */ +DEFCIFCODE(TARGET_OPTION_MISMATCH, N_("target specific option mismatch")) +DEFCIFCODE(MISMATCHED_ARGUMENTS, N_("mismatched arguments")) + +/* Call was originally indirect. */ +DEFCIFCODE(ORIGINALLY_INDIRECT_CALL, + N_("originally indirect function call not considered for inlining")) + +/* Cross module inlining not allowed in first early inline phase. */ +DEFCIFCODE(NO_INTERMODULE_INLINE, + N_("inter-module inlining is disabled")) + +/* Artificial edge. */ +DEFCIFCODE(ARTIFICIAL_EDGE, + N_("artificial call graph edge")) + +/* Ths edge represents an indirect edge with a yet-undetermined callee . */ +DEFCIFCODE(INDIRECT_UNKNOWN_CALL, + N_("indirect function call with a yet undetermined callee")) + +DEFCIFCODE(OVERWRITABLE, N_("function body can be overwriten at linktime")) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config.h new file mode 100644 index 0000000..aa6dd6b --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config.h @@ -0,0 +1,10 @@ +#ifndef GCC_CONFIG_H +#define GCC_CONFIG_H +#ifdef GENERATOR_FILE +#error config.h is for the host, not build, machine. +#endif +#include "auto-host.h" +#ifdef IN_GCC +# include "ansidecl.h" +#endif +#endif /* GCC_CONFIG_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/aout.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/aout.h new file mode 100644 index 0000000..f8e7367 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/aout.h @@ -0,0 +1,380 @@ +/* Definitions of target machine for GNU compiler, for ARM with a.out + Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2004, 2007, 2008, 2010 + Free Software Foundation, Inc. + Contributed by Richard Earnshaw (rearnsha@armltd.co.uk). + + 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/>. */ + +#ifndef ASM_APP_ON +#define ASM_APP_ON "" +#endif +#ifndef ASM_APP_OFF +#define ASM_APP_OFF "" +#endif + +/* Switch to the text or data segment. */ +#define TEXT_SECTION_ASM_OP "\t.text" +#define DATA_SECTION_ASM_OP "\t.data" +#define BSS_SECTION_ASM_OP "\t.bss" + +/* Note: If USER_LABEL_PREFIX or LOCAL_LABEL_PREFIX are changed, + make sure that this change is reflected in the function + coff_arm_is_local_label_name() in bfd/coff-arm.c. */ +#ifndef REGISTER_PREFIX +#define REGISTER_PREFIX "" +#endif + +#ifndef USER_LABEL_PREFIX +#define USER_LABEL_PREFIX "_" +#endif + +#ifndef LOCAL_LABEL_PREFIX +#define LOCAL_LABEL_PREFIX "" +#endif + +/* The assembler's names for the registers. Note that the ?xx registers are + there so that VFPv3/NEON registers D16-D31 have the same spacing as D0-D15 + (each of which is overlaid on two S registers), although there are no + actual single-precision registers which correspond to D16-D31. */ +#ifndef REGISTER_NAMES +#define REGISTER_NAMES \ +{ \ + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ + "r8", "r9", "sl", "fp", "ip", "sp", "lr", "pc", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "cc", "sfp", "afp", \ + "mv0", "mv1", "mv2", "mv3", \ + "mv4", "mv5", "mv6", "mv7", \ + "mv8", "mv9", "mv10", "mv11", \ + "mv12", "mv13", "mv14", "mv15", \ + "wcgr0", "wcgr1", "wcgr2", "wcgr3", \ + "wr0", "wr1", "wr2", "wr3", \ + "wr4", "wr5", "wr6", "wr7", \ + "wr8", "wr9", "wr10", "wr11", \ + "wr12", "wr13", "wr14", "wr15", \ + "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", \ + "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15", \ + "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23", \ + "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", \ + "d16", "?16", "d17", "?17", "d18", "?18", "d19", "?19", \ + "d20", "?20", "d21", "?21", "d22", "?22", "d23", "?23", \ + "d24", "?24", "d25", "?25", "d26", "?26", "d27", "?27", \ + "d28", "?28", "d29", "?29", "d30", "?30", "d31", "?31", \ + "vfpcc" \ +} +#endif + +#ifndef ADDITIONAL_REGISTER_NAMES +#define ADDITIONAL_REGISTER_NAMES \ +{ \ + {"a1", 0}, \ + {"a2", 1}, \ + {"a3", 2}, \ + {"a4", 3}, \ + {"v1", 4}, \ + {"v2", 5}, \ + {"v3", 6}, \ + {"v4", 7}, \ + {"v5", 8}, \ + {"v6", 9}, \ + {"rfp", 9}, /* Gcc used to call it this */ \ + {"sb", 9}, \ + {"v7", 10}, \ + {"r10", 10}, /* sl */ \ + {"r11", 11}, /* fp */ \ + {"r12", 12}, /* ip */ \ + {"r13", 13}, /* sp */ \ + {"r14", 14}, /* lr */ \ + {"r15", 15}, /* pc */ \ + {"mvf0", 27}, \ + {"mvf1", 28}, \ + {"mvf2", 29}, \ + {"mvf3", 30}, \ + {"mvf4", 31}, \ + {"mvf5", 32}, \ + {"mvf6", 33}, \ + {"mvf7", 34}, \ + {"mvf8", 35}, \ + {"mvf9", 36}, \ + {"mvf10", 37}, \ + {"mvf11", 38}, \ + {"mvf12", 39}, \ + {"mvf13", 40}, \ + {"mvf14", 41}, \ + {"mvf15", 42}, \ + {"mvd0", 27}, \ + {"mvd1", 28}, \ + {"mvd2", 29}, \ + {"mvd3", 30}, \ + {"mvd4", 31}, \ + {"mvd5", 32}, \ + {"mvd6", 33}, \ + {"mvd7", 34}, \ + {"mvd8", 35}, \ + {"mvd9", 36}, \ + {"mvd10", 37}, \ + {"mvd11", 38}, \ + {"mvd12", 39}, \ + {"mvd13", 40}, \ + {"mvd14", 41}, \ + {"mvd15", 42}, \ + {"mvfx0", 27}, \ + {"mvfx1", 28}, \ + {"mvfx2", 29}, \ + {"mvfx3", 30}, \ + {"mvfx4", 31}, \ + {"mvfx5", 32}, \ + {"mvfx6", 33}, \ + {"mvfx7", 34}, \ + {"mvfx8", 35}, \ + {"mvfx9", 36}, \ + {"mvfx10", 37}, \ + {"mvfx11", 38}, \ + {"mvfx12", 39}, \ + {"mvfx13", 40}, \ + {"mvfx14", 41}, \ + {"mvfx15", 42}, \ + {"mvdx0", 27}, \ + {"mvdx1", 28}, \ + {"mvdx2", 29}, \ + {"mvdx3", 30}, \ + {"mvdx4", 31}, \ + {"mvdx5", 32}, \ + {"mvdx6", 33}, \ + {"mvdx7", 34}, \ + {"mvdx8", 35}, \ + {"mvdx9", 36}, \ + {"mvdx10", 37}, \ + {"mvdx11", 38}, \ + {"mvdx12", 39}, \ + {"mvdx13", 40}, \ + {"mvdx14", 41}, \ + {"mvdx15", 42} \ +} +#endif + +#ifndef OVERLAPPING_REGISTER_NAMES +#define OVERLAPPING_REGISTER_NAMES \ +{ \ + {"d0", 63, 2}, \ + {"d1", 65, 2}, \ + {"d2", 67, 2}, \ + {"d3", 69, 2}, \ + {"d4", 71, 2}, \ + {"d5", 73, 2}, \ + {"d6", 75, 2}, \ + {"d7", 77, 2}, \ + {"d8", 79, 2}, \ + {"d9", 81, 2}, \ + {"d10", 83, 2}, \ + {"d11", 85, 2}, \ + {"d12", 87, 2}, \ + {"d13", 89, 2}, \ + {"d14", 91, 2}, \ + {"d15", 93, 2}, \ + {"q0", 63, 4}, \ + {"q1", 67, 4}, \ + {"q2", 71, 4}, \ + {"q3", 75, 4}, \ + {"q4", 79, 4}, \ + {"q5", 83, 4}, \ + {"q6", 87, 4}, \ + {"q7", 91, 4}, \ + {"q8", 95, 4}, \ + {"q9", 99, 4}, \ + {"q10", 103, 4}, \ + {"q11", 107, 4}, \ + {"q12", 111, 4}, \ + {"q13", 115, 4}, \ + {"q14", 119, 4}, \ + {"q15", 123, 4} \ +} +#endif + +#ifndef NO_DOLLAR_IN_LABEL +#define NO_DOLLAR_IN_LABEL 1 +#endif + +/* Generate DBX debugging information. riscix.h will undefine this because + the native assembler does not support stabs. */ +#define DBX_DEBUGGING_INFO 1 + +/* Acorn dbx moans about continuation chars, so don't use any. */ +#ifndef DBX_CONTIN_LENGTH +#define DBX_CONTIN_LENGTH 0 +#endif + +/* Output a function label definition. */ +#ifndef ASM_DECLARE_FUNCTION_NAME +#define ASM_DECLARE_FUNCTION_NAME(STREAM, NAME, DECL) \ + do \ + { \ + ARM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL); \ + ASM_OUTPUT_LABEL (STREAM, NAME); \ + } \ + while (0) +#endif + +/* Globalizing directive for a label. */ +#define GLOBAL_ASM_OP "\t.global\t" + +/* Make an internal label into a string. */ +#ifndef ASM_GENERATE_INTERNAL_LABEL +#define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM) \ + sprintf (STRING, "*%s%s%u", LOCAL_LABEL_PREFIX, PREFIX, (unsigned int)(NUM)) +#endif + +/* Output an element of a dispatch table. */ +#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \ + do \ + { \ + gcc_assert (!TARGET_THUMB2); \ + asm_fprintf (STREAM, "\t.word\t%LL%d\n", VALUE); \ + } \ + while (0) + + +/* Thumb-2 always uses addr_diff_elf so that the Table Branch instructions + can be used. For non-pic code where the offsets do not suitable for + TBB/TBH the elements are output as absolute labels. */ +#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \ + do \ + { \ + if (TARGET_ARM) \ + asm_fprintf (STREAM, "\tb\t%LL%d\n", VALUE); \ + else if (TARGET_THUMB1) \ + { \ + if (flag_pic || optimize_size) \ + { \ + switch (GET_MODE(body)) \ + { \ + case QImode: \ + asm_fprintf (STREAM, "\t.byte\t(%LL%d-%LL%d)/2\n", \ + VALUE, REL); \ + break; \ + case HImode: /* TBH */ \ + asm_fprintf (STREAM, "\t.2byte\t(%LL%d-%LL%d)/2\n", \ + VALUE, REL); \ + break; \ + case SImode: \ + asm_fprintf (STREAM, "\t.word\t%LL%d-%LL%d\n", \ + VALUE, REL); \ + break; \ + default: \ + gcc_unreachable(); \ + } \ + } \ + else \ + asm_fprintf (STREAM, "\t.word\t%LL%d+1\n", VALUE); \ + } \ + else /* Thumb-2 */ \ + { \ + switch (GET_MODE(body)) \ + { \ + case QImode: /* TBB */ \ + asm_fprintf (STREAM, "\t.byte\t(%LL%d-%LL%d)/2\n", \ + VALUE, REL); \ + break; \ + case HImode: /* TBH */ \ + asm_fprintf (STREAM, "\t.2byte\t(%LL%d-%LL%d)/2\n", \ + VALUE, REL); \ + break; \ + case SImode: \ + if (flag_pic) \ + asm_fprintf (STREAM, "\t.word\t%LL%d+1-%LL%d\n", VALUE, REL); \ + else \ + asm_fprintf (STREAM, "\t.word\t%LL%d+1\n", VALUE); \ + break; \ + default: \ + gcc_unreachable(); \ + } \ + } \ + } \ + while (0) + + +#undef ASM_OUTPUT_ASCII +#define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) \ + output_ascii_pseudo_op (STREAM, (const unsigned char *) (PTR), LEN) + +/* Output a gap. In fact we fill it with nulls. */ +#undef ASM_OUTPUT_SKIP +#define ASM_OUTPUT_SKIP(STREAM, NBYTES) \ + fprintf (STREAM, "\t.space\t%d\n", (int) (NBYTES)) + +/* Align output to a power of two. Horrible /bin/as. */ +#ifndef ASM_OUTPUT_ALIGN +#define ASM_OUTPUT_ALIGN(STREAM, POWER) \ + do \ + { \ + register int amount = 1 << (POWER); \ + \ + if (amount == 2) \ + fprintf (STREAM, "\t.even\n"); \ + else if (amount != 1) \ + fprintf (STREAM, "\t.align\t%d\n", amount - 4); \ + } \ + while (0) +#endif + +/* Output a common block. */ +#ifndef ASM_OUTPUT_COMMON +#define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \ + do \ + { \ + fprintf (STREAM, "\t.comm\t"); \ + assemble_name (STREAM, NAME); \ + asm_fprintf (STREAM, ", %d\t%@ %d\n", \ + (int)(ROUNDED), (int)(SIZE)); \ + } \ + while (0) +#endif + +/* Output a local common block. /bin/as can't do this, so hack a + `.space' into the bss segment. Note that this is *bad* practice, + which is guaranteed NOT to work since it doesn't define STATIC + COMMON space but merely STATIC BSS space. */ +#ifndef ASM_OUTPUT_ALIGNED_LOCAL +#define ASM_OUTPUT_ALIGNED_LOCAL(STREAM, NAME, SIZE, ALIGN) \ + do \ + { \ + switch_to_section (bss_section); \ + ASM_OUTPUT_ALIGN (STREAM, floor_log2 (ALIGN / BITS_PER_UNIT)); \ + ASM_OUTPUT_LABEL (STREAM, NAME); \ + fprintf (STREAM, "\t.space\t%d\n", (int)(SIZE)); \ + } \ + while (0) +#endif + +/* Output a zero-initialized block. */ +#ifndef ASM_OUTPUT_ALIGNED_BSS +#define ASM_OUTPUT_ALIGNED_BSS(STREAM, DECL, NAME, SIZE, ALIGN) \ + asm_output_aligned_bss (STREAM, DECL, NAME, SIZE, ALIGN) +#endif + +/* Output a #ident directive. */ +#ifndef ASM_OUTPUT_IDENT +#define ASM_OUTPUT_IDENT(STREAM,STRING) \ + asm_fprintf (STREAM, "%@ - - - ident %s\n", STRING) +#endif + +#ifndef ASM_COMMENT_START +#define ASM_COMMENT_START "@" +#endif + +/* This works for GAS and some other assemblers. */ +#define SET_ASM_OP "\t.set\t" diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/arm-protos.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/arm-protos.h new file mode 100644 index 0000000..f037a45 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/arm-protos.h @@ -0,0 +1,231 @@ +/* Prototypes for exported functions defined in arm.c and pe.c + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2010 Free Software Foundation, Inc. + Contributed by Richard Earnshaw (rearnsha@arm.com) + Minor hacks by Nick Clifton (nickc@cygnus.com) + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + GCC is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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/>. */ + +#ifndef GCC_ARM_PROTOS_H +#define GCC_ARM_PROTOS_H + +extern int use_return_insn (int, rtx); +extern enum reg_class arm_regno_class (int); +extern void arm_load_pic_register (unsigned long); +extern int arm_volatile_func (void); +extern const char *arm_output_epilogue (rtx); +extern void arm_expand_prologue (void); +extern const char *arm_strip_name_encoding (const char *); +extern void arm_asm_output_labelref (FILE *, const char *); +extern void thumb2_asm_output_opcode (FILE *); +extern unsigned long arm_current_func_type (void); +extern HOST_WIDE_INT arm_compute_initial_elimination_offset (unsigned int, + unsigned int); +extern HOST_WIDE_INT thumb_compute_initial_elimination_offset (unsigned int, + unsigned int); +extern unsigned int arm_dbx_register_number (unsigned int); +extern void arm_output_fn_unwind (FILE *, bool); + + +#ifdef RTX_CODE +extern bool arm_vector_mode_supported_p (enum machine_mode); +extern bool arm_small_register_classes_for_mode_p (enum machine_mode); +extern int arm_hard_regno_mode_ok (unsigned int, enum machine_mode); +extern int const_ok_for_arm (HOST_WIDE_INT); +extern int arm_split_constant (RTX_CODE, enum machine_mode, rtx, + HOST_WIDE_INT, rtx, rtx, int); +extern RTX_CODE arm_canonicalize_comparison (RTX_CODE, rtx *, rtx *); +extern int legitimate_pic_operand_p (rtx); +extern rtx legitimize_pic_address (rtx, enum machine_mode, rtx); +extern rtx legitimize_tls_address (rtx, rtx); +extern int arm_legitimate_address_outer_p (enum machine_mode, rtx, RTX_CODE, int); +extern int thumb_legitimate_offset_p (enum machine_mode, HOST_WIDE_INT); +extern bool arm_legitimize_reload_address (rtx *, enum machine_mode, int, int, + int); +extern rtx thumb_legitimize_reload_address (rtx *, enum machine_mode, int, int, + int); +extern int arm_const_double_rtx (rtx); +extern int neg_const_double_rtx_ok_for_fpa (rtx); +extern int vfp3_const_double_rtx (rtx); +extern int neon_immediate_valid_for_move (rtx, enum machine_mode, rtx *, int *); +extern int neon_immediate_valid_for_logic (rtx, enum machine_mode, int, rtx *, + int *); +extern char *neon_output_logic_immediate (const char *, rtx *, + enum machine_mode, int, int); +extern void neon_pairwise_reduce (rtx, rtx, enum machine_mode, + rtx (*) (rtx, rtx, rtx)); +extern rtx neon_make_constant (rtx); +extern void neon_expand_vector_init (rtx, rtx); +extern void neon_lane_bounds (rtx, HOST_WIDE_INT, HOST_WIDE_INT); +extern void neon_const_bounds (rtx, HOST_WIDE_INT, HOST_WIDE_INT); +extern HOST_WIDE_INT neon_element_bits (enum machine_mode); +extern void neon_reinterpret (rtx, rtx); +extern void neon_emit_pair_result_insn (enum machine_mode, + rtx (*) (rtx, rtx, rtx, rtx), + rtx, rtx, rtx); +extern void neon_disambiguate_copy (rtx *, rtx *, rtx *, unsigned int); +extern enum reg_class coproc_secondary_reload_class (enum machine_mode, rtx, + bool); +extern bool arm_tls_referenced_p (rtx); +extern bool arm_cannot_force_const_mem (rtx); + +extern int cirrus_memory_offset (rtx); +extern int arm_coproc_mem_operand (rtx, bool); +extern int neon_vector_mem_operand (rtx, int); +extern int neon_struct_mem_operand (rtx); +extern int arm_no_early_store_addr_dep (rtx, rtx); +extern int arm_early_store_addr_dep (rtx, rtx); +extern int arm_early_load_addr_dep (rtx, rtx); +extern int arm_no_early_alu_shift_dep (rtx, rtx); +extern int arm_no_early_alu_shift_value_dep (rtx, rtx); +extern int arm_no_early_mul_dep (rtx, rtx); +extern int arm_mac_accumulator_is_mul_result (rtx, rtx); + +extern int tls_mentioned_p (rtx); +extern int symbol_mentioned_p (rtx); +extern int label_mentioned_p (rtx); +extern RTX_CODE minmax_code (rtx); +extern int adjacent_mem_locations (rtx, rtx); +extern bool gen_ldm_seq (rtx *, int, bool); +extern bool gen_stm_seq (rtx *, int); +extern bool gen_const_stm_seq (rtx *, int); +extern rtx arm_gen_load_multiple (int *, int, rtx, int, rtx, HOST_WIDE_INT *); +extern rtx arm_gen_store_multiple (int *, int, rtx, int, rtx, HOST_WIDE_INT *); +extern int arm_gen_movmemqi (rtx *); +extern enum machine_mode arm_select_cc_mode (RTX_CODE, rtx, rtx); +extern enum machine_mode arm_select_dominance_cc_mode (rtx, rtx, + HOST_WIDE_INT); +extern rtx arm_gen_compare_reg (RTX_CODE, rtx, rtx); +extern rtx arm_gen_return_addr_mask (void); +extern void arm_reload_in_hi (rtx *); +extern void arm_reload_out_hi (rtx *); +extern int arm_const_double_inline_cost (rtx); +extern bool arm_const_double_by_parts (rtx); +extern bool arm_const_double_by_immediates (rtx); +extern const char *fp_immediate_constant (rtx); +extern void arm_emit_call_insn (rtx, rtx); +extern const char *output_call (rtx *); +extern const char *output_call_mem (rtx *); +void arm_emit_movpair (rtx, rtx); +extern const char *output_mov_long_double_fpa_from_arm (rtx *); +extern const char *output_mov_long_double_arm_from_fpa (rtx *); +extern const char *output_mov_long_double_arm_from_arm (rtx *); +extern const char *output_mov_double_fpa_from_arm (rtx *); +extern const char *output_mov_double_arm_from_fpa (rtx *); +extern const char *output_move_double (rtx *); +extern const char *output_move_quad (rtx *); +extern const char *output_move_vfp (rtx *operands); +extern const char *output_move_neon (rtx *operands); +extern int arm_attr_length_move_neon (rtx); +extern int arm_address_offset_is_imm (rtx); +extern const char *output_add_immediate (rtx *); +extern const char *arithmetic_instr (rtx, int); +extern void output_ascii_pseudo_op (FILE *, const unsigned char *, int); +extern const char *output_return_instruction (rtx, int, int); +extern void arm_poke_function_name (FILE *, const char *); +extern void arm_final_prescan_insn (rtx); +extern int arm_debugger_arg_offset (int, rtx); +extern bool arm_is_long_call_p (tree); +extern int arm_emit_vector_const (FILE *, rtx); +extern void arm_emit_fp16_const (rtx c); +extern const char * arm_output_load_gr (rtx *); +extern const char *vfp_output_fstmd (rtx *); +extern void arm_set_return_address (rtx, rtx); +extern int arm_eliminable_register (rtx); +extern const char *arm_output_shift(rtx *, int); +extern void arm_expand_sync (enum machine_mode, struct arm_sync_generator *, + rtx, rtx, rtx, rtx); +extern const char *arm_output_memory_barrier (rtx *); +extern const char *arm_output_sync_insn (rtx, rtx *); +extern unsigned int arm_sync_loop_insns (rtx , rtx *); + +#if defined TREE_CODE +extern void arm_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree); +extern bool arm_pad_arg_upward (enum machine_mode, const_tree); +extern bool arm_pad_reg_upward (enum machine_mode, tree, int); +#endif +extern int arm_apply_result_size (void); +extern rtx aapcs_libcall_value (enum machine_mode); + +#endif /* RTX_CODE */ + +extern int arm_float_words_big_endian (void); + +/* Thumb functions. */ +extern void arm_init_expanders (void); +extern const char *thumb_unexpanded_epilogue (void); +extern void thumb1_expand_prologue (void); +extern void thumb1_expand_epilogue (void); +#ifdef TREE_CODE +extern int is_called_in_ARM_mode (tree); +#endif +extern int thumb_shiftable_const (unsigned HOST_WIDE_INT); +#ifdef RTX_CODE +extern void thumb1_final_prescan_insn (rtx); +extern void thumb2_final_prescan_insn (rtx); +extern const char *thumb_load_double_from_address (rtx *); +extern const char *thumb_output_move_mem_multiple (int, rtx *); +extern const char *thumb_call_via_reg (rtx); +extern void thumb_expand_movmemqi (rtx *); +extern rtx arm_return_addr (int, rtx); +extern void thumb_reload_out_hi (rtx *); +extern void thumb_reload_in_hi (rtx *); +extern void thumb_set_return_address (rtx, rtx); +extern const char *thumb1_output_casesi (rtx *); +extern const char *thumb2_output_casesi (rtx *); +#endif + +/* Defined in pe.c. */ +extern int arm_dllexport_name_p (const char *); +extern int arm_dllimport_name_p (const char *); + +#ifdef TREE_CODE +extern void arm_pe_unique_section (tree, int); +extern void arm_pe_encode_section_info (tree, rtx, int); +extern int arm_dllexport_p (tree); +extern int arm_dllimport_p (tree); +extern void arm_mark_dllexport (tree); +extern void arm_mark_dllimport (tree); +#endif + +extern void arm_pr_long_calls (struct cpp_reader *); +extern void arm_pr_no_long_calls (struct cpp_reader *); +extern void arm_pr_long_calls_off (struct cpp_reader *); + +extern void arm_lang_object_attributes_init(void); + +extern const char *arm_mangle_type (const_tree); + +extern void arm_order_regs_for_local_alloc (void); + +#ifdef RTX_CODE +/* This needs to be here because we need RTX_CODE and similar. */ + +struct tune_params +{ + bool (*rtx_costs) (rtx, RTX_CODE, RTX_CODE, int *, bool); + bool (*sched_adjust_cost) (rtx, rtx, rtx, int *); + int constant_limit; + int num_prefetch_slots; + int l1_cache_size; + int l1_cache_line_size; +}; + +extern const struct tune_params *current_tune; +#endif /* RTX_CODE */ + +#endif /* ! GCC_ARM_PROTOS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/arm.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/arm.h new file mode 100644 index 0000000..0e2e827 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/arm.h @@ -0,0 +1,2463 @@ +/* Definitions of target machine for GNU compiler, for ARM. + Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, + 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl) + and Martin Simmons (@harleqn.co.uk). + More major hacks by Richard Earnshaw (rearnsha@arm.com) + Minor hacks by Nick Clifton (nickc@cygnus.com) + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GCC is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + 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/>. */ + +#ifndef GCC_ARM_H +#define GCC_ARM_H + +/* We can't use enum machine_mode inside a generator file because it + hasn't been created yet; we shouldn't be using any code that + needs the real definition though, so this ought to be safe. */ +#ifdef GENERATOR_FILE +#define MACHMODE int +#else +#include "insn-modes.h" +#define MACHMODE enum machine_mode +#endif + +#include "config/vxworks-dummy.h" + +/* The architecture define. */ +extern char arm_arch_name[]; + +/* Target CPU builtins. */ +#define TARGET_CPU_CPP_BUILTINS() \ + do \ + { \ + if (TARGET_DSP_MULTIPLY) \ + builtin_define ("__ARM_FEATURE_DSP"); \ + /* Define __arm__ even when in thumb mode, for \ + consistency with armcc. */ \ + builtin_define ("__arm__"); \ + builtin_define ("__APCS_32__"); \ + if (TARGET_THUMB) \ + builtin_define ("__thumb__"); \ + if (TARGET_THUMB2) \ + builtin_define ("__thumb2__"); \ + \ + if (TARGET_BIG_END) \ + { \ + builtin_define ("__ARMEB__"); \ + if (TARGET_THUMB) \ + builtin_define ("__THUMBEB__"); \ + if (TARGET_LITTLE_WORDS) \ + builtin_define ("__ARMWEL__"); \ + } \ + else \ + { \ + builtin_define ("__ARMEL__"); \ + if (TARGET_THUMB) \ + builtin_define ("__THUMBEL__"); \ + } \ + \ + if (TARGET_SOFT_FLOAT) \ + builtin_define ("__SOFTFP__"); \ + \ + if (TARGET_VFP) \ + builtin_define ("__VFP_FP__"); \ + \ + if (TARGET_NEON) \ + builtin_define ("__ARM_NEON__"); \ + \ + /* Add a define for interworking. \ + Needed when building libgcc.a. */ \ + if (arm_cpp_interwork) \ + builtin_define ("__THUMB_INTERWORK__"); \ + \ + builtin_assert ("cpu=arm"); \ + builtin_assert ("machine=arm"); \ + \ + builtin_define (arm_arch_name); \ + if (arm_arch_cirrus) \ + builtin_define ("__MAVERICK__"); \ + if (arm_arch_xscale) \ + builtin_define ("__XSCALE__"); \ + if (arm_arch_iwmmxt) \ + builtin_define ("__IWMMXT__"); \ + if (TARGET_AAPCS_BASED) \ + { \ + if (arm_pcs_default == ARM_PCS_AAPCS_VFP) \ + builtin_define ("__ARM_PCS_VFP"); \ + else if (arm_pcs_default == ARM_PCS_AAPCS) \ + builtin_define ("__ARM_PCS"); \ + builtin_define ("__ARM_EABI__"); \ + } \ + } while (0) + +/* The various ARM cores. */ +enum processor_type +{ +#define ARM_CORE(NAME, IDENT, ARCH, FLAGS, COSTS) \ + IDENT, +#include "arm-cores.def" +#undef ARM_CORE + /* Used to indicate that no processor has been specified. */ + arm_none +}; + +enum target_cpus +{ +#define ARM_CORE(NAME, IDENT, ARCH, FLAGS, COSTS) \ + TARGET_CPU_##IDENT, +#include "arm-cores.def" +#undef ARM_CORE + TARGET_CPU_generic +}; + +/* The processor for which instructions should be scheduled. */ +extern enum processor_type arm_tune; + +enum arm_sync_generator_tag + { + arm_sync_generator_omn, + arm_sync_generator_omrn + }; + +/* Wrapper to pass around a polymorphic pointer to a sync instruction + generator and. */ +struct arm_sync_generator +{ + enum arm_sync_generator_tag op; + union + { + rtx (* omn) (rtx, rtx, rtx); + rtx (* omrn) (rtx, rtx, rtx, rtx); + } u; +}; + +typedef enum arm_cond_code +{ + ARM_EQ = 0, ARM_NE, ARM_CS, ARM_CC, ARM_MI, ARM_PL, ARM_VS, ARM_VC, + ARM_HI, ARM_LS, ARM_GE, ARM_LT, ARM_GT, ARM_LE, ARM_AL, ARM_NV +} +arm_cc; + +extern arm_cc arm_current_cc; + +#define ARM_INVERSE_CONDITION_CODE(X) ((arm_cc) (((int)X) ^ 1)) + +extern int arm_target_label; +extern int arm_ccfsm_state; +extern GTY(()) rtx arm_target_insn; +/* The label of the current constant pool. */ +extern rtx pool_vector_label; +/* Set to 1 when a return insn is output, this means that the epilogue + is not needed. */ +extern int return_used_this_function; +/* Callback to output language specific object attributes. */ +extern void (*arm_lang_output_object_attributes_hook)(void); + +/* Just in case configure has failed to define anything. */ +#ifndef TARGET_CPU_DEFAULT +#define TARGET_CPU_DEFAULT TARGET_CPU_generic +#endif + + +#undef CPP_SPEC +#define CPP_SPEC "%(subtarget_cpp_spec) \ +%{msoft-float:%{mhard-float: \ + %e-msoft-float and -mhard_float may not be used together}} \ +%{mbig-endian:%{mlittle-endian: \ + %e-mbig-endian and -mlittle-endian may not be used together}}" + +#ifndef CC1_SPEC +#define CC1_SPEC "" +#endif + +/* This macro defines names of additional specifications to put in the specs + that can be used in various specifications like CC1_SPEC. Its definition + is an initializer with a subgrouping for each command option. + + Each subgrouping contains a string constant, that defines the + specification name, and a string constant that used by the GCC driver + program. + + Do not define this macro if it does not need to do anything. */ +#define EXTRA_SPECS \ + { "subtarget_cpp_spec", SUBTARGET_CPP_SPEC }, \ + SUBTARGET_EXTRA_SPECS + +#ifndef SUBTARGET_EXTRA_SPECS +#define SUBTARGET_EXTRA_SPECS +#endif + +#ifndef SUBTARGET_CPP_SPEC +#define SUBTARGET_CPP_SPEC "" +#endif + +/* Run-time Target Specification. */ +#ifndef TARGET_VERSION +#define TARGET_VERSION fputs (" (ARM/generic)", stderr); +#endif + +#define TARGET_SOFT_FLOAT (arm_float_abi == ARM_FLOAT_ABI_SOFT) +/* Use hardware floating point instructions. */ +#define TARGET_HARD_FLOAT (arm_float_abi != ARM_FLOAT_ABI_SOFT) +/* Use hardware floating point calling convention. */ +#define TARGET_HARD_FLOAT_ABI (arm_float_abi == ARM_FLOAT_ABI_HARD) +#define TARGET_FPA (arm_fpu_desc->model == ARM_FP_MODEL_FPA) +#define TARGET_MAVERICK (arm_fpu_desc->model == ARM_FP_MODEL_MAVERICK) +#define TARGET_VFP (arm_fpu_desc->model == ARM_FP_MODEL_VFP) +#define TARGET_IWMMXT (arm_arch_iwmmxt) +#define TARGET_REALLY_IWMMXT (TARGET_IWMMXT && TARGET_32BIT) +#define TARGET_IWMMXT_ABI (TARGET_32BIT && arm_abi == ARM_ABI_IWMMXT) +#define TARGET_ARM (! TARGET_THUMB) +#define TARGET_EITHER 1 /* (TARGET_ARM | TARGET_THUMB) */ +#define TARGET_BACKTRACE (leaf_function_p () \ + ? TARGET_TPCS_LEAF_FRAME \ + : TARGET_TPCS_FRAME) +#define TARGET_LDRD (arm_arch5e && ARM_DOUBLEWORD_ALIGN) +#define TARGET_AAPCS_BASED \ + (arm_abi != ARM_ABI_APCS && arm_abi != ARM_ABI_ATPCS) + +#define TARGET_HARD_TP (target_thread_pointer == TP_CP15) +#define TARGET_SOFT_TP (target_thread_pointer == TP_SOFT) + +/* Only 16-bit thumb code. */ +#define TARGET_THUMB1 (TARGET_THUMB && !arm_arch_thumb2) +/* Arm or Thumb-2 32-bit code. */ +#define TARGET_32BIT (TARGET_ARM || arm_arch_thumb2) +/* 32-bit Thumb-2 code. */ +#define TARGET_THUMB2 (TARGET_THUMB && arm_arch_thumb2) +/* Thumb-1 only. */ +#define TARGET_THUMB1_ONLY (TARGET_THUMB1 && !arm_arch_notm) +/* FPA emulator without LFM. */ +#define TARGET_FPA_EMU2 (TARGET_FPA && arm_fpu_desc->rev == 2) + +/* The following two macros concern the ability to execute coprocessor + instructions for VFPv3 or NEON. TARGET_VFP3/TARGET_VFPD32 are currently + only ever tested when we know we are generating for VFP hardware; we need + to be more careful with TARGET_NEON as noted below. */ + +/* FPU is has the full VFPv3/NEON register file of 32 D registers. */ +#define TARGET_VFPD32 (TARGET_VFP && arm_fpu_desc->regs == VFP_REG_D32) + +/* FPU supports VFPv3 instructions. */ +#define TARGET_VFP3 (TARGET_VFP && arm_fpu_desc->rev >= 3) + +/* FPU only supports VFP single-precision instructions. */ +#define TARGET_VFP_SINGLE (TARGET_VFP && arm_fpu_desc->regs == VFP_REG_SINGLE) + +/* FPU supports VFP double-precision instructions. */ +#define TARGET_VFP_DOUBLE (TARGET_VFP && arm_fpu_desc->regs != VFP_REG_SINGLE) + +/* FPU supports half-precision floating-point with NEON element load/store. */ +#define TARGET_NEON_FP16 \ + (TARGET_VFP && arm_fpu_desc->neon && arm_fpu_desc->fp16) + +/* FPU supports VFP half-precision floating-point. */ +#define TARGET_FP16 (TARGET_VFP && arm_fpu_desc->fp16) + +/* FPU supports Neon instructions. The setting of this macro gets + revealed via __ARM_NEON__ so we add extra guards upon TARGET_32BIT + and TARGET_HARD_FLOAT to ensure that NEON instructions are + available. */ +#define TARGET_NEON (TARGET_32BIT && TARGET_HARD_FLOAT \ + && TARGET_VFP && arm_fpu_desc->neon) + +/* "DSP" multiply instructions, eg. SMULxy. */ +#define TARGET_DSP_MULTIPLY \ + (TARGET_32BIT && arm_arch5e && (arm_arch_notm || arm_arch7em)) +/* Integer SIMD instructions, and extend-accumulate instructions. */ +#define TARGET_INT_SIMD \ + (TARGET_32BIT && arm_arch6 && (arm_arch_notm || arm_arch7em)) + +/* Should MOVW/MOVT be used in preference to a constant pool. */ +#define TARGET_USE_MOVT (arm_arch_thumb2 && !optimize_size) + +/* We could use unified syntax for arm mode, but for now we just use it + for Thumb-2. */ +#define TARGET_UNIFIED_ASM TARGET_THUMB2 + +/* Nonzero if this chip provides the DMB instruction. */ +#define TARGET_HAVE_DMB (arm_arch7) + +/* Nonzero if this chip implements a memory barrier via CP15. */ +#define TARGET_HAVE_DMB_MCR (arm_arch6k && ! TARGET_HAVE_DMB) + +/* Nonzero if this chip implements a memory barrier instruction. */ +#define TARGET_HAVE_MEMORY_BARRIER (TARGET_HAVE_DMB || TARGET_HAVE_DMB_MCR) + +/* Nonzero if this chip supports ldrex and strex */ +#define TARGET_HAVE_LDREX ((arm_arch6 && TARGET_ARM) || arm_arch7) + +/* Nonzero if this chip supports ldrex{bhd} and strex{bhd}. */ +#define TARGET_HAVE_LDREXBHD ((arm_arch6k && TARGET_ARM) || arm_arch7) + +/* True iff the full BPABI is being used. If TARGET_BPABI is true, + then TARGET_AAPCS_BASED must be true -- but the converse does not + hold. TARGET_BPABI implies the use of the BPABI runtime library, + etc., in addition to just the AAPCS calling conventions. */ +#ifndef TARGET_BPABI +#define TARGET_BPABI false +#endif + +/* Support for a compile-time default CPU, et cetera. The rules are: + --with-arch is ignored if -march or -mcpu are specified. + --with-cpu is ignored if -march or -mcpu are specified, and is overridden + by --with-arch. + --with-tune is ignored if -mtune or -mcpu are specified (but not affected + by -march). + --with-float is ignored if -mhard-float, -msoft-float or -mfloat-abi are + specified. + --with-fpu is ignored if -mfpu is specified. + --with-abi is ignored is -mabi is specified. */ +#define OPTION_DEFAULT_SPECS \ + {"arch", "%{!march=*:%{!mcpu=*:-march=%(VALUE)}}" }, \ + {"cpu", "%{!march=*:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \ + {"tune", "%{!mcpu=*:%{!mtune=*:-mtune=%(VALUE)}}" }, \ + {"float", \ + "%{!msoft-float:%{!mhard-float:%{!mfloat-abi=*:-mfloat-abi=%(VALUE)}}}" }, \ + {"fpu", "%{!mfpu=*:-mfpu=%(VALUE)}"}, \ + {"abi", "%{!mabi=*:-mabi=%(VALUE)}"}, \ + {"mode", "%{!marm:%{!mthumb:-m%(VALUE)}}"}, + +/* Which floating point model to use. */ +enum arm_fp_model +{ + ARM_FP_MODEL_UNKNOWN, + /* FPA model (Hardware or software). */ + ARM_FP_MODEL_FPA, + /* Cirrus Maverick floating point model. */ + ARM_FP_MODEL_MAVERICK, + /* VFP floating point model. */ + ARM_FP_MODEL_VFP +}; + +enum vfp_reg_type +{ + VFP_NONE = 0, + VFP_REG_D16, + VFP_REG_D32, + VFP_REG_SINGLE +}; + +extern const struct arm_fpu_desc +{ + const char *name; + enum arm_fp_model model; + int rev; + enum vfp_reg_type regs; + int neon; + int fp16; +} *arm_fpu_desc; + +/* Which floating point hardware to schedule for. */ +extern int arm_fpu_attr; + +enum float_abi_type +{ + ARM_FLOAT_ABI_SOFT, + ARM_FLOAT_ABI_SOFTFP, + ARM_FLOAT_ABI_HARD +}; + +extern enum float_abi_type arm_float_abi; + +#ifndef TARGET_DEFAULT_FLOAT_ABI +#define TARGET_DEFAULT_FLOAT_ABI ARM_FLOAT_ABI_SOFT +#endif + +/* Which __fp16 format to use. + The enumeration values correspond to the numbering for the + Tag_ABI_FP_16bit_format attribute. + */ +enum arm_fp16_format_type +{ + ARM_FP16_FORMAT_NONE = 0, + ARM_FP16_FORMAT_IEEE = 1, + ARM_FP16_FORMAT_ALTERNATIVE = 2 +}; + +extern enum arm_fp16_format_type arm_fp16_format; +#define LARGEST_EXPONENT_IS_NORMAL(bits) \ + ((bits) == 16 && arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE) + +/* Which ABI to use. */ +enum arm_abi_type +{ + ARM_ABI_APCS, + ARM_ABI_ATPCS, + ARM_ABI_AAPCS, + ARM_ABI_IWMMXT, + ARM_ABI_AAPCS_LINUX +}; + +extern enum arm_abi_type arm_abi; + +#ifndef ARM_DEFAULT_ABI +#define ARM_DEFAULT_ABI ARM_ABI_APCS +#endif + +/* Which thread pointer access sequence to use. */ +enum arm_tp_type { + TP_AUTO, + TP_SOFT, + TP_CP15 +}; + +extern enum arm_tp_type target_thread_pointer; + +/* Nonzero if this chip supports the ARM Architecture 3M extensions. */ +extern int arm_arch3m; + +/* Nonzero if this chip supports the ARM Architecture 4 extensions. */ +extern int arm_arch4; + +/* Nonzero if this chip supports the ARM Architecture 4T extensions. */ +extern int arm_arch4t; + +/* Nonzero if this chip supports the ARM Architecture 5 extensions. */ +extern int arm_arch5; + +/* Nonzero if this chip supports the ARM Architecture 5E extensions. */ +extern int arm_arch5e; + +/* Nonzero if this chip supports the ARM Architecture 6 extensions. */ +extern int arm_arch6; + +/* Nonzero if this chip supports the ARM Architecture 6k extensions. */ +extern int arm_arch6k; + +/* Nonzero if this chip supports the ARM Architecture 7 extensions. */ +extern int arm_arch7; + +/* Nonzero if instructions not present in the 'M' profile can be used. */ +extern int arm_arch_notm; + +/* Nonzero if instructions present in ARMv7E-M can be used. */ +extern int arm_arch7em; + +/* Nonzero if this chip can benefit from load scheduling. */ +extern int arm_ld_sched; + +/* Nonzero if generating Thumb code, either Thumb-1 or Thumb-2. */ +extern int thumb_code; + +/* Nonzero if generating Thumb-1 code. */ +extern int thumb1_code; + +/* Nonzero if this chip is a StrongARM. */ +extern int arm_tune_strongarm; + +/* Nonzero if this chip is a Cirrus variant. */ +extern int arm_arch_cirrus; + +/* Nonzero if this chip supports Intel XScale with Wireless MMX technology. */ +extern int arm_arch_iwmmxt; + +/* Nonzero if this chip is an XScale. */ +extern int arm_arch_xscale; + +/* Nonzero if tuning for XScale. */ +extern int arm_tune_xscale; + +/* Nonzero if tuning for stores via the write buffer. */ +extern int arm_tune_wbuf; + +/* Nonzero if tuning for Cortex-A9. */ +extern int arm_tune_cortex_a9; + +/* Nonzero if we should define __THUMB_INTERWORK__ in the + preprocessor. + XXX This is a bit of a hack, it's intended to help work around + problems in GLD which doesn't understand that armv5t code is + interworking clean. */ +extern int arm_cpp_interwork; + +/* Nonzero if chip supports Thumb 2. */ +extern int arm_arch_thumb2; + +/* Nonzero if chip supports integer division instruction. */ +extern int arm_arch_hwdiv; + +#ifndef TARGET_DEFAULT +#define TARGET_DEFAULT (MASK_APCS_FRAME) +#endif + +/* Nonzero if PIC code requires explicit qualifiers to generate + PLT and GOT relocs rather than the assembler doing so implicitly. + Subtargets can override these if required. */ +#ifndef NEED_GOT_RELOC +#define NEED_GOT_RELOC 0 +#endif +#ifndef NEED_PLT_RELOC +#define NEED_PLT_RELOC 0 +#endif + +/* Nonzero if we need to refer to the GOT with a PC-relative + offset. In other words, generate + + .word _GLOBAL_OFFSET_TABLE_ - [. - (.Lxx + 8)] + + rather than + + .word _GLOBAL_OFFSET_TABLE_ - (.Lxx + 8) + + The default is true, which matches NetBSD. Subtargets can + override this if required. */ +#ifndef GOT_PCREL +#define GOT_PCREL 1 +#endif + +/* Target machine storage Layout. */ + + +/* Define this macro if it is advisable to hold scalars in registers + in a wider mode than that declared by the program. In such cases, + the value is constrained to be within the bounds of the declared + type, but kept valid in the wider mode. The signedness of the + extension may differ from that of the type. */ + +/* It is far faster to zero extend chars than to sign extend them */ + +#define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \ + if (GET_MODE_CLASS (MODE) == MODE_INT \ + && GET_MODE_SIZE (MODE) < 4) \ + { \ + if (MODE == QImode) \ + UNSIGNEDP = 1; \ + else if (MODE == HImode) \ + UNSIGNEDP = 1; \ + (MODE) = SImode; \ + } + +/* Define this if most significant bit is lowest numbered + in instructions that operate on numbered bit-fields. */ +#define BITS_BIG_ENDIAN 0 + +/* Define this if most significant byte of a word is the lowest numbered. + Most ARM processors are run in little endian mode, so that is the default. + If you want to have it run-time selectable, change the definition in a + cover file to be TARGET_BIG_ENDIAN. */ +#define BYTES_BIG_ENDIAN (TARGET_BIG_END != 0) + +/* Define this if most significant word of a multiword number is the lowest + numbered. + This is always false, even when in big-endian mode. */ +#define WORDS_BIG_ENDIAN (BYTES_BIG_ENDIAN && ! TARGET_LITTLE_WORDS) + +/* Define this if most significant word of doubles is the lowest numbered. + The rules are different based on whether or not we use FPA-format, + VFP-format or some other floating point co-processor's format doubles. */ +#define FLOAT_WORDS_BIG_ENDIAN (arm_float_words_big_endian ()) + +#define UNITS_PER_WORD 4 + +/* True if natural alignment is used for doubleword types. */ +#define ARM_DOUBLEWORD_ALIGN TARGET_AAPCS_BASED + +#define DOUBLEWORD_ALIGNMENT 64 + +#define PARM_BOUNDARY 32 + +#define STACK_BOUNDARY (ARM_DOUBLEWORD_ALIGN ? DOUBLEWORD_ALIGNMENT : 32) + +#define PREFERRED_STACK_BOUNDARY \ + (arm_abi == ARM_ABI_ATPCS ? 64 : STACK_BOUNDARY) + +#define FUNCTION_BOUNDARY ((TARGET_THUMB && optimize_size) ? 16 : 32) + +/* The lowest bit is used to indicate Thumb-mode functions, so the + vbit must go into the delta field of pointers to member + functions. */ +#define TARGET_PTRMEMFUNC_VBIT_LOCATION ptrmemfunc_vbit_in_delta + +#define EMPTY_FIELD_BOUNDARY 32 + +#define BIGGEST_ALIGNMENT (ARM_DOUBLEWORD_ALIGN ? DOUBLEWORD_ALIGNMENT : 32) + +/* XXX Blah -- this macro is used directly by libobjc. Since it + supports no vector modes, cut out the complexity and fall back + on BIGGEST_FIELD_ALIGNMENT. */ +#ifdef IN_TARGET_LIBS +#define BIGGEST_FIELD_ALIGNMENT 64 +#endif + +/* Make strings word-aligned so strcpy from constants will be faster. */ +#define CONSTANT_ALIGNMENT_FACTOR (TARGET_THUMB || ! arm_tune_xscale ? 1 : 2) + +#define CONSTANT_ALIGNMENT(EXP, ALIGN) \ + ((TREE_CODE (EXP) == STRING_CST \ + && !optimize_size \ + && (ALIGN) < BITS_PER_WORD * CONSTANT_ALIGNMENT_FACTOR) \ + ? BITS_PER_WORD * CONSTANT_ALIGNMENT_FACTOR : (ALIGN)) + +/* Align definitions of arrays, unions and structures so that + initializations and copies can be made more efficient. This is not + ABI-changing, so it only affects places where we can see the + definition. Increasing the alignment tends to introduce padding, + so don't do this when optimizing for size/conserving stack space. */ +#define ARM_EXPAND_ALIGNMENT(COND, EXP, ALIGN) \ + (((COND) && ((ALIGN) < BITS_PER_WORD) \ + && (TREE_CODE (EXP) == ARRAY_TYPE \ + || TREE_CODE (EXP) == UNION_TYPE \ + || TREE_CODE (EXP) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN)) + +/* Align global data. */ +#define DATA_ALIGNMENT(EXP, ALIGN) \ + ARM_EXPAND_ALIGNMENT(!optimize_size, EXP, ALIGN) + +/* Similarly, make sure that objects on the stack are sensibly aligned. */ +#define LOCAL_ALIGNMENT(EXP, ALIGN) \ + ARM_EXPAND_ALIGNMENT(!flag_conserve_stack, EXP, ALIGN) + +/* Setting STRUCTURE_SIZE_BOUNDARY to 32 produces more efficient code, but the + value set in previous versions of this toolchain was 8, which produces more + compact structures. The command line option -mstructure_size_boundary=<n> + can be used to change this value. For compatibility with the ARM SDK + however the value should be left at 32. ARM SDT Reference Manual (ARM DUI + 0020D) page 2-20 says "Structures are aligned on word boundaries". + The AAPCS specifies a value of 8. */ +#define STRUCTURE_SIZE_BOUNDARY arm_structure_size_boundary +extern int arm_structure_size_boundary; + +/* This is the value used to initialize arm_structure_size_boundary. If a + particular arm target wants to change the default value it should change + the definition of this macro, not STRUCTURE_SIZE_BOUNDARY. See netbsd.h + for an example of this. */ +#ifndef DEFAULT_STRUCTURE_SIZE_BOUNDARY +#define DEFAULT_STRUCTURE_SIZE_BOUNDARY 32 +#endif + +/* Nonzero if move instructions will actually fail to work + when given unaligned data. */ +#define STRICT_ALIGNMENT 1 + +/* wchar_t is unsigned under the AAPCS. */ +#ifndef WCHAR_TYPE +#define WCHAR_TYPE (TARGET_AAPCS_BASED ? "unsigned int" : "int") + +#define WCHAR_TYPE_SIZE BITS_PER_WORD +#endif + +#ifndef SIZE_TYPE +#define SIZE_TYPE (TARGET_AAPCS_BASED ? "unsigned int" : "long unsigned int") +#endif + +#ifndef PTRDIFF_TYPE +#define PTRDIFF_TYPE (TARGET_AAPCS_BASED ? "int" : "long int") +#endif + +/* AAPCS requires that structure alignment is affected by bitfields. */ +#ifndef PCC_BITFIELD_TYPE_MATTERS +#define PCC_BITFIELD_TYPE_MATTERS TARGET_AAPCS_BASED +#endif + + +/* Standard register usage. */ + +/* Register allocation in ARM Procedure Call Standard (as used on RISCiX): + (S - saved over call). + + r0 * argument word/integer result + r1-r3 argument word + + r4-r8 S register variable + r9 S (rfp) register variable (real frame pointer) + + r10 F S (sl) stack limit (used by -mapcs-stack-check) + r11 F S (fp) argument pointer + r12 (ip) temp workspace + r13 F S (sp) lower end of current stack frame + r14 (lr) link address/workspace + r15 F (pc) program counter + + f0 floating point result + f1-f3 floating point scratch + + f4-f7 S floating point variable + + cc This is NOT a real register, but is used internally + to represent things that use or set the condition + codes. + sfp This isn't either. It is used during rtl generation + since the offset between the frame pointer and the + auto's isn't known until after register allocation. + afp Nor this, we only need this because of non-local + goto. Without it fp appears to be used and the + elimination code won't get rid of sfp. It tracks + fp exactly at all times. + + *: See TARGET_CONDITIONAL_REGISTER_USAGE */ + +/* + mvf0 Cirrus floating point result + mvf1-mvf3 Cirrus floating point scratch + mvf4-mvf15 S Cirrus floating point variable. */ + +/* s0-s15 VFP scratch (aka d0-d7). + s16-s31 S VFP variable (aka d8-d15). + vfpcc Not a real register. Represents the VFP condition + code flags. */ + +/* The stack backtrace structure is as follows: + fp points to here: | save code pointer | [fp] + | return link value | [fp, #-4] + | return sp value | [fp, #-8] + | return fp value | [fp, #-12] + [| saved r10 value |] + [| saved r9 value |] + [| saved r8 value |] + [| saved r7 value |] + [| saved r6 value |] + [| saved r5 value |] + [| saved r4 value |] + [| saved r3 value |] + [| saved r2 value |] + [| saved r1 value |] + [| saved r0 value |] + [| saved f7 value |] three words + [| saved f6 value |] three words + [| saved f5 value |] three words + [| saved f4 value |] three words + r0-r3 are not normally saved in a C function. */ + +/* 1 for registers that have pervasive standard uses + and are not available for the register allocator. */ +#define FIXED_REGISTERS \ +{ \ + 0,0,0,0,0,0,0,0, \ + 0,0,0,0,0,1,0,1, \ + 0,0,0,0,0,0,0,0, \ + 1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1 \ +} + +/* 1 for registers not available across function calls. + These must include the FIXED_REGISTERS and also any + registers that can be used without being saved. + The latter must include the registers where values are returned + and the register where structure-value addresses are passed. + Aside from that, you can include as many other registers as you like. + The CC is not preserved over function calls on the ARM 6, so it is + easier to assume this for all. SFP is preserved, since FP is. */ +#define CALL_USED_REGISTERS \ +{ \ + 1,1,1,1,0,0,0,0, \ + 0,0,0,0,1,1,1,1, \ + 1,1,1,1,0,0,0,0, \ + 1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1,1,1,1,1,1,1,1, \ + 1 \ +} + +#ifndef SUBTARGET_CONDITIONAL_REGISTER_USAGE +#define SUBTARGET_CONDITIONAL_REGISTER_USAGE +#endif + +/* These are a couple of extensions to the formats accepted + by asm_fprintf: + %@ prints out ASM_COMMENT_START + %r prints out REGISTER_PREFIX reg_names[arg] */ +#define ASM_FPRINTF_EXTENSIONS(FILE, ARGS, P) \ + case '@': \ + fputs (ASM_COMMENT_START, FILE); \ + break; \ + \ + case 'r': \ + fputs (REGISTER_PREFIX, FILE); \ + fputs (reg_names [va_arg (ARGS, int)], FILE); \ + break; + +/* Round X up to the nearest word. */ +#define ROUND_UP_WORD(X) (((X) + 3) & ~3) + +/* Convert fron bytes to ints. */ +#define ARM_NUM_INTS(X) (((X) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) + +/* The number of (integer) registers required to hold a quantity of type MODE. + Also used for VFP registers. */ +#define ARM_NUM_REGS(MODE) \ + ARM_NUM_INTS (GET_MODE_SIZE (MODE)) + +/* The number of (integer) registers required to hold a quantity of TYPE MODE. */ +#define ARM_NUM_REGS2(MODE, TYPE) \ + ARM_NUM_INTS ((MODE) == BLKmode ? \ + int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) + +/* The number of (integer) argument register available. */ +#define NUM_ARG_REGS 4 + +/* And similarly for the VFP. */ +#define NUM_VFP_ARG_REGS 16 + +/* Return the register number of the N'th (integer) argument. */ +#define ARG_REGISTER(N) (N - 1) + +/* Specify the registers used for certain standard purposes. + The values of these macros are register numbers. */ + +/* The number of the last argument register. */ +#define LAST_ARG_REGNUM ARG_REGISTER (NUM_ARG_REGS) + +/* The numbers of the Thumb register ranges. */ +#define FIRST_LO_REGNUM 0 +#define LAST_LO_REGNUM 7 +#define FIRST_HI_REGNUM 8 +#define LAST_HI_REGNUM 11 + +/* Overridden by config/arm/bpabi.h. */ +#ifndef ARM_UNWIND_INFO +#define ARM_UNWIND_INFO 0 +#endif + +/* Use r0 and r1 to pass exception handling information. */ +#define EH_RETURN_DATA_REGNO(N) (((N) < 2) ? N : INVALID_REGNUM) + +/* The register that holds the return address in exception handlers. */ +#define ARM_EH_STACKADJ_REGNUM 2 +#define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, ARM_EH_STACKADJ_REGNUM) + +/* The native (Norcroft) Pascal compiler for the ARM passes the static chain + as an invisible last argument (possible since varargs don't exist in + Pascal), so the following is not true. */ +#define STATIC_CHAIN_REGNUM 12 + +/* Define this to be where the real frame pointer is if it is not possible to + work out the offset between the frame pointer and the automatic variables + until after register allocation has taken place. FRAME_POINTER_REGNUM + should point to a special register that we will make sure is eliminated. + + For the Thumb we have another problem. The TPCS defines the frame pointer + as r11, and GCC believes that it is always possible to use the frame pointer + as base register for addressing purposes. (See comments in + find_reloads_address()). But - the Thumb does not allow high registers, + including r11, to be used as base address registers. Hence our problem. + + The solution used here, and in the old thumb port is to use r7 instead of + r11 as the hard frame pointer and to have special code to generate + backtrace structures on the stack (if required to do so via a command line + option) using r11. This is the only 'user visible' use of r11 as a frame + pointer. */ +#define ARM_HARD_FRAME_POINTER_REGNUM 11 +#define THUMB_HARD_FRAME_POINTER_REGNUM 7 + +#define HARD_FRAME_POINTER_REGNUM \ + (TARGET_ARM \ + ? ARM_HARD_FRAME_POINTER_REGNUM \ + : THUMB_HARD_FRAME_POINTER_REGNUM) + +#define HARD_FRAME_POINTER_IS_FRAME_POINTER 0 +#define HARD_FRAME_POINTER_IS_ARG_POINTER 0 + +#define FP_REGNUM HARD_FRAME_POINTER_REGNUM + +/* Register to use for pushing function arguments. */ +#define STACK_POINTER_REGNUM SP_REGNUM + +/* ARM floating pointer registers. */ +#define FIRST_FPA_REGNUM 16 +#define LAST_FPA_REGNUM 23 +#define IS_FPA_REGNUM(REGNUM) \ + (((REGNUM) >= FIRST_FPA_REGNUM) && ((REGNUM) <= LAST_FPA_REGNUM)) + +#define FIRST_IWMMXT_GR_REGNUM 43 +#define LAST_IWMMXT_GR_REGNUM 46 +#define FIRST_IWMMXT_REGNUM 47 +#define LAST_IWMMXT_REGNUM 62 +#define IS_IWMMXT_REGNUM(REGNUM) \ + (((REGNUM) >= FIRST_IWMMXT_REGNUM) && ((REGNUM) <= LAST_IWMMXT_REGNUM)) +#define IS_IWMMXT_GR_REGNUM(REGNUM) \ + (((REGNUM) >= FIRST_IWMMXT_GR_REGNUM) && ((REGNUM) <= LAST_IWMMXT_GR_REGNUM)) + +/* Base register for access to local variables of the function. */ +#define FRAME_POINTER_REGNUM 25 + +/* Base register for access to arguments of the function. */ +#define ARG_POINTER_REGNUM 26 + +#define FIRST_CIRRUS_FP_REGNUM 27 +#define LAST_CIRRUS_FP_REGNUM 42 +#define IS_CIRRUS_REGNUM(REGNUM) \ + (((REGNUM) >= FIRST_CIRRUS_FP_REGNUM) && ((REGNUM) <= LAST_CIRRUS_FP_REGNUM)) + +#define FIRST_VFP_REGNUM 63 +#define D7_VFP_REGNUM 78 /* Registers 77 and 78 == VFP reg D7. */ +#define LAST_VFP_REGNUM \ + (TARGET_VFPD32 ? LAST_HI_VFP_REGNUM : LAST_LO_VFP_REGNUM) + +#define IS_VFP_REGNUM(REGNUM) \ + (((REGNUM) >= FIRST_VFP_REGNUM) && ((REGNUM) <= LAST_VFP_REGNUM)) + +/* VFP registers are split into two types: those defined by VFP versions < 3 + have D registers overlaid on consecutive pairs of S registers. VFP version 3 + defines 16 new D registers (d16-d31) which, for simplicity and correctness + in various parts of the backend, we implement as "fake" single-precision + registers (which would be S32-S63, but cannot be used in that way). The + following macros define these ranges of registers. */ +#define LAST_LO_VFP_REGNUM 94 +#define FIRST_HI_VFP_REGNUM 95 +#define LAST_HI_VFP_REGNUM 126 + +#define VFP_REGNO_OK_FOR_SINGLE(REGNUM) \ + ((REGNUM) <= LAST_LO_VFP_REGNUM) + +/* DFmode values are only valid in even register pairs. */ +#define VFP_REGNO_OK_FOR_DOUBLE(REGNUM) \ + ((((REGNUM) - FIRST_VFP_REGNUM) & 1) == 0) + +/* Neon Quad values must start at a multiple of four registers. */ +#define NEON_REGNO_OK_FOR_QUAD(REGNUM) \ + ((((REGNUM) - FIRST_VFP_REGNUM) & 3) == 0) + +/* Neon structures of vectors must be in even register pairs and there + must be enough registers available. Because of various patterns + requiring quad registers, we require them to start at a multiple of + four. */ +#define NEON_REGNO_OK_FOR_NREGS(REGNUM, N) \ + ((((REGNUM) - FIRST_VFP_REGNUM) & 3) == 0 \ + && (LAST_VFP_REGNUM - (REGNUM) >= 2 * (N) - 1)) + +/* The number of hard registers is 16 ARM + 8 FPA + 1 CC + 1 SFP + 1 AFP. */ +/* + 16 Cirrus registers take us up to 43. */ +/* Intel Wireless MMX Technology registers add 16 + 4 more. */ +/* VFP (VFP3) adds 32 (64) + 1 more. */ +#define FIRST_PSEUDO_REGISTER 128 + +#define DBX_REGISTER_NUMBER(REGNO) arm_dbx_register_number (REGNO) + +/* Value should be nonzero if functions must have frame pointers. + Zero means the frame pointer need not be set up (and parms may be accessed + via the stack pointer) in functions that seem suitable. + If we have to have a frame pointer we might as well make use of it. + APCS says that the frame pointer does not need to be pushed in leaf + functions, or simple tail call functions. */ + +#ifndef SUBTARGET_FRAME_POINTER_REQUIRED +#define SUBTARGET_FRAME_POINTER_REQUIRED 0 +#endif + +/* Return number of consecutive hard regs needed starting at reg REGNO + to hold something of mode MODE. + This is ordinarily the length in words of a value of mode MODE + but can be less for certain modes in special long registers. + + On the ARM regs are UNITS_PER_WORD bits wide; FPA regs can hold any FP + mode. */ +#define HARD_REGNO_NREGS(REGNO, MODE) \ + ((TARGET_32BIT \ + && REGNO >= FIRST_FPA_REGNUM \ + && REGNO != FRAME_POINTER_REGNUM \ + && REGNO != ARG_POINTER_REGNUM) \ + && !IS_VFP_REGNUM (REGNO) \ + ? 1 : ARM_NUM_REGS (MODE)) + +/* Return true if REGNO is suitable for holding a quantity of type MODE. */ +#define HARD_REGNO_MODE_OK(REGNO, MODE) \ + arm_hard_regno_mode_ok ((REGNO), (MODE)) + +/* Value is 1 if it is a good idea to tie two pseudo registers + when one has mode MODE1 and one has mode MODE2. + If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, + for any hard reg, then this must be 0 for correct output. */ +#define MODES_TIEABLE_P(MODE1, MODE2) \ + (GET_MODE_CLASS (MODE1) == GET_MODE_CLASS (MODE2)) + +#define VALID_IWMMXT_REG_MODE(MODE) \ + (arm_vector_mode_supported_p (MODE) || (MODE) == DImode) + +/* Modes valid for Neon D registers. */ +#define VALID_NEON_DREG_MODE(MODE) \ + ((MODE) == V2SImode || (MODE) == V4HImode || (MODE) == V8QImode \ + || (MODE) == V2SFmode || (MODE) == DImode) + +/* Modes valid for Neon Q registers. */ +#define VALID_NEON_QREG_MODE(MODE) \ + ((MODE) == V4SImode || (MODE) == V8HImode || (MODE) == V16QImode \ + || (MODE) == V4SFmode || (MODE) == V2DImode) + +/* Structure modes valid for Neon registers. */ +#define VALID_NEON_STRUCT_MODE(MODE) \ + ((MODE) == TImode || (MODE) == EImode || (MODE) == OImode \ + || (MODE) == CImode || (MODE) == XImode) + +/* The register numbers in sequence, for passing to arm_gen_load_multiple. */ +extern int arm_regs_in_sequence[]; + +/* The order in which register should be allocated. It is good to use ip + since no saving is required (though calls clobber it) and it never contains + function parameters. It is quite good to use lr since other calls may + clobber it anyway. Allocate r0 through r3 in reverse order since r3 is + least likely to contain a function parameter; in addition results are + returned in r0. + For VFP/VFPv3, allocate D16-D31 first, then caller-saved registers (D0-D7), + then D8-D15. The reason for doing this is to attempt to reduce register + pressure when both single- and double-precision registers are used in a + function. */ + +#define REG_ALLOC_ORDER \ +{ \ + 3, 2, 1, 0, 12, 14, 4, 5, \ + 6, 7, 8, 10, 9, 11, 13, 15, \ + 16, 17, 18, 19, 20, 21, 22, 23, \ + 27, 28, 29, 30, 31, 32, 33, 34, \ + 35, 36, 37, 38, 39, 40, 41, 42, \ + 43, 44, 45, 46, 47, 48, 49, 50, \ + 51, 52, 53, 54, 55, 56, 57, 58, \ + 59, 60, 61, 62, \ + 24, 25, 26, \ + 95, 96, 97, 98, 99, 100, 101, 102, \ + 103, 104, 105, 106, 107, 108, 109, 110, \ + 111, 112, 113, 114, 115, 116, 117, 118, \ + 119, 120, 121, 122, 123, 124, 125, 126, \ + 78, 77, 76, 75, 74, 73, 72, 71, \ + 70, 69, 68, 67, 66, 65, 64, 63, \ + 79, 80, 81, 82, 83, 84, 85, 86, \ + 87, 88, 89, 90, 91, 92, 93, 94, \ + 127 \ +} + +/* Use different register alloc ordering for Thumb. */ +#define ADJUST_REG_ALLOC_ORDER arm_order_regs_for_local_alloc () + +/* Tell IRA to use the order we define rather than messing it up with its + own cost calculations. */ +#define HONOR_REG_ALLOC_ORDER + +/* Interrupt functions can only use registers that have already been + saved by the prologue, even if they would normally be + call-clobbered. */ +#define HARD_REGNO_RENAME_OK(SRC, DST) \ + (! IS_INTERRUPT (cfun->machine->func_type) || \ + df_regs_ever_live_p (DST)) + +/* Register and constant classes. */ + +/* Register classes: used to be simple, just all ARM regs or all FPA regs + Now that the Thumb is involved it has become more complicated. */ +enum reg_class +{ + NO_REGS, + FPA_REGS, + CIRRUS_REGS, + VFP_D0_D7_REGS, + VFP_LO_REGS, + VFP_HI_REGS, + VFP_REGS, + IWMMXT_GR_REGS, + IWMMXT_REGS, + LO_REGS, + STACK_REG, + BASE_REGS, + HI_REGS, + CC_REG, + VFPCC_REG, + GENERAL_REGS, + CORE_REGS, + ALL_REGS, + LIM_REG_CLASSES +}; + +#define N_REG_CLASSES (int) LIM_REG_CLASSES + +/* Give names of register classes as strings for dump file. */ +#define REG_CLASS_NAMES \ +{ \ + "NO_REGS", \ + "FPA_REGS", \ + "CIRRUS_REGS", \ + "VFP_D0_D7_REGS", \ + "VFP_LO_REGS", \ + "VFP_HI_REGS", \ + "VFP_REGS", \ + "IWMMXT_GR_REGS", \ + "IWMMXT_REGS", \ + "LO_REGS", \ + "STACK_REG", \ + "BASE_REGS", \ + "HI_REGS", \ + "CC_REG", \ + "VFPCC_REG", \ + "GENERAL_REGS", \ + "CORE_REGS", \ + "ALL_REGS", \ +} + +/* Define which registers fit in which classes. + This is an initializer for a vector of HARD_REG_SET + of length N_REG_CLASSES. */ +#define REG_CLASS_CONTENTS \ +{ \ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* NO_REGS */ \ + { 0x00FF0000, 0x00000000, 0x00000000, 0x00000000 }, /* FPA_REGS */ \ + { 0xF8000000, 0x000007FF, 0x00000000, 0x00000000 }, /* CIRRUS_REGS */ \ + { 0x00000000, 0x80000000, 0x00007FFF, 0x00000000 }, /* VFP_D0_D7_REGS */ \ + { 0x00000000, 0x80000000, 0x7FFFFFFF, 0x00000000 }, /* VFP_LO_REGS */ \ + { 0x00000000, 0x00000000, 0x80000000, 0x7FFFFFFF }, /* VFP_HI_REGS */ \ + { 0x00000000, 0x80000000, 0xFFFFFFFF, 0x7FFFFFFF }, /* VFP_REGS */ \ + { 0x00000000, 0x00007800, 0x00000000, 0x00000000 }, /* IWMMXT_GR_REGS */ \ + { 0x00000000, 0x7FFF8000, 0x00000000, 0x00000000 }, /* IWMMXT_REGS */ \ + { 0x000000FF, 0x00000000, 0x00000000, 0x00000000 }, /* LO_REGS */ \ + { 0x00002000, 0x00000000, 0x00000000, 0x00000000 }, /* STACK_REG */ \ + { 0x000020FF, 0x00000000, 0x00000000, 0x00000000 }, /* BASE_REGS */ \ + { 0x0000DF00, 0x00000000, 0x00000000, 0x00000000 }, /* HI_REGS */ \ + { 0x01000000, 0x00000000, 0x00000000, 0x00000000 }, /* CC_REG */ \ + { 0x00000000, 0x00000000, 0x00000000, 0x80000000 }, /* VFPCC_REG */ \ + { 0x0000DFFF, 0x00000000, 0x00000000, 0x00000000 }, /* GENERAL_REGS */ \ + { 0x0000FFFF, 0x00000000, 0x00000000, 0x00000000 }, /* CORE_REGS */ \ + { 0xFAFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF } /* ALL_REGS */ \ +} + +/* Any of the VFP register classes. */ +#define IS_VFP_CLASS(X) \ + ((X) == VFP_D0_D7_REGS || (X) == VFP_LO_REGS \ + || (X) == VFP_HI_REGS || (X) == VFP_REGS) + +/* The same information, inverted: + Return the class number of the smallest class containing + reg number REGNO. This could be a conditional expression + or could index an array. */ +#define REGNO_REG_CLASS(REGNO) arm_regno_class (REGNO) + +/* The following macro defines cover classes for Integrated Register + Allocator. Cover classes is a set of non-intersected register + classes covering all hard registers used for register allocation + purpose. Any move between two registers of a cover class should be + cheaper than load or store of the registers. The macro value is + array of register classes with LIM_REG_CLASSES used as the end + marker. */ + +#define IRA_COVER_CLASSES \ +{ \ + GENERAL_REGS, FPA_REGS, CIRRUS_REGS, VFP_REGS, IWMMXT_GR_REGS, IWMMXT_REGS,\ + LIM_REG_CLASSES \ +} + +/* FPA registers can't do subreg as all values are reformatted to internal + precision. VFP registers may only be accessed in the mode they + were set. */ +#define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \ + (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO) \ + ? reg_classes_intersect_p (FPA_REGS, (CLASS)) \ + || reg_classes_intersect_p (VFP_REGS, (CLASS)) \ + : 0) + +/* The class value for index registers, and the one for base regs. */ +#define INDEX_REG_CLASS (TARGET_THUMB1 ? LO_REGS : GENERAL_REGS) +#define BASE_REG_CLASS (TARGET_THUMB1 ? LO_REGS : CORE_REGS) + +/* For the Thumb the high registers cannot be used as base registers + when addressing quantities in QI or HI mode; if we don't know the + mode, then we must be conservative. */ +#define MODE_BASE_REG_CLASS(MODE) \ + (TARGET_32BIT ? CORE_REGS : \ + (((MODE) == SImode) ? BASE_REGS : LO_REGS)) + +/* For Thumb we can not support SP+reg addressing, so we return LO_REGS + instead of BASE_REGS. */ +#define MODE_BASE_REG_REG_CLASS(MODE) BASE_REG_CLASS + +/* When this hook returns true for MODE, the compiler allows + registers explicitly used in the rtl to be used as spill registers + but prevents the compiler from extending the lifetime of these + registers. */ +#define TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P \ + arm_small_register_classes_for_mode_p + +/* Given an rtx X being reloaded into a reg required to be + in class CLASS, return the class of reg to actually use. + In general this is just CLASS, but for the Thumb core registers and + immediate constants we prefer a LO_REGS class or a subset. */ +#define PREFERRED_RELOAD_CLASS(X, CLASS) \ + (TARGET_32BIT ? (CLASS) : \ + ((CLASS) == GENERAL_REGS || (CLASS) == HI_REGS \ + || (CLASS) == NO_REGS || (CLASS) == STACK_REG \ + ? LO_REGS : (CLASS))) + +/* Must leave BASE_REGS reloads alone */ +#define THUMB_SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \ + ((CLASS) != LO_REGS && (CLASS) != BASE_REGS \ + ? ((true_regnum (X) == -1 ? LO_REGS \ + : (true_regnum (X) + HARD_REGNO_NREGS (0, MODE) > 8) ? LO_REGS \ + : NO_REGS)) \ + : NO_REGS) + +#define THUMB_SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \ + ((CLASS) != LO_REGS && (CLASS) != BASE_REGS \ + ? ((true_regnum (X) == -1 ? LO_REGS \ + : (true_regnum (X) + HARD_REGNO_NREGS (0, MODE) > 8) ? LO_REGS \ + : NO_REGS)) \ + : NO_REGS) + +/* Return the register class of a scratch register needed to copy IN into + or out of a register in CLASS in MODE. If it can be done directly, + NO_REGS is returned. */ +#define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \ + /* Restrict which direct reloads are allowed for VFP/iWMMXt regs. */ \ + ((TARGET_VFP && TARGET_HARD_FLOAT \ + && IS_VFP_CLASS (CLASS)) \ + ? coproc_secondary_reload_class (MODE, X, FALSE) \ + : (TARGET_IWMMXT && (CLASS) == IWMMXT_REGS) \ + ? coproc_secondary_reload_class (MODE, X, TRUE) \ + : TARGET_32BIT \ + ? (((MODE) == HImode && ! arm_arch4 && true_regnum (X) == -1) \ + ? GENERAL_REGS : NO_REGS) \ + : THUMB_SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)) + +/* If we need to load shorts byte-at-a-time, then we need a scratch. */ +#define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \ + /* Restrict which direct reloads are allowed for VFP/iWMMXt regs. */ \ + ((TARGET_VFP && TARGET_HARD_FLOAT \ + && IS_VFP_CLASS (CLASS)) \ + ? coproc_secondary_reload_class (MODE, X, FALSE) : \ + (TARGET_IWMMXT && (CLASS) == IWMMXT_REGS) ? \ + coproc_secondary_reload_class (MODE, X, TRUE) : \ + /* Cannot load constants into Cirrus registers. */ \ + (TARGET_MAVERICK && TARGET_HARD_FLOAT \ + && (CLASS) == CIRRUS_REGS \ + && (CONSTANT_P (X) || GET_CODE (X) == SYMBOL_REF)) \ + ? GENERAL_REGS : \ + (TARGET_32BIT ? \ + (((CLASS) == IWMMXT_REGS || (CLASS) == IWMMXT_GR_REGS) \ + && CONSTANT_P (X)) \ + ? GENERAL_REGS : \ + (((MODE) == HImode && ! arm_arch4 \ + && (GET_CODE (X) == MEM \ + || ((GET_CODE (X) == REG || GET_CODE (X) == SUBREG) \ + && true_regnum (X) == -1))) \ + ? GENERAL_REGS : NO_REGS) \ + : THUMB_SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X))) + +/* Try a machine-dependent way of reloading an illegitimate address + operand. If we find one, push the reload and jump to WIN. This + macro is used in only one place: `find_reloads_address' in reload.c. + + For the ARM, we wish to handle large displacements off a base + register by splitting the addend across a MOV and the mem insn. + This can cut the number of reloads needed. */ +#define ARM_LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND, WIN) \ + do \ + { \ + if (arm_legitimize_reload_address (&X, MODE, OPNUM, TYPE, IND)) \ + goto WIN; \ + } \ + while (0) + +/* XXX If an HImode FP+large_offset address is converted to an HImode + SP+large_offset address, then reload won't know how to fix it. It sees + only that SP isn't valid for HImode, and so reloads the SP into an index + register, but the resulting address is still invalid because the offset + is too big. We fix it here instead by reloading the entire address. */ +/* We could probably achieve better results by defining PROMOTE_MODE to help + cope with the variances between the Thumb's signed and unsigned byte and + halfword load instructions. */ +/* ??? This should be safe for thumb2, but we may be able to do better. */ +#define THUMB_LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_L, WIN) \ +do { \ + rtx new_x = thumb_legitimize_reload_address (&X, MODE, OPNUM, TYPE, IND_L); \ + if (new_x) \ + { \ + X = new_x; \ + goto WIN; \ + } \ +} while (0) + +#define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) \ + if (TARGET_ARM) \ + ARM_LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN); \ + else \ + THUMB_LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) + +/* Return the maximum number of consecutive registers + needed to represent mode MODE in a register of class CLASS. + ARM regs are UNITS_PER_WORD bits while FPA regs can hold any FP mode */ +#define CLASS_MAX_NREGS(CLASS, MODE) \ + (((CLASS) == FPA_REGS || (CLASS) == CIRRUS_REGS) ? 1 : ARM_NUM_REGS (MODE)) + +/* If defined, gives a class of registers that cannot be used as the + operand of a SUBREG that changes the mode of the object illegally. */ + +/* Moves between FPA_REGS and GENERAL_REGS are two memory insns. + Moves between VFP_REGS and GENERAL_REGS are a single insn, but + it is typically more expensive than a single memory access. We set + the cost to less than two memory accesses so that floating + point to integer conversion does not go through memory. */ +#define REGISTER_MOVE_COST(MODE, FROM, TO) \ + (TARGET_32BIT ? \ + ((FROM) == FPA_REGS && (TO) != FPA_REGS ? 20 : \ + (FROM) != FPA_REGS && (TO) == FPA_REGS ? 20 : \ + IS_VFP_CLASS (FROM) && !IS_VFP_CLASS (TO) ? 15 : \ + !IS_VFP_CLASS (FROM) && IS_VFP_CLASS (TO) ? 15 : \ + (FROM) == IWMMXT_REGS && (TO) != IWMMXT_REGS ? 4 : \ + (FROM) != IWMMXT_REGS && (TO) == IWMMXT_REGS ? 4 : \ + (FROM) == IWMMXT_GR_REGS || (TO) == IWMMXT_GR_REGS ? 20 : \ + (FROM) == CIRRUS_REGS && (TO) != CIRRUS_REGS ? 20 : \ + (FROM) != CIRRUS_REGS && (TO) == CIRRUS_REGS ? 20 : \ + 2) \ + : \ + ((FROM) == HI_REGS || (TO) == HI_REGS) ? 4 : 2) + +/* Stack layout; function entry, exit and calling. */ + +/* Define this if pushing a word on the stack + makes the stack pointer a smaller address. */ +#define STACK_GROWS_DOWNWARD 1 + +/* Define this to nonzero if the nominal address of the stack frame + is at the high-address end of the local variables; + that is, each additional local variable allocated + goes at a more negative offset in the frame. */ +#define FRAME_GROWS_DOWNWARD 1 + +/* The amount of scratch space needed by _interwork_{r7,r11}_call_via_rN(). + When present, it is one word in size, and sits at the top of the frame, + between the soft frame pointer and either r7 or r11. + + We only need _interwork_rM_call_via_rN() for -mcaller-super-interworking, + and only then if some outgoing arguments are passed on the stack. It would + be tempting to also check whether the stack arguments are passed by indirect + calls, but there seems to be no reason in principle why a post-reload pass + couldn't convert a direct call into an indirect one. */ +#define CALLER_INTERWORKING_SLOT_SIZE \ + (TARGET_CALLER_INTERWORKING \ + && crtl->outgoing_args_size != 0 \ + ? UNITS_PER_WORD : 0) + +/* Offset within stack frame to start allocating local variables at. + If FRAME_GROWS_DOWNWARD, this is the offset to the END of the + first local allocated. Otherwise, it is the offset to the BEGINNING + of the first local allocated. */ +#define STARTING_FRAME_OFFSET 0 + +/* If we generate an insn to push BYTES bytes, + this says how many the stack pointer really advances by. */ +/* The push insns do not do this rounding implicitly. + So don't define this. */ +/* #define PUSH_ROUNDING(NPUSHED) ROUND_UP_WORD (NPUSHED) */ + +/* Define this if the maximum size of all the outgoing args is to be + accumulated and pushed during the prologue. The amount can be + found in the variable crtl->outgoing_args_size. */ +#define ACCUMULATE_OUTGOING_ARGS 1 + +/* Offset of first parameter from the argument pointer register value. */ +#define FIRST_PARM_OFFSET(FNDECL) (TARGET_ARM ? 4 : 0) + +/* Define how to find the value returned by a library function + assuming the value has mode MODE. */ +#define LIBCALL_VALUE(MODE) \ + (TARGET_AAPCS_BASED ? aapcs_libcall_value (MODE) \ + : (TARGET_32BIT && TARGET_HARD_FLOAT_ABI && TARGET_FPA \ + && GET_MODE_CLASS (MODE) == MODE_FLOAT) \ + ? gen_rtx_REG (MODE, FIRST_FPA_REGNUM) \ + : TARGET_32BIT && TARGET_HARD_FLOAT_ABI && TARGET_MAVERICK \ + && GET_MODE_CLASS (MODE) == MODE_FLOAT \ + ? gen_rtx_REG (MODE, FIRST_CIRRUS_FP_REGNUM) \ + : TARGET_IWMMXT_ABI && arm_vector_mode_supported_p (MODE) \ + ? gen_rtx_REG (MODE, FIRST_IWMMXT_REGNUM) \ + : gen_rtx_REG (MODE, ARG_REGISTER (1))) + +/* 1 if REGNO is a possible register number for a function value. */ +#define FUNCTION_VALUE_REGNO_P(REGNO) \ + ((REGNO) == ARG_REGISTER (1) \ + || (TARGET_AAPCS_BASED && TARGET_32BIT \ + && TARGET_VFP && TARGET_HARD_FLOAT \ + && (REGNO) == FIRST_VFP_REGNUM) \ + || (TARGET_32BIT && ((REGNO) == FIRST_CIRRUS_FP_REGNUM) \ + && TARGET_HARD_FLOAT_ABI && TARGET_MAVERICK) \ + || ((REGNO) == FIRST_IWMMXT_REGNUM && TARGET_IWMMXT_ABI) \ + || (TARGET_32BIT && ((REGNO) == FIRST_FPA_REGNUM) \ + && TARGET_HARD_FLOAT_ABI && TARGET_FPA)) + +/* Amount of memory needed for an untyped call to save all possible return + registers. */ +#define APPLY_RESULT_SIZE arm_apply_result_size() + +/* Define DEFAULT_PCC_STRUCT_RETURN to 1 if all structure and union return + values must be in memory. On the ARM, they need only do so if larger + than a word, or if they contain elements offset from zero in the struct. */ +#define DEFAULT_PCC_STRUCT_RETURN 0 + +/* These bits describe the different types of function supported + by the ARM backend. They are exclusive. i.e. a function cannot be both a + normal function and an interworked function, for example. Knowing the + type of a function is important for determining its prologue and + epilogue sequences. + Note value 7 is currently unassigned. Also note that the interrupt + function types all have bit 2 set, so that they can be tested for easily. + Note that 0 is deliberately chosen for ARM_FT_UNKNOWN so that when the + machine_function structure is initialized (to zero) func_type will + default to unknown. This will force the first use of arm_current_func_type + to call arm_compute_func_type. */ +#define ARM_FT_UNKNOWN 0 /* Type has not yet been determined. */ +#define ARM_FT_NORMAL 1 /* Your normal, straightforward function. */ +#define ARM_FT_INTERWORKED 2 /* A function that supports interworking. */ +#define ARM_FT_ISR 4 /* An interrupt service routine. */ +#define ARM_FT_FIQ 5 /* A fast interrupt service routine. */ +#define ARM_FT_EXCEPTION 6 /* An ARM exception handler (subcase of ISR). */ + +#define ARM_FT_TYPE_MASK ((1 << 3) - 1) + +/* In addition functions can have several type modifiers, + outlined by these bit masks: */ +#define ARM_FT_INTERRUPT (1 << 2) /* Note overlap with FT_ISR and above. */ +#define ARM_FT_NAKED (1 << 3) /* No prologue or epilogue. */ +#define ARM_FT_VOLATILE (1 << 4) /* Does not return. */ +#define ARM_FT_NESTED (1 << 5) /* Embedded inside another func. */ +#define ARM_FT_STACKALIGN (1 << 6) /* Called with misaligned stack. */ + +/* Some macros to test these flags. */ +#define ARM_FUNC_TYPE(t) (t & ARM_FT_TYPE_MASK) +#define IS_INTERRUPT(t) (t & ARM_FT_INTERRUPT) +#define IS_VOLATILE(t) (t & ARM_FT_VOLATILE) +#define IS_NAKED(t) (t & ARM_FT_NAKED) +#define IS_NESTED(t) (t & ARM_FT_NESTED) +#define IS_STACKALIGN(t) (t & ARM_FT_STACKALIGN) + + +/* Structure used to hold the function stack frame layout. Offsets are + relative to the stack pointer on function entry. Positive offsets are + in the direction of stack growth. + Only soft_frame is used in thumb mode. */ + +typedef struct GTY(()) arm_stack_offsets +{ + int saved_args; /* ARG_POINTER_REGNUM. */ + int frame; /* ARM_HARD_FRAME_POINTER_REGNUM. */ + int saved_regs; + int soft_frame; /* FRAME_POINTER_REGNUM. */ + int locals_base; /* THUMB_HARD_FRAME_POINTER_REGNUM. */ + int outgoing_args; /* STACK_POINTER_REGNUM. */ + unsigned int saved_regs_mask; +} +arm_stack_offsets; + +#ifndef GENERATOR_FILE +/* A C structure for machine-specific, per-function data. + This is added to the cfun structure. */ +typedef struct GTY(()) machine_function +{ + /* Additional stack adjustment in __builtin_eh_throw. */ + rtx eh_epilogue_sp_ofs; + /* Records if LR has to be saved for far jumps. */ + int far_jump_used; + /* Records if ARG_POINTER was ever live. */ + int arg_pointer_live; + /* Records if the save of LR has been eliminated. */ + int lr_save_eliminated; + /* The size of the stack frame. Only valid after reload. */ + arm_stack_offsets stack_offsets; + /* Records the type of the current function. */ + unsigned long func_type; + /* Record if the function has a variable argument list. */ + int uses_anonymous_args; + /* Records if sibcalls are blocked because an argument + register is needed to preserve stack alignment. */ + int sibcall_blocked; + /* The PIC register for this function. This might be a pseudo. */ + rtx pic_reg; + /* Labels for per-function Thumb call-via stubs. One per potential calling + register. We can never call via LR or PC. We can call via SP if a + trampoline happens to be on the top of the stack. */ + rtx call_via[14]; + /* Set to 1 when a return insn is output, this means that the epilogue + is not needed. */ + int return_used_this_function; + /* When outputting Thumb-1 code, record the last insn that provides + information about condition codes, and the comparison operands. */ + rtx thumb1_cc_insn; + rtx thumb1_cc_op0; + rtx thumb1_cc_op1; + /* Also record the CC mode that is supported. */ + enum machine_mode thumb1_cc_mode; +} +machine_function; +#endif + +/* As in the machine_function, a global set of call-via labels, for code + that is in text_section. */ +extern GTY(()) rtx thumb_call_via_label[14]; + +/* The number of potential ways of assigning to a co-processor. */ +#define ARM_NUM_COPROC_SLOTS 1 + +/* Enumeration of procedure calling standard variants. We don't really + support all of these yet. */ +enum arm_pcs +{ + ARM_PCS_AAPCS, /* Base standard AAPCS. */ + ARM_PCS_AAPCS_VFP, /* Use VFP registers for floating point values. */ + ARM_PCS_AAPCS_IWMMXT, /* Use iWMMXT registers for vectors. */ + /* This must be the last AAPCS variant. */ + ARM_PCS_AAPCS_LOCAL, /* Private call within this compilation unit. */ + ARM_PCS_ATPCS, /* ATPCS. */ + ARM_PCS_APCS, /* APCS (legacy Linux etc). */ + ARM_PCS_UNKNOWN +}; + +/* Default procedure calling standard of current compilation unit. */ +extern enum arm_pcs arm_pcs_default; + +/* A C type for declaring a variable that is used as the first argument of + `FUNCTION_ARG' and other related values. */ +typedef struct +{ + /* This is the number of registers of arguments scanned so far. */ + int nregs; + /* This is the number of iWMMXt register arguments scanned so far. */ + int iwmmxt_nregs; + int named_count; + int nargs; + /* Which procedure call variant to use for this call. */ + enum arm_pcs pcs_variant; + + /* AAPCS related state tracking. */ + int aapcs_arg_processed; /* No need to lay out this argument again. */ + int aapcs_cprc_slot; /* Index of co-processor rules to handle + this argument, or -1 if using core + registers. */ + int aapcs_ncrn; + int aapcs_next_ncrn; + rtx aapcs_reg; /* Register assigned to this argument. */ + int aapcs_partial; /* How many bytes are passed in regs (if + split between core regs and stack. + Zero otherwise. */ + int aapcs_cprc_failed[ARM_NUM_COPROC_SLOTS]; + int can_split; /* Argument can be split between core regs + and the stack. */ + /* Private data for tracking VFP register allocation */ + unsigned aapcs_vfp_regs_free; + unsigned aapcs_vfp_reg_alloc; + int aapcs_vfp_rcount; + MACHMODE aapcs_vfp_rmode; +} CUMULATIVE_ARGS; + +#define FUNCTION_ARG_PADDING(MODE, TYPE) \ + (arm_pad_arg_upward (MODE, TYPE) ? upward : downward) + +#define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \ + (arm_pad_reg_upward (MODE, TYPE, FIRST) ? upward : downward) + +/* For AAPCS, padding should never be below the argument. For other ABIs, + * mimic the default. */ +#define PAD_VARARGS_DOWN \ + ((TARGET_AAPCS_BASED) ? 0 : BYTES_BIG_ENDIAN) + +/* Initialize a variable CUM of type CUMULATIVE_ARGS + for a call to a function whose data type is FNTYPE. + For a library call, FNTYPE is 0. + On the ARM, the offset starts at 0. */ +#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ + arm_init_cumulative_args (&(CUM), (FNTYPE), (LIBNAME), (FNDECL)) + +/* 1 if N is a possible register number for function argument passing. + On the ARM, r0-r3 are used to pass args. */ +#define FUNCTION_ARG_REGNO_P(REGNO) \ + (IN_RANGE ((REGNO), 0, 3) \ + || (TARGET_AAPCS_BASED && TARGET_VFP && TARGET_HARD_FLOAT \ + && IN_RANGE ((REGNO), FIRST_VFP_REGNUM, FIRST_VFP_REGNUM + 15)) \ + || (TARGET_IWMMXT_ABI \ + && IN_RANGE ((REGNO), FIRST_IWMMXT_REGNUM, FIRST_IWMMXT_REGNUM + 9))) + + +/* If your target environment doesn't prefix user functions with an + underscore, you may wish to re-define this to prevent any conflicts. */ +#ifndef ARM_MCOUNT_NAME +#define ARM_MCOUNT_NAME "*mcount" +#endif + +/* Call the function profiler with a given profile label. The Acorn + compiler puts this BEFORE the prolog but gcc puts it afterwards. + On the ARM the full profile code will look like: + .data + LP1 + .word 0 + .text + mov ip, lr + bl mcount + .word LP1 + + profile_function() in final.c outputs the .data section, FUNCTION_PROFILER + will output the .text section. + + The ``mov ip,lr'' seems like a good idea to stick with cc convention. + ``prof'' doesn't seem to mind about this! + + Note - this version of the code is designed to work in both ARM and + Thumb modes. */ +#ifndef ARM_FUNCTION_PROFILER +#define ARM_FUNCTION_PROFILER(STREAM, LABELNO) \ +{ \ + char temp[20]; \ + rtx sym; \ + \ + asm_fprintf (STREAM, "\tmov\t%r, %r\n\tbl\t", \ + IP_REGNUM, LR_REGNUM); \ + assemble_name (STREAM, ARM_MCOUNT_NAME); \ + fputc ('\n', STREAM); \ + ASM_GENERATE_INTERNAL_LABEL (temp, "LP", LABELNO); \ + sym = gen_rtx_SYMBOL_REF (Pmode, temp); \ + assemble_aligned_integer (UNITS_PER_WORD, sym); \ +} +#endif + +#ifdef THUMB_FUNCTION_PROFILER +#define FUNCTION_PROFILER(STREAM, LABELNO) \ + if (TARGET_ARM) \ + ARM_FUNCTION_PROFILER (STREAM, LABELNO) \ + else \ + THUMB_FUNCTION_PROFILER (STREAM, LABELNO) +#else +#define FUNCTION_PROFILER(STREAM, LABELNO) \ + ARM_FUNCTION_PROFILER (STREAM, LABELNO) +#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. + No definition is equivalent to always zero. + + On the ARM, the function epilogue recovers the stack pointer from the + frame. */ +#define EXIT_IGNORE_STACK 1 + +#define EPILOGUE_USES(REGNO) ((REGNO) == LR_REGNUM) + +/* Determine if the epilogue should be output as RTL. + You should override this if you define FUNCTION_EXTRA_EPILOGUE. */ +#define USE_RETURN_INSN(ISCOND) \ + (TARGET_32BIT ? use_return_insn (ISCOND, NULL) : 0) + +/* Definitions for register eliminations. + + This is an array of structures. Each structure initializes one pair + of eliminable registers. The "from" register number is given first, + followed by "to". Eliminations of the same "from" register are listed + in order of preference. + + We have two registers that can be eliminated on the ARM. First, the + arg pointer register can often be eliminated in favor of the stack + pointer register. Secondly, the pseudo frame pointer register can always + be eliminated; it is replaced with either the stack or the real frame + pointer. Note we have to use {ARM|THUMB}_HARD_FRAME_POINTER_REGNUM + because the definition of HARD_FRAME_POINTER_REGNUM is not a constant. */ + +#define ELIMINABLE_REGS \ +{{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM },\ + { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM },\ + { ARG_POINTER_REGNUM, ARM_HARD_FRAME_POINTER_REGNUM },\ + { ARG_POINTER_REGNUM, THUMB_HARD_FRAME_POINTER_REGNUM },\ + { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM },\ + { FRAME_POINTER_REGNUM, ARM_HARD_FRAME_POINTER_REGNUM },\ + { FRAME_POINTER_REGNUM, THUMB_HARD_FRAME_POINTER_REGNUM }} + +/* Define the offset between two registers, one to be eliminated, and the + other its replacement, at the start of a routine. */ +#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ + if (TARGET_ARM) \ + (OFFSET) = arm_compute_initial_elimination_offset (FROM, TO); \ + else \ + (OFFSET) = thumb_compute_initial_elimination_offset (FROM, TO) + +/* Special case handling of the location of arguments passed on the stack. */ +#define DEBUGGER_ARG_OFFSET(value, addr) value ? value : arm_debugger_arg_offset (value, addr) + +/* Initialize data used by insn expanders. This is called from insn_emit, + once for every function before code is generated. */ +#define INIT_EXPANDERS arm_init_expanders () + +/* Length in units of the trampoline for entering a nested function. */ +#define TRAMPOLINE_SIZE (TARGET_32BIT ? 16 : 20) + +/* Alignment required for a trampoline in bits. */ +#define TRAMPOLINE_ALIGNMENT 32 + +/* Addressing modes, and classification of registers for them. */ +#define HAVE_POST_INCREMENT 1 +#define HAVE_PRE_INCREMENT TARGET_32BIT +#define HAVE_POST_DECREMENT TARGET_32BIT +#define HAVE_PRE_DECREMENT TARGET_32BIT +#define HAVE_PRE_MODIFY_DISP TARGET_32BIT +#define HAVE_POST_MODIFY_DISP TARGET_32BIT +#define HAVE_PRE_MODIFY_REG TARGET_32BIT +#define HAVE_POST_MODIFY_REG TARGET_32BIT + +/* Macros to check register numbers against specific register classes. */ + +/* These assume that REGNO is a hard or pseudo reg number. + They give nonzero only if REGNO is a hard reg of the suitable class + or a pseudo reg currently allocated to a suitable hard reg. + Since they use reg_renumber, they are safe only once reg_renumber + has been allocated, which happens in local-alloc.c. */ +#define TEST_REGNO(R, TEST, VALUE) \ + ((R TEST VALUE) || ((unsigned) reg_renumber[R] TEST VALUE)) + +/* Don't allow the pc to be used. */ +#define ARM_REGNO_OK_FOR_BASE_P(REGNO) \ + (TEST_REGNO (REGNO, <, PC_REGNUM) \ + || TEST_REGNO (REGNO, ==, FRAME_POINTER_REGNUM) \ + || TEST_REGNO (REGNO, ==, ARG_POINTER_REGNUM)) + +#define THUMB1_REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \ + (TEST_REGNO (REGNO, <=, LAST_LO_REGNUM) \ + || (GET_MODE_SIZE (MODE) >= 4 \ + && TEST_REGNO (REGNO, ==, STACK_POINTER_REGNUM))) + +#define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \ + (TARGET_THUMB1 \ + ? THUMB1_REGNO_MODE_OK_FOR_BASE_P (REGNO, MODE) \ + : ARM_REGNO_OK_FOR_BASE_P (REGNO)) + +/* Nonzero if X can be the base register in a reg+reg addressing mode. + For Thumb, we can not use SP + reg, so reject SP. */ +#define REGNO_MODE_OK_FOR_REG_BASE_P(X, MODE) \ + REGNO_MODE_OK_FOR_BASE_P (X, QImode) + +/* For ARM code, we don't care about the mode, but for Thumb, the index + must be suitable for use in a QImode load. */ +#define REGNO_OK_FOR_INDEX_P(REGNO) \ + (REGNO_MODE_OK_FOR_BASE_P (REGNO, QImode) \ + && !TEST_REGNO (REGNO, ==, STACK_POINTER_REGNUM)) + +/* Maximum number of registers that can appear in a valid memory address. + Shifts in addresses can't be by a register. */ +#define MAX_REGS_PER_ADDRESS 2 + +/* Recognize any constant value that is a valid address. */ +/* XXX We can address any constant, eventually... */ +/* ??? Should the TARGET_ARM here also apply to thumb2? */ +#define CONSTANT_ADDRESS_P(X) \ + (GET_CODE (X) == SYMBOL_REF \ + && (CONSTANT_POOL_ADDRESS_P (X) \ + || (TARGET_ARM && optimize > 0 && SYMBOL_REF_FLAG (X)))) + +/* True if SYMBOL + OFFSET constants must refer to something within + SYMBOL's section. */ +#define ARM_OFFSETS_MUST_BE_WITHIN_SECTIONS_P 0 + +/* Nonzero if all target requires all absolute relocations be R_ARM_ABS32. */ +#ifndef TARGET_DEFAULT_WORD_RELOCATIONS +#define TARGET_DEFAULT_WORD_RELOCATIONS 0 +#endif + +/* Nonzero if the constant value X is a legitimate general operand. + It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. + + On the ARM, allow any integer (invalid ones are removed later by insn + patterns), nice doubles and symbol_refs which refer to the function's + constant pool XXX. + + When generating pic allow anything. */ +#define ARM_LEGITIMATE_CONSTANT_P(X) (flag_pic || ! label_mentioned_p (X)) + +#define THUMB_LEGITIMATE_CONSTANT_P(X) \ + ( GET_CODE (X) == CONST_INT \ + || GET_CODE (X) == CONST_DOUBLE \ + || CONSTANT_ADDRESS_P (X) \ + || flag_pic) + +#define LEGITIMATE_CONSTANT_P(X) \ + (!arm_cannot_force_const_mem (X) \ + && (TARGET_32BIT ? ARM_LEGITIMATE_CONSTANT_P (X) \ + : THUMB_LEGITIMATE_CONSTANT_P (X))) + +#ifndef SUBTARGET_NAME_ENCODING_LENGTHS +#define SUBTARGET_NAME_ENCODING_LENGTHS +#endif + +/* This is a C fragment for the inside of a switch statement. + Each case label should return the number of characters to + be stripped from the start of a function's name, if that + name starts with the indicated character. */ +#define ARM_NAME_ENCODING_LENGTHS \ + case '*': return 1; \ + SUBTARGET_NAME_ENCODING_LENGTHS + +/* This is how to output a reference to a user-level label named NAME. + `assemble_name' uses this. */ +#undef ASM_OUTPUT_LABELREF +#define ASM_OUTPUT_LABELREF(FILE, NAME) \ + arm_asm_output_labelref (FILE, NAME) + +/* Output IT instructions for conditionally executed Thumb-2 instructions. */ +#define ASM_OUTPUT_OPCODE(STREAM, PTR) \ + if (TARGET_THUMB2) \ + thumb2_asm_output_opcode (STREAM); + +/* The EABI specifies that constructors should go in .init_array. + Other targets use .ctors for compatibility. */ +#ifndef ARM_EABI_CTORS_SECTION_OP +#define ARM_EABI_CTORS_SECTION_OP \ + "\t.section\t.init_array,\"aw\",%init_array" +#endif +#ifndef ARM_EABI_DTORS_SECTION_OP +#define ARM_EABI_DTORS_SECTION_OP \ + "\t.section\t.fini_array,\"aw\",%fini_array" +#endif +#define ARM_CTORS_SECTION_OP \ + "\t.section\t.ctors,\"aw\",%progbits" +#define ARM_DTORS_SECTION_OP \ + "\t.section\t.dtors,\"aw\",%progbits" + +/* Define CTORS_SECTION_ASM_OP. */ +#undef CTORS_SECTION_ASM_OP +#undef DTORS_SECTION_ASM_OP +#ifndef IN_LIBGCC2 +# define CTORS_SECTION_ASM_OP \ + (TARGET_AAPCS_BASED ? ARM_EABI_CTORS_SECTION_OP : ARM_CTORS_SECTION_OP) +# define DTORS_SECTION_ASM_OP \ + (TARGET_AAPCS_BASED ? ARM_EABI_DTORS_SECTION_OP : ARM_DTORS_SECTION_OP) +#else /* !defined (IN_LIBGCC2) */ +/* In libgcc, CTORS_SECTION_ASM_OP must be a compile-time constant, + so we cannot use the definition above. */ +# ifdef __ARM_EABI__ +/* The .ctors section is not part of the EABI, so we do not define + CTORS_SECTION_ASM_OP when in libgcc; that prevents crtstuff + from trying to use it. We do define it when doing normal + compilation, as .init_array can be used instead of .ctors. */ +/* There is no need to emit begin or end markers when using + init_array; the dynamic linker will compute the size of the + array itself based on special symbols created by the static + linker. However, we do need to arrange to set up + exception-handling here. */ +# define CTOR_LIST_BEGIN asm (ARM_EABI_CTORS_SECTION_OP) +# define CTOR_LIST_END /* empty */ +# define DTOR_LIST_BEGIN asm (ARM_EABI_DTORS_SECTION_OP) +# define DTOR_LIST_END /* empty */ +# else /* !defined (__ARM_EABI__) */ +# define CTORS_SECTION_ASM_OP ARM_CTORS_SECTION_OP +# define DTORS_SECTION_ASM_OP ARM_DTORS_SECTION_OP +# endif /* !defined (__ARM_EABI__) */ +#endif /* !defined (IN_LIBCC2) */ + +/* True if the operating system can merge entities with vague linkage + (e.g., symbols in COMDAT group) during dynamic linking. */ +#ifndef TARGET_ARM_DYNAMIC_VAGUE_LINKAGE_P +#define TARGET_ARM_DYNAMIC_VAGUE_LINKAGE_P true +#endif + +#define ARM_OUTPUT_FN_UNWIND(F, PROLOGUE) arm_output_fn_unwind (F, PROLOGUE) + +/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx + and check its validity for a certain class. + We have two alternate definitions for each of them. + The usual definition accepts all pseudo regs; the other rejects + them unless they have been allocated suitable hard regs. + The symbol REG_OK_STRICT causes the latter definition to be used. + Thumb-2 has the same restrictions as arm. */ +#ifndef REG_OK_STRICT + +#define ARM_REG_OK_FOR_BASE_P(X) \ + (REGNO (X) <= LAST_ARM_REGNUM \ + || REGNO (X) >= FIRST_PSEUDO_REGISTER \ + || REGNO (X) == FRAME_POINTER_REGNUM \ + || REGNO (X) == ARG_POINTER_REGNUM) + +#define ARM_REG_OK_FOR_INDEX_P(X) \ + ((REGNO (X) <= LAST_ARM_REGNUM \ + && REGNO (X) != STACK_POINTER_REGNUM) \ + || REGNO (X) >= FIRST_PSEUDO_REGISTER \ + || REGNO (X) == FRAME_POINTER_REGNUM \ + || REGNO (X) == ARG_POINTER_REGNUM) + +#define THUMB1_REG_MODE_OK_FOR_BASE_P(X, MODE) \ + (REGNO (X) <= LAST_LO_REGNUM \ + || REGNO (X) >= FIRST_PSEUDO_REGISTER \ + || (GET_MODE_SIZE (MODE) >= 4 \ + && (REGNO (X) == STACK_POINTER_REGNUM \ + || (X) == hard_frame_pointer_rtx \ + || (X) == arg_pointer_rtx))) + +#define REG_STRICT_P 0 + +#else /* REG_OK_STRICT */ + +#define ARM_REG_OK_FOR_BASE_P(X) \ + ARM_REGNO_OK_FOR_BASE_P (REGNO (X)) + +#define ARM_REG_OK_FOR_INDEX_P(X) \ + ARM_REGNO_OK_FOR_INDEX_P (REGNO (X)) + +#define THUMB1_REG_MODE_OK_FOR_BASE_P(X, MODE) \ + THUMB1_REGNO_MODE_OK_FOR_BASE_P (REGNO (X), MODE) + +#define REG_STRICT_P 1 + +#endif /* REG_OK_STRICT */ + +/* Now define some helpers in terms of the above. */ + +#define REG_MODE_OK_FOR_BASE_P(X, MODE) \ + (TARGET_THUMB1 \ + ? THUMB1_REG_MODE_OK_FOR_BASE_P (X, MODE) \ + : ARM_REG_OK_FOR_BASE_P (X)) + +/* For 16-bit Thumb, a valid index register is anything that can be used in + a byte load instruction. */ +#define THUMB1_REG_OK_FOR_INDEX_P(X) \ + THUMB1_REG_MODE_OK_FOR_BASE_P (X, QImode) + +/* Nonzero if X is a hard reg that can be used as an index + or if it is a pseudo reg. On the Thumb, the stack pointer + is not suitable. */ +#define REG_OK_FOR_INDEX_P(X) \ + (TARGET_THUMB1 \ + ? THUMB1_REG_OK_FOR_INDEX_P (X) \ + : ARM_REG_OK_FOR_INDEX_P (X)) + +/* Nonzero if X can be the base register in a reg+reg addressing mode. + For Thumb, we can not use SP + reg, so reject SP. */ +#define REG_MODE_OK_FOR_REG_BASE_P(X, MODE) \ + REG_OK_FOR_INDEX_P (X) + +#define ARM_BASE_REGISTER_RTX_P(X) \ + (GET_CODE (X) == REG && ARM_REG_OK_FOR_BASE_P (X)) + +#define ARM_INDEX_REGISTER_RTX_P(X) \ + (GET_CODE (X) == REG && ARM_REG_OK_FOR_INDEX_P (X)) + +/* Specify the machine mode that this machine uses + for the index in the tablejump instruction. */ +#define CASE_VECTOR_MODE Pmode + +#define CASE_VECTOR_PC_RELATIVE (TARGET_THUMB2 \ + || (TARGET_THUMB1 \ + && (optimize_size || flag_pic))) + +#define CASE_VECTOR_SHORTEN_MODE(min, max, body) \ + (TARGET_THUMB1 \ + ? (min >= 0 && max < 512 \ + ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 1, QImode) \ + : min >= -256 && max < 256 \ + ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 0, QImode) \ + : min >= 0 && max < 8192 \ + ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 1, HImode) \ + : min >= -4096 && max < 4096 \ + ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 0, HImode) \ + : SImode) \ + : ((min < 0 || max >= 0x2000 || !TARGET_THUMB2) ? SImode \ + : (max >= 0x200) ? HImode \ + : QImode)) + +/* signed 'char' is most compatible, but RISC OS wants it unsigned. + unsigned is probably best, but may break some code. */ +#ifndef DEFAULT_SIGNED_CHAR +#define DEFAULT_SIGNED_CHAR 0 +#endif + +/* Max number of bytes we can move from memory to memory + in one reasonably fast instruction. */ +#define MOVE_MAX 4 + +#undef MOVE_RATIO +#define MOVE_RATIO(speed) (arm_tune_xscale ? 4 : 2) + +/* Define if operations between registers always perform the operation + on the full register even if a narrower mode is specified. */ +#define WORD_REGISTER_OPERATIONS + +/* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD + will either zero-extend or sign-extend. The value of this macro should + be the code that says which one of the two operations is implicitly + done, UNKNOWN if none. */ +#define LOAD_EXTEND_OP(MODE) \ + (TARGET_THUMB ? ZERO_EXTEND : \ + ((arm_arch4 || (MODE) == QImode) ? ZERO_EXTEND \ + : ((BYTES_BIG_ENDIAN && (MODE) == HImode) ? SIGN_EXTEND : UNKNOWN))) + +/* Nonzero if access to memory by bytes is slow and undesirable. */ +#define SLOW_BYTE_ACCESS 0 + +#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1 + +/* Immediate shift counts are truncated by the output routines (or was it + the assembler?). Shift counts in a register are truncated by ARM. Note + that the native compiler puts too large (> 32) immediate shift counts + into a register and shifts by the register, letting the ARM decide what + to do instead of doing that itself. */ +/* This is all wrong. Defining SHIFT_COUNT_TRUNCATED tells combine that + code like (X << (Y % 32)) for register X, Y is equivalent to (X << Y). + On the arm, Y in a register is used modulo 256 for the shift. Only for + rotates is modulo 32 used. */ +/* #define SHIFT_COUNT_TRUNCATED 1 */ + +/* All integers have the same format so truncation is easy. */ +#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 + +/* Calling from registers is a massive pain. */ +#define NO_FUNCTION_CSE 1 + +/* The machine modes of pointers and functions */ +#define Pmode SImode +#define FUNCTION_MODE Pmode + +#define ARM_FRAME_RTX(X) \ + ( (X) == frame_pointer_rtx || (X) == stack_pointer_rtx \ + || (X) == arg_pointer_rtx) + +/* Moves to and from memory are quite expensive */ +#define MEMORY_MOVE_COST(M, CLASS, IN) \ + (TARGET_32BIT ? 10 : \ + ((GET_MODE_SIZE (M) < 4 ? 8 : 2 * GET_MODE_SIZE (M)) \ + * (CLASS == LO_REGS ? 1 : 2))) + +/* Try to generate sequences that don't involve branches, we can then use + conditional instructions */ +#define BRANCH_COST(speed_p, predictable_p) \ + (TARGET_32BIT ? 4 : (optimize > 0 ? 2 : 0)) + +/* Position Independent Code. */ +/* We decide which register to use based on the compilation options and + the assembler in use; this is more general than the APCS restriction of + using sb (r9) all the time. */ +extern unsigned arm_pic_register; + +/* The register number of the register used to address a table of static + data addresses in memory. */ +#define PIC_OFFSET_TABLE_REGNUM arm_pic_register + +/* We can't directly access anything that contains a symbol, + nor can we indirect via the constant pool. One exception is + UNSPEC_TLS, which is always PIC. */ +#define LEGITIMATE_PIC_OPERAND_P(X) \ + (!(symbol_mentioned_p (X) \ + || label_mentioned_p (X) \ + || (GET_CODE (X) == SYMBOL_REF \ + && CONSTANT_POOL_ADDRESS_P (X) \ + && (symbol_mentioned_p (get_pool_constant (X)) \ + || label_mentioned_p (get_pool_constant (X))))) \ + || tls_mentioned_p (X)) + +/* We need to know when we are making a constant pool; this determines + whether data needs to be in the GOT or can be referenced via a GOT + offset. */ +extern int making_const_table; + +/* Handle pragmas for compatibility with Intel's compilers. */ +/* Also abuse this to register additional C specific EABI attributes. */ +#define REGISTER_TARGET_PRAGMAS() do { \ + c_register_pragma (0, "long_calls", arm_pr_long_calls); \ + c_register_pragma (0, "no_long_calls", arm_pr_no_long_calls); \ + c_register_pragma (0, "long_calls_off", arm_pr_long_calls_off); \ + arm_lang_object_attributes_init(); \ +} while (0) + +/* Condition code information. */ +/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE, + return the mode to be used for the comparison. */ + +#define SELECT_CC_MODE(OP, X, Y) arm_select_cc_mode (OP, X, Y) + +#define REVERSIBLE_CC_MODE(MODE) 1 + +#define REVERSE_CONDITION(CODE,MODE) \ + (((MODE) == CCFPmode || (MODE) == CCFPEmode) \ + ? reverse_condition_maybe_unordered (code) \ + : reverse_condition (code)) + +#define CANONICALIZE_COMPARISON(CODE, OP0, OP1) \ + (CODE) = arm_canonicalize_comparison (CODE, &(OP0), &(OP1)) + +/* The arm5 clz instruction returns 32. */ +#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) +#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) + +#define CC_STATUS_INIT \ + do { cfun->machine->thumb1_cc_insn = NULL_RTX; } while (0) + +#undef ASM_APP_OFF +#define ASM_APP_OFF (TARGET_THUMB1 ? "\t.code\t16\n" : \ + TARGET_THUMB2 ? "\t.thumb\n" : "") + +/* Output a push or a pop instruction (only used when profiling). + We can't push STATIC_CHAIN_REGNUM (r12) directly with Thumb-1. We know + that ASM_OUTPUT_REG_PUSH will be matched with ASM_OUTPUT_REG_POP, and + that r7 isn't used by the function profiler, so we can use it as a + scratch reg. WARNING: This isn't safe in the general case! It may be + sensitive to future changes in final.c:profile_function. */ +#define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \ + do \ + { \ + if (TARGET_ARM) \ + asm_fprintf (STREAM,"\tstmfd\t%r!,{%r}\n", \ + STACK_POINTER_REGNUM, REGNO); \ + else if (TARGET_THUMB1 \ + && (REGNO) == STATIC_CHAIN_REGNUM) \ + { \ + asm_fprintf (STREAM, "\tpush\t{r7}\n"); \ + asm_fprintf (STREAM, "\tmov\tr7, %r\n", REGNO);\ + asm_fprintf (STREAM, "\tpush\t{r7}\n"); \ + } \ + else \ + asm_fprintf (STREAM, "\tpush {%r}\n", REGNO); \ + } while (0) + + +/* See comment for ASM_OUTPUT_REG_PUSH concerning Thumb-1 issue. */ +#define ASM_OUTPUT_REG_POP(STREAM, REGNO) \ + do \ + { \ + if (TARGET_ARM) \ + asm_fprintf (STREAM, "\tldmfd\t%r!,{%r}\n", \ + STACK_POINTER_REGNUM, REGNO); \ + else if (TARGET_THUMB1 \ + && (REGNO) == STATIC_CHAIN_REGNUM) \ + { \ + asm_fprintf (STREAM, "\tpop\t{r7}\n"); \ + asm_fprintf (STREAM, "\tmov\t%r, r7\n", REGNO);\ + asm_fprintf (STREAM, "\tpop\t{r7}\n"); \ + } \ + else \ + asm_fprintf (STREAM, "\tpop {%r}\n", REGNO); \ + } while (0) + +/* Jump table alignment is explicit in ASM_OUTPUT_CASE_LABEL. */ +#define ADDR_VEC_ALIGN(JUMPTABLE) 0 + +/* This is how to output a label which precedes a jumptable. Since + Thumb instructions are 2 bytes, we may need explicit alignment here. */ +#undef ASM_OUTPUT_CASE_LABEL +#define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, JUMPTABLE) \ + do \ + { \ + if (TARGET_THUMB && GET_MODE (PATTERN (JUMPTABLE)) == SImode) \ + ASM_OUTPUT_ALIGN (FILE, 2); \ + (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM); \ + } \ + while (0) + +/* Make sure subsequent insns are aligned after a TBB. */ +#define ASM_OUTPUT_CASE_END(FILE, NUM, JUMPTABLE) \ + do \ + { \ + if (GET_MODE (PATTERN (JUMPTABLE)) == QImode) \ + ASM_OUTPUT_ALIGN (FILE, 1); \ + } \ + while (0) + +#define ARM_DECLARE_FUNCTION_NAME(STREAM, NAME, DECL) \ + do \ + { \ + if (TARGET_THUMB) \ + { \ + if (is_called_in_ARM_mode (DECL) \ + || (TARGET_THUMB1 && !TARGET_THUMB1_ONLY \ + && cfun->is_thunk)) \ + fprintf (STREAM, "\t.code 32\n") ; \ + else if (TARGET_THUMB1) \ + fprintf (STREAM, "\t.code\t16\n\t.thumb_func\n") ; \ + else \ + fprintf (STREAM, "\t.thumb\n\t.thumb_func\n") ; \ + } \ + if (TARGET_POKE_FUNCTION_NAME) \ + arm_poke_function_name (STREAM, (const char *) NAME); \ + } \ + while (0) + +/* For aliases of functions we use .thumb_set instead. */ +#define ASM_OUTPUT_DEF_FROM_DECLS(FILE, DECL1, DECL2) \ + do \ + { \ + const char *const LABEL1 = XSTR (XEXP (DECL_RTL (decl), 0), 0); \ + const char *const LABEL2 = IDENTIFIER_POINTER (DECL2); \ + \ + if (TARGET_THUMB && TREE_CODE (DECL1) == FUNCTION_DECL) \ + { \ + fprintf (FILE, "\t.thumb_set "); \ + assemble_name (FILE, LABEL1); \ + fprintf (FILE, ","); \ + assemble_name (FILE, LABEL2); \ + fprintf (FILE, "\n"); \ + } \ + else \ + ASM_OUTPUT_DEF (FILE, LABEL1, LABEL2); \ + } \ + while (0) + +#ifdef HAVE_GAS_MAX_SKIP_P2ALIGN +/* To support -falign-* switches we need to use .p2align so + that alignment directives in code sections will be padded + with no-op instructions, rather than zeroes. */ +#define ASM_OUTPUT_MAX_SKIP_ALIGN(FILE, LOG, MAX_SKIP) \ + if ((LOG) != 0) \ + { \ + if ((MAX_SKIP) == 0) \ + fprintf ((FILE), "\t.p2align %d\n", (int) (LOG)); \ + else \ + fprintf ((FILE), "\t.p2align %d,,%d\n", \ + (int) (LOG), (int) (MAX_SKIP)); \ + } +#endif + +/* Add two bytes to the length of conditionally executed Thumb-2 + instructions for the IT instruction. */ +#define ADJUST_INSN_LENGTH(insn, length) \ + if (TARGET_THUMB2 && GET_CODE (PATTERN (insn)) == COND_EXEC) \ + length += 2; + +/* Only perform branch elimination (by making instructions conditional) if + we're optimizing. For Thumb-2 check if any IT instructions need + outputting. */ +#define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \ + if (TARGET_ARM && optimize) \ + arm_final_prescan_insn (INSN); \ + else if (TARGET_THUMB2) \ + thumb2_final_prescan_insn (INSN); \ + else if (TARGET_THUMB1) \ + thumb1_final_prescan_insn (INSN) + +#define ARM_SIGN_EXTEND(x) ((HOST_WIDE_INT) \ + (HOST_BITS_PER_WIDE_INT <= 32 ? (unsigned HOST_WIDE_INT) (x) \ + : ((((unsigned HOST_WIDE_INT)(x)) & (unsigned HOST_WIDE_INT) 0xffffffff) |\ + ((((unsigned HOST_WIDE_INT)(x)) & (unsigned HOST_WIDE_INT) 0x80000000) \ + ? ((~ (unsigned HOST_WIDE_INT) 0) \ + & ~ (unsigned HOST_WIDE_INT) 0xffffffff) \ + : 0)))) + +/* A C expression whose value is RTL representing the value of the return + address for the frame COUNT steps up from the current frame. */ + +#define RETURN_ADDR_RTX(COUNT, FRAME) \ + arm_return_addr (COUNT, FRAME) + +/* Mask of the bits in the PC that contain the real return address + when running in 26-bit mode. */ +#define RETURN_ADDR_MASK26 (0x03fffffc) + +/* Pick up the return address upon entry to a procedure. Used for + dwarf2 unwind information. This also enables the table driven + mechanism. */ +#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, LR_REGNUM) +#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LR_REGNUM) + +/* Used to mask out junk bits from the return address, such as + processor state, interrupt status, condition codes and the like. */ +#define MASK_RETURN_ADDR \ + /* If we are generating code for an ARM2/ARM3 machine or for an ARM6 \ + in 26 bit mode, the condition codes must be masked out of the \ + return address. This does not apply to ARM6 and later processors \ + when running in 32 bit mode. */ \ + ((arm_arch4 || TARGET_THUMB) \ + ? (gen_int_mode ((unsigned long)0xffffffff, Pmode)) \ + : arm_gen_return_addr_mask ()) + + +/* Neon defines builtins from ARM_BUILTIN_MAX upwards, though they don't have + symbolic names defined here (which would require too much duplication). + FIXME? */ +enum arm_builtins +{ + ARM_BUILTIN_GETWCX, + ARM_BUILTIN_SETWCX, + + ARM_BUILTIN_WZERO, + + ARM_BUILTIN_WAVG2BR, + ARM_BUILTIN_WAVG2HR, + ARM_BUILTIN_WAVG2B, + ARM_BUILTIN_WAVG2H, + + ARM_BUILTIN_WACCB, + ARM_BUILTIN_WACCH, + ARM_BUILTIN_WACCW, + + ARM_BUILTIN_WMACS, + ARM_BUILTIN_WMACSZ, + ARM_BUILTIN_WMACU, + ARM_BUILTIN_WMACUZ, + + ARM_BUILTIN_WSADB, + ARM_BUILTIN_WSADBZ, + ARM_BUILTIN_WSADH, + ARM_BUILTIN_WSADHZ, + + ARM_BUILTIN_WALIGN, + + ARM_BUILTIN_TMIA, + ARM_BUILTIN_TMIAPH, + ARM_BUILTIN_TMIABB, + ARM_BUILTIN_TMIABT, + ARM_BUILTIN_TMIATB, + ARM_BUILTIN_TMIATT, + + ARM_BUILTIN_TMOVMSKB, + ARM_BUILTIN_TMOVMSKH, + ARM_BUILTIN_TMOVMSKW, + + ARM_BUILTIN_TBCSTB, + ARM_BUILTIN_TBCSTH, + ARM_BUILTIN_TBCSTW, + + ARM_BUILTIN_WMADDS, + ARM_BUILTIN_WMADDU, + + ARM_BUILTIN_WPACKHSS, + ARM_BUILTIN_WPACKWSS, + ARM_BUILTIN_WPACKDSS, + ARM_BUILTIN_WPACKHUS, + ARM_BUILTIN_WPACKWUS, + ARM_BUILTIN_WPACKDUS, + + ARM_BUILTIN_WADDB, + ARM_BUILTIN_WADDH, + ARM_BUILTIN_WADDW, + ARM_BUILTIN_WADDSSB, + ARM_BUILTIN_WADDSSH, + ARM_BUILTIN_WADDSSW, + ARM_BUILTIN_WADDUSB, + ARM_BUILTIN_WADDUSH, + ARM_BUILTIN_WADDUSW, + ARM_BUILTIN_WSUBB, + ARM_BUILTIN_WSUBH, + ARM_BUILTIN_WSUBW, + ARM_BUILTIN_WSUBSSB, + ARM_BUILTIN_WSUBSSH, + ARM_BUILTIN_WSUBSSW, + ARM_BUILTIN_WSUBUSB, + ARM_BUILTIN_WSUBUSH, + ARM_BUILTIN_WSUBUSW, + + ARM_BUILTIN_WAND, + ARM_BUILTIN_WANDN, + ARM_BUILTIN_WOR, + ARM_BUILTIN_WXOR, + + ARM_BUILTIN_WCMPEQB, + ARM_BUILTIN_WCMPEQH, + ARM_BUILTIN_WCMPEQW, + ARM_BUILTIN_WCMPGTUB, + ARM_BUILTIN_WCMPGTUH, + ARM_BUILTIN_WCMPGTUW, + ARM_BUILTIN_WCMPGTSB, + ARM_BUILTIN_WCMPGTSH, + ARM_BUILTIN_WCMPGTSW, + + ARM_BUILTIN_TEXTRMSB, + ARM_BUILTIN_TEXTRMSH, + ARM_BUILTIN_TEXTRMSW, + ARM_BUILTIN_TEXTRMUB, + ARM_BUILTIN_TEXTRMUH, + ARM_BUILTIN_TEXTRMUW, + ARM_BUILTIN_TINSRB, + ARM_BUILTIN_TINSRH, + ARM_BUILTIN_TINSRW, + + ARM_BUILTIN_WMAXSW, + ARM_BUILTIN_WMAXSH, + ARM_BUILTIN_WMAXSB, + ARM_BUILTIN_WMAXUW, + ARM_BUILTIN_WMAXUH, + ARM_BUILTIN_WMAXUB, + ARM_BUILTIN_WMINSW, + ARM_BUILTIN_WMINSH, + ARM_BUILTIN_WMINSB, + ARM_BUILTIN_WMINUW, + ARM_BUILTIN_WMINUH, + ARM_BUILTIN_WMINUB, + + ARM_BUILTIN_WMULUM, + ARM_BUILTIN_WMULSM, + ARM_BUILTIN_WMULUL, + + ARM_BUILTIN_PSADBH, + ARM_BUILTIN_WSHUFH, + + ARM_BUILTIN_WSLLH, + ARM_BUILTIN_WSLLW, + ARM_BUILTIN_WSLLD, + ARM_BUILTIN_WSRAH, + ARM_BUILTIN_WSRAW, + ARM_BUILTIN_WSRAD, + ARM_BUILTIN_WSRLH, + ARM_BUILTIN_WSRLW, + ARM_BUILTIN_WSRLD, + ARM_BUILTIN_WRORH, + ARM_BUILTIN_WRORW, + ARM_BUILTIN_WRORD, + ARM_BUILTIN_WSLLHI, + ARM_BUILTIN_WSLLWI, + ARM_BUILTIN_WSLLDI, + ARM_BUILTIN_WSRAHI, + ARM_BUILTIN_WSRAWI, + ARM_BUILTIN_WSRADI, + ARM_BUILTIN_WSRLHI, + ARM_BUILTIN_WSRLWI, + ARM_BUILTIN_WSRLDI, + ARM_BUILTIN_WRORHI, + ARM_BUILTIN_WRORWI, + ARM_BUILTIN_WRORDI, + + ARM_BUILTIN_WUNPCKIHB, + ARM_BUILTIN_WUNPCKIHH, + ARM_BUILTIN_WUNPCKIHW, + ARM_BUILTIN_WUNPCKILB, + ARM_BUILTIN_WUNPCKILH, + ARM_BUILTIN_WUNPCKILW, + + ARM_BUILTIN_WUNPCKEHSB, + ARM_BUILTIN_WUNPCKEHSH, + ARM_BUILTIN_WUNPCKEHSW, + ARM_BUILTIN_WUNPCKEHUB, + ARM_BUILTIN_WUNPCKEHUH, + ARM_BUILTIN_WUNPCKEHUW, + ARM_BUILTIN_WUNPCKELSB, + ARM_BUILTIN_WUNPCKELSH, + ARM_BUILTIN_WUNPCKELSW, + ARM_BUILTIN_WUNPCKELUB, + ARM_BUILTIN_WUNPCKELUH, + ARM_BUILTIN_WUNPCKELUW, + + ARM_BUILTIN_THREAD_POINTER, + + ARM_BUILTIN_NEON_BASE, + + ARM_BUILTIN_MAX = ARM_BUILTIN_NEON_BASE /* FIXME: Wrong! */ +}; + +/* Do emit .note.GNU-stack by default. */ +#ifndef NEED_INDICATE_EXEC_STACK +#define NEED_INDICATE_EXEC_STACK 1 +#endif + +/* The maximum number of parallel loads or stores we support in an ldm/stm + instruction. */ +#define MAX_LDM_STM_OPS 4 + +#endif /* ! GCC_ARM_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/bpabi.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/bpabi.h new file mode 100644 index 0000000..7b5ee62 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/bpabi.h @@ -0,0 +1,125 @@ +/* Configuration file for ARM BPABI targets. + Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by CodeSourcery, LLC + + 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/>. */ + +/* Use the AAPCS ABI by default. */ +#define ARM_DEFAULT_ABI ARM_ABI_AAPCS + +/* Assume that AAPCS ABIs should adhere to the full BPABI. */ +#define TARGET_BPABI (TARGET_AAPCS_BASED) + +/* BPABI targets use EABI frame unwinding tables. */ +#undef ARM_UNWIND_INFO +#define ARM_UNWIND_INFO 1 + +/* Section 4.1 of the AAPCS requires the use of VFP format. */ +#undef FPUTYPE_DEFAULT +#define FPUTYPE_DEFAULT "vfp" + +/* TARGET_BIG_ENDIAN_DEFAULT is set in + config.gcc for big endian configurations. */ +#if TARGET_BIG_ENDIAN_DEFAULT +#define TARGET_ENDIAN_DEFAULT MASK_BIG_END +#else +#define TARGET_ENDIAN_DEFAULT 0 +#endif + +/* EABI targets should enable interworking by default. */ +#undef TARGET_DEFAULT +#define TARGET_DEFAULT (MASK_INTERWORK | TARGET_ENDIAN_DEFAULT) + +/* The ARM BPABI functions return a boolean; they use no special + calling convention. */ +#define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) TARGET_BPABI + +/* The BPABI integer comparison routines return { -1, 0, 1 }. */ +#define TARGET_LIB_INT_CMP_BIASED !TARGET_BPABI + +#define TARGET_FIX_V4BX_SPEC " %{mcpu=arm8|mcpu=arm810|mcpu=strongarm*"\ + "|march=armv4|mcpu=fa526|mcpu=fa626:--fix-v4bx}" + +#define BE8_LINK_SPEC " %{mbig-endian:%{march=armv7-a|mcpu=cortex-a5"\ + "|mcpu=cortex-a8|mcpu=cortex-a9|mcpu=cortex-a15:%{!r:--be8}}}" + +/* Tell the assembler to build BPABI binaries. */ +#undef SUBTARGET_EXTRA_ASM_SPEC +#define SUBTARGET_EXTRA_ASM_SPEC \ + "%{mabi=apcs-gnu|mabi=atpcs:-meabi=gnu;:-meabi=5}" TARGET_FIX_V4BX_SPEC + +#ifndef SUBTARGET_EXTRA_LINK_SPEC +#define SUBTARGET_EXTRA_LINK_SPEC "" +#endif + +/* The generic link spec in elf.h does not support shared libraries. */ +#define BPABI_LINK_SPEC \ + "%{mbig-endian:-EB} %{mlittle-endian:-EL} " \ + "%{static:-Bstatic} %{shared:-shared} %{symbolic:-Bsymbolic} " \ + "-X" SUBTARGET_EXTRA_LINK_SPEC TARGET_FIX_V4BX_SPEC BE8_LINK_SPEC + +#undef LINK_SPEC +#define LINK_SPEC BPABI_LINK_SPEC + +/* The BPABI requires that we always use an out-of-line implementation + of RTTI comparison, even if the target supports weak symbols, + because the same object file might be used on a target that does + not support merging symbols across DLL boundaries. This macro is + broken out separately so that it can be used within + TARGET_OS_CPP_BUILTINS in configuration files for systems based on + the BPABI. */ +#define TARGET_BPABI_CPP_BUILTINS() \ + do \ + { \ + builtin_define ("__GXX_TYPEINFO_EQUALITY_INLINE=0"); \ + } \ + while (false) + +#undef TARGET_OS_CPP_BUILTINS +#define TARGET_OS_CPP_BUILTINS() \ + TARGET_BPABI_CPP_BUILTINS() + +/* The BPABI specifies the use of .{init,fini}_array. Therefore, we + do not want GCC to put anything into the .{init,fini} sections. */ +#undef INIT_SECTION_ASM_OP +#undef FINI_SECTION_ASM_OP +#define INIT_ARRAY_SECTION_ASM_OP ARM_EABI_CTORS_SECTION_OP +#define FINI_ARRAY_SECTION_ASM_OP ARM_EABI_DTORS_SECTION_OP + +/* The legacy _mcount implementation assumes r11 points to a + 4-word APCS frame. This is generally not true for EABI targets, + particularly not in Thumb mode. We assume the mcount + implementation does not require a counter variable (No Counter). + Note that __gnu_mcount_nc will be entered with a misaligned stack. + This is OK because it uses a special calling convention anyway. */ + +#undef NO_PROFILE_COUNTERS +#define NO_PROFILE_COUNTERS 1 +#undef ARM_FUNCTION_PROFILER +#define ARM_FUNCTION_PROFILER(STREAM, LABELNO) \ +{ \ + fprintf (STREAM, "\tpush\t{lr}\n"); \ + fprintf (STREAM, "\tbl\t__gnu_mcount_nc\n"); \ +} + +#undef SUBTARGET_FRAME_POINTER_REQUIRED +#define SUBTARGET_FRAME_POINTER_REQUIRED 0 + +/* __gnu_mcount_nc restores the original LR value before returning. Ensure + that there is no unnecessary hook set up. */ +#undef PROFILE_HOOK diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/elf.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/elf.h new file mode 100644 index 0000000..8840088 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/elf.h @@ -0,0 +1,166 @@ +/* Definitions of target machine for GNU compiler. + For ARM with ELF obj format. + Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2004, 2005, 2007, + 2008 Free Software Foundation, Inc. + Contributed by Philip Blundell <philb@gnu.org> and + Catherine Moore <clm@cygnus.com> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GCC is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + 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/>. */ + +#ifndef OBJECT_FORMAT_ELF + #error elf.h included before elfos.h +#endif + +#ifndef LOCAL_LABEL_PREFIX +#define LOCAL_LABEL_PREFIX "." +#endif + +#ifndef SUBTARGET_CPP_SPEC +#define SUBTARGET_CPP_SPEC "-D__ELF__" +#endif + +#ifndef SUBTARGET_EXTRA_SPECS +#define SUBTARGET_EXTRA_SPECS \ + { "subtarget_extra_asm_spec", SUBTARGET_EXTRA_ASM_SPEC }, \ + { "subtarget_asm_float_spec", SUBTARGET_ASM_FLOAT_SPEC }, \ + SUBSUBTARGET_EXTRA_SPECS +#endif + +#ifndef SUBTARGET_EXTRA_ASM_SPEC +#define SUBTARGET_EXTRA_ASM_SPEC "" +#endif + +#ifndef SUBTARGET_ASM_FLOAT_SPEC +#define SUBTARGET_ASM_FLOAT_SPEC "\ +%{mapcs-float:-mfloat}" +#endif + +#undef SUBSUBTARGET_EXTRA_SPECS +#define SUBSUBTARGET_EXTRA_SPECS + +#ifndef ASM_SPEC +#define ASM_SPEC "\ +%{mbig-endian:-EB} \ +%{mlittle-endian:-EL} \ +%{mcpu=*:-mcpu=%*} \ +%{march=*:-march=%*} \ +%{mapcs-*:-mapcs-%*} \ +%(subtarget_asm_float_spec) \ +%{mthumb-interwork:-mthumb-interwork} \ +%{msoft-float:-mfloat-abi=soft} %{mhard-float:-mfloat-abi=hard} \ +%{mfloat-abi=*} %{mfpu=*} \ +%(subtarget_extra_asm_spec)" +#endif + +/* The ARM uses @ are a comment character so we need to redefine + TYPE_OPERAND_FMT. */ +#undef TYPE_OPERAND_FMT +#define TYPE_OPERAND_FMT "%%%s" + +/* We might need a ARM specific header to function declarations. */ +#undef ASM_DECLARE_FUNCTION_NAME +#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ + do \ + { \ + ARM_DECLARE_FUNCTION_NAME (FILE, NAME, DECL); \ + ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "function"); \ + ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \ + ASM_OUTPUT_LABEL(FILE, NAME); \ + ARM_OUTPUT_FN_UNWIND (FILE, TRUE); \ + } \ + while (0) + +/* We might need an ARM specific trailer for function declarations. */ +#undef ASM_DECLARE_FUNCTION_SIZE +#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ + do \ + { \ + ARM_OUTPUT_FN_UNWIND (FILE, FALSE); \ + if (!flag_inhibit_size_directive) \ + ASM_OUTPUT_MEASURED_SIZE (FILE, FNAME); \ + } \ + while (0) + +/* Define this macro if jump tables (for `tablejump' insns) should be + output in the text section, along with the assembler instructions. + Otherwise, the readonly data section is used. */ +/* We put ARM and Thumb-2 jump tables in the text section, because it makes + the code more efficient, but for Thumb-1 it's better to put them out of + band unless we are generating compressed tables. */ +#define JUMP_TABLES_IN_TEXT_SECTION \ + (TARGET_32BIT || (TARGET_THUMB && (optimize_size || flag_pic))) + +#ifndef LINK_SPEC +#define LINK_SPEC "%{mbig-endian:-EB} %{mlittle-endian:-EL} -X" +#endif + +/* Run-time Target Specification. */ +#ifndef TARGET_VERSION +#define TARGET_VERSION fputs (" (ARM/elf)", stderr) +#endif + +#ifndef TARGET_DEFAULT +#define TARGET_DEFAULT (MASK_APCS_FRAME) +#endif + +#ifndef MULTILIB_DEFAULTS +#define MULTILIB_DEFAULTS \ + { "marm", "mlittle-endian", "msoft-float", "mno-thumb-interwork", "fno-leading-underscore" } +#endif + +#define TARGET_ASM_FILE_START_APP_OFF true +#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true + + +/* Output an element in the static constructor array. */ +#undef TARGET_ASM_CONSTRUCTOR +#define TARGET_ASM_CONSTRUCTOR arm_elf_asm_constructor + +#undef TARGET_ASM_DESTRUCTOR +#define TARGET_ASM_DESTRUCTOR arm_elf_asm_destructor + +/* For PIC code we need to explicitly specify (PLT) and (GOT) relocs. */ +#define NEED_PLT_RELOC flag_pic +#define NEED_GOT_RELOC flag_pic + +/* The ELF assembler handles GOT addressing differently to NetBSD. */ +#define GOT_PCREL 0 + +/* Align output to a power of two. Note ".align 0" is redundant, + and also GAS will treat it as ".align 2" which we do not want. */ +#define ASM_OUTPUT_ALIGN(STREAM, POWER) \ + do \ + { \ + if ((POWER) > 0) \ + fprintf (STREAM, "\t.align\t%d\n", POWER); \ + } \ + while (0) + +/* Horrible hack: We want to prevent some libgcc routines being included + for some multilibs. */ +#ifndef __ARM_ARCH_6M__ +#undef L_fixdfsi +#undef L_fixunsdfsi +#undef L_truncdfsf2 +#undef L_fixsfsi +#undef L_fixunssfsi +#undef L_floatdidf +#undef L_floatdisf +#undef L_floatundidf +#undef L_floatundisf +#endif + diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/unknown-elf.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/unknown-elf.h new file mode 100644 index 0000000..b47455e --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/arm/unknown-elf.h @@ -0,0 +1,100 @@ +/* Definitions for non-Linux based ARM systems using ELF + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2010 + Free Software Foundation, Inc. + Contributed by Catherine Moore <clm@cygnus.com> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GCC is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + 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/>. */ + +/* elfos.h should have already been included. Now just override + any conflicting definitions and add any extras. */ + +/* Run-time Target Specification. */ +#ifndef TARGET_VERSION +#define TARGET_VERSION fputs (" (ARM/ELF)", stderr); +#endif + +/* Default to using software floating point. */ +#ifndef TARGET_DEFAULT +#define TARGET_DEFAULT (0) +#endif + +/* Now we define the strings used to build the spec file. */ +#define UNKNOWN_ELF_STARTFILE_SPEC " crti%O%s crtbegin%O%s crt0%O%s" + +#undef STARTFILE_SPEC +#define STARTFILE_SPEC UNKNOWN_ELF_STARTFILE_SPEC + +#define UNKNOWN_ELF_ENDFILE_SPEC "crtend%O%s crtn%O%s" + +#undef ENDFILE_SPEC +#define ENDFILE_SPEC UNKNOWN_ELF_ENDFILE_SPEC + +/* The __USES_INITFINI__ define is tested in newlib/libc/sys/arm/crt0.S + to see if it needs to invoked _init() and _fini(). */ +#undef SUBTARGET_CPP_SPEC +#define SUBTARGET_CPP_SPEC "-D__USES_INITFINI__" + +#undef PREFERRED_DEBUGGING_TYPE +#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG + +/* Return a nonzero value if DECL has a section attribute. */ +#define IN_NAMED_SECTION_P(DECL) \ + ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \ + && DECL_SECTION_NAME (DECL) != NULL_TREE) + +#undef ASM_OUTPUT_ALIGNED_BSS +#define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \ + do \ + { \ + if (IN_NAMED_SECTION_P (DECL)) \ + switch_to_section (get_named_section (DECL, NULL, 0)); \ + else \ + switch_to_section (bss_section); \ + \ + ASM_OUTPUT_ALIGN (FILE, floor_log2 (ALIGN / BITS_PER_UNIT)); \ + \ + last_assemble_variable_decl = DECL; \ + ASM_DECLARE_OBJECT_NAME (FILE, NAME, DECL); \ + ASM_OUTPUT_SKIP (FILE, SIZE ? (int)(SIZE) : 1); \ + } \ + while (0) + +#undef ASM_OUTPUT_ALIGNED_DECL_LOCAL +#define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \ + do \ + { \ + if ((DECL) != NULL && IN_NAMED_SECTION_P (DECL)) \ + switch_to_section (get_named_section (DECL, NULL, 0)); \ + else \ + switch_to_section (bss_section); \ + \ + ASM_OUTPUT_ALIGN (FILE, floor_log2 (ALIGN / BITS_PER_UNIT)); \ + ASM_OUTPUT_LABEL (FILE, NAME); \ + fprintf (FILE, "\t.space\t%d\n", SIZE ? (int)(SIZE) : 1); \ + } \ + while (0) + +#ifndef SUBTARGET_CPU_DEFAULT +#define SUBTARGET_CPU_DEFAULT TARGET_CPU_arm7tdmi +#endif + +/* The libgcc udivmod functions may throw exceptions. If newlib is + configured to support long longs in I/O, then printf will depend on + udivmoddi4, which will depend on the exception unwind routines, + which will depend on abort, which is defined in libc. */ +#undef LINK_GCC_C_SEQUENCE_SPEC +#define LINK_GCC_C_SEQUENCE_SPEC "--start-group %G %L --end-group" diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/dbxelf.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/dbxelf.h new file mode 100644 index 0000000..8d3c265 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/dbxelf.h @@ -0,0 +1,68 @@ +/* Definitions needed when using stabs embedded in ELF sections. + Copyright (C) 1999, 2004, 2007, 2009 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +/* This file may be included by any ELF target which wishes to + support -gstabs generating stabs in sections, as produced by gas + and understood by gdb. */ + +#ifndef GCC_DBX_ELF_H +#define GCC_DBX_ELF_H + +/* Output DBX (stabs) debugging information if doing -gstabs. */ + +#define DBX_DEBUGGING_INFO 1 + +/* Make LBRAC and RBRAC addresses relative to the start of the + function. The native Solaris stabs debugging format works this + way, gdb expects it, and it reduces the number of relocation + entries... */ + +#define DBX_BLOCKS_FUNCTION_RELATIVE 1 + +/* ... but, to make this work, functions must appear prior to line info. */ + +#define DBX_FUNCTION_FIRST + +/* When generating stabs debugging, use N_BINCL entries. */ + +#define DBX_USE_BINCL + +/* There is no limit to the length of stabs strings. */ + +#ifndef DBX_CONTIN_LENGTH +#define DBX_CONTIN_LENGTH 0 +#endif + +/* Like block addresses, stabs line numbers are relative to the + current function. */ + +#define DBX_LINES_FUNCTION_RELATIVE 1 + +/* Generate a blank trailing N_SO to mark the end of the .o file, since + we can't depend upon the linker to mark .o file boundaries with + embedded stabs. */ + +#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END + +#endif /* ! GCC_DBX_ELF_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/elfos.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/elfos.h new file mode 100644 index 0000000..e483216 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/elfos.h @@ -0,0 +1,531 @@ +/* elfos.h -- operating system specific defines to be used when + targeting GCC for some generic ELF system + Copyright (C) 1991, 1994, 1995, 1999, 2000, 2001, 2002, 2003, 2004, + 2007, 2009, 2010 Free Software Foundation, Inc. + Based on svr4.h contributed by Ron Guilmette (rfg@netcom.com). + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +#define TARGET_OBJFMT_CPP_BUILTINS() \ + do \ + { \ + builtin_define ("__ELF__"); \ + } \ + while (0) + +/* Define a symbol indicating that we are using elfos.h. + Some CPU specific configuration files use this. */ +#define USING_ELFOS_H + +/* The prefix to add to user-visible assembler symbols. + + For ELF systems the convention is *not* to prepend a leading + underscore onto user-level symbol names. */ + +#undef USER_LABEL_PREFIX +#define USER_LABEL_PREFIX "" + +/* The biggest alignment supported by ELF in bits. 32-bit ELF + supports section alignment up to (0x80000000 * 8), while + 64-bit ELF supports (0x8000000000000000 * 8). If this macro + is not defined, the default is the largest alignment supported + by 32-bit ELF and representable on a 32-bit host. Use this + macro to limit the alignment which can be specified using + the `__attribute__ ((aligned (N)))' construct. */ +#ifndef MAX_OFILE_ALIGNMENT +#define MAX_OFILE_ALIGNMENT (((unsigned int) 1 << 28) * 8) +#endif + +/* Use periods rather than dollar signs in special g++ assembler names. */ + +#define NO_DOLLAR_IN_LABEL + +/* Writing `int' for a bit-field forces int alignment for the structure. */ + +#ifndef PCC_BITFIELD_TYPE_MATTERS +#define PCC_BITFIELD_TYPE_MATTERS 1 +#endif + +/* All ELF targets can support DWARF-2. */ + +#define DWARF2_DEBUGGING_INFO 1 + +/* The GNU tools operate better with dwarf2, and it is required by some + psABI's. Since we don't have any native tools to be compatible with, + default to dwarf2. */ + +#ifndef PREFERRED_DEBUGGING_TYPE +#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG +#endif + +/* All SVR4 targets use the ELF object file format. */ +#define OBJECT_FORMAT_ELF + + +/* Output #ident as a .ident. */ + +#define ASM_OUTPUT_IDENT(FILE, NAME) \ + fprintf (FILE, "%s\"%s\"\n", IDENT_ASM_OP, NAME); + +#define IDENT_ASM_OP "\t.ident\t" + +#undef SET_ASM_OP +#define SET_ASM_OP "\t.set\t" + +/* Most svr4 assemblers want a .file directive at the beginning of + their input file. */ +#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true + +/* This is how to allocate empty space in some section. The .zero + pseudo-op is used for this on most svr4 assemblers. */ + +#define SKIP_ASM_OP "\t.zero\t" + +#undef ASM_OUTPUT_SKIP +#define ASM_OUTPUT_SKIP(FILE, SIZE) \ + fprintf ((FILE), "%s"HOST_WIDE_INT_PRINT_UNSIGNED"\n",\ + SKIP_ASM_OP, (SIZE)) + +/* This is how to store into the string LABEL + the symbol_ref name of an internal numbered label where + PREFIX is the class of label and NUM is the number within the class. + This is suitable for output with `assemble_name'. + + For most svr4 systems, the convention is that any symbol which begins + with a period is not put into the linker symbol table by the assembler. */ + +#undef ASM_GENERATE_INTERNAL_LABEL +#define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ + do \ + { \ + sprintf (LABEL, "*.%s%u", PREFIX, (unsigned) (NUM)); \ + } \ + while (0) + +/* Output the label which precedes a jumptable. Note that for all svr4 + systems where we actually generate jumptables (which is to say every + svr4 target except i386, where we use casesi instead) we put the jump- + tables into the .rodata section and since other stuff could have been + put into the .rodata section prior to any given jumptable, we have to + make sure that the location counter for the .rodata section gets pro- + perly re-aligned prior to the actual beginning of the jump table. */ + +#undef ALIGN_ASM_OP +#define ALIGN_ASM_OP "\t.align\t" + +#ifndef ASM_OUTPUT_BEFORE_CASE_LABEL +#define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE, PREFIX, NUM, TABLE) \ + ASM_OUTPUT_ALIGN ((FILE), 2); +#endif + +#undef ASM_OUTPUT_CASE_LABEL +#define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, JUMPTABLE) \ + do \ + { \ + ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE) \ + (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM); \ + } \ + while (0) + +/* The standard SVR4 assembler seems to require that certain builtin + library routines (e.g. .udiv) be explicitly declared as .globl + in each assembly file where they are referenced. */ + +#define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN) \ + (*targetm.asm_out.globalize_label) (FILE, XSTR (FUN, 0)) + +/* This says how to output assembler code to declare an + uninitialized external linkage data object. Under SVR4, + the linker seems to want the alignment of data objects + to depend on their types. We do exactly that here. */ + +#define COMMON_ASM_OP "\t.comm\t" + +#undef ASM_OUTPUT_ALIGNED_COMMON +#define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN) \ + do \ + { \ + fprintf ((FILE), "%s", COMMON_ASM_OP); \ + assemble_name ((FILE), (NAME)); \ + fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ + (SIZE), (ALIGN) / BITS_PER_UNIT); \ + } \ + while (0) + +/* This says how to output assembler code to declare an + uninitialized internal linkage data object. Under SVR4, + the linker seems to want the alignment of data objects + to depend on their types. We do exactly that here. */ + +#define LOCAL_ASM_OP "\t.local\t" + +#undef ASM_OUTPUT_ALIGNED_LOCAL +#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \ + do \ + { \ + fprintf ((FILE), "%s", LOCAL_ASM_OP); \ + assemble_name ((FILE), (NAME)); \ + fprintf ((FILE), "\n"); \ + ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN); \ + } \ + while (0) + +/* This is the pseudo-op used to generate a contiguous sequence of byte + values from a double-quoted string WITHOUT HAVING A TERMINATING NUL + AUTOMATICALLY APPENDED. This is the same for most svr4 assemblers. */ + +#undef ASCII_DATA_ASM_OP +#define ASCII_DATA_ASM_OP "\t.ascii\t" + +/* Support a read-only data section. */ +#define READONLY_DATA_SECTION_ASM_OP "\t.section\t.rodata" + +/* On svr4, we *do* have support for the .init and .fini sections, and we + can put stuff in there to be executed before and after `main'. We let + crtstuff.c and other files know this by defining the following symbols. + The definitions say how to change sections to the .init and .fini + sections. This is the same for all known svr4 assemblers. */ + +#define INIT_SECTION_ASM_OP "\t.section\t.init" +#define FINI_SECTION_ASM_OP "\t.section\t.fini" + +/* Output assembly directive to move to the beginning of current section. */ +#ifdef HAVE_GAS_SUBSECTION_ORDERING +# define ASM_SECTION_START_OP "\t.subsection\t-1" +# define ASM_OUTPUT_SECTION_START(FILE) \ + fprintf ((FILE), "%s\n", ASM_SECTION_START_OP) +#endif + +#define MAKE_DECL_ONE_ONLY(DECL) (DECL_WEAK (DECL) = 1) + +/* Switch into a generic section. */ +#define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section + +#undef TARGET_ASM_SELECT_RTX_SECTION +#define TARGET_ASM_SELECT_RTX_SECTION default_elf_select_rtx_section +#undef TARGET_ASM_SELECT_SECTION +#define TARGET_ASM_SELECT_SECTION default_elf_select_section +#undef TARGET_HAVE_SWITCHABLE_BSS_SECTIONS +#define TARGET_HAVE_SWITCHABLE_BSS_SECTIONS true + +/* Define the strings used for the special svr4 .type and .size directives. + These strings generally do not vary from one system running svr4 to + another, but if a given system (e.g. m88k running svr) needs to use + different pseudo-op names for these, they may be overridden in the + file which includes this one. */ + +#define TYPE_ASM_OP "\t.type\t" +#define SIZE_ASM_OP "\t.size\t" + +/* This is how we tell the assembler that a symbol is weak. */ + +#define ASM_WEAKEN_LABEL(FILE, NAME) \ + do \ + { \ + fputs ("\t.weak\t", (FILE)); \ + assemble_name ((FILE), (NAME)); \ + fputc ('\n', (FILE)); \ + } \ + while (0) + +/* The following macro defines the format used to output the second + operand of the .type assembler directive. Different svr4 assemblers + expect various different forms for this operand. The one given here + is just a default. You may need to override it in your machine- + specific tm.h file (depending upon the particulars of your assembler). */ + +#define TYPE_OPERAND_FMT "@%s" + +/* Write the extra assembler code needed to declare a function's result. + Most svr4 assemblers don't require any special declaration of the + result value, but there are exceptions. */ + +#ifndef ASM_DECLARE_RESULT +#define ASM_DECLARE_RESULT(FILE, RESULT) +#endif + +/* These macros generate the special .type and .size directives which + are used to set the corresponding fields of the linker symbol table + entries in an ELF object file under SVR4. These macros also output + the starting labels for the relevant functions/objects. */ + +/* Write the extra assembler code needed to declare a function properly. + Some svr4 assemblers need to also have something extra said about the + function's return value. We allow for that here. */ + +#ifndef ASM_DECLARE_FUNCTION_NAME +#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ + do \ + { \ + ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "function"); \ + ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \ + ASM_OUTPUT_FUNCTION_LABEL (FILE, NAME, DECL); \ + } \ + while (0) +#endif + +/* Write the extra assembler code needed to declare an object properly. */ + +#ifdef HAVE_GAS_GNU_UNIQUE_OBJECT +#define USE_GNU_UNIQUE_OBJECT 1 +#else +#define USE_GNU_UNIQUE_OBJECT 0 +#endif + +#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \ + do \ + { \ + HOST_WIDE_INT size; \ + \ + /* For template static data member instantiations or \ + inline fn local statics and their guard variables, use \ + gnu_unique_object so that they will be combined even under \ + RTLD_LOCAL. Don't use gnu_unique_object for typeinfo, \ + vtables and other read-only artificial decls. */ \ + if (USE_GNU_UNIQUE_OBJECT && DECL_ONE_ONLY (DECL) \ + && (!DECL_ARTIFICIAL (DECL) || !TREE_READONLY (DECL))) \ + ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "gnu_unique_object"); \ + else \ + ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "object"); \ + \ + size_directive_output = 0; \ + if (!flag_inhibit_size_directive \ + && (DECL) && DECL_SIZE (DECL)) \ + { \ + size_directive_output = 1; \ + size = int_size_in_bytes (TREE_TYPE (DECL)); \ + ASM_OUTPUT_SIZE_DIRECTIVE (FILE, NAME, size); \ + } \ + \ + ASM_OUTPUT_LABEL (FILE, NAME); \ + } \ + while (0) + +/* Output the size directive for a decl in rest_of_decl_compilation + in the case where we did not do so before the initializer. + Once we find the error_mark_node, we know that the value of + size_directive_output was set + by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ + +#undef ASM_FINISH_DECLARE_OBJECT +#define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)\ + do \ + { \ + const char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \ + HOST_WIDE_INT size; \ + \ + if (!flag_inhibit_size_directive \ + && DECL_SIZE (DECL) \ + && ! AT_END && TOP_LEVEL \ + && DECL_INITIAL (DECL) == error_mark_node \ + && !size_directive_output) \ + { \ + size_directive_output = 1; \ + size = int_size_in_bytes (TREE_TYPE (DECL)); \ + ASM_OUTPUT_SIZE_DIRECTIVE (FILE, name, size); \ + } \ + } \ + while (0) + +/* This is how to declare the size of a function. */ +#ifndef ASM_DECLARE_FUNCTION_SIZE +#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ + do \ + { \ + if (!flag_inhibit_size_directive) \ + ASM_OUTPUT_MEASURED_SIZE (FILE, FNAME); \ + } \ + while (0) +#endif + +/* A table of bytes codes used by the ASM_OUTPUT_ASCII and + ASM_OUTPUT_LIMITED_STRING macros. Each byte in the table + corresponds to a particular byte value [0..255]. For any + given byte value, if the value in the corresponding table + position is zero, the given character can be output directly. + If the table value is 1, the byte must be output as a \ooo + octal escape. If the tables value is anything else, then the + byte value should be output as a \ followed by the value + in the table. Note that we can use standard UN*X escape + sequences for many control characters, but we don't use + \a to represent BEL because some svr4 assemblers (e.g. on + the i386) don't know about that. Also, we don't use \v + since some versions of gas, such as 2.2 did not accept it. */ + +#define ESCAPES \ +"\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ +\0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\ +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\ +\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ +\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ +\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ +\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1" + +/* Some svr4 assemblers have a limit on the number of characters which + can appear in the operand of a .string directive. If your assembler + has such a limitation, you should define STRING_LIMIT to reflect that + limit. Note that at least some svr4 assemblers have a limit on the + actual number of bytes in the double-quoted string, and that they + count each character in an escape sequence as one byte. Thus, an + escape sequence like \377 would count as four bytes. + + If your target assembler doesn't support the .string directive, you + should define this to zero. +*/ + +#define STRING_LIMIT ((unsigned) 256) + +#define STRING_ASM_OP "\t.string\t" + +/* The routine used to output NUL terminated strings. We use a special + version of this for most svr4 targets because doing so makes the + generated assembly code more compact (and thus faster to assemble) + as well as more readable, especially for targets like the i386 + (where the only alternative is to output character sequences as + comma separated lists of numbers). */ + +#define ASM_OUTPUT_LIMITED_STRING(FILE, STR) \ + do \ + { \ + register const unsigned char *_limited_str = \ + (const unsigned char *) (STR); \ + register unsigned ch; \ + \ + fprintf ((FILE), "%s\"", STRING_ASM_OP); \ + \ + for (; (ch = *_limited_str); _limited_str++) \ + { \ + register int escape; \ + \ + switch (escape = ESCAPES[ch]) \ + { \ + case 0: \ + putc (ch, (FILE)); \ + break; \ + case 1: \ + fprintf ((FILE), "\\%03o", ch); \ + break; \ + default: \ + putc ('\\', (FILE)); \ + putc (escape, (FILE)); \ + break; \ + } \ + } \ + \ + fprintf ((FILE), "\"\n"); \ + } \ + while (0) + +/* The routine used to output sequences of byte values. We use a special + version of this for most svr4 targets because doing so makes the + generated assembly code more compact (and thus faster to assemble) + as well as more readable. Note that if we find subparts of the + character sequence which end with NUL (and which are shorter than + STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING. */ + +#undef ASM_OUTPUT_ASCII +#define ASM_OUTPUT_ASCII(FILE, STR, LENGTH) \ + do \ + { \ + const unsigned char *_ascii_bytes = \ + (const unsigned char *) (STR); \ + const unsigned char *limit = _ascii_bytes + (LENGTH); \ + const unsigned char *last_null = NULL; \ + unsigned bytes_in_chunk = 0; \ + \ + for (; _ascii_bytes < limit; _ascii_bytes++) \ + { \ + const unsigned char *p; \ + \ + if (bytes_in_chunk >= 60) \ + { \ + fprintf ((FILE), "\"\n"); \ + bytes_in_chunk = 0; \ + } \ + \ + if (_ascii_bytes > last_null) \ + { \ + for (p = _ascii_bytes; p < limit && *p != '\0'; p++) \ + continue; \ + last_null = p; \ + } \ + else \ + p = last_null; \ + \ + if (p < limit && (p - _ascii_bytes) <= (long)STRING_LIMIT) \ + { \ + if (bytes_in_chunk > 0) \ + { \ + fprintf ((FILE), "\"\n"); \ + bytes_in_chunk = 0; \ + } \ + \ + ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes); \ + _ascii_bytes = p; \ + } \ + else \ + { \ + register int escape; \ + register unsigned ch; \ + \ + if (bytes_in_chunk == 0) \ + fprintf ((FILE), "%s\"", ASCII_DATA_ASM_OP); \ + \ + switch (escape = ESCAPES[ch = *_ascii_bytes]) \ + { \ + case 0: \ + putc (ch, (FILE)); \ + bytes_in_chunk++; \ + break; \ + case 1: \ + fprintf ((FILE), "\\%03o", ch); \ + bytes_in_chunk += 4; \ + break; \ + default: \ + putc ('\\', (FILE)); \ + putc (escape, (FILE)); \ + bytes_in_chunk += 2; \ + break; \ + } \ + } \ + } \ + \ + if (bytes_in_chunk > 0) \ + fprintf ((FILE), "\"\n"); \ + } \ + while (0) + +/* Allow the use of the -frecord-gcc-switches switch via the + elf_record_gcc_switches function defined in varasm.c. */ +#undef TARGET_ASM_RECORD_GCC_SWITCHES +#define TARGET_ASM_RECORD_GCC_SWITCHES elf_record_gcc_switches + +/* A C statement (sans semicolon) to output to the stdio stream STREAM + any text necessary for declaring the name of an external symbol + named NAME which is referenced in this compilation but not defined. + It is needed to properly support non-default visibility. */ + +#ifndef ASM_OUTPUT_EXTERNAL +#define ASM_OUTPUT_EXTERNAL(FILE, DECL, NAME) \ + default_elf_asm_output_external (FILE, DECL, NAME) +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/initfini-array.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/initfini-array.h new file mode 100644 index 0000000..bb48c70 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/initfini-array.h @@ -0,0 +1,41 @@ +/* Definitions for ELF systems with .init_array/.fini_array section + support. + Copyright (C) 2011, 2012 + 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/>. */ + +#ifdef HAVE_INITFINI_ARRAY + +#define USE_INITFINI_ARRAY + +#undef INIT_SECTION_ASM_OP +#undef FINI_SECTION_ASM_OP + +#undef INIT_ARRAY_SECTION_ASM_OP +#define INIT_ARRAY_SECTION_ASM_OP + +#undef FINI_ARRAY_SECTION_ASM_OP +#define FINI_ARRAY_SECTION_ASM_OP + +/* Use .init_array/.fini_array section for constructors and destructors. */ +#undef TARGET_ASM_CONSTRUCTOR +#define TARGET_ASM_CONSTRUCTOR default_elf_init_array_asm_out_constructor +#undef TARGET_ASM_DESTRUCTOR +#define TARGET_ASM_DESTRUCTOR default_elf_fini_array_asm_out_destructor + +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/newlib-stdint.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/newlib-stdint.h new file mode 100644 index 0000000..3bc8a59 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/config/newlib-stdint.h @@ -0,0 +1,64 @@ +/* Definitions for <stdint.h> types on systems using newlib. + Copyright (C) 2008, 2009 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/>. */ + +/* newlib uses 32-bit long in certain cases for all non-SPU + targets. */ +#ifndef STDINT_LONG32 +#define STDINT_LONG32 (LONG_TYPE_SIZE == 32) +#endif + +#define SIG_ATOMIC_TYPE "int" + +/* The newlib logic actually checks for sizes greater than 32 rather + than equal to 64 for various 64-bit types. */ + +#define INT8_TYPE (CHAR_TYPE_SIZE == 8 ? "signed char" : 0) +#define INT16_TYPE (SHORT_TYPE_SIZE == 16 ? "short int" : INT_TYPE_SIZE == 16 ? "int" : CHAR_TYPE_SIZE == 16 ? "signed char" : 0) +#define INT32_TYPE (STDINT_LONG32 ? "long int" : INT_TYPE_SIZE == 32 ? "int" : SHORT_TYPE_SIZE == 32 ? "short int" : CHAR_TYPE_SIZE == 32 ? "signed char" : 0) +#define INT64_TYPE (LONG_TYPE_SIZE == 64 ? "long int" : LONG_LONG_TYPE_SIZE == 64 ? "long long int" : INT_TYPE_SIZE == 64 ? "int" : 0) +#define UINT8_TYPE (CHAR_TYPE_SIZE == 8 ? "unsigned char" : 0) +#define UINT16_TYPE (SHORT_TYPE_SIZE == 16 ? "short unsigned int" : INT_TYPE_SIZE == 16 ? "unsigned int" : CHAR_TYPE_SIZE == 16 ? "unsigned char" : 0) +#define UINT32_TYPE (STDINT_LONG32 ? "long unsigned int" : INT_TYPE_SIZE == 32 ? "unsigned int" : SHORT_TYPE_SIZE == 32 ? "short unsigned int" : CHAR_TYPE_SIZE == 32 ? "unsigned char" : 0) +#define UINT64_TYPE (LONG_TYPE_SIZE == 64 ? "long unsigned int" : LONG_LONG_TYPE_SIZE == 64 ? "long long unsigned int" : INT_TYPE_SIZE == 64 ? "unsigned int" : 0) + +#define INT_LEAST8_TYPE (INT8_TYPE ? INT8_TYPE : INT16_TYPE ? INT16_TYPE : INT32_TYPE ? INT32_TYPE : INT64_TYPE ? INT64_TYPE : 0) +#define INT_LEAST16_TYPE (INT16_TYPE ? INT16_TYPE : INT32_TYPE ? INT32_TYPE : INT64_TYPE ? INT64_TYPE : 0) +#define INT_LEAST32_TYPE (INT32_TYPE ? INT32_TYPE : INT64_TYPE ? INT64_TYPE : 0) +#define INT_LEAST64_TYPE INT64_TYPE +#define UINT_LEAST8_TYPE (UINT8_TYPE ? UINT8_TYPE : UINT16_TYPE ? UINT16_TYPE : UINT32_TYPE ? UINT32_TYPE : UINT64_TYPE ? UINT64_TYPE : 0) +#define UINT_LEAST16_TYPE (UINT16_TYPE ? UINT16_TYPE : UINT32_TYPE ? UINT32_TYPE : UINT64_TYPE ? UINT64_TYPE : 0) +#define UINT_LEAST32_TYPE (UINT32_TYPE ? UINT32_TYPE : UINT64_TYPE ? UINT64_TYPE : 0) +#define UINT_LEAST64_TYPE UINT64_TYPE + +#define INT_FAST8_TYPE (INT_TYPE_SIZE >= 8 ? "int" : INT_LEAST8_TYPE) +#define INT_FAST16_TYPE (INT_TYPE_SIZE >= 16 ? "int" : INT_LEAST16_TYPE) +#define INT_FAST32_TYPE (INT_TYPE_SIZE >= 32 ? "int" : INT_LEAST32_TYPE) +#define INT_FAST64_TYPE (INT_TYPE_SIZE >= 64 ? "int" : INT_LEAST64_TYPE) +#define UINT_FAST8_TYPE (INT_TYPE_SIZE >= 8 ? "unsigned int" : UINT_LEAST8_TYPE) +#define UINT_FAST16_TYPE (INT_TYPE_SIZE >= 16 ? "unsigned int" : UINT_LEAST16_TYPE) +#define UINT_FAST32_TYPE (INT_TYPE_SIZE >= 32 ? "unsigned int" : UINT_LEAST32_TYPE) +#define UINT_FAST64_TYPE (INT_TYPE_SIZE >= 64 ? "unsigned int" : UINT_LEAST64_TYPE) + +/* Newlib uses the unsigned type corresponding to ptrdiff_t for + uintptr_t; this is the same as size_t for most newlib-using + targets. */ +#define INTPTR_TYPE PTRDIFF_TYPE +#ifndef UINTPTR_TYPE +#define UINTPTR_TYPE SIZE_TYPE +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/configargs.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/configargs.h new file mode 100644 index 0000000..ca1a515 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/configargs.h @@ -0,0 +1,7 @@ +/* Generated automatically. */ +static const char configuration_arguments[] = "/Volumes/androidtc/androidtoolchain/./src/build/../gcc/gcc-4.6/configure --prefix=/usr/local --target=arm-eabi --host=x86_64-apple-darwin --build=x86_64-apple-darwin --with-gnu-as --with-gnu-ld --enable-languages=c,c++ --with-gmp=/Volumes/androidtc/buildarmeabi/obj/temp-install --with-mpfr=/Volumes/androidtc/buildarmeabi/obj/temp-install --with-mpc=/Volumes/androidtc/buildarmeabi/obj/temp-install --without-ppl --without-cloog --disable-libssp --enable-threads --disable-nls --disable-libmudflap --disable-libgomp --disable-libstdc__-v3 --disable-sjlj-exceptions --disable-shared --disable-tls --disable-libitm --with-float=soft --with-fpu=vfp --with-arch=armv5te --enable-target-optspace --with-abi=aapcs --with-gcc-version=4.6 --with-binutils-version=2.21 --with-gmp-version=4.2.4 --with-mpfr-version=2.4.1 --with-gdb-version=7.3.x --with-arch=armv5te --with-sysroot=/Volumes/androidtc/buildarmeabi/install/sysroot --with-prefix=/Volumes/androidtc/buildarmeabi/install --with-gold-version=2.21 --enable-gold --disable-gold --disable-multilib --program-transform-name='s&^&arm-eabi-&'"; +static const char thread_model[] = "single"; + +static const struct { + const char *name, *value; +} configure_default_options[] = { { "abi", "aapcs" }, { "arch", "armv5te" }, { "float", "soft" }, { "fpu", "vfp" } }; diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/coretypes.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/coretypes.h new file mode 100644 index 0000000..20932b8 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/coretypes.h @@ -0,0 +1,175 @@ +/* GCC core type declarations. + Copyright (C) 2002, 2004, 2007, 2008, 2009, 2010 + 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 + +struct bitmap_head_def; +typedef struct bitmap_head_def *bitmap; +typedef const struct bitmap_head_def *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; +struct rtvec_def; +typedef struct rtvec_def *rtvec; +typedef const struct rtvec_def *const_rtvec; +union tree_node; +typedef union tree_node *tree; +union gimple_statement_d; +typedef union gimple_statement_d *gimple; +typedef const union tree_node *const_tree; +typedef const union gimple_statement_d *const_gimple; +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; +typedef struct diagnostic_context diagnostic_context; +struct gimple_seq_d; +typedef struct gimple_seq_d *gimple_seq; +typedef const struct gimple_seq_d *const_gimple_seq; + +/* 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 unwind/exception handling info that can be generated. */ + +enum unwind_info_type +{ + UI_NONE, + UI_SJLJ, + UI_DWARF2, + UI_TARGET +}; + +/* 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 +}; + + +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; + +#define obstack_chunk_alloc ((void *(*) (long)) xmalloc) +#define obstack_chunk_free ((void (*) (void *)) free) +#define OBSTACK_CHUNK_SIZE 0 +#define gcc_obstack_init(OBSTACK) \ + _obstack_begin ((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; + +#else + +struct _dont_use_rtx_here_; +struct _dont_use_rtvec_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 tree union _dont_use_tree_here_ * +#define const_tree union _dont_use_tree_here_ * + +#endif + +#endif /* coretypes.h */ + diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cp-tree.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cp-tree.def new file mode 100644 index 0000000..509d5e7 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cp-tree.def @@ -0,0 +1,466 @@ +/* This file contains the definitions and documentation for the + additional tree codes used in the GNU C++ compiler (see tree.def + for the standard codes). + Copyright (C) 1987, 1988, 1990, 1993, 1997, 1998, 2003, 2004, 2005, + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2010 + Free Software Foundation, Inc. + Hacked by Michael Tiemann (tiemann@cygnus.com) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + + +/* An OFFSET_REF is used in two situations: + + 1. An expression of the form `A::m' where `A' is a class and `m' is + a non-static member. In this case, operand 0 will be a TYPE + (corresponding to `A') and operand 1 will be a FIELD_DECL, + BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m'). + + The expression is a pointer-to-member if its address is taken, + but simply denotes a member of the object if its address is not + taken. + + This form is only used during the parsing phase; once semantic + analysis has taken place they are eliminated. + + 2. An expression of the form `x.*p'. In this case, operand 0 will + be an expression corresponding to `x' and operand 1 will be an + expression with pointer-to-member type. */ +DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2) + +/* A pointer-to-member constant. For a pointer-to-member constant + `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the + PTRMEM_CST_MEMBER is the _DECL for `Y'. */ +DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0) + +/* For NEW_EXPR, operand 0 is the placement list. + Operand 1 is the new-declarator. + Operand 2 is the number of elements in the array. + Operand 3 is the initializer. */ +DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4) +DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3) + +/* For DELETE_EXPR, operand 0 is the store to be destroyed. + Operand 1 is the value to pass to the destroying function + saying whether the store should be deallocated as well. */ +DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2) +DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2) + +/* Value is reference to particular overloaded class method. + Operand 0 is the class, operand 1 is the field + The COMPLEXITY field holds the class level (usually 0). */ +DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2) + +/* When composing an object with a member, this is the result. + Operand 0 is the object. Operand 1 is the member (usually + a dereferenced pointer to member). */ +DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2) + +/* Type conversion operator in C++. TREE_TYPE is type that this + operator converts to. Operand is expression to be converted. */ +DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1) + +/* AGGR_INIT_EXPRs have a variably-sized representation similar to + that of CALL_EXPRs. Operand 0 is an INTEGER_CST node containing the + operand count, operand 1 is the function which performs initialization, + operand 2 is the slot which was allocated for this expression, and + the remaining operands are the arguments to the initialization function. */ +DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3) + +/* Initialization of an array from another array, expressed at a high level + so that it works with TARGET_EXPR. Operand 0 is the target, operand 1 + is the initializer. */ +DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", tcc_expression, 2) + +/* A throw expression. operand 0 is the expression, if there was one, + else it is NULL_TREE. */ +DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1) + +/* An empty class object. The TREE_TYPE gives the class type. We use + these to avoid actually creating instances of the empty classes. */ +DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0) + +/* A reference to a member function or member functions from a base + class. BASELINK_FUNCTIONS gives the FUNCTION_DECL, + TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the + functions. BASELINK_BINFO gives the base from which the functions + come, i.e., the base to which the `this' pointer must be converted + before the functions are called. BASELINK_ACCESS_BINFO gives the + base used to name the functions. + + A BASELINK is an expression; the TREE_TYPE of the BASELINK gives + the type of the expression. This type is either a FUNCTION_TYPE, + METHOD_TYPE, or `unknown_type_node' indicating that the function is + overloaded. */ +DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0) + +/* Template definition. The following fields have the specified uses, + although there are other macros in cp-tree.h that should be used for + accessing this data. + DECL_ARGUMENTS template parm vector + DECL_TEMPLATE_INFO template text &c + DECL_VINDEX list of instantiations already produced; + only done for functions so far + For class template: + DECL_INITIAL associated templates (methods &c) + DECL_TEMPLATE_RESULT null + For non-class templates: + TREE_TYPE type of object to be constructed + DECL_TEMPLATE_RESULT decl for object to be created + (e.g., FUNCTION_DECL with tmpl parms used) + */ +DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0) + +/* Index into a template parameter list. The TEMPLATE_PARM_IDX gives + the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL + gives the level (from 1) of the parameter. + + Here's an example: + + template <class T> // Index 0, Level 1. + struct S + { + template <class U, // Index 0, Level 2. + class V> // Index 1, Level 2. + void f(); + }; + + The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended + from this one. The first descendant will have the same IDX, but + its LEVEL will be one less. The TREE_CHAIN field is used to chain + together the descendants. The TEMPLATE_PARM_DECL is the + declaration of this parameter, either a TYPE_DECL or CONST_DECL. + The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant + parent, i.e., the LEVEL that the parameter originally had when it + was declared. For example, if we instantiate S<int>, we will have: + + struct S<int> + { + template <class U, // Index 0, Level 1, Orig Level 2 + class V> // Index 1, Level 1, Orig Level 2 + void f(); + }; + + The LEVEL is the level of the parameter when we are worrying about + the types of things; the ORIG_LEVEL is the level when we are + worrying about instantiating things. */ +DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0) + +/* Index into a template parameter list for template template parameters. + This parameter must be a type. The TYPE_FIELDS value will be a + TEMPLATE_PARM_INDEX. + + It is used without template arguments like TT in C<TT>, + TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE + and TYPE_NAME is a TEMPLATE_DECL. */ +DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0) + +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE, + BOUND_TEMPLATE_TEMPLATE_PARM. */ + +/* Index into a template parameter list. This parameter must be a type. + The type.values field will be a TEMPLATE_PARM_INDEX. */ +DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0) + +/* A type designated by `typename T::t'. TYPE_CONTEXT is `T', + TYPE_NAME is an IDENTIFIER_NODE for `t'. If the type was named via + template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR. + TREE_TYPE is always NULL. */ +DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0) + +/* A type designated by `__typeof (expr)'. TYPEOF_TYPE_EXPR is the + expression in question. */ +DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0) + +/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments + like TT<int>. + In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the + template name and its bound arguments. TYPE_NAME is a TYPE_DECL. */ +DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", + tcc_type, 0) + +/* For template template argument of the form `T::template C'. + TYPE_CONTEXT is `T', the template parameter dependent object. + TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template. */ +DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0) + +/* A using declaration. USING_DECL_SCOPE contains the specified + scope. In a member using decl, unless DECL_DEPENDENT_P is true, + USING_DECL_DECLS contains the _DECL or OVERLOAD so named. This is + not an alias, but is later expanded into multiple aliases. */ +DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0) + +/* A using directive. The operand is USING_STMT_NAMESPACE. */ +DEFTREECODE (USING_STMT, "using_directive", tcc_statement, 1) + +/* An un-parsed default argument. Holds a vector of input tokens and + a vector of places where the argument was instantiated before + parsing had occurred. */ +DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0) + +/* A template-id, like foo<int>. The first operand is the template. + The second is NULL if there are no explicit arguments, or a + TREE_VEC of arguments. The template will be a FUNCTION_DECL, + TEMPLATE_DECL, or an OVERLOAD. If the template-id refers to a + member template, the template may be an IDENTIFIER_NODE. */ +DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2) + +/* A list-like node for chaining overloading candidates. TREE_TYPE is + the original name, and the parameter is the FUNCTION_DECL. */ +DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0) + +/* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or + "OBJECT.SCOPE::~DESTRUCTOR. The first operand is the OBJECT. The + second operand (if non-NULL) is the SCOPE. The third operand is + the TYPE node corresponding to the DESTRUCTOR. The type of the + first operand will always be a scalar type. + + The type of a PSEUDO_DTOR_EXPR is always "void", even though it can + be used as if it were a zero-argument function. We handle the + function-call case specially, and giving it "void" type prevents it + being used in expressions in ways that are not permitted. */ +DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3) + +/* A whole bunch of tree codes for the initial, superficial parsing of + templates. */ +DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3) +DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1) +DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1) +DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1) +DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1) +DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1) +DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2) +DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1) +DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1) + +/* A placeholder for an expression that is not type-dependent, but + does occur in a template. When an expression that is not + type-dependent appears in a larger expression, we must compute the + type of that larger expression. That computation would normally + modify the original expression, which would change the mangling of + that expression if it appeared in a template argument list. In + that situation, we create a NON_DEPENDENT_EXPR to take the place of + the original expression. The expression is the only operand -- it + is only needed for diagnostics. */ +DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1) + +/* CTOR_INITIALIZER is a placeholder in template code for a call to + setup_vtbl_pointer (and appears in all functions, not just ctors). */ +DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1) + +DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2) + +DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2) + +/* A HANDLER wraps a catch handler for the HANDLER_TYPE. If this is + CATCH_ALL_TYPE, then the handler catches all types. The declaration of + the catch variable is in HANDLER_PARMS, and the body block in + HANDLER_BODY. */ +DEFTREECODE (HANDLER, "handler", tcc_statement, 2) + +/* A MUST_NOT_THROW_EXPR wraps an expression that may not + throw, and must call terminate if it does. */ +DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1) + +/* A CLEANUP_STMT marks the point at which a declaration is fully + constructed. The CLEANUP_EXPR is run on behalf of CLEANUP_DECL + when CLEANUP_BODY completes. */ +DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3) + +/* Represents an 'if' statement. The operands are IF_COND, + THEN_CLAUSE, and ELSE_CLAUSE, respectively. */ +/* ??? It is currently still necessary to distinguish between IF_STMT + and COND_EXPR for the benefit of templates. */ +DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 3) + +/* Used to represent a `for' statement. The operands are + FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively. */ +DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 4) + +/* Used to represent a range-based `for' statement. The operands are + RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, respectively. Only used + in templates. */ +DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 3) + +/* Used to represent a 'while' statement. The operands are WHILE_COND + and WHILE_BODY, respectively. */ +DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2) + +/* Used to represent a 'do' statement. The operands are DO_BODY and + DO_COND, respectively. */ +DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2) + +/* Used to represent a 'break' statement. */ +DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0) + +/* Used to represent a 'continue' statement. */ +DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0) + +/* Used to represent a 'switch' statement. The operands are + SWITCH_STMT_COND, SWITCH_STMT_BODY and SWITCH_STMT_TYPE, respectively. */ +DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 3) + +/* Used to represent an expression statement. Use `EXPR_STMT_EXPR' to + obtain the expression. */ +DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1) + +DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0) + +/* Represents an 'offsetof' expression during template expansion. */ +DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1) + +/* Represents a 'sizeof' expression during template expansion. */ +DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1) + +/* Represents the -> operator during template expansion. */ +DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1) + +/* Represents an '__alignof__' expression during template + expansion. */ +DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1) + +/* Represents an Objective-C++ '@encode' expression during template + expansion. */ +DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1) + +/* A STMT_EXPR represents a statement-expression during template + expansion. This is the GCC extension { ( ... ) }. The + STMT_EXPR_STMT is the statement given by the expression. */ +DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1) + +/* Unary plus. Operand 0 is the expression to which the unary plus + is applied. */ +DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1) + +/** C++0x extensions. */ + +/* A static assertion. This is a C++0x extension. + STATIC_ASSERT_CONDITION contains the condition that is being + checked. STATIC_ASSERT_MESSAGE contains the message (a string + literal) to be displayed if the condition fails to hold. */ +DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0) + +/* Represents an argument pack of types (or templates). An argument + pack stores zero or more arguments that will be used to instantiate + a parameter pack. + + ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument + pack. + + Example: + template<typename... Values> + class tuple { ... }; + + tuple<int, float, double> t; + + Values is a (template) parameter pack. When tuple<int, float, + double> is instantiated, the Values parameter pack is instantiated + with the argument pack <int, float, double>. ARGUMENT_PACK_ARGS will + be a TREE_VEC containing int, float, and double. */ +DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0) + +/* Represents an argument pack of values, which can be used either for + non-type template arguments or function call arguments. + + NONTYPE_ARGUMENT_PACK plays precisely the same role as + TYPE_ARGUMENT_PACK, but will be used for packing non-type template + arguments (e.g., "int... Dimensions") or function arguments ("const + Args&... args"). */ +DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1) + +/* Represents a type expression that will be expanded into a list of + types when instantiated with one or more argument packs. + + PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is + the type or expression that we will substitute into with each + argument in an argument pack. + + SET_PACK_EXPANSION_PATTERN sets the expansion pattern. + + PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter + packs that are used in this pack expansion. + + Example: + template<typename... Values> + struct tied : tuple<Values&...> { + // ... + }; + + The derivation from tuple contains a TYPE_PACK_EXPANSION for the + template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its + PACK_EXPANSION_PARAMETER_PACKS will contain "Values". */ +DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0) + +/* Represents an expression that will be expanded into a list of + expressions when instantiated with one or more argument packs. + + EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION, + but will be used for expressions. */ +DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 1) + +/* Selects the Ith parameter out of an argument pack. This node will + be used when instantiating pack expansions; see + tsubst_pack_expansion. + + ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node + from which the argument will be selected. + + ARGUMENT_PACK_SELECT_INDEX contains the index into the argument + pack that will be returned by this ARGUMENT_PACK_SELECT node. The + index is a machine integer. */ +DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0) + +/** C++ extensions. */ + +/* Represents a trait expression during template expansion. */ +DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0) + +/* A lambda expression. This is a C++0x extension. + LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be + none. + LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'. + LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists. + LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable. + LAMBDA_EXPR_RETURN_TYPE holds the return type, if it was specified. */ +DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0) + +/* The declared type of an expression. This is a C++0x extension. + DECLTYPE_TYPE_EXPR is the expression whose type we are computing. + DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the + expression was parsed as an id-expression or a member access + expression. When false, it was parsed as a full expression. + DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics. + DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction. */ +DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0) + +/* Used to represent the template information stored by template + specializations. + The accessors are: + TI_TEMPLATE the template declaration associated to the specialization + TI_ARGS the arguments of the template specialization + TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in + the pattern of the template for which access check is needed at template + instantiation time. */ +DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0) + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cp-tree.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cp-tree.h new file mode 100644 index 0000000..daf4714 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cp-tree.h @@ -0,0 +1,5683 @@ +/* Definitions for C++ parsing and type checking. + Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Michael Tiemann (tiemann@cygnus.com) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + +#ifndef GCC_CP_TREE_H +#define GCC_CP_TREE_H + +#include "ggc.h" +#include "function.h" +#include "hashtab.h" +#include "vec.h" +#include "l-ipo.h" + +/* In order for the format checking to accept the C++ front end + diagnostic framework extensions, you must include this file before + diagnostic-core.h, not after. We override the definition of GCC_DIAG_STYLE + in c-common.h. */ +#undef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_cxxdiag__ +#if defined(GCC_DIAGNOSTIC_CORE_H) || defined (GCC_C_COMMON_H) +#error \ +In order for the format checking to accept the C++ front end diagnostic \ +framework extensions, you must include this file before diagnostic-core.h and \ +c-common.h, not after. +#endif +#include "c-family/c-common.h" +#include "diagnostic.h" + +#include "name-lookup.h" + +/* Usage of TREE_LANG_FLAG_?: + 0: IDENTIFIER_MARKED (IDENTIFIER_NODEs) + NEW_EXPR_USE_GLOBAL (in NEW_EXPR). + DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR). + COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR). + TREE_INDIRECT_USING (in NAMESPACE_DECL). + CLEANUP_P (in TRY_BLOCK) + AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR) + PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF) + PAREN_STRING_LITERAL (in STRING_CST) + DECL_PRETTY_FUNCTION_P (in VAR_DECL) + KOENIG_LOOKUP_P (in CALL_EXPR) + STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST). + EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT) + STMT_EXPR_NO_SCOPE (in STMT_EXPR) + BIND_EXPR_TRY_BLOCK (in BIND_EXPR) + TYPENAME_IS_ENUM_P (in TYPENAME_TYPE) + REFERENCE_REF_P (in INDIRECT_EXPR) + QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF) + OMP_FOR_GIMPLIFYING_P (in OMP_FOR) + BASELINK_QUALIFIED_P (in BASELINK) + TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR) + TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX) + ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute) + CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR) + LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR) + DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE) + VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR) + 1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE) + TI_PENDING_TEMPLATE_FLAG. + TEMPLATE_PARMS_FOR_INLINE. + DELETE_EXPR_USE_VEC (in DELETE_EXPR). + (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out). + ICS_ELLIPSIS_FLAG (in _CONV) + DECL_INITIALIZED_P (in VAR_DECL) + TYPENAME_IS_CLASS_P (in TYPENAME_TYPE) + STMT_IS_FULL_EXPR_P (in _STMT) + TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR) + LAMBDA_EXPR_MUTABLE_P (in LAMBDA_EXPR) + DECLTYPE_FOR_LAMBDA_RETURN (in DECLTYPE_TYPE) + 2: IDENTIFIER_OPNAME_P (in IDENTIFIER_NODE) + ICS_THIS_FLAG (in _CONV) + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL) + STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST) + TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE) + LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (in LAMBDA_EXPR) + TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR) + 3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out). + ICS_BAD_FLAG (in _CONV) + FN_TRY_BLOCK_P (in TRY_BLOCK) + IDENTIFIER_CTOR_OR_DTOR_P (in IDENTIFIER_NODE) + BIND_EXPR_BODY_BLOCK (in BIND_EXPR) + DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL) + 4: TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR, + or FIELD_DECL). + IDENTIFIER_TYPENAME_P (in IDENTIFIER_NODE) + DECL_TINFO_P (in VAR_DECL) + 5: C_IS_RESERVED_WORD (in IDENTIFIER_NODE) + DECL_VTABLE_OR_VTT_P (in VAR_DECL) + 6: IDENTIFIER_REPO_CHOSEN (in IDENTIFIER_NODE) + DECL_CONSTRUCTION_VTABLE_P (in VAR_DECL) + TYPE_MARKED_P (in _TYPE) + + Usage of TYPE_LANG_FLAG_?: + 0: TYPE_DEPENDENT_P + 1: TYPE_HAS_USER_CONSTRUCTOR. + 2: unused + 3: TYPE_FOR_JAVA. + 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR + 5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE) + ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE) + 6: TYPE_DEPENDENT_P_VALID + + Usage of DECL_LANG_FLAG_?: + 0: DECL_ERROR_REPORTED (in VAR_DECL). + DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL) + DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL) + DECL_MUTABLE_P (in FIELD_DECL) + DECL_DEPENDENT_P (in USING_DECL) + 1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL). + DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL) + DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL) + FUNCTION_PARAMETER_PACK_P (in PARM_DECL) + 2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL). + DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL) + 3: DECL_IN_AGGR_P. + 4: DECL_C_BIT_FIELD (in a FIELD_DECL) + DECL_ANON_UNION_VAR_P (in a VAR_DECL) + DECL_SELF_REFERENCE_P (in a TYPE_DECL) + DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL) + 5: DECL_INTERFACE_KNOWN. + 6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL). + DECL_FIELD_IS_BASE (in FIELD_DECL) + 7: DECL_DEAD_FOR_LOCAL (in VAR_DECL). + DECL_THUNK_P (in a member FUNCTION_DECL) + DECL_NORMAL_CAPTURE_P (in FIELD_DECL) + 8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL) + + Usage of language-independent fields in a language-dependent manner: + + TYPE_ALIAS_SET + This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so + forth as a substitute for the mark bits provided in `lang_type'. + At present, only the six low-order bits are used. + + TYPE_LANG_SLOT_1 + For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO. + For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS + + BINFO_VIRTUALS + For a binfo, this is a TREE_LIST. There is an entry for each + virtual function declared either in BINFO or its direct and + indirect primary bases. + + The BV_DELTA of each node gives the amount by which to adjust the + `this' pointer when calling the function. If the method is an + overridden version of a base class method, then it is assumed + that, prior to adjustment, the this pointer points to an object + of the base class. + + The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable + index of the vcall offset for this entry. + + The BV_FN is the declaration for the virtual function itself. + + If BV_LOST_PRIMARY is set, it means that this entry is for a lost + primary virtual base and can be left null in the vtable. + + BINFO_VTABLE + This is an expression with POINTER_TYPE that gives the value + to which the vptr should be initialized. Use get_vtbl_decl_for_binfo + to extract the VAR_DECL for the complete vtable. + + DECL_VINDEX + This field is NULL for a non-virtual function. For a virtual + function, it is eventually set to an INTEGER_CST indicating the + index in the vtable at which this function can be found. When + a virtual function is declared, but before it is known what + function is overridden, this field is the error_mark_node. + + Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is + the virtual function this one overrides, and whose TREE_CHAIN is + the old DECL_VINDEX. */ + +/* Language-specific tree checkers. */ + +#define VAR_OR_FUNCTION_DECL_CHECK(NODE) \ + TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL) + +#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \ + TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL) + +#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \ + TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL) + +#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \ + TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM) + +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) +#define THUNK_FUNCTION_CHECK(NODE) __extension__ \ +({ __typeof (NODE) const __t = (NODE); \ + if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \ + || !__t->decl_common.lang_specific->u.fn.thunk_p) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0); \ + __t; }) +#else +#define THUNK_FUNCTION_CHECK(NODE) (NODE) +#endif + +/* Language-dependent contents of an identifier. */ + +struct GTY(()) lang_identifier { + struct c_common_identifier c_common; + cxx_binding *namespace_bindings; + cxx_binding *bindings; + tree class_template_info; + tree label_value; +}; + +/* In an IDENTIFIER_NODE, nonzero if this identifier is actually a + keyword. C_RID_CODE (node) is then the RID_* value of the keyword, + and C_RID_YYCODE is the token number wanted by Yacc. */ + +#define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_5 (ID) + +#define LANG_IDENTIFIER_CAST(NODE) \ + ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE)) + +struct GTY(()) template_parm_index_s { + struct tree_common common; + int index; + int level; + int orig_level; + int num_siblings; + tree decl; +}; +typedef struct template_parm_index_s template_parm_index; + +struct GTY(()) ptrmem_cst { + struct tree_common common; + tree member; +}; +typedef struct ptrmem_cst * ptrmem_cst_t; + +#define IDENTIFIER_GLOBAL_VALUE(NODE) \ + namespace_binding ((NODE), global_namespace) +#define SET_IDENTIFIER_GLOBAL_VALUE(NODE, VAL) \ + set_namespace_binding ((NODE), global_namespace, (VAL)) +#define IDENTIFIER_NAMESPACE_VALUE(NODE) \ + namespace_binding ((NODE), current_namespace) +#define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) \ + set_namespace_binding ((NODE), current_namespace, (VAL)) + +#define CLEANUP_P(NODE) TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE)) + +#define BIND_EXPR_TRY_BLOCK(NODE) \ + TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE)) + +/* Used to mark the block around the member initializers and cleanups. */ +#define BIND_EXPR_BODY_BLOCK(NODE) \ + TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE)) +#define FUNCTION_NEEDS_BODY_BLOCK(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE)) + +#define STATEMENT_LIST_NO_SCOPE(NODE) \ + TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE)) +#define STATEMENT_LIST_TRY_BLOCK(NODE) \ + TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE)) + +/* Nonzero if this statement should be considered a full-expression, + i.e., if temporaries created during this statement should have + their destructors run at the end of this statement. */ +#define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE)) + +/* Marks the result of a statement expression. */ +#define EXPR_STMT_STMT_EXPR_RESULT(NODE) \ + TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE)) + +/* Nonzero if this statement-expression does not have an associated scope. */ +#define STMT_EXPR_NO_SCOPE(NODE) \ + TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE)) + +/* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual + sense of `same'. */ +#define same_type_p(TYPE1, TYPE2) \ + comptypes ((TYPE1), (TYPE2), COMPARE_STRICT) + +/* Nonzero if we are presently building a statement tree, rather + than expanding each statement as we encounter it. */ +#define building_stmt_tree() (cur_stmt_list != NULL_TREE) + +/* Returns nonzero iff NODE is a declaration for the global function + `main'. */ +#define DECL_MAIN_P(NODE) \ + (DECL_EXTERN_C_FUNCTION_P (NODE) \ + && DECL_NAME (NODE) != NULL_TREE \ + && MAIN_NAME_P (DECL_NAME (NODE)) \ + && flag_hosted) + +/* The overloaded FUNCTION_DECL. */ +#define OVL_FUNCTION(NODE) \ + (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function) +#define OVL_CHAIN(NODE) TREE_CHAIN (NODE) +/* Polymorphic access to FUNCTION and CHAIN. */ +#define OVL_CURRENT(NODE) \ + ((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE)) +#define OVL_NEXT(NODE) \ + ((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE) +/* If set, this was imported in a using declaration. + This is not to confuse with being used somewhere, which + is not important for this node. */ +#define OVL_USED(NODE) TREE_USED (NODE) + +struct GTY(()) tree_overload { + struct tree_common common; + tree function; +}; + +/* Returns true iff NODE is a BASELINK. */ +#define BASELINK_P(NODE) \ + (TREE_CODE (NODE) == BASELINK) +/* The BINFO indicating the base from which the BASELINK_FUNCTIONS came. */ +#define BASELINK_BINFO(NODE) \ + (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo) +/* The functions referred to by the BASELINK; either a FUNCTION_DECL, + a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR. */ +#define BASELINK_FUNCTIONS(NODE) \ + (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions) +/* The BINFO in which the search for the functions indicated by this baselink + began. This base is used to determine the accessibility of functions + selected by overload resolution. */ +#define BASELINK_ACCESS_BINFO(NODE) \ + (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo) +/* For a type-conversion operator, the BASELINK_OPTYPE indicates the type + to which the conversion should occur. This value is important if + the BASELINK_FUNCTIONS include a template conversion operator -- + the BASELINK_OPTYPE can be used to determine what type the user + requested. */ +#define BASELINK_OPTYPE(NODE) \ + (TREE_CHAIN (BASELINK_CHECK (NODE))) +/* Nonzero if this baselink was from a qualified lookup. */ +#define BASELINK_QUALIFIED_P(NODE) \ + TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE)) + +struct GTY(()) tree_baselink { + struct tree_common common; + tree binfo; + tree functions; + tree access_binfo; +}; + +/* The different kinds of ids that we encounter. */ + +typedef enum cp_id_kind +{ + /* Not an id at all. */ + CP_ID_KIND_NONE, + /* An unqualified-id that is not a template-id. */ + CP_ID_KIND_UNQUALIFIED, + /* An unqualified-id that is a dependent name. */ + CP_ID_KIND_UNQUALIFIED_DEPENDENT, + /* An unqualified template-id. */ + CP_ID_KIND_TEMPLATE_ID, + /* A qualified-id. */ + CP_ID_KIND_QUALIFIED +} cp_id_kind; + + +/* The various kinds of C++0x warnings we encounter. */ + +typedef enum cpp0x_warn_str +{ + /* extended initializer lists */ + CPP0X_INITIALIZER_LISTS, + /* explicit conversion operators */ + CPP0X_EXPLICIT_CONVERSION, + /* variadic templates */ + CPP0X_VARIADIC_TEMPLATES, + /* lambda expressions */ + CPP0X_LAMBDA_EXPR, + /* C++0x auto */ + CPP0X_AUTO, + /* scoped enums */ + CPP0X_SCOPED_ENUMS, + /* defaulted and deleted functions */ + CPP0X_DEFAULTED_DELETED, + /* inline namespaces */ + CPP0X_INLINE_NAMESPACES +} cpp0x_warn_str; + +/* The various kinds of operation used by composite_pointer_type. */ + +typedef enum composite_pointer_operation +{ + /* comparison */ + CPO_COMPARISON, + /* conversion */ + CPO_CONVERSION, + /* conditional expression */ + CPO_CONDITIONAL_EXPR +} composite_pointer_operation; + +/* Possible cases of expression list used by build_x_compound_expr_from_list. */ +typedef enum expr_list_kind { + ELK_INIT, /* initializer */ + ELK_MEM_INIT, /* member initializer */ + ELK_FUNC_CAST /* functional cast */ +} expr_list_kind; + +/* Possible cases of implicit bad rhs conversions. */ +typedef enum impl_conv_rhs { + ICR_DEFAULT_ARGUMENT, /* default argument */ + ICR_CONVERTING, /* converting */ + ICR_INIT, /* initialization */ + ICR_ARGPASS, /* argument passing */ + ICR_RETURN, /* return */ + ICR_ASSIGN /* assignment */ +} impl_conv_rhs; + +/* Possible cases of implicit or explicit bad conversions to void. */ +typedef enum impl_conv_void { + ICV_CAST, /* (explicit) conversion to void */ + ICV_SECOND_OF_COND, /* second operand of conditional expression */ + ICV_THIRD_OF_COND, /* third operand of conditional expression */ + ICV_RIGHT_OF_COMMA, /* right operand of comma operator */ + ICV_LEFT_OF_COMMA, /* left operand of comma operator */ + ICV_STATEMENT, /* statement */ + ICV_THIRD_IN_FOR /* for increment expression */ +} impl_conv_void; + +/* Macros for access to language-specific slots in an identifier. */ + +#define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings) +#define IDENTIFIER_TEMPLATE(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->class_template_info) + +/* The IDENTIFIER_BINDING is the innermost cxx_binding for the + identifier. It's PREVIOUS is the next outermost binding. Each + VALUE field is a DECL for the associated declaration. Thus, + name lookup consists simply of pulling off the node at the front + of the list (modulo oddities for looking up the names of types, + and such.) You can use SCOPE field to determine the scope + that bound the name. */ +#define IDENTIFIER_BINDING(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->bindings) + +/* TREE_TYPE only indicates on local and class scope the current + type. For namespace scope, the presence of a type in any namespace + is indicated with global_type_node, and the real type behind must + be found through lookup. */ +#define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE) +#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE) +#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE)) +#define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0) + +#define IDENTIFIER_LABEL_VALUE(NODE) \ + (LANG_IDENTIFIER_CAST (NODE)->label_value) +#define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \ + IDENTIFIER_LABEL_VALUE (NODE) = (VALUE) + +/* Nonzero if this identifier is used as a virtual function name somewhere + (optimizes searches). */ +#define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1 (NODE) + +/* Nonzero if this identifier is the prefix for a mangled C++ operator + name. */ +#define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2 (NODE) + +/* Nonzero if this identifier is the name of a type-conversion + operator. */ +#define IDENTIFIER_TYPENAME_P(NODE) \ + TREE_LANG_FLAG_4 (NODE) + +/* Nonzero if this identifier is the name of a constructor or + destructor. */ +#define IDENTIFIER_CTOR_OR_DTOR_P(NODE) \ + TREE_LANG_FLAG_3 (NODE) + +/* True iff NAME is the DECL_ASSEMBLER_NAME for an entity with vague + linkage which the prelinker has assigned to this translation + unit. */ +#define IDENTIFIER_REPO_CHOSEN(NAME) \ + (TREE_LANG_FLAG_6 (NAME)) + +/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */ +#define C_TYPE_FIELDS_READONLY(TYPE) \ + (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly) + +/* The tokens stored in the default argument. */ + +#define DEFARG_TOKENS(NODE) \ + (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->tokens) +#define DEFARG_INSTANTIATIONS(NODE) \ + (((struct tree_default_arg *)DEFAULT_ARG_CHECK (NODE))->instantiations) + +struct GTY (()) tree_default_arg { + struct tree_common common; + struct cp_token_cache *tokens; + VEC(tree,gc) *instantiations; +}; + +/* The condition associated with the static assertion. This must be + an integral constant expression. */ +#define STATIC_ASSERT_CONDITION(NODE) \ + (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition) + +/* The message associated with the static assertion. This must be a + string constant, which will be emitted as an error message when the + static assert condition is false. */ +#define STATIC_ASSERT_MESSAGE(NODE) \ + (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message) + +/* Source location information for a static assertion. */ +#define STATIC_ASSERT_SOURCE_LOCATION(NODE) \ + (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location) + +struct GTY (()) tree_static_assert { + struct tree_common common; + tree condition; + tree message; + location_t location; +}; + +struct GTY (()) tree_argument_pack_select { + struct tree_common common; + tree argument_pack; + int index; +}; + +/* The different kinds of traits that we encounter. */ + +typedef enum cp_trait_kind +{ + CPTK_HAS_NOTHROW_ASSIGN, + CPTK_HAS_NOTHROW_CONSTRUCTOR, + CPTK_HAS_NOTHROW_COPY, + CPTK_HAS_TRIVIAL_ASSIGN, + CPTK_HAS_TRIVIAL_CONSTRUCTOR, + CPTK_HAS_TRIVIAL_COPY, + CPTK_HAS_TRIVIAL_DESTRUCTOR, + CPTK_HAS_VIRTUAL_DESTRUCTOR, + CPTK_IS_ABSTRACT, + CPTK_IS_BASE_OF, + CPTK_IS_CLASS, + CPTK_IS_CONVERTIBLE_TO, + CPTK_IS_EMPTY, + CPTK_IS_ENUM, + CPTK_IS_POD, + CPTK_IS_POLYMORPHIC, + CPTK_IS_STD_LAYOUT, + CPTK_IS_TRIVIAL, + CPTK_IS_LITERAL_TYPE, + CPTK_IS_UNION +} cp_trait_kind; + +/* The types that we are processing. */ +#define TRAIT_EXPR_TYPE1(NODE) \ + (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1) + +#define TRAIT_EXPR_TYPE2(NODE) \ + (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2) + +/* The specific trait that we are processing. */ +#define TRAIT_EXPR_KIND(NODE) \ + (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind) + +struct GTY (()) tree_trait_expr { + struct tree_common common; + tree type1; + tree type2; + enum cp_trait_kind kind; +}; + +/* Based off of TYPE_ANONYMOUS_P. */ +#define LAMBDA_TYPE_P(NODE) \ + (CLASS_TYPE_P (NODE) && LAMBDANAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) + +/* Test if FUNCTION_DECL is a lambda function. */ +#define LAMBDA_FUNCTION_P(FNDECL) \ + (DECL_OVERLOADED_OPERATOR_P (FNDECL) == CALL_EXPR \ + && LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL))) + +enum cp_lambda_default_capture_mode_type { + CPLD_NONE, + CPLD_COPY, + CPLD_REFERENCE +}; + +/* The method of default capture, if any. */ +#define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode) + +/* The capture-list, including `this'. Each capture is stored as a FIELD_DECL + * so that the name, type, and field are all together, whether or not it has + * been added to the lambda's class type. + TREE_LIST: + TREE_PURPOSE: The FIELD_DECL for this capture. + TREE_VALUE: The initializer. This is part of a GNU extension. */ +#define LAMBDA_EXPR_CAPTURE_LIST(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list) + +/* The node in the capture-list that holds the 'this' capture. */ +#define LAMBDA_EXPR_THIS_CAPTURE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture) + +/* Predicate tracking whether `this' is in the effective capture set. */ +#define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \ + LAMBDA_EXPR_THIS_CAPTURE(NODE) + +/* Predicate tracking whether the lambda was declared 'mutable'. */ +#define LAMBDA_EXPR_MUTABLE_P(NODE) \ + TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE)) + +/* True iff we should try to deduce the lambda return type from any return + statement. */ +#define LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P(NODE) \ + TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE)) + +/* The return type in the expression. + * NULL_TREE indicates that none was specified. */ +#define LAMBDA_EXPR_RETURN_TYPE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->return_type) + +/* The source location of the lambda. */ +#define LAMBDA_EXPR_LOCATION(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus) + +/* The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL, + FIELD_DECL or NULL_TREE. If this is NULL_TREE, we have no linkage. */ +#define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope) + +/* If EXTRA_SCOPE, this is the number of the lambda within that scope. */ +#define LAMBDA_EXPR_DISCRIMINATOR(NODE) \ + (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator) + +struct GTY (()) tree_lambda_expr +{ + struct tree_common common; + location_t locus; + enum cp_lambda_default_capture_mode_type default_capture_mode; + tree capture_list; + tree this_capture; + tree return_type; + tree extra_scope; + int discriminator; +}; + +/* A (typedef,context,usage location) triplet. + It represents a typedef used through a + context at a given source location. + e.g. + struct foo { + typedef int myint; + }; + + struct bar { + foo::myint v; // #1<-- this location. + }; + + In bar, the triplet will be (myint, foo, #1). + */ +struct GTY(()) qualified_typedef_usage_s { + tree typedef_decl; + tree context; + location_t locus; +}; +typedef struct qualified_typedef_usage_s qualified_typedef_usage_t; +DEF_VEC_O (qualified_typedef_usage_t); +DEF_VEC_ALLOC_O (qualified_typedef_usage_t,gc); + +struct GTY(()) tree_template_info { + struct tree_common common; + VEC(qualified_typedef_usage_t,gc) *typedefs_needing_access_checking; +}; + +enum cp_tree_node_structure_enum { + TS_CP_GENERIC, + TS_CP_IDENTIFIER, + TS_CP_TPI, + TS_CP_PTRMEM, + TS_CP_BINDING, + TS_CP_OVERLOAD, + TS_CP_BASELINK, + TS_CP_WRAPPER, + TS_CP_DEFAULT_ARG, + TS_CP_STATIC_ASSERT, + TS_CP_ARGUMENT_PACK_SELECT, + TS_CP_TRAIT_EXPR, + TS_CP_LAMBDA_EXPR, + TS_CP_TEMPLATE_INFO, + LAST_TS_CP_ENUM +}; + +/* The resulting tree type. */ +union GTY((desc ("cp_tree_node_structure (&%h)"), + chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)"))) lang_tree_node { + union tree_node GTY ((tag ("TS_CP_GENERIC"), + desc ("tree_node_structure (&%h)"))) generic; + struct template_parm_index_s GTY ((tag ("TS_CP_TPI"))) tpi; + struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem; + struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload; + struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink; + struct tree_default_arg GTY ((tag ("TS_CP_DEFAULT_ARG"))) default_arg; + struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier; + struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT"))) + static_assertion; + struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT"))) + argument_pack_select; + struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR"))) + trait_expression; + struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR"))) + lambda_expression; + struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO"))) + template_info; +}; + + +enum cp_tree_index +{ + CPTI_JAVA_BYTE_TYPE, + CPTI_JAVA_SHORT_TYPE, + CPTI_JAVA_INT_TYPE, + CPTI_JAVA_LONG_TYPE, + CPTI_JAVA_FLOAT_TYPE, + CPTI_JAVA_DOUBLE_TYPE, + CPTI_JAVA_CHAR_TYPE, + CPTI_JAVA_BOOLEAN_TYPE, + + CPTI_WCHAR_DECL, + CPTI_VTABLE_ENTRY_TYPE, + CPTI_DELTA_TYPE, + CPTI_VTABLE_INDEX_TYPE, + CPTI_CLEANUP_TYPE, + CPTI_VTT_PARM_TYPE, + + CPTI_CLASS_TYPE, + CPTI_UNKNOWN_TYPE, + CPTI_INIT_LIST_TYPE, + CPTI_VTBL_TYPE, + CPTI_VTBL_PTR_TYPE, + CPTI_STD, + CPTI_ABI, + CPTI_CONST_TYPE_INFO_TYPE, + CPTI_TYPE_INFO_PTR_TYPE, + CPTI_ABORT_FNDECL, + CPTI_GLOBAL_DELETE_FNDECL, + CPTI_AGGR_TAG, + + CPTI_CTOR_IDENTIFIER, + CPTI_COMPLETE_CTOR_IDENTIFIER, + CPTI_BASE_CTOR_IDENTIFIER, + CPTI_DTOR_IDENTIFIER, + CPTI_COMPLETE_DTOR_IDENTIFIER, + CPTI_BASE_DTOR_IDENTIFIER, + CPTI_DELETING_DTOR_IDENTIFIER, + CPTI_DELTA_IDENTIFIER, + CPTI_IN_CHARGE_IDENTIFIER, + CPTI_VTT_PARM_IDENTIFIER, + CPTI_NELTS_IDENTIFIER, + CPTI_THIS_IDENTIFIER, + CPTI_PFN_IDENTIFIER, + CPTI_VPTR_IDENTIFIER, + CPTI_STD_IDENTIFIER, + + CPTI_LANG_NAME_C, + CPTI_LANG_NAME_CPLUSPLUS, + CPTI_LANG_NAME_JAVA, + + CPTI_EMPTY_EXCEPT_SPEC, + CPTI_NOEXCEPT_TRUE_SPEC, + CPTI_NOEXCEPT_FALSE_SPEC, + CPTI_JCLASS, + CPTI_TERMINATE, + CPTI_CALL_UNEXPECTED, + CPTI_ATEXIT_FN_PTR_TYPE, + CPTI_ATEXIT, + CPTI_DSO_HANDLE, + CPTI_DCAST, + + CPTI_KEYED_CLASSES, + + CPTI_NULLPTR, + CPTI_NULLPTR_TYPE, + + CPTI_MAX +}; + +extern GTY(()) tree cp_global_trees[CPTI_MAX]; + +#define java_byte_type_node cp_global_trees[CPTI_JAVA_BYTE_TYPE] +#define java_short_type_node cp_global_trees[CPTI_JAVA_SHORT_TYPE] +#define java_int_type_node cp_global_trees[CPTI_JAVA_INT_TYPE] +#define java_long_type_node cp_global_trees[CPTI_JAVA_LONG_TYPE] +#define java_float_type_node cp_global_trees[CPTI_JAVA_FLOAT_TYPE] +#define java_double_type_node cp_global_trees[CPTI_JAVA_DOUBLE_TYPE] +#define java_char_type_node cp_global_trees[CPTI_JAVA_CHAR_TYPE] +#define java_boolean_type_node cp_global_trees[CPTI_JAVA_BOOLEAN_TYPE] + +#define wchar_decl_node cp_global_trees[CPTI_WCHAR_DECL] +#define vtable_entry_type cp_global_trees[CPTI_VTABLE_ENTRY_TYPE] +/* The type used to represent an offset by which to adjust the `this' + pointer in pointer-to-member types. */ +#define delta_type_node cp_global_trees[CPTI_DELTA_TYPE] +/* The type used to represent an index into the vtable. */ +#define vtable_index_type cp_global_trees[CPTI_VTABLE_INDEX_TYPE] + +#define class_type_node cp_global_trees[CPTI_CLASS_TYPE] +#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE] +#define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE] +#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE] +#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE] +#define std_node cp_global_trees[CPTI_STD] +#define abi_node cp_global_trees[CPTI_ABI] +#define const_type_info_type_node cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE] +#define type_info_ptr_type cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE] +#define abort_fndecl cp_global_trees[CPTI_ABORT_FNDECL] +#define global_delete_fndecl cp_global_trees[CPTI_GLOBAL_DELETE_FNDECL] +#define current_aggr cp_global_trees[CPTI_AGGR_TAG] +#define nullptr_node cp_global_trees[CPTI_NULLPTR] +#define nullptr_type_node cp_global_trees[CPTI_NULLPTR_TYPE] + +/* We cache these tree nodes so as to call get_identifier less + frequently. */ + +/* The name of a constructor that takes an in-charge parameter to + decide whether or not to construct virtual base classes. */ +#define ctor_identifier cp_global_trees[CPTI_CTOR_IDENTIFIER] +/* The name of a constructor that constructs virtual base classes. */ +#define complete_ctor_identifier cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER] +/* The name of a constructor that does not construct virtual base classes. */ +#define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER] +/* The name of a destructor that takes an in-charge parameter to + decide whether or not to destroy virtual base classes and whether + or not to delete the object. */ +#define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER] +/* The name of a destructor that destroys virtual base classes. */ +#define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER] +/* The name of a destructor that does not destroy virtual base + classes. */ +#define base_dtor_identifier cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER] +/* The name of a destructor that destroys virtual base classes, and + then deletes the entire object. */ +#define deleting_dtor_identifier cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER] +#define delta_identifier cp_global_trees[CPTI_DELTA_IDENTIFIER] +#define in_charge_identifier cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER] +/* The name of the parameter that contains a pointer to the VTT to use + for this subobject constructor or destructor. */ +#define vtt_parm_identifier cp_global_trees[CPTI_VTT_PARM_IDENTIFIER] +#define nelts_identifier cp_global_trees[CPTI_NELTS_IDENTIFIER] +#define this_identifier cp_global_trees[CPTI_THIS_IDENTIFIER] +#define pfn_identifier cp_global_trees[CPTI_PFN_IDENTIFIER] +#define vptr_identifier cp_global_trees[CPTI_VPTR_IDENTIFIER] +/* The name of the std namespace. */ +#define std_identifier cp_global_trees[CPTI_STD_IDENTIFIER] +#define lang_name_c cp_global_trees[CPTI_LANG_NAME_C] +#define lang_name_cplusplus cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS] +#define lang_name_java cp_global_trees[CPTI_LANG_NAME_JAVA] + +/* Exception specifier used for throw(). */ +#define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC] +#define noexcept_true_spec cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC] +#define noexcept_false_spec cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC] + +/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */ +#define jclass_node cp_global_trees[CPTI_JCLASS] + +/* The declaration for `std::terminate'. */ +#define terminate_node cp_global_trees[CPTI_TERMINATE] + +/* The declaration for "__cxa_call_unexpected". */ +#define call_unexpected_node cp_global_trees[CPTI_CALL_UNEXPECTED] + +/* The type of the function-pointer argument to "__cxa_atexit" (or + "std::atexit", if "__cxa_atexit" is not being used). */ +#define atexit_fn_ptr_type_node cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE] + +/* A pointer to `std::atexit'. */ +#define atexit_node cp_global_trees[CPTI_ATEXIT] + +/* A pointer to `__dso_handle'. */ +#define dso_handle_node cp_global_trees[CPTI_DSO_HANDLE] + +/* The declaration of the dynamic_cast runtime. */ +#define dynamic_cast_node cp_global_trees[CPTI_DCAST] + +/* The type of a destructor. */ +#define cleanup_type cp_global_trees[CPTI_CLEANUP_TYPE] + +/* The type of the vtt parameter passed to subobject constructors and + destructors. */ +#define vtt_parm_type cp_global_trees[CPTI_VTT_PARM_TYPE] + +/* A TREE_LIST of the dynamic classes whose vtables may have to be + emitted in this translation unit. */ + +#define keyed_classes cp_global_trees[CPTI_KEYED_CLASSES] + +/* Node to indicate default access. This must be distinct from the + access nodes in tree.h. */ + +#define access_default_node null_node + +/* Global state. */ + +struct GTY(()) saved_scope { + VEC(cxx_saved_binding,gc) *old_bindings; + tree old_namespace; + VEC(tree,gc) *decl_ns_list; + tree class_name; + tree class_type; + tree access_specifier; + tree function_decl; + VEC(tree,gc) *lang_base; + tree lang_name; + tree template_parms; + struct cp_binding_level *x_previous_class_level; + tree x_saved_tree; + + int x_processing_template_decl; + int x_processing_specialization; + BOOL_BITFIELD x_processing_explicit_instantiation : 1; + BOOL_BITFIELD need_pop_function_context : 1; + + int unevaluated_operand; + int inhibit_evaluation_warnings; + + struct stmt_tree_s x_stmt_tree; + + struct cp_binding_level *class_bindings; + struct cp_binding_level *bindings; + + struct saved_scope *prev; +}; + +/* The current open namespace. */ + +#define current_namespace scope_chain->old_namespace + +/* The stack for namespaces of current declarations. */ + +#define decl_namespace_list scope_chain->decl_ns_list + +/* IDENTIFIER_NODE: name of current class */ + +#define current_class_name scope_chain->class_name + +/* _TYPE: the type of the current class */ + +#define current_class_type scope_chain->class_type + +/* When parsing a class definition, the access specifier most recently + given by the user, or, if no access specifier was given, the + default value appropriate for the kind of class (i.e., struct, + class, or union). */ + +#define current_access_specifier scope_chain->access_specifier + +/* Pointer to the top of the language name stack. */ + +#define current_lang_base scope_chain->lang_base +#define current_lang_name scope_chain->lang_name + +/* When parsing a template declaration, a TREE_LIST represents the + active template parameters. Each node in the list represents one + level of template parameters. The innermost level is first in the + list. The depth of each level is stored as an INTEGER_CST in the + TREE_PURPOSE of each node. The parameters for that level are + stored in the TREE_VALUE. */ + +#define current_template_parms scope_chain->template_parms + +#define processing_template_decl scope_chain->x_processing_template_decl +#define processing_specialization scope_chain->x_processing_specialization +#define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation + +/* The cached class binding level, from the most recently exited + class, or NULL if none. */ + +#define previous_class_level scope_chain->x_previous_class_level + +/* A list of private types mentioned, for deferred access checking. */ + +extern GTY(()) struct saved_scope *scope_chain; + +struct GTY(()) cxx_int_tree_map { + unsigned int uid; + tree to; +}; + +extern unsigned int cxx_int_tree_map_hash (const void *); +extern int cxx_int_tree_map_eq (const void *, const void *); + +/* Global state pertinent to the current function. */ + +struct GTY(()) language_function { + struct c_language_function base; + + tree x_cdtor_label; + tree x_current_class_ptr; + tree x_current_class_ref; + tree x_eh_spec_block; + tree x_in_charge_parm; + tree x_vtt_parm; + tree x_return_value; + + BOOL_BITFIELD returns_value : 1; + BOOL_BITFIELD returns_null : 1; + BOOL_BITFIELD returns_abnormally : 1; + BOOL_BITFIELD in_function_try_handler : 1; + BOOL_BITFIELD in_base_initializer : 1; + + /* True if this function can throw an exception. */ + BOOL_BITFIELD can_throw : 1; + + htab_t GTY((param_is(struct named_label_entry))) x_named_labels; + struct cp_binding_level *bindings; + VEC(tree,gc) *x_local_names; + htab_t GTY((param_is (struct cxx_int_tree_map))) extern_decl_map; +}; + +/* The current C++-specific per-function global variables. */ + +#define cp_function_chain (cfun->language) + +/* In a constructor destructor, the point at which all derived class + destroying/construction has been done. I.e., just before a + constructor returns, or before any base class destroying will be done + in a destructor. */ + +#define cdtor_label cp_function_chain->x_cdtor_label + +/* When we're processing a member function, current_class_ptr is the + PARM_DECL for the `this' pointer. The current_class_ref is an + expression for `*this'. */ + +#define current_class_ptr \ + (cfun && cp_function_chain \ + ? cp_function_chain->x_current_class_ptr : NULL_TREE) +#define current_class_ref \ + ((cfun && cp_function_chain) \ + ? cp_function_chain->x_current_class_ref : NULL_TREE) + +/* The EH_SPEC_BLOCK for the exception-specifiers for the current + function, if any. */ + +#define current_eh_spec_block cp_function_chain->x_eh_spec_block + +/* The `__in_chrg' parameter for the current function. Only used for + constructors and destructors. */ + +#define current_in_charge_parm cp_function_chain->x_in_charge_parm + +/* The `__vtt_parm' parameter for the current function. Only used for + constructors and destructors. */ + +#define current_vtt_parm cp_function_chain->x_vtt_parm + +/* Set to 0 at beginning of a function definition, set to 1 if + a return statement that specifies a return value is seen. */ + +#define current_function_returns_value cp_function_chain->returns_value + +/* Set to 0 at beginning of a function definition, set to 1 if + a return statement with no argument is seen. */ + +#define current_function_returns_null cp_function_chain->returns_null + +/* Set to 0 at beginning of a function definition, set to 1 if + a call to a noreturn function is seen. */ + +#define current_function_returns_abnormally \ + cp_function_chain->returns_abnormally + +/* Nonzero if we are processing a base initializer. Zero elsewhere. */ +#define in_base_initializer cp_function_chain->in_base_initializer + +#define in_function_try_handler cp_function_chain->in_function_try_handler + +/* Expression always returned from function, or error_mark_node + otherwise, for use by the automatic named return value optimization. */ + +#define current_function_return_value \ + (cp_function_chain->x_return_value) + +/* True if NAME is the IDENTIFIER_NODE for an overloaded "operator + new" or "operator delete". */ +#define NEW_DELETE_OPNAME_P(NAME) \ + ((NAME) == ansi_opname (NEW_EXPR) \ + || (NAME) == ansi_opname (VEC_NEW_EXPR) \ + || (NAME) == ansi_opname (DELETE_EXPR) \ + || (NAME) == ansi_opname (VEC_DELETE_EXPR)) + +#define ansi_opname(CODE) \ + (operator_name_info[(int) (CODE)].identifier) +#define ansi_assopname(CODE) \ + (assignment_operator_name_info[(int) (CODE)].identifier) + +/* True if NODE is an erroneous expression. */ + +#define error_operand_p(NODE) \ + ((NODE) == error_mark_node \ + || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node)) + +/* TRUE if a tree code represents a statement. */ +extern bool statement_code_p[MAX_TREE_CODES]; + +#define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)] + +enum languages { lang_c, lang_cplusplus, lang_java }; + +/* Macros to make error reporting functions' lives easier. */ +#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE))) +#define TYPE_LINKAGE_IDENTIFIER(NODE) \ + (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE))) +#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE))) +#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE))) + +/* Nonzero if NODE has no name for linkage purposes. */ +#define TYPE_ANONYMOUS_P(NODE) \ + (TAGGED_TYPE_P (NODE) && ANON_AGGRNAME_P (TYPE_LINKAGE_IDENTIFIER (NODE))) + +/* The _DECL for this _TYPE. */ +#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) + +/* Nonzero if T is a class (or struct or union) type. Also nonzero + for template type parameters, typename types, and instantiated + template template parameters. Keep these checks in ascending code + order. */ +#define MAYBE_CLASS_TYPE_P(T) \ + (TREE_CODE (T) == TEMPLATE_TYPE_PARM \ + || TREE_CODE (T) == TYPENAME_TYPE \ + || TREE_CODE (T) == TYPEOF_TYPE \ + || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \ + || TREE_CODE (T) == DECLTYPE_TYPE \ + || CLASS_TYPE_P (T)) + +/* Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or + union type. */ +#define SET_CLASS_TYPE_P(T, VAL) \ + (TYPE_LANG_FLAG_5 (T) = (VAL)) + +/* Nonzero if T is a class type. Zero for template type parameters, + typename types, and so forth. */ +#define CLASS_TYPE_P(T) \ + (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T)) + +/* Nonzero if T is a class type but not an union. */ +#define NON_UNION_CLASS_TYPE_P(T) \ + (CLASS_TYPE_P (T) && TREE_CODE (T) != UNION_TYPE) + +/* Keep these checks in ascending code order. */ +#define RECORD_OR_UNION_CODE_P(T) \ + ((T) == RECORD_TYPE || (T) == UNION_TYPE) +#define TAGGED_TYPE_P(T) \ + (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE) +#define IS_OVERLOAD_TYPE(T) TAGGED_TYPE_P (T) + +/* True if this a "Java" type, defined in 'extern "Java"'. */ +#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE) + +/* True if this type is dependent. This predicate is only valid if + TYPE_DEPENDENT_P_VALID is true. */ +#define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE) + +/* True if dependent_type_p has been called for this type, with the + result that TYPE_DEPENDENT_P is valid. */ +#define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE) + +/* Nonzero if this type is const-qualified. */ +#define CP_TYPE_CONST_P(NODE) \ + ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0) + +/* Nonzero if this type is volatile-qualified. */ +#define CP_TYPE_VOLATILE_P(NODE) \ + ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0) + +/* Nonzero if this type is restrict-qualified. */ +#define CP_TYPE_RESTRICT_P(NODE) \ + ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0) + +/* Nonzero if this type is const-qualified, but not + volatile-qualified. Other qualifiers are ignored. This macro is + used to test whether or not it is OK to bind an rvalue to a + reference. */ +#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \ + ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \ + == TYPE_QUAL_CONST) + +#define FUNCTION_ARG_CHAIN(NODE) \ + TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))) + +/* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES + which refers to a user-written parameter. */ +#define FUNCTION_FIRST_USER_PARMTYPE(NODE) \ + skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE))) + +/* Similarly, but for DECL_ARGUMENTS. */ +#define FUNCTION_FIRST_USER_PARM(NODE) \ + skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE)) + +/* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and + ambiguity issues. */ +#define DERIVED_FROM_P(PARENT, TYPE) \ + (lookup_base ((TYPE), (PARENT), ba_any, NULL) != NULL_TREE) +/* Nonzero iff TYPE is uniquely derived from PARENT. Ignores + accessibility. */ +#define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) \ + (lookup_base ((TYPE), (PARENT), ba_unique | ba_quiet, NULL) != NULL_TREE) +/* Nonzero iff TYPE is publicly & uniquely derived from PARENT. */ +#define PUBLICLY_UNIQUELY_DERIVED_P(PARENT, TYPE) \ + (lookup_base ((TYPE), (PARENT), ba_ignore_scope | ba_check | ba_quiet, \ + NULL) != NULL_TREE) + +/* Gives the visibility specification for a class type. */ +#define CLASSTYPE_VISIBILITY(TYPE) \ + DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE)) +#define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE) \ + DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE)) + +typedef struct GTY (()) tree_pair_s { + tree purpose; + tree value; +} tree_pair_s; +typedef tree_pair_s *tree_pair_p; +DEF_VEC_O (tree_pair_s); +DEF_VEC_ALLOC_O (tree_pair_s,gc); + +/* This is a few header flags for 'struct lang_type'. Actually, + all but the first are used only for lang_type_class; they + are put in this structure to save space. */ +struct GTY(()) lang_type_header { + BOOL_BITFIELD is_lang_type_class : 1; + + BOOL_BITFIELD has_type_conversion : 1; + BOOL_BITFIELD has_copy_ctor : 1; + BOOL_BITFIELD has_default_ctor : 1; + BOOL_BITFIELD const_needs_init : 1; + BOOL_BITFIELD ref_needs_init : 1; + BOOL_BITFIELD has_const_copy_assign : 1; + + BOOL_BITFIELD spare : 1; +}; + +/* This structure provides additional information above and beyond + what is provide in the ordinary tree_type. In the past, we used it + for the types of class types, template parameters types, typename + types, and so forth. However, there can be many (tens to hundreds + of thousands) of template parameter types in a compilation, and + there's no need for this additional information in that case. + Therefore, we now use this data structure only for class types. + + In the past, it was thought that there would be relatively few + class types. However, in the presence of heavy use of templates, + many (i.e., thousands) of classes can easily be generated. + Therefore, we should endeavor to keep the size of this structure to + a minimum. */ +struct GTY(()) lang_type_class { + struct lang_type_header h; + + unsigned char align; + + unsigned has_mutable : 1; + unsigned com_interface : 1; + unsigned non_pod_class : 1; + unsigned nearly_empty_p : 1; + unsigned user_align : 1; + unsigned has_copy_assign : 1; + unsigned has_new : 1; + unsigned has_array_new : 1; + + unsigned gets_delete : 2; + unsigned interface_only : 1; + unsigned interface_unknown : 1; + unsigned contains_empty_class_p : 1; + unsigned anon_aggr : 1; + unsigned non_zero_init : 1; + unsigned empty_p : 1; + + unsigned vec_new_uses_cookie : 1; + unsigned declared_class : 1; + unsigned diamond_shaped : 1; + unsigned repeated_base : 1; + unsigned being_defined : 1; + unsigned java_interface : 1; + unsigned debug_requested : 1; + unsigned fields_readonly : 1; + + unsigned use_template : 2; + unsigned ptrmemfunc_flag : 1; + unsigned was_anonymous : 1; + unsigned lazy_default_ctor : 1; + unsigned lazy_copy_ctor : 1; + unsigned lazy_copy_assign : 1; + unsigned lazy_destructor : 1; + + unsigned has_const_copy_ctor : 1; + unsigned has_complex_copy_ctor : 1; + unsigned has_complex_copy_assign : 1; + unsigned non_aggregate : 1; + unsigned has_complex_dflt : 1; + unsigned has_list_ctor : 1; + unsigned non_std_layout : 1; + unsigned is_literal : 1; + + unsigned lazy_move_ctor : 1; + unsigned lazy_move_assign : 1; + unsigned has_complex_move_ctor : 1; + unsigned has_complex_move_assign : 1; + unsigned has_constexpr_ctor : 1; + + /* When adding a flag here, consider whether or not it ought to + apply to a template instance if it applies to the template. If + so, make sure to copy it in instantiate_class_template! */ + + /* There are some bits left to fill out a 32-bit word. Keep track + of this by updating the size of this bitfield whenever you add or + remove a flag. */ + unsigned dummy : 3; + + tree primary_base; + VEC(tree_pair_s,gc) *vcall_indices; + tree vtables; + tree typeinfo_var; + VEC(tree,gc) *vbases; + binding_table nested_udts; + tree as_base; + VEC(tree,gc) *pure_virtuals; + tree friend_classes; + VEC(tree,gc) * GTY((reorder ("resort_type_method_vec"))) methods; + tree key_method; + tree decl_list; + tree template_info; + tree befriending_classes; + /* In a RECORD_TYPE, information specific to Objective-C++, such + as a list of adopted protocols or a pointer to a corresponding + @interface. See objc/objc-act.h for details. */ + tree objc_info; + /* sorted_fields is sorted based on a pointer, so we need to be able + to resort it if pointers get rearranged. */ + struct sorted_fields_type * GTY ((reorder ("resort_sorted_fields"))) + sorted_fields; + /* FIXME reuse another field? */ + tree lambda_expr; +}; + +struct GTY(()) lang_type_ptrmem { + struct lang_type_header h; + tree record; +}; + +struct GTY((variable_size)) lang_type { + union lang_type_u + { + struct lang_type_header GTY((skip (""))) h; + struct lang_type_class GTY((tag ("1"))) c; + struct lang_type_ptrmem GTY((tag ("0"))) ptrmem; + } GTY((desc ("%h.h.is_lang_type_class"))) u; +}; + +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) + +#define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \ +({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ + if (! lt->u.h.is_lang_type_class) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.c; }) + +#define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \ +({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \ + if (lt->u.h.is_lang_type_class) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.ptrmem; }) + +#else + +#define LANG_TYPE_CLASS_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.c) +#define LANG_TYPE_PTRMEM_CHECK(NODE) (&TYPE_LANG_SPECIFIC (NODE)->u.ptrmem) + +#endif /* ENABLE_TREE_CHECKING */ + +/* Nonzero for _CLASSTYPE means that operator delete is defined. */ +#define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete) +#define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1) + +/* Nonzero if `new NODE[x]' should cause the allocation of extra + storage to indicate how many array elements are in use. */ +#define TYPE_VEC_NEW_USES_COOKIE(NODE) \ + (CLASS_TYPE_P (NODE) \ + && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie) + +/* Nonzero means that this _CLASSTYPE node defines ways of converting + itself to other types. */ +#define TYPE_HAS_CONVERSION(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.has_type_conversion) + +/* Nonzero means that NODE (a class type) has a default constructor -- + but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor) + +/* Nonzero means that NODE (a class type) has a copy constructor -- + but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_COPY_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor) + +/* Nonzero means that NODE (a class type) has a move constructor -- + but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor) + +/* Nonzero means that NODE (a class type) has an assignment operator + -- but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign) + +/* Nonzero means that NODE (a class type) has an assignment operator + -- but that it has not yet been declared. */ +#define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign) + +/* Nonzero means that NODE (a class type) has a destructor -- but that + it has not yet been declared. */ +#define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor) + +/* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */ +#define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign) + +/* True iff the class type NODE has an "operator =" whose parameter + has a parameter of type "const X&". */ +#define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.has_const_copy_assign) + +/* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */ +#define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->h.has_copy_ctor) +#define TYPE_HAS_CONST_COPY_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor) + +/* Nonzero if this class has an X(initializer_list<T>) constructor. */ +#define TYPE_HAS_LIST_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor) + +/* Nonzero if this class has a constexpr constructor other than a copy/move + constructor. Note that a class can have constexpr constructors for + static initialization even if it isn't a literal class. */ +#define TYPE_HAS_CONSTEXPR_CTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor) + +/* Nonzero if this class defines an overloaded operator new. (An + operator new [] doesn't count.) */ +#define TYPE_HAS_NEW_OPERATOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_new) + +/* Nonzero if this class defines an overloaded operator new[]. */ +#define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new) + +/* Nonzero means that this type is being defined. I.e., the left brace + starting the definition of this type has been seen. */ +#define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined) + +/* Nonzero means that this type is either complete or being defined, so we + can do lookup in it. */ +#define COMPLETE_OR_OPEN_TYPE_P(NODE) \ + (COMPLETE_TYPE_P (NODE) || (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE))) + +/* Mark bits for repeated base checks. */ +#define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE)) + +/* Nonzero if the class NODE has multiple paths to the same (virtual) + base object. */ +#define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \ + (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped) + +/* Nonzero if the class NODE has multiple instances of the same base + type. */ +#define CLASSTYPE_REPEATED_BASE_P(NODE) \ + (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base) + +/* The member function with which the vtable will be emitted: + the first noninline non-pure-virtual member function. NULL_TREE + if there is no key function or if this is a class template */ +#define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method) + +/* Vector member functions defined in this class. Each element is + either a FUNCTION_DECL, a TEMPLATE_DECL, or an OVERLOAD. All + functions with the same name end up in the same slot. The first + two elements are for constructors, and destructors, respectively. + All template conversion operators to innermost template dependent + types are overloaded on the next slot, if they exist. Note, the + names for these functions will not all be the same. The + non-template conversion operators & templated conversions to + non-innermost template types are next, followed by ordinary member + functions. There may be empty entries at the end of the vector. + The conversion operators are unsorted. The ordinary member + functions are sorted, once the class is complete. */ +#define CLASSTYPE_METHOD_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->methods) + +/* For class templates, this is a TREE_LIST of all member data, + functions, types, and friends in the order of declaration. + The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend, + and the RECORD_TYPE for the class template otherwise. */ +#define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list) + +/* The slot in the CLASSTYPE_METHOD_VEC where constructors go. */ +#define CLASSTYPE_CONSTRUCTOR_SLOT 0 + +/* The slot in the CLASSTYPE_METHOD_VEC where destructors go. */ +#define CLASSTYPE_DESTRUCTOR_SLOT 1 + +/* The first slot in the CLASSTYPE_METHOD_VEC where conversion + operators can appear. */ +#define CLASSTYPE_FIRST_CONVERSION_SLOT 2 + +/* A FUNCTION_DECL or OVERLOAD for the constructors for NODE. These + are the constructors that take an in-charge parameter. */ +#define CLASSTYPE_CONSTRUCTORS(NODE) \ + (VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT)) + +/* A FUNCTION_DECL for the destructor for NODE. These are the + destructors that take an in-charge parameter. If + CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL + until the destructor is created with lazily_declare_fn. */ +#define CLASSTYPE_DESTRUCTORS(NODE) \ + (CLASSTYPE_METHOD_VEC (NODE) \ + ? VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT) \ + : NULL_TREE) + +/* A dictionary of the nested user-defined-types (class-types, or enums) + found within this class. This table includes nested member class + templates. */ +#define CLASSTYPE_NESTED_UTDS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts) + +/* Nonzero if NODE has a primary base class, i.e., a base class with + which it shares the virtual function table pointer. */ +#define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \ + (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE) + +/* If non-NULL, this is the binfo for the primary base class, i.e., + the base class which contains the virtual function table pointer + for this class. */ +#define CLASSTYPE_PRIMARY_BINFO(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->primary_base) + +/* A vector of BINFOs for the direct and indirect virtual base classes + that this type uses in a post-order depth-first left-to-right + order. (In other words, these bases appear in the order that they + should be initialized.) */ +#define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases) + +/* The type corresponding to NODE when NODE is used as a base class, + i.e., NODE without virtual base classes. */ + +#define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base) + +/* True iff NODE is the CLASSTYPE_AS_BASE version of some type. */ + +#define IS_FAKE_BASE_TYPE(NODE) \ + (TREE_CODE (NODE) == RECORD_TYPE \ + && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \ + && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE)) + +/* These are the size and alignment of the type without its virtual + base classes, for when we use this type as a base itself. */ +#define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE)) +#define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE)) +#define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE)) +#define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE)) + +/* The alignment of NODE, without its virtual bases, in bytes. */ +#define CLASSTYPE_ALIGN_UNIT(NODE) \ + (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT) + +/* True if this a Java interface type, declared with + '__attribute__ ((java_interface))'. */ +#define TYPE_JAVA_INTERFACE(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->java_interface) + +/* A VEC(tree) of virtual functions which cannot be inherited by + derived classes. When deriving from this type, the derived + class must provide its own definition for each of these functions. */ +#define CLASSTYPE_PURE_VIRTUALS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals) + +/* Nonzero means that this type has an X() constructor. */ +#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.has_default_ctor) + +/* Nonzero means that this type contains a mutable member. */ +#define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable) +#define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE)) + +/* Nonzero means that this class type is not POD for the purpose of layout + (as defined in the ABI). This is different from the language's POD. */ +#define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class) + +/* Nonzero means that this class type is a non-standard-layout class. */ +#define CLASSTYPE_NON_STD_LAYOUT(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout) + +/* Nonzero means that this class contains pod types whose default + initialization is not a zero initialization (namely, pointers to + data members). */ +#define CLASSTYPE_NON_ZERO_INIT_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init) + +/* Nonzero if this class is "empty" in the sense of the C++ ABI. */ +#define CLASSTYPE_EMPTY_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->empty_p) + +/* Nonzero if this class is "nearly empty", i.e., contains only a + virtual function table pointer. */ +#define CLASSTYPE_NEARLY_EMPTY_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p) + +/* Nonzero if this class contains an empty subobject. */ +#define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p) + +/* A list of class types of which this type is a friend. The + TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the + case of a template friend. */ +#define CLASSTYPE_FRIEND_CLASSES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes) + +/* A list of the classes which grant friendship to this class. */ +#define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes) + +/* The associated LAMBDA_EXPR that made this class. */ +#define CLASSTYPE_LAMBDA_EXPR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr) +/* The extra mangling scope for this closure type. */ +#define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \ + (LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE))) + +/* Say whether this node was declared as a "class" or a "struct". */ +#define CLASSTYPE_DECLARED_CLASS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->declared_class) + +/* Nonzero if this class has const members + which have no specified initialization. */ +#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) \ + (TYPE_LANG_SPECIFIC (NODE) \ + ? LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init : 0) +#define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.const_needs_init = (VALUE)) + +/* Nonzero if this class has ref members + which have no specified initialization. */ +#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) \ + (TYPE_LANG_SPECIFIC (NODE) \ + ? LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init : 0) +#define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->h.ref_needs_init = (VALUE)) + +/* Nonzero if this class is included from a header file which employs + `#pragma interface', and it is not included in its implementation file. */ +#define CLASSTYPE_INTERFACE_ONLY(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_only) + +/* True if we have already determined whether or not vtables, VTTs, + typeinfo, and other similar per-class data should be emitted in + this translation unit. This flag does not indicate whether or not + these items should be emitted; it only indicates that we know one + way or the other. */ +#define CLASSTYPE_INTERFACE_KNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0) +/* The opposite of CLASSTYPE_INTERFACE_KNOWN. */ +#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown) + +#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X)) +#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1) +#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0) + +/* Nonzero if a _DECL node requires us to output debug info for this class. */ +#define CLASSTYPE_DEBUG_REQUESTED(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested) + +/* Additional macros for inheritance information. */ + +/* Nonzero means that this class is on a path leading to a new vtable. */ +#define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE) + +/* Nonzero means B (a BINFO) has its own vtable. Any copies will not + have this flag set. */ +#define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B)) + +/* Compare a BINFO_TYPE with another type for equality. For a binfo, + this is functionally equivalent to using same_type_p, but + measurably faster. At least one of the arguments must be a + BINFO_TYPE. The other can be a BINFO_TYPE or a regular type. If + BINFO_TYPE(T) ever stops being the main variant of the class the + binfo is for, this macro must change. */ +#define SAME_BINFO_TYPE_P(A, B) ((A) == (B)) + +/* Any subobject that needs a new vtable must have a vptr and must not + be a non-virtual primary base (since it would then use the vtable from a + derived class and never become non-primary.) */ +#define SET_BINFO_NEW_VTABLE_MARKED(B) \ + (BINFO_NEW_VTABLE_MARKED (B) = 1, \ + gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)), \ + gcc_assert (TYPE_VFIELD (BINFO_TYPE (B)))) + +/* Nonzero if this binfo is for a dependent base - one that should not + be searched. */ +#define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE) + +/* Nonzero if this binfo has lost its primary base binfo (because that + is a nearly-empty virtual base that has been taken by some other + base in the complete hierarchy. */ +#define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE) + +/* Nonzero if this BINFO is a primary base class. */ +#define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE) + +/* Used by various search routines. */ +#define IDENTIFIER_MARKED(NODE) TREE_LANG_FLAG_0 (NODE) + +/* A VEC(tree_pair_s) of the vcall indices associated with the class + NODE. The PURPOSE of each element is a FUNCTION_DECL for a virtual + function. The VALUE is the index into the virtual table where the + vcall offset for that function is stored, when NODE is a virtual + base. */ +#define CLASSTYPE_VCALL_INDICES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices) + +/* The various vtables for the class NODE. The primary vtable will be + first, followed by the construction vtables and VTT, if any. */ +#define CLASSTYPE_VTABLES(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->vtables) + +/* The std::type_info variable representing this class, or NULL if no + such variable has been created. This field is only set for the + TYPE_MAIN_VARIANT of the class. */ +#define CLASSTYPE_TYPEINFO_VAR(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) + +/* Accessor macros for the BINFO_VIRTUALS list. */ + +/* The number of bytes by which to adjust the `this' pointer when + calling this virtual function. Subtract this value from the this + pointer. Always non-NULL, might be constant zero though. */ +#define BV_DELTA(NODE) (TREE_PURPOSE (NODE)) + +/* If non-NULL, the vtable index at which to find the vcall offset + when calling this virtual function. Add the value at that vtable + index to the this pointer. */ +#define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE)) + +/* The function to call. */ +#define BV_FN(NODE) (TREE_VALUE (NODE)) + +/* Whether or not this entry is for a lost primary virtual base. */ +#define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE)) + +/* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that + this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE + will be NULL_TREE to indicate a throw specification of `()', or + no exceptions allowed. For a noexcept specification, TREE_VALUE + is NULL_TREE and TREE_PURPOSE is the constant-expression. */ +#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_LANG_SLOT_1 (NODE) + +/* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()' + or noexcept(true). */ +#define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE)) + +/* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the + case for things declared noexcept(true) and, with -fnothrow-opt, for + throw() functions. */ +#define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE) + +/* The binding level associated with the namespace. */ +#define NAMESPACE_LEVEL(NODE) \ + (LANG_DECL_NS_CHECK (NODE)->level) + +/* Flags shared by all forms of DECL_LANG_SPECIFIC. + + Some of the flags live here only to make lang_decl_min/fn smaller. Do + not make this struct larger than 32 bits; instead, make sel smaller. */ + +struct GTY(()) lang_decl_base { + unsigned selector : 16; /* Larger than necessary for faster access. */ + ENUM_BITFIELD(languages) language : 4; + unsigned use_template : 2; + unsigned not_really_extern : 1; /* var or fn */ + unsigned initialized_in_class : 1; /* var or fn */ + unsigned repo_available_p : 1; /* var or fn */ + unsigned threadprivate_or_deleted_p : 1; /* var or fn */ + unsigned anticipated_p : 1; /* fn or type */ + unsigned friend_attr : 1; /* fn or type */ + unsigned template_conv_p : 1; /* var or template */ + unsigned odr_used : 1; /* var or fn */ + unsigned u2sel : 1; + /* 1 spare bit */ +}; + +/* True for DECL codes which have template info and access. */ +#define LANG_DECL_HAS_MIN(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + || TREE_CODE (NODE) == FIELD_DECL \ + || TREE_CODE (NODE) == VAR_DECL \ + || TREE_CODE (NODE) == CONST_DECL \ + || TREE_CODE (NODE) == TYPE_DECL \ + || TREE_CODE (NODE) == TEMPLATE_DECL \ + || TREE_CODE (NODE) == USING_DECL) + +/* DECL_LANG_SPECIFIC for the above codes. */ + +struct GTY(()) lang_decl_min { + struct lang_decl_base base; + + /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is + THUNK_ALIAS. + In a FUNCTION_DECL for which DECL_THUNK_P does not hold, + VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is + DECL_TEMPLATE_INFO. */ + tree template_info; + + union lang_decl_u2 { + /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is + THUNK_VIRTUAL_OFFSET. + Otherwise this is DECL_ACCESS. */ + tree GTY ((tag ("0"))) access; + + /* For VAR_DECL in function, this is DECL_DISCRIMINATOR. */ + int GTY ((tag ("1"))) discriminator; + } GTY ((desc ("%0.u.base.u2sel"))) u2; +}; + +/* Additional DECL_LANG_SPECIFIC information for functions. */ + +struct GTY(()) lang_decl_fn { + struct lang_decl_min min; + + /* In an overloaded operator, this is the value of + DECL_OVERLOADED_OPERATOR_P. */ + ENUM_BITFIELD (tree_code) operator_code : 16; + + unsigned global_ctor_p : 1; + unsigned global_dtor_p : 1; + unsigned constructor_attr : 1; + unsigned destructor_attr : 1; + unsigned assignment_operator_p : 1; + unsigned static_function : 1; + unsigned pure_virtual : 1; + unsigned defaulted_p : 1; + + unsigned has_in_charge_parm_p : 1; + unsigned has_vtt_parm_p : 1; + unsigned pending_inline_p : 1; + unsigned nonconverting : 1; + unsigned thunk_p : 1; + unsigned this_thunk_p : 1; + unsigned hidden_friend_p : 1; + /* 1 spare bit. */ + + /* For a non-thunk function decl, this is a tree list of + friendly classes. For a thunk function decl, it is the + thunked to function decl. */ + tree befriending_classes; + + /* For a non-virtual FUNCTION_DECL, this is + DECL_FRIEND_CONTEXT. For a virtual FUNCTION_DECL for which + DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both + this pointer and result pointer adjusting thunks are + chained here. This pointer thunks to return pointer thunks + will be chained on the return pointer thunk. */ + tree context; + + union lang_decl_u5 + { + /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is + DECL_CLONED_FUNCTION. */ + tree GTY ((tag ("0"))) cloned_function; + + /* In a FUNCTION_DECL for which THUNK_P holds this is the + THUNK_FIXED_OFFSET. */ + HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset; + } GTY ((desc ("%1.thunk_p"))) u5; + + union lang_decl_u3 + { + struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info; + struct language_function * GTY ((tag ("0"))) + saved_language_function; + } GTY ((desc ("%1.pending_inline_p"))) u; + +}; + +/* DECL_LANG_SPECIFIC for namespaces. */ + +struct GTY(()) lang_decl_ns { + struct lang_decl_base base; + struct cp_binding_level *level; +}; + +/* DECL_LANG_SPECIFIC for parameters. */ + +struct GTY(()) lang_decl_parm { + struct lang_decl_base base; + int level; + int index; +}; + +/* DECL_LANG_SPECIFIC for all types. It would be nice to just make this a + union rather than a struct containing a union as its only field, but + tree.h declares it as a struct. */ + +struct GTY((variable_size)) lang_decl { + union GTY((desc ("%h.base.selector"))) lang_decl_u { + struct lang_decl_base GTY ((default)) base; + struct lang_decl_min GTY((tag ("0"))) min; + struct lang_decl_fn GTY ((tag ("1"))) fn; + struct lang_decl_ns GTY((tag ("2"))) ns; + struct lang_decl_parm GTY((tag ("3"))) parm; + } u; +}; + +/* Looks through a template (if present) to find what it declares. */ +#define STRIP_TEMPLATE(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE) + +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) + +#define LANG_DECL_MIN_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (!LANG_DECL_HAS_MIN (NODE)) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.min; }) + +/* We want to be able to check DECL_CONSTRUCTOR_P and such on a function + template, not just on a FUNCTION_DECL. So when looking for things in + lang_decl_fn, look down through a TEMPLATE_DECL into its result. */ +#define LANG_DECL_FN_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE)); \ + if (!DECL_DECLARES_FUNCTION_P (NODE) || lt->u.base.selector != 1) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.fn; }) + +#define LANG_DECL_NS_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (TREE_CODE (NODE) != NAMESPACE_DECL || lt->u.base.selector != 2) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.ns; }) + +#define LANG_DECL_PARM_CHECK(NODE) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (TREE_CODE (NODE) != PARM_DECL) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.parm; }) + +#define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \ +({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \ + if (!LANG_DECL_HAS_MIN (NODE) || lt->u.base.u2sel != TF) \ + lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \ + <->u.min.u2; }) + +#else + +#define LANG_DECL_MIN_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (NODE)->u.min) + +#define LANG_DECL_FN_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn) + +#define LANG_DECL_NS_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (NODE)->u.ns) + +#define LANG_DECL_PARM_CHECK(NODE) \ + (&DECL_LANG_SPECIFIC (NODE)->u.parm) + +#define LANG_DECL_U2_CHECK(NODE, TF) \ + (&DECL_LANG_SPECIFIC (NODE)->u.min.u2) + +#endif /* ENABLE_TREE_CHECKING */ + +/* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the + declaration. Some entities (like a member function in a local + class, or a local variable) do not have linkage at all, and this + macro should not be used in those cases. + + Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was + created by language-independent code, and has C linkage. Most + VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but + we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage. */ +#define DECL_LANGUAGE(NODE) \ + (DECL_LANG_SPECIFIC (NODE) \ + ? DECL_LANG_SPECIFIC (NODE)->u.base.language \ + : (TREE_CODE (NODE) == FUNCTION_DECL \ + ? lang_c : lang_cplusplus)) + +/* Set the language linkage for NODE to LANGUAGE. */ +#define SET_DECL_LANGUAGE(NODE, LANGUAGE) \ + (DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE)) + +/* For FUNCTION_DECLs: nonzero means that this function is a constructor. */ +#define DECL_CONSTRUCTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->constructor_attr) + +/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete + object. */ +#define DECL_COMPLETE_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == complete_ctor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base + object. */ +#define DECL_BASE_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == base_ctor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the + specialized in-charge constructor or the specialized not-in-charge + constructor. */ +#define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE) \ + (DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \ + && !DECL_CLONED_FUNCTION_P (NODE)) + +/* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor. */ +#define DECL_COPY_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0) + +/* Nonzero if NODE (a FUNCTION_DECL) is a move constructor. */ +#define DECL_MOVE_CONSTRUCTOR_P(NODE) \ + (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE)) + +/* Nonzero if NODE is a destructor. */ +#define DECL_DESTRUCTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->destructor_attr) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the + specialized in-charge constructor, in-charge deleting constructor, + or the base destructor. */ +#define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE) \ + (DECL_DECLARES_FUNCTION_P (NODE) && DECL_DESTRUCTOR_P (NODE) \ + && !DECL_CLONED_FUNCTION_P (NODE)) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete + object. */ +#define DECL_COMPLETE_DESTRUCTOR_P(NODE) \ + (DECL_DESTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == complete_dtor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base + object. */ +#define DECL_BASE_DESTRUCTOR_P(NODE) \ + (DECL_DESTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == base_dtor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete + object that deletes the object after it has been destroyed. */ +#define DECL_DELETING_DESTRUCTOR_P(NODE) \ + (DECL_DESTRUCTOR_P (NODE) \ + && DECL_NAME (NODE) == deleting_dtor_identifier) + +/* Nonzero if NODE (a FUNCTION_DECL) is a cloned constructor or + destructor. */ +#define DECL_CLONED_FUNCTION_P(NODE) (!!decl_cloned_function_p (NODE, true)) + +/* If DECL_CLONED_FUNCTION_P holds, this is the function that was + cloned. */ +#define DECL_CLONED_FUNCTION(NODE) (*decl_cloned_function_p (NODE, false)) + +/* Perform an action for each clone of FN, if FN is a function with + clones. This macro should be used like: + + FOR_EACH_CLONE (clone, fn) + { ... } + + */ +#define FOR_EACH_CLONE(CLONE, FN) \ + if (TREE_CODE (FN) == FUNCTION_DECL \ + && (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (FN) \ + || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (FN))) \ + for (CLONE = DECL_CHAIN (FN); \ + CLONE && DECL_CLONED_FUNCTION_P (CLONE); \ + CLONE = DECL_CHAIN (CLONE)) + +/* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS. */ +#define DECL_DISCRIMINATOR_P(NODE) \ + (TREE_CODE (NODE) == VAR_DECL \ + && DECL_FUNCTION_SCOPE_P (NODE)) + +/* Discriminator for name mangling. */ +#define DECL_DISCRIMINATOR(NODE) (LANG_DECL_U2_CHECK (NODE, 1)->discriminator) + +/* True iff DECL_DISCRIMINATOR is set for a DECL_DISCRIMINATOR_P decl. */ +#define DECL_DISCRIMINATOR_SET_P(NODE) \ + (DECL_LANG_SPECIFIC (NODE) && DECL_LANG_SPECIFIC (NODE)->u.base.u2sel == 1) + +/* The index of a user-declared parameter in its function, starting at 1. + All artificial parameters will have index 0. */ +#define DECL_PARM_INDEX(NODE) \ + (LANG_DECL_PARM_CHECK (NODE)->index) + +/* The level of a user-declared parameter in its function, starting at 1. + A parameter of the function will have level 1; a parameter of the first + nested function declarator (i.e. t in void f (void (*p)(T t))) will have + level 2. */ +#define DECL_PARM_LEVEL(NODE) \ + (LANG_DECL_PARM_CHECK (NODE)->level) + +/* Nonzero if the VTT parm has been added to NODE. */ +#define DECL_HAS_VTT_PARM_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p) + +/* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is + required. */ +#define DECL_NEEDS_VTT_PARM_P(NODE) \ + (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE)) \ + && (DECL_BASE_CONSTRUCTOR_P (NODE) \ + || DECL_BASE_DESTRUCTOR_P (NODE))) + +/* Nonzero if NODE is a user-defined conversion operator. */ +#define DECL_CONV_FN_P(NODE) \ + (DECL_NAME (NODE) && IDENTIFIER_TYPENAME_P (DECL_NAME (NODE))) + +/* If FN is a conversion operator, the type to which it converts. + Otherwise, NULL_TREE. */ +#define DECL_CONV_FN_TYPE(FN) \ + (DECL_CONV_FN_P (FN) ? TREE_TYPE (DECL_NAME (FN)) : NULL_TREE) + +/* Nonzero if NODE, which is a TEMPLATE_DECL, is a template + conversion operator to a type dependent on the innermost template + args. */ +#define DECL_TEMPLATE_CONV_FN_P(NODE) \ + (DECL_LANG_SPECIFIC (TEMPLATE_DECL_CHECK (NODE))->u.base.template_conv_p) + +/* Nonzero if NODE, a static data member, was declared in its class as an + array of unknown bound. */ +#define VAR_HAD_UNKNOWN_BOUND(NODE) \ + (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) \ + ? DECL_LANG_SPECIFIC (NODE)->u.base.template_conv_p \ + : false) +#define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \ + (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.template_conv_p = true) + +/* Set the overloaded operator code for NODE to CODE. */ +#define SET_OVERLOADED_OPERATOR_CODE(NODE, CODE) \ + (LANG_DECL_FN_CHECK (NODE)->operator_code = (CODE)) + +/* If NODE is an overloaded operator, then this returns the TREE_CODE + associated with the overloaded operator. + DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine + whether or not NODE is an assignment operator. If NODE is not an + overloaded operator, ERROR_MARK is returned. Since the numerical + value of ERROR_MARK is zero, this macro can be used as a predicate + to test whether or not NODE is an overloaded operator. */ +#define DECL_OVERLOADED_OPERATOR_P(NODE) \ + (IDENTIFIER_OPNAME_P (DECL_NAME (NODE)) \ + ? LANG_DECL_FN_CHECK (NODE)->operator_code : ERROR_MARK) + +/* Nonzero if NODE is an assignment operator (including += and such). */ +#define DECL_ASSIGNMENT_OPERATOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->assignment_operator_p) + +/* For FUNCTION_DECLs: nonzero means that this function is a + constructor or a destructor with an extra in-charge parameter to + control whether or not virtual bases are constructed. */ +#define DECL_HAS_IN_CHARGE_PARM_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p) + +/* Nonzero if DECL is a declaration of __builtin_constant_p. */ +#define DECL_IS_BUILTIN_CONSTANT_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \ + && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P) + +/* Nonzero for _DECL means that this decl appears in (or will appear + in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for + detecting circularity in case members are multiply defined. In the + case of a VAR_DECL, it is also used to determine how program storage + should be allocated. */ +#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE)) + +/* Nonzero for a VAR_DECL means that the variable's initialization (if + any) has been processed. (In general, DECL_INITIALIZED_P is + !DECL_EXTERN, but static data members may be initialized even if + not defined.) */ +#define DECL_INITIALIZED_P(NODE) \ + (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE))) + +/* Nonzero for a VAR_DECL iff an explicit initializer was provided. */ +#define DECL_NONTRIVIALLY_INITIALIZED_P(NODE) \ + (TREE_LANG_FLAG_3 (VAR_DECL_CHECK (NODE))) + +/* Nonzero for a VAR_DECL that was initialized with a + constant-expression. */ +#define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \ + (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE))) + +/* Nonzero if the DECL was initialized in the class definition itself, + rather than outside the class. This is used for both static member + VAR_DECLS, and FUNCTION_DECLS that are defined in the class. */ +#define DECL_INITIALIZED_IN_CLASS_P(DECL) \ + (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \ + ->u.base.initialized_in_class) + +/* Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr]. + Only available for decls with DECL_LANG_SPECIFIC. */ +#define DECL_ODR_USED(DECL) \ + (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \ + ->u.base.odr_used) + +/* Nonzero for DECL means that this decl is just a friend declaration, + and should not be added to the list of members for this class. */ +#define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.friend_attr) + +/* A TREE_LIST of the types which have befriended this FUNCTION_DECL. */ +#define DECL_BEFRIENDING_CLASSES(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->befriending_classes) + +/* Nonzero for FUNCTION_DECL means that this decl is a static + member function. */ +#define DECL_STATIC_FUNCTION_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->static_function) + +/* Nonzero for FUNCTION_DECL means that this decl is a non-static + member function. */ +#define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \ + (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE) + +/* Nonzero for FUNCTION_DECL means that this decl is a member function + (static or non-static). */ +#define DECL_FUNCTION_MEMBER_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE)) + +/* Nonzero for FUNCTION_DECL means that this member function + has `this' as const X *const. */ +#define DECL_CONST_MEMFUNC_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ + && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE \ + (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) + +/* Nonzero for FUNCTION_DECL means that this member function + has `this' as volatile X *const. */ +#define DECL_VOLATILE_MEMFUNC_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ + && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE \ + (TYPE_ARG_TYPES (TREE_TYPE (NODE)))))) + +/* Nonzero for a DECL means that this member is a non-static member. */ +#define DECL_NONSTATIC_MEMBER_P(NODE) \ + (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) \ + || TREE_CODE (NODE) == FIELD_DECL) + +/* Nonzero for _DECL means that this member object type + is mutable. */ +#define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (NODE)) + +/* Nonzero for _DECL means that this constructor or conversion function is + non-converting. */ +#define DECL_NONCONVERTING_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->nonconverting) + +/* Nonzero for FUNCTION_DECL means that this member function is a pure + virtual function. */ +#define DECL_PURE_VIRTUAL_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->pure_virtual) + +/* True (in a FUNCTION_DECL) if NODE is a virtual function that is an + invalid overrider for a function from a base class. Once we have + complained about an invalid overrider we avoid complaining about it + again. */ +#define DECL_INVALID_OVERRIDER_P(NODE) \ + (DECL_LANG_FLAG_4 (NODE)) + +/* The thunks associated with NODE, a FUNCTION_DECL. */ +#define DECL_THUNKS(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->context) + +/* Nonzero if NODE is a thunk, rather than an ordinary function. */ +#define DECL_THUNK_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + && DECL_LANG_SPECIFIC (NODE) \ + && LANG_DECL_FN_CHECK (NODE)->thunk_p) + +/* Set DECL_THUNK_P for node. */ +#define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING) \ + (LANG_DECL_FN_CHECK (NODE)->thunk_p = 1, \ + LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING)) + +/* Nonzero if NODE is a this pointer adjusting thunk. */ +#define DECL_THIS_THUNK_P(NODE) \ + (DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p) + +/* Nonzero if NODE is a result pointer adjusting thunk. */ +#define DECL_RESULT_THUNK_P(NODE) \ + (DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p) + +/* Nonzero if NODE is a FUNCTION_DECL, but not a thunk. */ +#define DECL_NON_THUNK_FUNCTION_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE)) + +/* Nonzero if NODE is `extern "C"'. */ +#define DECL_EXTERN_C_P(NODE) \ + (DECL_LANGUAGE (NODE) == lang_c) + +/* Nonzero if NODE is an `extern "C"' function. */ +#define DECL_EXTERN_C_FUNCTION_P(NODE) \ + (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE)) + +/* True iff DECL is an entity with vague linkage whose definition is + available in this translation unit. */ +#define DECL_REPO_AVAILABLE_P(NODE) \ + (DECL_LANG_SPECIFIC (NODE)->u.base.repo_available_p) + +/* True if DECL is declared 'constexpr'. */ +#define DECL_DECLARED_CONSTEXPR_P(DECL) \ + DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL))) + +/* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a + template function. */ +#define DECL_PRETTY_FUNCTION_P(NODE) \ + (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))) + +/* The _TYPE context in which this _DECL appears. This field holds the + class where a virtual function instance is actually defined. */ +#define DECL_CLASS_CONTEXT(NODE) \ + (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE) + +/* For a non-member friend function, the class (if any) in which this + friend was defined. For example, given: + + struct S { friend void f (); }; + + the DECL_FRIEND_CONTEXT for `f' will be `S'. */ +#define DECL_FRIEND_CONTEXT(NODE) \ + ((DECL_DECLARES_FUNCTION_P (NODE) \ + && DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE)) \ + ? LANG_DECL_FN_CHECK (NODE)->context \ + : NULL_TREE) + +/* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT. */ +#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \ + (LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT)) + +#define CP_DECL_CONTEXT(NODE) \ + (!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace) +#define CP_TYPE_CONTEXT(NODE) \ + (!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace) +#define FROB_CONTEXT(NODE) \ + ((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE)) + +/* 1 iff NODE has namespace scope, including the global namespace. */ +#define DECL_NAMESPACE_SCOPE_P(NODE) \ + (!DECL_TEMPLATE_PARM_P (NODE) \ + && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL) + +#define TYPE_NAMESPACE_SCOPE_P(NODE) \ + (TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL) + +#define NAMESPACE_SCOPE_P(NODE) \ + ((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \ + || (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE))) + +/* 1 iff NODE is a class member. */ +#define DECL_CLASS_SCOPE_P(NODE) \ + (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE))) + +#define TYPE_CLASS_SCOPE_P(NODE) \ + (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE))) + +/* 1 iff NODE is function-local. */ +#define DECL_FUNCTION_SCOPE_P(NODE) \ + (DECL_CONTEXT (NODE) \ + && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL) + +#define TYPE_FUNCTION_SCOPE_P(NODE) \ + (TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL) + +/* 1 iff VAR_DECL node NODE is a type-info decl. This flag is set for + both the primary typeinfo object and the associated NTBS name. */ +#define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)) + +/* 1 iff VAR_DECL node NODE is virtual table or VTT. */ +#define DECL_VTABLE_OR_VTT_P(NODE) TREE_LANG_FLAG_5 (VAR_DECL_CHECK (NODE)) + +/* Returns 1 iff VAR_DECL is a construction virtual table. + DECL_VTABLE_OR_VTT_P will be true in this case and must be checked + before using this macro. */ +#define DECL_CONSTRUCTION_VTABLE_P(NODE) \ + TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE)) + +/* 1 iff NODE is function-local, but for types. */ +#define LOCAL_CLASS_P(NODE) \ + (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE) + +/* For a NAMESPACE_DECL: the list of using namespace directives + The PURPOSE is the used namespace, the value is the namespace + that is the common ancestor. */ +#define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE)) + +/* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users + of a namespace, to record the transitive closure of using namespace. */ +#define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE)) + +/* In a NAMESPACE_DECL, the list of namespaces which have associated + themselves with this one. */ +#define DECL_NAMESPACE_ASSOCIATIONS(NODE) \ + (NAMESPACE_DECL_CHECK (NODE)->decl_non_common.saved_tree) + +/* In a NAMESPACE_DECL, points to the original namespace if this is + a namespace alias. */ +#define DECL_NAMESPACE_ALIAS(NODE) \ + DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE)) +#define ORIGINAL_NAMESPACE(NODE) \ + (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE)) + +/* Nonzero if NODE is the std namespace. */ +#define DECL_NAMESPACE_STD_P(NODE) \ + (TREE_CODE (NODE) == NAMESPACE_DECL \ + && CP_DECL_CONTEXT (NODE) == global_namespace \ + && DECL_NAME (NODE) == std_identifier) + +/* In a TREE_LIST concatenating using directives, indicate indirect + directives */ +#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0) + +/* In a TREE_LIST in an attribute list, indicates that the attribute + must be applied at instantiation time. */ +#define ATTR_IS_DEPENDENT(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0) + +extern tree decl_shadowed_for_var_lookup (tree); +extern void decl_shadowed_for_var_insert (tree, tree); + +/* Non zero if this is a using decl for a dependent scope. */ +#define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE)) + +/* The scope named in a using decl. */ +#define USING_DECL_SCOPE(NODE) TREE_TYPE (USING_DECL_CHECK (NODE)) + +/* The decls named by a using decl. */ +#define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE)) + +/* In a VAR_DECL, true if we have a shadowed local variable + in the shadowed var table for this VAR_DECL. */ +#define DECL_HAS_SHADOWED_FOR_VAR_P(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.shadowed_for_var_p) + +/* In a VAR_DECL for a variable declared in a for statement, + this is the shadowed (local) variable. */ +#define DECL_SHADOWED_FOR_VAR(NODE) \ + (DECL_HAS_SHADOWED_FOR_VAR_P(NODE) ? decl_shadowed_for_var_lookup (NODE) : NULL) + +#define SET_DECL_SHADOWED_FOR_VAR(NODE, VAL) \ + (decl_shadowed_for_var_insert (NODE, VAL)) + +/* In a FUNCTION_DECL, this is nonzero if this function was defined in + the class definition. We have saved away the text of the function, + but have not yet processed it. */ +#define DECL_PENDING_INLINE_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->pending_inline_p) + +/* If DECL_PENDING_INLINE_P holds, this is the saved text of the + function. */ +#define DECL_PENDING_INLINE_INFO(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info) + +/* For a class type: if this structure has many fields, we'll sort them + and put them into a TREE_VEC. */ +#define CLASSTYPE_SORTED_FIELDS(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->sorted_fields) + +/* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or + TEMPLATE_DECL, the entity is either a template specialization (if + DECL_USE_TEMPLATE is nonzero) or the abstract instance of the + template itself. + + In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose + TREE_PURPOSE is the TEMPLATE_DECL of which this entity is a + specialization or abstract instance. The TREE_VALUE is the + template arguments used to specialize the template. + + Consider: + + template <typename T> struct S { friend void f(T) {} }; + + In this case, S<int>::f is, from the point of view of the compiler, + an instantiation of a template -- but, from the point of view of + the language, each instantiation of S results in a wholly unrelated + global function f. In this case, DECL_TEMPLATE_INFO for S<int>::f + will be non-NULL, but DECL_USE_TEMPLATE will be zero. */ +#define DECL_TEMPLATE_INFO(NODE) \ + (DECL_LANG_SPECIFIC (VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK (NODE)) \ + ->u.min.template_info) + +/* For a VAR_DECL, indicates that the variable is actually a + non-static data member of anonymous union that has been promoted to + variable status. */ +#define DECL_ANON_UNION_VAR_P(NODE) \ + (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))) + +/* Template information for a RECORD_TYPE or UNION_TYPE. */ +#define CLASSTYPE_TEMPLATE_INFO(NODE) \ + (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info) + +/* Template information for an ENUMERAL_TYPE. Although an enumeration may + not be a primary template, it may be declared within the scope of a + primary template and the enumeration constants may depend on + non-type template parameters. */ +#define ENUM_TEMPLATE_INFO(NODE) \ + (TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE))) + +/* Template information for a template template parameter. */ +#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \ + (LANG_TYPE_CLASS_CHECK (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)) \ + ->template_info) + +/* Template information for an ENUMERAL_, RECORD_, or UNION_TYPE. */ +#define TYPE_TEMPLATE_INFO(NODE) \ + (TREE_CODE (NODE) == ENUMERAL_TYPE \ + ? ENUM_TEMPLATE_INFO (NODE) : \ + (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ + ? TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (NODE) : \ + (TYPE_LANG_SPECIFIC (NODE) \ + ? CLASSTYPE_TEMPLATE_INFO (NODE) \ + : NULL_TREE))) + +/* Set the template information for an ENUMERAL_, RECORD_, or + UNION_TYPE to VAL. */ +#define SET_TYPE_TEMPLATE_INFO(NODE, VAL) \ + (TREE_CODE (NODE) == ENUMERAL_TYPE \ + ? (ENUM_TEMPLATE_INFO (NODE) = (VAL)) \ + : (CLASSTYPE_TEMPLATE_INFO (NODE) = (VAL))) + +#define TI_TEMPLATE(NODE) TREE_TYPE (TEMPLATE_INFO_CHECK (NODE)) +#define TI_ARGS(NODE) TREE_CHAIN (TEMPLATE_INFO_CHECK (NODE)) +#define TI_PENDING_TEMPLATE_FLAG(NODE) TREE_LANG_FLAG_1 (NODE) +/* For a given TREE_VEC containing a template argument list, + this property contains the number of arguments that are not + defaulted. */ +#define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) TREE_CHAIN (TREE_VEC_CHECK (NODE)) +/* Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT + property. */ +#define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \ + NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE) +#ifdef ENABLE_CHECKING +#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \ + int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) +#else +#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \ + NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \ + ? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \ + : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE)) +#endif +/* The list of typedefs - used in the template - that need + access checking at template instantiation time. */ +#define TI_TYPEDEFS_NEEDING_ACCESS_CHECKING(NODE) \ + ((struct tree_template_info*)TEMPLATE_INFO_CHECK \ + (NODE))->typedefs_needing_access_checking + +/* We use TREE_VECs to hold template arguments. If there is only one + level of template arguments, then the TREE_VEC contains the + arguments directly. If there is more than one level of template + arguments, then each entry in the TREE_VEC is itself a TREE_VEC, + containing the template arguments for a single level. The first + entry in the outer TREE_VEC is the outermost level of template + parameters; the last is the innermost. + + It is incorrect to ever form a template argument vector containing + only one level of arguments, but which is a TREE_VEC containing as + its only entry the TREE_VEC for that level. + + For each TREE_VEC containing the template arguments for a single + level, it's possible to get or set the number of non defaulted + template arguments by using the accessor macros + GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or + SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT. */ + +/* Nonzero if the template arguments is actually a vector of vectors, + rather than just a vector. */ +#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ + (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0) \ + && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) + +/* The depth of a template argument vector. When called directly by + the parser, we use a TREE_LIST rather than a TREE_VEC to represent + template arguments. In fact, we may even see NULL_TREE if there + are no template arguments. In both of those cases, there is only + one level of template arguments. */ +#define TMPL_ARGS_DEPTH(NODE) \ + (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) + +/* The LEVELth level of the template ARGS. The outermost level of + args is level 1, not level 0. */ +#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ + (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ + ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS)) + +/* Set the LEVELth level of the template ARGS to VAL. This macro does + not work with single-level argument vectors. */ +#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ + (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL)) + +/* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ +#define TMPL_ARG(ARGS, LEVEL, IDX) \ + (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) + +/* Given a single level of template arguments in NODE, return the + number of arguments. */ +#define NUM_TMPL_ARGS(NODE) \ + (TREE_VEC_LENGTH (NODE)) + +/* Returns the innermost level of template arguments in ARGS. */ +#define INNERMOST_TEMPLATE_ARGS(NODE) \ + (get_innermost_template_args ((NODE), 1)) + +/* The number of levels of template parameters given by NODE. */ +#define TMPL_PARMS_DEPTH(NODE) \ + ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE))) + +/* The TEMPLATE_DECL instantiated or specialized by NODE. This + TEMPLATE_DECL will be the immediate parent, not the most general + template. For example, in: + + template <class T> struct S { template <class U> void f(U); } + + the FUNCTION_DECL for S<int>::f<double> will have, as its + DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'. + + As a special case, for a member friend template of a template + class, this value will not be a TEMPLATE_DECL, but rather an + IDENTIFIER_NODE or OVERLOAD indicating the name of the template and + any explicit template arguments provided. For example, in: + + template <class T> struct S { friend void f<int>(int, double); } + + the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the + DECL_TI_ARGS will be {int}. */ +#define DECL_TI_TEMPLATE(NODE) TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE)) + +/* The template arguments used to obtain this decl from the most + general form of DECL_TI_TEMPLATE. For the example given for + DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}. These + are always the full set of arguments required to instantiate this + declaration from the most general template specialized here. */ +#define DECL_TI_ARGS(NODE) TI_ARGS (DECL_TEMPLATE_INFO (NODE)) + +/* The TEMPLATE_DECL associated with NODE, a class type. Even if NODE + will be generated from a partial specialization, the TEMPLATE_DECL + referred to here will be the original template. For example, + given: + + template <typename T> struct S {}; + template <typename T> struct S<T*> {}; + + the CLASSTPYE_TI_TEMPLATE for S<int*> will be S, not the S<T*>. */ +#define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE)) +#define CLASSTYPE_TI_ARGS(NODE) TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE)) + +/* For a template instantiation TYPE, returns the TYPE corresponding + to the primary template. Otherwise returns TYPE itself. */ +#define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE) \ + ((CLASSTYPE_USE_TEMPLATE ((TYPE)) \ + && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE))) \ + ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE \ + (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \ + : (TYPE)) + +/* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs. */ +#define TYPE_TI_TEMPLATE(NODE) \ + (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE))) + +/* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE. */ +#define TYPE_TI_ARGS(NODE) \ + (TI_ARGS (TYPE_TEMPLATE_INFO (NODE))) + +#define INNERMOST_TEMPLATE_PARMS(NODE) TREE_VALUE (NODE) + +/* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the + sense of [temp.mem]. */ +#define DECL_MEMBER_TEMPLATE_P(NODE) \ + (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE))) + +/* Nonzero if the NODE corresponds to the template parameters for a + member template, whose inline definition is being processed after + the class definition is complete. */ +#define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE) + +/* Determine if a parameter (i.e., a PARM_DECL) is a function + parameter pack. */ +#define FUNCTION_PARAMETER_PACK_P(NODE) \ + (DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))) + +/* Determines if NODE is an expansion of one or more parameter packs, + e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION. */ +#define PACK_EXPANSION_P(NODE) \ + (TREE_CODE (NODE) == TYPE_PACK_EXPANSION \ + || TREE_CODE (NODE) == EXPR_PACK_EXPANSION) + +/* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or + EXPR_PACK_EXPANSION. */ +#define PACK_EXPANSION_PATTERN(NODE) \ + (TREE_CODE (NODE) == TYPE_PACK_EXPANSION? TREE_TYPE (NODE) \ + : TREE_OPERAND (NODE, 0)) + +/* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or + EXPR_PACK_EXPANSION. */ +#define SET_PACK_EXPANSION_PATTERN(NODE,VALUE) \ + if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION) \ + TREE_TYPE (NODE) = VALUE; \ + else \ + TREE_OPERAND (NODE, 0) = VALUE + +/* The list of parameter packs used in the PACK_EXPANSION_* node. The + TREE_VALUE of each TREE_LIST contains the parameter packs. */ +#define PACK_EXPANSION_PARAMETER_PACKS(NODE) TREE_CHAIN (NODE) + +/* Determine if this is an argument pack. */ +#define ARGUMENT_PACK_P(NODE) \ + (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK \ + || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK) + +/* The arguments stored in an argument pack. Arguments are stored in a + TREE_VEC, which may have length zero. */ +#define ARGUMENT_PACK_ARGS(NODE) \ + (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE) \ + : TREE_OPERAND (NODE, 0)) + +/* Set the arguments stored in an argument pack. VALUE must be a + TREE_VEC. */ +#define SET_ARGUMENT_PACK_ARGS(NODE,VALUE) \ + if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK) \ + TREE_TYPE (NODE) = VALUE; \ + else \ + TREE_OPERAND (NODE, 0) = VALUE + +/* Whether the argument pack is "incomplete", meaning that more + arguments can still be deduced. Incomplete argument packs are only + used when the user has provided an explicit template argument list + for a variadic function template. Some of the explicit template + arguments will be placed into the beginning of the argument pack, + but additional arguments might still be deduced. */ +#define ARGUMENT_PACK_INCOMPLETE_P(NODE) \ + TREE_LANG_FLAG_0 (ARGUMENT_PACK_ARGS (NODE)) + +/* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template + arguments used to fill this pack. */ +#define ARGUMENT_PACK_EXPLICIT_ARGS(NODE) \ + TREE_TYPE (ARGUMENT_PACK_ARGS (NODE)) + +/* In an ARGUMENT_PACK_SELECT, the argument pack from which an + argument will be selected. */ +#define ARGUMENT_PACK_SELECT_FROM_PACK(NODE) \ + (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack) + +/* In an ARGUMENT_PACK_SELECT, the index of the argument we want to + select. */ +#define ARGUMENT_PACK_SELECT_INDEX(NODE) \ + (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index) + +/* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the + ARGUMENT_PACK_SELECT represents. */ +#define ARGUMENT_PACK_SELECT_ARG(NODE) \ + TREE_VEC_ELT (ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (NODE)), \ + ARGUMENT_PACK_SELECT_INDEX (NODE)); + +/* In a FUNCTION_DECL, the saved language-specific per-function data. */ +#define DECL_SAVED_FUNCTION_DATA(NODE) \ + (LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE)) \ + ->u.saved_language_function) + +/* Indicates an indirect_expr is for converting a reference. */ +#define REFERENCE_REF_P(NODE) \ + TREE_LANG_FLAG_0 (INDIRECT_REF_CHECK (NODE)) + +#define NEW_EXPR_USE_GLOBAL(NODE) \ + TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE)) +#define DELETE_EXPR_USE_GLOBAL(NODE) \ + TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE)) +#define DELETE_EXPR_USE_VEC(NODE) \ + TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE)) + +/* Indicates that this is a non-dependent COMPOUND_EXPR which will + resolve to a function call. */ +#define COMPOUND_EXPR_OVERLOADED(NODE) \ + TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE)) + +/* In a CALL_EXPR appearing in a template, true if Koenig lookup + should be performed at instantiation time. */ +#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE)) + +/* Indicates whether a string literal has been parenthesized. Such + usages are disallowed in certain circumstances. */ + +#define PAREN_STRING_LITERAL_P(NODE) \ + TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE)) + +/* Nonzero if this AGGR_INIT_EXPR provides for initialization via a + constructor call, rather than an ordinary function call. */ +#define AGGR_INIT_VIA_CTOR_P(NODE) \ + TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE)) + +/* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize + the object. */ +#define AGGR_INIT_ZERO_FIRST(NODE) \ + TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE)) + +/* AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR + accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of + CALL_EXPR_STATIC_CHAIN). */ + +#define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1) +#define AGGR_INIT_EXPR_SLOT(NODE) \ + TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2) +#define AGGR_INIT_EXPR_ARG(NODE, I) \ + TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3) +#define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3) + +/* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE. + We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if + the argument count is zero when checking is enabled. Instead, do + the pointer arithmetic to advance past the 3 fixed operands in a + AGGR_INIT_EXPR. That produces a valid pointer to just past the end of + the operand array, even if it's not valid to dereference it. */ +#define AGGR_INIT_EXPR_ARGP(NODE) \ + (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3) + +/* Abstract iterators for AGGR_INIT_EXPRs. */ + +/* Structure containing iterator state. */ +typedef struct aggr_init_expr_arg_iterator_d { + tree t; /* the aggr_init_expr */ + int n; /* argument count */ + int i; /* next argument index */ +} aggr_init_expr_arg_iterator; + +/* Initialize the abstract argument list iterator object ITER with the + arguments from AGGR_INIT_EXPR node EXP. */ +static inline void +init_aggr_init_expr_arg_iterator (tree exp, + aggr_init_expr_arg_iterator *iter) +{ + iter->t = exp; + iter->n = aggr_init_expr_nargs (exp); + iter->i = 0; +} + +/* Return the next argument from abstract argument list iterator object ITER, + and advance its state. Return NULL_TREE if there are no more arguments. */ +static inline tree +next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter) +{ + tree result; + if (iter->i >= iter->n) + return NULL_TREE; + result = AGGR_INIT_EXPR_ARG (iter->t, iter->i); + iter->i++; + return result; +} + +/* Initialize the abstract argument list iterator object ITER, then advance + past and return the first argument. Useful in for expressions, e.g. + for (arg = first_aggr_init_expr_arg (exp, &iter); arg; + arg = next_aggr_init_expr_arg (&iter)) */ +static inline tree +first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter) +{ + init_aggr_init_expr_arg_iterator (exp, iter); + return next_aggr_init_expr_arg (iter); +} + +/* Test whether there are more arguments in abstract argument list iterator + ITER, without changing its state. */ +static inline bool +more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) +{ + return (iter->i < iter->n); +} + +/* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable + ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state. */ +#define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call) \ + for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg); \ + (arg) = next_aggr_init_expr_arg (&(iter))) + +/* VEC_INIT_EXPR accessors. */ +#define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (NODE, 0) +#define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (NODE, 1) + +/* Indicates that a VEC_INIT_EXPR is a potential constant expression. + Only set when the current function is constexpr. */ +#define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \ + TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE)) + +/* Indicates that a VEC_INIT_EXPR is expressing value-initialization. */ +#define VEC_INIT_EXPR_VALUE_INIT(NODE) \ + TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE)) + +/* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a + TEMPLATE_DECL. This macro determines whether or not a given class + type is really a template type, as opposed to an instantiation or + specialization of one. */ +#define CLASSTYPE_IS_TEMPLATE(NODE) \ + (CLASSTYPE_TEMPLATE_INFO (NODE) \ + && !CLASSTYPE_USE_TEMPLATE (NODE) \ + && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) + +/* The name used by the user to name the typename type. Typically, + this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the + corresponding TYPE_DECL. However, this may also be a + TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'. */ +#define TYPENAME_TYPE_FULLNAME(NODE) (TYPENAME_TYPE_CHECK (NODE))->type.values + +/* True if a TYPENAME_TYPE was declared as an "enum". */ +#define TYPENAME_IS_ENUM_P(NODE) \ + (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE))) + +/* True if a TYPENAME_TYPE was declared as a "class", "struct", or + "union". */ +#define TYPENAME_IS_CLASS_P(NODE) \ + (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE))) + +/* True if a TYPENAME_TYPE is in the process of being resolved. */ +#define TYPENAME_IS_RESOLVING_P(NODE) \ + (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE))) + +/* Nonzero in INTEGER_CST means that this int is negative by dint of + using a twos-complement negated operand. */ +#define TREE_NEGATED_INT(NODE) TREE_LANG_FLAG_0 (INTEGER_CST_CHECK (NODE)) + +/* [class.virtual] + + A class that declares or inherits a virtual function is called a + polymorphic class. */ +#define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE)) + +/* Nonzero if this class has a virtual function table pointer. */ +#define TYPE_CONTAINS_VPTR_P(NODE) \ + (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE)) + +/* This flag is true of a local VAR_DECL if it was declared in a for + statement, but we are no longer in the scope of the for. */ +#define DECL_DEAD_FOR_LOCAL(NODE) DECL_LANG_FLAG_7 (VAR_DECL_CHECK (NODE)) + +/* This flag is set on a VAR_DECL that is a DECL_DEAD_FOR_LOCAL + if we already emitted a warning about using it. */ +#define DECL_ERROR_REPORTED(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)) + +/* Nonzero if NODE is a FUNCTION_DECL (for a function with global + scope) declared in a local scope. */ +#define DECL_LOCAL_FUNCTION_P(NODE) \ + DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)) + +/* Nonzero if NODE is a DECL which we know about but which has not + been explicitly declared, such as a built-in function or a friend + declared inside a class. In the latter case DECL_HIDDEN_FRIEND_P + will be set. */ +#define DECL_ANTICIPATED(NODE) \ + (DECL_LANG_SPECIFIC (DECL_COMMON_CHECK (NODE))->u.base.anticipated_p) + +/* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend + within a class but has not been declared in the surrounding scope. + The function is invisible except via argument dependent lookup. */ +#define DECL_HIDDEN_FRIEND_P(NODE) \ + (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->hidden_friend_p) + +/* Nonzero if DECL has been declared threadprivate by + #pragma omp threadprivate. */ +#define CP_DECL_THREADPRIVATE_P(DECL) \ + (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p) + +/* Nonzero if DECL was declared with '= delete'. */ +#define DECL_DELETED_FN(DECL) \ + (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p) + +/* Nonzero if DECL was declared with '= default' (maybe implicitly). */ +#define DECL_DEFAULTED_FN(DECL) \ + (LANG_DECL_FN_CHECK (DECL)->defaulted_p) + +/* Nonzero if DECL is explicitly defaulted in the class body. */ +#define DECL_DEFAULTED_IN_CLASS_P(DECL) \ + (DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL)) +/* Nonzero if DECL was defaulted outside the class body. */ +#define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL) \ + (DECL_DEFAULTED_FN (DECL) \ + && !(DECL_ARTIFICIAL (DECL) || DECL_INITIALIZED_IN_CLASS_P (DECL))) + +/* Record whether a typedef for type `int' was actually `signed int'. */ +#define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP) + +/* Returns nonzero if DECL has external linkage, as specified by the + language standard. (This predicate may hold even when the + corresponding entity is not actually given external linkage in the + object file; see decl_linkage for details.) */ +#define DECL_EXTERNAL_LINKAGE_P(DECL) \ + (decl_linkage (DECL) == lk_external) + +/* Keep these codes in ascending code order. */ + +#define INTEGRAL_CODE_P(CODE) \ + ((CODE) == ENUMERAL_TYPE \ + || (CODE) == BOOLEAN_TYPE \ + || (CODE) == INTEGER_TYPE) + +/* [basic.fundamental] + + Types bool, char, wchar_t, and the signed and unsigned integer types + are collectively called integral types. + + Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration + types as well, which is incorrect in C++. Keep these checks in + ascending code order. */ +#define CP_INTEGRAL_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == BOOLEAN_TYPE \ + || TREE_CODE (TYPE) == INTEGER_TYPE) + +/* Returns true if TYPE is an integral or enumeration name. Keep + these checks in ascending code order. */ +#define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE)) + +/* Returns true if TYPE is an integral or unscoped enumeration type. */ +#define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \ + (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE)) + +/* True if the class type TYPE is a literal type. */ +#define CLASSTYPE_LITERAL_P(TYPE) \ + (LANG_TYPE_CLASS_CHECK (TYPE)->is_literal) + +/* [basic.fundamental] + + Integral and floating types are collectively called arithmetic + types. + + As a GNU extension, we also accept complex types. + + Keep these checks in ascending code order. */ +#define ARITHMETIC_TYPE_P(TYPE) \ + (CP_INTEGRAL_TYPE_P (TYPE) \ + || TREE_CODE (TYPE) == REAL_TYPE \ + || TREE_CODE (TYPE) == COMPLEX_TYPE) + +/* True iff TYPE is cv decltype(nullptr). */ +#define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE) + +/* [basic.types] + + Arithmetic types, enumeration types, pointer types, + pointer-to-member types, and std::nullptr_t are collectively called + scalar types. + + Keep these checks in ascending code order. */ +#define SCALAR_TYPE_P(TYPE) \ + (TYPE_PTRMEM_P (TYPE) \ + || TREE_CODE (TYPE) == ENUMERAL_TYPE \ + || ARITHMETIC_TYPE_P (TYPE) \ + || TYPE_PTR_P (TYPE) \ + || TYPE_PTRMEMFUNC_P (TYPE) \ + || NULLPTR_TYPE_P (TYPE)) + +/* Determines whether this type is a C++0x scoped enumeration + type. Scoped enumerations types are introduced via "enum class" or + "enum struct", e.g., + + enum class Color { + Red, Green, Blue + }; + + Scoped enumeration types are different from normal (unscoped) + enumeration types in several ways: + + - The enumerators of a scoped enumeration type are only available + within the scope of the enumeration type and not in the + enclosing scope. For example, the Red color can be referred to + with "Color::Red" but not "Red". + + - Scoped enumerators and enumerations do not implicitly convert + to integers or 'bool'. + + - The underlying type of the enum is well-defined. */ +#define SCOPED_ENUM_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE)) + +/* Determine whether this is an unscoped enumeration type. */ +#define UNSCOPED_ENUM_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE)) + +/* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped + enumeration type (1) or a normal (unscoped) enumeration type + (0). */ +#define SET_SCOPED_ENUM_P(TYPE, VAL) \ + (ENUM_IS_SCOPED (TYPE) = (VAL)) + +#define SET_OPAQUE_ENUM_P(TYPE, VAL) \ + (ENUM_IS_OPAQUE (TYPE) = (VAL)) + +#define OPAQUE_ENUM_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE)) + +/* Determines whether an ENUMERAL_TYPE has an explicit + underlying type. */ +#define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE)) + +/* Returns the underlying type of the given enumeration type. The + underlying type is determined in different ways, depending on the + properties of the enum: + + - In C++0x, the underlying type can be explicitly specified, e.g., + + enum E1 : char { ... } // underlying type is char + + - In a C++0x scoped enumeration, the underlying type is int + unless otherwises specified: + + enum class E2 { ... } // underlying type is int + + - Otherwise, the underlying type is determined based on the + values of the enumerators. In this case, the + ENUM_UNDERLYING_TYPE will not be set until after the definition + of the enumeration is completed by finish_enum. */ +#define ENUM_UNDERLYING_TYPE(TYPE) \ + TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE)) + +/* [dcl.init.aggr] + + An aggregate is an array or a class with no user-declared + constructors, no private or protected non-static data members, no + base classes, and no virtual functions. + + As an extension, we also treat vectors as aggregates. Keep these + checks in ascending code order. */ +#define CP_AGGREGATE_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == VECTOR_TYPE \ + ||TREE_CODE (TYPE) == ARRAY_TYPE \ + || (CLASS_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE))) + +/* Nonzero for a class type means that the class type has a + user-declared constructor. */ +#define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE)) + +/* When appearing in an INDIRECT_REF, it means that the tree structure + underneath is actually a call to a constructor. This is needed + when the constructor must initialize local storage (which can + be automatically destroyed), rather than allowing it to allocate + space from the heap. + + When appearing in a SAVE_EXPR, it means that underneath + is a call to a constructor. + + When appearing in a CONSTRUCTOR, the expression is a + compound literal. + + When appearing in a FIELD_DECL, it means that this field + has been duly initialized in its constructor. */ +#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE)) + +/* True if NODE is a brace-enclosed initializer. */ +#define BRACE_ENCLOSED_INITIALIZER_P(NODE) \ + (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node) + +/* True if NODE is a compound-literal, i.e., a brace-enclosed + initializer cast to a particular type. */ +#define COMPOUND_LITERAL_P(NODE) \ + (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE)) + +#define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \ + && VEC_empty (constructor_elt, \ + CONSTRUCTOR_ELTS (NODE)) \ + && !TREE_HAS_CONSTRUCTOR (NODE)) + +/* True if NODE is a init-list used as a direct-initializer, i.e. + B b{1,2}, not B b({1,2}) or B b = {1,2}. */ +#define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE))) + +/* Nonzero means that an object of this type can not be initialized using + an initializer list. */ +#define CLASSTYPE_NON_AGGREGATE(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate) +#define TYPE_NON_AGGREGATE_CLASS(NODE) \ + (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE)) + +/* Nonzero if there is a non-trivial X::op=(cv X&) for this class. */ +#define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign) + +/* Nonzero if there is a non-trivial X::X(cv X&) for this class. */ +#define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor) + +/* Nonzero if there is a non-trivial X::op=(X&&) for this class. */ +#define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign) + +/* Nonzero if there is a non-trivial X::X(X&&) for this class. */ +#define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor) + +/* Nonzero if there is a non-trivial default constructor for this class. */ +#define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt) + +/* Nonzero if TYPE has a trivial destructor. From [class.dtor]: + + A destructor is trivial if it is an implicitly declared + destructor and if: + + - all of the direct base classes of its class have trivial + destructors, + + - for all of the non-static data members of its class that are + of class type (or array thereof), each such class has a + trivial destructor. */ +#define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \ + (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE)) + +/* Nonzero for _TYPE node means that this type does not have a trivial + destructor. Therefore, destroying an object of this type will + involve a call to a destructor. This can apply to objects of + ARRAY_TYPE is the type of the elements needs a destructor. */ +#define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \ + (TYPE_LANG_FLAG_4 (NODE)) + +/* Nonzero for class type means that the default constructor is trivial. */ +#define TYPE_HAS_TRIVIAL_DFLT(NODE) \ + (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE)) + +/* Nonzero for class type means that copy initialization of this type can use + a bitwise copy. */ +#define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \ + (TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE)) + +/* Nonzero for class type means that assignment of this type can use + a bitwise copy. */ +#define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \ + (TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE)) + +/* Returns true if NODE is a pointer-to-data-member. */ +#define TYPE_PTRMEM_P(NODE) \ + (TREE_CODE (NODE) == OFFSET_TYPE) +/* Returns true if NODE is a pointer. */ +#define TYPE_PTR_P(NODE) \ + (TREE_CODE (NODE) == POINTER_TYPE) + +/* Returns true if NODE is an object type: + + [basic.types] + + An object type is a (possibly cv-qualified) type that is not a + function type, not a reference type, and not a void type. + + Keep these checks in ascending order, for speed. */ +#define TYPE_OBJ_P(NODE) \ + (TREE_CODE (NODE) != REFERENCE_TYPE \ + && TREE_CODE (NODE) != VOID_TYPE \ + && TREE_CODE (NODE) != FUNCTION_TYPE \ + && TREE_CODE (NODE) != METHOD_TYPE) + +/* Returns true if NODE is a pointer to an object. Keep these checks + in ascending tree code order. */ +#define TYPE_PTROB_P(NODE) \ + (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE))) + +/* Returns true if NODE is a reference to an object. Keep these checks + in ascending tree code order. */ +#define TYPE_REF_OBJ_P(NODE) \ + (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE))) + +/* Returns true if NODE is a pointer to an object, or a pointer to + void. Keep these checks in ascending tree code order. */ +#define TYPE_PTROBV_P(NODE) \ + (TYPE_PTR_P (NODE) \ + && !(TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE \ + || TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)) + +/* Returns true if NODE is a pointer to function. */ +#define TYPE_PTRFN_P(NODE) \ + (TREE_CODE (NODE) == POINTER_TYPE \ + && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) + +/* Returns true if NODE is a reference to function. */ +#define TYPE_REFFN_P(NODE) \ + (TREE_CODE (NODE) == REFERENCE_TYPE \ + && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE) + +/* Nonzero for _TYPE node means that this type is a pointer to member + function type. */ +#define TYPE_PTRMEMFUNC_P(NODE) \ + (TREE_CODE (NODE) == RECORD_TYPE \ + && TYPE_LANG_SPECIFIC (NODE) \ + && TYPE_PTRMEMFUNC_FLAG (NODE)) + +#define TYPE_PTRMEMFUNC_FLAG(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->ptrmemfunc_flag) + +/* Returns true if NODE is a pointer-to-member. */ +#define TYPE_PTR_TO_MEMBER_P(NODE) \ + (TYPE_PTRMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE)) + +/* Indicates when overload resolution may resolve to a pointer to + member function. [expr.unary.op]/3 */ +#define PTRMEM_OK_P(NODE) \ + TREE_LANG_FLAG_0 (TREE_CHECK2 ((NODE), ADDR_EXPR, OFFSET_REF)) + +/* Get the POINTER_TYPE to the METHOD_TYPE associated with this + pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true, + before using this macro. */ +#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \ + (TREE_TYPE (TYPE_FIELDS (NODE))) + +/* Returns `A' for a type like `int (A::*)(double)' */ +#define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \ + TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) + +/* These are use to manipulate the canonical RECORD_TYPE from the + hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */ +#define TYPE_GET_PTRMEMFUNC_TYPE(NODE) \ + (TYPE_LANG_SPECIFIC (NODE) ? LANG_TYPE_PTRMEM_CHECK (NODE)->record : NULL) +#define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) \ + do { \ + if (TYPE_LANG_SPECIFIC (NODE) == NULL) \ + { \ + TYPE_LANG_SPECIFIC (NODE) = ggc_alloc_cleared_lang_type \ + (sizeof (struct lang_type_ptrmem)); \ + TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.h.is_lang_type_class = 0; \ + } \ + TYPE_LANG_SPECIFIC (NODE)->u.ptrmem.record = (VALUE); \ + } while (0) + +/* For a pointer-to-member type of the form `T X::*', this is `X'. + For a type like `void (X::*)() const', this type is `X', not `const + X'. To get at the `const X' you have to look at the + TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have + type `const X*'. */ +#define TYPE_PTRMEM_CLASS_TYPE(NODE) \ + (TYPE_PTRMEM_P (NODE) \ + ? TYPE_OFFSET_BASETYPE (NODE) \ + : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE)) + +/* For a pointer-to-member type of the form `T X::*', this is `T'. */ +#define TYPE_PTRMEM_POINTED_TO_TYPE(NODE) \ + (TYPE_PTRMEM_P (NODE) \ + ? TREE_TYPE (NODE) \ + : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE))) + +/* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for + `X'. */ +#define PTRMEM_CST_CLASS(NODE) \ + TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE))) + +/* For a pointer-to-member constant `X::Y' this is the _DECL for + `Y'. */ +#define PTRMEM_CST_MEMBER(NODE) (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member) + +/* The expression in question for a TYPEOF_TYPE. */ +#define TYPEOF_TYPE_EXPR(NODE) (TYPEOF_TYPE_CHECK (NODE))->type.values + +/* The expression in question for a DECLTYPE_TYPE. */ +#define DECLTYPE_TYPE_EXPR(NODE) (DECLTYPE_TYPE_CHECK (NODE))->type.values + +/* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an + id-expression or a member-access expression. When false, it was + parsed as a full expression. */ +#define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \ + (DECLTYPE_TYPE_CHECK (NODE))->type.string_flag + +/* These flags indicate that we want different semantics from normal + decltype: lambda capture just drops references, lambda return also does + type decay. */ +#define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \ + TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE)) +#define DECLTYPE_FOR_LAMBDA_RETURN(NODE) \ + TREE_LANG_FLAG_1 (DECLTYPE_TYPE_CHECK (NODE)) + +/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was + specified in its declaration. This can also be set for an + erroneously declared PARM_DECL. */ +#define DECL_THIS_EXTERN(NODE) \ + DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) + +/* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was + specified in its declaration. This can also be set for an + erroneously declared PARM_DECL. */ +#define DECL_THIS_STATIC(NODE) \ + DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE)) + +/* Nonzero for FIELD_DECL node means that this field is a base class + of the parent object, as opposed to a member field. */ +#define DECL_FIELD_IS_BASE(NODE) \ + DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE)) + +/* Nonzero for FIELD_DECL node means that this field is a simple (no + explicit initializer) lambda capture field, making it invisible to + name lookup in unevaluated contexts. */ +#define DECL_NORMAL_CAPTURE_P(NODE) \ + DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE)) + +/* Nonzero if TYPE is an anonymous union or struct type. We have to use a + flag for this because "A union for which objects or pointers are + declared is not an anonymous union" [class.union]. */ +#define ANON_AGGR_TYPE_P(NODE) \ + (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr) +#define SET_ANON_AGGR_TYPE_P(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1) + +/* Nonzero if TYPE is an anonymous union type. */ +#define ANON_UNION_TYPE_P(NODE) \ + (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE)) + +/* Define fields and accessors for nodes representing declared names. */ + +#define TYPE_WAS_ANONYMOUS(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->was_anonymous) + +/* C++: all of these are overloaded! These apply only to TYPE_DECLs. */ + +/* The format of each node in the DECL_FRIENDLIST is as follows: + + The TREE_PURPOSE will be the name of a function, i.e., an + IDENTIFIER_NODE. The TREE_VALUE will be itself a TREE_LIST, whose + TREE_VALUEs are friends with the given name. */ +#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE)) +#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST)) +#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST)) + +/* The DECL_ACCESS, if non-NULL, is a TREE_LIST. The TREE_PURPOSE of + each node is a type; the TREE_VALUE is the access granted for this + DECL in that type. The DECL_ACCESS is set by access declarations. + For example, if a member that would normally be public in a + derived class is made protected, then the derived class and the + protected_access_node will appear in the DECL_ACCESS for the node. */ +#define DECL_ACCESS(NODE) (LANG_DECL_U2_CHECK (NODE, 0)->access) + +/* Nonzero if the FUNCTION_DECL is a global constructor. */ +#define DECL_GLOBAL_CTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->global_ctor_p) + +/* Nonzero if the FUNCTION_DECL is a global destructor. */ +#define DECL_GLOBAL_DTOR_P(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->global_dtor_p) + +/* Accessor macros for C++ template decl nodes. */ + +/* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node + is a INT_CST whose TREE_INT_CST_LOW indicates the level of the + template parameters, with 1 being the outermost set of template + parameters. The TREE_VALUE is a vector, whose elements are the + template parameters at each level. Each element in the vector is a + TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a + non-type parameter), or a TYPE_DECL (if the parameter is a type + parameter). The TREE_PURPOSE is the default value, if any. The + TEMPLATE_PARM_INDEX for the parameter is available as the + DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a + TYPE_DECL). */ +#define DECL_TEMPLATE_PARMS(NODE) DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments +#define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \ + INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE)) +#define DECL_NTPARMS(NODE) \ + TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE)) +/* For function, method, class-data templates. */ +#define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT_FLD (NODE) +/* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS + lists all instantiations and specializations of the function so that + tsubst_friend_function can reassign them to another template if we find + that the namespace-scope template is really a partial instantiation of a + friend template. + + For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds + all instantiations and specializations of the class type, including + partial instantiations and partial specializations, so that if we + explicitly specialize a partial instantiation we can walk the list + in maybe_process_partial_specialization and reassign them or complain + as appropriate. + + In both cases, the TREE_PURPOSE of each node contains the arguments + used; the TREE_VALUE contains the generated variable. The template + arguments are always complete. For example, given: + + template <class T> struct S1 { + template <class U> struct S2 {}; + template <class U> struct S2<U*> {}; + }; + + the record for the partial specialization will contain, as its + argument list, { {T}, {U*} }, and will be on the + DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template + <class U> struct S1<T>::S2'. + + This list is not used for other templates. */ +#define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX (NODE) +/* For a class template, this list contains the partial + specializations of this template. (Full specializations are not + recorded on this list.) The TREE_PURPOSE holds the arguments used + in the partial specialization (e.g., for `template <class T> struct + S<T*, int>' this will be `T*'.) The arguments will also include + any outer template arguments. The TREE_VALUE holds the innermost + template parameters for the specialization (e.g., `T' in the + example above.) The TREE_TYPE is the _TYPE node for the partial + specialization. + + This list is not used for other templates. */ +#define DECL_TEMPLATE_SPECIALIZATIONS(NODE) DECL_SIZE (NODE) + +/* Nonzero for a DECL which is actually a template parameter. Keep + these checks in ascending tree code order. */ +#define DECL_TEMPLATE_PARM_P(NODE) \ + (DECL_LANG_FLAG_0 (NODE) \ + && (TREE_CODE (NODE) == CONST_DECL \ + || TREE_CODE (NODE) == PARM_DECL \ + || TREE_CODE (NODE) == TYPE_DECL \ + || TREE_CODE (NODE) == TEMPLATE_DECL)) + +/* Mark NODE as a template parameter. */ +#define SET_DECL_TEMPLATE_PARM_P(NODE) \ + (DECL_LANG_FLAG_0 (NODE) = 1) + +/* Nonzero if NODE is a template template parameter. */ +#define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE)) + +/* Nonzero if NODE is a TEMPLATE_DECL representing an + UNBOUND_CLASS_TEMPLATE tree node. */ +#define DECL_UNBOUND_CLASS_TEMPLATE_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL && !DECL_TEMPLATE_RESULT (NODE)) + +#define DECL_FUNCTION_TEMPLATE_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL \ + && !DECL_UNBOUND_CLASS_TEMPLATE_P (NODE) \ + && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL) + +/* Nonzero for a DECL that represents a template class. */ +#define DECL_CLASS_TEMPLATE_P(NODE) \ + (TREE_CODE (NODE) == TEMPLATE_DECL \ + && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE \ + && DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE))) + +/* Nonzero if NODE which declares a type. */ +#define DECL_DECLARES_TYPE_P(NODE) \ + (TREE_CODE (NODE) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (NODE)) + +/* Nonzero if NODE declares a function. */ +#define DECL_DECLARES_FUNCTION_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (NODE)) + +/* Nonzero if NODE is the typedef implicitly generated for a type when + the type is declared. In C++, `struct S {};' is roughly + equivalent to `struct S {}; typedef struct S S;' in C. + DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this + example. In C++, there is a second implicit typedef for each + class, in the scope of `S' itself, so that you can say `S::S'. + DECL_SELF_REFERENCE_P will hold for that second typedef. */ +#define DECL_IMPLICIT_TYPEDEF_P(NODE) \ + (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE)) +#define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \ + (DECL_LANG_FLAG_2 (NODE) = 1) +#define DECL_SELF_REFERENCE_P(NODE) \ + (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE)) +#define SET_DECL_SELF_REFERENCE_P(NODE) \ + (DECL_LANG_FLAG_4 (NODE) = 1) + +/* A `primary' template is one that has its own template header. A + member function of a class template is a template, but not primary. + A member template is primary. Friend templates are primary, too. */ + +/* Returns the primary template corresponding to these parameters. */ +#define DECL_PRIMARY_TEMPLATE(NODE) \ + (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE))) + +/* Returns nonzero if NODE is a primary template. */ +#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE)) + +/* Nonzero iff NODE is a specialization of a template. The value + indicates the type of specializations: + + 1=implicit instantiation + + 2=partial or explicit specialization, e.g.: + + template <> int min<int> (int, int), + + 3=explicit instantiation, e.g.: + + template int min<int> (int, int); + + Note that NODE will be marked as a specialization even if the + template it is instantiating is not a primary template. For + example, given: + + template <typename T> struct O { + void f(); + struct I {}; + }; + + both O<int>::f and O<int>::I will be marked as instantiations. + + If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also + be non-NULL. */ +#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template) + +/* Like DECL_USE_TEMPLATE, but for class types. */ +#define CLASSTYPE_USE_TEMPLATE(NODE) \ + (LANG_TYPE_CLASS_CHECK (NODE)->use_template) + +/* True if NODE is a specialization of a primary template. */ +#define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE) \ + (CLASS_TYPE_P (NODE) \ + && CLASSTYPE_USE_TEMPLATE (NODE) \ + && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))) + +#define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1) +#define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) & 1) + +#define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2) +#define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2) + +/* Returns true for an explicit or partial specialization of a class + template. */ +#define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) == 2) +#define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) = 2) + +#define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1) +#define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1) +#define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) == 1) +#define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) = 1) + +#define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3) +#define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3) +#define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) == 3) +#define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \ + (CLASSTYPE_USE_TEMPLATE (NODE) = 3) + +/* Nonzero if DECL is a friend function which is an instantiation + from the point of view of the compiler, but not from the point of + view of the language. For example given: + template <class T> struct S { friend void f(T) {}; }; + the declaration of `void f(int)' generated when S<int> is + instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be + a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION. */ +#define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \ + (DECL_TEMPLATE_INFO (DECL) && !DECL_USE_TEMPLATE (DECL)) + +/* Nonzero iff we are currently processing a declaration for an + entity with its own template parameter list, and which is not a + full specialization. */ +#define PROCESSING_REAL_TEMPLATE_DECL_P() \ + (processing_template_decl > template_class_depth (current_scope ())) + +/* Nonzero if this VAR_DECL or FUNCTION_DECL has already been + instantiated, i.e. its definition has been generated from the + pattern given in the template. */ +#define DECL_TEMPLATE_INSTANTIATED(NODE) \ + DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE)) + +/* We know what we're doing with this decl now. */ +#define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE) + +/* DECL_EXTERNAL must be set on a decl until the decl is actually emitted, + so that assemble_external will work properly. So we have this flag to + tell us whether the decl is really not external. + + This flag does not indicate whether or not the decl is defined in the + current translation unit; it indicates whether or not we should emit the + decl at the end of compilation if it is defined and needed. */ +#define DECL_NOT_REALLY_EXTERN(NODE) \ + (DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern) + +#define DECL_REALLY_EXTERN(NODE) \ + (DECL_EXTERNAL (NODE) && ! DECL_NOT_REALLY_EXTERN (NODE)) + +/* A thunk is a stub function. + + A thunk is an alternate entry point for an ordinary FUNCTION_DECL. + The address of the ordinary FUNCTION_DECL is given by the + DECL_INITIAL, which is always an ADDR_EXPR whose operand is a + FUNCTION_DECL. The job of the thunk is to either adjust the this + pointer before transferring control to the FUNCTION_DECL, or call + FUNCTION_DECL and then adjust the result value. Note, the result + pointer adjusting thunk must perform a call to the thunked + function, (or be implemented via passing some invisible parameter + to the thunked function, which is modified to perform the + adjustment just before returning). + + A thunk may perform either, or both, of the following operations: + + o Adjust the this or result pointer by a constant offset. + o Adjust the this or result pointer by looking up a vcall or vbase offset + in the vtable. + + A this pointer adjusting thunk converts from a base to a derived + class, and hence adds the offsets. A result pointer adjusting thunk + converts from a derived class to a base, and hence subtracts the + offsets. If both operations are performed, then the constant + adjustment is performed first for this pointer adjustment and last + for the result pointer adjustment. + + The constant adjustment is given by THUNK_FIXED_OFFSET. If the + vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is + used. For this pointer adjusting thunks, it is the vcall offset + into the vtable. For result pointer adjusting thunks it is the + binfo of the virtual base to convert to. Use that binfo's vbase + offset. + + It is possible to have equivalent covariant thunks. These are + distinct virtual covariant thunks whose vbase offsets happen to + have the same value. THUNK_ALIAS is used to pick one as the + canonical thunk, which will get all the this pointer adjusting + thunks attached to it. */ + +/* An integer indicating how many bytes should be subtracted from the + this or result pointer when this function is called. */ +#define THUNK_FIXED_OFFSET(DECL) \ + (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset) + +/* A tree indicating how to perform the virtual adjustment. For a this + adjusting thunk it is the number of bytes to be added to the vtable + to find the vcall offset. For a result adjusting thunk, it is the + binfo of the relevant virtual base. If NULL, then there is no + virtual adjust. (The vptr is always located at offset zero from + the this or result pointer.) (If the covariant type is within the + class hierarchy being laid out, the vbase index is not yet known + at the point we need to create the thunks, hence the need to use + binfos.) */ + +#define THUNK_VIRTUAL_OFFSET(DECL) \ + (LANG_DECL_U2_CHECK (FUNCTION_DECL_CHECK (DECL), 0)->access) + +/* A thunk which is equivalent to another thunk. */ +#define THUNK_ALIAS(DECL) \ + (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info) + +/* For thunk NODE, this is the FUNCTION_DECL thunked to. It is + possible for the target to be a thunk too. */ +#define THUNK_TARGET(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->befriending_classes) + +/* True for a SCOPE_REF iff the "template" keyword was used to + indicate that the qualified name denotes a template. */ +#define QUALIFIED_NAME_IS_TEMPLATE(NODE) \ + (TREE_LANG_FLAG_0 (SCOPE_REF_CHECK (NODE))) + +/* True for an OMP_ATOMIC that has dependent parameters. These are stored + as an expr in operand 1, and integer_zero_node in operand 0. */ +#define OMP_ATOMIC_DEPENDENT_P(NODE) \ + (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST) + +/* Used while gimplifying continue statements bound to OMP_FOR nodes. */ +#define OMP_FOR_GIMPLIFYING_P(NODE) \ + (TREE_LANG_FLAG_0 (OMP_FOR_CHECK (NODE))) + +/* A language-specific token attached to the OpenMP data clauses to + hold code (or code fragments) related to ctors, dtors, and op=. + See semantics.c for details. */ +#define CP_OMP_CLAUSE_INFO(NODE) \ + TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \ + OMP_CLAUSE_COPYPRIVATE)) + +/* These macros provide convenient access to the various _STMT nodes + created when parsing template declarations. */ +#define TRY_STMTS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0) +#define TRY_HANDLERS(NODE) TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1) + +#define EH_SPEC_STMTS(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0) +#define EH_SPEC_RAISES(NODE) TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1) + +#define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0) + +/* Nonzero if this try block is a function try block. */ +#define FN_TRY_BLOCK_P(NODE) TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE)) +#define HANDLER_PARMS(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 0) +#define HANDLER_BODY(NODE) TREE_OPERAND (HANDLER_CHECK (NODE), 1) +#define HANDLER_TYPE(NODE) TREE_TYPE (HANDLER_CHECK (NODE)) + +/* CLEANUP_STMT accessors. The statement(s) covered, the cleanup to run + and the VAR_DECL for which this cleanup exists. */ +#define CLEANUP_BODY(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0) +#define CLEANUP_EXPR(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1) +#define CLEANUP_DECL(NODE) TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2) + +/* IF_STMT accessors. These give access to the condition of the if + statement, the then block of the if statement, and the else block + of the if statement if it exists. */ +#define IF_COND(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 0) +#define THEN_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 1) +#define ELSE_CLAUSE(NODE) TREE_OPERAND (IF_STMT_CHECK (NODE), 2) + +/* WHILE_STMT accessors. These give access to the condition of the + while statement and the body of the while statement, respectively. */ +#define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0) +#define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1) + +/* DO_STMT accessors. These give access to the condition of the do + statement and the body of the do statement, respectively. */ +#define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0) +#define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1) + +/* FOR_STMT accessors. These give access to the init statement, + condition, update expression, and body of the for statement, + respectively. */ +#define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0) +#define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1) +#define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2) +#define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3) + +/* RANGE_FOR_STMT accessors. These give access to the declarator, + expression and body of the statement, respectively. */ +#define RANGE_FOR_DECL(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0) +#define RANGE_FOR_EXPR(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1) +#define RANGE_FOR_BODY(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2) + +#define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0) +#define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1) +#define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2) + +/* STMT_EXPR accessor. */ +#define STMT_EXPR_STMT(NODE) TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0) + +/* EXPR_STMT accessor. This gives the expression associated with an + expression statement. */ +#define EXPR_STMT_EXPR(NODE) TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0) + +/* True if this TARGET_EXPR was created by build_cplus_new, and so we can + discard it if it isn't useful. */ +#define TARGET_EXPR_IMPLICIT_P(NODE) \ + TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE)) + +/* True if this TARGET_EXPR is the result of list-initialization of a + temporary. */ +#define TARGET_EXPR_LIST_INIT_P(NODE) \ + TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE)) + +/* True if this TARGET_EXPR expresses direct-initialization of an object + to be named later. */ +#define TARGET_EXPR_DIRECT_INIT_P(NODE) \ + TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE)) + +/* True if EXPR expresses direct-initialization of a TYPE. */ +#define DIRECT_INIT_EXPR_P(TYPE,EXPR) \ + (TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR) \ + && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR))) + +/* An enumeration of the kind of tags that C++ accepts. */ +enum tag_types { + none_type = 0, /* Not a tag type. */ + record_type, /* "struct" types. */ + class_type, /* "class" types. */ + union_type, /* "union" types. */ + enum_type, /* "enum" types. */ + typename_type /* "typename" types. */ +}; + +/* The various kinds of lvalues we distinguish. */ +enum cp_lvalue_kind_flags { + clk_none = 0, /* Things that are not an lvalue. */ + clk_ordinary = 1, /* An ordinary lvalue. */ + clk_rvalueref = 2,/* An rvalue formed using an rvalue reference */ + clk_class = 4, /* An rvalue of class-type. */ + clk_bitfield = 8, /* An lvalue for a bit-field. */ + clk_packed = 16 /* An lvalue for a packed field. */ +}; + +/* This type is used for parameters and variables which hold + combinations of the flags in enum cp_lvalue_kind_flags. */ +typedef int cp_lvalue_kind; + +/* Various kinds of template specialization, instantiation, etc. */ +typedef enum tmpl_spec_kind { + tsk_none, /* Not a template at all. */ + tsk_invalid_member_spec, /* An explicit member template + specialization, but the enclosing + classes have not all been explicitly + specialized. */ + tsk_invalid_expl_inst, /* An explicit instantiation containing + template parameter lists. */ + tsk_excessive_parms, /* A template declaration with too many + template parameter lists. */ + tsk_insufficient_parms, /* A template declaration with too few + parameter lists. */ + tsk_template, /* A template declaration. */ + tsk_expl_spec, /* An explicit specialization. */ + tsk_expl_inst /* An explicit instantiation. */ +} tmpl_spec_kind; + +/* The various kinds of access. BINFO_ACCESS depends on these being + two bit quantities. The numerical values are important; they are + used to initialize RTTI data structures, so changing them changes + the ABI. */ +typedef enum access_kind { + ak_none = 0, /* Inaccessible. */ + ak_public = 1, /* Accessible, as a `public' thing. */ + ak_protected = 2, /* Accessible, as a `protected' thing. */ + ak_private = 3 /* Accessible, as a `private' thing. */ +} access_kind; + +/* The various kinds of special functions. If you add to this list, + you should update special_function_p as well. */ +typedef enum special_function_kind { + sfk_none = 0, /* Not a special function. This enumeral + must have value zero; see + special_function_p. */ + sfk_constructor, /* A constructor. */ + sfk_copy_constructor, /* A copy constructor. */ + sfk_move_constructor, /* A move constructor. */ + sfk_copy_assignment, /* A copy assignment operator. */ + sfk_move_assignment, /* A move assignment operator. */ + sfk_destructor, /* A destructor. */ + sfk_complete_destructor, /* A destructor for complete objects. */ + sfk_base_destructor, /* A destructor for base subobjects. */ + sfk_deleting_destructor, /* A destructor for complete objects that + deletes the object after it has been + destroyed. */ + sfk_conversion /* A conversion operator. */ +} special_function_kind; + +/* The various kinds of linkage. From [basic.link], + + A name is said to have linkage when it might denote the same + object, reference, function, type, template, namespace or value + as a name introduced in another scope: + + -- When a name has external linkage, the entity it denotes can + be referred to from scopes of other translation units or from + other scopes of the same translation unit. + + -- When a name has internal linkage, the entity it denotes can + be referred to by names from other scopes in the same + translation unit. + + -- When a name has no linkage, the entity it denotes cannot be + referred to by names from other scopes. */ + +typedef enum linkage_kind { + lk_none, /* No linkage. */ + lk_internal, /* Internal linkage. */ + lk_external /* External linkage. */ +} linkage_kind; + +typedef enum duration_kind { + dk_static, + dk_thread, + dk_auto, + dk_dynamic +} duration_kind; + +/* Bitmask flags to control type substitution. */ +enum tsubst_flags { + tf_none = 0, /* nothing special */ + tf_error = 1 << 0, /* give error messages */ + tf_warning = 1 << 1, /* give warnings too */ + tf_ignore_bad_quals = 1 << 2, /* ignore bad cvr qualifiers */ + tf_keep_type_decl = 1 << 3, /* retain typedef type decls + (make_typename_type use) */ + tf_ptrmem_ok = 1 << 4, /* pointers to member ok (internal + instantiate_type use) */ + tf_user = 1 << 5, /* found template must be a user template + (lookup_template_class use) */ + tf_conv = 1 << 6, /* We are determining what kind of + conversion might be permissible, + not actually performing the + conversion. */ + tf_no_access_control = 1 << 7, /* Do not perform access checks, even + when issuing other errors. */ + /* Convenient substitution flags combinations. */ + tf_warning_or_error = tf_warning | tf_error +}; + +/* This type is used for parameters and variables which hold + combinations of the flags in enum tsubst_flags. */ +typedef int tsubst_flags_t; + +/* The kind of checking we can do looking in a class hierarchy. */ +enum base_access_flags { + ba_any = 0, /* Do not check access, allow an ambiguous base, + prefer a non-virtual base */ + ba_unique = 1 << 0, /* Must be a unique base. */ + ba_check_bit = 1 << 1, /* Check access. */ + ba_check = ba_unique | ba_check_bit, + ba_ignore_scope = 1 << 2, /* Ignore access allowed by local scope. */ + ba_quiet = 1 << 3 /* Do not issue error messages. */ +}; + +/* This type is used for parameters and variables which hold + combinations of the flags in enum base_access_flags. */ +typedef int base_access; + +/* The various kinds of access check during parsing. */ +typedef enum deferring_kind { + dk_no_deferred = 0, /* Check access immediately */ + dk_deferred = 1, /* Deferred check */ + dk_no_check = 2 /* No access check */ +} deferring_kind; + +/* The kind of base we can find, looking in a class hierarchy. + Values <0 indicate we failed. */ +typedef enum base_kind { + bk_inaccessible = -3, /* The base is inaccessible */ + bk_ambig = -2, /* The base is ambiguous */ + bk_not_base = -1, /* It is not a base */ + bk_same_type = 0, /* It is the same type */ + bk_proper_base = 1, /* It is a proper base */ + bk_via_virtual = 2 /* It is a proper base, but via a virtual + path. This might not be the canonical + binfo. */ +} base_kind; + +/* Node for "pointer to (virtual) function". + This may be distinct from ptr_type_node so gdb can distinguish them. */ +#define vfunc_ptr_type_node vtable_entry_type + + +/* For building calls to `delete'. */ +extern GTY(()) tree integer_two_node; + +/* The number of function bodies which we are currently processing. + (Zero if we are at namespace scope, one inside the body of a + function, two inside the body of a function in a local class, etc.) */ +extern int function_depth; + +/* In parser.c. */ + +/* Nonzero if we are parsing an unevaluated operand: an operand to + sizeof, typeof, or alignof. This is a count since operands to + sizeof can be nested. */ + +extern int cp_unevaluated_operand; +extern tree cp_convert_range_for (tree, tree, tree); + +/* in pt.c */ + +/* These values are used for the `STRICT' parameter to type_unification and + fn_type_unification. Their meanings are described with the + documentation for fn_type_unification. */ + +typedef enum unification_kind_t { + DEDUCE_CALL, + DEDUCE_CONV, + DEDUCE_EXACT +} unification_kind_t; + +/* in class.c */ + +extern int current_class_depth; + +/* An array of all local classes present in this translation unit, in + declaration order. */ +extern GTY(()) VEC(tree,gc) *local_classes; + +/* Here's where we control how name mangling takes place. */ + +/* Cannot use '$' up front, because this confuses gdb + (names beginning with '$' are gdb-local identifiers). + + Note that all forms in which the '$' is significant are long enough + for direct indexing (meaning that if we know there is a '$' + at a particular location, we can index into the string at + any other location that provides distinguishing characters). */ + +/* Define NO_DOT_IN_LABEL in your favorite tm file if your assembler + doesn't allow '.' in symbol names. */ +#ifndef NO_DOT_IN_LABEL + +#define JOINER '.' + +#define AUTO_TEMP_NAME "_.tmp_" +#define VFIELD_BASE ".vf" +#define VFIELD_NAME "_vptr." +#define VFIELD_NAME_FORMAT "_vptr.%s" + +#define ANON_AGGRNAME_FORMAT "._%d" + +#else /* NO_DOT_IN_LABEL */ + +#ifndef NO_DOLLAR_IN_LABEL + +#define JOINER '$' + +#define AUTO_TEMP_NAME "_$tmp_" +#define VFIELD_BASE "$vf" +#define VFIELD_NAME "_vptr$" +#define VFIELD_NAME_FORMAT "_vptr$%s" +#define ANON_AGGRNAME_FORMAT "$_%d" + +#else /* NO_DOLLAR_IN_LABEL */ + +#define IN_CHARGE_NAME "__in_chrg" +#define AUTO_TEMP_NAME "__tmp_" +#define TEMP_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \ + sizeof (AUTO_TEMP_NAME) - 1)) +#define VTABLE_NAME "__vt_" +#define VTABLE_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \ + sizeof (VTABLE_NAME) - 1)) +#define VFIELD_BASE "__vfb" +#define VFIELD_NAME "__vptr_" +#define VFIELD_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \ + sizeof (VFIELD_NAME) - 1)) +#define VFIELD_NAME_FORMAT "__vptr_%s" + +#define ANON_AGGRNAME_PREFIX "__anon_" +#define ANON_AGGRNAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \ + sizeof (ANON_AGGRNAME_PREFIX) - 1)) +#define ANON_AGGRNAME_FORMAT "__anon_%d" + +#endif /* NO_DOLLAR_IN_LABEL */ +#endif /* NO_DOT_IN_LABEL */ + +#define THIS_NAME "this" + +#define IN_CHARGE_NAME "__in_chrg" + +#define VTBL_PTR_TYPE "__vtbl_ptr_type" +#define VTABLE_DELTA_NAME "__delta" +#define VTABLE_PFN_NAME "__pfn" + +#define LAMBDANAME_PREFIX "__lambda" +#define LAMBDANAME_FORMAT LAMBDANAME_PREFIX "%d" +#define LAMBDANAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), \ + LAMBDANAME_PREFIX, \ + sizeof (LAMBDANAME_PREFIX) - 1)) + +#if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) + +#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ + && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \ + && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) + +#define TEMP_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1)) +#define VFIELD_NAME_P(ID_NODE) \ + (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1)) + +/* For anonymous aggregate types, we need some sort of name to + hold on to. In practice, this should not appear, but it should + not be harmful if it does. */ +#define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ + && IDENTIFIER_POINTER (ID_NODE)[1] == '_') +#endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */ + + +/* Nonzero if we're done parsing and into end-of-file activities. */ + +extern int at_eof; + +/* A list of namespace-scope objects which have constructors or + destructors which reside in the global scope. The decl is stored + in the TREE_VALUE slot and the initializer is stored in the + TREE_PURPOSE slot. */ +extern GTY(()) tree static_aggregates; + +enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG }; + +/* These are uses as bits in flags passed to various functions to + control their behavior. Despite the LOOKUP_ prefix, many of these + do not control name lookup. ??? Functions using these flags should + probably be modified to accept explicit boolean flags for the + behaviors relevant to them. */ +/* Check for access violations. */ +#define LOOKUP_PROTECT (1 << 0) +/* Complain if no suitable member function matching the arguments is + found. */ +#define LOOKUP_COMPLAIN (1 << 1) +#define LOOKUP_NORMAL (LOOKUP_PROTECT | LOOKUP_COMPLAIN) +/* Even if the function found by lookup is a virtual function, it + should be called directly. */ +#define LOOKUP_NONVIRTUAL (1 << 2) +/* Non-converting (i.e., "explicit") constructors are not tried. This flag + indicates that we are not performing direct-initialization. */ +#define LOOKUP_ONLYCONVERTING (1 << 3) +#define LOOKUP_IMPLICIT (LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING) +/* If a temporary is created, it should be created so that it lives + as long as the current variable bindings; otherwise it only lives + until the end of the complete-expression. It also forces + direct-initialization in cases where other parts of the compiler + have already generated a temporary, such as reference + initialization and the catch parameter. */ +#define DIRECT_BIND (1 << 4) +/* We're performing a user-defined conversion, so more user-defined + conversions are not permitted (only built-in conversions). */ +#define LOOKUP_NO_CONVERSION (1 << 5) +/* The user has explicitly called a destructor. (Therefore, we do + not need to check that the object is non-NULL before calling the + destructor.) */ +#define LOOKUP_DESTRUCTOR (1 << 6) +/* Do not permit references to bind to temporaries. */ +#define LOOKUP_NO_TEMP_BIND (1 << 7) +/* Do not accept objects, and possibly namespaces. */ +#define LOOKUP_PREFER_TYPES (1 << 8) +/* Do not accept objects, and possibly types. */ +#define LOOKUP_PREFER_NAMESPACES (1 << 9) +/* Accept types or namespaces. */ +#define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES) +/* Return friend declarations and un-declared builtin functions. + (Normally, these entities are registered in the symbol table, but + not found by lookup.) */ +#define LOOKUP_HIDDEN (LOOKUP_PREFER_NAMESPACES << 1) +/* Prefer that the lvalue be treated as an rvalue. */ +#define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1) +/* We're inside an init-list, so narrowing conversions are ill-formed. */ +#define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1) +/* Avoid user-defined conversions for the first parameter of a copy + constructor (or move constructor). */ +#define LOOKUP_NO_COPY_CTOR_CONVERSION (LOOKUP_NO_NARROWING << 1) +/* This is the first parameter of a copy constructor. */ +#define LOOKUP_COPY_PARM (LOOKUP_NO_COPY_CTOR_CONVERSION << 1) +/* We only want to consider list constructors. */ +#define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1) +/* Return after determining which function to call and checking access. + Used by sythesized_method_walk to determine which functions will + be called to initialize subobjects, in order to determine exception + specification and possible implicit delete. + This is kind of a hack, but since access control doesn't respect SFINAE + we can't just use tf_none to avoid access control errors, we need + another mechanism. Exiting early also avoids problems with trying + to perform argument conversions when the class isn't complete yet. */ +#define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1) +/* Used by calls from defaulted functions to limit the overload set to avoid + cycles trying to declare them (core issue 1092). */ +#define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1) +/* Used in calls to store_init_value to suppress its usual call to + digest_init. */ +#define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1) +/* An instantiation with explicit template arguments. */ +#define LOOKUP_EXPLICIT_TMPL_ARGS (LOOKUP_ALREADY_DIGESTED << 1) + +#define LOOKUP_NAMESPACES_ONLY(F) \ + (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES)) +#define LOOKUP_TYPES_ONLY(F) \ + (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES)) +#define LOOKUP_QUALIFIERS_ONLY(F) ((F) & LOOKUP_PREFER_BOTH) + + +/* These flags are used by the conversion code. + CONV_IMPLICIT : Perform implicit conversions (standard and user-defined). + CONV_STATIC : Perform the explicit conversions for static_cast. + CONV_CONST : Perform the explicit conversions for const_cast. + CONV_REINTERPRET: Perform the explicit conversions for reinterpret_cast. + CONV_PRIVATE : Perform upcasts to private bases. + CONV_FORCE_TEMP : Require a new temporary when converting to the same + aggregate type. */ + +#define CONV_IMPLICIT 1 +#define CONV_STATIC 2 +#define CONV_CONST 4 +#define CONV_REINTERPRET 8 +#define CONV_PRIVATE 16 +/* #define CONV_NONCONVERTING 32 */ +#define CONV_FORCE_TEMP 64 +#define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ + | CONV_REINTERPRET) +#define CONV_C_CAST (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \ + | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP) + +/* Used by build_expr_type_conversion to indicate which types are + acceptable as arguments to the expression under consideration. */ + +#define WANT_INT 1 /* integer types, including bool */ +#define WANT_FLOAT 2 /* floating point types */ +#define WANT_ENUM 4 /* enumerated types */ +#define WANT_POINTER 8 /* pointer types */ +#define WANT_NULL 16 /* null pointer constant */ +#define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */ +#define WANT_ARITH (WANT_INT | WANT_FLOAT | WANT_VECTOR_OR_COMPLEX) + +/* Used with comptypes, and related functions, to guide type + comparison. */ + +#define COMPARE_STRICT 0 /* Just check if the types are the + same. */ +#define COMPARE_BASE 1 /* Check to see if the second type is + derived from the first. */ +#define COMPARE_DERIVED 2 /* Like COMPARE_BASE, but in + reverse. */ +#define COMPARE_REDECLARATION 4 /* The comparison is being done when + another declaration of an existing + entity is seen. */ +#define COMPARE_STRUCTURAL 8 /* The comparison is intended to be + structural. The actual comparison + will be identical to + COMPARE_STRICT. */ + +/* Used with push_overloaded_decl. */ +#define PUSH_GLOBAL 0 /* Push the DECL into namespace scope, + regardless of the current scope. */ +#define PUSH_LOCAL 1 /* Push the DECL into the current + scope. */ +#define PUSH_USING 2 /* We are pushing this DECL as the + result of a using declaration. */ + +/* Used with start function. */ +#define SF_DEFAULT 0 /* No flags. */ +#define SF_PRE_PARSED 1 /* The function declaration has + already been parsed. */ +#define SF_INCLASS_INLINE 2 /* The function is an inline, defined + in the class body. */ + +/* Used with start_decl's initialized parameter. */ +#define SD_UNINITIALIZED 0 +#define SD_INITIALIZED 1 +#define SD_DEFAULTED 2 +#define SD_DELETED 3 + +/* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2 + is derived from TYPE1, or if TYPE2 is a pointer (reference) to a + class derived from the type pointed to (referred to) by TYPE1. */ +#define same_or_base_type_p(TYPE1, TYPE2) \ + comptypes ((TYPE1), (TYPE2), COMPARE_BASE) + +/* These macros are used to access a TEMPLATE_PARM_INDEX. */ +#define TEMPLATE_PARM_INDEX_CAST(NODE) \ + ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE)) +#define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index) +#define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level) +/* The Number of sibling parms this template parm has. */ +#define TEMPLATE_PARM_NUM_SIBLINGS(NODE) \ + (TEMPLATE_PARM_INDEX_CAST (NODE)->num_siblings) +#define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE)) +#define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level) +#define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl) +#define TEMPLATE_PARM_PARAMETER_PACK(NODE) \ + (TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE))) + +/* These macros are for accessing the fields of TEMPLATE_TYPE_PARM, + TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes. */ +#define TEMPLATE_TYPE_PARM_INDEX(NODE) \ + (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, \ + BOUND_TEMPLATE_TEMPLATE_PARM))->type.values +#define TEMPLATE_TYPE_IDX(NODE) \ + (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_LEVEL(NODE) \ + (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \ + (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_DECL(NODE) \ + (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE))) +#define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \ + (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE))) + +/* These constants can used as bit flags in the process of tree formatting. + + TFF_PLAIN_IDENTIFIER: unqualified part of a name. + TFF_SCOPE: include the class and namespace scope of the name. + TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name. + TFF_DECL_SPECIFIERS: print decl-specifiers. + TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with + a class-key (resp. `enum'). + TFF_RETURN_TYPE: include function return type. + TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values. + TFF_EXCEPTION_SPECIFICATION: show function exception specification. + TFF_TEMPLATE_HEADER: show the template<...> header in a + template-declaration. + TFF_TEMPLATE_NAME: show only template-name. + TFF_EXPR_IN_PARENS: parenthesize expressions. + TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments. + TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the + top-level entity. + TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments + identical to their defaults. */ + +#define TFF_PLAIN_IDENTIFIER (0) +#define TFF_SCOPE (1) +#define TFF_CHASE_TYPEDEF (1 << 1) +#define TFF_DECL_SPECIFIERS (1 << 2) +#define TFF_CLASS_KEY_OR_ENUM (1 << 3) +#define TFF_RETURN_TYPE (1 << 4) +#define TFF_FUNCTION_DEFAULT_ARGUMENTS (1 << 5) +#define TFF_EXCEPTION_SPECIFICATION (1 << 6) +#define TFF_TEMPLATE_HEADER (1 << 7) +#define TFF_TEMPLATE_NAME (1 << 8) +#define TFF_EXPR_IN_PARENS (1 << 9) +#define TFF_NO_FUNCTION_ARGUMENTS (1 << 10) +#define TFF_UNQUALIFIED_NAME (1 << 11) +#define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS (1 << 12) + +/* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM + node. */ +#define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE) \ + ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM) \ + ? TYPE_TI_TEMPLATE (NODE) \ + : TYPE_NAME (NODE)) + +/* in lex.c */ + +extern void init_reswords (void); + +typedef struct GTY(()) operator_name_info_t { + /* The IDENTIFIER_NODE for the operator. */ + tree identifier; + /* The name of the operator. */ + const char *name; + /* The mangled name of the operator. */ + const char *mangled_name; + /* The arity of the operator. */ + int arity; +} operator_name_info_t; + +/* A mapping from tree codes to operator name information. */ +extern GTY(()) operator_name_info_t operator_name_info + [(int) MAX_TREE_CODES]; +/* Similar, but for assignment operators. */ +extern GTY(()) operator_name_info_t assignment_operator_name_info + [(int) MAX_TREE_CODES]; + +/* A type-qualifier, or bitmask therefore, using the TYPE_QUAL + constants. */ + +typedef int cp_cv_quals; + +/* A storage class. */ + +typedef enum cp_storage_class { + /* sc_none must be zero so that zeroing a cp_decl_specifier_seq + sets the storage_class field to sc_none. */ + sc_none = 0, + sc_auto, + sc_register, + sc_static, + sc_extern, + sc_mutable +} cp_storage_class; + +/* An individual decl-specifier. */ + +typedef enum cp_decl_spec { + ds_first, + ds_signed = ds_first, + ds_unsigned, + ds_short, + ds_long, + ds_const, + ds_volatile, + ds_restrict, + ds_inline, + ds_virtual, + ds_explicit, + ds_friend, + ds_typedef, + ds_constexpr, + ds_complex, + ds_thread, + ds_last +} cp_decl_spec; + +/* A decl-specifier-seq. */ + +typedef struct cp_decl_specifier_seq { + /* The number of times each of the keywords has been seen. */ + unsigned specs[(int) ds_last]; + /* The location of the primary type. Mainly used for error + reporting. */ + location_t type_location; + /* The primary type, if any, given by the decl-specifier-seq. + Modifiers, like "short", "const", and "unsigned" are not + reflected here. This field will be a TYPE, unless a typedef-name + was used, in which case it will be a TYPE_DECL. */ + tree type; + /* The attributes, if any, provided with the specifier sequence. */ + tree attributes; + /* If non-NULL, a built-in type that the user attempted to redefine + to some other type. */ + tree redefined_builtin_type; + /* The storage class specified -- or sc_none if no storage class was + explicitly specified. */ + cp_storage_class storage_class; + /* True iff TYPE_SPEC indicates a user-defined type. */ + BOOL_BITFIELD user_defined_type_p : 1; + /* True iff multiple types were (erroneously) specified for this + decl-specifier-seq. */ + BOOL_BITFIELD multiple_types_p : 1; + /* True iff multiple storage classes were (erroneously) specified + for this decl-specifier-seq or a combination of a storage class + with a typedef specifier. */ + BOOL_BITFIELD conflicting_specifiers_p : 1; + /* True iff at least one decl-specifier was found. */ + BOOL_BITFIELD any_specifiers_p : 1; + /* True iff at least one type-specifier was found. */ + BOOL_BITFIELD any_type_specifiers_p : 1; + /* True iff "int" was explicitly provided. */ + BOOL_BITFIELD explicit_int_p : 1; + /* True iff "__int128" was explicitly provided. */ + BOOL_BITFIELD explicit_int128_p : 1; + /* True iff "char" was explicitly provided. */ + BOOL_BITFIELD explicit_char_p : 1; +} cp_decl_specifier_seq; + +/* The various kinds of declarators. */ + +typedef enum cp_declarator_kind { + cdk_id, + cdk_function, + cdk_array, + cdk_pointer, + cdk_reference, + cdk_ptrmem, + cdk_error +} cp_declarator_kind; + +/* A declarator. */ + +typedef struct cp_declarator cp_declarator; + +typedef struct cp_parameter_declarator cp_parameter_declarator; + +/* A parameter, before it has been semantically analyzed. */ +struct cp_parameter_declarator { + /* The next parameter, or NULL_TREE if none. */ + cp_parameter_declarator *next; + /* The decl-specifiers-seq for the parameter. */ + cp_decl_specifier_seq decl_specifiers; + /* The declarator for the parameter. */ + cp_declarator *declarator; + /* The default-argument expression, or NULL_TREE, if none. */ + tree default_argument; + /* True iff this is the first parameter in the list and the + parameter sequence ends with an ellipsis. */ + bool ellipsis_p; +}; + +/* A declarator. */ +struct cp_declarator { + /* The kind of declarator. */ + ENUM_BITFIELD (cp_declarator_kind) kind : 4; + /* Whether we parsed an ellipsis (`...') just before the declarator, + to indicate this is a parameter pack. */ + BOOL_BITFIELD parameter_pack_p : 1; + location_t id_loc; /* Currently only set for cdk_id and cdk_function. */ + /* Attributes that apply to this declarator. */ + tree attributes; + /* For all but cdk_id and cdk_error, the contained declarator. For + cdk_id and cdk_error, guaranteed to be NULL. */ + cp_declarator *declarator; + union { + /* For identifiers. */ + struct { + /* If non-NULL, the qualifying scope (a NAMESPACE_DECL or + *_TYPE) for this identifier. */ + tree qualifying_scope; + /* The unqualified name of the entity -- an IDENTIFIER_NODE, + BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */ + tree unqualified_name; + /* If this is the name of a function, what kind of special + function (if any). */ + special_function_kind sfk; + } id; + /* For functions. */ + struct { + /* The parameters to the function as a TREE_LIST of decl/default. */ + tree parameters; + /* The cv-qualifiers for the function. */ + cp_cv_quals qualifiers; + /* The exception-specification for the function. */ + tree exception_specification; + /* The late-specified return type, if any. */ + tree late_return_type; + } function; + /* For arrays. */ + struct { + /* The bounds to the array. */ + tree bounds; + } array; + /* For cdk_pointer and cdk_ptrmem. */ + struct { + /* The cv-qualifiers for the pointer. */ + cp_cv_quals qualifiers; + /* For cdk_ptrmem, the class type containing the member. */ + tree class_type; + } pointer; + /* For cdk_reference */ + struct { + /* The cv-qualifiers for the reference. These qualifiers are + only used to diagnose ill-formed code. */ + cp_cv_quals qualifiers; + /* Whether this is an rvalue reference */ + bool rvalue_ref; + } reference; + } u; +}; + +/* A level of template instantiation. */ +struct GTY(()) tinst_level { + /* The immediately deeper level in the chain. */ + struct tinst_level *next; + + /* The original node. Can be either a DECL (for a function or static + data member) or a TYPE (for a class), depending on what we were + asked to instantiate. */ + tree decl; + + /* The location where the template is instantiated. */ + location_t locus; + + /* True if the location is in a system header. */ + bool in_system_header_p; +}; + +/* A parameter list indicating for a function with no parameters, + e.g "int f(void)". */ +extern cp_parameter_declarator *no_parameters; + +/* True if we saw "#pragma GCC java_exceptions". */ +extern bool pragma_java_exceptions; + +/* in call.c */ +extern bool check_dtor_name (tree, tree); + +extern tree build_conditional_expr (tree, tree, tree, + tsubst_flags_t); +extern tree build_addr_func (tree); +extern tree build_call_a (tree, int, tree*); +extern tree build_call_n (tree, int, ...); +extern bool null_ptr_cst_p (tree); +extern bool sufficient_parms_p (const_tree); +extern tree type_decays_to (tree); +extern tree build_user_type_conversion (tree, tree, int); +extern tree build_new_function_call (tree, VEC(tree,gc) **, bool, + tsubst_flags_t); +extern tree build_operator_new_call (tree, VEC(tree,gc) **, tree *, + tree *, tree *); +extern tree build_new_method_call (tree, tree, VEC(tree,gc) **, + tree, int, tree *, + tsubst_flags_t); +extern tree build_special_member_call (tree, tree, VEC(tree,gc) **, + tree, int, tsubst_flags_t); +extern tree build_new_op (enum tree_code, int, tree, + tree, tree, bool *, + tsubst_flags_t); +extern tree build_op_call (tree, VEC(tree,gc) **, + tsubst_flags_t); +extern tree build_op_delete_call (enum tree_code, tree, tree, bool, tree, tree); +extern bool can_convert (tree, tree); +extern bool can_convert_arg (tree, tree, tree, int); +extern bool can_convert_arg_bad (tree, tree, tree, int); +extern bool enforce_access (tree, tree, tree); +extern tree convert_default_arg (tree, tree, tree, int); +extern tree convert_arg_to_ellipsis (tree); +extern tree build_x_va_arg (tree, tree); +extern tree cxx_type_promotes_to (tree); +extern tree type_passed_as (tree); +extern tree convert_for_arg_passing (tree, tree); +extern bool is_properly_derived_from (tree, tree); +extern tree set_up_extended_ref_temp (tree, tree, tree *, tree *); +extern tree initialize_reference (tree, tree, tree, tree *, tsubst_flags_t); +extern tree make_temporary_var_for_ref_to_temp (tree, tree); +extern tree strip_top_quals (tree); +extern bool reference_related_p (tree, tree); +extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t); +extern tree perform_implicit_conversion_flags (tree, tree, tsubst_flags_t, int); +extern tree build_integral_nontype_arg_conv (tree, tree, tsubst_flags_t); +extern tree perform_direct_initialization_if_possible (tree, tree, bool, + tsubst_flags_t); +extern tree in_charge_arg_for_name (tree); +extern tree build_cxx_call (tree, int, tree *); +extern bool is_std_init_list (tree); +extern bool is_list_ctor (tree); +#ifdef ENABLE_CHECKING +extern void validate_conversion_obstack (void); +#endif /* ENABLE_CHECKING */ + +/* in class.c */ +extern tree build_vfield_ref (tree, tree); +extern tree build_base_path (enum tree_code, tree, + tree, int); +extern tree convert_to_base (tree, tree, bool, bool, + tsubst_flags_t); +extern tree convert_to_base_statically (tree, tree); +extern tree build_vtbl_ref (tree, tree); +extern tree build_vfn_ref (tree, tree); +extern tree get_vtable_decl (tree, int); +extern void resort_type_method_vec (void *, void *, + gt_pointer_operator, void *); +extern bool add_method (tree, tree, tree); +extern bool currently_open_class (tree); +extern tree currently_open_derived_class (tree); +extern tree current_nonlambda_class_type (void); +extern tree finish_struct (tree, tree); +extern void finish_struct_1 (tree); +extern int resolves_to_fixed_type_p (tree, int *); +extern void init_class_processing (void); +extern int is_empty_class (tree); +extern bool is_really_empty_class (tree); +extern void pushclass (tree); +extern void popclass (void); +extern void push_nested_class (tree); +extern void pop_nested_class (void); +extern int current_lang_depth (void); +extern void push_lang_context (tree); +extern void pop_lang_context (void); +extern tree instantiate_type (tree, tree, tsubst_flags_t); +extern void print_class_statistics (void); +extern void build_self_reference (void); +extern int same_signature_p (const_tree, const_tree); +extern void maybe_add_class_template_decl_list (tree, tree, int); +extern void unreverse_member_declarations (tree); +extern void invalidate_class_lookup_cache (void); +extern void maybe_note_name_used_in_class (tree, tree); +extern void note_name_declared_in_class (tree, tree); +extern tree get_vtbl_decl_for_binfo (tree); +extern void debug_class (tree); +extern void debug_thunks (tree); +extern tree cp_get_virtual_function_decl (tree, tree); +extern tree cp_fold_obj_type_ref (tree, tree); +extern bool cp_decl_is_base_field (tree); +extern bool cp_decl_is_constructor (tree); +extern bool cp_decl_is_destructor (tree); +extern int cp_decl_is_const_member_func (tree); +extern void set_linkage_according_to_type (tree, tree); +extern void determine_key_method (tree); +extern void check_for_override (tree, tree); +extern void push_class_stack (void); +extern void pop_class_stack (void); +extern bool type_has_user_nondefault_constructor (tree); +extern tree in_class_defaulted_default_constructor (tree); +extern bool user_provided_p (tree); +extern bool type_has_user_provided_constructor (tree); +extern bool type_has_user_provided_default_constructor (tree); +extern tree default_init_uninitialized_part (tree); +extern bool synthesized_default_constructor_is_constexpr (tree); +extern bool type_has_constexpr_default_constructor (tree); +extern bool type_has_virtual_destructor (tree); +extern bool type_has_move_constructor (tree); +extern bool type_has_move_assign (tree); +extern void defaulted_late_check (tree); +extern bool defaultable_fn_check (tree); +extern void fixup_type_variants (tree); +extern void fixup_attribute_variants (tree); +extern tree* decl_cloned_function_p (const_tree, bool); +extern void clone_function_decl (tree, int); +extern void adjust_clone_args (tree); + +/* in cvt.c */ +extern tree convert_to_reference (tree, tree, int, int, tree); +extern tree convert_from_reference (tree); +extern tree force_rvalue (tree); +extern tree ocp_convert (tree, tree, int, int); +extern tree cp_convert (tree, tree); +extern tree cp_convert_and_check (tree, tree); +extern tree cp_fold_convert (tree, tree); +extern tree convert_to_void (tree, impl_conv_void, + tsubst_flags_t); +extern tree convert_force (tree, tree, int); +extern tree build_expr_type_conversion (int, tree, bool); +extern tree type_promotes_to (tree); +extern tree perform_qualification_conversions (tree, tree); + +/* in name-lookup.c */ +extern tree pushdecl (tree); +extern tree pushdecl_maybe_friend (tree, bool); +extern void maybe_push_cleanup_level (tree); +extern tree pushtag (tree, tree, tag_scope); +extern tree make_anon_name (void); +extern tree pushdecl_top_level_maybe_friend (tree, bool); +extern tree pushdecl_top_level_and_finish (tree, tree); +extern tree check_for_out_of_scope_variable (tree); +extern void print_other_binding_stack (struct cp_binding_level *); +extern tree maybe_push_decl (tree); +extern tree current_decl_namespace (void); + +/* decl.c */ +extern tree poplevel (int, int, int); +extern void cxx_init_decl_processing (void); +enum cp_tree_node_structure_enum cp_tree_node_structure + (union lang_tree_node *); +extern void finish_scope (void); +extern void push_switch (tree); +extern void pop_switch (void); +extern tree make_lambda_name (void); +extern int decls_match (tree, tree); +extern tree duplicate_decls (tree, tree, bool); +extern tree declare_local_label (tree); +extern tree define_label (location_t, tree); +extern void check_goto (tree); +extern bool check_omp_return (void); +extern tree make_typename_type (tree, tree, enum tag_types, tsubst_flags_t); +extern tree make_unbound_class_template (tree, tree, tree, tsubst_flags_t); +extern tree build_library_fn_ptr (const char *, tree); +extern tree build_cp_library_fn_ptr (const char *, tree); +extern tree push_library_fn (tree, tree, tree); +extern tree push_void_library_fn (tree, tree); +extern tree push_throw_library_fn (tree, tree); +extern tree check_tag_decl (cp_decl_specifier_seq *); +extern tree shadow_tag (cp_decl_specifier_seq *); +extern tree groktypename (cp_decl_specifier_seq *, const cp_declarator *, bool); +extern tree start_decl (const cp_declarator *, cp_decl_specifier_seq *, int, tree, tree, tree *); +extern void start_decl_1 (tree, bool); +extern bool check_array_initializer (tree, tree, tree); +extern void cp_finish_decl (tree, tree, bool, tree, int); +extern int cp_complete_array_type (tree *, tree, bool); +extern tree build_ptrmemfunc_type (tree); +extern tree build_ptrmem_type (tree, tree); +/* the grokdeclarator prototype is in decl.h */ +extern tree build_this_parm (tree, cp_cv_quals); +extern int copy_fn_p (const_tree); +extern bool move_fn_p (const_tree); +extern tree get_scope_of_declarator (const cp_declarator *); +extern void grok_special_member_properties (tree); +extern int grok_ctor_properties (const_tree, const_tree); +extern bool grok_op_properties (tree, bool); +extern tree xref_tag (enum tag_types, tree, tag_scope, bool); +extern tree xref_tag_from_type (tree, tree, tag_scope); +extern bool xref_basetypes (tree, tree); +extern tree start_enum (tree, tree, tree, bool, bool *); +extern void finish_enum_value_list (tree); +extern void finish_enum (tree); +extern void build_enumerator (tree, tree, tree, location_t); +extern tree lookup_enumerator (tree, tree); +extern void start_preparsed_function (tree, tree, int); +extern int start_function (cp_decl_specifier_seq *, const cp_declarator *, tree); +extern tree begin_function_body (void); +extern void finish_function_body (tree); +extern tree outer_curly_brace_block (tree); +extern tree finish_function (int); +extern tree grokmethod (cp_decl_specifier_seq *, const cp_declarator *, tree); +extern void maybe_register_incomplete_var (tree); +extern void maybe_commonize_var (tree); +extern void complete_vars (tree); +extern void finish_stmt (void); +extern tree static_fn_type (tree); +extern void revert_static_member_fn (tree); +extern void fixup_anonymous_aggr (tree); +extern int check_static_variable_definition (tree, tree); +extern tree compute_array_index_type (tree, tree, tsubst_flags_t); +extern tree check_default_argument (tree, tree); +typedef int (*walk_namespaces_fn) (tree, void *); +extern int walk_namespaces (walk_namespaces_fn, + void *); +extern int wrapup_globals_for_namespace (tree, void *); +extern tree create_implicit_typedef (tree, tree); +extern int local_variable_p (const_tree); +extern tree register_dtor_fn (tree); +extern tmpl_spec_kind current_tmpl_spec_kind (int); +extern tree cp_fname_init (const char *, tree *); +extern tree cxx_builtin_function (tree decl); +extern tree cxx_builtin_function_ext_scope (tree decl); +extern tree check_elaborated_type_specifier (enum tag_types, tree, bool); +extern void warn_extern_redeclared_static (tree, tree); +extern tree cxx_comdat_group (tree); +extern bool cp_missing_noreturn_ok_p (tree); +extern void initialize_artificial_var (tree, VEC(constructor_elt,gc) *); +extern tree check_var_type (tree, tree); +extern tree reshape_init (tree, tree); +extern tree next_initializable_field (tree); + +extern bool defer_mark_used_calls; +extern GTY(()) VEC(tree, gc) *deferred_mark_used_calls; +extern tree finish_case_label (location_t, tree, tree); +extern tree cxx_maybe_build_cleanup (tree); + +/* in decl2.c */ +extern bool check_java_method (tree); +extern tree build_memfn_type (tree, tree, cp_cv_quals); +extern tree change_return_type (tree, tree); +extern void maybe_retrofit_in_chrg (tree); +extern void maybe_make_one_only (tree); +extern bool vague_linkage_p (tree); +extern void grokclassfn (tree, tree, + enum overload_flags); +extern tree grok_array_decl (tree, tree); +extern tree delete_sanity (tree, tree, bool, int); +extern tree check_classfn (tree, tree, tree); +extern void check_member_template (tree); +extern tree grokfield (const cp_declarator *, cp_decl_specifier_seq *, + tree, bool, tree, tree); +extern tree grokbitfield (const cp_declarator *, cp_decl_specifier_seq *, + tree, tree); +extern tree cp_reconstruct_complex_type (tree, tree); +extern void cplus_decl_attributes (tree *, tree, int); +extern void finish_anon_union (tree); +extern void cp_write_global_declarations (void); +extern void cp_process_pending_declarations (location_t); +extern void cp_clear_deferred_fns (void); +extern void cp_clear_conv_type_map (void); +extern tree coerce_new_type (tree); +extern tree coerce_delete_type (tree); +extern void comdat_linkage (tree); +extern void determine_visibility (tree); +extern void constrain_class_visibility (tree); +extern void import_export_decl (tree); +extern tree build_cleanup (tree); +extern tree build_offset_ref_call_from_tree (tree, VEC(tree,gc) **); +extern bool decl_constant_var_p (tree); +extern bool decl_maybe_constant_var_p (tree); +extern void check_default_args (tree); +extern void mark_used (tree); +extern void finish_static_data_member_decl (tree, tree, bool, tree, int); +extern tree cp_build_parm_decl (tree, tree); +extern tree get_guard (tree); +extern tree get_guard_cond (tree); +extern tree set_guard (tree); +extern tree cxx_callgraph_analyze_expr (tree *, int *); +extern void mark_needed (tree); +extern bool decl_needed_p (tree); +extern void note_vague_linkage_fn (tree); +extern tree build_artificial_parm (tree, tree); +extern bool possibly_inlined_p (tree); +extern int parm_index (tree); + +/* in error.c */ +extern void init_error (void); +extern const char *type_as_string (tree, int); +extern const char *type_as_string_translate (tree, int); +extern const char *decl_as_string (tree, int); +extern const char *decl_as_string_translate (tree, int); +extern const char *expr_as_string (tree, int); +extern const char *lang_decl_name (tree, int, bool); +extern const char *language_to_string (enum languages); +extern const char *class_key_or_enum_as_string (tree); +extern void print_instantiation_context (void); +extern void maybe_warn_variadic_templates (void); +extern void maybe_warn_cpp0x (cpp0x_warn_str str); +extern bool pedwarn_cxx98 (location_t, int, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4); +extern location_t location_of (tree); +extern void qualified_name_lookup_error (tree, tree, tree, + location_t); + +/* in except.c */ +extern void init_exception_processing (void); +extern tree expand_start_catch_block (tree); +extern void expand_end_catch_block (void); +extern tree build_exc_ptr (void); +extern tree build_throw (tree); +extern int nothrow_libfn_p (const_tree); +extern void check_handlers (tree); +extern tree finish_noexcept_expr (tree, tsubst_flags_t); +extern void perform_deferred_noexcept_checks (void); +extern bool nothrow_spec_p (const_tree); +extern bool type_noexcept_p (const_tree); +extern bool type_throw_all_p (const_tree); +extern tree build_noexcept_spec (tree, int); +extern void choose_personality_routine (enum languages); +extern tree eh_type_info (tree); +extern tree begin_eh_spec_block (void); +extern void finish_eh_spec_block (tree, tree); +extern tree build_eh_type_type (tree); +extern tree cp_protect_cleanup_actions (void); + +/* in expr.c */ +extern tree cplus_expand_constant (tree); +extern tree mark_rvalue_use (tree); +extern tree mark_lvalue_use (tree); +extern tree mark_type_use (tree); +extern void mark_exp_read (tree); + +/* friend.c */ +extern int is_friend (tree, tree); +extern void make_friend_class (tree, tree, bool); +extern void add_friend (tree, tree, bool); +extern tree do_friend (tree, tree, tree, tree, enum overload_flags, bool); + +/* in init.c */ +extern tree expand_member_init (tree); +extern void emit_mem_initializers (tree); +extern tree build_aggr_init (tree, tree, int, + tsubst_flags_t); +extern int is_class_type (tree, int); +extern tree get_type_value (tree); +extern tree build_zero_init (tree, tree, bool); +extern tree build_value_init (tree, tsubst_flags_t); +extern tree build_value_init_noctor (tree, tsubst_flags_t); +extern tree build_offset_ref (tree, tree, bool); +extern tree build_new (VEC(tree,gc) **, tree, tree, + VEC(tree,gc) **, int, + tsubst_flags_t); +extern tree get_temp_regvar (tree, tree); +extern tree build_vec_init (tree, tree, tree, bool, int, + tsubst_flags_t); +extern tree build_delete (tree, tree, + special_function_kind, + int, int); +extern void push_base_cleanups (void); +extern tree build_vec_delete (tree, tree, + special_function_kind, int); +extern tree create_temporary_var (tree); +extern void initialize_vtbl_ptrs (tree); +extern tree build_java_class_ref (tree); +extern tree integral_constant_value (tree); +extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool); + +/* in lex.c */ +extern void cxx_dup_lang_specific_decl (tree); +extern void yyungetc (int, int); + +extern tree unqualified_name_lookup_error (tree); +extern tree unqualified_fn_lookup_error (tree); +extern tree build_lang_decl (enum tree_code, tree, tree); +extern tree build_lang_decl_loc (location_t, enum tree_code, tree, tree); +extern void retrofit_lang_decl (tree); +extern tree copy_decl (tree); +extern tree copy_type (tree); +extern tree cxx_make_type (enum tree_code); +extern tree make_class_type (enum tree_code); +extern bool cxx_init (void); +extern void cxx_finish (void); +extern bool in_main_input_context (void); + +/* in method.c */ +extern void init_method (void); +extern tree make_thunk (tree, bool, tree, tree); +extern void finish_thunk (tree); +extern void use_thunk (tree, bool); +extern bool trivial_fn_p (tree); +extern bool maybe_explain_implicit_delete (tree); +extern void synthesize_method (tree); +extern tree lazily_declare_fn (special_function_kind, + tree); +extern tree skip_artificial_parms_for (const_tree, tree); +extern int num_artificial_parms_for (const_tree); +extern tree make_alias_for (tree, tree); +extern tree get_copy_ctor (tree, tsubst_flags_t); +extern tree get_copy_assign (tree); +extern tree get_default_ctor (tree); +extern tree get_dtor (tree, tsubst_flags_t); +extern tree locate_ctor (tree); + +/* In optimize.c */ +extern bool maybe_clone_body (tree); + +/* in pt.c */ +extern bool check_template_shadow (tree); +extern tree get_innermost_template_args (tree, int); +extern void maybe_begin_member_template_processing (tree); +extern void maybe_end_member_template_processing (void); +extern tree finish_member_template_decl (tree); +extern void begin_template_parm_list (void); +extern bool begin_specialization (void); +extern void reset_specialization (void); +extern void end_specialization (void); +extern void begin_explicit_instantiation (void); +extern void end_explicit_instantiation (void); +extern tree check_explicit_specialization (tree, tree, int, int); +extern tree make_auto (void); +extern tree do_auto_deduction (tree, tree, tree); +extern tree type_uses_auto (tree); +extern void append_type_to_template_for_access_check (tree, tree, tree, + location_t); +extern tree splice_late_return_type (tree, tree); +extern bool is_auto (const_tree); +extern tree process_template_parm (tree, location_t, tree, + bool, bool, unsigned); +extern tree end_template_parm_list (tree); +void fixup_template_parms (void); +extern void end_template_decl (void); +extern tree maybe_update_decl_type (tree, tree); +extern bool check_default_tmpl_args (tree, tree, int, int, int); +extern tree push_template_decl (tree); +extern tree push_template_decl_real (tree, bool); +extern bool redeclare_class_template (tree, tree); +extern tree lookup_template_class (tree, tree, tree, tree, + int, tsubst_flags_t); +extern tree lookup_template_function (tree, tree); +extern int uses_template_parms (tree); +extern int uses_template_parms_level (tree, int); +extern tree instantiate_class_template (tree); +extern tree instantiate_template (tree, tree, tsubst_flags_t); +extern int fn_type_unification (tree, tree, tree, + const tree *, unsigned int, + tree, unification_kind_t, int); +extern void mark_decl_instantiated (tree, int); +extern int more_specialized_fn (tree, tree, int); +extern void do_decl_instantiation (tree, tree); +extern void do_type_instantiation (tree, tree, tsubst_flags_t); +extern bool always_instantiate_p (tree); +extern tree instantiate_decl (tree, int, bool); +extern int comp_template_parms (const_tree, const_tree); +extern bool uses_parameter_packs (tree); +extern bool template_parameter_pack_p (const_tree); +extern bool function_parameter_pack_p (const_tree); +extern bool function_parameter_expanded_from_pack_p (tree, tree); +extern tree make_pack_expansion (tree); +extern bool check_for_bare_parameter_packs (tree); +extern tree build_template_info (tree, tree); +extern tree get_template_info (const_tree); +extern VEC(qualified_typedef_usage_t,gc)* get_types_needing_access_check (tree); +extern int template_class_depth (tree); +extern int is_specialization_of (tree, tree); +extern bool is_specialization_of_friend (tree, tree); +extern tree get_pattern_parm (tree, tree); +extern int comp_template_args (tree, tree); +extern tree maybe_process_partial_specialization (tree); +extern tree most_specialized_instantiation (tree); +extern void print_candidates (tree); +extern void instantiate_pending_templates (int); +extern tree tsubst_default_argument (tree, tree, tree); +extern tree tsubst (tree, tree, tsubst_flags_t, tree); +extern tree tsubst_copy_and_build (tree, tree, tsubst_flags_t, + tree, bool, bool); +extern tree most_general_template (tree); +extern tree get_mostly_instantiated_function_type (tree); +extern int problematic_instantiation_changed (void); +extern void record_last_problematic_instantiation (void); +extern struct tinst_level *current_instantiation(void); +extern tree maybe_get_template_decl_from_type_decl (tree); +extern int processing_template_parmlist; +extern bool dependent_type_p (tree); +extern bool dependent_scope_p (tree); +extern bool any_dependent_template_arguments_p (const_tree); +extern bool dependent_template_p (tree); +extern bool dependent_template_id_p (tree, tree); +extern bool type_dependent_expression_p (tree); +extern bool any_type_dependent_arguments_p (const VEC(tree,gc) *); +extern bool type_dependent_expression_p_push (tree); +extern bool value_dependent_expression_p (tree); +extern bool any_value_dependent_elements_p (const_tree); +extern bool dependent_omp_for_p (tree, tree, tree, tree); +extern tree resolve_typename_type (tree, bool); +extern tree template_for_substitution (tree); +extern tree build_non_dependent_expr (tree); +extern void make_args_non_dependent (VEC(tree,gc) *); +extern bool reregister_specialization (tree, tree, tree); +extern tree fold_non_dependent_expr (tree); +extern bool explicit_class_specialization_p (tree); +extern int push_tinst_level (tree); +extern void pop_tinst_level (void); +extern struct tinst_level *outermost_tinst_level(void); +extern bool parameter_of_template_p (tree, tree); +extern void init_template_processing (void); +extern void print_template_statistics (void); +bool template_template_parameter_p (const_tree); +extern bool primary_template_instantiation_p (const_tree); +extern tree get_primary_template_innermost_parameters (const_tree); +extern tree get_template_parms_at_level (tree, int); +extern tree get_template_innermost_arguments (const_tree); +extern tree get_template_argument_pack_elems (const_tree); +extern tree get_function_template_decl (const_tree); +extern tree resolve_nondeduced_context (tree); +extern hashval_t iterative_hash_template_arg (tree arg, hashval_t val); + +/* in repo.c */ +extern void init_repo (void); +extern int repo_emit_p (tree); +extern bool repo_export_class_p (const_tree); +extern void finish_repo (void); + +/* in rtti.c */ +/* A vector of all tinfo decls that haven't been emitted yet. */ +extern GTY(()) VEC(tree,gc) *unemitted_tinfo_decls; + +extern void init_rtti_processing (void); +extern tree build_typeid (tree); +extern tree get_tinfo_decl (tree); +extern tree get_typeid (tree); +extern tree build_headof (tree); +extern tree build_dynamic_cast (tree, tree, tsubst_flags_t); +extern void emit_support_tinfos (void); +extern bool emit_tinfo_decl (tree); + +/* in search.c */ +extern bool accessible_base_p (tree, tree, bool); +extern tree lookup_base (tree, tree, base_access, + base_kind *); +extern tree dcast_base_hint (tree, tree); +extern int accessible_p (tree, tree, bool); +extern tree lookup_field_1 (tree, tree, bool); +extern tree lookup_field (tree, tree, int, bool); +extern int lookup_fnfields_1 (tree, tree); +extern tree lookup_fnfields_slot (tree, tree); +extern int class_method_index_for_fn (tree, tree); +extern tree lookup_fnfields (tree, tree, int); +extern tree lookup_member (tree, tree, int, bool); +extern int look_for_overrides (tree, tree); +extern void get_pure_virtuals (tree); +extern void maybe_suppress_debug_info (tree); +extern void note_debug_info_needed (tree); +extern void print_search_statistics (void); +extern void reinit_search_statistics (void); +extern tree current_scope (void); +extern int at_function_scope_p (void); +extern bool at_class_scope_p (void); +extern bool at_namespace_scope_p (void); +extern tree context_for_name_lookup (tree); +extern tree lookup_conversions (tree); +extern tree binfo_from_vbase (tree); +extern tree binfo_for_vbase (tree, tree); +extern tree look_for_overrides_here (tree, tree); +#define dfs_skip_bases ((tree)1) +extern tree dfs_walk_all (tree, tree (*) (tree, void *), + tree (*) (tree, void *), void *); +extern tree dfs_walk_once (tree, tree (*) (tree, void *), + tree (*) (tree, void *), void *); +extern tree binfo_via_virtual (tree, tree); +extern tree build_baselink (tree, tree, tree, tree); +extern tree adjust_result_of_qualified_name_lookup + (tree, tree, tree); +extern tree copied_binfo (tree, tree); +extern tree original_binfo (tree, tree); +extern int shared_member_p (tree); + + +/* The representation of a deferred access check. */ + +typedef struct GTY(()) deferred_access_check { + /* The base class in which the declaration is referenced. */ + tree binfo; + /* The declaration whose access must be checked. */ + tree decl; + /* The declaration that should be used in the error message. */ + tree diag_decl; +} deferred_access_check; +DEF_VEC_O(deferred_access_check); +DEF_VEC_ALLOC_O(deferred_access_check,gc); + +/* in semantics.c */ +extern void push_deferring_access_checks (deferring_kind); +extern void resume_deferring_access_checks (void); +extern void stop_deferring_access_checks (void); +extern void pop_deferring_access_checks (void); +extern VEC (deferred_access_check,gc)* get_deferred_access_checks (void); +extern void pop_to_parent_deferring_access_checks (void); +extern void perform_access_checks (VEC (deferred_access_check,gc)*); +extern void perform_deferred_access_checks (void); +extern void perform_or_defer_access_check (tree, tree, tree); +extern bool speculative_access_check (tree, tree, tree, bool); +extern int stmts_are_full_exprs_p (void); +extern void init_cp_semantics (void); +extern tree do_poplevel (tree); +extern void add_decl_expr (tree); +extern tree finish_expr_stmt (tree); +extern tree begin_if_stmt (void); +extern void finish_if_stmt_cond (tree, tree); +extern tree finish_then_clause (tree); +extern void begin_else_clause (tree); +extern void finish_else_clause (tree); +extern void finish_if_stmt (tree); +extern tree begin_while_stmt (void); +extern void finish_while_stmt_cond (tree, tree); +extern void finish_while_stmt (tree); +extern tree begin_do_stmt (void); +extern void finish_do_body (tree); +extern void finish_do_stmt (tree, tree); +extern tree finish_return_stmt (tree); +extern tree begin_for_scope (tree *); +extern tree begin_for_stmt (tree, tree); +extern void finish_for_init_stmt (tree); +extern void finish_for_cond (tree, tree); +extern void finish_for_expr (tree, tree); +extern void finish_for_stmt (tree); +extern tree begin_range_for_stmt (tree, tree); +extern void finish_range_for_decl (tree, tree, tree); +extern void finish_range_for_stmt (tree); +extern tree finish_break_stmt (void); +extern tree finish_continue_stmt (void); +extern tree begin_switch_stmt (void); +extern void finish_switch_cond (tree, tree); +extern void finish_switch_stmt (tree); +extern tree finish_goto_stmt (tree); +extern tree begin_try_block (void); +extern void finish_try_block (tree); +extern void finish_handler_sequence (tree); +extern tree begin_function_try_block (tree *); +extern void finish_function_try_block (tree); +extern void finish_function_handler_sequence (tree, tree); +extern void finish_cleanup_try_block (tree); +extern tree begin_handler (void); +extern void finish_handler_parms (tree, tree); +extern void finish_handler (tree); +extern void finish_cleanup (tree, tree); +extern bool literal_type_p (tree); +extern tree validate_constexpr_fundecl (tree); +extern tree register_constexpr_fundef (tree, tree); +extern bool check_constexpr_ctor_body (tree, tree); +extern tree ensure_literal_type_for_constexpr_object (tree); +extern bool potential_constant_expression (tree); +extern bool potential_rvalue_constant_expression (tree); +extern bool require_potential_constant_expression (tree); +extern bool require_potential_rvalue_constant_expression (tree); +extern tree cxx_constant_value (tree); +extern tree maybe_constant_value (tree); +extern tree maybe_constant_init (tree); +extern bool is_sub_constant_expr (tree); +extern bool reduced_constant_expression_p (tree); +extern VEC(tree,heap)* cx_error_context (void); + +enum { + BCS_NO_SCOPE = 1, + BCS_TRY_BLOCK = 2, + BCS_FN_BODY = 4 +}; +extern tree begin_compound_stmt (unsigned int); + +extern void finish_compound_stmt (tree); +extern tree finish_asm_stmt (int, tree, tree, tree, tree, + tree); +extern tree finish_label_stmt (tree); +extern void finish_label_decl (tree); +extern tree finish_parenthesized_expr (tree); +extern tree finish_non_static_data_member (tree, tree, tree); +extern tree begin_stmt_expr (void); +extern tree finish_stmt_expr_expr (tree, tree); +extern tree finish_stmt_expr (tree, bool); +extern tree stmt_expr_value_expr (tree); +bool empty_expr_stmt_p (tree); +extern tree perform_koenig_lookup (tree, VEC(tree,gc) *, bool); +extern tree finish_call_expr (tree, VEC(tree,gc) **, bool, + bool, tsubst_flags_t); +extern tree finish_increment_expr (tree, enum tree_code); +extern tree finish_this_expr (void); +extern tree finish_pseudo_destructor_expr (tree, tree, tree); +extern tree finish_unary_op_expr (enum tree_code, tree); +extern tree finish_compound_literal (tree, tree); +extern tree finish_fname (tree); +extern void finish_translation_unit (void); +extern tree finish_template_type_parm (tree, tree); +extern tree finish_template_template_parm (tree, tree); +extern tree begin_class_definition (tree, tree); +extern void finish_template_decl (tree); +extern tree finish_template_type (tree, tree, int); +extern tree finish_base_specifier (tree, tree, bool); +extern void finish_member_declaration (tree); +extern tree finish_id_expression (tree, tree, tree, + cp_id_kind *, + bool, bool, bool *, + bool, bool, bool, bool, + const char **, + location_t); +extern tree finish_typeof (tree); +extern tree finish_offsetof (tree); +extern void finish_decl_cleanup (tree, tree); +extern void finish_eh_cleanup (tree); +extern void emit_associated_thunks (tree); +extern void finish_mem_initializers (tree); +extern tree check_template_template_default_arg (tree); +extern bool expand_or_defer_fn_1 (tree); +extern void expand_or_defer_fn (tree); +extern void add_typedef_to_current_template_for_access_check (tree, tree, + location_t); +extern void check_accessibility_of_qualified_id (tree, tree, tree); +extern tree finish_qualified_id_expr (tree, tree, bool, bool, + bool, bool); +extern void simplify_aggr_init_expr (tree *); +extern void finalize_nrv (tree *, tree, tree); +extern void note_decl_for_pch (tree); +extern tree finish_omp_clauses (tree); +extern void finish_omp_threadprivate (tree); +extern tree begin_omp_structured_block (void); +extern tree finish_omp_structured_block (tree); +extern tree begin_omp_parallel (void); +extern tree finish_omp_parallel (tree, tree); +extern tree begin_omp_task (void); +extern tree finish_omp_task (tree, tree); +extern tree finish_omp_for (location_t, tree, tree, + tree, tree, tree, tree, tree); +extern void finish_omp_atomic (enum tree_code, tree, tree); +extern void finish_omp_barrier (void); +extern void finish_omp_flush (void); +extern void finish_omp_taskwait (void); +extern bool cxx_omp_create_clause_info (tree, tree, bool, bool, bool); +extern tree baselink_for_fns (tree); +extern void finish_static_assert (tree, tree, location_t, + bool); +extern tree describable_type (tree); +extern tree finish_decltype_type (tree, bool, tsubst_flags_t); +extern tree finish_trait_expr (enum cp_trait_kind, tree, tree); +extern tree build_lambda_expr (void); +extern tree build_lambda_object (tree); +extern tree begin_lambda_type (tree); +extern tree lambda_capture_field_type (tree); +extern tree lambda_return_type (tree); +extern tree lambda_function (tree); +extern void apply_lambda_return_type (tree, tree); +extern tree add_capture (tree, tree, tree, bool, bool); +extern tree add_default_capture (tree, tree, tree); +extern void register_capture_members (tree); +extern tree lambda_expr_this_capture (tree); +extern tree nonlambda_method_basetype (void); +extern void maybe_add_lambda_conv_op (tree); + +/* in tree.c */ +void cp_free_lang_data (tree t); +extern tree force_target_expr (tree, tree); +extern tree build_target_expr_with_type (tree, tree); +extern void lang_check_failed (const char *, int, + const char *) ATTRIBUTE_NORETURN; +extern tree stabilize_expr (tree, tree *); +extern void stabilize_call (tree, tree *); +extern void stabilize_aggr_init (tree, tree *); +extern bool stabilize_init (tree, tree *); +extern tree add_stmt_to_compound (tree, tree); +extern void init_tree (void); +extern bool pod_type_p (const_tree); +extern bool layout_pod_type_p (const_tree); +extern bool std_layout_type_p (const_tree); +extern bool trivial_type_p (const_tree); +extern bool trivially_copyable_p (const_tree); +extern bool type_has_nontrivial_default_init (const_tree); +extern bool type_has_nontrivial_copy_init (const_tree); +extern bool class_tmpl_impl_spec_p (const_tree); +extern int zero_init_p (const_tree); +extern tree strip_typedefs (tree); +extern tree copy_binfo (tree, tree, tree, + tree *, int); +extern int member_p (const_tree); +extern cp_lvalue_kind real_lvalue_p (const_tree); +extern cp_lvalue_kind lvalue_kind (const_tree); +extern bool lvalue_or_rvalue_with_address_p (const_tree); +extern bool builtin_valid_in_constant_expr_p (const_tree); +extern tree build_min (enum tree_code, tree, ...); +extern tree build_min_nt (enum tree_code, ...); +extern tree build_min_non_dep (enum tree_code, tree, ...); +extern tree build_min_non_dep_call_vec (tree, tree, VEC(tree,gc) *); +extern tree build_cplus_new (tree, tree); +extern tree build_aggr_init_expr (tree, tree); +extern tree get_target_expr (tree); +extern tree build_cplus_array_type (tree, tree); +extern tree build_array_of_n_type (tree, int); +extern tree build_array_copy (tree); +extern tree build_vec_init_expr (tree, tree); +extern void diagnose_non_constexpr_vec_init (tree); +extern tree hash_tree_cons (tree, tree, tree); +extern tree hash_tree_chain (tree, tree); +extern tree build_qualified_name (tree, tree, tree, bool); +extern int is_overloaded_fn (tree); +extern tree get_fns (tree); +extern tree get_first_fn (tree); +extern tree ovl_cons (tree, tree); +extern tree build_overload (tree, tree); +extern bool non_static_member_function_p (tree); +extern const char *cxx_printable_name (tree, int); +extern const char *cxx_printable_name_translate (tree, int); +extern tree build_exception_variant (tree, tree); +extern tree bind_template_template_parm (tree, tree); +extern tree array_type_nelts_total (tree); +extern tree array_type_nelts_top (tree); +extern tree break_out_target_exprs (tree); +extern tree get_type_decl (tree); +extern tree decl_namespace_context (tree); +extern bool decl_anon_ns_mem_p (const_tree); +extern tree lvalue_type (tree); +extern tree error_type (tree); +extern int varargs_function_p (const_tree); +extern bool really_overloaded_fn (tree); +extern bool cp_tree_equal (tree, tree); +extern tree no_linkage_check (tree, bool); +extern void debug_binfo (tree); +extern tree build_dummy_object (tree); +extern tree maybe_dummy_object (tree, tree *); +extern int is_dummy_object (const_tree); +extern const struct attribute_spec cxx_attribute_table[]; +extern tree make_ptrmem_cst (tree, tree); +extern tree cp_build_type_attribute_variant (tree, tree); +extern tree cp_build_reference_type (tree, bool); +extern tree move (tree); +extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t); +#define cp_build_qualified_type(TYPE, QUALS) \ + cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error) +extern bool cv_qualified_p (const_tree); +extern tree cv_unqualified (tree); +extern special_function_kind special_function_p (const_tree); +extern int count_trees (tree); +extern int char_type_p (tree); +extern void verify_stmt_tree (tree); +extern linkage_kind decl_linkage (tree); +extern duration_kind decl_storage_duration (tree); +extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn, + void*, struct pointer_set_t*); +#define cp_walk_tree(a,b,c,d) \ + walk_tree_1 (a, b, c, d, cp_walk_subtrees) +#define cp_walk_tree_without_duplicates(a,b,c) \ + walk_tree_without_duplicates_1 (a, b, c, cp_walk_subtrees) +extern tree fold_if_not_in_template (tree); +extern tree rvalue (tree); +extern tree convert_bitfield_to_declared_type (tree); +extern tree cp_save_expr (tree); +extern bool cast_valid_in_integral_constant_expression_p (tree); +extern bool cxx_type_hash_eq (const_tree, const_tree); + +extern void cxx_print_statistics (void); + +/* in ptree.c */ +extern void cxx_print_xnode (FILE *, tree, int); +extern void cxx_print_decl (FILE *, tree, int); +extern void cxx_print_type (FILE *, tree, int); +extern void cxx_print_identifier (FILE *, tree, int); +extern void cxx_print_error_function (diagnostic_context *, + const char *, + struct diagnostic_info *); + +/* in typeck.c */ +extern bool cxx_mark_addressable (tree); +extern int string_conv_p (const_tree, const_tree, int); +extern tree cp_truthvalue_conversion (tree); +extern tree condition_conversion (tree); +extern tree require_complete_type (tree); +extern tree require_complete_type_sfinae (tree, tsubst_flags_t); +extern tree complete_type (tree); +extern tree complete_type_or_else (tree, tree); +extern tree complete_type_or_maybe_complain (tree, tree, tsubst_flags_t); +extern int type_unknown_p (const_tree); +enum { ce_derived, ce_normal, ce_exact }; +extern bool comp_except_specs (const_tree, const_tree, int); +extern bool comptypes (tree, tree, int); +extern bool same_type_ignoring_top_level_qualifiers_p (tree, tree); +extern bool compparms (const_tree, const_tree); +extern int comp_cv_qualification (const_tree, const_tree); +extern int comp_cv_qual_signature (tree, tree); +extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code, bool); +extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool); +extern tree cxx_sizeof_nowarn (tree); +extern tree is_bitfield_expr_with_lowered_type (const_tree); +extern tree unlowered_expr_type (const_tree); +extern tree decay_conversion (tree); +extern tree build_class_member_access_expr (tree, tree, tree, bool, + tsubst_flags_t); +extern tree finish_class_member_access_expr (tree, tree, bool, + tsubst_flags_t); +extern tree build_x_indirect_ref (tree, ref_operator, + tsubst_flags_t); +extern tree cp_build_indirect_ref (tree, ref_operator, + tsubst_flags_t); +extern tree build_array_ref (location_t, tree, tree); +extern tree cp_build_array_ref (location_t, tree, tree, + tsubst_flags_t); +extern tree get_member_function_from_ptrfunc (tree *, tree); +extern tree cp_build_function_call (tree, tree, tsubst_flags_t); +extern tree cp_build_function_call_nary (tree, tsubst_flags_t, ...) + ATTRIBUTE_SENTINEL; +extern tree cp_build_function_call_vec (tree, VEC(tree,gc) **, + tsubst_flags_t); +extern tree build_x_binary_op (enum tree_code, tree, + enum tree_code, tree, + enum tree_code, bool *, + tsubst_flags_t); +extern tree build_x_array_ref (tree, tree, tsubst_flags_t); +extern tree build_x_unary_op (enum tree_code, tree, + tsubst_flags_t); +extern tree cp_build_addr_expr (tree, tsubst_flags_t); +extern tree cp_build_addr_expr_strict (tree, tsubst_flags_t); +extern tree cp_build_unary_op (enum tree_code, tree, int, + tsubst_flags_t); +extern tree unary_complex_lvalue (enum tree_code, tree); +extern tree build_x_conditional_expr (tree, tree, tree, + tsubst_flags_t); +extern tree build_x_compound_expr_from_list (tree, expr_list_kind, + tsubst_flags_t); +extern tree build_x_compound_expr_from_vec (VEC(tree,gc) *, const char *); +extern tree build_x_compound_expr (tree, tree, tsubst_flags_t); +extern tree build_compound_expr (location_t, tree, tree); +extern tree cp_build_compound_expr (tree, tree, tsubst_flags_t); +extern tree build_static_cast (tree, tree, tsubst_flags_t); +extern tree build_reinterpret_cast (tree, tree, tsubst_flags_t); +extern tree build_const_cast (tree, tree, tsubst_flags_t); +extern tree build_c_cast (location_t, tree, tree); +extern tree cp_build_c_cast (tree, tree, tsubst_flags_t); +extern tree build_x_modify_expr (tree, enum tree_code, tree, + tsubst_flags_t); +extern tree cp_build_modify_expr (tree, enum tree_code, tree, + tsubst_flags_t); +extern tree convert_for_initialization (tree, tree, tree, int, + impl_conv_rhs, tree, int, + tsubst_flags_t); +extern int comp_ptr_ttypes (tree, tree); +extern bool comp_ptr_ttypes_const (tree, tree); +extern bool error_type_p (const_tree); +extern int ptr_reasonably_similar (const_tree, const_tree); +extern tree build_ptrmemfunc (tree, tree, int, bool, + tsubst_flags_t); +extern int cp_type_quals (const_tree); +extern int type_memfn_quals (const_tree); +extern tree apply_memfn_quals (tree, cp_cv_quals); +extern bool cp_has_mutable_p (const_tree); +extern bool at_least_as_qualified_p (const_tree, const_tree); +extern void cp_apply_type_quals_to_decl (int, tree); +extern tree build_ptrmemfunc1 (tree, tree, tree); +extern void expand_ptrmemfunc_cst (tree, tree *, tree *); +extern tree type_after_usual_arithmetic_conversions (tree, tree); +extern tree common_pointer_type (tree, tree); +extern tree composite_pointer_type (tree, tree, tree, tree, + composite_pointer_operation, + tsubst_flags_t); +extern tree merge_types (tree, tree); +extern tree strip_array_domain (tree); +extern tree check_return_expr (tree, bool *); +extern tree cp_build_binary_op (location_t, + enum tree_code, tree, tree, + tsubst_flags_t); +#define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) +extern tree build_ptrmemfunc_access_expr (tree, tree); +extern tree build_address (tree); +extern tree build_typed_address (tree, tree); +extern tree build_nop (tree, tree); +extern tree non_reference (tree); +extern tree lookup_anon_field (tree, tree); +extern bool invalid_nonstatic_memfn_p (const_tree, tsubst_flags_t); +extern tree convert_member_func_to_ptr (tree, tree); +extern tree convert_ptrmem (tree, tree, bool, bool, + tsubst_flags_t); +extern int lvalue_or_else (tree, enum lvalue_use, + tsubst_flags_t); +extern void check_template_keyword (tree); + +/* in typeck2.c */ +extern void require_complete_eh_spec_types (tree, tree); +extern void cxx_incomplete_type_diagnostic (const_tree, const_tree, diagnostic_t); +#undef cxx_incomplete_type_error +extern void cxx_incomplete_type_error (const_tree, const_tree); +#define cxx_incomplete_type_error(V,T) \ + (cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR)) +extern tree error_not_base_type (tree, tree); +extern tree binfo_or_else (tree, tree); +extern void cxx_readonly_error (tree, enum lvalue_use); +extern void complete_type_check_abstract (tree); +extern int abstract_virtuals_error (tree, tree); + +extern tree store_init_value (tree, tree, int); +extern void check_narrowing (tree, tree); +extern tree digest_init (tree, tree); +extern tree digest_init_flags (tree, tree, int); +extern tree build_scoped_ref (tree, tree, tree *); +extern tree build_x_arrow (tree); +extern tree build_m_component_ref (tree, tree); +extern tree build_functional_cast (tree, tree, tsubst_flags_t); +extern tree add_exception_specifier (tree, tree, int); +extern tree merge_exception_specifiers (tree, tree); + +/* in mangle.c */ +extern void init_mangle (void); +extern void mangle_decl (tree); +extern const char *mangle_type_string (tree); +extern tree mangle_typeinfo_for_type (tree); +extern tree mangle_typeinfo_string_for_type (tree); +extern tree mangle_vtbl_for_type (tree); +extern tree mangle_vtt_for_type (tree); +extern tree mangle_ctor_vtbl_for_type (tree, tree); +extern tree mangle_thunk (tree, int, tree, tree); +extern tree mangle_conv_op_name_for_type (tree); +extern tree mangle_guard_variable (tree); +extern tree mangle_ref_init_variable (tree); + +/* in dump.c */ +extern bool cp_dump_tree (void *, tree); + +/* In cp/cp-objcp-common.c. */ + +extern alias_set_type cxx_get_alias_set (tree); +extern bool cxx_warn_unused_global_decl (const_tree); +extern size_t cp_tree_size (enum tree_code); +extern bool cp_var_mod_type_p (tree, tree); +extern void cxx_initialize_diagnostics (diagnostic_context *); +extern int cxx_types_compatible_p (tree, tree); +extern void init_shadowed_var_for_decl (void); + +/* LIPO support. */ +extern bool cp_is_compiler_generated_type (tree); +extern void cp_clear_global_name_bindings (tree); +extern bool +cp_is_non_sharable_global_decl (tree, void *); +extern void cp_lipo_dup_lang_type (tree, tree); +extern void cp_lipo_copy_lang_type (tree, tree); +extern int cp_get_lang_decl_size (tree); +extern int cp_cmp_lang_type (tree, tree); +extern void cp_add_built_in_decl (tree); +extern void cp_save_built_in_decl_pre_parsing (void); +extern void cp_restore_built_in_decl_pre_parsing (void); +extern void cp_save_built_in_decl_post_parsing (void); +extern void cp_restore_built_in_decl_post_parsing (void); + + +/* in cp-gimplify.c */ +extern int cp_gimplify_expr (tree *, gimple_seq *, + gimple_seq *); +extern void cp_genericize (tree); +extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree); +extern tree cxx_omp_clause_default_ctor (tree, tree, tree); +extern tree cxx_omp_clause_copy_ctor (tree, tree, tree); +extern tree cxx_omp_clause_assign_op (tree, tree, tree); +extern tree cxx_omp_clause_dtor (tree, tree); +extern void cxx_omp_finish_clause (tree); +extern bool cxx_omp_privatize_by_reference (const_tree); + +/* in name-lookup.c */ +extern void suggest_alternatives_for (location_t, tree); + +/* -- end of C++ */ + +#endif /* ! GCC_CP_TREE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cxx-pretty-print.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cxx-pretty-print.h new file mode 100644 index 0000000..d12506e --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/cxx-pretty-print.h @@ -0,0 +1,78 @@ +/* Interface for the GNU C++ pretty-printer. + Copyright (C) 2003, 2004, 2005, 2007, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> + +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/>. */ + +#ifndef GCC_CXX_PRETTY_PRINT_H +#define GCC_CXX_PRETTY_PRINT_H + +#include "c-family/c-pretty-print.h" + +#undef pp_c_base +#define pp_c_base(PP) (&(PP)->c_base) + +typedef enum +{ + /* Ask for a qualified-id. */ + pp_cxx_flag_default_argument = 1 << pp_c_flag_last_bit + +} cxx_pretty_printer_flags; + +typedef struct +{ + c_pretty_printer c_base; + /* This is the enclosing scope of the entity being pretty-printed. */ + tree enclosing_scope; +} cxx_pretty_printer; + +#define pp_cxx_cv_qualifier_seq(PP, T) \ + pp_c_type_qualifier_list (pp_c_base (PP), T) + +#define pp_cxx_whitespace(PP) pp_c_whitespace (pp_c_base (PP)) +#define pp_cxx_left_paren(PP) pp_c_left_paren (pp_c_base (PP)) +#define pp_cxx_right_paren(PP) pp_c_right_paren (pp_c_base (PP)) +#define pp_cxx_left_brace(PP) pp_c_left_brace (pp_c_base (PP)) +#define pp_cxx_right_brace(PP) pp_c_right_brace (pp_c_base (PP)) +#define pp_cxx_left_bracket(PP) pp_c_left_bracket (pp_c_base (PP)) +#define pp_cxx_right_bracket(PP) pp_c_right_bracket (pp_c_base (PP)) +#define pp_cxx_dot(PP) pp_c_dot (pp_c_base (PP)) +#define pp_cxx_ampersand(PP) pp_c_ampersand (pp_c_base (PP)) +#define pp_cxx_star(PP) pp_c_star (pp_c_base (PP)) +#define pp_cxx_arrow(PP) pp_c_arrow (pp_c_base (PP)) +#define pp_cxx_semicolon(PP) pp_c_semicolon (pp_c_base (PP)) +#define pp_cxx_complement(PP) pp_c_complement (pp_c_base (PP)) + +#define pp_cxx_ws_string(PP, I) pp_c_ws_string (pp_c_base (PP), I) +#define pp_cxx_identifier(PP, I) pp_c_identifier (pp_c_base (PP), I) +#define pp_cxx_tree_identifier(PP, T) \ + pp_c_tree_identifier (pp_c_base (PP), T) + +void pp_cxx_pretty_printer_init (cxx_pretty_printer *); +void pp_cxx_begin_template_argument_list (cxx_pretty_printer *); +void pp_cxx_end_template_argument_list (cxx_pretty_printer *); +void pp_cxx_colon_colon (cxx_pretty_printer *); +void pp_cxx_separate_with (cxx_pretty_printer *, int); + +void pp_cxx_declaration (cxx_pretty_printer *, tree); +void pp_cxx_canonical_template_parameter (cxx_pretty_printer *, tree); +void pp_cxx_trait_expression (cxx_pretty_printer *, tree); +void pp_cxx_va_arg_expression (cxx_pretty_printer *, tree); +void pp_cxx_offsetof_expression (cxx_pretty_printer *, tree); + +#endif /* GCC_CXX_PRETTY_PRINT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/name-lookup.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/name-lookup.h new file mode 100644 index 0000000..1b70232 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cp/name-lookup.h @@ -0,0 +1,377 @@ +/* Declarations for C++ name lookup routines. + Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> + +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/>. */ + +#ifndef GCC_CP_NAME_LOOKUP_H +#define GCC_CP_NAME_LOOKUP_H + +#include "c-family/c-common.h" + +/* The type of dictionary used to map names to types declared at + a given scope. */ +typedef struct binding_table_s *binding_table; +typedef struct binding_entry_s *binding_entry; + +/* The type of a routine repeatedly called by binding_table_foreach. */ +typedef void (*bt_foreach_proc) (binding_entry, void *); + +struct GTY(()) binding_entry_s { + binding_entry chain; + tree name; + tree type; +}; + +/* These macros indicate the initial chains count for binding_table. */ +#define SCOPE_DEFAULT_HT_SIZE (1 << 3) +#define CLASS_SCOPE_HT_SIZE (1 << 3) +#define NAMESPACE_ORDINARY_HT_SIZE (1 << 5) +#define NAMESPACE_STD_HT_SIZE (1 << 8) +#define GLOBAL_SCOPE_HT_SIZE (1 << 8) + +extern void binding_table_foreach (binding_table, bt_foreach_proc, void *); +extern binding_entry binding_table_find (binding_table, tree); + +/* Datatype that represents binding established by a declaration between + a name and a C++ entity. */ +typedef struct cxx_binding cxx_binding; + +/* The datatype used to implement C++ scope. */ +typedef struct cp_binding_level cxx_scope; + +/* Nonzero if this binding is for a local scope, as opposed to a class + or namespace scope. */ +#define LOCAL_BINDING_P(NODE) ((NODE)->is_local) + +/* True if NODE->value is from a base class of the class which is + currently being defined. */ +#define INHERITED_VALUE_BINDING_P(NODE) ((NODE)->value_is_inherited) + +struct GTY(()) cxx_binding { + /* Link to chain together various bindings for this name. */ + cxx_binding *previous; + /* The non-type entity this name is bound to. */ + tree value; + /* The type entity this name is bound to. */ + tree type; + /* The scope at which this binding was made. */ + cxx_scope *scope; + unsigned value_is_inherited : 1; + unsigned is_local : 1; +}; + +/* Datatype used to temporarily save C++ bindings (for implicit + instantiations purposes and like). Implemented in decl.c. */ +typedef struct GTY(()) cxx_saved_binding { + /* The name of the current binding. */ + tree identifier; + /* The binding we're saving. */ + cxx_binding *binding; + tree real_type_value; +} cxx_saved_binding; + +DEF_VEC_O(cxx_saved_binding); +DEF_VEC_ALLOC_O(cxx_saved_binding,gc); + +extern tree identifier_type_value (tree); +extern void set_identifier_type_value (tree, tree); +extern void pop_binding (tree, tree); +extern void pop_global_binding (tree, cxx_binding*); +extern tree constructor_name (tree); +extern bool constructor_name_p (tree, tree); + +/* The kinds of scopes we recognize. */ +typedef enum scope_kind { + sk_block = 0, /* An ordinary block scope. This enumerator must + have the value zero because "cp_binding_level" + is initialized by using "memset" to set the + contents to zero, and the default scope kind + is "sk_block". */ + sk_cleanup, /* A scope for (pseudo-)scope for cleanup. It is + pseudo in that it is transparent to name lookup + activities. */ + sk_try, /* A try-block. */ + sk_catch, /* A catch-block. */ + sk_for, /* The scope of the variable declared in a + for-init-statement. */ + sk_function_parms, /* The scope containing function parameters. */ + sk_class, /* The scope containing the members of a class. */ + sk_scoped_enum, /* The scope containing the enumertors of a C++0x + scoped enumeration. */ + sk_namespace, /* The scope containing the members of a + namespace, including the global scope. */ + sk_template_parms, /* A scope for template parameters. */ + sk_template_spec, /* Like sk_template_parms, but for an explicit + specialization. Since, by definition, an + explicit specialization is introduced by + "template <>", this scope is always empty. */ + sk_omp /* An OpenMP structured block. */ +} scope_kind; + +/* The scope where the class/struct/union/enum tag applies. */ +typedef enum tag_scope { + ts_current = 0, /* Current scope only. This is for the + class-key identifier; + case mentioned in [basic.lookup.elab]/2, + or the class/enum definition + class-key identifier { ... }; */ + ts_global = 1, /* All scopes. This is the 3.4.1 + [basic.lookup.unqual] lookup mentioned + in [basic.lookup.elab]/2. */ + ts_within_enclosing_non_class = 2 /* Search within enclosing non-class + only, for friend class lookup + according to [namespace.memdef]/3 + and [class.friend]/9. */ +} tag_scope; + +typedef struct GTY(()) cp_class_binding { + cxx_binding base; + /* The bound name. */ + tree identifier; +} cp_class_binding; + +DEF_VEC_O(cp_class_binding); +DEF_VEC_ALLOC_O(cp_class_binding,gc); + +typedef struct GTY(()) cp_label_binding { + /* The bound LABEL_DECL. */ + tree label; + /* The previous IDENTIFIER_LABEL_VALUE. */ + tree prev_value; +} cp_label_binding; + +DEF_VEC_O(cp_label_binding); +DEF_VEC_ALLOC_O(cp_label_binding,gc); + +/* For each binding contour we allocate a binding_level structure + which records the names defined in that contour. + Contours include: + 0) the global one + 1) one for each function definition, + where internal declarations of the parameters appear. + 2) one for each compound statement, + to record its declarations. + + The current meaning of a name can be found by searching the levels + from the current one out to the global one. + + Off to the side, may be the class_binding_level. This exists only + to catch class-local declarations. It is otherwise nonexistent. + + Also there may be binding levels that catch cleanups that must be + run when exceptions occur. Thus, to see whether a name is bound in + the current scope, it is not enough to look in the + CURRENT_BINDING_LEVEL. You should use lookup_name_current_level + instead. */ + +/* Note that the information in the `names' component of the global contour + is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */ + +struct GTY(()) cp_binding_level { + /* A chain of _DECL nodes for all variables, constants, functions, + and typedef types. These are in the reverse of the order + supplied. There may be OVERLOADs on this list, too, but they + are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */ + tree names; + + /* Count of elements in names chain. */ + size_t names_size; + + /* A chain of NAMESPACE_DECL nodes. */ + tree namespaces; + + /* An array of static functions and variables (for namespaces only) */ + VEC(tree,gc) *static_decls; + + /* A list of USING_DECL nodes. */ + tree usings; + + /* A list of used namespaces. PURPOSE is the namespace, + VALUE the common ancestor with this binding_level's namespace. */ + tree using_directives; + + /* For the binding level corresponding to a class, the entities + declared in the class or its base classes. */ + VEC(cp_class_binding,gc) *class_shadowed; + + /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and + is used for all binding levels. The TREE_PURPOSE is the name of + the entity, the TREE_TYPE is the associated type. In addition + the TREE_VALUE is the IDENTIFIER_TYPE_VALUE before we entered + the class. */ + tree type_shadowed; + + /* Similar to class_shadowed, but for IDENTIFIER_LABEL_VALUE, and + used for all binding levels. */ + VEC(cp_label_binding,gc) *shadowed_labels; + + /* For each level (except not the global one), + a chain of BLOCK nodes for all the levels + that were entered and exited one level down. */ + tree blocks; + + /* The entity (namespace, class, function) the scope of which this + binding contour corresponds to. Otherwise NULL. */ + tree this_entity; + + /* The binding level which this one is contained in (inherits from). */ + struct cp_binding_level *level_chain; + + /* List of VAR_DECLS saved from a previous for statement. + These would be dead in ISO-conforming code, but might + be referenced in ARM-era code. */ + VEC(tree,gc) *dead_vars_from_for; + + /* STATEMENT_LIST for statements in this binding contour. + Only used at present for SK_CLEANUP temporary bindings. */ + tree statement_list; + + /* Binding depth at which this level began. */ + int binding_depth; + + /* The kind of scope that this object represents. However, a + SK_TEMPLATE_SPEC scope is represented with KIND set to + SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true. */ + ENUM_BITFIELD (scope_kind) kind : 4; + + /* True if this scope is an SK_TEMPLATE_SPEC scope. This field is + only valid if KIND == SK_TEMPLATE_PARMS. */ + BOOL_BITFIELD explicit_spec_p : 1; + + /* true means make a BLOCK for this level regardless of all else. */ + unsigned keep : 1; + + /* Nonzero if this level can safely have additional + cleanup-needing variables added to it. */ + unsigned more_cleanups_ok : 1; + unsigned have_cleanups : 1; + + /* 24 bits left to fill a 32-bit word. */ + }; + +/* The binding level currently in effect. */ + +#define current_binding_level \ + (*(cfun && cp_function_chain && cp_function_chain->bindings \ + ? &cp_function_chain->bindings \ + : &scope_chain->bindings)) + +/* The binding level of the current class, if any. */ + +#define class_binding_level scope_chain->class_bindings + +/* The tree node representing the global scope. */ +extern GTY(()) tree global_namespace; +extern GTY(()) tree global_scope_name; + +/* Indicates that there is a type value in some namespace, although + that is not necessarily in scope at the moment. */ + +extern GTY(()) tree global_type_node; + +/* True if SCOPE designates the global scope binding contour. */ +#define global_scope_p(SCOPE) \ + ((SCOPE) == NAMESPACE_LEVEL (global_namespace)) + +extern cxx_scope *leave_scope (void); +extern bool kept_level_p (void); +extern int global_bindings_p (void); +extern bool toplevel_bindings_p (void); +extern bool namespace_bindings_p (void); +extern bool template_parm_scope_p (void); +extern scope_kind innermost_scope_kind (void); +extern cxx_scope *begin_scope (scope_kind, tree); +extern void print_binding_stack (void); +extern void push_to_top_level (void); +extern void pop_from_top_level (void); +extern void pop_everything (void); +extern void keep_next_level (bool); +extern bool is_ancestor (tree, tree); +extern tree push_scope (tree); +extern void pop_scope (tree); +extern tree push_inner_scope (tree); +extern void pop_inner_scope (tree, tree); +extern void push_binding_level (struct cp_binding_level *); + +extern void push_namespace (tree); +extern void pop_namespace (void); +extern void push_nested_namespace (tree); +extern void pop_nested_namespace (tree); +extern bool handle_namespace_attrs (tree, tree); +extern void pushlevel_class (void); +extern void poplevel_class (void); +extern tree pushdecl_with_scope (tree, cxx_scope *, bool); +extern tree lookup_name_prefer_type (tree, int); +extern tree lookup_name_real (tree, int, int, bool, int, int); +extern tree lookup_type_scope (tree, tag_scope); +extern tree namespace_binding (tree, tree); +extern void set_namespace_binding (tree, tree, tree); +extern bool hidden_name_p (tree); +extern tree remove_hidden_names (tree); +extern tree lookup_qualified_name (tree, tree, bool, bool); +extern tree lookup_name_nonclass (tree); +extern tree lookup_name_innermost_nonclass_level (tree); +extern tree lookup_name_in_func_params (tree, tree); +extern bool is_local_extern (tree); +extern tree lookup_function_nonclass (tree, VEC(tree,gc) *, bool); +extern void push_local_binding (tree, tree, int); +extern bool pushdecl_class_level (tree); +extern tree pushdecl_namespace_level (tree, bool); +extern bool push_class_level_binding (tree, tree); +extern tree getdecls (void); +extern int function_parm_depth (void); +extern tree cp_namespace_decls (tree); +extern void set_decl_namespace (tree, tree, bool); +extern void push_decl_namespace (tree); +extern void pop_decl_namespace (void); +extern void do_namespace_alias (tree, tree); +extern void do_toplevel_using_decl (tree, tree, tree); +extern void do_local_using_decl (tree, tree, tree); +extern tree do_class_using_decl (tree, tree); +extern void do_using_directive (tree); +extern tree lookup_arg_dependent (tree, tree, VEC(tree,gc) *, bool); +extern bool is_associated_namespace (tree, tree); +extern void parse_using_directive (tree, tree); +extern tree innermost_non_namespace_value (tree); +extern cxx_binding *outer_binding (tree, cxx_binding *, bool); +extern void cp_emit_debug_info_for_using (tree, tree); + +/* Set *DECL to the (non-hidden) declaration for ID at global scope, + if present and return true; otherwise return false. */ + +static inline bool +get_global_value_if_present (tree id, tree *decl) +{ + tree global_value = namespace_binding (id, global_namespace); + if (global_value) + *decl = global_value; + return global_value != NULL; +} + +/* True is the binding of IDENTIFIER at global scope names a type. */ + +static inline bool +is_typename_at_global_scope (tree id) +{ + tree global_value = namespace_binding (id, global_namespace); + + return global_value && TREE_CODE (global_value) == TYPE_DECL; +} + +#endif /* GCC_CP_NAME_LOOKUP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cppdefault.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cppdefault.h new file mode 100644 index 0000000..657c4ab --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cppdefault.h @@ -0,0 +1,70 @@ +/* CPP Library. + Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2003, 2004, 2006, 2007 Free Software Foundation, Inc. + Contributed by Per Bothner, 1994-95. + Based on CCCP program by Paul Rubin, June 1986 + Adapted to ANSI C, Richard Stallman, Jan 1987 + + 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 3, 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; see the file COPYING3. If not see + <http://www.gnu.org/licenses/>. */ + +#ifndef GCC_CPPDEFAULT_H +#define GCC_CPPDEFAULT_H + +/* This is the default list of directories to search for include files. + It may be overridden by the various -I and -ixxx options. + + #include "file" looks in the same directory as the current file, + then this list. + #include <file> just looks in this list. + + All these directories are treated as `system' include directories + (they are not subject to pedantic warnings in some cases). */ + +struct default_include +{ + const char *const fname; /* The name of the directory. */ + const char *const component; /* The component containing the directory + (see update_path in prefix.c) */ + const char cplusplus; /* Only look here if we're compiling C++. */ + const char cxx_aware; /* Includes in this directory don't need to + be wrapped in extern "C" when compiling + C++. */ + const char add_sysroot; /* FNAME should be prefixed by + cpp_SYSROOT. */ + const char multilib; /* FNAME should have the multilib path + specified with -imultilib + appended. */ +}; + +extern const struct default_include cpp_include_defaults[]; +extern const char cpp_GCC_INCLUDE_DIR[]; +extern const size_t cpp_GCC_INCLUDE_DIR_len; + +/* The configure-time prefix, i.e., the value supplied as the argument + to --prefix=. */ +extern const char cpp_PREFIX[]; +/* The length of the configure-time prefix. */ +extern const size_t cpp_PREFIX_len; +/* The configure-time execution prefix. This is typically the lib/gcc + subdirectory of cpp_PREFIX. */ +extern const char cpp_EXEC_PREFIX[]; +/* The run-time execution prefix. This is typically the lib/gcc + subdirectory of the actual installation. */ +extern const char *gcc_exec_prefix; + +/* Return true if the toolchain is relocated. */ +bool cpp_relocated (void); + +#endif /* ! GCC_CPPDEFAULT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cpplib.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cpplib.h new file mode 100644 index 0000000..0f32863 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/cpplib.h @@ -0,0 +1,988 @@ +/* Definitions for CPP library. + Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, + 2004, 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Written by Per Bothner, 1994-95. + +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 3, 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; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ +#ifndef LIBCPP_CPPLIB_H +#define LIBCPP_CPPLIB_H + +#include <sys/types.h> +#include "symtab.h" +#include "line-map.h" + +typedef struct cpp_reader cpp_reader; +typedef struct cpp_buffer cpp_buffer; +typedef struct cpp_options cpp_options; +typedef struct cpp_token cpp_token; +typedef struct cpp_string cpp_string; +typedef struct cpp_hashnode cpp_hashnode; +typedef struct cpp_macro cpp_macro; +typedef struct cpp_callbacks cpp_callbacks; +typedef struct cpp_dir cpp_dir; + +struct answer; +struct _cpp_file; + +/* The first three groups, apart from '=', can appear in preprocessor + expressions (+= and -= are used to indicate unary + and - resp.). + This allows a lookup table to be implemented in _cpp_parse_expr. + + The first group, to CPP_LAST_EQ, can be immediately followed by an + '='. The lexer needs operators ending in '=', like ">>=", to be in + the same order as their counterparts without the '=', like ">>". + + See the cpp_operator table optab in expr.c if you change the order or + add or remove anything in the first group. */ + +#define TTYPE_TABLE \ + OP(EQ, "=") \ + OP(NOT, "!") \ + OP(GREATER, ">") /* compare */ \ + OP(LESS, "<") \ + OP(PLUS, "+") /* math */ \ + OP(MINUS, "-") \ + OP(MULT, "*") \ + OP(DIV, "/") \ + OP(MOD, "%") \ + OP(AND, "&") /* bit ops */ \ + OP(OR, "|") \ + OP(XOR, "^") \ + OP(RSHIFT, ">>") \ + OP(LSHIFT, "<<") \ + \ + OP(COMPL, "~") \ + OP(AND_AND, "&&") /* logical */ \ + OP(OR_OR, "||") \ + OP(QUERY, "?") \ + OP(COLON, ":") \ + OP(COMMA, ",") /* grouping */ \ + OP(OPEN_PAREN, "(") \ + OP(CLOSE_PAREN, ")") \ + TK(EOF, NONE) \ + OP(EQ_EQ, "==") /* compare */ \ + OP(NOT_EQ, "!=") \ + OP(GREATER_EQ, ">=") \ + OP(LESS_EQ, "<=") \ + \ + /* These two are unary + / - in preprocessor expressions. */ \ + OP(PLUS_EQ, "+=") /* math */ \ + OP(MINUS_EQ, "-=") \ + \ + OP(MULT_EQ, "*=") \ + OP(DIV_EQ, "/=") \ + OP(MOD_EQ, "%=") \ + OP(AND_EQ, "&=") /* bit ops */ \ + OP(OR_EQ, "|=") \ + OP(XOR_EQ, "^=") \ + OP(RSHIFT_EQ, ">>=") \ + OP(LSHIFT_EQ, "<<=") \ + /* Digraphs together, beginning with CPP_FIRST_DIGRAPH. */ \ + OP(HASH, "#") /* digraphs */ \ + OP(PASTE, "##") \ + OP(OPEN_SQUARE, "[") \ + OP(CLOSE_SQUARE, "]") \ + OP(OPEN_BRACE, "{") \ + OP(CLOSE_BRACE, "}") \ + /* The remainder of the punctuation. Order is not significant. */ \ + OP(SEMICOLON, ";") /* structure */ \ + OP(ELLIPSIS, "...") \ + OP(PLUS_PLUS, "++") /* increment */ \ + OP(MINUS_MINUS, "--") \ + OP(DEREF, "->") /* accessors */ \ + OP(DOT, ".") \ + OP(SCOPE, "::") \ + OP(DEREF_STAR, "->*") \ + OP(DOT_STAR, ".*") \ + OP(ATSIGN, "@") /* used in Objective-C */ \ + \ + TK(NAME, IDENT) /* word */ \ + TK(AT_NAME, IDENT) /* @word - Objective-C */ \ + TK(NUMBER, LITERAL) /* 34_be+ta */ \ + \ + TK(CHAR, LITERAL) /* 'char' */ \ + TK(WCHAR, LITERAL) /* L'char' */ \ + TK(CHAR16, LITERAL) /* u'char' */ \ + TK(CHAR32, LITERAL) /* U'char' */ \ + TK(OTHER, LITERAL) /* stray punctuation */ \ + \ + TK(STRING, LITERAL) /* "string" */ \ + TK(WSTRING, LITERAL) /* L"string" */ \ + TK(STRING16, LITERAL) /* u"string" */ \ + TK(STRING32, LITERAL) /* U"string" */ \ + TK(UTF8STRING, LITERAL) /* u8"string" */ \ + TK(OBJC_STRING, LITERAL) /* @"string" - Objective-C */ \ + TK(HEADER_NAME, LITERAL) /* <stdio.h> in #include */ \ + \ + TK(COMMENT, LITERAL) /* Only if output comments. */ \ + /* SPELL_LITERAL happens to DTRT. */ \ + TK(MACRO_ARG, NONE) /* Macro argument. */ \ + TK(PRAGMA, NONE) /* Only for deferred pragmas. */ \ + TK(PRAGMA_EOL, NONE) /* End-of-line for deferred pragmas. */ \ + TK(PADDING, NONE) /* Whitespace for -E. */ + +#define OP(e, s) CPP_ ## e, +#define TK(e, s) CPP_ ## e, +enum cpp_ttype +{ + TTYPE_TABLE + N_TTYPES, + + /* Positions in the table. */ + CPP_LAST_EQ = CPP_LSHIFT, + CPP_FIRST_DIGRAPH = CPP_HASH, + CPP_LAST_PUNCTUATOR= CPP_ATSIGN, + CPP_LAST_CPP_OP = CPP_LESS_EQ +}; +#undef OP +#undef TK + +/* C language kind, used when calling cpp_create_reader. */ +enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC1X, + CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC1X, + CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11, CLK_ASM}; + +/* Payload of a NUMBER, STRING, CHAR or COMMENT token. */ +struct GTY(()) cpp_string { + unsigned int len; + const unsigned char *text; +}; + +/* Flags for the cpp_token structure. */ +#define PREV_WHITE (1 << 0) /* If whitespace before this token. */ +#define DIGRAPH (1 << 1) /* If it was a digraph. */ +#define STRINGIFY_ARG (1 << 2) /* If macro argument to be stringified. */ +#define PASTE_LEFT (1 << 3) /* If on LHS of a ## operator. */ +#define NAMED_OP (1 << 4) /* C++ named operators. */ +#define NO_EXPAND (1 << 5) /* Do not macro-expand this token. */ +#define BOL (1 << 6) /* Token at beginning of line. */ +#define PURE_ZERO (1 << 7) /* Single 0 digit, used by the C++ frontend, + set in c-lex.c. */ +#define SP_DIGRAPH (1 << 8) /* # or ## token was a digraph. */ +#define SP_PREV_WHITE (1 << 9) /* If whitespace before a ## + operator, or before this token + after a # operator. */ + +/* Specify which field, if any, of the cpp_token union is used. */ + +enum cpp_token_fld_kind { + CPP_TOKEN_FLD_NODE, + CPP_TOKEN_FLD_SOURCE, + CPP_TOKEN_FLD_STR, + CPP_TOKEN_FLD_ARG_NO, + CPP_TOKEN_FLD_TOKEN_NO, + CPP_TOKEN_FLD_PRAGMA, + CPP_TOKEN_FLD_NONE +}; + +/* A macro argument in the cpp_token union. */ +struct GTY(()) cpp_macro_arg { + /* Argument number. */ + unsigned int arg_no; +}; + +/* An identifier in the cpp_token union. */ +struct GTY(()) cpp_identifier { + /* The canonical (UTF-8) spelling of the identifier. */ + cpp_hashnode * + GTY ((nested_ptr (union tree_node, + "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL", + "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"))) + node; +}; + +/* A preprocessing token. This has been carefully packed and should + occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts. */ +struct GTY(()) cpp_token { + source_location src_loc; /* Location of first char of token. */ + ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT; /* token type */ + unsigned short flags; /* flags - see above */ + + union cpp_token_u + { + /* An identifier. */ + struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node; + + /* Inherit padding from this token. */ + cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source; + + /* A string, or number. */ + struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str; + + /* Argument no. for a CPP_MACRO_ARG. */ + struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg; + + /* Original token no. for a CPP_PASTE (from a sequence of + consecutive paste tokens in a macro expansion). */ + unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no; + + /* Caller-supplied identifier for a CPP_PRAGMA. */ + unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma; + } GTY ((desc ("cpp_token_val_index (&%1)"))) val; +}; + +/* Say which field is in use. */ +extern enum cpp_token_fld_kind cpp_token_val_index (cpp_token *tok); + +/* A type wide enough to hold any multibyte source character. + cpplib's character constant interpreter requires an unsigned type. + Also, a typedef for the signed equivalent. + The width of this type is capped at 32 bits; there do exist targets + where wchar_t is 64 bits, but only in a non-default mode, and there + would be no meaningful interpretation for a wchar_t value greater + than 2^32 anyway -- the widest wide-character encoding around is + ISO 10646, which stops at 2^31. */ +#if CHAR_BIT * SIZEOF_INT >= 32 +# define CPPCHAR_SIGNED_T int +#elif CHAR_BIT * SIZEOF_LONG >= 32 +# define CPPCHAR_SIGNED_T long +#else +# error "Cannot find a least-32-bit signed integer type" +#endif +typedef unsigned CPPCHAR_SIGNED_T cppchar_t; +typedef CPPCHAR_SIGNED_T cppchar_signed_t; + +/* Style of header dependencies to generate. */ +enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM }; + +/* The possible normalization levels, from most restrictive to least. */ +enum cpp_normalize_level { + /* In NFKC. */ + normalized_KC = 0, + /* In NFC. */ + normalized_C, + /* In NFC, except for subsequences where being in NFC would make + the identifier invalid. */ + normalized_identifier_C, + /* Not normalized at all. */ + normalized_none +}; + +/* This structure is nested inside struct cpp_reader, and + carries all the options visible to the command line. */ +struct cpp_options +{ + /* Characters between tab stops. */ + unsigned int tabstop; + + /* The language we're preprocessing. */ + enum c_lang lang; + + /* Nonzero means use extra default include directories for C++. */ + unsigned char cplusplus; + + /* Nonzero means handle cplusplus style comments. */ + unsigned char cplusplus_comments; + + /* Nonzero means define __OBJC__, treat @ as a special token, use + the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow + "#import". */ + unsigned char objc; + + /* Nonzero means don't copy comments into the output file. */ + unsigned char discard_comments; + + /* Nonzero means don't copy comments into the output file during + macro expansion. */ + unsigned char discard_comments_in_macro_exp; + + /* Nonzero means process the ISO trigraph sequences. */ + unsigned char trigraphs; + + /* Nonzero means process the ISO digraph sequences. */ + unsigned char digraphs; + + /* Nonzero means to allow hexadecimal floats and LL suffixes. */ + unsigned char extended_numbers; + + /* Nonzero means process u/U prefix literals (UTF-16/32). */ + unsigned char uliterals; + + /* Nonzero means print names of header files (-H). */ + unsigned char print_include_names; + + /* Nonzero means complain about deprecated features. */ + unsigned char cpp_warn_deprecated; + + /* Nonzero means warn if slash-star appears in a comment. */ + unsigned char warn_comments; + + /* Nonzero means warn if a user-supplied include directory does not + exist. */ + unsigned char warn_missing_include_dirs; + + /* Nonzero means warn if there are any trigraphs. */ + unsigned char warn_trigraphs; + + /* Nonzero means warn about multicharacter charconsts. */ + unsigned char warn_multichar; + + /* Nonzero means warn about various incompatibilities with + traditional C. */ + unsigned char cpp_warn_traditional; + + /* Nonzero means warn about long long numeric constants. */ + unsigned char cpp_warn_long_long; + + /* Nonzero means warn about text after an #endif (or #else). */ + unsigned char warn_endif_labels; + + /* Nonzero means warn about implicit sign changes owing to integer + promotions. */ + unsigned char warn_num_sign_change; + + /* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode. + Presumably the usage is protected by the appropriate #ifdef. */ + unsigned char warn_variadic_macros; + + /* Nonzero means warn about builtin macros that are redefined or + explicitly undefined. */ + unsigned char warn_builtin_macro_redefined; + + /* Nonzero means we should look for header.gcc files that remap file + names. */ + unsigned char remap; + + /* Zero means dollar signs are punctuation. */ + unsigned char dollars_in_ident; + + /* Nonzero means UCNs are accepted in identifiers. */ + unsigned char extended_identifiers; + + /* True if we should warn about dollars in identifiers or numbers + for this translation unit. */ + unsigned char warn_dollars; + + /* Nonzero means warn if undefined identifiers are evaluated in an #if. */ + unsigned char warn_undef; + + /* Nonzero means warn of unused macros from the main file. */ + unsigned char warn_unused_macros; + + /* Nonzero for the 1999 C Standard, including corrigenda and amendments. */ + unsigned char c99; + + /* Nonzero if we are conforming to a specific C or C++ standard. */ + unsigned char std; + + /* Nonzero means give all the error messages the ANSI standard requires. */ + unsigned char cpp_pedantic; + + /* Nonzero means we're looking at already preprocessed code, so don't + bother trying to do macro expansion and whatnot. */ + unsigned char preprocessed; + + /* Nonzero means handle C++ alternate operator names. */ + unsigned char operator_names; + + /* Nonzero means warn about use of C++ alternate operator names. */ + unsigned char warn_cxx_operator_names; + + /* True for traditional preprocessing. */ + unsigned char traditional; + + /* Holds the name of the target (execution) character set. */ + const char *narrow_charset; + + /* Holds the name of the target wide character set. */ + const char *wide_charset; + + /* Holds the name of the input character set. */ + const char *input_charset; + + /* The minimum permitted level of normalization before a warning + is generated. */ + enum cpp_normalize_level warn_normalize; + + /* True to warn about precompiled header files we couldn't use. */ + bool warn_invalid_pch; + + /* True if dependencies should be restored from a precompiled header. */ + bool restore_pch_deps; + + /* Dependency generation. */ + struct + { + /* Style of header dependencies to generate. */ + enum cpp_deps_style style; + + /* Assume missing files are generated files. */ + bool missing_files; + + /* Generate phony targets for each dependency apart from the first + one. */ + bool phony_targets; + + /* If true, no dependency is generated on the main file. */ + bool ignore_main_file; + + /* If true, intend to use the preprocessor output (e.g., for compilation) + in addition to the dependency info. */ + bool need_preprocessor_output; + } deps; + + /* Target-specific features set by the front end or client. */ + + /* Precision for target CPP arithmetic, target characters, target + ints and target wide characters, respectively. */ + size_t precision, char_precision, int_precision, wchar_precision; + + /* True means chars (wide chars) are unsigned. */ + bool unsigned_char, unsigned_wchar; + + /* True if the most significant byte in a word has the lowest + address in memory. */ + bool bytes_big_endian; + + /* Nonzero means __STDC__ should have the value 0 in system headers. */ + unsigned char stdc_0_in_system_headers; + + /* True disables tokenization outside of preprocessing directives. */ + bool directives_only; +}; + +/* Callback for header lookup for HEADER, which is the name of a + source file. It is used as a method of last resort to find headers + that are not otherwise found during the normal include processing. + The return value is the malloced name of a header to try and open, + if any, or NULL otherwise. This callback is called only if the + header is otherwise unfound. */ +typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **); + +/* Call backs to cpplib client. */ +struct cpp_callbacks +{ + /* Called when a new line of preprocessed output is started. */ + void (*line_change) (cpp_reader *, const cpp_token *, int); + + /* Called when switching to/from a new file. + The line_map is for the new file. It is NULL if there is no new file. + (In C this happens when done with <built-in>+<command line> and also + when done with a main file.) This can be used for resource cleanup. */ + void (*file_change) (cpp_reader *, const struct line_map *); + + void (*dir_change) (cpp_reader *, const char *); + void (*include) (cpp_reader *, unsigned int, const unsigned char *, + const char *, int, const cpp_token **); + void (*define) (cpp_reader *, unsigned int, cpp_hashnode *); + void (*undef) (cpp_reader *, unsigned int, cpp_hashnode *); + void (*ident) (cpp_reader *, unsigned int, const cpp_string *); + void (*def_pragma) (cpp_reader *, unsigned int); + int (*valid_pch) (cpp_reader *, const char *, int); + void (*read_pch) (cpp_reader *, const char *, int, const char *); + missing_header_cb missing_header; + + /* Context-sensitive macro support. Returns macro (if any) that should + be expanded. */ + cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *); + + /* Called to emit a diagnostic. This callback receives the + translated message. */ + bool (*error) (cpp_reader *, int, int, source_location, unsigned int, + const char *, va_list *) + ATTRIBUTE_FPTR_PRINTF(6,0); + + /* Callbacks for when a macro is expanded, or tested (whether + defined or not at the time) in #ifdef, #ifndef or "defined". */ + void (*used_define) (cpp_reader *, unsigned int, cpp_hashnode *); + void (*used_undef) (cpp_reader *, unsigned int, cpp_hashnode *); + /* Called before #define and #undef or other macro definition + changes are processed. */ + void (*before_define) (cpp_reader *); + /* Called whenever a macro is expanded or tested. + Second argument is the location of the start of the current expansion. */ + void (*used) (cpp_reader *, source_location, cpp_hashnode *); + + /* Callback that can change a user builtin into normal macro. */ + bool (*user_builtin_macro) (cpp_reader *, cpp_hashnode *); +}; + +#ifdef VMS +#define INO_T_CPP ino_t ino[3] +#else +#define INO_T_CPP ino_t ino +#endif + +/* Chain of directories to look for include files in. */ +struct cpp_dir +{ + /* NULL-terminated singly-linked list. */ + struct cpp_dir *next; + + /* NAME of the directory, NUL-terminated. */ + char *name; + unsigned int len; + + /* One if a system header, two if a system header that has extern + "C" guards for C++. */ + unsigned char sysp; + + /* Is this a user-supplied directory? */ + bool user_supplied_p; + + /* The canonicalized NAME as determined by lrealpath. This field + is only used by hosts that lack reliable inode numbers. */ + char *canonical_name; + + /* Mapping of file names for this directory for MS-DOS and related + platforms. A NULL-terminated array of (from, to) pairs. */ + const char **name_map; + + /* Routine to construct pathname, given the search path name and the + HEADER we are trying to find, return a constructed pathname to + try and open. If this is NULL, the constructed pathname is as + constructed by append_file_to_dir. */ + char *(*construct) (const char *header, cpp_dir *dir); + + /* The C front end uses these to recognize duplicated + directories in the search path. */ + INO_T_CPP; + dev_t dev; +}; + +/* The structure of a node in the hash table. The hash table has + entries for all identifiers: either macros defined by #define + commands (type NT_MACRO), assertions created with #assert + (NT_ASSERTION), or neither of the above (NT_VOID). Builtin macros + like __LINE__ are flagged NODE_BUILTIN. Poisoned identifiers are + flagged NODE_POISONED. NODE_OPERATOR (C++ only) indicates an + identifier that behaves like an operator such as "xor". + NODE_DIAGNOSTIC is for speed in lex_token: it indicates a + diagnostic may be required for this node. Currently this only + applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat + warnings about NODE_OPERATOR. */ + +/* Hash node flags. */ +#define NODE_OPERATOR (1 << 0) /* C++ named operator. */ +#define NODE_POISONED (1 << 1) /* Poisoned identifier. */ +#define NODE_BUILTIN (1 << 2) /* Builtin macro. */ +#define NODE_DIAGNOSTIC (1 << 3) /* Possible diagnostic when lexed. */ +#define NODE_WARN (1 << 4) /* Warn if redefined or undefined. */ +#define NODE_DISABLED (1 << 5) /* A disabled macro. */ +#define NODE_MACRO_ARG (1 << 6) /* Used during #define processing. */ +#define NODE_USED (1 << 7) /* Dumped with -dU. */ +#define NODE_CONDITIONAL (1 << 8) /* Conditional macro */ +#define NODE_WARN_OPERATOR (1 << 9) /* Warn about C++ named operator. */ + +/* Different flavors of hash node. */ +enum node_type +{ + NT_VOID = 0, /* No definition yet. */ + NT_MACRO, /* A macro of some form. */ + NT_ASSERTION /* Predicate for #assert. */ +}; + +/* Different flavors of builtin macro. _Pragma is an operator, but we + handle it with the builtin code for efficiency reasons. */ +enum cpp_builtin_type +{ + BT_SPECLINE = 0, /* `__LINE__' */ + BT_DATE, /* `__DATE__' */ + BT_FILE, /* `__FILE__' */ + BT_BASE_FILE, /* `__BASE_FILE__' */ + BT_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */ + BT_TIME, /* `__TIME__' */ + BT_STDC, /* `__STDC__' */ + BT_PRAGMA, /* `_Pragma' operator */ + BT_TIMESTAMP, /* `__TIMESTAMP__' */ + BT_COUNTER, /* `__COUNTER__' */ + BT_FIRST_USER, /* User defined builtin macros. */ + BT_LAST_USER = BT_FIRST_USER + 31 +}; + +#define CPP_HASHNODE(HNODE) ((cpp_hashnode *) (HNODE)) +#define HT_NODE(NODE) ((ht_identifier *) (NODE)) +#define NODE_LEN(NODE) HT_LEN (&(NODE)->ident) +#define NODE_NAME(NODE) HT_STR (&(NODE)->ident) + +/* Specify which field, if any, of the union is used. */ + +enum { + NTV_MACRO, + NTV_ANSWER, + NTV_BUILTIN, + NTV_ARGUMENT, + NTV_NONE +}; + +#define CPP_HASHNODE_VALUE_IDX(HNODE) \ + ((HNODE.flags & NODE_MACRO_ARG) ? NTV_ARGUMENT \ + : HNODE.type == NT_MACRO ? ((HNODE.flags & NODE_BUILTIN) \ + ? NTV_BUILTIN : NTV_MACRO) \ + : HNODE.type == NT_ASSERTION ? NTV_ANSWER \ + : NTV_NONE) + +/* The common part of an identifier node shared amongst all 3 C front + ends. Also used to store CPP identifiers, which are a superset of + identifiers in the grammatical sense. */ + +union GTY(()) _cpp_hashnode_value { + /* If a macro. */ + cpp_macro * GTY((tag ("NTV_MACRO"))) macro; + /* Answers to an assertion. */ + struct answer * GTY ((tag ("NTV_ANSWER"))) answers; + /* Code for a builtin macro. */ + enum cpp_builtin_type GTY ((tag ("NTV_BUILTIN"))) builtin; + /* Macro argument index. */ + unsigned short GTY ((tag ("NTV_ARGUMENT"))) arg_index; +}; + +struct GTY(()) cpp_hashnode { + struct ht_identifier ident; + unsigned int is_directive : 1; + unsigned int directive_index : 7; /* If is_directive, + then index into directive table. + Otherwise, a NODE_OPERATOR. */ + unsigned char rid_code; /* Rid code - for front ends. */ + ENUM_BITFIELD(node_type) type : 6; /* CPP node type. */ + unsigned int flags : 10; /* CPP flags. */ + + union _cpp_hashnode_value GTY ((desc ("CPP_HASHNODE_VALUE_IDX (%1)"))) value; +}; + +/* Call this first to get a handle to pass to other functions. + + If you want cpplib to manage its own hashtable, pass in a NULL + pointer. Otherwise you should pass in an initialized hash table + that cpplib will share; this technique is used by the C front + ends. */ +extern cpp_reader *cpp_create_reader (enum c_lang, struct ht *, + struct line_maps *); + +/* Reset the cpp_reader's line_map. This is only used after reading a + PCH file. */ +extern void cpp_set_line_map (cpp_reader *, struct line_maps *); + +/* Call this to change the selected language standard (e.g. because of + command line options). */ +extern void cpp_set_lang (cpp_reader *, enum c_lang); + +/* Set the include paths. */ +extern void cpp_set_include_chains (cpp_reader *, cpp_dir *, cpp_dir *, int); + +/* Call these to get pointers to the options, callback, and deps + structures for a given reader. These pointers are good until you + call cpp_finish on that reader. You can either edit the callbacks + through the pointer returned from cpp_get_callbacks, or set them + with cpp_set_callbacks. */ +extern cpp_options *cpp_get_options (cpp_reader *); +extern cpp_callbacks *cpp_get_callbacks (cpp_reader *); +extern void cpp_set_callbacks (cpp_reader *, cpp_callbacks *); +extern struct deps *cpp_get_deps (cpp_reader *); + +/* This function reads the file, but does not start preprocessing. It + returns the name of the original file; this is the same as the + input file, except for preprocessed input. This will generate at + least one file change callback, and possibly a line change callback + too. If there was an error opening the file, it returns NULL. */ +extern const char *cpp_read_main_file (cpp_reader *, const char *); + +/* Set up built-ins with special behavior. Use cpp_init_builtins() + instead unless your know what you are doing. */ +extern void cpp_init_special_builtins (cpp_reader *); + +/* Set up built-ins like __FILE__. */ +extern void cpp_init_builtins (cpp_reader *, int); + +/* This is called after options have been parsed, and partially + processed. */ +extern void cpp_post_options (cpp_reader *); + +/* Set up translation to the target character set. */ +extern void cpp_init_iconv (cpp_reader *); + +/* Call this to finish preprocessing. If you requested dependency + generation, pass an open stream to write the information to, + otherwise NULL. It is your responsibility to close the stream. */ +extern void cpp_finish (cpp_reader *, FILE *deps_stream); + +/* Call this to release the handle at the end of preprocessing. Any + use of the handle after this function returns is invalid. */ +extern void cpp_destroy (cpp_reader *); + +extern unsigned int cpp_token_len (const cpp_token *); +extern unsigned char *cpp_token_as_text (cpp_reader *, const cpp_token *); +extern unsigned char *cpp_spell_token (cpp_reader *, const cpp_token *, + unsigned char *, bool); +extern void cpp_register_pragma (cpp_reader *, const char *, const char *, + void (*) (cpp_reader *), bool); +extern void cpp_register_deferred_pragma (cpp_reader *, const char *, + const char *, unsigned, bool, bool); +extern int cpp_avoid_paste (cpp_reader *, const cpp_token *, + const cpp_token *); +extern const cpp_token *cpp_get_token (cpp_reader *); +extern const cpp_token *cpp_get_token_with_location (cpp_reader *, + source_location *); +extern const unsigned char *cpp_macro_definition (cpp_reader *, + cpp_hashnode *); +extern void _cpp_backup_tokens (cpp_reader *, unsigned int); +extern const cpp_token *cpp_peek_token (cpp_reader *, int); + +/* Evaluate a CPP_*CHAR* token. */ +extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *, + unsigned int *, int *); +/* Evaluate a vector of CPP_*STRING* tokens. */ +extern bool cpp_interpret_string (cpp_reader *, + const cpp_string *, size_t, + cpp_string *, enum cpp_ttype); +extern bool cpp_interpret_string_notranslate (cpp_reader *, + const cpp_string *, size_t, + cpp_string *, enum cpp_ttype); + +/* Convert a host character constant to the execution character set. */ +extern cppchar_t cpp_host_to_exec_charset (cpp_reader *, cppchar_t); + +/* Used to register macros and assertions, perhaps from the command line. + The text is the same as the command line argument. */ +extern void cpp_define (cpp_reader *, const char *); +extern void cpp_define_formatted (cpp_reader *pfile, + const char *fmt, ...) ATTRIBUTE_PRINTF_2; +extern void cpp_assert (cpp_reader *, const char *); +extern void cpp_undef (cpp_reader *, const char *); +extern void cpp_unassert (cpp_reader *, const char *); + +/* Undefine all macros and assertions. */ +extern void cpp_undef_all (cpp_reader *); + +extern cpp_buffer *cpp_push_buffer (cpp_reader *, const unsigned char *, + size_t, int); +extern int cpp_defined (cpp_reader *, const unsigned char *, int); + +/* A preprocessing number. Code assumes that any unused high bits of + the double integer are set to zero. */ +typedef unsigned HOST_WIDE_INT cpp_num_part; +typedef struct cpp_num cpp_num; +struct cpp_num +{ + cpp_num_part high; + cpp_num_part low; + bool unsignedp; /* True if value should be treated as unsigned. */ + bool overflow; /* True if the most recent calculation overflowed. */ +}; + +/* cpplib provides two interfaces for interpretation of preprocessing + numbers. + + cpp_classify_number categorizes numeric constants according to + their field (integer, floating point, or invalid), radix (decimal, + octal, hexadecimal), and type suffixes. */ + +#define CPP_N_CATEGORY 0x000F +#define CPP_N_INVALID 0x0000 +#define CPP_N_INTEGER 0x0001 +#define CPP_N_FLOATING 0x0002 + +#define CPP_N_WIDTH 0x00F0 +#define CPP_N_SMALL 0x0010 /* int, float, shrot _Fract/Accum */ +#define CPP_N_MEDIUM 0x0020 /* long, double, long _Fract/_Accum. */ +#define CPP_N_LARGE 0x0040 /* long long, long double, + long long _Fract/Accum. */ + +#define CPP_N_WIDTH_MD 0xF0000 /* machine defined. */ +#define CPP_N_MD_W 0x10000 +#define CPP_N_MD_Q 0x20000 + +#define CPP_N_RADIX 0x0F00 +#define CPP_N_DECIMAL 0x0100 +#define CPP_N_HEX 0x0200 +#define CPP_N_OCTAL 0x0400 +#define CPP_N_BINARY 0x0800 + +#define CPP_N_UNSIGNED 0x1000 /* Properties. */ +#define CPP_N_IMAGINARY 0x2000 +#define CPP_N_DFLOAT 0x4000 +#define CPP_N_DEFAULT 0x8000 + +#define CPP_N_FRACT 0x100000 /* Fract types. */ +#define CPP_N_ACCUM 0x200000 /* Accum types. */ + +/* Classify a CPP_NUMBER token. The return value is a combination of + the flags from the above sets. */ +extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *); + +/* Evaluate a token classified as category CPP_N_INTEGER. */ +extern cpp_num cpp_interpret_integer (cpp_reader *, const cpp_token *, + unsigned int type); + +/* Sign extend a number, with PRECISION significant bits and all + others assumed clear, to fill out a cpp_num structure. */ +cpp_num cpp_num_sign_extend (cpp_num, size_t); + +/* Diagnostic levels. To get a diagnostic without associating a + position in the translation unit with it, use cpp_error_with_line + with a line number of zero. */ + +enum { + /* Warning, an error with -Werror. */ + CPP_DL_WARNING = 0, + /* Same as CPP_DL_WARNING, except it is not suppressed in system headers. */ + CPP_DL_WARNING_SYSHDR, + /* Warning, an error with -pedantic-errors or -Werror. */ + CPP_DL_PEDWARN, + /* An error. */ + CPP_DL_ERROR, + /* An internal consistency check failed. Prints "internal error: ", + otherwise the same as CPP_DL_ERROR. */ + CPP_DL_ICE, + /* An informative note following a warning. */ + CPP_DL_NOTE, + /* A fatal error. */ + CPP_DL_FATAL +}; + +/* Warning reason codes. Use a reason code of zero for unclassified warnings + and errors that are not warnings. */ +enum { + CPP_W_NONE = 0, + CPP_W_DEPRECATED, + CPP_W_COMMENTS, + CPP_W_MISSING_INCLUDE_DIRS, + CPP_W_TRIGRAPHS, + CPP_W_MULTICHAR, + CPP_W_TRADITIONAL, + CPP_W_LONG_LONG, + CPP_W_ENDIF_LABELS, + CPP_W_NUM_SIGN_CHANGE, + CPP_W_VARIADIC_MACROS, + CPP_W_BUILTIN_MACRO_REDEFINED, + CPP_W_DOLLARS, + CPP_W_UNDEF, + CPP_W_UNUSED_MACROS, + CPP_W_CXX_OPERATOR_NAMES, + CPP_W_NORMALIZE, + CPP_W_INVALID_PCH, + CPP_W_WARNING_DIRECTIVE +}; + +/* Output a diagnostic of some kind. */ +extern bool cpp_error (cpp_reader *, int, const char *msgid, ...) + ATTRIBUTE_PRINTF_3; +extern bool cpp_warning (cpp_reader *, int, const char *msgid, ...) + ATTRIBUTE_PRINTF_3; +extern bool cpp_pedwarning (cpp_reader *, int, const char *msgid, ...) + ATTRIBUTE_PRINTF_3; +extern bool cpp_warning_syshdr (cpp_reader *, int, const char *msgid, ...) + ATTRIBUTE_PRINTF_3; + +/* Output a diagnostic with "MSGID: " preceding the + error string of errno. No location is printed. */ +extern bool cpp_errno (cpp_reader *, int, const char *msgid); + +/* Same as cpp_error, except additionally specifies a position as a + (translation unit) physical line and physical column. If the line is + zero, then no location is printed. */ +extern bool cpp_error_with_line (cpp_reader *, int, source_location, + unsigned, const char *msgid, ...) + ATTRIBUTE_PRINTF_5; +extern bool cpp_warning_with_line (cpp_reader *, int, source_location, + unsigned, const char *msgid, ...) + ATTRIBUTE_PRINTF_5; +extern bool cpp_pedwarning_with_line (cpp_reader *, int, source_location, + unsigned, const char *msgid, ...) + ATTRIBUTE_PRINTF_5; +extern bool cpp_warning_with_line_syshdr (cpp_reader *, int, source_location, + unsigned, const char *msgid, ...) + ATTRIBUTE_PRINTF_5; + +/* In lex.c */ +extern int cpp_ideq (const cpp_token *, const char *); +extern void cpp_output_line (cpp_reader *, FILE *); +extern unsigned char *cpp_output_line_to_string (cpp_reader *, + const unsigned char *); +extern void cpp_output_token (const cpp_token *, FILE *); +extern const char *cpp_type2name (enum cpp_ttype, unsigned char flags); +/* Returns the value of an escape sequence, truncated to the correct + target precision. PSTR points to the input pointer, which is just + after the backslash. LIMIT is how much text we have. WIDE is true + if the escape sequence is part of a wide character constant or + string literal. Handles all relevant diagnostics. */ +extern cppchar_t cpp_parse_escape (cpp_reader *, const unsigned char ** pstr, + const unsigned char *limit, int wide); + +/* Structure used to hold a comment block at a given location in the + source code. */ + +typedef struct +{ + /* Text of the comment including the terminators. */ + char *comment; + + /* source location for the given comment. */ + source_location sloc; +} cpp_comment; + +/* Structure holding all comments for a given cpp_reader. */ + +typedef struct +{ + /* table of comment entries. */ + cpp_comment *entries; + + /* number of actual entries entered in the table. */ + int count; + + /* number of entries allocated currently. */ + int allocated; +} cpp_comment_table; + +/* Returns the table of comments encountered by the preprocessor. This + table is only populated when pfile->state.save_comments is true. */ +extern cpp_comment_table *cpp_get_comments (cpp_reader *); + +/* In hash.c */ + +/* Lookup an identifier in the hashtable. Puts the identifier in the + table if it is not already there. */ +extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *, + unsigned int); + +typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *); +extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *); + +/* In macro.c */ +extern void cpp_scan_nooutput (cpp_reader *); +extern int cpp_sys_macro_p (cpp_reader *); +extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *, + unsigned int); + +/* In files.c */ +extern bool cpp_included (cpp_reader *, const char *); +extern bool cpp_included_before (cpp_reader *, const char *, source_location); +extern void cpp_make_system_header (cpp_reader *, int, int); +extern bool cpp_push_include (cpp_reader *, const char *); +extern void cpp_change_file (cpp_reader *, enum lc_reason, const char *); +extern const char *cpp_get_path (struct _cpp_file *); +extern cpp_dir *cpp_get_dir (struct _cpp_file *); +extern cpp_buffer *cpp_get_buffer (cpp_reader *); +extern struct _cpp_file *cpp_get_file (cpp_buffer *); +extern cpp_buffer *cpp_get_prev (cpp_buffer *); +extern void cpp_clear_file_cache (cpp_reader *); + +/* In pch.c */ +struct save_macro_data; +extern int cpp_save_state (cpp_reader *, FILE *); +extern int cpp_write_pch_deps (cpp_reader *, FILE *); +extern int cpp_write_pch_state (cpp_reader *, FILE *); +extern int cpp_valid_state (cpp_reader *, const char *, int); +extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **); +extern int cpp_read_state (cpp_reader *, const char *, FILE *, + struct save_macro_data *); + +#endif /* ! LIBCPP_CPPLIB_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/debug.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/debug.h new file mode 100644 index 0000000..cdaf457 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/debug.h @@ -0,0 +1,229 @@ +/* Debug hooks for GCC. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010 + Free Software Foundation, Inc. + + 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 3, 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; see the file COPYING3. If not see + <http://www.gnu.org/licenses/>. */ + +#ifndef GCC_DEBUG_H +#define GCC_DEBUG_H + +/* This structure contains hooks for the debug information output + functions, accessed through the global instance debug_hooks set in + toplev.c according to command line options. */ +struct gcc_debug_hooks +{ + /* Initialize debug output. MAIN_FILENAME is the name of the main + input file. */ + void (* init) (const char *main_filename); + + /* Output debug symbols. */ + void (* finish) (const char *main_filename); + + /* Called from cgraph_optimize before starting to assemble + functions/variables/toplevel asms. */ + void (* assembly_start) (void); + + /* Macro defined on line LINE with name and expansion TEXT. */ + void (* define) (unsigned int line, const char *text); + + /* MACRO undefined on line LINE. */ + void (* undef) (unsigned int line, const char *macro); + + /* Record the beginning of a new source file FILE from LINE number + in the previous one. */ + void (* start_source_file) (unsigned int line, const char *file); + + /* Record the resumption of a source file. LINE is the line number + in the source file we are returning to. */ + void (* end_source_file) (unsigned int line); + + /* Record the beginning of block N, counting from 1 and not + including the function-scope block, at LINE. */ + void (* begin_block) (unsigned int line, unsigned int n); + + /* Record the end of a block. Arguments as for begin_block. */ + void (* end_block) (unsigned int line, unsigned int n); + + /* Returns nonzero if it is appropriate not to emit any debugging + information for BLOCK, because it doesn't contain any + instructions. This may not be the case for blocks containing + nested functions, since we may actually call such a function even + though the BLOCK information is messed up. Defaults to true. */ + bool (* ignore_block) (const_tree); + + /* Record a source file location at (FILE, LINE, DISCRIMINATOR). */ + void (* source_line) (unsigned int line, const char *file, + int discriminator, bool is_stmt); + + /* Called at start of prologue code. LINE is the first line in the + function. */ + void (* begin_prologue) (unsigned int line, const char *file); + + /* Called at end of prologue code. LINE is the first line in the + function. */ + void (* end_prologue) (unsigned int line, const char *file); + + /* Called at beginning of epilogue code. */ + void (* begin_epilogue) (unsigned int line, const char *file); + + /* Record end of epilogue code. */ + void (* end_epilogue) (unsigned int line, const char *file); + + /* Called at start of function DECL, before it is declared. */ + void (* begin_function) (tree decl); + + /* Record end of function. LINE is highest line number in function. */ + void (* end_function) (unsigned int line); + + /* Debug information for a function DECL. This might include the + function name (a symbol), its parameters, and the block that + makes up the function's body, and the local variables of the + function. */ + void (* function_decl) (tree decl); + + /* Debug information for a global DECL. Called from toplev.c after + compilation proper has finished. */ + void (* global_decl) (tree decl); + + /* Debug information for a type DECL. Called from toplev.c after + compilation proper, also from various language front ends to + record built-in types. The second argument is properly a + boolean, which indicates whether or not the type is a "local" + type as determined by the language. (It's not a boolean for + legacy reasons.) */ + void (* type_decl) (tree decl, int local); + + /* Debug information for imported modules and declarations. */ + void (* imported_module_or_decl) (tree decl, tree name, + tree context, bool child); + + /* DECL is an inline function, whose body is present, but which is + not being output at this point. */ + void (* deferred_inline_function) (tree decl); + + /* DECL is an inline function which is about to be emitted out of + line. The hook is useful to, e.g., emit abstract debug info for + the inline before it gets mangled by optimization. */ + void (* outlining_inline_function) (tree decl); + + /* Called from final_scan_insn for any CODE_LABEL insn whose + LABEL_NAME is non-null. */ + void (* label) (rtx); + + /* Called after the start and before the end of writing a PCH file. + The parameter is 0 if after the start, 1 if before the end. */ + void (* handle_pch) (unsigned int); + + /* Called from final_scan_insn for any NOTE_INSN_VAR_LOCATION note. */ + void (* var_location) (rtx); + + /* Called from final_scan_insn if there is a switch between hot and cold + text sections. */ + void (* switch_text_section) (void); + + /* Records a direct call to the function DECL, noting the point of call + and the debug info for the function. Called from final_scan_insn + when ICF debugging is enabled. */ + void (* direct_call) (tree decl); + + /* Records the OBJ_TYPE_REF_TOKEN for a virtual call through ADDR, which + for C++ is the vtable slot index, noting the INSN_UID for the call + instruction. Called from calls.c:emit_call_1 when ICF debugging is + enabled. It's necessary to do this during lowering because the + call instruction and the OBJ_TYPE_REF become separated after that + point. */ + void (* virtual_call_token) (tree addr, int insn_uid); + + /* Copies the OBJ_TYPE_REF_TOKEN for a virtual call from OLD_INSN to + NEW_INSN. Called from emit-rtl.c:try_split when a CALL_INSN is + split, so that the vtable slot index remains associated with the + new CALL_INSN. */ + void (* copy_call_info) (rtx old_insn, rtx new_insn); + + /* Records a virtual call given INSN_UID, which is the UID of the call + instruction. The UID is then mapped to the vtable slot index noted + during the lowering phase. Called from final_scan_insn when ICF + debugging is enabled. */ + void (* virtual_call) (int insn_uid); + + /* Called from grokdeclarator. Replaces the anonymous name with the + type name. */ + void (* set_name) (tree, tree); + + /* This is 1 if the debug writer wants to see start and end commands for the + main source files, and 0 otherwise. */ + int start_end_main_source_file; + + /* The type of symtab field used by these debug hooks. This is one + of the TYPE_SYMTAB_IS_xxx values defined in tree.h. */ + int tree_type_symtab_field; +}; + +extern const struct gcc_debug_hooks *debug_hooks; + +/* The do-nothing hooks. */ +extern void debug_nothing_void (void); +extern void debug_nothing_charstar (const char *); +extern void debug_nothing_int_charstar (unsigned int, const char *); +extern void debug_nothing_int_charstar_int_bool (unsigned int, const char *, + int, bool); +extern void debug_nothing_int (unsigned int); +extern void debug_nothing_int_int (unsigned int, unsigned int); +extern void debug_nothing_tree (tree); +extern void debug_nothing_tree_tree (tree, tree); +extern void debug_nothing_tree_int (tree, int); +extern void debug_nothing_tree_tree_tree_bool (tree, tree, tree, bool); +extern bool debug_true_const_tree (const_tree); +extern void debug_nothing_rtx (rtx); +extern void debug_nothing_rtx_rtx (rtx, rtx); +extern void debug_nothing_uid (int); + +/* Hooks for various debug formats. */ +extern const struct gcc_debug_hooks do_nothing_debug_hooks; +extern const struct gcc_debug_hooks dbx_debug_hooks; +extern const struct gcc_debug_hooks sdb_debug_hooks; +extern const struct gcc_debug_hooks xcoff_debug_hooks; +extern const struct gcc_debug_hooks dwarf2_debug_hooks; +extern const struct gcc_debug_hooks vmsdbg_debug_hooks; + +/* Dwarf2 frame information. */ + +extern void dwarf2out_begin_prologue (unsigned int, const char *); +extern void dwarf2out_vms_end_prologue (unsigned int, const char *); +extern void dwarf2out_vms_begin_epilogue (unsigned int, const char *); +extern void dwarf2out_end_epilogue (unsigned int, const char *); +extern void dwarf2out_frame_init (void); +extern void dwarf2out_frame_finish (void); +/* Decide whether we want to emit frame unwind information for the current + translation unit. */ +extern int dwarf2out_do_frame (void); +extern int dwarf2out_do_cfi_asm (void); +extern void dwarf2out_switch_text_section (void); + +extern void debug_flush_symbol_queue (void); +extern void debug_queue_symbol (tree); +extern void debug_free_queue (void); +extern int debug_nesting; +extern int symbol_queue_index; + +const char *remap_debug_filename (const char *); +void add_debug_prefix_map (const char *); + +/* For -fdump-go-spec. */ + +extern const struct gcc_debug_hooks * +dump_go_spec_init (const char *, const struct gcc_debug_hooks *); + +#endif /* !GCC_DEBUG_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/defaults.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/defaults.h new file mode 100644 index 0000000..815ddd2 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/defaults.h @@ -0,0 +1,1342 @@ +/* Definitions of various defaults for tm.h macros. + Copyright (C) 1992, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, + 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Ron Guilmette (rfg@monkeys.com) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +#ifndef GCC_DEFAULTS_H +#define GCC_DEFAULTS_H + +/* 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) asm_fprintf ((FILE), "%U%s", (NAME)) +#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 + +/* Determines whether we may use common symbols to represent one-only + semantics (a.k.a. "vague linkage"). */ +#ifndef USE_COMMON_FOR_ONE_ONLY +# define USE_COMMON_FOR_ONE_ONLY 1 +#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 duplicate library search directories can be removed from a + linker command without changing the linker's semantics, give this + symbol a nonzero. */ +#ifndef LINK_ELIMINATE_DUPLICATE_LDIRECTORIES +#define LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 0 +#endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */ + +/* 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_IN_DATA_SECTION) +#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 + +/* If we have named section and we support weak symbols, then use the + .jcr section for recording java classes which need to be registered + at program start-up time. */ +#if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK +#ifndef JCR_SECTION_NAME +#define JCR_SECTION_NAME ".jcr" +#endif +#endif + +/* This decision to use a .jcr section can be overridden by defining + USE_JCR_SECTION to 0 in target file. This is necessary if target + can define JCR_SECTION_NAME but does not have crtstuff or + linker support for .jcr section. */ +#ifndef TARGET_USE_JCR_SECTION +#ifdef JCR_SECTION_NAME +#define TARGET_USE_JCR_SECTION 1 +#else +#define TARGET_USE_JCR_SECTION 0 +#endif +#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 + +/* 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 + +/* 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_UNIT +#define BITS_PER_UNIT 8 +#endif + +#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 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 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 + +/* 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 + +/* If more than one debugging type is supported, you must define + PREFERRED_DEBUGGING_TYPE to choose the default. */ + +#if 1 < (defined (DBX_DEBUGGING_INFO) + defined (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 defined SDB_DEBUGGING_INFO +#define PREFERRED_DEBUGGING_TYPE SDB_DEBUG + +#elif defined DWARF2_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 LARGEST_EXPONENT_IS_NORMAL +#define LARGEST_EXPONENT_IS_NORMAL(SIZE) 0 +#endif + +#ifndef ROUND_TOWARDS_ZERO +#define ROUND_TOWARDS_ZERO 0 +#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 + +#ifdef TARGET_FLT_EVAL_METHOD +#define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 1 +#else +#define TARGET_FLT_EVAL_METHOD 0 +#define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 0 +#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 none of these macros are defined, the port must use the new + technique of defining constraints in the machine description. + tm_p.h will define those macros that machine-independent code + still uses. */ +#if !defined CONSTRAINT_LEN \ + && !defined REG_CLASS_FROM_LETTER \ + && !defined REG_CLASS_FROM_CONSTRAINT \ + && !defined CONST_OK_FOR_LETTER_P \ + && !defined CONST_OK_FOR_CONSTRAINT_P \ + && !defined CONST_DOUBLE_OK_FOR_LETTER_P \ + && !defined CONST_DOUBLE_OK_FOR_CONSTRAINT_P \ + && !defined EXTRA_CONSTRAINT \ + && !defined EXTRA_CONSTRAINT_STR \ + && !defined EXTRA_MEMORY_CONSTRAINT \ + && !defined EXTRA_ADDRESS_CONSTRAINT + +#define USE_MD_CONSTRAINTS + +#if GCC_VERSION >= 3000 && defined IN_GCC +/* These old constraint macros shouldn't appear anywhere in a + configuration using MD constraint definitions. */ +#pragma GCC poison REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P \ + CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT +#endif + +#else /* old constraint mechanism in use */ + +/* Determine whether extra constraint letter should be handled + via address reload (like 'o'). */ +#ifndef EXTRA_MEMORY_CONSTRAINT +#define EXTRA_MEMORY_CONSTRAINT(C,STR) 0 +#endif + +/* Determine whether extra constraint letter should be handled + as an address (like 'p'). */ +#ifndef EXTRA_ADDRESS_CONSTRAINT +#define EXTRA_ADDRESS_CONSTRAINT(C,STR) 0 +#endif + +/* When a port defines CONSTRAINT_LEN, it should use DEFAULT_CONSTRAINT_LEN + for all the characters that it does not want to change, so things like the + 'length' of a digit in a matching constraint is an implementation detail, + and not part of the interface. */ +#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 + +#ifndef CONSTRAINT_LEN +#define CONSTRAINT_LEN(C,STR) DEFAULT_CONSTRAINT_LEN (C, STR) +#endif + +#if defined (CONST_OK_FOR_LETTER_P) && ! defined (CONST_OK_FOR_CONSTRAINT_P) +#define CONST_OK_FOR_CONSTRAINT_P(VAL,C,STR) CONST_OK_FOR_LETTER_P (VAL, C) +#endif + +#if defined (CONST_DOUBLE_OK_FOR_LETTER_P) && ! defined (CONST_DOUBLE_OK_FOR_CONSTRAINT_P) +#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(OP,C,STR) \ + CONST_DOUBLE_OK_FOR_LETTER_P (OP, C) +#endif + +#ifndef REG_CLASS_FROM_CONSTRAINT +#define REG_CLASS_FROM_CONSTRAINT(C,STR) REG_CLASS_FROM_LETTER (C) +#endif + +#if defined (EXTRA_CONSTRAINT) && ! defined (EXTRA_CONSTRAINT_STR) +#define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C) +#endif + +#endif /* old constraint mechanism in use */ + +/* Determine whether the entire c99 runtime + is present in the runtime library. */ +#ifndef TARGET_C99_FUNCTIONS +#define TARGET_C99_FUNCTIONS 0 +#endif + +/* Determine whether the target runtime library has + a sincos implementation following the GNU extension. */ +#ifndef TARGET_HAS_SINCOS +#define TARGET_HAS_SINCOS 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 + +#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 + +/* 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 + +/* Assume that trampolines need function alignment. */ +#ifndef TRAMPOLINE_ALIGNMENT +#define TRAMPOLINE_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 + +/* 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 + +/* Many ports have no mode-dependent addresses (except possibly autoincrement + and autodecrement addresses, which are handled by target-independent code + in recog.c). */ +#ifndef GO_IF_MODE_DEPENDENT_ADDRESS +#define GO_IF_MODE_DEPENDENT_ADDRESS(X, WIN) +#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 + +#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 + +/* 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 \ + (targetm.except_unwind_info (&global_options) == UI_SJLJ \ + ? 75 * UNITS_PER_WORD \ + : 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 \ + (targetm.except_unwind_info (&global_options) == UI_SJLJ \ + ? 75 * UNITS_PER_WORD \ + : 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 + +#ifndef SWITCHABLE_TARGET +#define SWITCHABLE_TARGET 0 +#endif + +#endif /* GCC_INSN_FLAGS_H */ + +#endif /* ! GCC_DEFAULTS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic-core.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic-core.h new file mode 100644 index 0000000..a9edb0d --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic-core.h @@ -0,0 +1,91 @@ +/* Declarations of core diagnostic functionality for code that does + not need to deal with diagnostic contexts or diagnostic info + structures. + Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, + 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_DIAGNOSTIC_CORE_H +#define GCC_DIAGNOSTIC_CORE_H + +#include "input.h" +#include "bversion.h" + +/* Constants used to discriminate diagnostics. */ +typedef enum +{ +#define DEFINE_DIAGNOSTIC_KIND(K, msgid) K, +#include "diagnostic.def" +#undef DEFINE_DIAGNOSTIC_KIND + DK_LAST_DIAGNOSTIC_KIND, + /* This is used for tagging pragma pops in the diagnostic + classification history chain. */ + DK_POP +} diagnostic_t; + +extern const char *progname; + +extern const char *trim_filename (const char *); + +/* If we haven't already defined a front-end-specific diagnostics + style, use the generic one. */ +#ifndef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_tdiag__ +#endif +/* None of these functions are suitable for ATTRIBUTE_PRINTF, because + each language front end can extend them with its own set of format + specifiers. We must use custom format checks. */ +#if (ENABLE_CHECKING && GCC_VERSION >= 4001) || GCC_VERSION == BUILDING_GCC_VERSION +#define ATTRIBUTE_GCC_DIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m) +#else +#define ATTRIBUTE_GCC_DIAG(m, n) ATTRIBUTE_NONNULL(m) +#endif +extern void internal_error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2) + ATTRIBUTE_NORETURN; +/* Pass one of the OPT_W* from options.h as the first parameter. */ +extern bool warning (int, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); +extern bool warning_at (location_t, int, const char *, ...) + ATTRIBUTE_GCC_DIAG(3,4); +extern void error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); +extern void error_n (location_t, int, const char *, const char *, ...) + ATTRIBUTE_GCC_DIAG(3,5) ATTRIBUTE_GCC_DIAG(4,5); +extern void error_at (location_t, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); +extern void fatal_error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2) + ATTRIBUTE_NORETURN; +/* Pass one of the OPT_W* from options.h as the second parameter. */ +extern bool pedwarn (location_t, int, const char *, ...) + ATTRIBUTE_GCC_DIAG(3,4); +extern bool permerror (location_t, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); +extern void sorry (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); +extern void inform (location_t, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); +extern void inform_n (location_t, int, const char *, const char *, ...) + ATTRIBUTE_GCC_DIAG(3,5) ATTRIBUTE_GCC_DIAG(4,5); +extern void verbatim (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); +extern bool emit_diagnostic (diagnostic_t, location_t, int, + const char *, ...) ATTRIBUTE_GCC_DIAG(4,5); +extern bool seen_error (void); + +#ifdef BUFSIZ + /* N.B. Unlike all the others, fnotice is just gettext+fprintf, and + therefore it can have ATTRIBUTE_PRINTF. */ +extern void fnotice (FILE *, const char *, ...) + ATTRIBUTE_PRINTF_2; +#endif + +#endif /* ! GCC_DIAGNOSTIC_CORE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic.def new file mode 100644 index 0000000..e13bd3c --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic.def @@ -0,0 +1,45 @@ +/* Copyright (C) 2001, 2002, 2003, 2006, 2008 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/>. */ + +/* DK_UNSPECIFIED must be first so it has a value of zero. We never + assign this kind to an actual diagnostic, we only use this in + variables that can hold a kind, to mean they have yet to have a + kind specified. I.e. they're uninitialized. Within the diagnostic + machinery, this kind also means "don't change the existing kind", + meaning "no change is specified". */ +DEFINE_DIAGNOSTIC_KIND (DK_UNSPECIFIED, "") + +/* If a diagnostic is set to DK_IGNORED, it won't get reported at all. + This is used by the diagnostic machinery when it wants to disable a + diagnostic without disabling the option which causes it. */ +DEFINE_DIAGNOSTIC_KIND (DK_IGNORED, "") + +/* The remainder are real diagnostic types. */ +DEFINE_DIAGNOSTIC_KIND (DK_FATAL, "fatal error: ") +DEFINE_DIAGNOSTIC_KIND (DK_ICE, "internal compiler error: ") +DEFINE_DIAGNOSTIC_KIND (DK_ERROR, "error: ") +DEFINE_DIAGNOSTIC_KIND (DK_SORRY, "sorry, unimplemented: ") +DEFINE_DIAGNOSTIC_KIND (DK_WARNING, "warning: ") +DEFINE_DIAGNOSTIC_KIND (DK_ANACHRONISM, "anachronism: ") +DEFINE_DIAGNOSTIC_KIND (DK_NOTE, "note: ") +DEFINE_DIAGNOSTIC_KIND (DK_DEBUG, "debug: ") +/* These two would be re-classified as DK_WARNING or DK_ERROR, so the +prefix does not matter. */ +DEFINE_DIAGNOSTIC_KIND (DK_PEDWARN, "pedwarn: ") +DEFINE_DIAGNOSTIC_KIND (DK_PERMERROR, "permerror: ") + diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic.h new file mode 100644 index 0000000..8074354 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/diagnostic.h @@ -0,0 +1,282 @@ +/* Various declarations for language-independent diagnostics subroutines. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + 2010, Free Software Foundation, Inc. + Contributed by Gabriel Dos Reis <gdr@codesourcery.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_DIAGNOSTIC_H +#define GCC_DIAGNOSTIC_H + +#include "pretty-print.h" +#include "diagnostic-core.h" + +/* A diagnostic is described by the MESSAGE to send, the FILE and LINE of + its context and its KIND (ice, error, warning, note, ...) See complete + list in diagnostic.def. */ +typedef struct diagnostic_info +{ + text_info message; + location_t location; + unsigned int override_column; + /* Auxiliary data for client. */ + void *x_data; + /* The kind of diagnostic it is about. */ + diagnostic_t kind; + /* Which OPT_* directly controls this diagnostic. */ + int option_index; +} diagnostic_info; + +/* Each time a diagnostic's classification is changed with a pragma, + we record the change and the location of the change in an array of + these structs. */ +typedef struct diagnostic_classification_change_t +{ + location_t location; + int option; + diagnostic_t kind; +} diagnostic_classification_change_t; + +/* Forward declarations. */ +typedef void (*diagnostic_starter_fn) (diagnostic_context *, + diagnostic_info *); +typedef diagnostic_starter_fn diagnostic_finalizer_fn; + +/* This data structure bundles altogether any information relevant to + the context of a diagnostic message. */ +struct diagnostic_context +{ + /* Where most of the diagnostic formatting work is done. */ + pretty_printer *printer; + + /* The number of times we have issued diagnostics. */ + int diagnostic_count[DK_LAST_DIAGNOSTIC_KIND]; + + /* True if we should display the "warnings are being tread as error" + message, usually displayed once per compiler run. */ + bool some_warnings_are_errors; + + /* True if it has been requested that warnings be treated as errors. */ + bool warning_as_error_requested; + + /* The number of option indexes that can be passed to warning() et + al. */ + int n_opts; + + /* For each option index that can be passed to warning() et al + (OPT_* from options.h when using this code with the core GCC + options), this array may contain a new kind that the diagnostic + should be changed to before reporting, or DK_UNSPECIFIED to leave + it as the reported kind, or DK_IGNORED to not report it at + all. */ + diagnostic_t *classify_diagnostic; + + /* History of all changes to the classifications above. This list + is stored in location-order, so we can search it, either + binary-wise or end-to-front, to find the most recent + classification for a given diagnostic, given the location of the + diagnostic. */ + diagnostic_classification_change_t *classification_history; + + /* The size of the above array. */ + int n_classification_history; + + /* For pragma push/pop. */ + int *push_list; + int n_push; + + /* True if we should print the command line option which controls + each diagnostic, if known. */ + bool show_option_requested; + + /* True if we should raise a SIGABRT on errors. */ + bool abort_on_error; + + /* True if we should show the column number on diagnostics. */ + bool show_column; + + /* True if pedwarns are errors. */ + bool pedantic_errors; + + /* True if permerrors are warnings. */ + bool permissive; + + /* The index of the option to associate with turning permerrors into + warnings. */ + int opt_permissive; + + /* True if errors are fatal. */ + bool fatal_errors; + + /* True if all warnings should be disabled. */ + bool dc_inhibit_warnings; + + /* True if warnings should be given in system headers. */ + bool dc_warn_system_headers; + + /* Maximum number of errors to report. */ + unsigned int max_errors; + + /* This function is called before any message is printed out. It is + responsible for preparing message prefix and such. For example, it + might say: + In file included from "/usr/local/include/curses.h:5: + from "/home/gdr/src/nifty_printer.h:56: + ... + */ + diagnostic_starter_fn begin_diagnostic; + + /* This function is called after the diagnostic message is printed. */ + diagnostic_finalizer_fn end_diagnostic; + + /* Client hook to report an internal error. */ + void (*internal_error) (diagnostic_context *, const char *, va_list *); + + /* Client hook to say whether the option controlling a diagnostic is + enabled. Returns nonzero if enabled, zero if disabled. */ + int (*option_enabled) (int, void *); + + /* Client information to pass as second argument to + option_enabled. */ + void *option_state; + + /* Client hook to return the name of an option that controls a + diagnostic. Returns malloced memory. The first diagnostic_t + argument is the kind of diagnostic before any reclassification + (of warnings as errors, etc.); the second is the kind after any + reclassification. May return NULL if no name is to be printed. + May be passed 0 as well as the index of a particular option. */ + char *(*option_name) (diagnostic_context *, int, diagnostic_t, diagnostic_t); + + /* Auxiliary data for client. */ + void *x_data; + + /* Used to detect when the input file stack has changed since last + described. */ + const struct line_map *last_module; + + int lock; + + bool inhibit_notes_p; +}; + +static inline void +diagnostic_inhibit_notes (diagnostic_context * context) +{ + context->inhibit_notes_p = true; +} + + +/* Client supplied function to announce a diagnostic. */ +#define diagnostic_starter(DC) (DC)->begin_diagnostic + +/* Client supplied function called after a diagnostic message is + displayed. */ +#define diagnostic_finalizer(DC) (DC)->end_diagnostic + +/* Extension hooks for client. */ +#define diagnostic_context_auxiliary_data(DC) (DC)->x_data +#define diagnostic_info_auxiliary_data(DI) (DI)->x_data + +/* Same as pp_format_decoder. Works on 'diagnostic_context *'. */ +#define diagnostic_format_decoder(DC) ((DC)->printer->format_decoder) + +/* Same as output_prefixing_rule. Works on 'diagnostic_context *'. */ +#define diagnostic_prefixing_rule(DC) ((DC)->printer->wrapping.rule) + +/* Maximum characters per line in automatic line wrapping mode. + Zero means don't wrap lines. */ +#define diagnostic_line_cutoff(DC) ((DC)->printer->wrapping.line_cutoff) + +#define diagnostic_flush_buffer(DC) pp_base_flush ((DC)->printer) + +/* True if the last module or file in which a diagnostic was reported is + different from the current one. */ +#define diagnostic_last_module_changed(DC, MAP) \ + ((DC)->last_module != MAP) + +/* Remember the current module or file as being the last one in which we + report a diagnostic. */ +#define diagnostic_set_last_module(DC, MAP) \ + (DC)->last_module = MAP + +/* Raise SIGABRT on any diagnostic of severity DK_ERROR or higher. */ +#define diagnostic_abort_on_error(DC) \ + (DC)->abort_on_error = true + +/* This diagnostic_context is used by front-ends that directly output + diagnostic messages without going through `error', `warning', + and similar functions. */ +extern diagnostic_context *global_dc; + +/* The total count of a KIND of diagnostics emitted so far. */ +#define diagnostic_kind_count(DC, DK) (DC)->diagnostic_count[(int) (DK)] + +/* The number of errors that have been issued so far. Ideally, these + would take a diagnostic_context as an argument. */ +#define errorcount diagnostic_kind_count (global_dc, DK_ERROR) +/* Similarly, but for warnings. */ +#define warningcount diagnostic_kind_count (global_dc, DK_WARNING) +/* Similarly, but for sorrys. */ +#define sorrycount diagnostic_kind_count (global_dc, DK_SORRY) + +/* Returns nonzero if warnings should be emitted. */ +#define diagnostic_report_warnings_p(DC, LOC) \ + (!(DC)->dc_inhibit_warnings \ + && !(in_system_header_at (LOC) && !(DC)->dc_warn_system_headers)) + +#define report_diagnostic(D) diagnostic_report_diagnostic (global_dc, D) + +/* Override the column number to be used for reporting a + diagnostic. */ +#define diagnostic_override_column(DI, COL) (DI)->override_column = (COL) + +/* Override the option index to be used for reporting a + diagnostic. */ +#define diagnostic_override_option_index(DI, OPTIDX) \ + ((DI)->option_index = (OPTIDX)) + +/* Diagnostic related functions. */ +extern void diagnostic_initialize (diagnostic_context *, int); +extern void diagnostic_finish (diagnostic_context *); +extern void diagnostic_report_current_module (diagnostic_context *); + +/* Force diagnostics controlled by OPTIDX to be kind KIND. */ +extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *, + int /* optidx */, + diagnostic_t /* kind */, + location_t); +extern void diagnostic_push_diagnostics (diagnostic_context *, location_t); +extern void diagnostic_pop_diagnostics (diagnostic_context *, location_t); +extern bool diagnostic_report_diagnostic (diagnostic_context *, + diagnostic_info *); +#ifdef ATTRIBUTE_GCC_DIAG +extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *, + location_t, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0); +extern void diagnostic_set_info_translated (diagnostic_info *, const char *, + va_list *, location_t, + diagnostic_t) + ATTRIBUTE_GCC_DIAG(2,0); +#endif +extern char *diagnostic_build_prefix (diagnostic_context *, diagnostic_info *); +void default_diagnostic_starter (diagnostic_context *, diagnostic_info *); +void default_diagnostic_finalizer (diagnostic_context *, diagnostic_info *); + +/* Pure text formatting support functions. */ +extern char *file_name_as_prefix (const char *); + +#endif /* ! GCC_DIAGNOSTIC_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/double-int.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/double-int.h new file mode 100644 index 0000000..6d15551 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/double-int.h @@ -0,0 +1,320 @@ +/* Operations with long integers. + Copyright (C) 2006, 2007, 2008, 2010 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/>. */ + +#ifndef DOUBLE_INT_H +#define DOUBLE_INT_H + +#ifndef GENERATOR_FILE +#include <gmp.h> +#endif +#include "coretypes.h" + +/* A large integer is currently represented as a pair of HOST_WIDE_INTs. + It therefore represents a number with precision of + 2 * HOST_BITS_PER_WIDE_INT bits (it is however possible that the + internal representation will change, if numbers with greater precision + are needed, so the users should not rely on it). The representation does + not contain any information about signedness of the represented value, so + it can be used to represent both signed and unsigned numbers. For + operations where the results depend on signedness (division, comparisons), + it must be specified separately. For each such operation, there are three + versions of the function -- double_int_op, that takes an extra UNS argument + giving the signedness of the values, and double_int_sop and double_int_uop + that stand for its specializations for signed and unsigned values. + + You may also represent with numbers in smaller precision using double_int. + You however need to use double_int_ext (that fills in the bits of the + number over the prescribed precision with zeros or with the sign bit) before + operations that do not perform arithmetics modulo 2^precision (comparisons, + division), and possibly before storing the results, if you want to keep + them in some canonical form). In general, the signedness of double_int_ext + should match the signedness of the operation. + + ??? The components of double_int differ in signedness mostly for + historical reasons (they replace an older structure used to represent + numbers with precision higher than HOST_WIDE_INT). It might be less + confusing to have them both signed or both unsigned. */ + +typedef struct +{ + unsigned HOST_WIDE_INT low; + HOST_WIDE_INT high; +} double_int; + +#define HOST_BITS_PER_DOUBLE_INT (2 * HOST_BITS_PER_WIDE_INT) + +/* Constructors and conversions. */ + +/* Constructs double_int from integer CST. The bits over the precision of + HOST_WIDE_INT are filled with the sign bit. */ + +static inline double_int +shwi_to_double_int (HOST_WIDE_INT cst) +{ + double_int r; + + r.low = (unsigned HOST_WIDE_INT) cst; + r.high = cst < 0 ? -1 : 0; + + return r; +} + +/* Some useful constants. */ + +#define double_int_minus_one (shwi_to_double_int (-1)) +#define double_int_zero (shwi_to_double_int (0)) +#define double_int_one (shwi_to_double_int (1)) +#define double_int_two (shwi_to_double_int (2)) +#define double_int_ten (shwi_to_double_int (10)) + +/* Constructs double_int from unsigned integer CST. The bits over the + precision of HOST_WIDE_INT are filled with zeros. */ + +static inline double_int +uhwi_to_double_int (unsigned HOST_WIDE_INT cst) +{ + double_int r; + + r.low = cst; + r.high = 0; + + return r; +} + +/* Returns value of CST as a signed number. CST must satisfy + double_int_fits_in_shwi_p. */ + +static inline HOST_WIDE_INT +double_int_to_shwi (double_int cst) +{ + return (HOST_WIDE_INT) cst.low; +} + +/* Returns value of CST as an unsigned number. CST must satisfy + double_int_fits_in_uhwi_p. */ + +static inline unsigned HOST_WIDE_INT +double_int_to_uhwi (double_int cst) +{ + return cst.low; +} + +bool double_int_fits_in_hwi_p (double_int, bool); +bool double_int_fits_in_shwi_p (double_int); + +/* Returns true if CST fits in unsigned HOST_WIDE_INT. */ + +static inline bool +double_int_fits_in_uhwi_p (double_int cst) +{ + return cst.high == 0; +} + +/* The following operations perform arithmetics modulo 2^precision, + so you do not need to call double_int_ext between them, even if + you are representing numbers with precision less than + 2 * HOST_BITS_PER_WIDE_INT bits. */ + +double_int double_int_mul (double_int, double_int); +double_int double_int_mul_with_sign (double_int, double_int, bool, int *); +double_int double_int_add (double_int, double_int); +double_int double_int_sub (double_int, double_int); +double_int double_int_neg (double_int); + +/* You must ensure that double_int_ext is called on the operands + of the following operations, if the precision of the numbers + is less than 2 * HOST_BITS_PER_WIDE_INT bits. */ +double_int double_int_div (double_int, double_int, bool, unsigned); +double_int double_int_sdiv (double_int, double_int, unsigned); +double_int double_int_udiv (double_int, double_int, unsigned); +double_int double_int_mod (double_int, double_int, bool, unsigned); +double_int double_int_smod (double_int, double_int, unsigned); +double_int double_int_umod (double_int, double_int, unsigned); +double_int double_int_divmod (double_int, double_int, bool, unsigned, double_int *); +double_int double_int_sdivmod (double_int, double_int, unsigned, double_int *); +double_int double_int_udivmod (double_int, double_int, unsigned, double_int *); + +double_int double_int_setbit (double_int, unsigned); +int double_int_ctz (double_int); + +/* Logical operations. */ + +/* Returns ~A. */ + +static inline double_int +double_int_not (double_int a) +{ + a.low = ~a.low; + a.high = ~a.high; + return a; +} + +/* Returns A | B. */ + +static inline double_int +double_int_ior (double_int a, double_int b) +{ + a.low |= b.low; + a.high |= b.high; + return a; +} + +/* Returns A & B. */ + +static inline double_int +double_int_and (double_int a, double_int b) +{ + a.low &= b.low; + a.high &= b.high; + return a; +} + +/* Returns A & ~B. */ + +static inline double_int +double_int_and_not (double_int a, double_int b) +{ + a.low &= ~b.low; + a.high &= ~b.high; + return a; +} + +/* Returns A ^ B. */ + +static inline double_int +double_int_xor (double_int a, double_int b) +{ + a.low ^= b.low; + a.high ^= b.high; + return a; +} + + +/* Shift operations. */ +double_int double_int_lshift (double_int, HOST_WIDE_INT, unsigned int, bool); +double_int double_int_rshift (double_int, HOST_WIDE_INT, unsigned int, bool); +double_int double_int_lrotate (double_int, HOST_WIDE_INT, unsigned int); +double_int double_int_rrotate (double_int, HOST_WIDE_INT, unsigned int); + +/* Returns true if CST is negative. Of course, CST is considered to + be signed. */ + +static inline bool +double_int_negative_p (double_int cst) +{ + return cst.high < 0; +} + +int double_int_cmp (double_int, double_int, bool); +int double_int_scmp (double_int, double_int); +int double_int_ucmp (double_int, double_int); + +double_int double_int_max (double_int, double_int, bool); +double_int double_int_smax (double_int, double_int); +double_int double_int_umax (double_int, double_int); + +double_int double_int_min (double_int, double_int, bool); +double_int double_int_smin (double_int, double_int); +double_int double_int_umin (double_int, double_int); + +void dump_double_int (FILE *, double_int, bool); + +/* Zero and sign extension of numbers in smaller precisions. */ + +double_int double_int_ext (double_int, unsigned, bool); +double_int double_int_sext (double_int, unsigned); +double_int double_int_zext (double_int, unsigned); +double_int double_int_mask (unsigned); + +#define ALL_ONES (~((unsigned HOST_WIDE_INT) 0)) + +/* The operands of the following comparison functions must be processed + with double_int_ext, if their precision is less than + 2 * HOST_BITS_PER_WIDE_INT bits. */ + +/* Returns true if CST is zero. */ + +static inline bool +double_int_zero_p (double_int cst) +{ + return cst.low == 0 && cst.high == 0; +} + +/* Returns true if CST is one. */ + +static inline bool +double_int_one_p (double_int cst) +{ + return cst.low == 1 && cst.high == 0; +} + +/* Returns true if CST is minus one. */ + +static inline bool +double_int_minus_one_p (double_int cst) +{ + return (cst.low == ALL_ONES && cst.high == -1); +} + +/* Returns true if CST1 == CST2. */ + +static inline bool +double_int_equal_p (double_int cst1, double_int cst2) +{ + return cst1.low == cst2.low && cst1.high == cst2.high; +} + + +/* Legacy interface with decomposed high/low parts. */ + +extern int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT, + unsigned HOST_WIDE_INT, HOST_WIDE_INT, + unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, + bool); +#define add_double(l1,h1,l2,h2,lv,hv) \ + add_double_with_sign (l1, h1, l2, h2, lv, hv, false) +extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT, + unsigned HOST_WIDE_INT *, HOST_WIDE_INT *); +extern int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT, + unsigned HOST_WIDE_INT, HOST_WIDE_INT, + unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, + bool); +#define mul_double(l1,h1,l2,h2,lv,hv) \ + mul_double_with_sign (l1, h1, l2, h2, lv, hv, false) +extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT, + HOST_WIDE_INT, unsigned int, + unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, bool); +extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT, + HOST_WIDE_INT, unsigned int, + unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, bool); +extern int div_and_round_double (unsigned, int, unsigned HOST_WIDE_INT, + HOST_WIDE_INT, unsigned HOST_WIDE_INT, + HOST_WIDE_INT, unsigned HOST_WIDE_INT *, + HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, + HOST_WIDE_INT *); + + +#ifndef GENERATOR_FILE +/* Conversion to and from GMP integer representations. */ + +void mpz_set_double_int (mpz_t, double_int, bool); +double_int mpz_get_double_int (const_tree, mpz_t, bool); +#endif + +#endif /* DOUBLE_INT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/emit-rtl.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/emit-rtl.h new file mode 100644 index 0000000..31f1da0 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/emit-rtl.h @@ -0,0 +1,107 @@ +/* Exported functions from emit-rtl.c + Copyright (C) 2004, 2007, 2008, 2010 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/>. */ + +#ifndef GCC_EMIT_RTL_H +#define GCC_EMIT_RTL_H + +/* Set the alias set of MEM to SET. */ +extern void set_mem_alias_set (rtx, alias_set_type); + +/* Set the alignment of MEM to ALIGN bits. */ +extern void set_mem_align (rtx, unsigned int); + +/* Set the address space of MEM to ADDRSPACE. */ +extern void set_mem_addr_space (rtx, addr_space_t); + +/* Set the expr for MEM to EXPR. */ +extern void set_mem_expr (rtx, tree); + +/* Set the offset for MEM to OFFSET. */ +extern void set_mem_offset (rtx, rtx); + +/* Set the size for MEM to SIZE. */ +extern void set_mem_size (rtx, rtx); + +/* Set the attributes for MEM appropriate for a spill slot. */ +extern void set_mem_attrs_for_spill (rtx); +extern tree get_spill_slot_decl (bool); + +/* Return a memory reference like MEMREF, but with its address changed to + ADDR. The caller is asserting that the actual piece of memory pointed + to is the same, just the form of the address is being changed, such as + by putting something into a register. */ +extern rtx replace_equiv_address (rtx, rtx); + +/* Likewise, but the reference is not required to be valid. */ +extern rtx replace_equiv_address_nv (rtx, rtx); + +extern rtx gen_blockage (void); +extern rtvec gen_rtvec (int, ...); +extern rtx copy_insn_1 (rtx); +extern rtx copy_insn (rtx); +extern rtx gen_int_mode (HOST_WIDE_INT, enum machine_mode); +extern rtx emit_copy_of_insn_after (rtx, rtx); +extern void set_reg_attrs_from_value (rtx, rtx); +extern void set_reg_attrs_for_parm (rtx, rtx); +extern void set_reg_attrs_for_decl_rtl (tree t, rtx x); +extern void adjust_reg_mode (rtx, enum machine_mode); +extern int mem_expr_equal_p (const_tree, const_tree); + +/* Return the first insn of the current sequence or current function. */ + +static inline rtx +get_insns (void) +{ + return crtl->emit.x_first_insn; +} + +/* Specify a new insn as the first in the chain. */ + +static inline void +set_first_insn (rtx insn) +{ + gcc_checking_assert (!insn || !PREV_INSN (insn)); + crtl->emit.x_first_insn = insn; +} + +/* Return the last insn emitted in current sequence or current function. */ + +static inline rtx +get_last_insn (void) +{ + return crtl->emit.x_last_insn; +} + +/* Specify a new insn as the last in the chain. */ + +static inline void +set_last_insn (rtx insn) +{ + gcc_checking_assert (!insn || !NEXT_INSN (insn)); + crtl->emit.x_last_insn = insn; +} + +/* Return a number larger than any instruction's uid in this function. */ + +static inline int +get_max_uid (void) +{ + return crtl->emit.x_cur_insn_uid; +} +#endif /* GCC_EMIT_RTL_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/except.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/except.h new file mode 100644 index 0000000..14eca87 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/except.h @@ -0,0 +1,339 @@ +/* Exception Handling interface routines. + Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, + 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Contributed by Mike Stump <mrs@cygnus.com>. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* No include guards here, but define an include file marker anyway, so + that the compiler can keep track of where this file is included. This + is e.g. used to avoid including this file in front-end specific files. */ +#ifndef GCC_EXCEPT_H +# define GCC_EXCEPT_H +#endif + +#include "hashtab.h" +#include "vecprim.h" +#include "vecir.h" + +struct function; +struct eh_region_d; +struct pointer_map_t; + +/* The type of an exception region. */ +enum eh_region_type +{ + /* CLEANUP regions implement e.g. destructors run when exiting a block. + They can be generated from both GIMPLE_TRY_FINALLY and GIMPLE_TRY_CATCH + nodes. It is expected by the runtime that cleanup regions will *not* + resume normal program flow, but will continue propagation of the + exception. */ + ERT_CLEANUP, + + /* TRY regions implement catching an exception. The list of types associated + with the attached catch handlers is examined in order by the runtime and + control is transfered to the appropriate handler. Note that a NULL type + list is a catch-all handler, and that it will catch *all* exceptions + including those originating from a different language. */ + ERT_TRY, + + /* ALLOWED_EXCEPTIONS regions implement exception filtering, e.g. the + throw(type-list) specification that can be added to C++ functions. + The runtime examines the thrown exception vs the type list, and if + the exception does not match, transfers control to the handler. The + normal handler for C++ calls __cxa_call_unexpected. */ + ERT_ALLOWED_EXCEPTIONS, + + /* MUST_NOT_THROW regions prevent all exceptions from propagating. This + region type is used in C++ to surround destructors being run inside a + CLEANUP region. This differs from an ALLOWED_EXCEPTIONS region with + an empty type list in that the runtime is prepared to terminate the + program directly. We only generate code for MUST_NOT_THROW regions + along control paths that are already handling an exception within the + current function. */ + ERT_MUST_NOT_THROW +}; + + +/* A landing pad for a given exception region. Any transfer of control + from the EH runtime to the function happens at a landing pad. */ + +struct GTY(()) eh_landing_pad_d +{ + /* The linked list of all landing pads associated with the region. */ + struct eh_landing_pad_d *next_lp; + + /* The region with which this landing pad is associated. */ + struct eh_region_d *region; + + /* At the gimple level, the location to which control will be transfered + for this landing pad. There can be both EH and normal edges into the + block containing the post-landing-pad label. */ + tree post_landing_pad; + + /* At the rtl level, the location to which the runtime will transfer + control. This differs from the post-landing-pad in that the target's + EXCEPTION_RECEIVER pattern will be expanded here, as well as other + bookkeeping specific to exceptions. There must not be normal edges + into the block containing the landing-pad label. */ + rtx landing_pad; + + /* The index of this landing pad within fun->eh->lp_array. */ + int index; +}; + +/* A catch handler associated with an ERT_TRY region. */ + +struct GTY(()) eh_catch_d +{ + /* The double-linked list of all catch handlers for the region. */ + struct eh_catch_d *next_catch; + struct eh_catch_d *prev_catch; + + /* A TREE_LIST of runtime type objects that this catch handler + will catch, or NULL if all exceptions are caught. */ + tree type_list; + + /* A TREE_LIST of INTEGER_CSTs that correspond to the type_list entries, + having been mapped by assign_filter_values. These integers are to be + compared against the __builtin_eh_filter value. */ + tree filter_list; + + /* The code that should be executed if this catch handler matches the + thrown exception. This label is only maintained until + pass_lower_eh_dispatch, at which point it is cleared. */ + tree label; +}; + +/* Describes one exception region. */ + +struct GTY(()) eh_region_d +{ + /* The immediately surrounding region. */ + struct eh_region_d *outer; + + /* The list of immediately contained regions. */ + struct eh_region_d *inner; + struct eh_region_d *next_peer; + + /* The index of this region within fun->eh->region_array. */ + int index; + + /* Each region does exactly one thing. */ + enum eh_region_type type; + + /* Holds the action to perform based on the preceding type. */ + union eh_region_u { + struct eh_region_u_try { + /* The double-linked list of all catch handlers for this region. */ + struct eh_catch_d *first_catch; + struct eh_catch_d *last_catch; + } GTY ((tag ("ERT_TRY"))) eh_try; + + struct eh_region_u_allowed { + /* A TREE_LIST of runtime type objects allowed to pass. */ + tree type_list; + /* The code that should be executed if the thrown exception does + not match the type list. This label is only maintained until + pass_lower_eh_dispatch, at which point it is cleared. */ + tree label; + /* The integer that will be passed by the runtime to signal that + we should execute the code at LABEL. This integer is assigned + by assign_filter_values and is to be compared against the + __builtin_eh_filter value. */ + int filter; + } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed; + + struct eh_region_u_must_not_throw { + /* A function decl to be invoked if this region is actually reachable + from within the function, rather than implementable from the runtime. + The normal way for this to happen is for there to be a CLEANUP region + contained within this MUST_NOT_THROW region. Note that if the + runtime handles the MUST_NOT_THROW region, we have no control over + what termination function is called; it will be decided by the + personality function in effect for this CIE. */ + tree failure_decl; + /* The location assigned to the call of FAILURE_DECL, if expanded. */ + location_t failure_loc; + } GTY ((tag ("ERT_MUST_NOT_THROW"))) must_not_throw; + } GTY ((desc ("%0.type"))) u; + + /* The list of landing pads associated with this region. */ + struct eh_landing_pad_d *landing_pads; + + /* EXC_PTR and FILTER values copied from the runtime for this region. + Each region gets its own psuedos so that if there are nested exceptions + we do not overwrite the values of the first exception. */ + rtx exc_ptr_reg, filter_reg; + + /* True if this region should use __cxa_end_cleanup instead + of _Unwind_Resume. */ + bool use_cxa_end_cleanup; +}; + +typedef struct eh_landing_pad_d *eh_landing_pad; +typedef struct eh_catch_d *eh_catch; +typedef struct eh_region_d *eh_region; + +DEF_VEC_P(eh_region); +DEF_VEC_ALLOC_P(eh_region, gc); +DEF_VEC_ALLOC_P(eh_region, heap); + +DEF_VEC_P(eh_landing_pad); +DEF_VEC_ALLOC_P(eh_landing_pad, gc); + + +/* The exception status for each function. */ + +struct GTY(()) eh_status +{ + /* The tree of all regions for this function. */ + eh_region region_tree; + + /* The same information as an indexable array. */ + VEC(eh_region,gc) *region_array; + + /* The landing pads as an indexable array. */ + VEC(eh_landing_pad,gc) *lp_array; + + /* At the gimple level, a mapping from gimple statement to landing pad + or must-not-throw region. See record_stmt_eh_region. */ + htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table; + + /* All of the runtime type data used by the function. These objects + are emitted to the lang-specific-data-area for the function. */ + VEC(tree,gc) *ttype_data; + + /* The table of all action chains. These encode the eh_region tree in + a compact form for use by the runtime, and is also emitted to the + lang-specific-data-area. Note that the ARM EABI uses a different + format for the encoding than all other ports. */ + union eh_status_u { + VEC(tree,gc) * GTY((tag ("1"))) arm_eabi; + VEC(uchar,gc) * GTY((tag ("0"))) other; + } GTY ((desc ("targetm.arm_eabi_unwinder"))) ehspec_data; +}; + + +/* Invokes CALLBACK for every exception handler label. Only used by old + loop hackery; should not be used by new code. */ +extern void for_each_eh_label (void (*) (rtx)); + +extern void init_eh_for_function (void); + +extern void remove_eh_landing_pad (eh_landing_pad); +extern void remove_eh_handler (eh_region); + +extern bool current_function_has_exception_handlers (void); +extern void output_function_exception_table (const char *); + +extern rtx expand_builtin_eh_pointer (tree); +extern rtx expand_builtin_eh_filter (tree); +extern rtx expand_builtin_eh_copy_values (tree); +extern void expand_builtin_unwind_init (void); +extern rtx expand_builtin_eh_return_data_regno (tree); +extern rtx expand_builtin_extract_return_addr (tree); +extern void expand_builtin_init_dwarf_reg_sizes (tree); +extern rtx expand_builtin_frob_return_addr (tree); +extern rtx expand_builtin_dwarf_sp_column (void); +extern void expand_builtin_eh_return (tree, tree); +extern void expand_eh_return (void); +extern rtx expand_builtin_extend_pointer (tree); + +typedef tree (*duplicate_eh_regions_map) (tree, void *); +extern struct pointer_map_t *duplicate_eh_regions + (struct function *, eh_region, int, duplicate_eh_regions_map, void *); + +extern void sjlj_emit_function_exit_after (rtx); + +extern eh_region gen_eh_region_cleanup (eh_region); +extern eh_region gen_eh_region_try (eh_region); +extern eh_region gen_eh_region_allowed (eh_region, tree); +extern eh_region gen_eh_region_must_not_throw (eh_region); + +extern eh_catch gen_eh_region_catch (eh_region, tree); +extern eh_landing_pad gen_eh_landing_pad (eh_region); + +extern eh_region get_eh_region_from_number_fn (struct function *, int); +extern eh_region get_eh_region_from_number (int); +extern eh_landing_pad get_eh_landing_pad_from_number_fn (struct function*,int); +extern eh_landing_pad get_eh_landing_pad_from_number (int); +extern eh_region get_eh_region_from_lp_number_fn (struct function *, int); +extern eh_region get_eh_region_from_lp_number (int); + +extern eh_region eh_region_outermost (struct function *, eh_region, eh_region); + +extern void make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr); +extern void make_reg_eh_region_note_nothrow_nononlocal (rtx); + +extern void verify_eh_tree (struct function *); +extern void dump_eh_tree (FILE *, struct function *); +void debug_eh_tree (struct function *); +extern void add_type_for_runtime (tree); +extern tree lookup_type_for_runtime (tree); +extern void assign_filter_values (void); + +extern eh_region get_eh_region_from_rtx (const_rtx); +extern eh_landing_pad get_eh_landing_pad_from_rtx (const_rtx); + +struct GTY(()) throw_stmt_node { + gimple stmt; + int lp_nr; +}; + +extern struct htab *get_eh_throw_stmt_table (struct function *); +extern void set_eh_throw_stmt_table (struct function *, struct htab *); + +enum eh_personality_kind { + eh_personality_none, + eh_personality_any, + eh_personality_lang +}; + +extern enum eh_personality_kind +function_needs_eh_personality (struct function *); + +/* Pre-order iteration within the eh_region tree. */ + +static inline eh_region +ehr_next (eh_region r, eh_region start) +{ + if (r->inner) + r = r->inner; + else if (r->next_peer && r != start) + r = r->next_peer; + else + { + do + { + r = r->outer; + if (r == start) + return NULL; + } + while (r->next_peer == NULL); + r = r->next_peer; + } + return r; +} + +#define FOR_ALL_EH_REGION_AT(R, START) \ + for ((R) = (START); (R) != NULL; (R) = ehr_next (R, START)) + +#define FOR_ALL_EH_REGION_FN(R, FN) \ + for ((R) = (FN)->eh->region_tree; (R) != NULL; (R) = ehr_next (R, NULL)) + +#define FOR_ALL_EH_REGION(R) FOR_ALL_EH_REGION_FN (R, cfun) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/filenames.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/filenames.h new file mode 100644 index 0000000..d4955df --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/filenames.h @@ -0,0 +1,83 @@ +/* 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 2000, 2001, 2007, 2010 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 + +#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 +# 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 */ +# 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); + +#ifdef __cplusplus +} +#endif + +#endif /* FILENAMES_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/fixed-value.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/fixed-value.h new file mode 100644 index 0000000..ca0ee93 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/fixed-value.h @@ -0,0 +1,100 @@ +/* Fixed-point arithmetic support. + Copyright (C) 2006, 2007, 2009 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/>. */ + +#ifndef GCC_FIXED_VALUE_H +#define GCC_FIXED_VALUE_H + +#include "machmode.h" +#include "real.h" +#include "double-int.h" + +struct GTY(()) fixed_value +{ + double_int data; /* Store data up to 2 wide integers. */ + enum machine_mode mode; /* Use machine mode to know IBIT and FBIT. */ +}; + +#define FIXED_VALUE_TYPE struct fixed_value + +#define MAX_FCONST0 18 /* For storing 18 fixed-point zeros per + fract, ufract, accum, and uaccum modes . */ +#define MAX_FCONST1 8 /* For storing 8 fixed-point ones per accum + and uaccum modes. */ +/* Constant fixed-point values 0 and 1. */ +extern FIXED_VALUE_TYPE fconst0[MAX_FCONST0]; +extern FIXED_VALUE_TYPE fconst1[MAX_FCONST1]; + +/* Macros to access fconst0 and fconst1 via machine modes. */ +#define FCONST0(mode) fconst0[mode - QQmode] +#define FCONST1(mode) fconst1[mode - HAmode] + +/* Return a CONST_FIXED with value R and mode M. */ +#define CONST_FIXED_FROM_FIXED_VALUE(r, m) \ + const_fixed_from_fixed_value (r, m) +extern rtx const_fixed_from_fixed_value (FIXED_VALUE_TYPE, enum machine_mode); + +/* Initialize from a decimal or hexadecimal string. */ +extern void fixed_from_string (FIXED_VALUE_TYPE *, const char *, + enum machine_mode); + +/* In tree.c: wrap up a FIXED_VALUE_TYPE in a tree node. */ +extern tree build_fixed (tree, FIXED_VALUE_TYPE); + +/* Extend or truncate to a new mode. */ +extern bool fixed_convert (FIXED_VALUE_TYPE *, enum machine_mode, + const FIXED_VALUE_TYPE *, bool); + +/* Convert to a fixed-point mode from an integer. */ +extern bool fixed_convert_from_int (FIXED_VALUE_TYPE *, enum machine_mode, + double_int, bool, bool); + +/* Convert to a fixed-point mode from a real. */ +extern bool fixed_convert_from_real (FIXED_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *, bool); + +/* Convert to a real mode from a fixed-point. */ +extern void real_convert_from_fixed (REAL_VALUE_TYPE *, enum machine_mode, + const FIXED_VALUE_TYPE *); + +/* Compare two fixed-point objects for bitwise identity. */ +extern bool fixed_identical (const FIXED_VALUE_TYPE *, const FIXED_VALUE_TYPE *); + +/* Calculate a hash value. */ +extern unsigned int fixed_hash (const FIXED_VALUE_TYPE *); + +#define FIXED_VALUES_IDENTICAL(x, y) fixed_identical (&(x), &(y)) + +/* Determine whether a fixed-point value X is negative. */ +#define FIXED_VALUE_NEGATIVE(x) fixed_isneg (&(x)) + +/* Render F as a decimal floating point constant. */ +extern void fixed_to_decimal (char *str, const FIXED_VALUE_TYPE *, size_t); + +/* Binary or unary arithmetic on tree_code. */ +extern bool fixed_arithmetic (FIXED_VALUE_TYPE *, int, const FIXED_VALUE_TYPE *, + const FIXED_VALUE_TYPE *, bool); + +/* Compare fixed-point values by tree_code. */ +extern bool fixed_compare (int, const FIXED_VALUE_TYPE *, + const FIXED_VALUE_TYPE *); + +/* Determine whether a fixed-point value X is negative. */ +extern bool fixed_isneg (const FIXED_VALUE_TYPE *); + +#endif /* GCC_FIXED_VALUE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/flag-types.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/flag-types.h new file mode 100644 index 0000000..02a13f4 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/flag-types.h @@ -0,0 +1,214 @@ +/* Compilation switch flag type definitions for GCC. + Copyright (C) 1987, 1988, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, + 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_FLAG_TYPES_H +#define GCC_FLAG_TYPES_H + +enum debug_info_type +{ + NO_DEBUG, /* Write no debug info. */ + DBX_DEBUG, /* Write BSD .stabs for DBX (using dbxout.c). */ + SDB_DEBUG, /* Write COFF for (old) SDB (using sdbout.c). */ + DWARF2_DEBUG, /* Write Dwarf v2 debug info (using dwarf2out.c). */ + XCOFF_DEBUG, /* Write IBM/Xcoff debug info (using dbxout.c). */ + VMS_DEBUG, /* Write VMS debug info (using vmsdbgout.c). */ + VMS_AND_DWARF2_DEBUG /* Write VMS debug info (using vmsdbgout.c). + and DWARF v2 debug info (using dwarf2out.c). */ +}; + +enum debug_info_levels +{ + DINFO_LEVEL_NONE, /* Write no debugging info. */ + DINFO_LEVEL_TERSE, /* Write minimal info to support tracebacks only. */ + DINFO_LEVEL_NORMAL, /* Write info for all declarations (and line table). */ + DINFO_LEVEL_VERBOSE /* Write normal info plus #define/#undef info. */ +}; + +/* A major contribution to object and executable size is debug + information size. A major contribution to debug information + size is struct descriptions replicated in several object files. + The following function determines whether or not debug information + should be generated for a given struct. The indirect parameter + indicates that the struct is being handled indirectly, via + a pointer. See opts.c for the implementation. */ + +enum debug_info_usage +{ + DINFO_USAGE_DFN, /* A struct definition. */ + DINFO_USAGE_DIR_USE, /* A direct use, such as the type of a variable. */ + DINFO_USAGE_IND_USE, /* An indirect use, such as through a pointer. */ + DINFO_USAGE_NUM_ENUMS /* The number of enumerators. */ +}; + +/* A major contribution to object and executable size is debug + information size. A major contribution to debug information size + is struct descriptions replicated in several object files. The + following flags attempt to reduce this information. The basic + idea is to not emit struct debugging information in the current + compilation unit when that information will be generated by + another compilation unit. + + Debug information for a struct defined in the current source + file should be generated in the object file. Likewise the + debug information for a struct defined in a header should be + generated in the object file of the corresponding source file. + Both of these case are handled when the base name of the file of + the struct definition matches the base name of the source file + of the current compilation unit. This matching emits minimal + struct debugging information. + + The base file name matching rule above will fail to emit debug + information for structs defined in system headers. So a second + category of files includes system headers in addition to files + with matching bases. + + The remaining types of files are library headers and application + headers. We cannot currently distinguish these two types. */ + +enum debug_struct_file +{ + DINFO_STRUCT_FILE_NONE, /* Debug no structs. */ + DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the + same base name as the compilation unit. */ + DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system + header files. */ + DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */ +}; + +/* Enumerate visibility settings. This is deliberately ordered from most + to least visibility. */ +#ifndef SYMBOL_VISIBILITY_DEFINED +#define SYMBOL_VISIBILITY_DEFINED +enum symbol_visibility +{ + VISIBILITY_DEFAULT, + VISIBILITY_PROTECTED, + VISIBILITY_HIDDEN, + VISIBILITY_INTERNAL +}; +#endif + +/* The algorithm used for the integrated register allocator (IRA). */ +enum ira_algorithm +{ + IRA_ALGORITHM_CB, + IRA_ALGORITHM_PRIORITY +}; + +/* The regions used for the integrated register allocator (IRA). */ +enum ira_region +{ + IRA_REGION_ONE, + IRA_REGION_ALL, + IRA_REGION_MIXED +}; + +/* The options for excess precision. */ +enum excess_precision +{ + EXCESS_PRECISION_DEFAULT, + EXCESS_PRECISION_FAST, + EXCESS_PRECISION_STANDARD +}; + +/* Selection of the graph form. */ +enum graph_dump_types +{ + no_graph = 0, + vcg +}; + +/* Type of stack check. */ +enum stack_check_type +{ + /* Do not check the stack. */ + NO_STACK_CHECK = 0, + + /* Check the stack generically, i.e. assume no specific support + from the target configuration files. */ + GENERIC_STACK_CHECK, + + /* Check the stack and rely on the target configuration files to + check the static frame of functions, i.e. use the generic + mechanism only for dynamic stack allocations. */ + STATIC_BUILTIN_STACK_CHECK, + + /* Check the stack and entirely rely on the target configuration + files, i.e. do not use the generic mechanism at all. */ + FULL_BUILTIN_STACK_CHECK +}; + +/* 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 +}; + +/* Floating-point contraction mode. */ +enum fp_contract_mode { + FP_CONTRACT_OFF = 0, + FP_CONTRACT_ON = 1, + FP_CONTRACT_FAST = 2 +}; + +/* Vectorizer verbosity levels. */ +enum vect_verbosity_levels { + REPORT_NONE, + REPORT_VECTORIZED_LOCATIONS, + REPORT_UNVECTORIZED_LOCATIONS, + REPORT_COST, + REPORT_ALIGNMENT, + REPORT_DR_DETAILS, + REPORT_BAD_FORM_LOOPS, + REPORT_OUTER_LOOPS, + REPORT_SLP, + REPORT_DETAILS, + /* New verbosity levels should be added before this one. */ + MAX_VERBOSITY_LEVEL +}; + +/* flag_opt_info verbosity levels. */ +enum opt_info_verbosity_levels { + OPT_INFO_NONE = 0, + OPT_INFO_MIN = 1, + OPT_INFO_MED = 2, + OPT_INFO_MAX = 3 +}; +#endif /* ! GCC_FLAG_TYPES_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/flags.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/flags.h new file mode 100644 index 0000000..4104955 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/flags.h @@ -0,0 +1,153 @@ +/* Compilation switch flag definitions for GCC. + Copyright (C) 1987, 1988, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, + 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_FLAGS_H +#define GCC_FLAGS_H + +#include "coretypes.h" +#include "flag-types.h" +#include "options.h" + +#if !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) && !defined(IN_RTS) + +/* Names of debug_info_type, for error messages. */ +extern const char *const debug_type_names[]; + +extern void strip_off_ending (char *, int); +extern int base_of_path (const char *path, const char **base_out); + +/* True if this is the LTO front end (lto1). This is used to disable + gimple generation and lowering passes that are normally run on the + output of a front end. These passes must be bypassed for lto since + they have already been done before the gimple was written. */ + +extern bool in_lto_p; + +/* Return true iff flags are set as if -ffast-math. */ +extern bool fast_math_flags_set_p (const struct gcc_options *); +extern bool fast_math_flags_struct_set_p (struct cl_optimization *); + +/* Used to set the level of -Wstrict-aliasing in OPTS, when no level + is specified. The external way to set the default level is to use + -Wstrict-aliasing=level. + ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified, + and 0 otherwise. After calling this function, wstrict_aliasing will be + set to the default value of -Wstrict_aliasing=level. */ + +extern void set_Wstrict_aliasing (struct gcc_options *opts, int onoff); + +/* Now the symbols that are set with `-f' switches. */ + +/* True if printing into -fdump-final-insns= dump. */ + +extern bool final_insns_dump_p; + +/* Nonzero means make permerror produce warnings instead of errors. */ + +extern int flag_permissive; + +/* Generate code for GNU or NeXT Objective-C runtime environment. */ + +extern int flag_next_runtime; + +/* Other basic status info about current function. */ + +/* Target-dependent global state. */ +struct target_flag_state { + /* Values of the -falign-* flags: how much to align labels in code. + 0 means `use default', 1 means `don't align'. + For each variable, there is an _log variant which is the power + of two not less than the variable, for .align output. */ + int x_align_loops_log; + int x_align_loops_max_skip; + int x_align_jumps_log; + int x_align_jumps_max_skip; + int x_align_labels_log; + int x_align_labels_max_skip; + int x_align_functions_log; + + /* The excess precision currently in effect. */ + enum excess_precision x_flag_excess_precision; +}; + +extern struct target_flag_state default_target_flag_state; +#if SWITCHABLE_TARGET +extern struct target_flag_state *this_target_flag_state; +#else +#define this_target_flag_state (&default_target_flag_state) +#endif + +#define align_loops_log \ + (this_target_flag_state->x_align_loops_log) +#define align_loops_max_skip \ + (this_target_flag_state->x_align_loops_max_skip) +#define align_jumps_log \ + (this_target_flag_state->x_align_jumps_log) +#define align_jumps_max_skip \ + (this_target_flag_state->x_align_jumps_max_skip) +#define align_labels_log \ + (this_target_flag_state->x_align_labels_log) +#define align_labels_max_skip \ + (this_target_flag_state->x_align_labels_max_skip) +#define align_functions_log \ + (this_target_flag_state->x_align_functions_log) +#define flag_excess_precision \ + (this_target_flag_state->x_flag_excess_precision) + +/* Nonzero if we dump in VCG format, not plain text. */ +extern int dump_for_graph; + +/* Returns TRUE if generated code should match ABI version N or + greater is in use. */ + +#define abi_version_at_least(N) \ + (flag_abi_version == 0 || flag_abi_version >= (N)) + +/* True if overflow wraps around for the given integral type. That + is, TYPE_MAX + 1 == TYPE_MIN. */ +#define TYPE_OVERFLOW_WRAPS(TYPE) \ + (TYPE_UNSIGNED (TYPE) || flag_wrapv) + +/* True if overflow is undefined for the given integral type. We may + optimize on the assumption that values in the type never overflow. + + IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED + must issue a warning based on warn_strict_overflow. In some cases + it will be appropriate to issue the warning immediately, and in + other cases it will be appropriate to simply set a flag and let the + caller decide whether a warning is appropriate or not. */ +#define TYPE_OVERFLOW_UNDEFINED(TYPE) \ + (!TYPE_UNSIGNED (TYPE) && !flag_wrapv && !flag_trapv && flag_strict_overflow) + +/* True if overflow for the given integral type should issue a + trap. */ +#define TYPE_OVERFLOW_TRAPS(TYPE) \ + (!TYPE_UNSIGNED (TYPE) && flag_trapv) + +/* True if pointer types have undefined overflow. */ +#define POINTER_TYPE_OVERFLOW_UNDEFINED (flag_strict_overflow) + +/* Whether to emit an overflow warning whose code is C. */ +#define issue_strict_overflow_warning(c) (warn_strict_overflow >= (int) (c)) + +#endif + +#endif /* ! GCC_FLAGS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/function.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/function.h new file mode 100644 index 0000000..7563ba1 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/function.h @@ -0,0 +1,804 @@ +/* Structure for saving state for a nested function. + Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_FUNCTION_H +#define GCC_FUNCTION_H + +#include "tree.h" +#include "hashtab.h" +#include "vecprim.h" +#include "tm.h" /* For CUMULATIVE_ARGS. */ +#include "hard-reg-set.h" + +/* Stack of pending (incomplete) sequences saved by `start_sequence'. + Each element describes one pending sequence. + The main insn-chain is saved in the last element of the chain, + unless the chain is empty. */ + +struct GTY(()) sequence_stack { + /* First and last insns in the chain of the saved sequence. */ + rtx first; + rtx last; + struct sequence_stack *next; +}; + +struct GTY(()) emit_status { + /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. + After rtl generation, it is 1 plus the largest register number used. */ + int x_reg_rtx_no; + + /* Lowest label number in current function. */ + int x_first_label_num; + + /* The ends of the doubly-linked chain of rtl for the current function. + Both are reset to null at the start of rtl generation for the function. + + start_sequence saves both of these on `sequence_stack' and then starts + a new, nested sequence of insns. */ + rtx x_first_insn; + rtx x_last_insn; + + /* Stack of pending (incomplete) sequences saved by `start_sequence'. + Each element describes one pending sequence. + The main insn-chain is saved in the last element of the chain, + unless the chain is empty. */ + struct sequence_stack *sequence_stack; + + /* INSN_UID for next insn emitted. + Reset to 1 for each function compiled. */ + int x_cur_insn_uid; + + /* INSN_UID for next debug insn emitted. Only used if + --param min-nondebug-insn-uid=<value> is given with nonzero value. */ + int x_cur_debug_insn_uid; + + /* Location the last line-number NOTE emitted. + This is used to avoid generating duplicates. */ + location_t x_last_location; + + /* The length of the regno_pointer_align, regno_decl, and x_regno_reg_rtx + vectors. Since these vectors are needed during the expansion phase when + the total number of registers in the function is not yet known, the + vectors are copied and made bigger when necessary. */ + int regno_pointer_align_length; + + /* Indexed by pseudo register number, if nonzero gives the known alignment + for that pseudo (if REG_POINTER is set in x_regno_reg_rtx). + Allocated in parallel with x_regno_reg_rtx. */ + unsigned char * GTY((skip)) regno_pointer_align; +}; + + +/* Indexed by pseudo register number, gives the rtx for that pseudo. + Allocated in parallel with regno_pointer_align. + FIXME: We could put it into emit_status struct, but gengtype is not able to deal + with length attribute nested in top level structures. */ + +extern GTY ((length ("crtl->emit.x_reg_rtx_no"))) rtx * regno_reg_rtx; + +/* For backward compatibility... eventually these should all go away. */ +#define reg_rtx_no (crtl->emit.x_reg_rtx_no) +#define seq_stack (crtl->emit.sequence_stack) + +#define REGNO_POINTER_ALIGN(REGNO) (crtl->emit.regno_pointer_align[REGNO]) + +struct GTY(()) expr_status { + /* Number of units that we should eventually pop off the stack. + These are the arguments to function calls that have already returned. */ + int x_pending_stack_adjust; + + /* Under some ABIs, it is the caller's responsibility to pop arguments + pushed for function calls. A naive implementation would simply pop + the arguments immediately after each call. However, if several + function calls are made in a row, it is typically cheaper to pop + all the arguments after all of the calls are complete since a + single pop instruction can be used. Therefore, GCC attempts to + defer popping the arguments until absolutely necessary. (For + example, at the end of a conditional, the arguments must be popped, + since code outside the conditional won't know whether or not the + arguments need to be popped.) + + When INHIBIT_DEFER_POP is nonzero, however, the compiler does not + attempt to defer pops. Instead, the stack is popped immediately + after each call. Rather then setting this variable directly, use + NO_DEFER_POP and OK_DEFER_POP. */ + int x_inhibit_defer_pop; + + /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack + boundary can be momentarily unaligned while pushing the arguments. + Record the delta since last aligned boundary here in order to get + stack alignment in the nested function calls working right. */ + int x_stack_pointer_delta; + + /* Nonzero means __builtin_saveregs has already been done in this function. + The value is the pseudoreg containing the value __builtin_saveregs + returned. */ + rtx x_saveregs_value; + + /* Similarly for __builtin_apply_args. */ + rtx x_apply_args_value; + + /* List of labels that must never be deleted. */ + rtx x_forced_labels; +}; + +typedef struct call_site_record_d *call_site_record; +DEF_VEC_P(call_site_record); +DEF_VEC_ALLOC_P(call_site_record, gc); + +/* RTL representation of exception handling. */ +struct GTY(()) rtl_eh { + rtx ehr_stackadj; + rtx ehr_handler; + rtx ehr_label; + + rtx sjlj_fc; + rtx sjlj_exit_after; + + VEC(uchar,gc) *action_record_data; + + VEC(call_site_record,gc) *call_site_record[2]; +}; + +#define pending_stack_adjust (crtl->expr.x_pending_stack_adjust) +#define inhibit_defer_pop (crtl->expr.x_inhibit_defer_pop) +#define saveregs_value (crtl->expr.x_saveregs_value) +#define apply_args_value (crtl->expr.x_apply_args_value) +#define forced_labels (crtl->expr.x_forced_labels) +#define stack_pointer_delta (crtl->expr.x_stack_pointer_delta) + +struct gimple_df; +struct temp_slot; +typedef struct temp_slot *temp_slot_p; +struct call_site_record_d; + +DEF_VEC_P(temp_slot_p); +DEF_VEC_ALLOC_P(temp_slot_p,gc); +struct ipa_opt_pass_d; +typedef struct ipa_opt_pass_d *ipa_opt_pass; + +DEF_VEC_P(ipa_opt_pass); +DEF_VEC_ALLOC_P(ipa_opt_pass,heap); + +struct GTY(()) varasm_status { + /* If we're using a per-function constant pool, this is it. */ + struct rtx_constant_pool *pool; + + /* Number of tree-constants deferred during the expansion of this + function. */ + unsigned int deferred_constants; +}; + +/* Information mainlined about RTL representation of incoming arguments. */ +struct GTY(()) incoming_args { + /* Number of bytes of args popped by function being compiled on its return. + Zero if no bytes are to be popped. + May affect compilation of return insn or of function epilogue. */ + int pops_args; + + /* If function's args have a fixed size, this is that size, in bytes. + Otherwise, it is -1. + May affect compilation of return insn or of function epilogue. */ + int size; + + /* # bytes the prologue should push and pretend that the caller pushed them. + The prologue must do this, but only if parms can be passed in + registers. */ + int pretend_args_size; + + /* This is the offset from the arg pointer to the place where the first + anonymous arg can be found, if there is one. */ + rtx arg_offset_rtx; + + /* Quantities of various kinds of registers + used for the current function's args. */ + CUMULATIVE_ARGS info; + + /* The arg pointer hard register, or the pseudo into which it was copied. */ + rtx internal_arg_pointer; +}; + +/* Data for function partitioning. */ +struct GTY(()) function_subsections { + /* Assembly labels for the hot and cold text sections, to + be used by debugger functions for determining the size of text + sections. */ + + const char *hot_section_label; + const char *cold_section_label; + const char *hot_section_end_label; + const char *cold_section_end_label; +}; + +/* Describe an empty area of space in the stack frame. These can be chained + into a list; this is used to keep track of space wasted for alignment + reasons. */ +struct GTY(()) frame_space +{ + struct frame_space *next; + + HOST_WIDE_INT start; + HOST_WIDE_INT length; +}; + +/* Datastructures maintained for currently processed function in RTL form. */ +struct GTY(()) rtl_data { + struct expr_status expr; + struct emit_status emit; + struct varasm_status varasm; + struct incoming_args args; + struct function_subsections subsections; + struct rtl_eh eh; + + /* For function.c */ + + /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is + defined, the needed space is pushed by the prologue. */ + int outgoing_args_size; + + /* If nonzero, an RTL expression for the location at which the current + function returns its result. If the current function returns its + result in a register, current_function_return_rtx will always be + the hard register containing the result. */ + rtx return_rtx; + + /* Opaque pointer used by get_hard_reg_initial_val and + has_hard_reg_initial_val (see integrate.[hc]). */ + struct initial_value_struct *hard_reg_initial_vals; + + /* A variable living at the top of the frame that holds a known value. + Used for detecting stack clobbers. */ + tree stack_protect_guard; + + /* List (chain of EXPR_LIST) of labels heading the current handlers for + nonlocal gotos. */ + rtx x_nonlocal_goto_handler_labels; + + /* Label that will go on function epilogue. + Jumping to this label serves as a "return" instruction + on machines which require execution of the epilogue on all returns. */ + rtx x_return_label; + + /* Label that will go on the end of function epilogue. + Jumping to this label serves as a "naked return" instruction + on machines which require execution of the epilogue on all returns. */ + rtx x_naked_return_label; + + /* List (chain of EXPR_LISTs) of all stack slots in this function. + Made for the sake of unshare_all_rtl. */ + rtx x_stack_slot_list; + + /* List of empty areas in the stack frame. */ + struct frame_space *frame_space_list; + + /* Place after which to insert the tail_recursion_label if we need one. */ + rtx x_stack_check_probe_note; + + /* Location at which to save the argument pointer if it will need to be + referenced. There are two cases where this is done: if nonlocal gotos + exist, or if vars stored at an offset from the argument pointer will be + needed by inner routines. */ + rtx x_arg_pointer_save_area; + + /* Dynamic Realign Argument Pointer used for realigning stack. */ + rtx drap_reg; + + /* Offset to end of allocated area of stack frame. + If stack grows down, this is the address of the last stack slot allocated. + If stack grows up, this is the address for the next slot. */ + HOST_WIDE_INT x_frame_offset; + + /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ + rtx x_parm_birth_insn; + + /* List of all used temporaries allocated, by level. */ + VEC(temp_slot_p,gc) *x_used_temp_slots; + + /* List of available temp slots. */ + struct temp_slot *x_avail_temp_slots; + + /* Current nesting level for temporaries. */ + int x_temp_slot_level; + + /* The largest alignment needed on the stack, including requirement + for outgoing stack alignment. */ + unsigned int stack_alignment_needed; + + /* Preferred alignment of the end of stack frame, which is preferred + to call other functions. */ + unsigned int preferred_stack_boundary; + + /* The minimum alignment of parameter stack. */ + unsigned int parm_stack_boundary; + + /* The largest alignment of slot allocated on the stack. */ + unsigned int max_used_stack_slot_alignment; + + /* The stack alignment estimated before reload, with consideration of + following factors: + 1. Alignment of local stack variables (max_used_stack_slot_alignment) + 2. Alignment requirement to call other functions + (preferred_stack_boundary) + 3. Alignment of non-local stack variables but might be spilled in + local stack. */ + unsigned int stack_alignment_estimated; + + /* For reorg. */ + + /* If some insns can be deferred to the delay slots of the epilogue, the + delay list for them is recorded here. */ + rtx epilogue_delay_list; + + /* Nonzero if function being compiled called builtin_return_addr or + builtin_frame_address with nonzero count. */ + bool accesses_prior_frames; + + /* Nonzero if the function calls __builtin_eh_return. */ + bool calls_eh_return; + + /* Nonzero if function saves all registers, e.g. if it has a nonlocal + label that can reach the exit block via non-exceptional paths. */ + bool saves_all_registers; + + /* Nonzero if function being compiled has nonlocal gotos to parent + function. */ + bool has_nonlocal_goto; + + /* Nonzero if function being compiled has an asm statement. */ + bool has_asm_statement; + + /* This bit is used by the exception handling logic. It is set if all + calls (if any) are sibling calls. Such functions do not have to + have EH tables generated, as they cannot throw. A call to such a + function, however, should be treated as throwing if any of its callees + can throw. */ + bool all_throwers_are_sibcalls; + + /* Nonzero if stack limit checking should be enabled in the current + function. */ + bool limit_stack; + + /* Nonzero if profiling code should be generated. */ + bool profile; + + /* Nonzero if the current function uses the constant pool. */ + bool uses_const_pool; + + /* Nonzero if the current function uses pic_offset_table_rtx. */ + bool uses_pic_offset_table; + + /* Nonzero if the current function needs an lsda for exception handling. */ + bool uses_eh_lsda; + + /* Set when the tail call has been produced. */ + bool tail_call_emit; + + /* Nonzero if code to initialize arg_pointer_save_area has been emitted. */ + bool arg_pointer_save_area_init; + + /* Nonzero if current function must be given a frame pointer. + Set in global.c if anything is allocated on the stack there. */ + bool frame_pointer_needed; + + /* When set, expand should optimize for speed. */ + bool maybe_hot_insn_p; + + /* Nonzero if function stack realignment is needed. This flag may be + set twice: before and after reload. It is set before reload wrt + stack alignment estimation before reload. It will be changed after + reload if by then criteria of stack realignment is different. + The value set after reload is the accurate one and is finalized. */ + bool stack_realign_needed; + + /* Nonzero if function stack realignment is tried. This flag is set + only once before reload. It affects register elimination. This + is used to generate DWARF debug info for stack variables. */ + bool stack_realign_tried; + + /* Nonzero if function being compiled needs dynamic realigned + argument pointer (drap) if stack needs realigning. */ + bool need_drap; + + /* Nonzero if function stack realignment estimation is done, namely + stack_realign_needed flag has been set before reload wrt estimated + stack alignment info. */ + bool stack_realign_processed; + + /* Nonzero if function stack realignment has been finalized, namely + stack_realign_needed flag has been set and finalized after reload. */ + bool stack_realign_finalized; + + /* True if dbr_schedule has already been called for this function. */ + bool dbr_scheduled_p; + + /* True if current function can not throw. Unlike + TREE_NOTHROW (current_function_decl) it is set even for overwritable + function where currently compiled version of it is nothrow. */ + bool nothrow; + + /* Like regs_ever_live, but 1 if a reg is set or clobbered from an + asm. Unlike regs_ever_live, elements of this array corresponding + to eliminable regs (like the frame pointer) are set if an asm + sets them. */ + HARD_REG_SET asm_clobbers; +}; + +#define return_label (crtl->x_return_label) +#define naked_return_label (crtl->x_naked_return_label) +#define stack_slot_list (crtl->x_stack_slot_list) +#define parm_birth_insn (crtl->x_parm_birth_insn) +#define frame_offset (crtl->x_frame_offset) +#define stack_check_probe_note (crtl->x_stack_check_probe_note) +#define arg_pointer_save_area (crtl->x_arg_pointer_save_area) +#define used_temp_slots (crtl->x_used_temp_slots) +#define avail_temp_slots (crtl->x_avail_temp_slots) +#define temp_slot_level (crtl->x_temp_slot_level) +#define nonlocal_goto_handler_labels (crtl->x_nonlocal_goto_handler_labels) +#define frame_pointer_needed (crtl->frame_pointer_needed) +#define stack_realign_fp (crtl->stack_realign_needed && !crtl->need_drap) +#define stack_realign_drap (crtl->stack_realign_needed && crtl->need_drap) + +extern GTY(()) struct rtl_data x_rtl; + +/* Accessor to RTL datastructures. We keep them statically allocated now since + we never keep multiple functions. For threaded compiler we might however + want to do differently. */ +#define crtl (&x_rtl) + +struct GTY(()) stack_usage +{ + /* # of bytes of static stack space allocated by the function. */ + HOST_WIDE_INT static_stack_size; + + /* # of bytes of dynamic stack space allocated by the function. This is + meaningful only if has_unbounded_dynamic_stack_size is zero. */ + HOST_WIDE_INT dynamic_stack_size; + + /* # of bytes of space pushed onto the stack after the prologue. If + !ACCUMULATE_OUTGOING_ARGS, it contains the outgoing arguments. */ + int pushed_stack_size; + + /* # of dynamic allocations in the function. */ + unsigned int dynamic_alloc_count : 31; + + /* Nonzero if the amount of stack space allocated dynamically cannot + be bounded at compile-time. */ + unsigned int has_unbounded_dynamic_stack_size : 1; +}; + +#define current_function_static_stack_size (cfun->su->static_stack_size) +#define current_function_dynamic_stack_size (cfun->su->dynamic_stack_size) +#define current_function_pushed_stack_size (cfun->su->pushed_stack_size) +#define current_function_dynamic_alloc_count (cfun->su->dynamic_alloc_count) +#define current_function_has_unbounded_dynamic_stack_size \ + (cfun->su->has_unbounded_dynamic_stack_size) +#define current_function_allocates_dynamic_stack_space \ + (current_function_dynamic_stack_size != 0 \ + || current_function_has_unbounded_dynamic_stack_size) + +/* This structure can save all the important global and static variables + describing the status of the current function. */ + +struct GTY(()) function { + struct eh_status *eh; + + /* The control flow graph for this function. */ + struct control_flow_graph *cfg; + + /* GIMPLE body for this function. */ + struct gimple_seq_d *gimple_body; + + /* SSA and dataflow information. */ + struct gimple_df *gimple_df; + + /* The loops in this function. */ + struct loops *x_current_loops; + + /* The stack usage of this function. */ + struct stack_usage *su; + + /* Value histograms attached to particular statements. */ + htab_t GTY((skip)) value_histograms; + + /* For function.c. */ + + /* Points to the FUNCTION_DECL of this function. */ + tree decl; + + /* A PARM_DECL that should contain the static chain for this function. + It will be initialized at the beginning of the function. */ + tree static_chain_decl; + + /* An expression that contains the non-local goto save area. The first + word is the saved frame pointer and the second is the saved stack + pointer. */ + tree nonlocal_goto_save_area; + + /* Vector of function local variables, functions, types and constants. */ + VEC(tree,gc) *local_decls; + + /* For md files. */ + + /* tm.h can use this to store whatever it likes. */ + struct machine_function * GTY ((maybe_undef)) machine; + + /* Language-specific code can use this to store whatever it likes. */ + struct language_function * language; + + /* Used types hash table. */ + htab_t GTY ((param_is (union tree_node))) used_types_hash; + + /* Last statement uid. */ + int last_stmt_uid; + + /* Function's module id. */ + unsigned module_id; + + /* Function sequence number for profiling, debugging, etc. */ + int funcdef_no; + + /* Line number of the start of the function for debugging purposes. */ + location_t function_start_locus; + + /* Line number of the end of the function. */ + location_t function_end_locus; + + /* Properties used by the pass manager. */ + unsigned int curr_properties; + unsigned int last_verified; + + /* Non-null if the function does something that would prevent it from + being copied; this applies to both versioning and inlining. Set to + a string describing the reason for failure. */ + const char * GTY((skip)) cannot_be_copied_reason; + + /* Collected bit flags. */ + + /* Number of units of general registers that need saving in stdarg + function. What unit is depends on the backend, either it is number + of bytes, or it can be number of registers. */ + unsigned int va_list_gpr_size : 8; + + /* Number of units of floating point registers that need saving in stdarg + function. */ + unsigned int va_list_fpr_size : 8; + + /* Nonzero if function being compiled can call setjmp. */ + unsigned int calls_setjmp : 1; + + /* Nonzero if function being compiled can call alloca, + either as a subroutine or builtin. */ + unsigned int calls_alloca : 1; + + /* Nonzero if function being compiled receives nonlocal gotos + from nested functions. */ + unsigned int has_nonlocal_label : 1; + + /* Nonzero if we've set cannot_be_copied_reason. I.e. if + (cannot_be_copied_set && !cannot_be_copied_reason), the function + can in fact be copied. */ + unsigned int cannot_be_copied_set : 1; + + /* Nonzero if current function uses stdarg.h or equivalent. */ + unsigned int stdarg : 1; + + /* Nonzero if the back-end should not keep track of expressions that + determine the size of variable-sized objects. Normally, such + expressions are saved away, and then expanded when the next + function is started. For example, if a parameter has a + variable-sized type, then the size of the parameter is computed + when the function body is entered. However, some front-ends do + not desire this behavior. */ + unsigned int dont_save_pending_sizes_p : 1; + + unsigned int after_inlining : 1; + unsigned int always_inline_functions_inlined : 1; + + /* Nonzero if function being compiled can throw synchronous non-call + exceptions. */ + unsigned int can_throw_non_call_exceptions : 1; + + /* Fields below this point are not set for abstract functions; see + allocate_struct_function. */ + + /* Nonzero if function being compiled needs to be given an address + where the value should be stored. */ + unsigned int returns_struct : 1; + + /* Nonzero if function being compiled needs to + return the address of where it has put a structure value. */ + unsigned int returns_pcc_struct : 1; + + /* Nonzero if pass_tree_profile was run on this function. */ + unsigned int after_tree_profile : 1; + + /* Nonzero if this function has local DECL_HARD_REGISTER variables. + In this case code motion has to be done more carefully. */ + unsigned int has_local_explicit_reg_vars : 1; + + /* Nonzero if the current function is a thunk, i.e., a lightweight + function implemented by the output_mi_thunk hook) that just + adjusts one of its arguments and forwards to another + function. */ + unsigned int is_thunk : 1; +}; + +#if 0 +#define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) (unsigned)(((gid) >> FUNC_ID_WIDTH) & FUNC_ID_MASK) +#define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) (unsigned)((gid) & FUNC_ID_MASK) +#define FUNC_DECL_MODULE_ID(func) EXTRACT_MODULE_ID_FROM_GLOBAL_ID ((func)->funcdef_no + 1) +#define FUNC_DECL_FUNC_ID(func) EXTRACT_FUNC_ID_FROM_GLOBAL_ID ((func)->funcdef_no + 1) +#define FUNC_DECL_GLOBAL_ID(func) ((func)->funcdef_no + 1) +#define GEN_FUNC_GLOBAL_ID(m,f) ((((HOST_WIDE_INT) (m)) << FUNC_ID_WIDTH) | (f)) +#endif + +/* The bit width of function id in the global function id used + in LIPO. */ +#define FUNC_ID_WIDTH HOST_BITS_PER_WIDEST_INT / 2 +/* The mask to extract function id from the global function id. */ +#define FUNC_ID_MASK ((1ll << FUNC_ID_WIDTH) - 1) +/* Macro to extract module id from global function id GID. */ +#define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) (unsigned)(((gid) >>\ + FUNC_ID_WIDTH) & FUNC_ID_MASK) +/* Macro to extract function id from global function id GID. */ +#define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) (unsigned)((gid) & FUNC_ID_MASK) +/* Macro to generate a global function id from module id M and + function id F. */ +#define GEN_FUNC_GLOBAL_ID(m,f) ((((HOST_WIDEST_INT) (m)) << FUNC_ID_WIDTH)\ + | (f)) +/* Access macro for module_id field of function FUNC. */ +#define FUNC_DECL_MODULE_ID(func) ((func)->module_id) +/* Access macro for funcdef_no field of function FUNC. */ +#define FUNC_DECL_FUNC_ID(func) ((func)->funcdef_no + 1) +/* Macro to compute global function id for FUNC. */ +#define FUNC_DECL_GLOBAL_ID(func) \ + GEN_FUNC_GLOBAL_ID (FUNC_DECL_MODULE_ID (func), FUNC_DECL_FUNC_ID (func)) +/* 32 bit wide unique id used for asm label (limit: 30k modules, + 128k funcs per module. */ +#define FUNC_LABEL_ID(func) ((FUNC_DECL_MODULE_ID (func) << 18) +\ + (func)->funcdef_no) + +/* Add the decl D to the local_decls list of FUN. */ + +static inline void +add_local_decl (struct function *fun, tree d) +{ + VEC_safe_push (tree, gc, fun->local_decls, d); +} + +#define FOR_EACH_LOCAL_DECL(FUN, I, D) \ + FOR_EACH_VEC_ELT_REVERSE (tree, (FUN)->local_decls, I, D) + +/* If va_list_[gf]pr_size is set to this, it means we don't know how + many units need to be saved. */ +#define VA_LIST_MAX_GPR_SIZE 255 +#define VA_LIST_MAX_FPR_SIZE 255 + +/* The function currently being compiled. */ +extern GTY(()) struct function *cfun; + +/* In order to ensure that cfun is not set directly, we redefine it so + that it is not an lvalue. Rather than assign to cfun, use + push_cfun or set_cfun. */ +#define cfun (cfun + 0) + +/* Nonzero if we've already converted virtual regs to hard regs. */ +extern int virtuals_instantiated; + +/* Nonzero if at least one trampoline has been created. */ +extern int trampolines_created; + +struct GTY(()) types_used_by_vars_entry { + tree type; + tree var_decl; +}; + +/* Hash table making the relationship between a global variable + and the types it references in its initializer. The key of the + entry is a referenced type, and the value is the DECL of the global + variable. types_use_by_vars_do_hash and types_used_by_vars_eq below are + the hash and equality functions to use for this hash table. */ +extern GTY((param_is (struct types_used_by_vars_entry))) htab_t + types_used_by_vars_hash; + +hashval_t types_used_by_vars_do_hash (const void*); +int types_used_by_vars_eq (const void *, const void *); +void types_used_by_var_decl_insert (tree type, tree var_decl); + +/* During parsing of a global variable, this vector contains the types + referenced by the global variable. */ +extern GTY(()) VEC(tree,gc) *types_used_by_cur_var_decl; + + +/* cfun shouldn't be set directly; use one of these functions instead. */ +extern void set_cfun (struct function *new_cfun); +extern void push_cfun (struct function *new_cfun); +extern void pop_cfun (void); +extern void instantiate_decl_rtl (rtx x); + +/* For backward compatibility... eventually these should all go away. */ +#define current_function_funcdef_no (cfun->funcdef_no) + +#define current_loops (cfun->x_current_loops) +#define dom_computed (cfun->cfg->x_dom_computed) +#define n_bbs_in_dom_tree (cfun->cfg->x_n_bbs_in_dom_tree) +#define VALUE_HISTOGRAMS(fun) (fun)->value_histograms + +/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, + and create duplicate blocks. */ +extern void reorder_blocks (void); + +/* Set BLOCK_NUMBER for all the blocks in FN. */ +extern void number_blocks (tree); + +extern void clear_block_marks (tree); +extern tree blocks_nreverse (tree); + +/* Return size needed for stack frame based on slots so far allocated. + This size counts from zero. It is not rounded to STACK_BOUNDARY; + the caller may have to do that. */ +extern HOST_WIDE_INT get_frame_size (void); + +/* Issue an error message and return TRUE if frame OFFSET overflows in + the signed target pointer arithmetics for function FUNC. Otherwise + return FALSE. */ +extern bool frame_offset_overflow (HOST_WIDE_INT, tree); + +/* A pointer to a function to create target specific, per-function + data structures. */ +extern struct machine_function * (*init_machine_status) (void); + +/* Save and restore status information for a nested function. */ +extern void free_after_parsing (struct function *); +extern void free_after_compilation (struct function *); + +extern void init_varasm_status (void); + +#ifdef RTX_CODE +extern void diddle_return_value (void (*)(rtx, void*), void*); +extern void clobber_return_register (void); +#endif + +extern rtx get_arg_pointer_save_area (void); + +/* Returns the name of the current function. */ +extern const char *current_function_name (void); + +extern void do_warn_unused_parameter (tree); + +extern bool pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode, + tree, bool); +extern bool reference_callee_copied (CUMULATIVE_ARGS *, enum machine_mode, + tree, bool); + +extern void used_types_insert (tree); + +extern int get_next_funcdef_no (void); +extern int get_last_funcdef_no (void); + +extern void reset_funcdef_no (void); +extern void set_funcdef_no (int); + +/* In predict.c */ +extern bool optimize_function_for_size_p (struct function *); +extern bool optimize_function_for_speed_p (struct function *); + +#endif /* GCC_FUNCTION_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gcc-plugin.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gcc-plugin.h new file mode 100644 index 0000000..b98bcb6 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gcc-plugin.h @@ -0,0 +1,166 @@ +/* Public header file for plugins to include. + Copyright (C) 2009, 2010 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/>. */ + +#ifndef GCC_PLUGIN_H +#define GCC_PLUGIN_H + +#ifndef IN_GCC +#define IN_GCC +#endif + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "highlev-plugin-common.h" +#include "hashtab.h" + +/* Event names. */ +enum plugin_event +{ +# define DEFEVENT(NAME) NAME, +# include "plugin.def" +# undef DEFEVENT + PLUGIN_EVENT_FIRST_DYNAMIC +}; + +/* All globals declared here have C linkage to reduce link compatibility + issues with implementation language choice and mangling. */ +#ifdef __cplusplus +extern "C" { +#endif + +extern const char **plugin_event_name; + +struct plugin_argument +{ + char *key; /* key of the argument. */ + char *value; /* value is optional and can be NULL. */ +}; + +/* Additional information about the plugin. Used by --help and --version. */ + +struct plugin_info +{ + const char *version; + const char *help; +}; + +/* Represents the gcc version. Used to avoid using an incompatible plugin. */ + +struct plugin_gcc_version +{ + const char *basever; + const char *datestamp; + const char *devphase; + const char *revision; + const char *configuration_arguments; +}; + +/* Object that keeps track of the plugin name and its arguments. */ +struct plugin_name_args +{ + char *base_name; /* Short name of the plugin (filename without + .so suffix). */ + const char *full_name; /* Path to the plugin as specified with + -fplugin=. */ + int argc; /* Number of arguments specified with + -fplugin-arg-... */ + struct plugin_argument *argv; /* Array of ARGC key-value pairs. */ + const char *version; /* Version string provided by plugin. */ + const char *help; /* Help string provided by plugin. */ +}; + +/* The default version check. Compares every field in VERSION. */ + +extern bool plugin_default_version_check (struct plugin_gcc_version *, + struct plugin_gcc_version *); + +/* Function type for the plugin initialization routine. Each plugin module + should define this as an externally-visible function with name + "plugin_init." + + PLUGIN_INFO - plugin invocation information. + VERSION - the plugin_gcc_version symbol of GCC. + + Returns 0 if initialization finishes successfully. */ + +typedef int (*plugin_init_func) (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version); + +/* Declaration for "plugin_init" function so that it doesn't need to be + duplicated in every plugin. */ +extern int plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version); + +/* Function type for a plugin callback routine. + + GCC_DATA - event-specific data provided by GCC + USER_DATA - plugin-specific data provided by the plugin */ + +typedef void (*plugin_callback_func) (void *gcc_data, void *user_data); + +/* Called from the plugin's initialization code. Register a single callback. + This function can be called multiple times. + + PLUGIN_NAME - display name for this plugin + EVENT - which event the callback is for + CALLBACK - the callback to be called at the event + USER_DATA - plugin-provided data. +*/ + +/* Number of event ids / names registered so far. */ + +extern int get_event_last (void); + +int get_named_event_id (const char *name, enum insert_option insert); + +/* This is also called without a callback routine for the + PLUGIN_PASS_MANAGER_SETUP, PLUGIN_INFO, PLUGIN_REGISTER_GGC_ROOTS and + PLUGIN_REGISTER_GGC_CACHES pseudo-events, with a specific user_data. + */ + +extern void register_callback (const char *plugin_name, + int event, + plugin_callback_func callback, + void *user_data); + +extern int unregister_callback (const char *plugin_name, int event); + + +/* Retrieve the plugin directory name, as returned by the + -fprint-file-name=plugin argument to the gcc program, which is the + -iplugindir program argument to cc1. */ +extern const char* default_plugin_dir_name (void); + +#ifdef __cplusplus +} +#endif + +/* In case the C++ compiler does name mangling for globals, declare + plugin_is_GPL_compatible extern "C" so that a later definition + in a plugin file will have this linkage. */ +#ifdef __cplusplus +extern "C" { +#endif +extern int plugin_is_GPL_compatible; +#ifdef __cplusplus +} +#endif + +#endif /* GCC_PLUGIN_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/genrtl.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/genrtl.h new file mode 100644 index 0000000..04b0411 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/genrtl.h @@ -0,0 +1,1187 @@ +/* Generated automatically by gengenrtl from rtl.def. */ + +#ifndef GCC_GENRTL_H +#define GCC_GENRTL_H + +#include "statistics.h" + +static inline rtx +gen_rtx_fmt_0_stat (RTX_CODE code, enum machine_mode mode MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + X0EXP (rt, 0) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_0(c, m)\ + gen_rtx_fmt_0_stat (c, m MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ee_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0, + rtx arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_ee(c, m, p0, p1)\ + gen_rtx_fmt_ee_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ue_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0, + rtx arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_ue(c, m, p0, p1)\ + gen_rtx_fmt_ue_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_E_stat (RTX_CODE code, enum machine_mode mode, + rtvec arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XVEC (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_E(c, m, p0)\ + gen_rtx_fmt_E_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_e_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_e(c, m, p0)\ + gen_rtx_fmt_e_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iuuBeiie_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + rtx arg1, + rtx arg2, + struct basic_block_def *arg3, + rtx arg4, + int arg5, + int arg6, + rtx arg7 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + XBBDEF (rt, 3) = arg3; + XEXP (rt, 4) = arg4; + XINT (rt, 5) = arg5; + XINT (rt, 6) = arg6; + XEXP (rt, 7) = arg7; + + return rt; +} + +#define gen_rtx_fmt_iuuBeiie(c, m, p0, p1, p2, p3, p4, p5, p6, p7)\ + gen_rtx_fmt_iuuBeiie_stat (c, m, p0, p1, p2, p3, p4, p5, p6, p7 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iuuBeiie0_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + rtx arg1, + rtx arg2, + struct basic_block_def *arg3, + rtx arg4, + int arg5, + int arg6, + rtx arg7 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + XBBDEF (rt, 3) = arg3; + XEXP (rt, 4) = arg4; + XINT (rt, 5) = arg5; + XINT (rt, 6) = arg6; + XEXP (rt, 7) = arg7; + X0EXP (rt, 8) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_iuuBeiie0(c, m, p0, p1, p2, p3, p4, p5, p6, p7)\ + gen_rtx_fmt_iuuBeiie0_stat (c, m, p0, p1, p2, p3, p4, p5, p6, p7 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iuuBeiiee_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + rtx arg1, + rtx arg2, + struct basic_block_def *arg3, + rtx arg4, + int arg5, + int arg6, + rtx arg7, + rtx arg8 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + XBBDEF (rt, 3) = arg3; + XEXP (rt, 4) = arg4; + XINT (rt, 5) = arg5; + XINT (rt, 6) = arg6; + XEXP (rt, 7) = arg7; + XEXP (rt, 8) = arg8; + + return rt; +} + +#define gen_rtx_fmt_iuuBeiiee(c, m, p0, p1, p2, p3, p4, p5, p6, p7, p8)\ + gen_rtx_fmt_iuuBeiiee_stat (c, m, p0, p1, p2, p3, p4, p5, p6, p7, p8 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iuu00000_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + rtx arg1, + rtx arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + X0EXP (rt, 3) = NULL_RTX; + X0EXP (rt, 4) = NULL_RTX; + X0EXP (rt, 5) = NULL_RTX; + X0EXP (rt, 6) = NULL_RTX; + X0EXP (rt, 7) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_iuu00000(c, m, p0, p1, p2)\ + gen_rtx_fmt_iuu00000_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iuuB00is_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + rtx arg1, + rtx arg2, + struct basic_block_def *arg3, + int arg4, + const char *arg5 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + XBBDEF (rt, 3) = arg3; + X0EXP (rt, 4) = NULL_RTX; + X0EXP (rt, 5) = NULL_RTX; + XINT (rt, 6) = arg4; + XSTR (rt, 7) = arg5; + + return rt; +} + +#define gen_rtx_fmt_iuuB00is(c, m, p0, p1, p2, p3, p4, p5)\ + gen_rtx_fmt_iuuB00is_stat (c, m, p0, p1, p2, p3, p4, p5 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_si_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + int arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XINT (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_si(c, m, p0, p1)\ + gen_rtx_fmt_si_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ssiEEEi_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + const char *arg1, + int arg2, + rtvec arg3, + rtvec arg4, + rtvec arg5, + int arg6 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + XINT (rt, 2) = arg2; + XVEC (rt, 3) = arg3; + XVEC (rt, 4) = arg4; + XVEC (rt, 5) = arg5; + XINT (rt, 6) = arg6; + + return rt; +} + +#define gen_rtx_fmt_ssiEEEi(c, m, p0, p1, p2, p3, p4, p5, p6)\ + gen_rtx_fmt_ssiEEEi_stat (c, m, p0, p1, p2, p3, p4, p5, p6 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_Ei_stat (RTX_CODE code, enum machine_mode mode, + rtvec arg0, + int arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XVEC (rt, 0) = arg0; + XINT (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_Ei(c, m, p0, p1)\ + gen_rtx_fmt_Ei_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_eEee0_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0, + rtvec arg1, + rtx arg2, + rtx arg3 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + XVEC (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + XEXP (rt, 3) = arg3; + X0EXP (rt, 4) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_eEee0(c, m, p0, p1, p2, p3)\ + gen_rtx_fmt_eEee0_stat (c, m, p0, p1, p2, p3 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_eee_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0, + rtx arg1, + rtx arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_eee(c, m, p0, p1, p2)\ + gen_rtx_fmt_eee_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt__stat (RTX_CODE code, enum machine_mode mode MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + + return rt; +} + +#define gen_rtx_fmt_(c, m)\ + gen_rtx_fmt__stat (c, m MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_w_stat (RTX_CODE code, enum machine_mode mode, + HOST_WIDE_INT arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XWINT (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_w(c, m, p0)\ + gen_rtx_fmt_w_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_www_stat (RTX_CODE code, enum machine_mode mode, + HOST_WIDE_INT arg0, + HOST_WIDE_INT arg1, + HOST_WIDE_INT arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XWINT (rt, 0) = arg0; + XWINT (rt, 1) = arg1; + XWINT (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_www(c, m, p0, p1, p2)\ + gen_rtx_fmt_www_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_s_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_s(c, m, p0)\ + gen_rtx_fmt_s_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_i00_stat (RTX_CODE code, enum machine_mode mode, + int arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + X0EXP (rt, 1) = NULL_RTX; + X0EXP (rt, 2) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_i00(c, m, p0)\ + gen_rtx_fmt_i00_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ei_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0, + int arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + XINT (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_ei(c, m, p0, p1)\ + gen_rtx_fmt_ei_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_e0_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + X0EXP (rt, 1) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_e0(c, m, p0)\ + gen_rtx_fmt_e0_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_u_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_u(c, m, p0)\ + gen_rtx_fmt_u_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_s00_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + X0EXP (rt, 1) = NULL_RTX; + X0EXP (rt, 2) = NULL_RTX; + + return rt; +} + +#define gen_rtx_fmt_s00(c, m, p0)\ + gen_rtx_fmt_s00_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_tei_stat (RTX_CODE code, enum machine_mode mode, + union tree_node *arg0, + rtx arg1, + int arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XTREE (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XINT (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_tei(c, m, p0, p1, p2)\ + gen_rtx_fmt_tei_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_t_stat (RTX_CODE code, enum machine_mode mode, + union tree_node *arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XTREE (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_t(c, m, p0)\ + gen_rtx_fmt_t_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iss_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + const char *arg1, + const char *arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + XSTR (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_iss(c, m, p0, p1, p2)\ + gen_rtx_fmt_iss_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_is_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + const char *arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_is(c, m, p0, p1)\ + gen_rtx_fmt_is_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_isE_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + const char *arg1, + rtvec arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + XVEC (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_isE(c, m, p0, p1, p2)\ + gen_rtx_fmt_isE_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_i_stat (RTX_CODE code, enum machine_mode mode, + int arg0 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + + return rt; +} + +#define gen_rtx_fmt_i(c, m, p0)\ + gen_rtx_fmt_i_stat (c, m, p0 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_iE_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + rtvec arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XVEC (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_iE(c, m, p0, p1)\ + gen_rtx_fmt_iE_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ss_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + const char *arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_ss(c, m, p0, p1)\ + gen_rtx_fmt_ss_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_sEss_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + rtvec arg1, + const char *arg2, + const char *arg3 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XVEC (rt, 1) = arg1; + XSTR (rt, 2) = arg2; + XSTR (rt, 3) = arg3; + + return rt; +} + +#define gen_rtx_fmt_sEss(c, m, p0, p1, p2, p3)\ + gen_rtx_fmt_sEss_stat (c, m, p0, p1, p2, p3 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_eE_stat (RTX_CODE code, enum machine_mode mode, + rtx arg0, + rtvec arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XEXP (rt, 0) = arg0; + XVEC (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_eE(c, m, p0, p1)\ + gen_rtx_fmt_eE_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_Ess_stat (RTX_CODE code, enum machine_mode mode, + rtvec arg0, + const char *arg1, + const char *arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XVEC (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + XSTR (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_Ess(c, m, p0, p1, p2)\ + gen_rtx_fmt_Ess_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ses_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + rtx arg1, + const char *arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + XSTR (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_ses(c, m, p0, p1, p2)\ + gen_rtx_fmt_ses_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_sss_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + const char *arg1, + const char *arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + XSTR (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_sss(c, m, p0, p1, p2)\ + gen_rtx_fmt_sss_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_sse_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + const char *arg1, + rtx arg2 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XSTR (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + + return rt; +} + +#define gen_rtx_fmt_sse(c, m, p0, p1, p2)\ + gen_rtx_fmt_sse_stat (c, m, p0, p1, p2 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_sies_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + int arg1, + rtx arg2, + const char *arg3 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XINT (rt, 1) = arg1; + XEXP (rt, 2) = arg2; + XSTR (rt, 3) = arg3; + + return rt; +} + +#define gen_rtx_fmt_sies(c, m, p0, p1, p2, p3)\ + gen_rtx_fmt_sies_stat (c, m, p0, p1, p2, p3 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_sE_stat (RTX_CODE code, enum machine_mode mode, + const char *arg0, + rtvec arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XSTR (rt, 0) = arg0; + XVEC (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_sE(c, m, p0, p1)\ + gen_rtx_fmt_sE_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_ii_stat (RTX_CODE code, enum machine_mode mode, + int arg0, + int arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XINT (rt, 0) = arg0; + XINT (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_ii(c, m, p0, p1)\ + gen_rtx_fmt_ii_stat (c, m, p0, p1 MEM_STAT_INFO) + +static inline rtx +gen_rtx_fmt_Ee_stat (RTX_CODE code, enum machine_mode mode, + rtvec arg0, + rtx arg1 MEM_STAT_DECL) +{ + rtx rt; + rt = rtx_alloc_stat (code PASS_MEM_STAT); + + PUT_MODE (rt, mode); + XVEC (rt, 0) = arg0; + XEXP (rt, 1) = arg1; + + return rt; +} + +#define gen_rtx_fmt_Ee(c, m, p0, p1)\ + gen_rtx_fmt_Ee_stat (c, m, p0, p1 MEM_STAT_INFO) + + +#define gen_rtx_VALUE(MODE) \ + gen_rtx_fmt_0 (VALUE, (MODE)) +#define gen_rtx_DEBUG_EXPR(MODE) \ + gen_rtx_fmt_0 (DEBUG_EXPR, (MODE)) +#define gen_rtx_EXPR_LIST(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (EXPR_LIST, (MODE), (ARG0), (ARG1)) +#define gen_rtx_INSN_LIST(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ue (INSN_LIST, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SEQUENCE(MODE, ARG0) \ + gen_rtx_fmt_E (SEQUENCE, (MODE), (ARG0)) +#define gen_rtx_ADDRESS(MODE, ARG0) \ + gen_rtx_fmt_e (ADDRESS, (MODE), (ARG0)) +#define gen_rtx_DEBUG_INSN(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + gen_rtx_fmt_iuuBeiie (DEBUG_INSN, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#define gen_rtx_INSN(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + gen_rtx_fmt_iuuBeiie (INSN, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#define gen_rtx_JUMP_INSN(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) \ + gen_rtx_fmt_iuuBeiie0 (JUMP_INSN, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7)) +#define gen_rtx_CALL_INSN(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8) \ + gen_rtx_fmt_iuuBeiiee (CALL_INSN, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6), (ARG7), (ARG8)) +#define gen_rtx_BARRIER(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_iuu00000 (BARRIER, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_CODE_LABEL(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5) \ + gen_rtx_fmt_iuuB00is (CODE_LABEL, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (ARG5)) +#define gen_rtx_COND_EXEC(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (COND_EXEC, (MODE), (ARG0), (ARG1)) +#define gen_rtx_PARALLEL(MODE, ARG0) \ + gen_rtx_fmt_E (PARALLEL, (MODE), (ARG0)) +#define gen_rtx_ASM_INPUT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ASM_OPERANDS(MODE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \ + gen_rtx_fmt_ssiEEEi (ASM_OPERANDS, (MODE), (ARG0), (ARG1), (ARG2), (ARG3), (ARG4), (ARG5), (ARG6)) +#define gen_rtx_UNSPEC(MODE, ARG0, ARG1) \ + gen_rtx_fmt_Ei (UNSPEC, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNSPEC_VOLATILE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_Ei (UNSPEC_VOLATILE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ADDR_VEC(MODE, ARG0) \ + gen_rtx_fmt_E (ADDR_VEC, (MODE), (ARG0)) +#define gen_rtx_ADDR_DIFF_VEC(MODE, ARG0, ARG1, ARG2, ARG3) \ + gen_rtx_fmt_eEee0 (ADDR_DIFF_VEC, (MODE), (ARG0), (ARG1), (ARG2), (ARG3)) +#define gen_rtx_PREFETCH(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_eee (PREFETCH, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_SET(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SET, (MODE), (ARG0), (ARG1)) +#define gen_rtx_USE(MODE, ARG0) \ + gen_rtx_fmt_e (USE, (MODE), (ARG0)) +#define gen_rtx_CLOBBER(MODE, ARG0) \ + gen_rtx_fmt_e (CLOBBER, (MODE), (ARG0)) +#define gen_rtx_CALL(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (CALL, (MODE), (ARG0), (ARG1)) +#define gen_rtx_RETURN(MODE) \ + gen_rtx_fmt_ (RETURN, (MODE)) +#define gen_rtx_EH_RETURN(MODE) \ + gen_rtx_fmt_ (EH_RETURN, (MODE)) +#define gen_rtx_TRAP_IF(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (TRAP_IF, (MODE), (ARG0), (ARG1)) +#define gen_rtx_raw_CONST_INT(MODE, ARG0) \ + gen_rtx_fmt_w (CONST_INT, (MODE), (ARG0)) +#define gen_rtx_raw_CONST_VECTOR(MODE, ARG0) \ + gen_rtx_fmt_E (CONST_VECTOR, (MODE), (ARG0)) +#define gen_rtx_CONST_STRING(MODE, ARG0) \ + gen_rtx_fmt_s (CONST_STRING, (MODE), (ARG0)) +#define gen_rtx_CONST(MODE, ARG0) \ + gen_rtx_fmt_e (CONST, (MODE), (ARG0)) +#define gen_rtx_PC(MODE) \ + gen_rtx_fmt_ (PC, (MODE)) +#define gen_rtx_raw_REG(MODE, ARG0) \ + gen_rtx_fmt_i00 (REG, (MODE), (ARG0)) +#define gen_rtx_SCRATCH(MODE) \ + gen_rtx_fmt_0 (SCRATCH, (MODE)) +#define gen_rtx_raw_SUBREG(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ei (SUBREG, (MODE), (ARG0), (ARG1)) +#define gen_rtx_STRICT_LOW_PART(MODE, ARG0) \ + gen_rtx_fmt_e (STRICT_LOW_PART, (MODE), (ARG0)) +#define gen_rtx_CONCAT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (CONCAT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_CONCATN(MODE, ARG0) \ + gen_rtx_fmt_E (CONCATN, (MODE), (ARG0)) +#define gen_rtx_raw_MEM(MODE, ARG0) \ + gen_rtx_fmt_e0 (MEM, (MODE), (ARG0)) +#define gen_rtx_LABEL_REF(MODE, ARG0) \ + gen_rtx_fmt_u (LABEL_REF, (MODE), (ARG0)) +#define gen_rtx_SYMBOL_REF(MODE, ARG0) \ + gen_rtx_fmt_s00 (SYMBOL_REF, (MODE), (ARG0)) +#define gen_rtx_CC0(MODE) \ + gen_rtx_fmt_ (CC0, (MODE)) +#define gen_rtx_IF_THEN_ELSE(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_eee (IF_THEN_ELSE, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_COMPARE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (COMPARE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_PLUS(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (PLUS, (MODE), (ARG0), (ARG1)) +#define gen_rtx_MINUS(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (MINUS, (MODE), (ARG0), (ARG1)) +#define gen_rtx_NEG(MODE, ARG0) \ + gen_rtx_fmt_e (NEG, (MODE), (ARG0)) +#define gen_rtx_MULT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (MULT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SS_MULT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SS_MULT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_US_MULT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (US_MULT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_DIV(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (DIV, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SS_DIV(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SS_DIV, (MODE), (ARG0), (ARG1)) +#define gen_rtx_US_DIV(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (US_DIV, (MODE), (ARG0), (ARG1)) +#define gen_rtx_MOD(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (MOD, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UDIV(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UDIV, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UMOD(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UMOD, (MODE), (ARG0), (ARG1)) +#define gen_rtx_AND(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (AND, (MODE), (ARG0), (ARG1)) +#define gen_rtx_IOR(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (IOR, (MODE), (ARG0), (ARG1)) +#define gen_rtx_XOR(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (XOR, (MODE), (ARG0), (ARG1)) +#define gen_rtx_NOT(MODE, ARG0) \ + gen_rtx_fmt_e (NOT, (MODE), (ARG0)) +#define gen_rtx_ASHIFT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (ASHIFT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ROTATE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (ROTATE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ASHIFTRT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (ASHIFTRT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_LSHIFTRT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LSHIFTRT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ROTATERT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (ROTATERT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SMIN(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SMIN, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SMAX(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SMAX, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UMIN(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UMIN, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UMAX(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UMAX, (MODE), (ARG0), (ARG1)) +#define gen_rtx_PRE_DEC(MODE, ARG0) \ + gen_rtx_fmt_e (PRE_DEC, (MODE), (ARG0)) +#define gen_rtx_PRE_INC(MODE, ARG0) \ + gen_rtx_fmt_e (PRE_INC, (MODE), (ARG0)) +#define gen_rtx_POST_DEC(MODE, ARG0) \ + gen_rtx_fmt_e (POST_DEC, (MODE), (ARG0)) +#define gen_rtx_POST_INC(MODE, ARG0) \ + gen_rtx_fmt_e (POST_INC, (MODE), (ARG0)) +#define gen_rtx_PRE_MODIFY(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (PRE_MODIFY, (MODE), (ARG0), (ARG1)) +#define gen_rtx_POST_MODIFY(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (POST_MODIFY, (MODE), (ARG0), (ARG1)) +#define gen_rtx_NE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (NE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_EQ(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (EQ, (MODE), (ARG0), (ARG1)) +#define gen_rtx_GE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (GE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_GT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (GT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_LE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_LT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_GEU(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (GEU, (MODE), (ARG0), (ARG1)) +#define gen_rtx_GTU(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (GTU, (MODE), (ARG0), (ARG1)) +#define gen_rtx_LEU(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LEU, (MODE), (ARG0), (ARG1)) +#define gen_rtx_LTU(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LTU, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNORDERED(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UNORDERED, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ORDERED(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (ORDERED, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNEQ(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UNEQ, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNGE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UNGE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNGT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UNGT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNLE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UNLE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_UNLT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (UNLT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_LTGT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LTGT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SIGN_EXTEND(MODE, ARG0) \ + gen_rtx_fmt_e (SIGN_EXTEND, (MODE), (ARG0)) +#define gen_rtx_ZERO_EXTEND(MODE, ARG0) \ + gen_rtx_fmt_e (ZERO_EXTEND, (MODE), (ARG0)) +#define gen_rtx_TRUNCATE(MODE, ARG0) \ + gen_rtx_fmt_e (TRUNCATE, (MODE), (ARG0)) +#define gen_rtx_FLOAT_EXTEND(MODE, ARG0) \ + gen_rtx_fmt_e (FLOAT_EXTEND, (MODE), (ARG0)) +#define gen_rtx_FLOAT_TRUNCATE(MODE, ARG0) \ + gen_rtx_fmt_e (FLOAT_TRUNCATE, (MODE), (ARG0)) +#define gen_rtx_FLOAT(MODE, ARG0) \ + gen_rtx_fmt_e (FLOAT, (MODE), (ARG0)) +#define gen_rtx_FIX(MODE, ARG0) \ + gen_rtx_fmt_e (FIX, (MODE), (ARG0)) +#define gen_rtx_UNSIGNED_FLOAT(MODE, ARG0) \ + gen_rtx_fmt_e (UNSIGNED_FLOAT, (MODE), (ARG0)) +#define gen_rtx_UNSIGNED_FIX(MODE, ARG0) \ + gen_rtx_fmt_e (UNSIGNED_FIX, (MODE), (ARG0)) +#define gen_rtx_FRACT_CONVERT(MODE, ARG0) \ + gen_rtx_fmt_e (FRACT_CONVERT, (MODE), (ARG0)) +#define gen_rtx_UNSIGNED_FRACT_CONVERT(MODE, ARG0) \ + gen_rtx_fmt_e (UNSIGNED_FRACT_CONVERT, (MODE), (ARG0)) +#define gen_rtx_SAT_FRACT(MODE, ARG0) \ + gen_rtx_fmt_e (SAT_FRACT, (MODE), (ARG0)) +#define gen_rtx_UNSIGNED_SAT_FRACT(MODE, ARG0) \ + gen_rtx_fmt_e (UNSIGNED_SAT_FRACT, (MODE), (ARG0)) +#define gen_rtx_ABS(MODE, ARG0) \ + gen_rtx_fmt_e (ABS, (MODE), (ARG0)) +#define gen_rtx_SQRT(MODE, ARG0) \ + gen_rtx_fmt_e (SQRT, (MODE), (ARG0)) +#define gen_rtx_BSWAP(MODE, ARG0) \ + gen_rtx_fmt_e (BSWAP, (MODE), (ARG0)) +#define gen_rtx_FFS(MODE, ARG0) \ + gen_rtx_fmt_e (FFS, (MODE), (ARG0)) +#define gen_rtx_CLZ(MODE, ARG0) \ + gen_rtx_fmt_e (CLZ, (MODE), (ARG0)) +#define gen_rtx_CTZ(MODE, ARG0) \ + gen_rtx_fmt_e (CTZ, (MODE), (ARG0)) +#define gen_rtx_POPCOUNT(MODE, ARG0) \ + gen_rtx_fmt_e (POPCOUNT, (MODE), (ARG0)) +#define gen_rtx_PARITY(MODE, ARG0) \ + gen_rtx_fmt_e (PARITY, (MODE), (ARG0)) +#define gen_rtx_SIGN_EXTRACT(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_eee (SIGN_EXTRACT, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_ZERO_EXTRACT(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_eee (ZERO_EXTRACT, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_HIGH(MODE, ARG0) \ + gen_rtx_fmt_e (HIGH, (MODE), (ARG0)) +#define gen_rtx_LO_SUM(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (LO_SUM, (MODE), (ARG0), (ARG1)) +#define gen_rtx_VEC_MERGE(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_eee (VEC_MERGE, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_VEC_SELECT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (VEC_SELECT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_VEC_CONCAT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (VEC_CONCAT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_VEC_DUPLICATE(MODE, ARG0) \ + gen_rtx_fmt_e (VEC_DUPLICATE, (MODE), (ARG0)) +#define gen_rtx_SS_PLUS(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SS_PLUS, (MODE), (ARG0), (ARG1)) +#define gen_rtx_US_PLUS(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (US_PLUS, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SS_MINUS(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SS_MINUS, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SS_NEG(MODE, ARG0) \ + gen_rtx_fmt_e (SS_NEG, (MODE), (ARG0)) +#define gen_rtx_US_NEG(MODE, ARG0) \ + gen_rtx_fmt_e (US_NEG, (MODE), (ARG0)) +#define gen_rtx_SS_ABS(MODE, ARG0) \ + gen_rtx_fmt_e (SS_ABS, (MODE), (ARG0)) +#define gen_rtx_SS_ASHIFT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (SS_ASHIFT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_US_ASHIFT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (US_ASHIFT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_US_MINUS(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ee (US_MINUS, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SS_TRUNCATE(MODE, ARG0) \ + gen_rtx_fmt_e (SS_TRUNCATE, (MODE), (ARG0)) +#define gen_rtx_US_TRUNCATE(MODE, ARG0) \ + gen_rtx_fmt_e (US_TRUNCATE, (MODE), (ARG0)) +#define gen_rtx_FMA(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_eee (FMA, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_VAR_LOCATION(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_tei (VAR_LOCATION, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEBUG_IMPLICIT_PTR(MODE, ARG0) \ + gen_rtx_fmt_t (DEBUG_IMPLICIT_PTR, (MODE), (ARG0)) +#define gen_rtx_MATCH_OPERAND(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_iss (MATCH_OPERAND, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_MATCH_SCRATCH(MODE, ARG0, ARG1) \ + gen_rtx_fmt_is (MATCH_SCRATCH, (MODE), (ARG0), (ARG1)) +#define gen_rtx_MATCH_OPERATOR(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_isE (MATCH_OPERATOR, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_MATCH_PARALLEL(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_isE (MATCH_PARALLEL, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_MATCH_DUP(MODE, ARG0) \ + gen_rtx_fmt_i (MATCH_DUP, (MODE), (ARG0)) +#define gen_rtx_MATCH_OP_DUP(MODE, ARG0, ARG1) \ + gen_rtx_fmt_iE (MATCH_OP_DUP, (MODE), (ARG0), (ARG1)) +#define gen_rtx_MATCH_PAR_DUP(MODE, ARG0, ARG1) \ + gen_rtx_fmt_iE (MATCH_PAR_DUP, (MODE), (ARG0), (ARG1)) +#define gen_rtx_MATCH_CODE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (MATCH_CODE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_MATCH_TEST(MODE, ARG0) \ + gen_rtx_fmt_s (MATCH_TEST, (MODE), (ARG0)) +#define gen_rtx_DEFINE_EXPAND(MODE, ARG0, ARG1, ARG2, ARG3) \ + gen_rtx_fmt_sEss (DEFINE_EXPAND, (MODE), (ARG0), (ARG1), (ARG2), (ARG3)) +#define gen_rtx_DEFINE_DELAY(MODE, ARG0, ARG1) \ + gen_rtx_fmt_eE (DEFINE_DELAY, (MODE), (ARG0), (ARG1)) +#define gen_rtx_DEFINE_COND_EXEC(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_Ess (DEFINE_COND_EXEC, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_PREDICATE(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_ses (DEFINE_PREDICATE, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_SPECIAL_PREDICATE(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_ses (DEFINE_SPECIAL_PREDICATE, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_REGISTER_CONSTRAINT(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_sss (DEFINE_REGISTER_CONSTRAINT, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_CONSTRAINT(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_sse (DEFINE_CONSTRAINT, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_MEMORY_CONSTRAINT(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_sse (DEFINE_MEMORY_CONSTRAINT, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_ADDRESS_CONSTRAINT(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_sse (DEFINE_ADDRESS_CONSTRAINT, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_EXCLUSION_SET(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (EXCLUSION_SET, (MODE), (ARG0), (ARG1)) +#define gen_rtx_PRESENCE_SET(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (PRESENCE_SET, (MODE), (ARG0), (ARG1)) +#define gen_rtx_FINAL_PRESENCE_SET(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (FINAL_PRESENCE_SET, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ABSENCE_SET(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (ABSENCE_SET, (MODE), (ARG0), (ARG1)) +#define gen_rtx_FINAL_ABSENCE_SET(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (FINAL_ABSENCE_SET, (MODE), (ARG0), (ARG1)) +#define gen_rtx_DEFINE_AUTOMATON(MODE, ARG0) \ + gen_rtx_fmt_s (DEFINE_AUTOMATON, (MODE), (ARG0)) +#define gen_rtx_AUTOMATA_OPTION(MODE, ARG0) \ + gen_rtx_fmt_s (AUTOMATA_OPTION, (MODE), (ARG0)) +#define gen_rtx_DEFINE_RESERVATION(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (DEFINE_RESERVATION, (MODE), (ARG0), (ARG1)) +#define gen_rtx_DEFINE_INSN_RESERVATION(MODE, ARG0, ARG1, ARG2, ARG3) \ + gen_rtx_fmt_sies (DEFINE_INSN_RESERVATION, (MODE), (ARG0), (ARG1), (ARG2), (ARG3)) +#define gen_rtx_DEFINE_ATTR(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_sse (DEFINE_ATTR, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_DEFINE_ENUM_ATTR(MODE, ARG0, ARG1, ARG2) \ + gen_rtx_fmt_sse (DEFINE_ENUM_ATTR, (MODE), (ARG0), (ARG1), (ARG2)) +#define gen_rtx_ATTR(MODE, ARG0) \ + gen_rtx_fmt_s (ATTR, (MODE), (ARG0)) +#define gen_rtx_SET_ATTR(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (SET_ATTR, (MODE), (ARG0), (ARG1)) +#define gen_rtx_SET_ATTR_ALTERNATIVE(MODE, ARG0, ARG1) \ + gen_rtx_fmt_sE (SET_ATTR_ALTERNATIVE, (MODE), (ARG0), (ARG1)) +#define gen_rtx_EQ_ATTR(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ss (EQ_ATTR, (MODE), (ARG0), (ARG1)) +#define gen_rtx_EQ_ATTR_ALT(MODE, ARG0, ARG1) \ + gen_rtx_fmt_ii (EQ_ATTR_ALT, (MODE), (ARG0), (ARG1)) +#define gen_rtx_ATTR_FLAG(MODE, ARG0) \ + gen_rtx_fmt_s (ATTR_FLAG, (MODE), (ARG0)) +#define gen_rtx_COND(MODE, ARG0, ARG1) \ + gen_rtx_fmt_Ee (COND, (MODE), (ARG0), (ARG1)) + +#endif /* GCC_GENRTL_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ggc.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ggc.h new file mode 100644 index 0000000..00db925 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ggc.h @@ -0,0 +1,360 @@ +/* Garbage collection for the GNU compiler. + + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, + 2008, 2009, 2010 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/>. */ + +#ifndef GCC_GGC_H +#define GCC_GGC_H +#include "statistics.h" + +/* Symbols are marked with `ggc' for `gcc gc' so as not to interfere with + an external gc library that might be linked in. */ + +/* Constants for general use. */ +extern const char empty_string[]; /* empty string */ + +/* Internal functions and data structures used by the GTY + machinery, including the generated gt*.[hc] files. */ + +/* The first parameter is a pointer to a pointer, the second a cookie. */ +typedef void (*gt_pointer_operator) (void *, void *); + +#include "gtype-desc.h" + +/* One of these applies its third parameter (with cookie in the fourth + parameter) to each pointer in the object pointed to by the first + parameter, using the second parameter. */ +typedef void (*gt_note_pointers) (void *, void *, gt_pointer_operator, + void *); + +/* One of these is called before objects are re-ordered in memory. + The first parameter is the original object, the second is the + subobject that has had its pointers reordered, the third parameter + can compute the new values of a pointer when given the cookie in + the fourth parameter. */ +typedef void (*gt_handle_reorder) (void *, void *, gt_pointer_operator, + void *); + +/* Used by the gt_pch_n_* routines. Register an object in the hash table. */ +extern int gt_pch_note_object (void *, void *, gt_note_pointers, + enum gt_types_enum); + +/* Used by the gt_pch_n_* routines. Register that an object has a reorder + function. */ +extern void gt_pch_note_reorder (void *, void *, gt_handle_reorder); + +/* Mark the object in the first parameter and anything it points to. */ +typedef void (*gt_pointer_walker) (void *); + +/* Structures for the easy way to mark roots. + In an array, terminated by having base == NULL. */ +struct ggc_root_tab { + void *base; + size_t nelt; + size_t stride; + gt_pointer_walker cb; + gt_pointer_walker pchw; +}; +#define LAST_GGC_ROOT_TAB { NULL, 0, 0, NULL, NULL } +/* Pointers to arrays of ggc_root_tab, terminated by NULL. */ +extern const struct ggc_root_tab * const gt_ggc_rtab[]; +extern const struct ggc_root_tab * const gt_ggc_deletable_rtab[]; +extern const struct ggc_root_tab * const gt_pch_cache_rtab[]; +extern const struct ggc_root_tab * const gt_pch_scalar_rtab[]; + +/* Structure for hash table cache marking. */ +struct htab; +struct ggc_cache_tab { + struct htab * *base; + size_t nelt; + size_t stride; + gt_pointer_walker cb; + gt_pointer_walker pchw; + int (*marked_p) (const void *); +}; +#define LAST_GGC_CACHE_TAB { NULL, 0, 0, NULL, NULL, NULL } +/* Pointers to arrays of ggc_cache_tab, terminated by NULL. */ +extern const struct ggc_cache_tab * const gt_ggc_cache_rtab[]; + +/* If EXPR is not NULL and previously unmarked, mark it and evaluate + to true. Otherwise evaluate to false. */ +#define ggc_test_and_set_mark(EXPR) \ + ((EXPR) != NULL && ((void *) (EXPR)) != (void *) 1 && ! ggc_set_mark (EXPR)) + +#define ggc_mark(EXPR) \ + do { \ + const void *const a__ = (EXPR); \ + if (a__ != NULL && a__ != (void *) 1) \ + ggc_set_mark (a__); \ + } while (0) + +/* Actually set the mark on a particular region of memory, but don't + follow pointers. This function is called by ggc_mark_*. It + returns zero if the object was not previously marked; nonzero if + the object was already marked, or if, for any other reason, + pointers in this data structure should not be traversed. */ +extern int ggc_set_mark (const void *); + +/* Return 1 if P has been marked, zero otherwise. + P must have been allocated by the GC allocator; it mustn't point to + static objects, stack variables, or memory allocated with malloc. */ +extern int ggc_marked_p (const void *); + +/* PCH and GGC handling for strings, mostly trivial. */ +extern void gt_pch_n_S (const void *); +extern void gt_ggc_m_S (const void *); + +/* End of GTY machinery API. */ + +struct alloc_zone; + +/* Initialize the string pool. */ +extern void init_stringpool (void); + +/* Initialize the garbage collector. */ +extern void init_ggc (void); + +/* When true, identifier nodes are considered as GC roots. When + false, identifier nodes are treated like any other GC-allocated + object, and the identifier hash table is treated as a weak + hash. */ +extern bool ggc_protect_identifiers; + +/* Write out all GCed objects to F. */ +extern void gt_pch_save (FILE *f); + + +/* Allocation. */ + +/* The internal primitive. */ +extern void *ggc_internal_alloc_stat (size_t MEM_STAT_DECL); + +#define ggc_internal_alloc(s) ggc_internal_alloc_stat (s MEM_STAT_INFO) + +/* Allocate an object of the specified type and size. */ +extern void *ggc_alloc_typed_stat (enum gt_types_enum, size_t MEM_STAT_DECL); + +#define ggc_alloc_typed(s, z) ggc_alloc_typed_stat (s, z MEM_STAT_INFO) + +/* Allocates cleared memory. */ +extern void *ggc_internal_cleared_alloc_stat (size_t MEM_STAT_DECL); + +/* Resize a block. */ +extern void *ggc_realloc_stat (void *, size_t MEM_STAT_DECL); + +/* Free a block. To be used when known for certain it's not reachable. */ +extern void ggc_free (void *); + +extern void ggc_record_overhead (size_t, size_t, void * MEM_STAT_DECL); +extern void ggc_free_overhead (void *); +extern void ggc_prune_overhead_list (void); + +extern void dump_ggc_loc_statistics (bool); + +/* Reallocators. */ +#define GGC_RESIZEVEC(T, P, N) \ + ((T *) ggc_realloc_stat ((P), (N) * sizeof (T) MEM_STAT_INFO)) + +#define GGC_RESIZEVAR(T, P, N) \ + ((T *) ggc_realloc_stat ((P), (N) MEM_STAT_INFO)) + +static inline void * +ggc_internal_vec_alloc_stat (size_t s, size_t c MEM_STAT_DECL) +{ + return ggc_internal_alloc_stat (c * s PASS_MEM_STAT); +} + +static inline void * +ggc_internal_cleared_vec_alloc_stat (size_t s, size_t c MEM_STAT_DECL) +{ + return ggc_internal_cleared_alloc_stat (c * s PASS_MEM_STAT); +} + +#define ggc_internal_cleared_vec_alloc(s, c) \ + (ggc_internal_cleared_vec_alloc_stat ((s), (c) MEM_STAT_INFO)) + +static inline void * +ggc_alloc_atomic_stat (size_t s MEM_STAT_DECL) +{ + return ggc_internal_alloc_stat (s PASS_MEM_STAT); +} + +#define ggc_alloc_atomic(S) (ggc_alloc_atomic_stat ((S) MEM_STAT_INFO)) + +#define ggc_alloc_cleared_atomic(S) \ + (ggc_internal_cleared_alloc_stat ((S) MEM_STAT_INFO)) + +extern void * ggc_cleared_alloc_htab_ignore_args (size_t, size_t); + +extern void * ggc_cleared_alloc_ptr_array_two_args (size_t, size_t); + +#define htab_create_ggc(SIZE, HASH, EQ, DEL) \ + htab_create_typed_alloc (SIZE, HASH, EQ, DEL, \ + ggc_cleared_alloc_htab_ignore_args, \ + ggc_cleared_alloc_ptr_array_two_args, \ + ggc_free) + +#define splay_tree_new_ggc(COMPARE, ALLOC_TREE, ALLOC_NODE) \ + splay_tree_new_typed_alloc (COMPARE, NULL, NULL, &ALLOC_TREE, &ALLOC_NODE, \ + &ggc_splay_dont_free, NULL) + +extern void *ggc_splay_alloc (enum gt_types_enum, int, void *); + +extern void ggc_splay_dont_free (void *, void *); + +/* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS. + If LENGTH is -1, then CONTENTS is assumed to be a + null-terminated string and the memory sized accordingly. */ +extern const char *ggc_alloc_string_stat (const char *contents, int length + MEM_STAT_DECL); + +#define ggc_alloc_string(c, l) ggc_alloc_string_stat (c, l MEM_STAT_INFO) + +/* Make a copy of S, in GC-able memory. */ +#define ggc_strdup(S) ggc_alloc_string_stat ((S), -1 MEM_STAT_INFO) + +/* Invoke the collector. Garbage collection occurs only when this + function is called, not during allocations. */ +extern void ggc_collect (void); + +/* Register an additional root table. This can be useful for some + plugins. Does nothing if the passed pointer is NULL. */ +extern void ggc_register_root_tab (const struct ggc_root_tab *); + +/* Register an additional cache table. This can be useful for some + plugins. Does nothing if the passed pointer is NULL. */ +extern void ggc_register_cache_tab (const struct ggc_cache_tab *); + +/* Read objects previously saved with gt_pch_save from F. */ +extern void gt_pch_restore (FILE *f); + +/* Statistics. */ + +/* Print allocation statistics. */ +extern void ggc_print_statistics (void); + +extern void stringpool_statistics (void); + +/* Heuristics. */ +extern void init_ggc_heuristics (void); + +/* Zone collection. */ + +/* For regular rtl allocations. */ +extern struct alloc_zone rtl_zone; + +/* For regular tree allocations. */ +extern struct alloc_zone tree_zone; + +/* For IDENTIFIER_NODE allocations. */ +extern struct alloc_zone tree_id_zone; + +#define ggc_alloc_rtvec_sized(NELT) \ + (ggc_alloc_zone_vec_rtvec_def (1, \ + sizeof (struct rtvec_def) \ + + ((NELT) - 1) * sizeof (rtx), \ + &rtl_zone)) + +#if defined (GGC_ZONE) && !defined (GENERATOR_FILE) + +/* Allocate an object into the specified allocation zone. */ +extern void *ggc_internal_alloc_zone_stat (size_t, + struct alloc_zone * MEM_STAT_DECL); + +extern void *ggc_internal_cleared_alloc_zone_stat (size_t, + struct alloc_zone * MEM_STAT_DECL); + +static inline void * +ggc_internal_zone_alloc_stat (struct alloc_zone * z, size_t s MEM_STAT_DECL) +{ + return ggc_internal_alloc_zone_stat (s, z PASS_MEM_STAT); +} + +static inline void * +ggc_internal_zone_cleared_alloc_stat (struct alloc_zone * z, size_t s + MEM_STAT_DECL) +{ + return ggc_internal_cleared_alloc_zone_stat (s, z PASS_MEM_STAT); +} + +static inline void * +ggc_internal_zone_vec_alloc_stat (struct alloc_zone * z, size_t s, size_t n + MEM_STAT_DECL) +{ + return ggc_internal_alloc_zone_stat (s * n, z PASS_MEM_STAT); +} + + +#else + +static inline void * +ggc_internal_zone_alloc_stat (struct alloc_zone * z ATTRIBUTE_UNUSED, + size_t s MEM_STAT_DECL) +{ + return ggc_internal_alloc_stat (s PASS_MEM_STAT); +} + +static inline void * +ggc_internal_zone_cleared_alloc_stat (struct alloc_zone * z ATTRIBUTE_UNUSED, + size_t s MEM_STAT_DECL) +{ + return ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT); +} + +static inline void * +ggc_internal_zone_vec_alloc_stat (struct alloc_zone * z ATTRIBUTE_UNUSED, + size_t s, size_t n MEM_STAT_DECL) +{ + return ggc_internal_vec_alloc_stat (s, n PASS_MEM_STAT); +} + +extern size_t ggc_total_allocated (void); + +#endif + +/* Memory statistics passing versions of some allocators. Too few of them to + make gengtype produce them, so just define the needed ones here. */ +static inline struct rtx_def * +ggc_alloc_zone_rtx_def_stat (struct alloc_zone * z, size_t s MEM_STAT_DECL) +{ + return (struct rtx_def *) ggc_internal_zone_alloc_stat (z, s PASS_MEM_STAT); +} + +static inline union tree_node * +ggc_alloc_zone_tree_node_stat (struct alloc_zone * z, size_t s MEM_STAT_DECL) +{ + return (union tree_node *) ggc_internal_zone_alloc_stat (z, s PASS_MEM_STAT); +} + +static inline union tree_node * +ggc_alloc_zone_cleared_tree_node_stat (struct alloc_zone * z, size_t s + MEM_STAT_DECL) +{ + return (union tree_node *) + ggc_internal_zone_cleared_alloc_stat (z, s PASS_MEM_STAT); +} + +static inline union gimple_statement_d * +ggc_alloc_cleared_gimple_statement_d_stat (size_t s MEM_STAT_DECL) +{ + return (union gimple_statement_d *) + ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT); +} + +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gimple.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gimple.def new file mode 100644 index 0000000..2b5488a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gimple.def @@ -0,0 +1,350 @@ +/* This file contains the definitions of the GIMPLE IR tuples used in GCC. + + Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Contributed by Aldy Hernandez <aldyh@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* The format of this file is + DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol). */ + + +/* Error marker. This is used in similar ways as ERROR_MARK in tree.def. */ +DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE) + +/* IMPORTANT. Do not rearrange the codes between GIMPLE_COND and + GIMPLE_RETURN. The ordering is exposed by gimple_has_ops calls. + These are all the GIMPLE statements with register operands. */ + +/* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL> + represents the conditional jump: + + if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL + + COND_CODE is the tree code used as the comparison predicate. It + must be of class tcc_comparison. + + OP1 and OP2 are the operands used in the comparison. They must be + accepted by is_gimple_operand. + + TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the + jump target for the comparison. */ +DEFGSCODE(GIMPLE_COND, "gimple_cond", GSS_WITH_OPS) + +/* GIMPLE_DEBUG represents a debug statement. */ +DEFGSCODE(GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS) + +/* GIMPLE_GOTO <TARGET> represents unconditional jumps. + TARGET is a LABEL_DECL or an expression node for computed GOTOs. */ +DEFGSCODE(GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS) + +/* GIMPLE_LABEL <LABEL> represents label statements. LABEL is a + LABEL_DECL representing a jump target. */ +DEFGSCODE(GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS) + +/* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the + multiway branch: + + switch (INDEX) + { + case LAB1: ...; break; + ... + case LABN: ...; break; + default: ... + } + + INDEX is the variable evaluated to decide which label to jump to. + + DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels. + They must be CASE_LABEL_EXPR nodes. */ +DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", GSS_WITH_OPS) + +/* IMPORTANT. + + Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN. + It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE + statements with memory and register operands. */ + +/* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment + statement + + LHS = RHS1 SUBCODE RHS2. + + SUBCODE is the tree code for the expression computed by the RHS of the + assignment. It must be one of the tree codes accepted by + get_gimple_rhs_class. If LHS is not a gimple register according to + is_gimple_reg, SUBCODE must be of class GIMPLE_SINGLE_RHS. + + LHS is the operand on the LHS of the assignment. It must be a tree node + accepted by is_gimple_lvalue. + + RHS1 is the first operand on the RHS of the assignment. It must always be + present. It must be a tree node accepted by is_gimple_val. + + RHS2 is the second operand on the RHS of the assignment. It must be a tree + node accepted by is_gimple_val. This argument exists only if SUBCODE is + of class GIMPLE_BINARY_RHS. */ +DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS) + +/* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP> + represents inline assembly statements. + + STRING is the string containing the assembly statements. + I1 ... IN are the N input operands. + O1 ... OM are the M output operands. + C1 ... CP are the P clobber operands. + L1 ... LQ are the Q label operands. */ +DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM) + +/* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function + calls. + + FN is the callee. It must be accepted by is_gimple_call_addr. + + LHS is the operand where the return value from FN is stored. It may + be NULL. + + ARG1 ... ARGN are the arguments. They must all be accepted by + is_gimple_operand. + + CHAIN is the optional static chain link for nested functions. */ +DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_CALL) + +/* GIMPLE_RETURN <RETVAL> represents return statements. + + RETVAL is the value to return or NULL. If a value is returned it + must be accepted by is_gimple_operand. */ +DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS) + +/* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope. + VARS is the set of variables declared in that scope. + BLOCK is the symbol binding block used for debug information. + BODY is the sequence of statements in the scope. */ +DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND) + +/* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler. + TYPES is the type (or list of types) handled. HANDLER is the + sequence of statements that handle these types. */ +DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH) + +/* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception + specification. TYPES is a list of allowed types and FAILURE is the + sequence of statements to execute on failure. */ +DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER) + +/* GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier. + DECL is a noreturn function decl taking no arguments that will + be invoked if an exception propagates to this point. */ +DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT) + +/* GIMPLE_RESX resumes execution after an exception. */ +DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL) + +/* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on + the FILTER argument. */ +DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL) + +/* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node + + RESULT = PHI <ARG1, ..., ARGN> + + RESULT is the SSA name created by this PHI node. + + ARG1 ... ARGN are the arguments to the PHI node. N must be + exactly the same as the number of incoming edges to the basic block + holding the PHI node. Every argument is either an SSA name or a + tree node of class tcc_constant. */ +DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI) + +/* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP> + represents a try/catch or a try/finally statement. + + TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. + + EVAL is the sequence of statements to execute on entry to GIMPLE_TRY. + + CLEANUP is the sequence of statements to execute according to + TRY_KIND. If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected + if an exception is thrown during execution of EVAL. If TRY_KIND is + GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL + (regardless of whether EVAL finished normally, or jumped out or an + exception was thrown). */ +DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY) + +/* GIMPLE_NOP represents the "do nothing" statement. */ +DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE) + + +/* IMPORTANT. + + Do not rearrange any of the GIMPLE_OMP_* codes. This ordering is + exposed by the range check in gimple_omp_subcode(). */ + + +/* Tuples used for lowering of OMP_ATOMIC. Although the form of the OMP_ATOMIC + expression is very simple (just in form mem op= expr), various implicit + conversions may cause the expression to become more complex, so that it does + not fit the gimple grammar very well. To overcome this problem, OMP_ATOMIC + is rewritten as a sequence of two codes in gimplification: + + GIMPLE_OMP_LOAD (tmp, mem) + val = some computations involving tmp; + GIMPLE_OMP_STORE (val). */ +DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load", + GSS_OMP_ATOMIC_LOAD) +DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store", + GSS_OMP_ATOMIC_STORE) + +/* GIMPLE_OMP_CONTINUE marks the location of the loop or sections + iteration in partially lowered OpenMP code. */ +DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE) + +/* GIMPLE_OMP_CRITICAL <NAME, BODY> represents + + #pragma omp critical [name] + + NAME is the name given to the critical section. + BODY is the sequence of statements that are inside the critical section. */ +DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL) + +/* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY> + represents + + PRE_BODY + #pragma omp for [clause1 ... clauseN] + for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR) + BODY + + BODY is the loop body. + + CLAUSES is the list of clauses. + + INDEX must be an integer or pointer variable, which is implicitly thread + private. It must be accepted by is_gimple_operand. + + INITIAL is the initial value given to INDEX. It must be + accepted by is_gimple_operand. + + FINAL is the final value that INDEX should take. It must + be accepted by is_gimple_operand. + + COND is the condition code for the controlling predicate. It must + be one of { <, >, <=, >= } + + INCR is the loop index increment. It must be tree node of type + tcc_constant. + + PRE_BODY is a landing pad filled by the gimplifier with things from + INIT, COND, and INCR that are technically part of the OMP_FOR + structured block, but are evaluated before the loop body begins. + + INITIAL, FINAL and INCR are required to be loop invariant integer + expressions that are evaluated without any synchronization. + The evaluation order, frequency of evaluation and side-effects are + unspecified by the standard. */ +DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR) + +/* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master. + BODY is the sequence of statements to execute in the master section. */ +DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP) + +/* GIMPLE_OMP_ORDERED <BODY> represents #pragma omp ordered. + BODY is the sequence of statements to execute in the ordered section. */ +DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP) + +/* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents + + #pragma omp parallel [CLAUSES] + BODY + + BODY is a the sequence of statements to be executed by all threads. + + CLAUSES is a TREE_LIST node with all the clauses. + + CHILD_FN is set when outlining the body of the parallel region. + All the statements in BODY are moved into this newly created + function when converting OMP constructs into low-GIMPLE. + + DATA_ARG is a local variable in the parent function containing data + to be shared with CHILD_FN. This is used to implement all the data + sharing clauses. */ +DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL) + +/* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN, + ARG_SIZE, ARG_ALIGN> represents + + #pragma omp task [CLAUSES] + BODY + + BODY is a the sequence of statements to be executed by all threads. + + CLAUSES is a TREE_LIST node with all the clauses. + + CHILD_FN is set when outlining the body of the explicit task region. + All the statements in BODY are moved into this newly created + function when converting OMP constructs into low-GIMPLE. + + DATA_ARG is a local variable in the parent function containing data + to be shared with CHILD_FN. This is used to implement all the data + sharing clauses. + + COPY_FN is set when outlining the firstprivate var initialization. + All the needed statements are emitted into the newly created + function, or when only memcpy is needed, it is NULL. + + ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming + data area allocated by GOMP_task and passed to CHILD_FN. */ +DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK) + +/* OMP_RETURN marks the end of an OpenMP directive. */ +DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_BASE) + +/* OMP_SECTION <BODY> represents #pragma omp section. + BODY is the sequence of statements in the section body. */ +DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP) + +/* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections. + + BODY is the sequence of statements in the sections body. + CLAUSES is a TREE_LIST node holding the list of associated clauses. + CONTROL is a VAR_DECL used for deciding which of the sections + to execute. */ +DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS) + +/* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after + OMP_SECTIONS. It represents the GIMPLE_SWITCH used to decide which + branch is taken. */ +DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE) + +/* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single + BODY is the sequence of statements inside the single section. + CLAUSES is a TREE_LIST node holding the associated clauses. */ +DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE) + +/* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction. + + PREDICT is one of the predictors from predict.def. + + OUTCOME is NOT_TAKEN or TAKEN. */ +DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE) + +/* This node represents a cleanup expression. It is ONLY USED INTERNALLY + by the gimplifier as a placeholder for cleanups, and its uses will be + cleaned up by the time gimplification is done. + + This tuple should not exist outside of the gimplifier proper. */ +DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gimple.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gimple.h new file mode 100644 index 0000000..fca3d55 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gimple.h @@ -0,0 +1,4897 @@ +/* Gimple IR definitions. + + Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Contributed by Aldy Hernandez <aldyh@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_GIMPLE_H +#define GCC_GIMPLE_H + +#include "pointer-set.h" +#include "vec.h" +#include "vecprim.h" +#include "vecir.h" +#include "ggc.h" +#include "basic-block.h" +#include "tree-ssa-operands.h" +#include "tree-ssa-alias.h" + +struct gimple_seq_node_d; +typedef struct gimple_seq_node_d *gimple_seq_node; +typedef const struct gimple_seq_node_d *const_gimple_seq_node; + +/* For each block, the PHI nodes that need to be rewritten are stored into + these vectors. */ +typedef VEC(gimple, heap) *gimple_vec; +DEF_VEC_P (gimple_vec); +DEF_VEC_ALLOC_P (gimple_vec, heap); + +enum gimple_code { +#define DEFGSCODE(SYM, STRING, STRUCT) SYM, +#include "gimple.def" +#undef DEFGSCODE + LAST_AND_UNUSED_GIMPLE_CODE +}; + +extern const char *const gimple_code_name[]; +extern const unsigned char gimple_rhs_class_table[]; + +/* Error out if a gimple tuple is addressed incorrectly. */ +#if defined ENABLE_GIMPLE_CHECKING +#define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR) +extern void gimple_check_failed (const_gimple, const char *, int, \ + const char *, enum gimple_code, \ + enum tree_code) ATTRIBUTE_NORETURN; + +#define GIMPLE_CHECK(GS, CODE) \ + do { \ + const_gimple __gs = (GS); \ + if (gimple_code (__gs) != (CODE)) \ + gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \ + (CODE), ERROR_MARK); \ + } while (0) +#else /* not ENABLE_GIMPLE_CHECKING */ +#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR))) +#define GIMPLE_CHECK(GS, CODE) (void)0 +#endif + +/* Class of GIMPLE expressions suitable for the RHS of assignments. See + get_gimple_rhs_class. */ +enum gimple_rhs_class +{ + GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */ + GIMPLE_TERNARY_RHS, /* The expression is a ternary operation. */ + GIMPLE_BINARY_RHS, /* The expression is a binary operation. */ + GIMPLE_UNARY_RHS, /* The expression is a unary operation. */ + GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA + name, a _DECL, a _REF, etc. */ +}; + +/* Specific flags for individual GIMPLE statements. These flags are + always stored in gimple_statement_base.subcode and they may only be + defined for statement codes that do not use sub-codes. + + Values for the masks can overlap as long as the overlapping values + are never used in the same statement class. + + The maximum mask value that can be defined is 1 << 15 (i.e., each + statement code can hold up to 16 bitflags). + + Keep this list sorted. */ +enum gf_mask { + GF_ASM_INPUT = 1 << 0, + GF_ASM_VOLATILE = 1 << 1, + GF_CALL_CANNOT_INLINE = 1 << 0, + GF_CALL_FROM_THUNK = 1 << 1, + GF_CALL_RETURN_SLOT_OPT = 1 << 2, + GF_CALL_TAILCALL = 1 << 3, + GF_CALL_VA_ARG_PACK = 1 << 4, + GF_CALL_NOTHROW = 1 << 5, + GF_OMP_PARALLEL_COMBINED = 1 << 0, + + /* True on an GIMPLE_OMP_RETURN statement if the return does not require + a thread synchronization via some sort of barrier. The exact barrier + that would otherwise be emitted is dependent on the OMP statement with + which this return is associated. */ + GF_OMP_RETURN_NOWAIT = 1 << 0, + + GF_OMP_SECTION_LAST = 1 << 0, + GF_PREDICT_TAKEN = 1 << 15 +}; + +/* Currently, there's only one type of gimple debug stmt. Others are + envisioned, for example, to enable the generation of is_stmt notes + in line number information, to mark sequence points, etc. This + subcode is to be used to tell them apart. */ +enum gimple_debug_subcode { + GIMPLE_DEBUG_BIND = 0 +}; + +/* Masks for selecting a pass local flag (PLF) to work on. These + masks are used by gimple_set_plf and gimple_plf. */ +enum plf_mask { + GF_PLF_1 = 1 << 0, + GF_PLF_2 = 1 << 1 +}; + +/* A node in a gimple_seq_d. */ +struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) gimple_seq_node_d { + gimple stmt; + struct gimple_seq_node_d *prev; + struct gimple_seq_node_d *next; +}; + +/* A double-linked sequence of gimple statements. */ +struct GTY ((chain_next ("%h.next_free"))) gimple_seq_d { + /* First and last statements in the sequence. */ + gimple_seq_node first; + gimple_seq_node last; + + /* Sequences are created/destroyed frequently. To minimize + allocation activity, deallocated sequences are kept in a pool of + available sequences. This is the pointer to the next free + sequence in the pool. */ + gimple_seq next_free; +}; + + +/* Return the first node in GIMPLE sequence S. */ + +static inline gimple_seq_node +gimple_seq_first (const_gimple_seq s) +{ + return s ? s->first : NULL; +} + + +/* Return the first statement in GIMPLE sequence S. */ + +static inline gimple +gimple_seq_first_stmt (const_gimple_seq s) +{ + gimple_seq_node n = gimple_seq_first (s); + return (n) ? n->stmt : NULL; +} + + +/* Return the last node in GIMPLE sequence S. */ + +static inline gimple_seq_node +gimple_seq_last (const_gimple_seq s) +{ + return s ? s->last : NULL; +} + + +/* Return the last statement in GIMPLE sequence S. */ + +static inline gimple +gimple_seq_last_stmt (const_gimple_seq s) +{ + gimple_seq_node n = gimple_seq_last (s); + return (n) ? n->stmt : NULL; +} + + +/* Set the last node in GIMPLE sequence S to LAST. */ + +static inline void +gimple_seq_set_last (gimple_seq s, gimple_seq_node last) +{ + s->last = last; +} + + +/* Set the first node in GIMPLE sequence S to FIRST. */ + +static inline void +gimple_seq_set_first (gimple_seq s, gimple_seq_node first) +{ + s->first = first; +} + + +/* Return true if GIMPLE sequence S is empty. */ + +static inline bool +gimple_seq_empty_p (const_gimple_seq s) +{ + return s == NULL || s->first == NULL; +} + + +void gimple_seq_add_stmt (gimple_seq *, gimple); + +/* Link gimple statement GS to the end of the sequence *SEQ_P. If + *SEQ_P is NULL, a new sequence is allocated. This function is + similar to gimple_seq_add_stmt, but does not scan the operands. + During gimplification, we need to manipulate statement sequences + before the def/use vectors have been constructed. */ +void gimplify_seq_add_stmt (gimple_seq *, gimple); + +/* Allocate a new sequence and initialize its first element with STMT. */ + +static inline gimple_seq +gimple_seq_alloc_with_stmt (gimple stmt) +{ + gimple_seq seq = NULL; + gimple_seq_add_stmt (&seq, stmt); + return seq; +} + + +/* Returns the sequence of statements in BB. */ + +static inline gimple_seq +bb_seq (const_basic_block bb) +{ + return (!(bb->flags & BB_RTL) && bb->il.gimple) ? bb->il.gimple->seq : NULL; +} + + +/* Sets the sequence of statements in BB to SEQ. */ + +static inline void +set_bb_seq (basic_block bb, gimple_seq seq) +{ + gcc_checking_assert (!(bb->flags & BB_RTL)); + bb->il.gimple->seq = seq; +} + +/* Iterator object for GIMPLE statement sequences. */ + +typedef struct +{ + /* Sequence node holding the current statement. */ + gimple_seq_node ptr; + + /* Sequence and basic block holding the statement. These fields + are necessary to handle edge cases such as when statement is + added to an empty basic block or when the last statement of a + block/sequence is removed. */ + gimple_seq seq; + basic_block bb; +} gimple_stmt_iterator; + + +/* Data structure definitions for GIMPLE tuples. NOTE: word markers + are for 64 bit hosts. */ + +struct GTY(()) gimple_statement_base { + /* [ WORD 1 ] + Main identifying code for a tuple. */ + ENUM_BITFIELD(gimple_code) code : 8; + + /* Nonzero if a warning should not be emitted on this tuple. */ + unsigned int no_warning : 1; + + /* Nonzero if this tuple has been visited. Passes are responsible + for clearing this bit before using it. */ + unsigned int visited : 1; + + /* Nonzero if this tuple represents a non-temporal move. */ + unsigned int nontemporal_move : 1; + + /* Pass local flags. These flags are free for any pass to use as + they see fit. Passes should not assume that these flags contain + any useful value when the pass starts. Any initial state that + the pass requires should be set on entry to the pass. See + gimple_set_plf and gimple_plf for usage. */ + unsigned int plf : 2; + + /* Nonzero if this statement has been modified and needs to have its + operands rescanned. */ + unsigned modified : 1; + + /* Nonzero if this statement contains volatile operands. */ + unsigned has_volatile_ops : 1; + + /* Padding to get subcode to 16 bit alignment. */ + unsigned pad : 1; + + /* The SUBCODE field can be used for tuple-specific flags for tuples + that do not require subcodes. Note that SUBCODE should be at + least as wide as tree codes, as several tuples store tree codes + in there. */ + unsigned int subcode : 16; + + /* UID of this statement. This is used by passes that want to + assign IDs to statements. It must be assigned and used by each + pass. By default it should be assumed to contain garbage. */ + unsigned uid; + + /* [ WORD 2 ] + Locus information for debug info. */ + location_t location; + + /* Number of operands in this tuple. */ + unsigned num_ops; + + /* [ WORD 3 ] + Basic block holding this statement. */ + struct basic_block_def *bb; + + /* [ WORD 4 ] + Lexical block holding this statement. */ + tree block; +}; + + +/* Base structure for tuples with operands. */ + +struct GTY(()) gimple_statement_with_ops_base +{ + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5-6 ] + SSA operand vectors. NOTE: It should be possible to + amalgamate these vectors with the operand vector OP. However, + the SSA operand vectors are organized differently and contain + more information (like immediate use chaining). */ + struct def_optype_d GTY((skip (""))) *def_ops; + struct use_optype_d GTY((skip (""))) *use_ops; +}; + + +/* Statements that take register operands. */ + +struct GTY(()) gimple_statement_with_ops +{ + /* [ WORD 1-6 ] */ + struct gimple_statement_with_ops_base opbase; + + /* [ WORD 7 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* Base for statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_with_memory_ops_base +{ + /* [ WORD 1-6 ] */ + struct gimple_statement_with_ops_base opbase; + + /* [ WORD 7-8 ] + Virtual operands for this statement. The GC will pick them + up via the ssa_names array. */ + tree GTY((skip (""))) vdef; + tree GTY((skip (""))) vuse; +}; + + +/* Statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_with_memory_ops +{ + /* [ WORD 1-8 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 9 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* Call statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_call +{ + /* [ WORD 1-8 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 9-12 ] */ + struct pt_solution call_used; + struct pt_solution call_clobbered; + + /* [ WORD 13 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* OpenMP statements (#pragma omp). */ + +struct GTY(()) gimple_statement_omp { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] */ + gimple_seq body; +}; + + +/* GIMPLE_BIND */ + +struct GTY(()) gimple_statement_bind { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] + Variables declared in this scope. */ + tree vars; + + /* [ WORD 6 ] + This is different than the BLOCK field in gimple_statement_base, + which is analogous to TREE_BLOCK (i.e., the lexical block holding + this statement). This field is the equivalent of BIND_EXPR_BLOCK + in tree land (i.e., the lexical scope defined by this bind). See + gimple-low.c. */ + tree block; + + /* [ WORD 7 ] */ + gimple_seq body; +}; + + +/* GIMPLE_CATCH */ + +struct GTY(()) gimple_statement_catch { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] */ + tree types; + + /* [ WORD 6 ] */ + gimple_seq handler; +}; + + +/* GIMPLE_EH_FILTER */ + +struct GTY(()) gimple_statement_eh_filter { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] + Filter types. */ + tree types; + + /* [ WORD 6 ] + Failure actions. */ + gimple_seq failure; +}; + + +/* GIMPLE_EH_MUST_NOT_THROW */ + +struct GTY(()) gimple_statement_eh_mnt { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] Abort function decl. */ + tree fndecl; +}; + +/* GIMPLE_PHI */ + +struct GTY(()) gimple_statement_phi { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] */ + unsigned capacity; + unsigned nargs; + + /* [ WORD 6 ] */ + tree result; + + /* [ WORD 7 ] */ + struct phi_arg_d GTY ((length ("%h.nargs"))) args[1]; +}; + + +/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */ + +struct GTY(()) gimple_statement_eh_ctrl +{ + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] + Exception region number. */ + int region; +}; + + +/* GIMPLE_TRY */ + +struct GTY(()) gimple_statement_try { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] + Expression to evaluate. */ + gimple_seq eval; + + /* [ WORD 6 ] + Cleanup expression. */ + gimple_seq cleanup; +}; + +/* Kind of GIMPLE_TRY statements. */ +enum gimple_try_flags +{ + /* A try/catch. */ + GIMPLE_TRY_CATCH = 1 << 0, + + /* A try/finally. */ + GIMPLE_TRY_FINALLY = 1 << 1, + GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY, + + /* Analogous to TRY_CATCH_IS_CLEANUP. */ + GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2 +}; + +/* GIMPLE_WITH_CLEANUP_EXPR */ + +struct GTY(()) gimple_statement_wce { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be + executed if an exception is thrown, not on normal exit of its + scope. This flag is analogous to the CLEANUP_EH_ONLY flag + in TARGET_EXPRs. */ + + /* [ WORD 5 ] + Cleanup expression. */ + gimple_seq cleanup; +}; + + +/* GIMPLE_ASM */ + +struct GTY(()) gimple_statement_asm +{ + /* [ WORD 1-8 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 9 ] + __asm__ statement. */ + const char *string; + + /* [ WORD 10 ] + Number of inputs, outputs, clobbers, labels. */ + unsigned char ni; + unsigned char no; + unsigned char nc; + unsigned char nl; + + /* [ WORD 11 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + +/* GIMPLE_OMP_CRITICAL */ + +struct GTY(()) gimple_statement_omp_critical { + /* [ WORD 1-5 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 6 ] + Critical section name. */ + tree name; +}; + + +struct GTY(()) gimple_omp_for_iter { + /* Condition code. */ + enum tree_code cond; + + /* Index variable. */ + tree index; + + /* Initial value. */ + tree initial; + + /* Final value. */ + tree final; + + /* Increment. */ + tree incr; +}; + +/* GIMPLE_OMP_FOR */ + +struct GTY(()) gimple_statement_omp_for { + /* [ WORD 1-5 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 6 ] */ + tree clauses; + + /* [ WORD 7 ] + Number of elements in iter array. */ + size_t collapse; + + /* [ WORD 8 ] */ + struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter; + + /* [ WORD 9 ] + Pre-body evaluated before the loop body begins. */ + gimple_seq pre_body; +}; + + +/* GIMPLE_OMP_PARALLEL */ + +struct GTY(()) gimple_statement_omp_parallel { + /* [ WORD 1-5 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 6 ] + Clauses. */ + tree clauses; + + /* [ WORD 7 ] + Child function holding the body of the parallel region. */ + tree child_fn; + + /* [ WORD 8 ] + Shared data argument. */ + tree data_arg; +}; + + +/* GIMPLE_OMP_TASK */ + +struct GTY(()) gimple_statement_omp_task { + /* [ WORD 1-8 ] */ + struct gimple_statement_omp_parallel par; + + /* [ WORD 9 ] + Child function holding firstprivate initialization if needed. */ + tree copy_fn; + + /* [ WORD 10-11 ] + Size and alignment in bytes of the argument data block. */ + tree arg_size; + tree arg_align; +}; + + +/* GIMPLE_OMP_SECTION */ +/* Uses struct gimple_statement_omp. */ + + +/* GIMPLE_OMP_SECTIONS */ + +struct GTY(()) gimple_statement_omp_sections { + /* [ WORD 1-5 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 6 ] */ + tree clauses; + + /* [ WORD 7 ] + The control variable used for deciding which of the sections to + execute. */ + tree control; +}; + +/* GIMPLE_OMP_CONTINUE. + + Note: This does not inherit from gimple_statement_omp, because we + do not need the body field. */ + +struct GTY(()) gimple_statement_omp_continue { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] */ + tree control_def; + + /* [ WORD 6 ] */ + tree control_use; +}; + +/* GIMPLE_OMP_SINGLE */ + +struct GTY(()) gimple_statement_omp_single { + /* [ WORD 1-5 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 6 ] */ + tree clauses; +}; + + +/* GIMPLE_OMP_ATOMIC_LOAD. + Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp + contains a sequence, which we don't need here. */ + +struct GTY(()) gimple_statement_omp_atomic_load { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5-6 ] */ + tree rhs, lhs; +}; + +/* GIMPLE_OMP_ATOMIC_STORE. + See note on GIMPLE_OMP_ATOMIC_LOAD. */ + +struct GTY(()) gimple_statement_omp_atomic_store { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5 ] */ + tree val; +}; + +#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM, +enum gimple_statement_structure_enum { +#include "gsstruct.def" + LAST_GSS_ENUM +}; +#undef DEFGSSTRUCT + + +/* Define the overall contents of a gimple tuple. It may be any of the + structures declared above for various types of tuples. */ + +union GTY ((desc ("gimple_statement_structure (&%h)"), variable_size)) gimple_statement_d { + struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase; + struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops; + struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase; + struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem; + struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call; + struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp; + struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind; + struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch; + struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter; + struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt; + struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi; + struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl; + struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try; + struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce; + struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm; + struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical; + struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for; + struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel; + struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task; + struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections; + struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single; + struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue; + struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load; + struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store; +}; + +/* In gimple.c. */ + +/* Offset in bytes to the location of the operand vector. + Zero if there is no operand vector for this tuple structure. */ +extern size_t const gimple_ops_offset_[]; + +/* Map GIMPLE codes to GSS codes. */ +extern enum gimple_statement_structure_enum const gss_for_code_[]; + +/* This variable holds the currently expanded gimple statement for purposes + of comminucating the profile info to the builtin expanders. */ +extern gimple currently_expanding_gimple_stmt; + +gimple gimple_build_return (tree); + +gimple gimple_build_assign_stat (tree, tree MEM_STAT_DECL); +#define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO) + +void extract_ops_from_tree_1 (tree, enum tree_code *, tree *, tree *, tree *); + +gimple gimple_build_assign_with_ops_stat (enum tree_code, tree, tree, + tree, tree MEM_STAT_DECL); +#define gimple_build_assign_with_ops(c,o1,o2,o3) \ + gimple_build_assign_with_ops_stat (c, o1, o2, o3, NULL_TREE MEM_STAT_INFO) +#define gimple_build_assign_with_ops3(c,o1,o2,o3,o4) \ + gimple_build_assign_with_ops_stat (c, o1, o2, o3, o4 MEM_STAT_INFO) + +gimple gimple_build_debug_bind_stat (tree, tree, gimple MEM_STAT_DECL); +#define gimple_build_debug_bind(var,val,stmt) \ + gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) + +gimple gimple_build_call_vec (tree, VEC(tree, heap) *); +gimple gimple_build_call (tree, unsigned, ...); +gimple gimple_build_call_from_tree (tree); +gimple gimplify_assign (tree, tree, gimple_seq *); +gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree); +gimple gimple_build_label (tree label); +gimple gimple_build_goto (tree dest); +gimple gimple_build_nop (void); +gimple gimple_build_bind (tree, gimple_seq, tree); +gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, + VEC(tree,gc) *, VEC(tree,gc) *); +gimple gimple_build_catch (tree, gimple_seq); +gimple gimple_build_eh_filter (tree, gimple_seq); +gimple gimple_build_eh_must_not_throw (tree); +gimple gimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags); +gimple gimple_build_wce (gimple_seq); +gimple gimple_build_resx (int); +gimple gimple_build_eh_dispatch (int); +gimple gimple_build_switch_nlabels (unsigned, tree, tree); +gimple gimple_build_switch (unsigned, tree, tree, ...); +gimple gimple_build_switch_vec (tree, tree, VEC(tree,heap) *); +gimple gimple_build_omp_parallel (gimple_seq, tree, tree, tree); +gimple gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree); +gimple gimple_build_omp_for (gimple_seq, tree, size_t, gimple_seq); +gimple gimple_build_omp_critical (gimple_seq, tree); +gimple gimple_build_omp_section (gimple_seq); +gimple gimple_build_omp_continue (tree, tree); +gimple gimple_build_omp_master (gimple_seq); +gimple gimple_build_omp_return (bool); +gimple gimple_build_omp_ordered (gimple_seq); +gimple gimple_build_omp_sections (gimple_seq, tree); +gimple gimple_build_omp_sections_switch (void); +gimple gimple_build_omp_single (gimple_seq, tree); +gimple gimple_build_cdt (tree, tree); +gimple gimple_build_omp_atomic_load (tree, tree); +gimple gimple_build_omp_atomic_store (tree); +gimple gimple_build_predict (enum br_predictor, enum prediction); +enum gimple_statement_structure_enum gss_for_assign (enum tree_code); +void sort_case_labels (VEC(tree,heap) *); +void gimple_set_body (tree, gimple_seq); +gimple_seq gimple_body (tree); +bool gimple_has_body_p (tree); +gimple_seq gimple_seq_alloc (void); +void gimple_seq_free (gimple_seq); +void gimple_seq_add_seq (gimple_seq *, gimple_seq); +gimple_seq gimple_seq_copy (gimple_seq); +int gimple_call_flags (const_gimple); +int gimple_call_return_flags (const_gimple); +int gimple_call_arg_flags (const_gimple, unsigned); +void gimple_call_reset_alias_info (gimple); +bool gimple_assign_copy_p (gimple); +bool gimple_assign_ssa_name_copy_p (gimple); +bool gimple_assign_unary_nop_p (gimple); +void gimple_set_bb (gimple, struct basic_block_def *); +void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree); +void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *, enum tree_code, + tree, tree, tree); +tree gimple_get_lhs (const_gimple); +void gimple_set_lhs (gimple, tree); +void gimple_replace_lhs (gimple, tree); +gimple gimple_copy (gimple); +void gimple_set_modified (gimple, bool); +void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *); +gimple gimple_build_cond_from_tree (tree, tree, tree); +void gimple_cond_set_condition_from_tree (gimple, tree); +bool gimple_has_side_effects (const_gimple); +bool gimple_rhs_has_side_effects (const_gimple); +bool gimple_could_trap_p (gimple); +bool gimple_could_trap_p_1 (gimple, bool, bool); +bool gimple_assign_rhs_could_trap_p (gimple); +void gimple_regimplify_operands (gimple, gimple_stmt_iterator *); +bool empty_body_p (gimple_seq); +unsigned get_gimple_rhs_num_ops (enum tree_code); +#define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO) +gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL); +const char *gimple_decl_printable_name (tree, int); +bool gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace); +tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree, tree *, bool); +void gimple_adjust_this_by_delta (gimple_stmt_iterator *, tree); +/* Returns true iff T is a valid GIMPLE statement. */ +extern bool is_gimple_stmt (tree); + +/* Returns true iff TYPE is a valid type for a scalar register variable. */ +extern bool is_gimple_reg_type (tree); +/* Returns true iff T is a scalar register variable. */ +extern bool is_gimple_reg (tree); +/* Returns true iff T is any sort of variable. */ +extern bool is_gimple_variable (tree); +/* Returns true iff T is any sort of symbol. */ +extern bool is_gimple_id (tree); +/* Returns true iff T is a variable or an INDIRECT_REF (of a variable). */ +extern bool is_gimple_min_lval (tree); +/* Returns true iff T is something whose address can be taken. */ +extern bool is_gimple_addressable (tree); +/* Returns true iff T is any valid GIMPLE lvalue. */ +extern bool is_gimple_lvalue (tree); + +/* Returns true iff T is a GIMPLE address. */ +bool is_gimple_address (const_tree); +/* Returns true iff T is a GIMPLE invariant address. */ +bool is_gimple_invariant_address (const_tree); +/* Returns true iff T is a GIMPLE invariant address at interprocedural + level. */ +bool is_gimple_ip_invariant_address (const_tree); +/* Returns true iff T is a valid GIMPLE constant. */ +bool is_gimple_constant (const_tree); +/* Returns true iff T is a GIMPLE restricted function invariant. */ +extern bool is_gimple_min_invariant (const_tree); +/* Returns true iff T is a GIMPLE restricted interprecodural invariant. */ +extern bool is_gimple_ip_invariant (const_tree); +/* Returns true iff T is a GIMPLE rvalue. */ +extern bool is_gimple_val (tree); +/* Returns true iff T is a GIMPLE asm statement input. */ +extern bool is_gimple_asm_val (tree); +/* Returns true iff T is a valid address operand of a MEM_REF. */ +bool is_gimple_mem_ref_addr (tree); +/* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a + GIMPLE temporary, a renamed user variable, or something else, + respectively. */ +extern bool is_gimple_reg_rhs (tree); +extern bool is_gimple_mem_rhs (tree); + +/* Returns true iff T is a valid if-statement condition. */ +extern bool is_gimple_condexpr (tree); + +/* Returns true iff T is a variable that does not need to live in memory. */ +extern bool is_gimple_non_addressable (tree t); + +/* Returns true iff T is a valid call address expression. */ +extern bool is_gimple_call_addr (tree); +/* If T makes a function call, returns the CALL_EXPR operand. */ +extern tree get_call_expr_in (tree t); + +extern void recalculate_side_effects (tree); +extern bool gimple_compare_field_offset (tree, tree); +extern tree gimple_register_type (tree); +extern tree gimple_register_canonical_type (tree); +enum gtc_mode { GTC_MERGE = 0, GTC_DIAG = 1 }; +extern bool gimple_types_compatible_p (tree, tree, enum gtc_mode); +extern void print_gimple_types_stats (void); +extern void free_gimple_type_tables (void); +extern tree gimple_unsigned_type (tree); +extern tree gimple_signed_type (tree); +extern alias_set_type gimple_get_alias_set (tree); +extern void count_uses_and_derefs (tree, gimple, unsigned *, unsigned *, + unsigned *); +extern bool walk_stmt_load_store_addr_ops (gimple, void *, + bool (*)(gimple, tree, void *), + bool (*)(gimple, tree, void *), + bool (*)(gimple, tree, void *)); +extern bool walk_stmt_load_store_ops (gimple, void *, + bool (*)(gimple, tree, void *), + bool (*)(gimple, tree, void *)); +extern bool gimple_ior_addresses_taken (bitmap, gimple); +extern bool gimple_call_builtin_p (gimple, enum built_in_function); + +/* In gimplify.c */ +extern tree create_tmp_var_raw (tree, const char *); +extern tree create_tmp_var_name (const char *); +extern tree create_tmp_var (tree, const char *); +extern tree create_tmp_reg (tree, const char *); +extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *); +extern tree get_formal_tmp_var (tree, gimple_seq *); +extern void declare_vars (tree, gimple, bool); +extern void annotate_all_with_location (gimple_seq, location_t); + +/* Validation of GIMPLE expressions. Note that these predicates only check + the basic form of the expression, they don't recurse to make sure that + underlying nodes are also of the right form. */ +typedef bool (*gimple_predicate)(tree); + + +/* FIXME we should deduce this from the predicate. */ +enum fallback { + fb_none = 0, /* Do not generate a temporary. */ + + fb_rvalue = 1, /* Generate an rvalue to hold the result of a + gimplified expression. */ + + fb_lvalue = 2, /* Generate an lvalue to hold the result of a + gimplified expression. */ + + fb_mayfail = 4, /* Gimplification may fail. Error issued + afterwards. */ + fb_either= fb_rvalue | fb_lvalue +}; + +typedef int fallback_t; + +enum gimplify_status { + GS_ERROR = -2, /* Something Bad Seen. */ + GS_UNHANDLED = -1, /* A langhook result for "I dunno". */ + GS_OK = 0, /* We did something, maybe more to do. */ + GS_ALL_DONE = 1 /* The expression is fully gimplified. */ +}; + +struct gimplify_ctx +{ + struct gimplify_ctx *prev_context; + + VEC(gimple,heap) *bind_expr_stack; + tree temps; + gimple_seq conditional_cleanups; + tree exit_label; + tree return_temp; + + VEC(tree,heap) *case_labels; + /* The formal temporary table. Should this be persistent? */ + htab_t temp_htab; + + int conditions; + bool save_stack; + bool into_ssa; + bool allow_rhs_cond_expr; +}; + +extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *, + bool (*) (tree), fallback_t); +extern void gimplify_type_sizes (tree, gimple_seq *); +extern void gimplify_one_sizepos (tree *, gimple_seq *); +extern bool gimplify_stmt (tree *, gimple_seq *); +extern gimple gimplify_body (tree *, tree, bool); +extern void push_gimplify_context (struct gimplify_ctx *); +extern void pop_gimplify_context (gimple); +extern void gimplify_and_add (tree, gimple_seq *); + +/* Miscellaneous helpers. */ +extern void gimple_add_tmp_var (tree); +extern gimple gimple_current_bind_expr (void); +extern VEC(gimple, heap) *gimple_bind_expr_stack (void); +extern tree voidify_wrapper_expr (tree, tree); +extern tree build_and_jump (tree *); +extern tree force_labels_r (tree *, int *, void *); +extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *, + gimple_seq *); +struct gimplify_omp_ctx; +extern void omp_firstprivatize_variable (struct gimplify_omp_ctx *, tree); +extern tree gimple_boolify (tree); +extern gimple_predicate rhs_predicate_for (tree); +extern tree canonicalize_cond_expr_cond (tree); + +/* In omp-low.c. */ +extern tree omp_reduction_init (tree, tree); + +/* In tree-nested.c. */ +extern void lower_nested_functions (tree); +extern void insert_field_into_struct (tree, tree); + +/* In gimplify.c. */ +extern void gimplify_function_tree (tree); + +/* In cfgexpand.c. */ +extern tree gimple_assign_rhs_to_tree (gimple); + +/* In builtins.c */ +extern bool validate_gimple_arglist (const_gimple, ...); + +/* In tree-ssa.c */ +extern bool tree_ssa_useless_type_conversion (tree); +extern tree tree_ssa_strip_useless_type_conversions (tree); +extern bool useless_type_conversion_p (tree, tree); +extern bool types_compatible_p (tree, tree); + +/* Return the code for GIMPLE statement G. */ + +static inline enum gimple_code +gimple_code (const_gimple g) +{ + return g->gsbase.code; +} + + +/* Return the GSS code used by a GIMPLE code. */ + +static inline enum gimple_statement_structure_enum +gss_for_code (enum gimple_code code) +{ + gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE); + return gss_for_code_[code]; +} + + +/* Return which GSS code is used by GS. */ + +static inline enum gimple_statement_structure_enum +gimple_statement_structure (gimple gs) +{ + return gss_for_code (gimple_code (gs)); +} + + +/* Return true if statement G has sub-statements. This is only true for + High GIMPLE statements. */ + +static inline bool +gimple_has_substatements (gimple g) +{ + switch (gimple_code (g)) + { + case GIMPLE_BIND: + case GIMPLE_CATCH: + case GIMPLE_EH_FILTER: + case GIMPLE_TRY: + case GIMPLE_OMP_FOR: + case GIMPLE_OMP_MASTER: + case GIMPLE_OMP_ORDERED: + case GIMPLE_OMP_SECTION: + case GIMPLE_OMP_PARALLEL: + case GIMPLE_OMP_TASK: + case GIMPLE_OMP_SECTIONS: + case GIMPLE_OMP_SINGLE: + case GIMPLE_OMP_CRITICAL: + case GIMPLE_WITH_CLEANUP_EXPR: + return true; + + default: + return false; + } +} + + +/* Return the basic block holding statement G. */ + +static inline struct basic_block_def * +gimple_bb (const_gimple g) +{ + return g->gsbase.bb; +} + + +/* Return the lexical scope block holding statement G. */ + +static inline tree +gimple_block (const_gimple g) +{ + return g->gsbase.block; +} + + +/* Set BLOCK to be the lexical scope block holding statement G. */ + +static inline void +gimple_set_block (gimple g, tree block) +{ + g->gsbase.block = block; +} + + +/* Return location information for statement G. */ + +static inline location_t +gimple_location (const_gimple g) +{ + return g->gsbase.location; +} + +/* Return pointer to location information for statement G. */ + +static inline const location_t * +gimple_location_ptr (const_gimple g) +{ + return &g->gsbase.location; +} + + +/* Set location information for statement G. */ + +static inline void +gimple_set_location (gimple g, location_t location) +{ + g->gsbase.location = location; +} + + +/* Return true if G contains location information. */ + +static inline bool +gimple_has_location (const_gimple g) +{ + return gimple_location (g) != UNKNOWN_LOCATION; +} + + +/* Return the file name of the location of STMT. */ + +static inline const char * +gimple_filename (const_gimple stmt) +{ + return LOCATION_FILE (gimple_location (stmt)); +} + + +/* Return the line number of the location of STMT. */ + +static inline int +gimple_lineno (const_gimple stmt) +{ + return LOCATION_LINE (gimple_location (stmt)); +} + + +/* Determine whether SEQ is a singleton. */ + +static inline bool +gimple_seq_singleton_p (gimple_seq seq) +{ + return ((gimple_seq_first (seq) != NULL) + && (gimple_seq_first (seq) == gimple_seq_last (seq))); +} + +/* Return true if no warnings should be emitted for statement STMT. */ + +static inline bool +gimple_no_warning_p (const_gimple stmt) +{ + return stmt->gsbase.no_warning; +} + +/* Set the no_warning flag of STMT to NO_WARNING. */ + +static inline void +gimple_set_no_warning (gimple stmt, bool no_warning) +{ + stmt->gsbase.no_warning = (unsigned) no_warning; +} + +/* Set the visited status on statement STMT to VISITED_P. */ + +static inline void +gimple_set_visited (gimple stmt, bool visited_p) +{ + stmt->gsbase.visited = (unsigned) visited_p; +} + + +/* Return the visited status for statement STMT. */ + +static inline bool +gimple_visited_p (gimple stmt) +{ + return stmt->gsbase.visited; +} + + +/* Set pass local flag PLF on statement STMT to VAL_P. */ + +static inline void +gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p) +{ + if (val_p) + stmt->gsbase.plf |= (unsigned int) plf; + else + stmt->gsbase.plf &= ~((unsigned int) plf); +} + + +/* Return the value of pass local flag PLF on statement STMT. */ + +static inline unsigned int +gimple_plf (gimple stmt, enum plf_mask plf) +{ + return stmt->gsbase.plf & ((unsigned int) plf); +} + + +/* Set the UID of statement. */ + +static inline void +gimple_set_uid (gimple g, unsigned uid) +{ + g->gsbase.uid = uid; +} + + +/* Return the UID of statement. */ + +static inline unsigned +gimple_uid (const_gimple g) +{ + return g->gsbase.uid; +} + + +/* Return true if GIMPLE statement G has register or memory operands. */ + +static inline bool +gimple_has_ops (const_gimple g) +{ + return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN; +} + + +/* Return true if GIMPLE statement G has memory operands. */ + +static inline bool +gimple_has_mem_ops (const_gimple g) +{ + return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN; +} + + +/* Return the set of DEF operands for statement G. */ + +static inline struct def_optype_d * +gimple_def_ops (const_gimple g) +{ + if (!gimple_has_ops (g)) + return NULL; + return g->gsops.opbase.def_ops; +} + + +/* Set DEF to be the set of DEF operands for statement G. */ + +static inline void +gimple_set_def_ops (gimple g, struct def_optype_d *def) +{ + gcc_gimple_checking_assert (gimple_has_ops (g)); + g->gsops.opbase.def_ops = def; +} + + +/* Return the set of USE operands for statement G. */ + +static inline struct use_optype_d * +gimple_use_ops (const_gimple g) +{ + if (!gimple_has_ops (g)) + return NULL; + return g->gsops.opbase.use_ops; +} + + +/* Set USE to be the set of USE operands for statement G. */ + +static inline void +gimple_set_use_ops (gimple g, struct use_optype_d *use) +{ + gcc_gimple_checking_assert (gimple_has_ops (g)); + g->gsops.opbase.use_ops = use; +} + + +/* Return the set of VUSE operand for statement G. */ + +static inline use_operand_p +gimple_vuse_op (const_gimple g) +{ + struct use_optype_d *ops; + if (!gimple_has_mem_ops (g)) + return NULL_USE_OPERAND_P; + ops = g->gsops.opbase.use_ops; + if (ops + && USE_OP_PTR (ops)->use == &g->gsmembase.vuse) + return USE_OP_PTR (ops); + return NULL_USE_OPERAND_P; +} + +/* Return the set of VDEF operand for statement G. */ + +static inline def_operand_p +gimple_vdef_op (const_gimple g) +{ + struct def_optype_d *ops; + if (!gimple_has_mem_ops (g)) + return NULL_DEF_OPERAND_P; + ops = g->gsops.opbase.def_ops; + if (ops + && DEF_OP_PTR (ops) == &g->gsmembase.vdef) + return DEF_OP_PTR (ops); + return NULL_DEF_OPERAND_P; +} + + +/* Return the single VUSE operand of the statement G. */ + +static inline tree +gimple_vuse (const_gimple g) +{ + if (!gimple_has_mem_ops (g)) + return NULL_TREE; + return g->gsmembase.vuse; +} + +/* Return the single VDEF operand of the statement G. */ + +static inline tree +gimple_vdef (const_gimple g) +{ + if (!gimple_has_mem_ops (g)) + return NULL_TREE; + return g->gsmembase.vdef; +} + +/* Return the single VUSE operand of the statement G. */ + +static inline tree * +gimple_vuse_ptr (gimple g) +{ + if (!gimple_has_mem_ops (g)) + return NULL; + return &g->gsmembase.vuse; +} + +/* Return the single VDEF operand of the statement G. */ + +static inline tree * +gimple_vdef_ptr (gimple g) +{ + if (!gimple_has_mem_ops (g)) + return NULL; + return &g->gsmembase.vdef; +} + +/* Set the single VUSE operand of the statement G. */ + +static inline void +gimple_set_vuse (gimple g, tree vuse) +{ + gcc_gimple_checking_assert (gimple_has_mem_ops (g)); + g->gsmembase.vuse = vuse; +} + +/* Set the single VDEF operand of the statement G. */ + +static inline void +gimple_set_vdef (gimple g, tree vdef) +{ + gcc_gimple_checking_assert (gimple_has_mem_ops (g)); + g->gsmembase.vdef = vdef; +} + + +/* Return true if statement G has operands and the modified field has + been set. */ + +static inline bool +gimple_modified_p (const_gimple g) +{ + return (gimple_has_ops (g)) ? (bool) g->gsbase.modified : false; +} + + +/* Return the tree code for the expression computed by STMT. This is + only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For + GIMPLE_CALL, return CALL_EXPR as the expression code for + consistency. This is useful when the caller needs to deal with the + three kinds of computation that GIMPLE supports. */ + +static inline enum tree_code +gimple_expr_code (const_gimple stmt) +{ + enum gimple_code code = gimple_code (stmt); + if (code == GIMPLE_ASSIGN || code == GIMPLE_COND) + return (enum tree_code) stmt->gsbase.subcode; + else + { + gcc_gimple_checking_assert (code == GIMPLE_CALL); + return CALL_EXPR; + } +} + + +/* Mark statement S as modified, and update it. */ + +static inline void +update_stmt (gimple s) +{ + if (gimple_has_ops (s)) + { + gimple_set_modified (s, true); + update_stmt_operands (s); + } +} + +/* Update statement S if it has been optimized. */ + +static inline void +update_stmt_if_modified (gimple s) +{ + if (gimple_modified_p (s)) + update_stmt_operands (s); +} + +/* Return true if statement STMT contains volatile operands. */ + +static inline bool +gimple_has_volatile_ops (const_gimple stmt) +{ + if (gimple_has_mem_ops (stmt)) + return stmt->gsbase.has_volatile_ops; + else + return false; +} + + +/* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */ + +static inline void +gimple_set_has_volatile_ops (gimple stmt, bool volatilep) +{ + if (gimple_has_mem_ops (stmt)) + stmt->gsbase.has_volatile_ops = (unsigned) volatilep; +} + + +/* Return true if statement STMT may access memory. */ + +static inline bool +gimple_references_memory_p (gimple stmt) +{ + return gimple_has_mem_ops (stmt) && gimple_vuse (stmt); +} + + +/* Return the subcode for OMP statement S. */ + +static inline unsigned +gimple_omp_subcode (const_gimple s) +{ + gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD + && gimple_code (s) <= GIMPLE_OMP_SINGLE); + return s->gsbase.subcode; +} + +/* Set the subcode for OMP statement S to SUBCODE. */ + +static inline void +gimple_omp_set_subcode (gimple s, unsigned int subcode) +{ + /* We only have 16 bits for the subcode. Assert that we are not + overflowing it. */ + gcc_gimple_checking_assert (subcode < (1 << 16)); + s->gsbase.subcode = subcode; +} + +/* Set the nowait flag on OMP_RETURN statement S. */ + +static inline void +gimple_omp_return_set_nowait (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_OMP_RETURN); + s->gsbase.subcode |= GF_OMP_RETURN_NOWAIT; +} + + +/* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT + flag set. */ + +static inline bool +gimple_omp_return_nowait_p (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_RETURN); + return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0; +} + + +/* Return true if OMP section statement G has the GF_OMP_SECTION_LAST + flag set. */ + +static inline bool +gimple_omp_section_last_p (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_SECTION); + return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0; +} + + +/* Set the GF_OMP_SECTION_LAST flag on G. */ + +static inline void +gimple_omp_section_set_last (gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_SECTION); + g->gsbase.subcode |= GF_OMP_SECTION_LAST; +} + + +/* Return true if OMP parallel statement G has the + GF_OMP_PARALLEL_COMBINED flag set. */ + +static inline bool +gimple_omp_parallel_combined_p (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL); + return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0; +} + + +/* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean + value of COMBINED_P. */ + +static inline void +gimple_omp_parallel_set_combined_p (gimple g, bool combined_p) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL); + if (combined_p) + g->gsbase.subcode |= GF_OMP_PARALLEL_COMBINED; + else + g->gsbase.subcode &= ~GF_OMP_PARALLEL_COMBINED; +} + + +/* Return the number of operands for statement GS. */ + +static inline unsigned +gimple_num_ops (const_gimple gs) +{ + return gs->gsbase.num_ops; +} + + +/* Set the number of operands for statement GS. */ + +static inline void +gimple_set_num_ops (gimple gs, unsigned num_ops) +{ + gs->gsbase.num_ops = num_ops; +} + + +/* Return the array of operands for statement GS. */ + +static inline tree * +gimple_ops (gimple gs) +{ + size_t off; + + /* All the tuples have their operand vector at the very bottom + of the structure. Note that those structures that do not + have an operand vector have a zero offset. */ + off = gimple_ops_offset_[gimple_statement_structure (gs)]; + gcc_gimple_checking_assert (off != 0); + + return (tree *) ((char *) gs + off); +} + + +/* Return operand I for statement GS. */ + +static inline tree +gimple_op (const_gimple gs, unsigned i) +{ + if (gimple_has_ops (gs)) + { + gcc_gimple_checking_assert (i < gimple_num_ops (gs)); + return gimple_ops (CONST_CAST_GIMPLE (gs))[i]; + } + else + return NULL_TREE; +} + +/* Return a pointer to operand I for statement GS. */ + +static inline tree * +gimple_op_ptr (const_gimple gs, unsigned i) +{ + if (gimple_has_ops (gs)) + { + gcc_gimple_checking_assert (i < gimple_num_ops (gs)); + return gimple_ops (CONST_CAST_GIMPLE (gs)) + i; + } + else + return NULL; +} + +/* Set operand I of statement GS to OP. */ + +static inline void +gimple_set_op (gimple gs, unsigned i, tree op) +{ + gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs)); + + /* Note. It may be tempting to assert that OP matches + is_gimple_operand, but that would be wrong. Different tuples + accept slightly different sets of tree operands. Each caller + should perform its own validation. */ + gimple_ops (gs)[i] = op; +} + +/* Return true if GS is a GIMPLE_ASSIGN. */ + +static inline bool +is_gimple_assign (const_gimple gs) +{ + return gimple_code (gs) == GIMPLE_ASSIGN; +} + +/* Determine if expression CODE is one of the valid expressions that can + be used on the RHS of GIMPLE assignments. */ + +static inline enum gimple_rhs_class +get_gimple_rhs_class (enum tree_code code) +{ + return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code]; +} + +/* Return the LHS of assignment statement GS. */ + +static inline tree +gimple_assign_lhs (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op (gs, 0); +} + + +/* Return a pointer to the LHS of assignment statement GS. */ + +static inline tree * +gimple_assign_lhs_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op_ptr (gs, 0); +} + + +/* Set LHS to be the LHS operand of assignment statement GS. */ + +static inline void +gimple_assign_set_lhs (gimple gs, tree lhs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + gimple_set_op (gs, 0, lhs); + + if (lhs && TREE_CODE (lhs) == SSA_NAME) + SSA_NAME_DEF_STMT (lhs) = gs; +} + + +/* Return the first operand on the RHS of assignment statement GS. */ + +static inline tree +gimple_assign_rhs1 (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op (gs, 1); +} + + +/* Return a pointer to the first operand on the RHS of assignment + statement GS. */ + +static inline tree * +gimple_assign_rhs1_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op_ptr (gs, 1); +} + +/* Set RHS to be the first operand on the RHS of assignment statement GS. */ + +static inline void +gimple_assign_set_rhs1 (gimple gs, tree rhs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + gimple_set_op (gs, 1, rhs); +} + + +/* Return the second operand on the RHS of assignment statement GS. + If GS does not have two operands, NULL is returned instead. */ + +static inline tree +gimple_assign_rhs2 (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + if (gimple_num_ops (gs) >= 3) + return gimple_op (gs, 2); + else + return NULL_TREE; +} + + +/* Return a pointer to the second operand on the RHS of assignment + statement GS. */ + +static inline tree * +gimple_assign_rhs2_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op_ptr (gs, 2); +} + + +/* Set RHS to be the second operand on the RHS of assignment statement GS. */ + +static inline void +gimple_assign_set_rhs2 (gimple gs, tree rhs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + gimple_set_op (gs, 2, rhs); +} + +/* Return the third operand on the RHS of assignment statement GS. + If GS does not have two operands, NULL is returned instead. */ + +static inline tree +gimple_assign_rhs3 (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + if (gimple_num_ops (gs) >= 4) + return gimple_op (gs, 3); + else + return NULL_TREE; +} + +/* Return a pointer to the third operand on the RHS of assignment + statement GS. */ + +static inline tree * +gimple_assign_rhs3_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op_ptr (gs, 3); +} + + +/* Set RHS to be the third operand on the RHS of assignment statement GS. */ + +static inline void +gimple_assign_set_rhs3 (gimple gs, tree rhs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + gimple_set_op (gs, 3, rhs); +} + +/* A wrapper around gimple_assign_set_rhs_with_ops_1, for callers which expect + to see only a maximum of two operands. */ + +static inline void +gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, + tree op1, tree op2) +{ + gimple_assign_set_rhs_with_ops_1 (gsi, code, op1, op2, NULL); +} + +/* A wrapper around extract_ops_from_tree_1, for callers which expect + to see only a maximum of two operands. */ + +static inline void +extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0, + tree *op1) +{ + tree op2; + extract_ops_from_tree_1 (expr, code, op0, op1, &op2); + gcc_assert (op2 == NULL_TREE); +} + +/* Returns true if GS is a nontemporal move. */ + +static inline bool +gimple_assign_nontemporal_move_p (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gs->gsbase.nontemporal_move; +} + +/* Sets nontemporal move flag of GS to NONTEMPORAL. */ + +static inline void +gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + gs->gsbase.nontemporal_move = nontemporal; +} + + +/* Return the code of the expression computed on the rhs of assignment + statement GS. In case that the RHS is a single object, returns the + tree code of the object. */ + +static inline enum tree_code +gimple_assign_rhs_code (const_gimple gs) +{ + enum tree_code code; + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + code = (enum tree_code) gs->gsbase.subcode; + /* While we initially set subcode to the TREE_CODE of the rhs for + GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay + in sync when we rewrite stmts into SSA form or do SSA propagations. */ + if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS) + code = TREE_CODE (gimple_assign_rhs1 (gs)); + + return code; +} + + +/* Set CODE to be the code for the expression computed on the RHS of + assignment S. */ + +static inline void +gimple_assign_set_rhs_code (gimple s, enum tree_code code) +{ + GIMPLE_CHECK (s, GIMPLE_ASSIGN); + s->gsbase.subcode = code; +} + + +/* Return the gimple rhs class of the code of the expression computed on + the rhs of assignment statement GS. + This will never return GIMPLE_INVALID_RHS. */ + +static inline enum gimple_rhs_class +gimple_assign_rhs_class (const_gimple gs) +{ + return get_gimple_rhs_class (gimple_assign_rhs_code (gs)); +} + +/* Return true if GS is an assignment with a singleton RHS, i.e., + there is no operator associated with the assignment itself. + Unlike gimple_assign_copy_p, this predicate returns true for + any RHS operand, including those that perform an operation + and do not have the semantics of a copy, such as COND_EXPR. */ + +static inline bool +gimple_assign_single_p (gimple gs) +{ + return (is_gimple_assign (gs) + && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS); +} + + +/* Return true if S is a type-cast assignment. */ + +static inline bool +gimple_assign_cast_p (gimple s) +{ + if (is_gimple_assign (s)) + { + enum tree_code sc = gimple_assign_rhs_code (s); + return CONVERT_EXPR_CODE_P (sc) + || sc == VIEW_CONVERT_EXPR + || sc == FIX_TRUNC_EXPR; + } + + return false; +} + + +/* Return true if GS is a GIMPLE_CALL. */ + +static inline bool +is_gimple_call (const_gimple gs) +{ + return gimple_code (gs) == GIMPLE_CALL; +} + +/* Return the LHS of call statement GS. */ + +static inline tree +gimple_call_lhs (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op (gs, 0); +} + + +/* Return a pointer to the LHS of call statement GS. */ + +static inline tree * +gimple_call_lhs_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op_ptr (gs, 0); +} + + +/* Set LHS to be the LHS operand of call statement GS. */ + +static inline void +gimple_call_set_lhs (gimple gs, tree lhs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gimple_set_op (gs, 0, lhs); + if (lhs && TREE_CODE (lhs) == SSA_NAME) + SSA_NAME_DEF_STMT (lhs) = gs; +} + + +/* Return the tree node representing the function called by call + statement GS. */ + +static inline tree +gimple_call_fn (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op (gs, 1); +} + + +/* Return a pointer to the tree node representing the function called by call + statement GS. */ + +static inline tree * +gimple_call_fn_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op_ptr (gs, 1); +} + + +/* Set FN to be the function called by call statement GS. */ + +static inline void +gimple_call_set_fn (gimple gs, tree fn) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gimple_set_op (gs, 1, fn); +} + + +/* Set FNDECL to be the function called by call statement GS. */ + +static inline void +gimple_call_set_fndecl (gimple gs, tree decl) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gimple_set_op (gs, 1, build_fold_addr_expr_loc (gimple_location (gs), decl)); +} + + +/* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. + Otherwise return NULL. This function is analogous to + get_callee_fndecl in tree land. */ + +static inline tree +gimple_call_fndecl (const_gimple gs) +{ + tree addr = gimple_call_fn (gs); + if (TREE_CODE (addr) == ADDR_EXPR) + { + tree fndecl = TREE_OPERAND (addr, 0); + if (TREE_CODE (fndecl) == MEM_REF) + { + if (TREE_CODE (TREE_OPERAND (fndecl, 0)) == ADDR_EXPR + && integer_zerop (TREE_OPERAND (fndecl, 1))) + return TREE_OPERAND (TREE_OPERAND (fndecl, 0), 0); + else + return NULL_TREE; + } + return TREE_OPERAND (addr, 0); + } + return NULL_TREE; +} + + +/* Return the type returned by call statement GS. */ + +static inline tree +gimple_call_return_type (const_gimple gs) +{ + tree fn = gimple_call_fn (gs); + tree type = TREE_TYPE (fn); + + /* See through the pointer. */ + type = TREE_TYPE (type); + + /* The type returned by a FUNCTION_DECL is the type of its + function type. */ + return TREE_TYPE (type); +} + + +/* Return the static chain for call statement GS. */ + +static inline tree +gimple_call_chain (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op (gs, 2); +} + + +/* Return a pointer to the static chain for call statement GS. */ + +static inline tree * +gimple_call_chain_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op_ptr (gs, 2); +} + +/* Set CHAIN to be the static chain for call statement GS. */ + +static inline void +gimple_call_set_chain (gimple gs, tree chain) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + + gimple_set_op (gs, 2, chain); +} + + +/* Return the number of arguments used by call statement GS. */ + +static inline unsigned +gimple_call_num_args (const_gimple gs) +{ + unsigned num_ops; + GIMPLE_CHECK (gs, GIMPLE_CALL); + num_ops = gimple_num_ops (gs); + return num_ops - 3; +} + + +/* Return the argument at position INDEX for call statement GS. */ + +static inline tree +gimple_call_arg (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op (gs, index + 3); +} + + +/* Return a pointer to the argument at position INDEX for call + statement GS. */ + +static inline tree * +gimple_call_arg_ptr (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return gimple_op_ptr (gs, index + 3); +} + + +/* Set ARG to be the argument at position INDEX for call statement GS. */ + +static inline void +gimple_call_set_arg (gimple gs, unsigned index, tree arg) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gimple_set_op (gs, index + 3, arg); +} + + +/* If TAIL_P is true, mark call statement S as being a tail call + (i.e., a call just before the exit of a function). These calls are + candidate for tail call optimization. */ + +static inline void +gimple_call_set_tail (gimple s, bool tail_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (tail_p) + s->gsbase.subcode |= GF_CALL_TAILCALL; + else + s->gsbase.subcode &= ~GF_CALL_TAILCALL; +} + + +/* Return true if GIMPLE_CALL S is marked as a tail call. */ + +static inline bool +gimple_call_tail_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (s->gsbase.subcode & GF_CALL_TAILCALL) != 0; +} + + +/* Set the inlinable status of GIMPLE_CALL S to INLINABLE_P. */ + +static inline void +gimple_call_set_cannot_inline (gimple s, bool inlinable_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (inlinable_p) + s->gsbase.subcode |= GF_CALL_CANNOT_INLINE; + else + s->gsbase.subcode &= ~GF_CALL_CANNOT_INLINE; +} + + +/* Return true if GIMPLE_CALL S cannot be inlined. */ + +static inline bool +gimple_call_cannot_inline_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (s->gsbase.subcode & GF_CALL_CANNOT_INLINE) != 0; +} + + +/* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return + slot optimization. This transformation uses the target of the call + expansion as the return slot for calls that return in memory. */ + +static inline void +gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (return_slot_opt_p) + s->gsbase.subcode |= GF_CALL_RETURN_SLOT_OPT; + else + s->gsbase.subcode &= ~GF_CALL_RETURN_SLOT_OPT; +} + + +/* Return true if S is marked for return slot optimization. */ + +static inline bool +gimple_call_return_slot_opt_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (s->gsbase.subcode & GF_CALL_RETURN_SLOT_OPT) != 0; +} + + +/* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a + thunk to the thunked-to function. */ + +static inline void +gimple_call_set_from_thunk (gimple s, bool from_thunk_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (from_thunk_p) + s->gsbase.subcode |= GF_CALL_FROM_THUNK; + else + s->gsbase.subcode &= ~GF_CALL_FROM_THUNK; +} + + +/* Return true if GIMPLE_CALL S is a jump from a thunk. */ + +static inline bool +gimple_call_from_thunk_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (s->gsbase.subcode & GF_CALL_FROM_THUNK) != 0; +} + + +/* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the + argument pack in its argument list. */ + +static inline void +gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (pass_arg_pack_p) + s->gsbase.subcode |= GF_CALL_VA_ARG_PACK; + else + s->gsbase.subcode &= ~GF_CALL_VA_ARG_PACK; +} + + +/* Return true if GIMPLE_CALL S is a stdarg call that needs the + argument pack in its argument list. */ + +static inline bool +gimple_call_va_arg_pack_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (s->gsbase.subcode & GF_CALL_VA_ARG_PACK) != 0; +} + + +/* Return true if S is a noreturn call. */ + +static inline bool +gimple_call_noreturn_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (gimple_call_flags (s) & ECF_NORETURN) != 0; +} + + +/* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw + even if the called function can throw in other cases. */ + +static inline void +gimple_call_set_nothrow (gimple s, bool nothrow_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (nothrow_p) + s->gsbase.subcode |= GF_CALL_NOTHROW; + else + s->gsbase.subcode &= ~GF_CALL_NOTHROW; +} + +/* Return true if S is a nothrow call. */ + +static inline bool +gimple_call_nothrow_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (gimple_call_flags (s) & ECF_NOTHROW) != 0; +} + + +/* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */ + +static inline void +gimple_call_copy_flags (gimple dest_call, gimple orig_call) +{ + GIMPLE_CHECK (dest_call, GIMPLE_CALL); + GIMPLE_CHECK (orig_call, GIMPLE_CALL); + dest_call->gsbase.subcode = orig_call->gsbase.subcode; +} + + +/* Return a pointer to the points-to solution for the set of call-used + variables of the call CALL. */ + +static inline struct pt_solution * +gimple_call_use_set (gimple call) +{ + GIMPLE_CHECK (call, GIMPLE_CALL); + return &call->gimple_call.call_used; +} + + +/* Return a pointer to the points-to solution for the set of call-used + variables of the call CALL. */ + +static inline struct pt_solution * +gimple_call_clobber_set (gimple call) +{ + GIMPLE_CHECK (call, GIMPLE_CALL); + return &call->gimple_call.call_clobbered; +} + + +/* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a + non-NULL lhs. */ + +static inline bool +gimple_has_lhs (gimple stmt) +{ + return (is_gimple_assign (stmt) + || (is_gimple_call (stmt) + && gimple_call_lhs (stmt) != NULL_TREE)); +} + + +/* Return the code of the predicate computed by conditional statement GS. */ + +static inline enum tree_code +gimple_cond_code (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return (enum tree_code) gs->gsbase.subcode; +} + + +/* Set CODE to be the predicate code for the conditional statement GS. */ + +static inline void +gimple_cond_set_code (gimple gs, enum tree_code code) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + gs->gsbase.subcode = code; +} + + +/* Return the LHS of the predicate computed by conditional statement GS. */ + +static inline tree +gimple_cond_lhs (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return gimple_op (gs, 0); +} + +/* Return the pointer to the LHS of the predicate computed by conditional + statement GS. */ + +static inline tree * +gimple_cond_lhs_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return gimple_op_ptr (gs, 0); +} + +/* Set LHS to be the LHS operand of the predicate computed by + conditional statement GS. */ + +static inline void +gimple_cond_set_lhs (gimple gs, tree lhs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + gimple_set_op (gs, 0, lhs); +} + + +/* Return the RHS operand of the predicate computed by conditional GS. */ + +static inline tree +gimple_cond_rhs (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return gimple_op (gs, 1); +} + +/* Return the pointer to the RHS operand of the predicate computed by + conditional GS. */ + +static inline tree * +gimple_cond_rhs_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return gimple_op_ptr (gs, 1); +} + + +/* Set RHS to be the RHS operand of the predicate computed by + conditional statement GS. */ + +static inline void +gimple_cond_set_rhs (gimple gs, tree rhs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + gimple_set_op (gs, 1, rhs); +} + + +/* Return the label used by conditional statement GS when its + predicate evaluates to true. */ + +static inline tree +gimple_cond_true_label (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return gimple_op (gs, 2); +} + + +/* Set LABEL to be the label used by conditional statement GS when its + predicate evaluates to true. */ + +static inline void +gimple_cond_set_true_label (gimple gs, tree label) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + gimple_set_op (gs, 2, label); +} + + +/* Set LABEL to be the label used by conditional statement GS when its + predicate evaluates to false. */ + +static inline void +gimple_cond_set_false_label (gimple gs, tree label) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + gimple_set_op (gs, 3, label); +} + + +/* Return the label used by conditional statement GS when its + predicate evaluates to false. */ + +static inline tree +gimple_cond_false_label (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_COND); + return gimple_op (gs, 3); +} + + +/* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */ + +static inline void +gimple_cond_make_false (gimple gs) +{ + gimple_cond_set_lhs (gs, boolean_true_node); + gimple_cond_set_rhs (gs, boolean_false_node); + gs->gsbase.subcode = EQ_EXPR; +} + + +/* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */ + +static inline void +gimple_cond_make_true (gimple gs) +{ + gimple_cond_set_lhs (gs, boolean_true_node); + gimple_cond_set_rhs (gs, boolean_true_node); + gs->gsbase.subcode = EQ_EXPR; +} + +/* Check if conditional statemente GS is of the form 'if (1 == 1)', + 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */ + +static inline bool +gimple_cond_true_p (const_gimple gs) +{ + tree lhs = gimple_cond_lhs (gs); + tree rhs = gimple_cond_rhs (gs); + enum tree_code code = gimple_cond_code (gs); + + if (lhs != boolean_true_node && lhs != boolean_false_node) + return false; + + if (rhs != boolean_true_node && rhs != boolean_false_node) + return false; + + if (code == NE_EXPR && lhs != rhs) + return true; + + if (code == EQ_EXPR && lhs == rhs) + return true; + + return false; +} + +/* Check if conditional statement GS is of the form 'if (1 != 1)', + 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */ + +static inline bool +gimple_cond_false_p (const_gimple gs) +{ + tree lhs = gimple_cond_lhs (gs); + tree rhs = gimple_cond_rhs (gs); + enum tree_code code = gimple_cond_code (gs); + + if (lhs != boolean_true_node && lhs != boolean_false_node) + return false; + + if (rhs != boolean_true_node && rhs != boolean_false_node) + return false; + + if (code == NE_EXPR && lhs == rhs) + return true; + + if (code == EQ_EXPR && lhs != rhs) + return true; + + return false; +} + +/* Check if conditional statement GS is of the form 'if (var != 0)' or + 'if (var == 1)' */ + +static inline bool +gimple_cond_single_var_p (gimple gs) +{ + if (gimple_cond_code (gs) == NE_EXPR + && gimple_cond_rhs (gs) == boolean_false_node) + return true; + + if (gimple_cond_code (gs) == EQ_EXPR + && gimple_cond_rhs (gs) == boolean_true_node) + return true; + + return false; +} + +/* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */ + +static inline void +gimple_cond_set_condition (gimple stmt, enum tree_code code, tree lhs, tree rhs) +{ + gimple_cond_set_code (stmt, code); + gimple_cond_set_lhs (stmt, lhs); + gimple_cond_set_rhs (stmt, rhs); +} + +/* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */ + +static inline tree +gimple_label_label (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_LABEL); + return gimple_op (gs, 0); +} + + +/* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement + GS. */ + +static inline void +gimple_label_set_label (gimple gs, tree label) +{ + GIMPLE_CHECK (gs, GIMPLE_LABEL); + gimple_set_op (gs, 0, label); +} + + +/* Return the destination of the unconditional jump GS. */ + +static inline tree +gimple_goto_dest (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_GOTO); + return gimple_op (gs, 0); +} + + +/* Set DEST to be the destination of the unconditonal jump GS. */ + +static inline void +gimple_goto_set_dest (gimple gs, tree dest) +{ + GIMPLE_CHECK (gs, GIMPLE_GOTO); + gimple_set_op (gs, 0, dest); +} + + +/* Return the variables declared in the GIMPLE_BIND statement GS. */ + +static inline tree +gimple_bind_vars (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + return gs->gimple_bind.vars; +} + + +/* Set VARS to be the set of variables declared in the GIMPLE_BIND + statement GS. */ + +static inline void +gimple_bind_set_vars (gimple gs, tree vars) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + gs->gimple_bind.vars = vars; +} + + +/* Append VARS to the set of variables declared in the GIMPLE_BIND + statement GS. */ + +static inline void +gimple_bind_append_vars (gimple gs, tree vars) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + gs->gimple_bind.vars = chainon (gs->gimple_bind.vars, vars); +} + + +/* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */ + +static inline gimple_seq +gimple_bind_body (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + return gs->gimple_bind.body; +} + + +/* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND + statement GS. */ + +static inline void +gimple_bind_set_body (gimple gs, gimple_seq seq) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + gs->gimple_bind.body = seq; +} + + +/* Append a statement to the end of a GIMPLE_BIND's body. */ + +static inline void +gimple_bind_add_stmt (gimple gs, gimple stmt) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + gimple_seq_add_stmt (&gs->gimple_bind.body, stmt); +} + + +/* Append a sequence of statements to the end of a GIMPLE_BIND's body. */ + +static inline void +gimple_bind_add_seq (gimple gs, gimple_seq seq) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + gimple_seq_add_seq (&gs->gimple_bind.body, seq); +} + + +/* Return the TREE_BLOCK node associated with GIMPLE_BIND statement + GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */ + +static inline tree +gimple_bind_block (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + return gs->gimple_bind.block; +} + + +/* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND + statement GS. */ + +static inline void +gimple_bind_set_block (gimple gs, tree block) +{ + GIMPLE_CHECK (gs, GIMPLE_BIND); + gcc_gimple_checking_assert (block == NULL_TREE + || TREE_CODE (block) == BLOCK); + gs->gimple_bind.block = block; +} + + +/* Return the number of input operands for GIMPLE_ASM GS. */ + +static inline unsigned +gimple_asm_ninputs (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return gs->gimple_asm.ni; +} + + +/* Return the number of output operands for GIMPLE_ASM GS. */ + +static inline unsigned +gimple_asm_noutputs (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return gs->gimple_asm.no; +} + + +/* Return the number of clobber operands for GIMPLE_ASM GS. */ + +static inline unsigned +gimple_asm_nclobbers (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return gs->gimple_asm.nc; +} + +/* Return the number of label operands for GIMPLE_ASM GS. */ + +static inline unsigned +gimple_asm_nlabels (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return gs->gimple_asm.nl; +} + +/* Return input operand INDEX of GIMPLE_ASM GS. */ + +static inline tree +gimple_asm_input_op (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni); + return gimple_op (gs, index); +} + +/* Return a pointer to input operand INDEX of GIMPLE_ASM GS. */ + +static inline tree * +gimple_asm_input_op_ptr (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni); + return gimple_op_ptr (gs, index); +} + + +/* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS. */ + +static inline void +gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni + && TREE_CODE (in_op) == TREE_LIST); + gimple_set_op (gs, index, in_op); +} + + +/* Return output operand INDEX of GIMPLE_ASM GS. */ + +static inline tree +gimple_asm_output_op (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.no); + return gimple_op (gs, index + gs->gimple_asm.ni); +} + +/* Return a pointer to output operand INDEX of GIMPLE_ASM GS. */ + +static inline tree * +gimple_asm_output_op_ptr (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.no); + return gimple_op_ptr (gs, index + gs->gimple_asm.ni); +} + + +/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS. */ + +static inline void +gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.no + && TREE_CODE (out_op) == TREE_LIST); + gimple_set_op (gs, index + gs->gimple_asm.ni, out_op); +} + + +/* Return clobber operand INDEX of GIMPLE_ASM GS. */ + +static inline tree +gimple_asm_clobber_op (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nc); + return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no); +} + + +/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS. */ + +static inline void +gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nc + && TREE_CODE (clobber_op) == TREE_LIST); + gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op); +} + +/* Return label operand INDEX of GIMPLE_ASM GS. */ + +static inline tree +gimple_asm_label_op (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nl); + return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc); +} + +/* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS. */ + +static inline void +gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nl + && TREE_CODE (label_op) == TREE_LIST); + gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op); +} + +/* Return the string representing the assembly instruction in + GIMPLE_ASM GS. */ + +static inline const char * +gimple_asm_string (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return gs->gimple_asm.string; +} + + +/* Return true if GS is an asm statement marked volatile. */ + +static inline bool +gimple_asm_volatile_p (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return (gs->gsbase.subcode & GF_ASM_VOLATILE) != 0; +} + + +/* If VOLATLE_P is true, mark asm statement GS as volatile. */ + +static inline void +gimple_asm_set_volatile (gimple gs, bool volatile_p) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + if (volatile_p) + gs->gsbase.subcode |= GF_ASM_VOLATILE; + else + gs->gsbase.subcode &= ~GF_ASM_VOLATILE; +} + + +/* If INPUT_P is true, mark asm GS as an ASM_INPUT. */ + +static inline void +gimple_asm_set_input (gimple gs, bool input_p) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + if (input_p) + gs->gsbase.subcode |= GF_ASM_INPUT; + else + gs->gsbase.subcode &= ~GF_ASM_INPUT; +} + + +/* Return true if asm GS is an ASM_INPUT. */ + +static inline bool +gimple_asm_input_p (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASM); + return (gs->gsbase.subcode & GF_ASM_INPUT) != 0; +} + + +/* Return the types handled by GIMPLE_CATCH statement GS. */ + +static inline tree +gimple_catch_types (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CATCH); + return gs->gimple_catch.types; +} + + +/* Return a pointer to the types handled by GIMPLE_CATCH statement GS. */ + +static inline tree * +gimple_catch_types_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CATCH); + return &gs->gimple_catch.types; +} + + +/* Return the GIMPLE sequence representing the body of the handler of + GIMPLE_CATCH statement GS. */ + +static inline gimple_seq +gimple_catch_handler (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CATCH); + return gs->gimple_catch.handler; +} + + +/* Return a pointer to the GIMPLE sequence representing the body of + the handler of GIMPLE_CATCH statement GS. */ + +static inline gimple_seq * +gimple_catch_handler_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CATCH); + return &gs->gimple_catch.handler; +} + + +/* Set T to be the set of types handled by GIMPLE_CATCH GS. */ + +static inline void +gimple_catch_set_types (gimple gs, tree t) +{ + GIMPLE_CHECK (gs, GIMPLE_CATCH); + gs->gimple_catch.types = t; +} + + +/* Set HANDLER to be the body of GIMPLE_CATCH GS. */ + +static inline void +gimple_catch_set_handler (gimple gs, gimple_seq handler) +{ + GIMPLE_CHECK (gs, GIMPLE_CATCH); + gs->gimple_catch.handler = handler; +} + + +/* Return the types handled by GIMPLE_EH_FILTER statement GS. */ + +static inline tree +gimple_eh_filter_types (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_FILTER); + return gs->gimple_eh_filter.types; +} + + +/* Return a pointer to the types handled by GIMPLE_EH_FILTER statement + GS. */ + +static inline tree * +gimple_eh_filter_types_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_FILTER); + return &gs->gimple_eh_filter.types; +} + + +/* Return the sequence of statement to execute when GIMPLE_EH_FILTER + statement fails. */ + +static inline gimple_seq +gimple_eh_filter_failure (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_FILTER); + return gs->gimple_eh_filter.failure; +} + + +/* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS. */ + +static inline void +gimple_eh_filter_set_types (gimple gs, tree types) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_FILTER); + gs->gimple_eh_filter.types = types; +} + + +/* Set FAILURE to be the sequence of statements to execute on failure + for GIMPLE_EH_FILTER GS. */ + +static inline void +gimple_eh_filter_set_failure (gimple gs, gimple_seq failure) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_FILTER); + gs->gimple_eh_filter.failure = failure; +} + +/* Get the function decl to be called by the MUST_NOT_THROW region. */ + +static inline tree +gimple_eh_must_not_throw_fndecl (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_MUST_NOT_THROW); + return gs->gimple_eh_mnt.fndecl; +} + +/* Set the function decl to be called by GS to DECL. */ + +static inline void +gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_MUST_NOT_THROW); + gs->gimple_eh_mnt.fndecl = decl; +} + + +/* GIMPLE_TRY accessors. */ + +/* Return the kind of try block represented by GIMPLE_TRY GS. This is + either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */ + +static inline enum gimple_try_flags +gimple_try_kind (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRY); + return (enum gimple_try_flags) (gs->gsbase.subcode & GIMPLE_TRY_KIND); +} + + +/* Set the kind of try block represented by GIMPLE_TRY GS. */ + +static inline void +gimple_try_set_kind (gimple gs, enum gimple_try_flags kind) +{ + GIMPLE_CHECK (gs, GIMPLE_TRY); + gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH + || kind == GIMPLE_TRY_FINALLY); + if (gimple_try_kind (gs) != kind) + gs->gsbase.subcode = (unsigned int) kind; +} + + +/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */ + +static inline bool +gimple_try_catch_is_cleanup (const_gimple gs) +{ + gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH); + return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0; +} + + +/* Return the sequence of statements used as the body for GIMPLE_TRY GS. */ + +static inline gimple_seq +gimple_try_eval (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRY); + return gs->gimple_try.eval; +} + + +/* Return the sequence of statements used as the cleanup body for + GIMPLE_TRY GS. */ + +static inline gimple_seq +gimple_try_cleanup (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRY); + return gs->gimple_try.cleanup; +} + + +/* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */ + +static inline void +gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup) +{ + gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH); + if (catch_is_cleanup) + g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP; + else + g->gsbase.subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP; +} + + +/* Set EVAL to be the sequence of statements to use as the body for + GIMPLE_TRY GS. */ + +static inline void +gimple_try_set_eval (gimple gs, gimple_seq eval) +{ + GIMPLE_CHECK (gs, GIMPLE_TRY); + gs->gimple_try.eval = eval; +} + + +/* Set CLEANUP to be the sequence of statements to use as the cleanup + body for GIMPLE_TRY GS. */ + +static inline void +gimple_try_set_cleanup (gimple gs, gimple_seq cleanup) +{ + GIMPLE_CHECK (gs, GIMPLE_TRY); + gs->gimple_try.cleanup = cleanup; +} + + +/* Return the cleanup sequence for cleanup statement GS. */ + +static inline gimple_seq +gimple_wce_cleanup (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR); + return gs->gimple_wce.cleanup; +} + + +/* Set CLEANUP to be the cleanup sequence for GS. */ + +static inline void +gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup) +{ + GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR); + gs->gimple_wce.cleanup = cleanup; +} + + +/* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */ + +static inline bool +gimple_wce_cleanup_eh_only (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR); + return gs->gsbase.subcode != 0; +} + + +/* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */ + +static inline void +gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p) +{ + GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR); + gs->gsbase.subcode = (unsigned int) eh_only_p; +} + + +/* Return the maximum number of arguments supported by GIMPLE_PHI GS. */ + +static inline unsigned +gimple_phi_capacity (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + return gs->gimple_phi.capacity; +} + + +/* Return the number of arguments in GIMPLE_PHI GS. This must always + be exactly the number of incoming edges for the basic block holding + GS. */ + +static inline unsigned +gimple_phi_num_args (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + return gs->gimple_phi.nargs; +} + + +/* Return the SSA name created by GIMPLE_PHI GS. */ + +static inline tree +gimple_phi_result (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + return gs->gimple_phi.result; +} + +/* Return a pointer to the SSA name created by GIMPLE_PHI GS. */ + +static inline tree * +gimple_phi_result_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + return &gs->gimple_phi.result; +} + +/* Set RESULT to be the SSA name created by GIMPLE_PHI GS. */ + +static inline void +gimple_phi_set_result (gimple gs, tree result) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + gs->gimple_phi.result = result; +} + + +/* Return the PHI argument corresponding to incoming edge INDEX for + GIMPLE_PHI GS. */ + +static inline struct phi_arg_d * +gimple_phi_arg (gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + gcc_gimple_checking_assert (index <= gs->gimple_phi.capacity); + return &(gs->gimple_phi.args[index]); +} + +/* Set PHIARG to be the argument corresponding to incoming edge INDEX + for GIMPLE_PHI GS. */ + +static inline void +gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg) +{ + GIMPLE_CHECK (gs, GIMPLE_PHI); + gcc_gimple_checking_assert (index <= gs->gimple_phi.nargs); + gs->gimple_phi.args[index] = *phiarg; +} + +/* Return the region number for GIMPLE_RESX GS. */ + +static inline int +gimple_resx_region (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_RESX); + return gs->gimple_eh_ctrl.region; +} + +/* Set REGION to be the region number for GIMPLE_RESX GS. */ + +static inline void +gimple_resx_set_region (gimple gs, int region) +{ + GIMPLE_CHECK (gs, GIMPLE_RESX); + gs->gimple_eh_ctrl.region = region; +} + +/* Return the region number for GIMPLE_EH_DISPATCH GS. */ + +static inline int +gimple_eh_dispatch_region (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_DISPATCH); + return gs->gimple_eh_ctrl.region; +} + +/* Set REGION to be the region number for GIMPLE_EH_DISPATCH GS. */ + +static inline void +gimple_eh_dispatch_set_region (gimple gs, int region) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_DISPATCH); + gs->gimple_eh_ctrl.region = region; +} + +/* Return the number of labels associated with the switch statement GS. */ + +static inline unsigned +gimple_switch_num_labels (const_gimple gs) +{ + unsigned num_ops; + GIMPLE_CHECK (gs, GIMPLE_SWITCH); + num_ops = gimple_num_ops (gs); + gcc_gimple_checking_assert (num_ops > 1); + return num_ops - 1; +} + + +/* Set NLABELS to be the number of labels for the switch statement GS. */ + +static inline void +gimple_switch_set_num_labels (gimple g, unsigned nlabels) +{ + GIMPLE_CHECK (g, GIMPLE_SWITCH); + gimple_set_num_ops (g, nlabels + 1); +} + + +/* Return the index variable used by the switch statement GS. */ + +static inline tree +gimple_switch_index (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_SWITCH); + return gimple_op (gs, 0); +} + + +/* Return a pointer to the index variable for the switch statement GS. */ + +static inline tree * +gimple_switch_index_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_SWITCH); + return gimple_op_ptr (gs, 0); +} + + +/* Set INDEX to be the index variable for switch statement GS. */ + +static inline void +gimple_switch_set_index (gimple gs, tree index) +{ + GIMPLE_CHECK (gs, GIMPLE_SWITCH); + gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index)); + gimple_set_op (gs, 0, index); +} + + +/* Return the label numbered INDEX. The default label is 0, followed by any + labels in a switch statement. */ + +static inline tree +gimple_switch_label (const_gimple gs, unsigned index) +{ + GIMPLE_CHECK (gs, GIMPLE_SWITCH); + gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1); + return gimple_op (gs, index + 1); +} + +/* Set the label number INDEX to LABEL. 0 is always the default label. */ + +static inline void +gimple_switch_set_label (gimple gs, unsigned index, tree label) +{ + GIMPLE_CHECK (gs, GIMPLE_SWITCH); + gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1 + && (label == NULL_TREE + || TREE_CODE (label) == CASE_LABEL_EXPR)); + gimple_set_op (gs, index + 1, label); +} + +/* Return the default label for a switch statement. */ + +static inline tree +gimple_switch_default_label (const_gimple gs) +{ + return gimple_switch_label (gs, 0); +} + +/* Set the default label for a switch statement. */ + +static inline void +gimple_switch_set_default_label (gimple gs, tree label) +{ + gimple_switch_set_label (gs, 0, label); +} + +/* Return true if GS is a GIMPLE_DEBUG statement. */ + +static inline bool +is_gimple_debug (const_gimple gs) +{ + return gimple_code (gs) == GIMPLE_DEBUG; +} + +/* Return true if S is a GIMPLE_DEBUG BIND statement. */ + +static inline bool +gimple_debug_bind_p (const_gimple s) +{ + if (is_gimple_debug (s)) + return s->gsbase.subcode == GIMPLE_DEBUG_BIND; + + return false; +} + +/* Return the variable bound in a GIMPLE_DEBUG bind statement. */ + +static inline tree +gimple_debug_bind_get_var (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + return gimple_op (dbg, 0); +} + +/* Return the value bound to the variable in a GIMPLE_DEBUG bind + statement. */ + +static inline tree +gimple_debug_bind_get_value (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + return gimple_op (dbg, 1); +} + +/* Return a pointer to the value bound to the variable in a + GIMPLE_DEBUG bind statement. */ + +static inline tree * +gimple_debug_bind_get_value_ptr (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + return gimple_op_ptr (dbg, 1); +} + +/* Set the variable bound in a GIMPLE_DEBUG bind statement. */ + +static inline void +gimple_debug_bind_set_var (gimple dbg, tree var) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + gimple_set_op (dbg, 0, var); +} + +/* Set the value bound to the variable in a GIMPLE_DEBUG bind + statement. */ + +static inline void +gimple_debug_bind_set_value (gimple dbg, tree value) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + gimple_set_op (dbg, 1, value); +} + +/* The second operand of a GIMPLE_DEBUG_BIND, when the value was + optimized away. */ +#define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */ + +/* Remove the value bound to the variable in a GIMPLE_DEBUG bind + statement. */ + +static inline void +gimple_debug_bind_reset_value (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE); +} + +/* Return true if the GIMPLE_DEBUG bind statement is bound to a + value. */ + +static inline bool +gimple_debug_bind_has_value_p (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); + return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE; +} + +#undef GIMPLE_DEBUG_BIND_NOVALUE + +/* Return the body for the OMP statement GS. */ + +static inline gimple_seq +gimple_omp_body (gimple gs) +{ + return gs->omp.body; +} + +/* Set BODY to be the body for the OMP statement GS. */ + +static inline void +gimple_omp_set_body (gimple gs, gimple_seq body) +{ + gs->omp.body = body; +} + + +/* Return the name associated with OMP_CRITICAL statement GS. */ + +static inline tree +gimple_omp_critical_name (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL); + return gs->gimple_omp_critical.name; +} + + +/* Return a pointer to the name associated with OMP critical statement GS. */ + +static inline tree * +gimple_omp_critical_name_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL); + return &gs->gimple_omp_critical.name; +} + + +/* Set NAME to be the name associated with OMP critical statement GS. */ + +static inline void +gimple_omp_critical_set_name (gimple gs, tree name) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL); + gs->gimple_omp_critical.name = name; +} + + +/* Return the clauses associated with OMP_FOR GS. */ + +static inline tree +gimple_omp_for_clauses (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + return gs->gimple_omp_for.clauses; +} + + +/* Return a pointer to the OMP_FOR GS. */ + +static inline tree * +gimple_omp_for_clauses_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + return &gs->gimple_omp_for.clauses; +} + + +/* Set CLAUSES to be the list of clauses associated with OMP_FOR GS. */ + +static inline void +gimple_omp_for_set_clauses (gimple gs, tree clauses) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gs->gimple_omp_for.clauses = clauses; +} + + +/* Get the collapse count of OMP_FOR GS. */ + +static inline size_t +gimple_omp_for_collapse (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + return gs->gimple_omp_for.collapse; +} + + +/* Return the index variable for OMP_FOR GS. */ + +static inline tree +gimple_omp_for_index (const_gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return gs->gimple_omp_for.iter[i].index; +} + + +/* Return a pointer to the index variable for OMP_FOR GS. */ + +static inline tree * +gimple_omp_for_index_ptr (gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return &gs->gimple_omp_for.iter[i].index; +} + + +/* Set INDEX to be the index variable for OMP_FOR GS. */ + +static inline void +gimple_omp_for_set_index (gimple gs, size_t i, tree index) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + gs->gimple_omp_for.iter[i].index = index; +} + + +/* Return the initial value for OMP_FOR GS. */ + +static inline tree +gimple_omp_for_initial (const_gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return gs->gimple_omp_for.iter[i].initial; +} + + +/* Return a pointer to the initial value for OMP_FOR GS. */ + +static inline tree * +gimple_omp_for_initial_ptr (gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return &gs->gimple_omp_for.iter[i].initial; +} + + +/* Set INITIAL to be the initial value for OMP_FOR GS. */ + +static inline void +gimple_omp_for_set_initial (gimple gs, size_t i, tree initial) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + gs->gimple_omp_for.iter[i].initial = initial; +} + + +/* Return the final value for OMP_FOR GS. */ + +static inline tree +gimple_omp_for_final (const_gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return gs->gimple_omp_for.iter[i].final; +} + + +/* Return a pointer to the final value for OMP_FOR GS. */ + +static inline tree * +gimple_omp_for_final_ptr (gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return &gs->gimple_omp_for.iter[i].final; +} + + +/* Set FINAL to be the final value for OMP_FOR GS. */ + +static inline void +gimple_omp_for_set_final (gimple gs, size_t i, tree final) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + gs->gimple_omp_for.iter[i].final = final; +} + + +/* Return the increment value for OMP_FOR GS. */ + +static inline tree +gimple_omp_for_incr (const_gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return gs->gimple_omp_for.iter[i].incr; +} + + +/* Return a pointer to the increment value for OMP_FOR GS. */ + +static inline tree * +gimple_omp_for_incr_ptr (gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return &gs->gimple_omp_for.iter[i].incr; +} + + +/* Set INCR to be the increment value for OMP_FOR GS. */ + +static inline void +gimple_omp_for_set_incr (gimple gs, size_t i, tree incr) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + gs->gimple_omp_for.iter[i].incr = incr; +} + + +/* Return the sequence of statements to execute before the OMP_FOR + statement GS starts. */ + +static inline gimple_seq +gimple_omp_for_pre_body (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + return gs->gimple_omp_for.pre_body; +} + + +/* Set PRE_BODY to be the sequence of statements to execute before the + OMP_FOR statement GS starts. */ + +static inline void +gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gs->gimple_omp_for.pre_body = pre_body; +} + + +/* Return the clauses associated with OMP_PARALLEL GS. */ + +static inline tree +gimple_omp_parallel_clauses (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + return gs->gimple_omp_parallel.clauses; +} + + +/* Return a pointer to the clauses associated with OMP_PARALLEL GS. */ + +static inline tree * +gimple_omp_parallel_clauses_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + return &gs->gimple_omp_parallel.clauses; +} + + +/* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL + GS. */ + +static inline void +gimple_omp_parallel_set_clauses (gimple gs, tree clauses) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + gs->gimple_omp_parallel.clauses = clauses; +} + + +/* Return the child function used to hold the body of OMP_PARALLEL GS. */ + +static inline tree +gimple_omp_parallel_child_fn (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + return gs->gimple_omp_parallel.child_fn; +} + +/* Return a pointer to the child function used to hold the body of + OMP_PARALLEL GS. */ + +static inline tree * +gimple_omp_parallel_child_fn_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + return &gs->gimple_omp_parallel.child_fn; +} + + +/* Set CHILD_FN to be the child function for OMP_PARALLEL GS. */ + +static inline void +gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + gs->gimple_omp_parallel.child_fn = child_fn; +} + + +/* Return the artificial argument used to send variables and values + from the parent to the children threads in OMP_PARALLEL GS. */ + +static inline tree +gimple_omp_parallel_data_arg (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + return gs->gimple_omp_parallel.data_arg; +} + + +/* Return a pointer to the data argument for OMP_PARALLEL GS. */ + +static inline tree * +gimple_omp_parallel_data_arg_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + return &gs->gimple_omp_parallel.data_arg; +} + + +/* Set DATA_ARG to be the data argument for OMP_PARALLEL GS. */ + +static inline void +gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL); + gs->gimple_omp_parallel.data_arg = data_arg; +} + + +/* Return the clauses associated with OMP_TASK GS. */ + +static inline tree +gimple_omp_task_clauses (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_parallel.clauses; +} + + +/* Return a pointer to the clauses associated with OMP_TASK GS. */ + +static inline tree * +gimple_omp_task_clauses_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_parallel.clauses; +} + + +/* Set CLAUSES to be the list of clauses associated with OMP_TASK + GS. */ + +static inline void +gimple_omp_task_set_clauses (gimple gs, tree clauses) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_parallel.clauses = clauses; +} + + +/* Return the child function used to hold the body of OMP_TASK GS. */ + +static inline tree +gimple_omp_task_child_fn (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_parallel.child_fn; +} + +/* Return a pointer to the child function used to hold the body of + OMP_TASK GS. */ + +static inline tree * +gimple_omp_task_child_fn_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_parallel.child_fn; +} + + +/* Set CHILD_FN to be the child function for OMP_TASK GS. */ + +static inline void +gimple_omp_task_set_child_fn (gimple gs, tree child_fn) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_parallel.child_fn = child_fn; +} + + +/* Return the artificial argument used to send variables and values + from the parent to the children threads in OMP_TASK GS. */ + +static inline tree +gimple_omp_task_data_arg (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_parallel.data_arg; +} + + +/* Return a pointer to the data argument for OMP_TASK GS. */ + +static inline tree * +gimple_omp_task_data_arg_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_parallel.data_arg; +} + + +/* Set DATA_ARG to be the data argument for OMP_TASK GS. */ + +static inline void +gimple_omp_task_set_data_arg (gimple gs, tree data_arg) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_parallel.data_arg = data_arg; +} + + +/* Return the clauses associated with OMP_TASK GS. */ + +static inline tree +gimple_omp_taskreg_clauses (const_gimple gs) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_parallel.clauses; +} + + +/* Return a pointer to the clauses associated with OMP_TASK GS. */ + +static inline tree * +gimple_omp_taskreg_clauses_ptr (gimple gs) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_parallel.clauses; +} + + +/* Set CLAUSES to be the list of clauses associated with OMP_TASK + GS. */ + +static inline void +gimple_omp_taskreg_set_clauses (gimple gs, tree clauses) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_parallel.clauses = clauses; +} + + +/* Return the child function used to hold the body of OMP_TASK GS. */ + +static inline tree +gimple_omp_taskreg_child_fn (const_gimple gs) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_parallel.child_fn; +} + +/* Return a pointer to the child function used to hold the body of + OMP_TASK GS. */ + +static inline tree * +gimple_omp_taskreg_child_fn_ptr (gimple gs) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_parallel.child_fn; +} + + +/* Set CHILD_FN to be the child function for OMP_TASK GS. */ + +static inline void +gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_parallel.child_fn = child_fn; +} + + +/* Return the artificial argument used to send variables and values + from the parent to the children threads in OMP_TASK GS. */ + +static inline tree +gimple_omp_taskreg_data_arg (const_gimple gs) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_parallel.data_arg; +} + + +/* Return a pointer to the data argument for OMP_TASK GS. */ + +static inline tree * +gimple_omp_taskreg_data_arg_ptr (gimple gs) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_parallel.data_arg; +} + + +/* Set DATA_ARG to be the data argument for OMP_TASK GS. */ + +static inline void +gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg) +{ + if (gimple_code (gs) != GIMPLE_OMP_PARALLEL) + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_parallel.data_arg = data_arg; +} + + +/* Return the copy function used to hold the body of OMP_TASK GS. */ + +static inline tree +gimple_omp_task_copy_fn (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_task.copy_fn; +} + +/* Return a pointer to the copy function used to hold the body of + OMP_TASK GS. */ + +static inline tree * +gimple_omp_task_copy_fn_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_task.copy_fn; +} + + +/* Set CHILD_FN to be the copy function for OMP_TASK GS. */ + +static inline void +gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_task.copy_fn = copy_fn; +} + + +/* Return size of the data block in bytes in OMP_TASK GS. */ + +static inline tree +gimple_omp_task_arg_size (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_task.arg_size; +} + + +/* Return a pointer to the data block size for OMP_TASK GS. */ + +static inline tree * +gimple_omp_task_arg_size_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_task.arg_size; +} + + +/* Set ARG_SIZE to be the data block size for OMP_TASK GS. */ + +static inline void +gimple_omp_task_set_arg_size (gimple gs, tree arg_size) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_task.arg_size = arg_size; +} + + +/* Return align of the data block in bytes in OMP_TASK GS. */ + +static inline tree +gimple_omp_task_arg_align (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return gs->gimple_omp_task.arg_align; +} + + +/* Return a pointer to the data block align for OMP_TASK GS. */ + +static inline tree * +gimple_omp_task_arg_align_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + return &gs->gimple_omp_task.arg_align; +} + + +/* Set ARG_SIZE to be the data block align for OMP_TASK GS. */ + +static inline void +gimple_omp_task_set_arg_align (gimple gs, tree arg_align) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_TASK); + gs->gimple_omp_task.arg_align = arg_align; +} + + +/* Return the clauses associated with OMP_SINGLE GS. */ + +static inline tree +gimple_omp_single_clauses (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE); + return gs->gimple_omp_single.clauses; +} + + +/* Return a pointer to the clauses associated with OMP_SINGLE GS. */ + +static inline tree * +gimple_omp_single_clauses_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE); + return &gs->gimple_omp_single.clauses; +} + + +/* Set CLAUSES to be the clauses associated with OMP_SINGLE GS. */ + +static inline void +gimple_omp_single_set_clauses (gimple gs, tree clauses) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE); + gs->gimple_omp_single.clauses = clauses; +} + + +/* Return the clauses associated with OMP_SECTIONS GS. */ + +static inline tree +gimple_omp_sections_clauses (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS); + return gs->gimple_omp_sections.clauses; +} + + +/* Return a pointer to the clauses associated with OMP_SECTIONS GS. */ + +static inline tree * +gimple_omp_sections_clauses_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS); + return &gs->gimple_omp_sections.clauses; +} + + +/* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS + GS. */ + +static inline void +gimple_omp_sections_set_clauses (gimple gs, tree clauses) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS); + gs->gimple_omp_sections.clauses = clauses; +} + + +/* Return the control variable associated with the GIMPLE_OMP_SECTIONS + in GS. */ + +static inline tree +gimple_omp_sections_control (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS); + return gs->gimple_omp_sections.control; +} + + +/* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS + GS. */ + +static inline tree * +gimple_omp_sections_control_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS); + return &gs->gimple_omp_sections.control; +} + + +/* Set CONTROL to be the set of clauses associated with the + GIMPLE_OMP_SECTIONS in GS. */ + +static inline void +gimple_omp_sections_set_control (gimple gs, tree control) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS); + gs->gimple_omp_sections.control = control; +} + + +/* Set COND to be the condition code for OMP_FOR GS. */ + +static inline void +gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison + && i < gs->gimple_omp_for.collapse); + gs->gimple_omp_for.iter[i].cond = cond; +} + + +/* Return the condition code associated with OMP_FOR GS. */ + +static inline enum tree_code +gimple_omp_for_cond (const_gimple gs, size_t i) +{ + GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); + return gs->gimple_omp_for.iter[i].cond; +} + + +/* Set the value being stored in an atomic store. */ + +static inline void +gimple_omp_atomic_store_set_val (gimple g, tree val) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); + g->gimple_omp_atomic_store.val = val; +} + + +/* Return the value being stored in an atomic store. */ + +static inline tree +gimple_omp_atomic_store_val (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); + return g->gimple_omp_atomic_store.val; +} + + +/* Return a pointer to the value being stored in an atomic store. */ + +static inline tree * +gimple_omp_atomic_store_val_ptr (gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); + return &g->gimple_omp_atomic_store.val; +} + + +/* Set the LHS of an atomic load. */ + +static inline void +gimple_omp_atomic_load_set_lhs (gimple g, tree lhs) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD); + g->gimple_omp_atomic_load.lhs = lhs; +} + + +/* Get the LHS of an atomic load. */ + +static inline tree +gimple_omp_atomic_load_lhs (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD); + return g->gimple_omp_atomic_load.lhs; +} + + +/* Return a pointer to the LHS of an atomic load. */ + +static inline tree * +gimple_omp_atomic_load_lhs_ptr (gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD); + return &g->gimple_omp_atomic_load.lhs; +} + + +/* Set the RHS of an atomic load. */ + +static inline void +gimple_omp_atomic_load_set_rhs (gimple g, tree rhs) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD); + g->gimple_omp_atomic_load.rhs = rhs; +} + + +/* Get the RHS of an atomic load. */ + +static inline tree +gimple_omp_atomic_load_rhs (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD); + return g->gimple_omp_atomic_load.rhs; +} + + +/* Return a pointer to the RHS of an atomic load. */ + +static inline tree * +gimple_omp_atomic_load_rhs_ptr (gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD); + return &g->gimple_omp_atomic_load.rhs; +} + + +/* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */ + +static inline tree +gimple_omp_continue_control_def (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE); + return g->gimple_omp_continue.control_def; +} + +/* The same as above, but return the address. */ + +static inline tree * +gimple_omp_continue_control_def_ptr (gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE); + return &g->gimple_omp_continue.control_def; +} + +/* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */ + +static inline void +gimple_omp_continue_set_control_def (gimple g, tree def) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE); + g->gimple_omp_continue.control_def = def; +} + + +/* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */ + +static inline tree +gimple_omp_continue_control_use (const_gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE); + return g->gimple_omp_continue.control_use; +} + + +/* The same as above, but return the address. */ + +static inline tree * +gimple_omp_continue_control_use_ptr (gimple g) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE); + return &g->gimple_omp_continue.control_use; +} + + +/* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */ + +static inline void +gimple_omp_continue_set_control_use (gimple g, tree use) +{ + GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE); + g->gimple_omp_continue.control_use = use; +} + + +/* Return a pointer to the return value for GIMPLE_RETURN GS. */ + +static inline tree * +gimple_return_retval_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_RETURN); + return gimple_op_ptr (gs, 0); +} + +/* Return the return value for GIMPLE_RETURN GS. */ + +static inline tree +gimple_return_retval (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_RETURN); + return gimple_op (gs, 0); +} + + +/* Set RETVAL to be the return value for GIMPLE_RETURN GS. */ + +static inline void +gimple_return_set_retval (gimple gs, tree retval) +{ + GIMPLE_CHECK (gs, GIMPLE_RETURN); + gimple_set_op (gs, 0, retval); +} + + +/* Returns true when the gimple statment STMT is any of the OpenMP types. */ + +#define CASE_GIMPLE_OMP \ + case GIMPLE_OMP_PARALLEL: \ + case GIMPLE_OMP_TASK: \ + case GIMPLE_OMP_FOR: \ + case GIMPLE_OMP_SECTIONS: \ + case GIMPLE_OMP_SECTIONS_SWITCH: \ + case GIMPLE_OMP_SINGLE: \ + case GIMPLE_OMP_SECTION: \ + case GIMPLE_OMP_MASTER: \ + case GIMPLE_OMP_ORDERED: \ + case GIMPLE_OMP_CRITICAL: \ + case GIMPLE_OMP_RETURN: \ + case GIMPLE_OMP_ATOMIC_LOAD: \ + case GIMPLE_OMP_ATOMIC_STORE: \ + case GIMPLE_OMP_CONTINUE + +static inline bool +is_gimple_omp (const_gimple stmt) +{ + switch (gimple_code (stmt)) + { + CASE_GIMPLE_OMP: + return true; + default: + return false; + } +} + + +/* Returns TRUE if statement G is a GIMPLE_NOP. */ + +static inline bool +gimple_nop_p (const_gimple g) +{ + return gimple_code (g) == GIMPLE_NOP; +} + + +/* Return true if GS is a GIMPLE_RESX. */ + +static inline bool +is_gimple_resx (const_gimple gs) +{ + return gimple_code (gs) == GIMPLE_RESX; +} + +/* Return the predictor of GIMPLE_PREDICT statement GS. */ + +static inline enum br_predictor +gimple_predict_predictor (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_PREDICT); + return (enum br_predictor) (gs->gsbase.subcode & ~GF_PREDICT_TAKEN); +} + + +/* Set the predictor of GIMPLE_PREDICT statement GS to PREDICT. */ + +static inline void +gimple_predict_set_predictor (gimple gs, enum br_predictor predictor) +{ + GIMPLE_CHECK (gs, GIMPLE_PREDICT); + gs->gsbase.subcode = (gs->gsbase.subcode & GF_PREDICT_TAKEN) + | (unsigned) predictor; +} + + +/* Return the outcome of GIMPLE_PREDICT statement GS. */ + +static inline enum prediction +gimple_predict_outcome (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_PREDICT); + return (gs->gsbase.subcode & GF_PREDICT_TAKEN) ? TAKEN : NOT_TAKEN; +} + + +/* Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME. */ + +static inline void +gimple_predict_set_outcome (gimple gs, enum prediction outcome) +{ + GIMPLE_CHECK (gs, GIMPLE_PREDICT); + if (outcome == TAKEN) + gs->gsbase.subcode |= GF_PREDICT_TAKEN; + else + gs->gsbase.subcode &= ~GF_PREDICT_TAKEN; +} + + +/* Return the type of the main expression computed by STMT. Return + void_type_node if the statement computes nothing. */ + +static inline tree +gimple_expr_type (const_gimple stmt) +{ + enum gimple_code code = gimple_code (stmt); + + if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL) + { + tree type; + /* In general we want to pass out a type that can be substituted + for both the RHS and the LHS types if there is a possibly + useless conversion involved. That means returning the + original RHS type as far as we can reconstruct it. */ + if (code == GIMPLE_CALL) + type = gimple_call_return_type (stmt); + else + switch (gimple_assign_rhs_code (stmt)) + { + case POINTER_PLUS_EXPR: + type = TREE_TYPE (gimple_assign_rhs1 (stmt)); + break; + + default: + /* As fallback use the type of the LHS. */ + type = TREE_TYPE (gimple_get_lhs (stmt)); + break; + } + return type; + } + else if (code == GIMPLE_COND) + return boolean_type_node; + else + return void_type_node; +} + + +/* Return a new iterator pointing to GIMPLE_SEQ's first statement. */ + +static inline gimple_stmt_iterator +gsi_start (gimple_seq seq) +{ + gimple_stmt_iterator i; + + i.ptr = gimple_seq_first (seq); + i.seq = seq; + i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL; + + return i; +} + + +/* Return a new iterator pointing to the first statement in basic block BB. */ + +static inline gimple_stmt_iterator +gsi_start_bb (basic_block bb) +{ + gimple_stmt_iterator i; + gimple_seq seq; + + seq = bb_seq (bb); + i.ptr = gimple_seq_first (seq); + i.seq = seq; + i.bb = bb; + + return i; +} + + +/* Return a new iterator initially pointing to GIMPLE_SEQ's last statement. */ + +static inline gimple_stmt_iterator +gsi_last (gimple_seq seq) +{ + gimple_stmt_iterator i; + + i.ptr = gimple_seq_last (seq); + i.seq = seq; + i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL; + + return i; +} + + +/* Return a new iterator pointing to the last statement in basic block BB. */ + +static inline gimple_stmt_iterator +gsi_last_bb (basic_block bb) +{ + gimple_stmt_iterator i; + gimple_seq seq; + + seq = bb_seq (bb); + i.ptr = gimple_seq_last (seq); + i.seq = seq; + i.bb = bb; + + return i; +} + + +/* Return true if I is at the end of its sequence. */ + +static inline bool +gsi_end_p (gimple_stmt_iterator i) +{ + return i.ptr == NULL; +} + + +/* Return true if I is one statement before the end of its sequence. */ + +static inline bool +gsi_one_before_end_p (gimple_stmt_iterator i) +{ + return i.ptr != NULL && i.ptr->next == NULL; +} + + +/* Advance the iterator to the next gimple statement. */ + +static inline void +gsi_next (gimple_stmt_iterator *i) +{ + i->ptr = i->ptr->next; +} + +/* Advance the iterator to the previous gimple statement. */ + +static inline void +gsi_prev (gimple_stmt_iterator *i) +{ + i->ptr = i->ptr->prev; +} + +/* Return the current stmt. */ + +static inline gimple +gsi_stmt (gimple_stmt_iterator i) +{ + return i.ptr->stmt; +} + +/* Return a block statement iterator that points to the first non-label + statement in block BB. */ + +static inline gimple_stmt_iterator +gsi_after_labels (basic_block bb) +{ + gimple_stmt_iterator gsi = gsi_start_bb (bb); + + while (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL) + gsi_next (&gsi); + + return gsi; +} + +/* Advance the iterator to the next non-debug gimple statement. */ + +static inline void +gsi_next_nondebug (gimple_stmt_iterator *i) +{ + do + { + gsi_next (i); + } + while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i))); +} + +/* Advance the iterator to the next non-debug gimple statement. */ + +static inline void +gsi_prev_nondebug (gimple_stmt_iterator *i) +{ + do + { + gsi_prev (i); + } + while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i))); +} + +/* Return a new iterator pointing to the first non-debug statement in + basic block BB. */ + +static inline gimple_stmt_iterator +gsi_start_nondebug_bb (basic_block bb) +{ + gimple_stmt_iterator i = gsi_start_bb (bb); + + if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) + gsi_next_nondebug (&i); + + return i; +} + +/* Return a new iterator pointing to the last non-debug statement in + basic block BB. */ + +static inline gimple_stmt_iterator +gsi_last_nondebug_bb (basic_block bb) +{ + gimple_stmt_iterator i = gsi_last_bb (bb); + + if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) + gsi_prev_nondebug (&i); + + return i; +} + +/* Return a pointer to the current stmt. + + NOTE: You may want to use gsi_replace on the iterator itself, + as this performs additional bookkeeping that will not be done + if you simply assign through a pointer returned by gsi_stmt_ptr. */ + +static inline gimple * +gsi_stmt_ptr (gimple_stmt_iterator *i) +{ + return &i->ptr->stmt; +} + + +/* Return the basic block associated with this iterator. */ + +static inline basic_block +gsi_bb (gimple_stmt_iterator i) +{ + return i.bb; +} + + +/* Return the sequence associated with this iterator. */ + +static inline gimple_seq +gsi_seq (gimple_stmt_iterator i) +{ + return i.seq; +} + + +enum gsi_iterator_update +{ + GSI_NEW_STMT, /* Only valid when single statement is added, move + iterator to it. */ + GSI_SAME_STMT, /* Leave the iterator at the same statement. */ + GSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable + for linking other statements in the same + direction. */ +}; + +/* In gimple-iterator.c */ +gimple_stmt_iterator gsi_start_phis (basic_block); +gimple_seq gsi_split_seq_after (gimple_stmt_iterator); +gimple_seq gsi_split_seq_before (gimple_stmt_iterator *); +void gsi_replace (gimple_stmt_iterator *, gimple, bool); +void gsi_insert_before (gimple_stmt_iterator *, gimple, + enum gsi_iterator_update); +void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple, + enum gsi_iterator_update); +void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq, + enum gsi_iterator_update); +void gsi_insert_seq_before_without_update (gimple_stmt_iterator *, gimple_seq, + enum gsi_iterator_update); +void gsi_insert_after (gimple_stmt_iterator *, gimple, + enum gsi_iterator_update); +void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple, + enum gsi_iterator_update); +void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq, + enum gsi_iterator_update); +void gsi_insert_seq_after_without_update (gimple_stmt_iterator *, gimple_seq, + enum gsi_iterator_update); +void gsi_remove (gimple_stmt_iterator *, bool); +gimple_stmt_iterator gsi_for_stmt (gimple); +void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *); +void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *); +void gsi_move_to_bb_end (gimple_stmt_iterator *, struct basic_block_def *); +void gsi_insert_on_edge (edge, gimple); +void gsi_insert_seq_on_edge (edge, gimple_seq); +basic_block gsi_insert_on_edge_immediate (edge, gimple); +basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq); +void gsi_commit_one_edge_insert (edge, basic_block *); +void gsi_commit_edge_inserts (void); +gimple gimple_call_copy_skip_args (gimple, bitmap); + + +/* Convenience routines to walk all statements of a gimple function. + Note that this is useful exclusively before the code is converted + into SSA form. Once the program is in SSA form, the standard + operand interface should be used to analyze/modify statements. */ +struct walk_stmt_info +{ + /* Points to the current statement being walked. */ + gimple_stmt_iterator gsi; + + /* Additional data that the callback functions may want to carry + through the recursion. */ + void *info; + + /* Pointer map used to mark visited tree nodes when calling + walk_tree on each operand. If set to NULL, duplicate tree nodes + will be visited more than once. */ + struct pointer_set_t *pset; + + /* Indicates whether the operand being examined may be replaced + with something that matches is_gimple_val (if true) or something + slightly more complicated (if false). "Something" technically + means the common subset of is_gimple_lvalue and is_gimple_rhs, + but we never try to form anything more complicated than that, so + we don't bother checking. + + Also note that CALLBACK should update this flag while walking the + sub-expressions of a statement. For instance, when walking the + statement 'foo (&var)', the flag VAL_ONLY will initially be set + to true, however, when walking &var, the operand of that + ADDR_EXPR does not need to be a GIMPLE value. */ + bool val_only; + + /* True if we are currently walking the LHS of an assignment. */ + bool is_lhs; + + /* Optional. Set to true by the callback functions if they made any + changes. */ + bool changed; + + /* True if we're interested in location information. */ + bool want_locations; + + /* Operand returned by the callbacks. This is set when calling + walk_gimple_seq. If the walk_stmt_fn or walk_tree_fn callback + returns non-NULL, this field will contain the tree returned by + the last callback. */ + tree callback_result; +}; + +/* Callback for walk_gimple_stmt. Called for every statement found + during traversal. The first argument points to the statement to + walk. The second argument is a flag that the callback sets to + 'true' if it the callback handled all the operands and + sub-statements of the statement (the default value of this flag is + 'false'). The third argument is an anonymous pointer to data + to be used by the callback. */ +typedef tree (*walk_stmt_fn) (gimple_stmt_iterator *, bool *, + struct walk_stmt_info *); + +gimple walk_gimple_seq (gimple_seq, walk_stmt_fn, walk_tree_fn, + struct walk_stmt_info *); +tree walk_gimple_stmt (gimple_stmt_iterator *, walk_stmt_fn, walk_tree_fn, + struct walk_stmt_info *); +tree walk_gimple_op (gimple, walk_tree_fn, struct walk_stmt_info *); + +#ifdef GATHER_STATISTICS +/* Enum and arrays used for allocation stats. Keep in sync with + gimple.c:gimple_alloc_kind_names. */ +enum gimple_alloc_kind +{ + gimple_alloc_kind_assign, /* Assignments. */ + gimple_alloc_kind_phi, /* PHI nodes. */ + gimple_alloc_kind_cond, /* Conditionals. */ + gimple_alloc_kind_seq, /* Sequences. */ + gimple_alloc_kind_rest, /* Everything else. */ + gimple_alloc_kind_all +}; + +extern int gimple_alloc_counts[]; +extern int gimple_alloc_sizes[]; + +/* Return the allocation kind for a given stmt CODE. */ +static inline enum gimple_alloc_kind +gimple_alloc_kind (enum gimple_code code) +{ + switch (code) + { + case GIMPLE_ASSIGN: + return gimple_alloc_kind_assign; + case GIMPLE_PHI: + return gimple_alloc_kind_phi; + case GIMPLE_COND: + return gimple_alloc_kind_cond; + default: + return gimple_alloc_kind_rest; + } +} +#endif /* GATHER_STATISTICS */ + +extern void dump_gimple_statistics (void); + +/* In gimple-fold.c. */ +void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree); +tree gimple_fold_builtin (gimple); +bool fold_stmt (gimple_stmt_iterator *); +bool fold_stmt_inplace (gimple); +tree maybe_fold_offset_to_address (location_t, tree, tree, tree); +tree maybe_fold_offset_to_reference (location_t, tree, tree, tree); +tree maybe_fold_stmt_addition (location_t, tree, tree, tree); +tree get_symbol_constant_value (tree); +tree canonicalize_constructor_val (tree); +bool may_propagate_address_into_dereference (tree, tree); +extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree, + enum tree_code, tree, tree); +extern tree maybe_fold_or_comparisons (enum tree_code, tree, tree, + enum tree_code, tree, tree); + +#endif /* GCC_GIMPLE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gsstruct.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gsstruct.def new file mode 100644 index 0000000..0b6531e --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gsstruct.def @@ -0,0 +1,51 @@ +/* This file contains the definitions for the gimple IR structure + enumeration used in GCC. + + Copyright (C) 2007, 2008, 2010 Free Software Foundation, Inc. + Contributed by Aldy Hernandez <aldyh@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* The format of this file is + DEFGSSTRUCT(GSS enumeration value, structure name, has-tree-operands). + Each enum value should correspond with a single member of the union + gimple_statement_d. */ + +DEFGSSTRUCT(GSS_BASE, gimple_statement_base, false) +DEFGSSTRUCT(GSS_WITH_OPS, gimple_statement_with_ops, true) +DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_statement_with_memory_ops_base, false) +DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_statement_with_memory_ops, true) +DEFGSSTRUCT(GSS_CALL, gimple_statement_call, true) +DEFGSSTRUCT(GSS_ASM, gimple_statement_asm, true) +DEFGSSTRUCT(GSS_BIND, gimple_statement_bind, false) +DEFGSSTRUCT(GSS_PHI, gimple_statement_phi, false) +DEFGSSTRUCT(GSS_TRY, gimple_statement_try, false) +DEFGSSTRUCT(GSS_CATCH, gimple_statement_catch, false) +DEFGSSTRUCT(GSS_EH_FILTER, gimple_statement_eh_filter, false) +DEFGSSTRUCT(GSS_EH_MNT, gimple_statement_eh_mnt, false) +DEFGSSTRUCT(GSS_EH_CTRL, gimple_statement_eh_ctrl, false) +DEFGSSTRUCT(GSS_WCE, gimple_statement_wce, false) +DEFGSSTRUCT(GSS_OMP, gimple_statement_omp, false) +DEFGSSTRUCT(GSS_OMP_CRITICAL, gimple_statement_omp_critical, false) +DEFGSSTRUCT(GSS_OMP_FOR, gimple_statement_omp_for, false) +DEFGSSTRUCT(GSS_OMP_PARALLEL, gimple_statement_omp_parallel, false) +DEFGSSTRUCT(GSS_OMP_TASK, gimple_statement_omp_task, false) +DEFGSSTRUCT(GSS_OMP_SECTIONS, gimple_statement_omp_sections, false) +DEFGSSTRUCT(GSS_OMP_SINGLE, gimple_statement_omp_single, false) +DEFGSSTRUCT(GSS_OMP_CONTINUE, gimple_statement_omp_continue, false) +DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gimple_statement_omp_atomic_load, false) +DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE, gimple_statement_omp_atomic_store, false) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gtype-desc.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gtype-desc.h new file mode 100644 index 0000000..ff6d7f3 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/gtype-desc.h @@ -0,0 +1,8658 @@ +/* Type information for GCC. + Copyright (C) 2004, 2007, 2009 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/>. */ + +/* This file is machine generated. Do not edit. */ + +/* Enumeration of types known. */ +enum gt_types_enum { + gt_ggc_e_24lazy_hex_fp_value_struct, + gt_ggc_e_22VEC_c_saved_builtin_gc, + gt_ggc_e_24VEC_c_saved_builtin_base, + gt_ggc_e_15c_inline_static, + gt_ggc_e_24VEC_c_goto_bindings_p_gc, + gt_ggc_e_26VEC_c_goto_bindings_p_base, + gt_ggc_e_15c_goto_bindings, + gt_ggc_e_7c_scope, + gt_ggc_e_9c_binding, + gt_ggc_e_12c_label_vars, + gt_ggc_e_15c_spot_bindings, + gt_ggc_e_8c_parser, + gt_ggc_e_7c_token, + gt_ggc_e_20VEC_ivarref_entry_gc, + gt_ggc_e_22VEC_ivarref_entry_base, + gt_ggc_e_13ivarref_entry, + gt_ggc_e_22VEC_prot_list_entry_gc, + gt_ggc_e_24VEC_prot_list_entry_base, + gt_ggc_e_15prot_list_entry, + gt_ggc_e_19VEC_msgref_entry_gc, + gt_ggc_e_21VEC_msgref_entry_base, + gt_ggc_e_12msgref_entry, + gt_ggc_e_23VEC_ident_data_tuple_gc, + gt_ggc_e_25VEC_ident_data_tuple_base, + gt_ggc_e_16ident_data_tuple, + gt_ggc_e_15interface_tuple, + gt_ggc_e_17string_descriptor, + gt_ggc_e_9imp_entry, + gt_ggc_e_16hashed_attribute, + gt_ggc_e_12hashed_entry, + gt_ggc_e_23VEC_ltrans_partition_gc, + gt_ggc_e_25VEC_ltrans_partition_base, + gt_ggc_e_20ltrans_partition_def, + gt_ggc_e_14builtin_record, + gt_ggc_e_14string_or_tree, + gt_ggc_e_11cpool_entry, + gt_ggc_e_19VEC_method_entry_gc, + gt_ggc_e_21VEC_method_entry_base, + gt_ggc_e_14method_entry_d, + gt_ggc_e_13lang_decl_var, + gt_ggc_e_14type_assertion, + gt_ggc_e_14lang_decl_func, + gt_ggc_e_18treetreehash_entry, + gt_ggc_e_5CPool, + gt_ggc_e_3JCF, + gt_ggc_e_16gfc_powdecl_list, + gt_ggc_e_16gfc_st_parameter, + gt_ggc_e_22gfc_st_parameter_field, + gt_ggc_e_19gfc_intrinsic_map_t, + gt_ggc_e_17module_htab_entry, + gt_ggc_e_13binding_level, + gt_ggc_e_20VEC_saved_builtin_gc, + gt_ggc_e_22VEC_saved_builtin_base, + gt_ggc_e_2sb, + gt_ggc_e_9opt_stack, + gt_ggc_e_27VEC_pending_redefinition_gc, + gt_ggc_e_29VEC_pending_redefinition_base, + gt_ggc_e_22pending_redefinition_d, + gt_ggc_e_19VEC_pending_weak_gc, + gt_ggc_e_21VEC_pending_weak_base, + gt_ggc_e_14pending_weak_d, + gt_ggc_e_11align_stack, + gt_ggc_e_18VEC_tree_gc_vec_gc, + gt_ggc_e_20VEC_tree_gc_vec_base, + gt_ggc_e_19VEC_const_char_p_gc, + gt_ggc_e_21VEC_const_char_p_base, + gt_ggc_e_21pending_abstract_type, + gt_ggc_e_15VEC_tree_int_gc, + gt_ggc_e_17VEC_tree_int_base, + gt_ggc_e_8tree_int, + gt_ggc_e_9cp_parser, + gt_ggc_e_34VEC_cp_unparsed_functions_entry_gc, + gt_ggc_e_36VEC_cp_unparsed_functions_entry_base, + gt_ggc_e_29cp_unparsed_functions_entry_d, + gt_ggc_e_27VEC_cp_default_arg_entry_gc, + gt_ggc_e_29VEC_cp_default_arg_entry_base, + gt_ggc_e_22cp_default_arg_entry_d, + gt_ggc_e_17cp_parser_context, + gt_ggc_e_8cp_lexer, + gt_ggc_e_8cp_token, + gt_ggc_e_14cp_token_value, + gt_ggc_e_10tree_check, + gt_ggc_e_14constexpr_call, + gt_ggc_e_16constexpr_fundef, + gt_ggc_e_22VEC_deferred_access_gc, + gt_ggc_e_24VEC_deferred_access_base, + gt_ggc_e_15deferred_access, + gt_ggc_e_10spec_entry, + gt_ggc_e_26VEC_pending_attribute_p_gc, + gt_ggc_e_28VEC_pending_attribute_p_base, + gt_ggc_e_17pending_attribute, + gt_ggc_e_16pending_template, + gt_ggc_e_21VEC_incomplete_var_gc, + gt_ggc_e_23VEC_incomplete_var_base, + gt_ggc_e_16incomplete_var_d, + gt_ggc_e_21named_label_use_entry, + gt_ggc_e_28VEC_deferred_access_check_gc, + gt_ggc_e_30VEC_deferred_access_check_base, + gt_ggc_e_21deferred_access_check, + gt_ggc_e_20operator_name_info_t, + gt_ggc_e_11lang_decl_u, + gt_ggc_e_14lang_decl_parm, + gt_ggc_e_12lang_decl_ns, + gt_ggc_e_12lang_decl_fn, + gt_ggc_e_12lang_decl_u3, + gt_ggc_e_12lang_decl_u5, + gt_ggc_e_13lang_decl_min, + gt_ggc_e_12lang_decl_u2, + gt_ggc_e_14lang_decl_base, + gt_ggc_e_11lang_type_u, + gt_ggc_e_16lang_type_ptrmem, + gt_ggc_e_15lang_type_class, + gt_ggc_e_18sorted_fields_type, + gt_ggc_e_16lang_type_header, + gt_ggc_e_18VEC_tree_pair_s_gc, + gt_ggc_e_20VEC_tree_pair_s_base, + gt_ggc_e_11tree_pair_s, + gt_ggc_e_17named_label_entry, + gt_ggc_e_19c_language_function, + gt_ggc_e_11stmt_tree_s, + gt_ggc_e_18tree_template_info, + gt_ggc_e_32VEC_qualified_typedef_usage_t_gc, + gt_ggc_e_34VEC_qualified_typedef_usage_t_base, + gt_ggc_e_25qualified_typedef_usage_s, + gt_ggc_e_16tree_lambda_expr, + gt_ggc_e_15tree_trait_expr, + gt_ggc_e_25tree_argument_pack_select, + gt_ggc_e_18tree_static_assert, + gt_ggc_e_16tree_default_arg, + gt_ggc_e_14cp_token_cache, + gt_ggc_e_13tree_baselink, + gt_ggc_e_13tree_overload, + gt_ggc_e_10ptrmem_cst, + gt_ggc_e_21template_parm_index_s, + gt_ggc_e_15lang_identifier, + gt_ggc_e_19c_common_identifier, + gt_ggc_e_11saved_scope, + gt_ggc_e_16cxx_int_tree_map, + gt_ggc_e_23VEC_cp_label_binding_gc, + gt_ggc_e_25VEC_cp_label_binding_base, + gt_ggc_e_16cp_label_binding, + gt_ggc_e_23VEC_cp_class_binding_gc, + gt_ggc_e_25VEC_cp_class_binding_base, + gt_ggc_e_16cp_class_binding, + gt_ggc_e_24VEC_cxx_saved_binding_gc, + gt_ggc_e_26VEC_cxx_saved_binding_base, + gt_ggc_e_17cxx_saved_binding, + gt_ggc_e_16cp_binding_level, + gt_ggc_e_11cxx_binding, + gt_ggc_e_15binding_entry_s, + gt_ggc_e_15binding_table_s, + gt_ggc_e_11tinst_level, + gt_ggc_e_7globals, + gt_ggc_e_14VEC_tinfo_s_gc, + gt_ggc_e_16VEC_tinfo_s_base, + gt_ggc_e_7tinfo_s, + gt_ggc_e_18gnat_binding_level, + gt_ggc_e_9elab_info, + gt_ggc_e_10stmt_group, + gt_ggc_e_16VEC_parm_attr_gc, + gt_ggc_e_18VEC_parm_attr_base, + gt_ggc_e_11parm_attr_d, + gt_ggc_e_18lto_tree_ref_table, + gt_ggc_e_17lto_in_decl_state, + gt_ggc_e_22VEC_ipa_edge_args_t_gc, + gt_ggc_e_24VEC_ipa_edge_args_t_base, + gt_ggc_e_15jump_func_value, + gt_ggc_e_18ipa_member_ptr_cst, + gt_ggc_e_20ipa_ancestor_jf_data, + gt_ggc_e_21ipa_pass_through_data, + gt_ggc_e_20lto_symtab_entry_def, + gt_ggc_e_11heapvar_map, + gt_ggc_e_20ssa_operand_memory_d, + gt_ggc_e_13scev_info_str, + gt_ggc_e_24VEC_mem_addr_template_gc, + gt_ggc_e_26VEC_mem_addr_template_base, + gt_ggc_e_17mem_addr_template, + gt_ggc_e_12ssa_operands, + gt_ggc_e_26gimple_type_leader_entry_s, + gt_ggc_e_33gimple_statement_omp_atomic_store, + gt_ggc_e_32gimple_statement_omp_atomic_load, + gt_ggc_e_27gimple_statement_omp_single, + gt_ggc_e_29gimple_statement_omp_continue, + gt_ggc_e_29gimple_statement_omp_sections, + gt_ggc_e_25gimple_statement_omp_task, + gt_ggc_e_29gimple_statement_omp_parallel, + gt_ggc_e_24gimple_statement_omp_for, + gt_ggc_e_19gimple_omp_for_iter, + gt_ggc_e_29gimple_statement_omp_critical, + gt_ggc_e_20gimple_statement_asm, + gt_ggc_e_20gimple_statement_wce, + gt_ggc_e_20gimple_statement_try, + gt_ggc_e_24gimple_statement_eh_ctrl, + gt_ggc_e_20gimple_statement_phi, + gt_ggc_e_23gimple_statement_eh_mnt, + gt_ggc_e_26gimple_statement_eh_filter, + gt_ggc_e_22gimple_statement_catch, + gt_ggc_e_21gimple_statement_bind, + gt_ggc_e_20gimple_statement_omp, + gt_ggc_e_21gimple_statement_call, + gt_ggc_e_11pt_solution, + gt_ggc_e_32gimple_statement_with_memory_ops, + gt_ggc_e_37gimple_statement_with_memory_ops_base, + gt_ggc_e_25gimple_statement_with_ops, + gt_ggc_e_30gimple_statement_with_ops_base, + gt_ggc_e_21gimple_statement_base, + gt_ggc_e_17gimple_seq_node_d, + gt_ggc_e_9type_hash, + gt_ggc_e_16string_pool_data, + gt_ggc_e_18initial_value_pair, + gt_ggc_e_23temp_slot_address_entry, + gt_ggc_e_11eh_status_u, + gt_ggc_e_15throw_stmt_node, + gt_ggc_e_21VEC_eh_landing_pad_gc, + gt_ggc_e_23VEC_eh_landing_pad_base, + gt_ggc_e_16VEC_eh_region_gc, + gt_ggc_e_18VEC_eh_region_base, + gt_ggc_e_11eh_region_u, + gt_ggc_e_26eh_region_u_must_not_throw, + gt_ggc_e_19eh_region_u_allowed, + gt_ggc_e_15eh_region_u_try, + gt_ggc_e_10eh_catch_d, + gt_ggc_e_16eh_landing_pad_d, + gt_ggc_e_11eh_region_d, + gt_ggc_e_8type_ent, + gt_ggc_e_18saved_module_scope, + gt_ggc_e_10vcall_insn, + gt_ggc_e_18VEC_vcall_entry_gc, + gt_ggc_e_20VEC_vcall_entry_base, + gt_ggc_e_12vcall_struct, + gt_ggc_e_18VEC_dcall_entry_gc, + gt_ggc_e_20VEC_dcall_entry_base, + gt_ggc_e_12dcall_struct, + gt_ggc_e_22cached_dw_loc_list_def, + gt_ggc_e_16var_loc_list_def, + gt_ggc_e_12var_loc_node, + gt_ggc_e_20VEC_die_arg_entry_gc, + gt_ggc_e_22VEC_die_arg_entry_base, + gt_ggc_e_20die_arg_entry_struct, + gt_ggc_e_16limbo_die_struct, + gt_ggc_e_20VEC_macinfo_entry_gc, + gt_ggc_e_22VEC_macinfo_entry_base, + gt_ggc_e_14macinfo_struct, + gt_ggc_e_20VEC_pubname_entry_gc, + gt_ggc_e_22VEC_pubname_entry_base, + gt_ggc_e_23die_symbol_or_type_node, + gt_ggc_e_19VEC_dw_attr_node_gc, + gt_ggc_e_21VEC_dw_attr_node_base, + gt_ggc_e_18comdat_type_struct, + gt_ggc_e_25dw_ranges_by_label_struct, + gt_ggc_e_16dw_ranges_struct, + gt_ggc_e_14pubname_struct, + gt_ggc_e_28dw_separate_line_info_struct, + gt_ggc_e_19dw_line_info_struct, + gt_ggc_e_14dw_attr_struct, + gt_ggc_e_19dw_val_struct_union, + gt_ggc_e_22dw_val_vms_delta_union, + gt_ggc_e_16dw_val_die_union, + gt_ggc_e_13dw_vec_struct, + gt_ggc_e_25VEC_deferred_locations_gc, + gt_ggc_e_27VEC_deferred_locations_base, + gt_ggc_e_25deferred_locations_struct, + gt_ggc_e_18dw_loc_list_struct, + gt_ggc_e_13dw_val_struct, + gt_ggc_e_15dwarf_file_data, + gt_ggc_e_17reg_saved_in_data, + gt_ggc_e_15queued_reg_save, + gt_ggc_e_20indirect_string_node, + gt_ggc_e_19dw_loc_descr_struct, + gt_ggc_e_19dw_cfi_oprnd_struct, + gt_ggc_e_13dw_fde_struct, + gt_ggc_e_13dw_cfi_struct, + gt_ggc_e_8typeinfo, + gt_ggc_e_13ipa_edge_args, + gt_ggc_e_13ipa_jump_func, + gt_ggc_e_22VEC_alias_set_entry_gc, + gt_ggc_e_24VEC_alias_set_entry_base, + gt_ggc_e_17alias_set_entry_d, + gt_ggc_e_24constant_descriptor_tree, + gt_ggc_e_10cgraph_sym, + gt_ggc_e_15cgraph_mod_info, + gt_ggc_e_15cgraph_asm_node, + gt_ggc_e_25cgraph_indirect_call_info, + gt_ggc_e_20varpool_node_set_def, + gt_ggc_e_28varpool_node_set_element_def, + gt_ggc_e_23VEC_varpool_node_ptr_gc, + gt_ggc_e_25VEC_varpool_node_ptr_base, + gt_ggc_e_19cgraph_node_set_def, + gt_ggc_e_27cgraph_node_set_element_def, + gt_ggc_e_22VEC_cgraph_node_ptr_gc, + gt_ggc_e_24VEC_cgraph_node_ptr_base, + gt_ggc_e_11cgraph_edge, + gt_ggc_e_17cgraph_clone_info, + gt_ggc_e_24VEC_ipa_replace_map_p_gc, + gt_ggc_e_26VEC_ipa_replace_map_p_base, + gt_ggc_e_15ipa_replace_map, + gt_ggc_e_15cgraph_rtl_info, + gt_ggc_e_18cgraph_global_info, + gt_ggc_e_17cgraph_local_info, + gt_ggc_e_17cgraph_thunk_info, + gt_ggc_e_14inline_summary, + gt_ggc_e_18lto_file_decl_data, + gt_ggc_e_12ipa_ref_list, + gt_ggc_e_16VEC_ipa_ref_t_gc, + gt_ggc_e_18VEC_ipa_ref_t_base, + gt_ggc_e_7ipa_ref, + gt_ggc_e_13ipa_ref_ptr_u, + gt_ggc_e_12varpool_node, + gt_ggc_e_11cgraph_node, + gt_ggc_e_18VEC_basic_block_gc, + gt_ggc_e_20VEC_basic_block_base, + gt_ggc_e_24basic_block_il_dependent, + gt_ggc_e_14gimple_bb_info, + gt_ggc_e_11rtl_bb_info, + gt_ggc_e_11VEC_edge_gc, + gt_ggc_e_13VEC_edge_base, + gt_ggc_e_14edge_def_insns, + gt_ggc_e_13VEC_loop_p_gc, + gt_ggc_e_15VEC_loop_p_base, + gt_ggc_e_4loop, + gt_ggc_e_9loop_exit, + gt_ggc_e_13nb_iter_bound, + gt_ggc_e_12lpt_decision, + gt_ggc_e_16noswitch_section, + gt_ggc_e_15unnamed_section, + gt_ggc_e_13named_section, + gt_ggc_e_14section_common, + gt_ggc_e_24types_used_by_vars_entry, + gt_ggc_e_17language_function, + gt_ggc_e_5loops, + gt_ggc_e_18control_flow_graph, + gt_ggc_e_9eh_status, + gt_ggc_e_11stack_usage, + gt_ggc_e_8rtl_data, + gt_ggc_e_20initial_value_struct, + gt_ggc_e_11frame_space, + gt_ggc_e_20function_subsections, + gt_ggc_e_13incoming_args, + gt_ggc_e_13varasm_status, + gt_ggc_e_17rtx_constant_pool, + gt_ggc_e_18VEC_temp_slot_p_gc, + gt_ggc_e_20VEC_temp_slot_p_base, + gt_ggc_e_9temp_slot, + gt_ggc_e_9gimple_df, + gt_ggc_e_6rtl_eh, + gt_ggc_e_23VEC_call_site_record_gc, + gt_ggc_e_25VEC_call_site_record_base, + gt_ggc_e_18call_site_record_d, + gt_ggc_e_11expr_status, + gt_ggc_e_11emit_status, + gt_ggc_e_14sequence_stack, + gt_ggc_e_15target_libfuncs, + gt_ggc_e_13libfunc_entry, + gt_ggc_e_17tree_priority_map, + gt_ggc_e_12tree_int_map, + gt_ggc_e_13tree_decl_map, + gt_ggc_e_8tree_map, + gt_ggc_e_13tree_map_base, + gt_ggc_e_14lang_tree_node, + gt_ggc_e_18tree_target_option, + gt_ggc_e_24tree_optimization_option, + gt_ggc_e_19tree_statement_list, + gt_ggc_e_24tree_statement_list_node, + gt_ggc_e_14tree_type_decl, + gt_ggc_e_26tree_translation_unit_decl, + gt_ggc_e_18tree_function_decl, + gt_ggc_e_20tree_decl_non_common, + gt_ggc_e_13tree_var_decl, + gt_ggc_e_18tree_decl_with_vis, + gt_ggc_e_14tree_parm_decl, + gt_ggc_e_15tree_const_decl, + gt_ggc_e_16tree_result_decl, + gt_ggc_e_9var_ann_d, + gt_ggc_e_15tree_label_decl, + gt_ggc_e_15tree_field_decl, + gt_ggc_e_18tree_decl_with_rtl, + gt_ggc_e_16tree_decl_common, + gt_ggc_e_9lang_decl, + gt_ggc_e_17tree_decl_minimal, + gt_ggc_e_10tree_binfo, + gt_ggc_e_9tree_type, + gt_ggc_e_9lang_type, + gt_ggc_e_16tree_type_symtab, + gt_ggc_e_10die_struct, + gt_ggc_e_10tree_block, + gt_ggc_e_15tree_omp_clause, + gt_ggc_e_9phi_arg_d, + gt_ggc_e_13tree_ssa_name, + gt_ggc_e_17ssa_use_operand_d, + gt_ggc_e_12ptr_info_def, + gt_ggc_e_8tree_exp, + gt_ggc_e_17tree_exp_subunion, + gt_ggc_e_16tree_constructor, + gt_ggc_e_22VEC_constructor_elt_gc, + gt_ggc_e_24VEC_constructor_elt_base, + gt_ggc_e_17constructor_elt_d, + gt_ggc_e_8tree_vec, + gt_ggc_e_9tree_list, + gt_ggc_e_15tree_identifier, + gt_ggc_e_11tree_vector, + gt_ggc_e_12tree_complex, + gt_ggc_e_11tree_string, + gt_ggc_e_14tree_fixed_cst, + gt_ggc_e_13tree_real_cst, + gt_ggc_e_12tree_int_cst, + gt_ggc_e_11tree_common, + gt_ggc_e_9tree_base, + gt_ggc_e_17VEC_alias_pair_gc, + gt_ggc_e_19VEC_alias_pair_base, + gt_ggc_e_10alias_pair, + gt_ggc_e_10target_rtl, + gt_ggc_e_8function, + gt_ggc_e_16rtx_def_subunion, + gt_ggc_e_26rtx_def_debug_implicit_ptr, + gt_ggc_e_20rtx_def_var_location, + gt_ggc_e_11rtx_def_fma, + gt_ggc_e_19rtx_def_us_truncate, + gt_ggc_e_19rtx_def_ss_truncate, + gt_ggc_e_16rtx_def_us_minus, + gt_ggc_e_17rtx_def_us_ashift, + gt_ggc_e_17rtx_def_ss_ashift, + gt_ggc_e_14rtx_def_ss_abs, + gt_ggc_e_14rtx_def_us_neg, + gt_ggc_e_14rtx_def_ss_neg, + gt_ggc_e_16rtx_def_ss_minus, + gt_ggc_e_15rtx_def_us_plus, + gt_ggc_e_15rtx_def_ss_plus, + gt_ggc_e_21rtx_def_vec_duplicate, + gt_ggc_e_18rtx_def_vec_concat, + gt_ggc_e_18rtx_def_vec_select, + gt_ggc_e_17rtx_def_vec_merge, + gt_ggc_e_14rtx_def_lo_sum, + gt_ggc_e_12rtx_def_high, + gt_ggc_e_20rtx_def_zero_extract, + gt_ggc_e_20rtx_def_sign_extract, + gt_ggc_e_14rtx_def_parity, + gt_ggc_e_16rtx_def_popcount, + gt_ggc_e_11rtx_def_ctz, + gt_ggc_e_11rtx_def_clz, + gt_ggc_e_11rtx_def_ffs, + gt_ggc_e_13rtx_def_bswap, + gt_ggc_e_12rtx_def_sqrt, + gt_ggc_e_11rtx_def_abs, + gt_ggc_e_26rtx_def_unsigned_sat_fract, + gt_ggc_e_17rtx_def_sat_fract, + gt_ggc_e_30rtx_def_unsigned_fract_convert, + gt_ggc_e_21rtx_def_fract_convert, + gt_ggc_e_20rtx_def_unsigned_fix, + gt_ggc_e_22rtx_def_unsigned_float, + gt_ggc_e_11rtx_def_fix, + gt_ggc_e_13rtx_def_float, + gt_ggc_e_22rtx_def_float_truncate, + gt_ggc_e_20rtx_def_float_extend, + gt_ggc_e_16rtx_def_truncate, + gt_ggc_e_19rtx_def_zero_extend, + gt_ggc_e_19rtx_def_sign_extend, + gt_ggc_e_12rtx_def_ltgt, + gt_ggc_e_12rtx_def_unlt, + gt_ggc_e_12rtx_def_unle, + gt_ggc_e_12rtx_def_ungt, + gt_ggc_e_12rtx_def_unge, + gt_ggc_e_12rtx_def_uneq, + gt_ggc_e_15rtx_def_ordered, + gt_ggc_e_17rtx_def_unordered, + gt_ggc_e_11rtx_def_ltu, + gt_ggc_e_11rtx_def_leu, + gt_ggc_e_11rtx_def_gtu, + gt_ggc_e_11rtx_def_geu, + gt_ggc_e_10rtx_def_lt, + gt_ggc_e_10rtx_def_le, + gt_ggc_e_10rtx_def_gt, + gt_ggc_e_10rtx_def_ge, + gt_ggc_e_10rtx_def_eq, + gt_ggc_e_10rtx_def_ne, + gt_ggc_e_19rtx_def_post_modify, + gt_ggc_e_18rtx_def_pre_modify, + gt_ggc_e_16rtx_def_post_inc, + gt_ggc_e_16rtx_def_post_dec, + gt_ggc_e_15rtx_def_pre_inc, + gt_ggc_e_15rtx_def_pre_dec, + gt_ggc_e_12rtx_def_umax, + gt_ggc_e_12rtx_def_umin, + gt_ggc_e_12rtx_def_smax, + gt_ggc_e_12rtx_def_smin, + gt_ggc_e_16rtx_def_rotatert, + gt_ggc_e_16rtx_def_lshiftrt, + gt_ggc_e_16rtx_def_ashiftrt, + gt_ggc_e_14rtx_def_rotate, + gt_ggc_e_14rtx_def_ashift, + gt_ggc_e_11rtx_def_not, + gt_ggc_e_11rtx_def_xor, + gt_ggc_e_11rtx_def_ior, + gt_ggc_e_11rtx_def_and, + gt_ggc_e_12rtx_def_umod, + gt_ggc_e_12rtx_def_udiv, + gt_ggc_e_11rtx_def_mod, + gt_ggc_e_14rtx_def_us_div, + gt_ggc_e_14rtx_def_ss_div, + gt_ggc_e_11rtx_def_div, + gt_ggc_e_15rtx_def_us_mult, + gt_ggc_e_15rtx_def_ss_mult, + gt_ggc_e_12rtx_def_mult, + gt_ggc_e_11rtx_def_neg, + gt_ggc_e_13rtx_def_minus, + gt_ggc_e_12rtx_def_plus, + gt_ggc_e_15rtx_def_compare, + gt_ggc_e_20rtx_def_if_then_else, + gt_ggc_e_11rtx_def_cc0, + gt_ggc_e_18rtx_def_symbol_ref, + gt_ggc_e_12fake_union_1, + gt_ggc_e_17rtx_def_label_ref, + gt_ggc_e_11rtx_def_mem, + gt_ggc_e_15rtx_def_concatn, + gt_ggc_e_14rtx_def_concat, + gt_ggc_e_23rtx_def_strict_low_part, + gt_ggc_e_14rtx_def_subreg, + gt_ggc_e_15rtx_def_scratch, + gt_ggc_e_11rtx_def_reg, + gt_ggc_e_10rtx_def_pc, + gt_ggc_e_13rtx_def_const, + gt_ggc_e_20rtx_def_const_string, + gt_ggc_e_20rtx_def_const_vector, + gt_ggc_e_20rtx_def_const_double, + gt_ggc_e_19rtx_def_const_fixed, + gt_ggc_e_17rtx_def_const_int, + gt_ggc_e_15rtx_def_trap_if, + gt_ggc_e_17rtx_def_eh_return, + gt_ggc_e_14rtx_def_return, + gt_ggc_e_12rtx_def_call, + gt_ggc_e_15rtx_def_clobber, + gt_ggc_e_11rtx_def_use, + gt_ggc_e_11rtx_def_set, + gt_ggc_e_16rtx_def_prefetch, + gt_ggc_e_21rtx_def_addr_diff_vec, + gt_ggc_e_16rtx_def_addr_vec, + gt_ggc_e_23rtx_def_unspec_volatile, + gt_ggc_e_14rtx_def_unspec, + gt_ggc_e_20rtx_def_asm_operands, + gt_ggc_e_17rtx_def_asm_input, + gt_ggc_e_16rtx_def_parallel, + gt_ggc_e_17rtx_def_cond_exec, + gt_ggc_e_12rtx_def_note, + gt_ggc_e_18rtx_def_code_label, + gt_ggc_e_15rtx_def_barrier, + gt_ggc_e_17rtx_def_call_insn, + gt_ggc_e_17rtx_def_jump_insn, + gt_ggc_e_12rtx_def_insn, + gt_ggc_e_18rtx_def_debug_insn, + gt_ggc_e_15rtx_def_address, + gt_ggc_e_16rtx_def_sequence, + gt_ggc_e_17rtx_def_insn_list, + gt_ggc_e_17rtx_def_expr_list, + gt_ggc_e_18rtx_def_debug_expr, + gt_ggc_e_13rtx_def_value, + gt_ggc_e_15rtx_def_UnKnown, + gt_ggc_e_23rtx_def_symbol_subunion, + gt_ggc_e_21rtx_def_note_subunion, + gt_ggc_e_23constant_descriptor_rtx, + gt_ggc_e_11fixed_value, + gt_ggc_e_10real_value, + gt_ggc_e_12block_symbol, + gt_ggc_e_12object_block, + gt_ggc_e_9reg_attrs, + gt_ggc_e_9mem_attrs, + gt_ggc_e_14bitmap_obstack, + gt_ggc_e_18bitmap_element_def, + gt_ggc_e_12splay_tree_s, + gt_ggc_e_17splay_tree_node_s, + gt_ggc_e_4htab, + gt_ggc_e_16machine_function, + gt_ggc_e_17arm_stack_offsets, + gt_ggc_e_10VEC_rtx_gc, + gt_ggc_e_12VEC_rtx_base, + gt_ggc_e_13VEC_gimple_gc, + gt_ggc_e_15VEC_gimple_base, + gt_ggc_e_11VEC_tree_gc, + gt_ggc_e_13VEC_tree_none, + gt_ggc_e_13VEC_tree_base, + gt_ggc_e_12VEC_uchar_gc, + gt_ggc_e_14VEC_uchar_base, + gt_ggc_e_15basic_block_def, + gt_ggc_e_8edge_def, + gt_ggc_e_12gimple_seq_d, + gt_ggc_e_15cl_optimization, + gt_ggc_e_16cl_target_option, + gt_ggc_e_7section, + gt_ggc_e_18gimple_statement_d, + gt_ggc_e_9rtvec_def, + gt_ggc_e_7rtx_def, + gt_ggc_e_15bitmap_head_def, + gt_ggc_e_11cpp_macro_u, + gt_ggc_e_13ht_identifier, + gt_ggc_e_19_cpp_hashnode_value, + gt_ggc_e_11cpp_token_u, + gt_ggc_e_14cpp_identifier, + gt_ggc_e_9tree_node, + gt_ggc_e_13cpp_macro_arg, + gt_ggc_e_6answer, + gt_ggc_e_9cpp_macro, + gt_ggc_e_12cpp_hashnode, + gt_ggc_e_10cpp_string, + gt_ggc_e_9cpp_token, + gt_ggc_e_9line_maps, + gt_ggc_e_8line_map, + gt_e_II17splay_tree_node_s, + gt_e_SP9tree_node17splay_tree_node_s, + gt_e_P9tree_nodeP9tree_node17splay_tree_node_s, + gt_e_P15interface_tuple4htab, + gt_e_P17string_descriptor4htab, + gt_e_P14type_assertion4htab, + gt_e_P18treetreehash_entry4htab, + gt_e_P17module_htab_entry4htab, + gt_e_P21pending_abstract_type4htab, + gt_e_P14constexpr_call4htab, + gt_e_P16constexpr_fundef4htab, + gt_e_P10spec_entry4htab, + gt_e_P16cxx_int_tree_map4htab, + gt_e_P17named_label_entry4htab, + gt_e_P17lto_in_decl_state4htab, + gt_e_P20lto_symtab_entry_def4htab, + gt_e_P11heapvar_map4htab, + gt_e_P9tree_nodeP9tree_node12splay_tree_s, + gt_e_P13scev_info_str4htab, + gt_e_P12tree_int_map4htab, + gt_e_P23constant_descriptor_rtx4htab, + gt_e_P24constant_descriptor_tree4htab, + gt_e_P12object_block4htab, + gt_e_P7section4htab, + gt_e_P17tree_priority_map4htab, + gt_e_P13tree_decl_map4htab, + gt_e_P9type_hash4htab, + gt_e_P23temp_slot_address_entry4htab, + gt_e_P15throw_stmt_node4htab, + gt_e_P9reg_attrs4htab, + gt_e_P9mem_attrs4htab, + gt_e_P7rtx_def4htab, + gt_e_P12varpool_node4htab, + gt_e_P10cgraph_sym4htab, + gt_e_P8type_ent4htab, + gt_e_P18saved_module_scope4htab, + gt_e_SP9tree_node12splay_tree_s, + gt_e_P10vcall_insn4htab, + gt_e_P22cached_dw_loc_list_def4htab, + gt_e_P16var_loc_list_def4htab, + gt_e_P10die_struct4htab, + gt_e_P15dwarf_file_data4htab, + gt_e_P20indirect_string_node4htab, + gt_e_P11cgraph_node4htab, + gt_e_II12splay_tree_s, + gt_e_P15cgraph_mod_info4htab, + gt_e_P28varpool_node_set_element_def4htab, + gt_e_P27cgraph_node_set_element_def4htab, + gt_e_P11cgraph_edge4htab, + gt_e_P9loop_exit4htab, + gt_e_P24types_used_by_vars_entry4htab, + gt_e_P9tree_node4htab, + gt_e_P13libfunc_entry4htab, + gt_types_enum_last +}; + +/* Allocators for known structs and unions. */ + +#define ggc_alloc_lazy_hex_fp_value_struct() ((struct lazy_hex_fp_value_struct *)(ggc_internal_alloc_stat (sizeof (struct lazy_hex_fp_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lazy_hex_fp_value_struct() ((struct lazy_hex_fp_value_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct lazy_hex_fp_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_lazy_hex_fp_value_struct(n) ((struct lazy_hex_fp_value_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct lazy_hex_fp_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lazy_hex_fp_value_struct(n) ((struct lazy_hex_fp_value_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lazy_hex_fp_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lazy_hex_fp_value_struct(z) ((struct lazy_hex_fp_value_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lazy_hex_fp_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lazy_hex_fp_value_struct(z) ((struct lazy_hex_fp_value_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lazy_hex_fp_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lazy_hex_fp_value_struct(n, z) ((struct lazy_hex_fp_value_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lazy_hex_fp_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lazy_hex_fp_value_struct(n, z) ((struct lazy_hex_fp_value_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lazy_hex_fp_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_c_saved_builtin_gc() ((struct VEC_c_saved_builtin_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_c_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_c_saved_builtin_gc() ((struct VEC_c_saved_builtin_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_c_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_c_saved_builtin_gc(n) ((struct VEC_c_saved_builtin_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_c_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_c_saved_builtin_gc(n) ((struct VEC_c_saved_builtin_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_c_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_c_saved_builtin_gc(z) ((struct VEC_c_saved_builtin_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_c_saved_builtin_gc(z) ((struct VEC_c_saved_builtin_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_c_saved_builtin_gc(n, z) ((struct VEC_c_saved_builtin_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_c_saved_builtin_gc(n, z) ((struct VEC_c_saved_builtin_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_c_saved_builtin_base() ((struct VEC_c_saved_builtin_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_c_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_c_saved_builtin_base() ((struct VEC_c_saved_builtin_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_c_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_c_saved_builtin_base(n) ((struct VEC_c_saved_builtin_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_c_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_c_saved_builtin_base(n) ((struct VEC_c_saved_builtin_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_c_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_c_saved_builtin_base(z) ((struct VEC_c_saved_builtin_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_c_saved_builtin_base(z) ((struct VEC_c_saved_builtin_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_c_saved_builtin_base(n, z) ((struct VEC_c_saved_builtin_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_c_saved_builtin_base(n, z) ((struct VEC_c_saved_builtin_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_c_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_c_inline_static() ((struct c_inline_static *)(ggc_internal_alloc_stat (sizeof (struct c_inline_static) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_inline_static() ((struct c_inline_static *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_inline_static) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_inline_static(n) ((struct c_inline_static *)(ggc_internal_vec_alloc_stat (sizeof (struct c_inline_static), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_inline_static(n) ((struct c_inline_static *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_inline_static), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_inline_static(z) ((struct c_inline_static *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_inline_static) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_inline_static(z) ((struct c_inline_static *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_inline_static) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_inline_static(n, z) ((struct c_inline_static *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_inline_static), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_inline_static(n, z) ((struct c_inline_static *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_inline_static), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_c_goto_bindings_p_gc() ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_c_goto_bindings_p_gc() ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_c_goto_bindings_p_gc(n) ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_c_goto_bindings_p_gc(n) ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_c_goto_bindings_p_gc(z) ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_c_goto_bindings_p_gc(z) ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_c_goto_bindings_p_gc(n, z) ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_c_goto_bindings_p_gc(n, z) ((struct VEC_c_goto_bindings_p_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_c_goto_bindings_p_base() ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_c_goto_bindings_p_base() ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_c_goto_bindings_p_base(n) ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_c_goto_bindings_p_base(n) ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_c_goto_bindings_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_c_goto_bindings_p_base(z) ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_c_goto_bindings_p_base(z) ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_c_goto_bindings_p_base(n, z) ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_c_goto_bindings_p_base(n, z) ((struct VEC_c_goto_bindings_p_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_c_goto_bindings_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_c_goto_bindings() ((struct c_goto_bindings *)(ggc_internal_alloc_stat (sizeof (struct c_goto_bindings) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_goto_bindings() ((struct c_goto_bindings *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_goto_bindings) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_goto_bindings(n) ((struct c_goto_bindings *)(ggc_internal_vec_alloc_stat (sizeof (struct c_goto_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_goto_bindings(n) ((struct c_goto_bindings *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_goto_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_goto_bindings(z) ((struct c_goto_bindings *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_goto_bindings) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_goto_bindings(z) ((struct c_goto_bindings *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_goto_bindings) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_goto_bindings(n, z) ((struct c_goto_bindings *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_goto_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_goto_bindings(n, z) ((struct c_goto_bindings *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_goto_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_c_scope() ((struct c_scope *)(ggc_internal_alloc_stat (sizeof (struct c_scope) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_scope() ((struct c_scope *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_scope) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_scope(n) ((struct c_scope *)(ggc_internal_vec_alloc_stat (sizeof (struct c_scope), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_scope(n) ((struct c_scope *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_scope(z) ((struct c_scope *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_scope(z) ((struct c_scope *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_scope(n, z) ((struct c_scope *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_scope(n, z) ((struct c_scope *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_scope), n MEM_STAT_INFO))) +#define ggc_alloc_c_binding() ((struct c_binding *)(ggc_internal_alloc_stat (sizeof (struct c_binding) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_binding() ((struct c_binding *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_binding) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_binding(n) ((struct c_binding *)(ggc_internal_vec_alloc_stat (sizeof (struct c_binding), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_binding(n) ((struct c_binding *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_binding(z) ((struct c_binding *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_binding(z) ((struct c_binding *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_binding(n, z) ((struct c_binding *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_binding(n, z) ((struct c_binding *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_binding), n MEM_STAT_INFO))) +#define ggc_alloc_c_label_vars() ((struct c_label_vars *)(ggc_internal_alloc_stat (sizeof (struct c_label_vars) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_label_vars() ((struct c_label_vars *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_label_vars) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_label_vars(n) ((struct c_label_vars *)(ggc_internal_vec_alloc_stat (sizeof (struct c_label_vars), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_label_vars(n) ((struct c_label_vars *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_label_vars), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_label_vars(z) ((struct c_label_vars *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_label_vars) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_label_vars(z) ((struct c_label_vars *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_label_vars) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_label_vars(n, z) ((struct c_label_vars *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_label_vars), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_label_vars(n, z) ((struct c_label_vars *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_label_vars), n MEM_STAT_INFO))) +#define ggc_alloc_c_spot_bindings() ((struct c_spot_bindings *)(ggc_internal_alloc_stat (sizeof (struct c_spot_bindings) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_spot_bindings() ((struct c_spot_bindings *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_spot_bindings) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_spot_bindings(n) ((struct c_spot_bindings *)(ggc_internal_vec_alloc_stat (sizeof (struct c_spot_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_spot_bindings(n) ((struct c_spot_bindings *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_spot_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_spot_bindings(z) ((struct c_spot_bindings *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_spot_bindings) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_spot_bindings(z) ((struct c_spot_bindings *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_spot_bindings) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_spot_bindings(n, z) ((struct c_spot_bindings *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_spot_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_spot_bindings(n, z) ((struct c_spot_bindings *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_spot_bindings), n MEM_STAT_INFO))) +#define ggc_alloc_c_parser() ((struct c_parser *)(ggc_internal_alloc_stat (sizeof (struct c_parser) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_parser() ((struct c_parser *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_parser) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_parser(n) ((struct c_parser *)(ggc_internal_vec_alloc_stat (sizeof (struct c_parser), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_parser(n) ((struct c_parser *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_parser), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_parser(z) ((struct c_parser *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_parser) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_parser(z) ((struct c_parser *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_parser) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_parser(n, z) ((struct c_parser *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_parser), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_parser(n, z) ((struct c_parser *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_parser), n MEM_STAT_INFO))) +#define ggc_alloc_c_token() ((struct c_token *)(ggc_internal_alloc_stat (sizeof (struct c_token) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_token() ((struct c_token *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_token) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_token(n) ((struct c_token *)(ggc_internal_vec_alloc_stat (sizeof (struct c_token), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_token(n) ((struct c_token *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_token), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_token(z) ((struct c_token *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_token) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_token(z) ((struct c_token *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_token) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_token(n, z) ((struct c_token *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_token), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_token(n, z) ((struct c_token *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_token), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ivarref_entry_gc() ((struct VEC_ivarref_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_ivarref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ivarref_entry_gc() ((struct VEC_ivarref_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ivarref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ivarref_entry_gc(n) ((struct VEC_ivarref_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ivarref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ivarref_entry_gc(n) ((struct VEC_ivarref_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ivarref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ivarref_entry_gc(z) ((struct VEC_ivarref_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ivarref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ivarref_entry_gc(z) ((struct VEC_ivarref_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ivarref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ivarref_entry_gc(n, z) ((struct VEC_ivarref_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ivarref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ivarref_entry_gc(n, z) ((struct VEC_ivarref_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ivarref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ivarref_entry_base() ((struct VEC_ivarref_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_ivarref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ivarref_entry_base() ((struct VEC_ivarref_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ivarref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ivarref_entry_base(n) ((struct VEC_ivarref_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ivarref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ivarref_entry_base(n) ((struct VEC_ivarref_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ivarref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ivarref_entry_base(z) ((struct VEC_ivarref_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ivarref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ivarref_entry_base(z) ((struct VEC_ivarref_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ivarref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ivarref_entry_base(n, z) ((struct VEC_ivarref_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ivarref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ivarref_entry_base(n, z) ((struct VEC_ivarref_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ivarref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_ivarref_entry() ((struct ivarref_entry *)(ggc_internal_alloc_stat (sizeof (struct ivarref_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ivarref_entry() ((struct ivarref_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct ivarref_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_ivarref_entry(n) ((struct ivarref_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct ivarref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ivarref_entry(n) ((struct ivarref_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ivarref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ivarref_entry(z) ((struct ivarref_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ivarref_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ivarref_entry(z) ((struct ivarref_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ivarref_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ivarref_entry(n, z) ((struct ivarref_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ivarref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ivarref_entry(n, z) ((struct ivarref_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ivarref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_prot_list_entry_gc() ((struct VEC_prot_list_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_prot_list_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_prot_list_entry_gc() ((struct VEC_prot_list_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_prot_list_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_prot_list_entry_gc(n) ((struct VEC_prot_list_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_prot_list_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_prot_list_entry_gc(n) ((struct VEC_prot_list_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_prot_list_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_prot_list_entry_gc(z) ((struct VEC_prot_list_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_prot_list_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_prot_list_entry_gc(z) ((struct VEC_prot_list_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_prot_list_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_prot_list_entry_gc(n, z) ((struct VEC_prot_list_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_prot_list_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_prot_list_entry_gc(n, z) ((struct VEC_prot_list_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_prot_list_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_prot_list_entry_base() ((struct VEC_prot_list_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_prot_list_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_prot_list_entry_base() ((struct VEC_prot_list_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_prot_list_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_prot_list_entry_base(n) ((struct VEC_prot_list_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_prot_list_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_prot_list_entry_base(n) ((struct VEC_prot_list_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_prot_list_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_prot_list_entry_base(z) ((struct VEC_prot_list_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_prot_list_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_prot_list_entry_base(z) ((struct VEC_prot_list_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_prot_list_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_prot_list_entry_base(n, z) ((struct VEC_prot_list_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_prot_list_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_prot_list_entry_base(n, z) ((struct VEC_prot_list_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_prot_list_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_prot_list_entry() ((struct prot_list_entry *)(ggc_internal_alloc_stat (sizeof (struct prot_list_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_prot_list_entry() ((struct prot_list_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct prot_list_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_prot_list_entry(n) ((struct prot_list_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct prot_list_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_prot_list_entry(n) ((struct prot_list_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct prot_list_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_prot_list_entry(z) ((struct prot_list_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct prot_list_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_prot_list_entry(z) ((struct prot_list_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct prot_list_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_prot_list_entry(n, z) ((struct prot_list_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct prot_list_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_prot_list_entry(n, z) ((struct prot_list_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct prot_list_entry), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_msgref_entry_gc() ((struct VEC_msgref_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_msgref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_msgref_entry_gc() ((struct VEC_msgref_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_msgref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_msgref_entry_gc(n) ((struct VEC_msgref_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_msgref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_msgref_entry_gc(n) ((struct VEC_msgref_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_msgref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_msgref_entry_gc(z) ((struct VEC_msgref_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_msgref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_msgref_entry_gc(z) ((struct VEC_msgref_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_msgref_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_msgref_entry_gc(n, z) ((struct VEC_msgref_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_msgref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_msgref_entry_gc(n, z) ((struct VEC_msgref_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_msgref_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_msgref_entry_base() ((struct VEC_msgref_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_msgref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_msgref_entry_base() ((struct VEC_msgref_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_msgref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_msgref_entry_base(n) ((struct VEC_msgref_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_msgref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_msgref_entry_base(n) ((struct VEC_msgref_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_msgref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_msgref_entry_base(z) ((struct VEC_msgref_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_msgref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_msgref_entry_base(z) ((struct VEC_msgref_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_msgref_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_msgref_entry_base(n, z) ((struct VEC_msgref_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_msgref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_msgref_entry_base(n, z) ((struct VEC_msgref_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_msgref_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_msgref_entry() ((struct msgref_entry *)(ggc_internal_alloc_stat (sizeof (struct msgref_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_msgref_entry() ((struct msgref_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct msgref_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_msgref_entry(n) ((struct msgref_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct msgref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_msgref_entry(n) ((struct msgref_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct msgref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_msgref_entry(z) ((struct msgref_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct msgref_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_msgref_entry(z) ((struct msgref_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct msgref_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_msgref_entry(n, z) ((struct msgref_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct msgref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_msgref_entry(n, z) ((struct msgref_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct msgref_entry), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ident_data_tuple_gc() ((struct VEC_ident_data_tuple_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_ident_data_tuple_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ident_data_tuple_gc() ((struct VEC_ident_data_tuple_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ident_data_tuple_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ident_data_tuple_gc(n) ((struct VEC_ident_data_tuple_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ident_data_tuple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ident_data_tuple_gc(n) ((struct VEC_ident_data_tuple_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ident_data_tuple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ident_data_tuple_gc(z) ((struct VEC_ident_data_tuple_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ident_data_tuple_gc(z) ((struct VEC_ident_data_tuple_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ident_data_tuple_gc(n, z) ((struct VEC_ident_data_tuple_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ident_data_tuple_gc(n, z) ((struct VEC_ident_data_tuple_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ident_data_tuple_base() ((struct VEC_ident_data_tuple_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_ident_data_tuple_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ident_data_tuple_base() ((struct VEC_ident_data_tuple_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ident_data_tuple_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ident_data_tuple_base(n) ((struct VEC_ident_data_tuple_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ident_data_tuple_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ident_data_tuple_base(n) ((struct VEC_ident_data_tuple_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ident_data_tuple_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ident_data_tuple_base(z) ((struct VEC_ident_data_tuple_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ident_data_tuple_base(z) ((struct VEC_ident_data_tuple_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ident_data_tuple_base(n, z) ((struct VEC_ident_data_tuple_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ident_data_tuple_base(n, z) ((struct VEC_ident_data_tuple_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ident_data_tuple_base), n MEM_STAT_INFO))) +#define ggc_alloc_ident_data_tuple() ((struct ident_data_tuple *)(ggc_internal_alloc_stat (sizeof (struct ident_data_tuple) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ident_data_tuple() ((struct ident_data_tuple *)(ggc_internal_cleared_alloc_stat (sizeof (struct ident_data_tuple) MEM_STAT_INFO))) +#define ggc_alloc_vec_ident_data_tuple(n) ((struct ident_data_tuple *)(ggc_internal_vec_alloc_stat (sizeof (struct ident_data_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ident_data_tuple(n) ((struct ident_data_tuple *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ident_data_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ident_data_tuple(z) ((struct ident_data_tuple *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ident_data_tuple) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ident_data_tuple(z) ((struct ident_data_tuple *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ident_data_tuple) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ident_data_tuple(n, z) ((struct ident_data_tuple *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ident_data_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ident_data_tuple(n, z) ((struct ident_data_tuple *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ident_data_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_interface_tuple() ((struct interface_tuple *)(ggc_internal_alloc_stat (sizeof (struct interface_tuple) MEM_STAT_INFO))) +#define ggc_alloc_cleared_interface_tuple() ((struct interface_tuple *)(ggc_internal_cleared_alloc_stat (sizeof (struct interface_tuple) MEM_STAT_INFO))) +#define ggc_alloc_vec_interface_tuple(n) ((struct interface_tuple *)(ggc_internal_vec_alloc_stat (sizeof (struct interface_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_interface_tuple(n) ((struct interface_tuple *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct interface_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_zone_interface_tuple(z) ((struct interface_tuple *)(ggc_internal_zone_alloc_stat (z, sizeof (struct interface_tuple) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_interface_tuple(z) ((struct interface_tuple *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct interface_tuple) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_interface_tuple(n, z) ((struct interface_tuple *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct interface_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_interface_tuple(n, z) ((struct interface_tuple *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct interface_tuple), n MEM_STAT_INFO))) +#define ggc_alloc_string_descriptor() ((struct string_descriptor *)(ggc_internal_alloc_stat (sizeof (struct string_descriptor) MEM_STAT_INFO))) +#define ggc_alloc_cleared_string_descriptor() ((struct string_descriptor *)(ggc_internal_cleared_alloc_stat (sizeof (struct string_descriptor) MEM_STAT_INFO))) +#define ggc_alloc_vec_string_descriptor(n) ((struct string_descriptor *)(ggc_internal_vec_alloc_stat (sizeof (struct string_descriptor), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_string_descriptor(n) ((struct string_descriptor *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct string_descriptor), n MEM_STAT_INFO))) +#define ggc_alloc_zone_string_descriptor(z) ((struct string_descriptor *)(ggc_internal_zone_alloc_stat (z, sizeof (struct string_descriptor) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_string_descriptor(z) ((struct string_descriptor *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct string_descriptor) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_string_descriptor(n, z) ((struct string_descriptor *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct string_descriptor), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_string_descriptor(n, z) ((struct string_descriptor *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct string_descriptor), n MEM_STAT_INFO))) +#define ggc_alloc_imp_entry() ((struct imp_entry *)(ggc_internal_alloc_stat (sizeof (struct imp_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_imp_entry() ((struct imp_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct imp_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_imp_entry(n) ((struct imp_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct imp_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_imp_entry(n) ((struct imp_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct imp_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_imp_entry(z) ((struct imp_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct imp_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_imp_entry(z) ((struct imp_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct imp_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_imp_entry(n, z) ((struct imp_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct imp_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_imp_entry(n, z) ((struct imp_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct imp_entry), n MEM_STAT_INFO))) +#define ggc_alloc_hashed_attribute() ((struct hashed_attribute *)(ggc_internal_alloc_stat (sizeof (struct hashed_attribute) MEM_STAT_INFO))) +#define ggc_alloc_cleared_hashed_attribute() ((struct hashed_attribute *)(ggc_internal_cleared_alloc_stat (sizeof (struct hashed_attribute) MEM_STAT_INFO))) +#define ggc_alloc_vec_hashed_attribute(n) ((struct hashed_attribute *)(ggc_internal_vec_alloc_stat (sizeof (struct hashed_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_hashed_attribute(n) ((struct hashed_attribute *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct hashed_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_zone_hashed_attribute(z) ((struct hashed_attribute *)(ggc_internal_zone_alloc_stat (z, sizeof (struct hashed_attribute) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_hashed_attribute(z) ((struct hashed_attribute *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct hashed_attribute) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_hashed_attribute(n, z) ((struct hashed_attribute *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct hashed_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_hashed_attribute(n, z) ((struct hashed_attribute *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct hashed_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_hashed_entry() ((struct hashed_entry *)(ggc_internal_alloc_stat (sizeof (struct hashed_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_hashed_entry() ((struct hashed_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct hashed_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_hashed_entry(n) ((struct hashed_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct hashed_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_hashed_entry(n) ((struct hashed_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct hashed_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_hashed_entry(z) ((struct hashed_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct hashed_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_hashed_entry(z) ((struct hashed_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct hashed_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_hashed_entry(n, z) ((struct hashed_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct hashed_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_hashed_entry(n, z) ((struct hashed_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct hashed_entry), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ltrans_partition_gc() ((struct VEC_ltrans_partition_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_ltrans_partition_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ltrans_partition_gc() ((struct VEC_ltrans_partition_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ltrans_partition_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ltrans_partition_gc(n) ((struct VEC_ltrans_partition_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ltrans_partition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ltrans_partition_gc(n) ((struct VEC_ltrans_partition_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ltrans_partition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ltrans_partition_gc(z) ((struct VEC_ltrans_partition_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ltrans_partition_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ltrans_partition_gc(z) ((struct VEC_ltrans_partition_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ltrans_partition_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ltrans_partition_gc(n, z) ((struct VEC_ltrans_partition_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ltrans_partition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ltrans_partition_gc(n, z) ((struct VEC_ltrans_partition_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ltrans_partition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ltrans_partition_base() ((struct VEC_ltrans_partition_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_ltrans_partition_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ltrans_partition_base() ((struct VEC_ltrans_partition_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ltrans_partition_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ltrans_partition_base(n) ((struct VEC_ltrans_partition_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ltrans_partition_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ltrans_partition_base(n) ((struct VEC_ltrans_partition_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ltrans_partition_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ltrans_partition_base(z) ((struct VEC_ltrans_partition_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ltrans_partition_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ltrans_partition_base(z) ((struct VEC_ltrans_partition_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ltrans_partition_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ltrans_partition_base(n, z) ((struct VEC_ltrans_partition_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ltrans_partition_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ltrans_partition_base(n, z) ((struct VEC_ltrans_partition_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ltrans_partition_base), n MEM_STAT_INFO))) +#define ggc_alloc_ltrans_partition_def() ((struct ltrans_partition_def *)(ggc_internal_alloc_stat (sizeof (struct ltrans_partition_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ltrans_partition_def() ((struct ltrans_partition_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct ltrans_partition_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_ltrans_partition_def(n) ((struct ltrans_partition_def *)(ggc_internal_vec_alloc_stat (sizeof (struct ltrans_partition_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ltrans_partition_def(n) ((struct ltrans_partition_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ltrans_partition_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ltrans_partition_def(z) ((struct ltrans_partition_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ltrans_partition_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ltrans_partition_def(z) ((struct ltrans_partition_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ltrans_partition_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ltrans_partition_def(n, z) ((struct ltrans_partition_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ltrans_partition_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ltrans_partition_def(n, z) ((struct ltrans_partition_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ltrans_partition_def), n MEM_STAT_INFO))) +#define ggc_alloc_builtin_record() ((struct builtin_record *)(ggc_internal_alloc_stat (sizeof (struct builtin_record) MEM_STAT_INFO))) +#define ggc_alloc_cleared_builtin_record() ((struct builtin_record *)(ggc_internal_cleared_alloc_stat (sizeof (struct builtin_record) MEM_STAT_INFO))) +#define ggc_alloc_vec_builtin_record(n) ((struct builtin_record *)(ggc_internal_vec_alloc_stat (sizeof (struct builtin_record), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_builtin_record(n) ((struct builtin_record *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct builtin_record), n MEM_STAT_INFO))) +#define ggc_alloc_zone_builtin_record(z) ((struct builtin_record *)(ggc_internal_zone_alloc_stat (z, sizeof (struct builtin_record) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_builtin_record(z) ((struct builtin_record *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct builtin_record) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_builtin_record(n, z) ((struct builtin_record *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct builtin_record), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_builtin_record(n, z) ((struct builtin_record *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct builtin_record), n MEM_STAT_INFO))) +#define ggc_alloc_string_or_tree() ((union string_or_tree *)(ggc_internal_alloc_stat (sizeof (union string_or_tree) MEM_STAT_INFO))) +#define ggc_alloc_cleared_string_or_tree() ((union string_or_tree *)(ggc_internal_cleared_alloc_stat (sizeof (union string_or_tree) MEM_STAT_INFO))) +#define ggc_alloc_vec_string_or_tree(n) ((union string_or_tree *)(ggc_internal_vec_alloc_stat (sizeof (union string_or_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_string_or_tree(n) ((union string_or_tree *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union string_or_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_string_or_tree(z) ((union string_or_tree *)(ggc_internal_zone_alloc_stat (z, sizeof (union string_or_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_string_or_tree(z) ((union string_or_tree *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union string_or_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_string_or_tree(n, z) ((union string_or_tree *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union string_or_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_string_or_tree(n, z) ((union string_or_tree *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union string_or_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cpool_entry(SIZE) ((union cpool_entry *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpool_entry(SIZE) ((union cpool_entry *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_cpool_entry(SIZE, n) ((union cpool_entry *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpool_entry(SIZE, n) ((union cpool_entry *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpool_entry(SIZE, z) ((union cpool_entry *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpool_entry(SIZE, z) ((union cpool_entry *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpool_entry(SIZE, n, z) ((union cpool_entry *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpool_entry(SIZE, n, z) ((union cpool_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_VEC_method_entry_gc() ((struct VEC_method_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_method_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_method_entry_gc() ((struct VEC_method_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_method_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_method_entry_gc(n) ((struct VEC_method_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_method_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_method_entry_gc(n) ((struct VEC_method_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_method_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_method_entry_gc(z) ((struct VEC_method_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_method_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_method_entry_gc(z) ((struct VEC_method_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_method_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_method_entry_gc(n, z) ((struct VEC_method_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_method_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_method_entry_gc(n, z) ((struct VEC_method_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_method_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_method_entry_base() ((struct VEC_method_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_method_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_method_entry_base() ((struct VEC_method_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_method_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_method_entry_base(n) ((struct VEC_method_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_method_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_method_entry_base(n) ((struct VEC_method_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_method_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_method_entry_base(z) ((struct VEC_method_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_method_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_method_entry_base(z) ((struct VEC_method_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_method_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_method_entry_base(n, z) ((struct VEC_method_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_method_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_method_entry_base(n, z) ((struct VEC_method_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_method_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_method_entry_d() ((struct method_entry_d *)(ggc_internal_alloc_stat (sizeof (struct method_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_method_entry_d() ((struct method_entry_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct method_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_method_entry_d(n) ((struct method_entry_d *)(ggc_internal_vec_alloc_stat (sizeof (struct method_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_method_entry_d(n) ((struct method_entry_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct method_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_method_entry_d(z) ((struct method_entry_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct method_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_method_entry_d(z) ((struct method_entry_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct method_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_method_entry_d(n, z) ((struct method_entry_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct method_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_method_entry_d(n, z) ((struct method_entry_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct method_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_var() ((struct lang_decl_var *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_var) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_var() ((struct lang_decl_var *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_var) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_var(n) ((struct lang_decl_var *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_var), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_var(n) ((struct lang_decl_var *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_var), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_var(z) ((struct lang_decl_var *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_var) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_var(z) ((struct lang_decl_var *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_var) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_var(n, z) ((struct lang_decl_var *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_var), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_var(n, z) ((struct lang_decl_var *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_var), n MEM_STAT_INFO))) +#define ggc_alloc_type_assertion() ((struct type_assertion *)(ggc_internal_alloc_stat (sizeof (struct type_assertion) MEM_STAT_INFO))) +#define ggc_alloc_cleared_type_assertion() ((struct type_assertion *)(ggc_internal_cleared_alloc_stat (sizeof (struct type_assertion) MEM_STAT_INFO))) +#define ggc_alloc_vec_type_assertion(n) ((struct type_assertion *)(ggc_internal_vec_alloc_stat (sizeof (struct type_assertion), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_type_assertion(n) ((struct type_assertion *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct type_assertion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_type_assertion(z) ((struct type_assertion *)(ggc_internal_zone_alloc_stat (z, sizeof (struct type_assertion) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_type_assertion(z) ((struct type_assertion *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct type_assertion) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_type_assertion(n, z) ((struct type_assertion *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct type_assertion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_type_assertion(n, z) ((struct type_assertion *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct type_assertion), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_func() ((struct lang_decl_func *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_func) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_func() ((struct lang_decl_func *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_func) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_func(n) ((struct lang_decl_func *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_func), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_func(n) ((struct lang_decl_func *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_func), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_func(z) ((struct lang_decl_func *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_func) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_func(z) ((struct lang_decl_func *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_func) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_func(n, z) ((struct lang_decl_func *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_func), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_func(n, z) ((struct lang_decl_func *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_func), n MEM_STAT_INFO))) +#define ggc_alloc_treetreehash_entry() ((struct treetreehash_entry *)(ggc_internal_alloc_stat (sizeof (struct treetreehash_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_treetreehash_entry() ((struct treetreehash_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct treetreehash_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_treetreehash_entry(n) ((struct treetreehash_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct treetreehash_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_treetreehash_entry(n) ((struct treetreehash_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct treetreehash_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_treetreehash_entry(z) ((struct treetreehash_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct treetreehash_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_treetreehash_entry(z) ((struct treetreehash_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct treetreehash_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_treetreehash_entry(n, z) ((struct treetreehash_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct treetreehash_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_treetreehash_entry(n, z) ((struct treetreehash_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct treetreehash_entry), n MEM_STAT_INFO))) +#define ggc_alloc_CPool() ((struct CPool *)(ggc_internal_alloc_stat (sizeof (struct CPool) MEM_STAT_INFO))) +#define ggc_alloc_cleared_CPool() ((struct CPool *)(ggc_internal_cleared_alloc_stat (sizeof (struct CPool) MEM_STAT_INFO))) +#define ggc_alloc_vec_CPool(n) ((struct CPool *)(ggc_internal_vec_alloc_stat (sizeof (struct CPool), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_CPool(n) ((struct CPool *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct CPool), n MEM_STAT_INFO))) +#define ggc_alloc_zone_CPool(z) ((struct CPool *)(ggc_internal_zone_alloc_stat (z, sizeof (struct CPool) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_CPool(z) ((struct CPool *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct CPool) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_CPool(n, z) ((struct CPool *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct CPool), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_CPool(n, z) ((struct CPool *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct CPool), n MEM_STAT_INFO))) +#define ggc_alloc_JCF() ((struct JCF *)(ggc_internal_alloc_stat (sizeof (struct JCF) MEM_STAT_INFO))) +#define ggc_alloc_cleared_JCF() ((struct JCF *)(ggc_internal_cleared_alloc_stat (sizeof (struct JCF) MEM_STAT_INFO))) +#define ggc_alloc_vec_JCF(n) ((struct JCF *)(ggc_internal_vec_alloc_stat (sizeof (struct JCF), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_JCF(n) ((struct JCF *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct JCF), n MEM_STAT_INFO))) +#define ggc_alloc_zone_JCF(z) ((struct JCF *)(ggc_internal_zone_alloc_stat (z, sizeof (struct JCF) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_JCF(z) ((struct JCF *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct JCF) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_JCF(n, z) ((struct JCF *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct JCF), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_JCF(n, z) ((struct JCF *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct JCF), n MEM_STAT_INFO))) +#define ggc_alloc_gfc_powdecl_list() ((struct gfc_powdecl_list *)(ggc_internal_alloc_stat (sizeof (struct gfc_powdecl_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gfc_powdecl_list() ((struct gfc_powdecl_list *)(ggc_internal_cleared_alloc_stat (sizeof (struct gfc_powdecl_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_gfc_powdecl_list(n) ((struct gfc_powdecl_list *)(ggc_internal_vec_alloc_stat (sizeof (struct gfc_powdecl_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gfc_powdecl_list(n) ((struct gfc_powdecl_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gfc_powdecl_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gfc_powdecl_list(z) ((struct gfc_powdecl_list *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gfc_powdecl_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gfc_powdecl_list(z) ((struct gfc_powdecl_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gfc_powdecl_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gfc_powdecl_list(n, z) ((struct gfc_powdecl_list *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gfc_powdecl_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gfc_powdecl_list(n, z) ((struct gfc_powdecl_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gfc_powdecl_list), n MEM_STAT_INFO))) +#define ggc_alloc_gfc_st_parameter() ((struct gfc_st_parameter *)(ggc_internal_alloc_stat (sizeof (struct gfc_st_parameter) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gfc_st_parameter() ((struct gfc_st_parameter *)(ggc_internal_cleared_alloc_stat (sizeof (struct gfc_st_parameter) MEM_STAT_INFO))) +#define ggc_alloc_vec_gfc_st_parameter(n) ((struct gfc_st_parameter *)(ggc_internal_vec_alloc_stat (sizeof (struct gfc_st_parameter), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gfc_st_parameter(n) ((struct gfc_st_parameter *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gfc_st_parameter), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gfc_st_parameter(z) ((struct gfc_st_parameter *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gfc_st_parameter) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gfc_st_parameter(z) ((struct gfc_st_parameter *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gfc_st_parameter) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gfc_st_parameter(n, z) ((struct gfc_st_parameter *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gfc_st_parameter), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gfc_st_parameter(n, z) ((struct gfc_st_parameter *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gfc_st_parameter), n MEM_STAT_INFO))) +#define ggc_alloc_gfc_st_parameter_field() ((struct gfc_st_parameter_field *)(ggc_internal_alloc_stat (sizeof (struct gfc_st_parameter_field) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gfc_st_parameter_field() ((struct gfc_st_parameter_field *)(ggc_internal_cleared_alloc_stat (sizeof (struct gfc_st_parameter_field) MEM_STAT_INFO))) +#define ggc_alloc_vec_gfc_st_parameter_field(n) ((struct gfc_st_parameter_field *)(ggc_internal_vec_alloc_stat (sizeof (struct gfc_st_parameter_field), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gfc_st_parameter_field(n) ((struct gfc_st_parameter_field *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gfc_st_parameter_field), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gfc_st_parameter_field(z) ((struct gfc_st_parameter_field *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gfc_st_parameter_field) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gfc_st_parameter_field(z) ((struct gfc_st_parameter_field *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gfc_st_parameter_field) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gfc_st_parameter_field(n, z) ((struct gfc_st_parameter_field *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gfc_st_parameter_field), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gfc_st_parameter_field(n, z) ((struct gfc_st_parameter_field *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gfc_st_parameter_field), n MEM_STAT_INFO))) +#define ggc_alloc_gfc_intrinsic_map_t() ((struct gfc_intrinsic_map_t *)(ggc_internal_alloc_stat (sizeof (struct gfc_intrinsic_map_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gfc_intrinsic_map_t() ((struct gfc_intrinsic_map_t *)(ggc_internal_cleared_alloc_stat (sizeof (struct gfc_intrinsic_map_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_gfc_intrinsic_map_t(n) ((struct gfc_intrinsic_map_t *)(ggc_internal_vec_alloc_stat (sizeof (struct gfc_intrinsic_map_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gfc_intrinsic_map_t(n) ((struct gfc_intrinsic_map_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gfc_intrinsic_map_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gfc_intrinsic_map_t(z) ((struct gfc_intrinsic_map_t *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gfc_intrinsic_map_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gfc_intrinsic_map_t(z) ((struct gfc_intrinsic_map_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gfc_intrinsic_map_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gfc_intrinsic_map_t(n, z) ((struct gfc_intrinsic_map_t *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gfc_intrinsic_map_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gfc_intrinsic_map_t(n, z) ((struct gfc_intrinsic_map_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gfc_intrinsic_map_t), n MEM_STAT_INFO))) +#define ggc_alloc_module_htab_entry() ((struct module_htab_entry *)(ggc_internal_alloc_stat (sizeof (struct module_htab_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_module_htab_entry() ((struct module_htab_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct module_htab_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_module_htab_entry(n) ((struct module_htab_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct module_htab_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_module_htab_entry(n) ((struct module_htab_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct module_htab_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_module_htab_entry(z) ((struct module_htab_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct module_htab_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_module_htab_entry(z) ((struct module_htab_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct module_htab_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_module_htab_entry(n, z) ((struct module_htab_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct module_htab_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_module_htab_entry(n, z) ((struct module_htab_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct module_htab_entry), n MEM_STAT_INFO))) +#define ggc_alloc_binding_level() ((struct binding_level *)(ggc_internal_alloc_stat (sizeof (struct binding_level) MEM_STAT_INFO))) +#define ggc_alloc_cleared_binding_level() ((struct binding_level *)(ggc_internal_cleared_alloc_stat (sizeof (struct binding_level) MEM_STAT_INFO))) +#define ggc_alloc_vec_binding_level(n) ((struct binding_level *)(ggc_internal_vec_alloc_stat (sizeof (struct binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_binding_level(n) ((struct binding_level *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_binding_level(z) ((struct binding_level *)(ggc_internal_zone_alloc_stat (z, sizeof (struct binding_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_binding_level(z) ((struct binding_level *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct binding_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_binding_level(n, z) ((struct binding_level *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_binding_level(n, z) ((struct binding_level *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_saved_builtin_gc() ((struct VEC_saved_builtin_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_saved_builtin_gc() ((struct VEC_saved_builtin_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_saved_builtin_gc(n) ((struct VEC_saved_builtin_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_saved_builtin_gc(n) ((struct VEC_saved_builtin_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_saved_builtin_gc(z) ((struct VEC_saved_builtin_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_saved_builtin_gc(z) ((struct VEC_saved_builtin_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_saved_builtin_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_saved_builtin_gc(n, z) ((struct VEC_saved_builtin_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_saved_builtin_gc(n, z) ((struct VEC_saved_builtin_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_saved_builtin_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_saved_builtin_base() ((struct VEC_saved_builtin_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_saved_builtin_base() ((struct VEC_saved_builtin_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_saved_builtin_base(n) ((struct VEC_saved_builtin_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_saved_builtin_base(n) ((struct VEC_saved_builtin_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_saved_builtin_base(z) ((struct VEC_saved_builtin_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_saved_builtin_base(z) ((struct VEC_saved_builtin_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_saved_builtin_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_saved_builtin_base(n, z) ((struct VEC_saved_builtin_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_saved_builtin_base(n, z) ((struct VEC_saved_builtin_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_saved_builtin_base), n MEM_STAT_INFO))) +#define ggc_alloc_sb() ((struct sb *)(ggc_internal_alloc_stat (sizeof (struct sb) MEM_STAT_INFO))) +#define ggc_alloc_cleared_sb() ((struct sb *)(ggc_internal_cleared_alloc_stat (sizeof (struct sb) MEM_STAT_INFO))) +#define ggc_alloc_vec_sb(n) ((struct sb *)(ggc_internal_vec_alloc_stat (sizeof (struct sb), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_sb(n) ((struct sb *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct sb), n MEM_STAT_INFO))) +#define ggc_alloc_zone_sb(z) ((struct sb *)(ggc_internal_zone_alloc_stat (z, sizeof (struct sb) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_sb(z) ((struct sb *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct sb) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_sb(n, z) ((struct sb *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct sb), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_sb(n, z) ((struct sb *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct sb), n MEM_STAT_INFO))) +#define ggc_alloc_opt_stack() ((struct opt_stack *)(ggc_internal_alloc_stat (sizeof (struct opt_stack) MEM_STAT_INFO))) +#define ggc_alloc_cleared_opt_stack() ((struct opt_stack *)(ggc_internal_cleared_alloc_stat (sizeof (struct opt_stack) MEM_STAT_INFO))) +#define ggc_alloc_vec_opt_stack(n) ((struct opt_stack *)(ggc_internal_vec_alloc_stat (sizeof (struct opt_stack), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_opt_stack(n) ((struct opt_stack *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct opt_stack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_opt_stack(z) ((struct opt_stack *)(ggc_internal_zone_alloc_stat (z, sizeof (struct opt_stack) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_opt_stack(z) ((struct opt_stack *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct opt_stack) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_opt_stack(n, z) ((struct opt_stack *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct opt_stack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_opt_stack(n, z) ((struct opt_stack *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct opt_stack), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pending_redefinition_gc() ((struct VEC_pending_redefinition_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_pending_redefinition_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pending_redefinition_gc() ((struct VEC_pending_redefinition_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pending_redefinition_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pending_redefinition_gc(n) ((struct VEC_pending_redefinition_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pending_redefinition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pending_redefinition_gc(n) ((struct VEC_pending_redefinition_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pending_redefinition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pending_redefinition_gc(z) ((struct VEC_pending_redefinition_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pending_redefinition_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pending_redefinition_gc(z) ((struct VEC_pending_redefinition_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pending_redefinition_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pending_redefinition_gc(n, z) ((struct VEC_pending_redefinition_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pending_redefinition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pending_redefinition_gc(n, z) ((struct VEC_pending_redefinition_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pending_redefinition_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pending_redefinition_base() ((struct VEC_pending_redefinition_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_pending_redefinition_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pending_redefinition_base() ((struct VEC_pending_redefinition_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pending_redefinition_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pending_redefinition_base(n) ((struct VEC_pending_redefinition_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pending_redefinition_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pending_redefinition_base(n) ((struct VEC_pending_redefinition_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pending_redefinition_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pending_redefinition_base(z) ((struct VEC_pending_redefinition_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pending_redefinition_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pending_redefinition_base(z) ((struct VEC_pending_redefinition_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pending_redefinition_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pending_redefinition_base(n, z) ((struct VEC_pending_redefinition_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pending_redefinition_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pending_redefinition_base(n, z) ((struct VEC_pending_redefinition_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pending_redefinition_base), n MEM_STAT_INFO))) +#define ggc_alloc_pending_redefinition_d() ((struct pending_redefinition_d *)(ggc_internal_alloc_stat (sizeof (struct pending_redefinition_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_redefinition_d() ((struct pending_redefinition_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct pending_redefinition_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_redefinition_d(n) ((struct pending_redefinition_d *)(ggc_internal_vec_alloc_stat (sizeof (struct pending_redefinition_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_redefinition_d(n) ((struct pending_redefinition_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pending_redefinition_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_redefinition_d(z) ((struct pending_redefinition_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pending_redefinition_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_redefinition_d(z) ((struct pending_redefinition_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pending_redefinition_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pending_redefinition_d(n, z) ((struct pending_redefinition_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pending_redefinition_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_redefinition_d(n, z) ((struct pending_redefinition_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pending_redefinition_d), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pending_weak_gc() ((struct VEC_pending_weak_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_pending_weak_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pending_weak_gc() ((struct VEC_pending_weak_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pending_weak_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pending_weak_gc(n) ((struct VEC_pending_weak_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pending_weak_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pending_weak_gc(n) ((struct VEC_pending_weak_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pending_weak_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pending_weak_gc(z) ((struct VEC_pending_weak_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pending_weak_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pending_weak_gc(z) ((struct VEC_pending_weak_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pending_weak_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pending_weak_gc(n, z) ((struct VEC_pending_weak_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pending_weak_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pending_weak_gc(n, z) ((struct VEC_pending_weak_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pending_weak_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pending_weak_base() ((struct VEC_pending_weak_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_pending_weak_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pending_weak_base() ((struct VEC_pending_weak_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pending_weak_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pending_weak_base(n) ((struct VEC_pending_weak_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pending_weak_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pending_weak_base(n) ((struct VEC_pending_weak_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pending_weak_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pending_weak_base(z) ((struct VEC_pending_weak_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pending_weak_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pending_weak_base(z) ((struct VEC_pending_weak_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pending_weak_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pending_weak_base(n, z) ((struct VEC_pending_weak_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pending_weak_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pending_weak_base(n, z) ((struct VEC_pending_weak_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pending_weak_base), n MEM_STAT_INFO))) +#define ggc_alloc_pending_weak_d() ((struct pending_weak_d *)(ggc_internal_alloc_stat (sizeof (struct pending_weak_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_weak_d() ((struct pending_weak_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct pending_weak_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_weak_d(n) ((struct pending_weak_d *)(ggc_internal_vec_alloc_stat (sizeof (struct pending_weak_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_weak_d(n) ((struct pending_weak_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pending_weak_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_weak_d(z) ((struct pending_weak_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pending_weak_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_weak_d(z) ((struct pending_weak_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pending_weak_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pending_weak_d(n, z) ((struct pending_weak_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pending_weak_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_weak_d(n, z) ((struct pending_weak_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pending_weak_d), n MEM_STAT_INFO))) +#define ggc_alloc_align_stack() ((struct align_stack *)(ggc_internal_alloc_stat (sizeof (struct align_stack) MEM_STAT_INFO))) +#define ggc_alloc_cleared_align_stack() ((struct align_stack *)(ggc_internal_cleared_alloc_stat (sizeof (struct align_stack) MEM_STAT_INFO))) +#define ggc_alloc_vec_align_stack(n) ((struct align_stack *)(ggc_internal_vec_alloc_stat (sizeof (struct align_stack), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_align_stack(n) ((struct align_stack *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct align_stack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_align_stack(z) ((struct align_stack *)(ggc_internal_zone_alloc_stat (z, sizeof (struct align_stack) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_align_stack(z) ((struct align_stack *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct align_stack) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_align_stack(n, z) ((struct align_stack *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct align_stack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_align_stack(n, z) ((struct align_stack *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct align_stack), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_gc_vec_gc() ((struct VEC_tree_gc_vec_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_gc_vec_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_gc_vec_gc() ((struct VEC_tree_gc_vec_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_gc_vec_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_gc_vec_gc(n) ((struct VEC_tree_gc_vec_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_gc_vec_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_gc_vec_gc(n) ((struct VEC_tree_gc_vec_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_gc_vec_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_gc_vec_gc(z) ((struct VEC_tree_gc_vec_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_gc_vec_gc(z) ((struct VEC_tree_gc_vec_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_gc_vec_gc(n, z) ((struct VEC_tree_gc_vec_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_gc_vec_gc(n, z) ((struct VEC_tree_gc_vec_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_gc_vec_base() ((struct VEC_tree_gc_vec_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_gc_vec_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_gc_vec_base() ((struct VEC_tree_gc_vec_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_gc_vec_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_gc_vec_base(n) ((struct VEC_tree_gc_vec_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_gc_vec_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_gc_vec_base(n) ((struct VEC_tree_gc_vec_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_gc_vec_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_gc_vec_base(z) ((struct VEC_tree_gc_vec_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_gc_vec_base(z) ((struct VEC_tree_gc_vec_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_gc_vec_base(n, z) ((struct VEC_tree_gc_vec_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_gc_vec_base(n, z) ((struct VEC_tree_gc_vec_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_gc_vec_base), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_const_char_p_gc() ((struct VEC_const_char_p_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_const_char_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_const_char_p_gc() ((struct VEC_const_char_p_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_const_char_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_const_char_p_gc(n) ((struct VEC_const_char_p_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_const_char_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_const_char_p_gc(n) ((struct VEC_const_char_p_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_const_char_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_const_char_p_gc(z) ((struct VEC_const_char_p_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_const_char_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_const_char_p_gc(z) ((struct VEC_const_char_p_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_const_char_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_const_char_p_gc(n, z) ((struct VEC_const_char_p_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_const_char_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_const_char_p_gc(n, z) ((struct VEC_const_char_p_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_const_char_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_const_char_p_base() ((struct VEC_const_char_p_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_const_char_p_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_const_char_p_base() ((struct VEC_const_char_p_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_const_char_p_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_const_char_p_base(n) ((struct VEC_const_char_p_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_const_char_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_const_char_p_base(n) ((struct VEC_const_char_p_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_const_char_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_const_char_p_base(z) ((struct VEC_const_char_p_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_const_char_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_const_char_p_base(z) ((struct VEC_const_char_p_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_const_char_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_const_char_p_base(n, z) ((struct VEC_const_char_p_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_const_char_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_const_char_p_base(n, z) ((struct VEC_const_char_p_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_const_char_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_pending_abstract_type() ((struct pending_abstract_type *)(ggc_internal_alloc_stat (sizeof (struct pending_abstract_type) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_abstract_type() ((struct pending_abstract_type *)(ggc_internal_cleared_alloc_stat (sizeof (struct pending_abstract_type) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_abstract_type(n) ((struct pending_abstract_type *)(ggc_internal_vec_alloc_stat (sizeof (struct pending_abstract_type), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_abstract_type(n) ((struct pending_abstract_type *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pending_abstract_type), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_abstract_type(z) ((struct pending_abstract_type *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pending_abstract_type) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_abstract_type(z) ((struct pending_abstract_type *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pending_abstract_type) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pending_abstract_type(n, z) ((struct pending_abstract_type *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pending_abstract_type), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_abstract_type(n, z) ((struct pending_abstract_type *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pending_abstract_type), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_int_gc() ((struct VEC_tree_int_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_int_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_int_gc() ((struct VEC_tree_int_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_int_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_int_gc(n) ((struct VEC_tree_int_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_int_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_int_gc(n) ((struct VEC_tree_int_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_int_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_int_gc(z) ((struct VEC_tree_int_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_int_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_int_gc(z) ((struct VEC_tree_int_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_int_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_int_gc(n, z) ((struct VEC_tree_int_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_int_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_int_gc(n, z) ((struct VEC_tree_int_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_int_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_int_base() ((struct VEC_tree_int_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_int_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_int_base() ((struct VEC_tree_int_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_int_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_int_base(n) ((struct VEC_tree_int_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_int_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_int_base(n) ((struct VEC_tree_int_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_int_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_int_base(z) ((struct VEC_tree_int_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_int_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_int_base(z) ((struct VEC_tree_int_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_int_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_int_base(n, z) ((struct VEC_tree_int_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_int_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_int_base(n, z) ((struct VEC_tree_int_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_int_base), n MEM_STAT_INFO))) +#define ggc_alloc_tree_int() ((struct tree_int *)(ggc_internal_alloc_stat (sizeof (struct tree_int) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_int() ((struct tree_int *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_int) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_int(n) ((struct tree_int *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_int), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_int(n) ((struct tree_int *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_int), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_int(z) ((struct tree_int *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_int) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_int(z) ((struct tree_int *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_int) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_int(n, z) ((struct tree_int *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_int), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_int(n, z) ((struct tree_int *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_int), n MEM_STAT_INFO))) +#define ggc_alloc_cp_parser() ((struct cp_parser *)(ggc_internal_alloc_stat (sizeof (struct cp_parser) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_parser() ((struct cp_parser *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_parser) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_parser(n) ((struct cp_parser *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_parser), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_parser(n) ((struct cp_parser *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_parser), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_parser(z) ((struct cp_parser *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_parser) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_parser(z) ((struct cp_parser *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_parser) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_parser(n, z) ((struct cp_parser *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_parser), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_parser(n, z) ((struct cp_parser *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_parser), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_unparsed_functions_entry_gc() ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_unparsed_functions_entry_gc() ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_unparsed_functions_entry_gc(n) ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_unparsed_functions_entry_gc(n) ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_unparsed_functions_entry_gc(z) ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_unparsed_functions_entry_gc(z) ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_unparsed_functions_entry_gc(n, z) ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_unparsed_functions_entry_gc(n, z) ((struct VEC_cp_unparsed_functions_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_unparsed_functions_entry_base() ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_unparsed_functions_entry_base() ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_unparsed_functions_entry_base(n) ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_unparsed_functions_entry_base(n) ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_unparsed_functions_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_unparsed_functions_entry_base(z) ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_unparsed_functions_entry_base(z) ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_unparsed_functions_entry_base(n, z) ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_unparsed_functions_entry_base(n, z) ((struct VEC_cp_unparsed_functions_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_unparsed_functions_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cp_unparsed_functions_entry_d() ((struct cp_unparsed_functions_entry_d *)(ggc_internal_alloc_stat (sizeof (struct cp_unparsed_functions_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_unparsed_functions_entry_d() ((struct cp_unparsed_functions_entry_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_unparsed_functions_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_unparsed_functions_entry_d(n) ((struct cp_unparsed_functions_entry_d *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_unparsed_functions_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_unparsed_functions_entry_d(n) ((struct cp_unparsed_functions_entry_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_unparsed_functions_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_unparsed_functions_entry_d(z) ((struct cp_unparsed_functions_entry_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_unparsed_functions_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_unparsed_functions_entry_d(z) ((struct cp_unparsed_functions_entry_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_unparsed_functions_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_unparsed_functions_entry_d(n, z) ((struct cp_unparsed_functions_entry_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_unparsed_functions_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_unparsed_functions_entry_d(n, z) ((struct cp_unparsed_functions_entry_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_unparsed_functions_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_default_arg_entry_gc() ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_default_arg_entry_gc() ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_default_arg_entry_gc(n) ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_default_arg_entry_gc(n) ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_default_arg_entry_gc(z) ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_default_arg_entry_gc(z) ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_default_arg_entry_gc(n, z) ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_default_arg_entry_gc(n, z) ((struct VEC_cp_default_arg_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_default_arg_entry_base() ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_default_arg_entry_base() ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_default_arg_entry_base(n) ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_default_arg_entry_base(n) ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_default_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_default_arg_entry_base(z) ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_default_arg_entry_base(z) ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_default_arg_entry_base(n, z) ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_default_arg_entry_base(n, z) ((struct VEC_cp_default_arg_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_default_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cp_default_arg_entry_d() ((struct cp_default_arg_entry_d *)(ggc_internal_alloc_stat (sizeof (struct cp_default_arg_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_default_arg_entry_d() ((struct cp_default_arg_entry_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_default_arg_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_default_arg_entry_d(n) ((struct cp_default_arg_entry_d *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_default_arg_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_default_arg_entry_d(n) ((struct cp_default_arg_entry_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_default_arg_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_default_arg_entry_d(z) ((struct cp_default_arg_entry_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_default_arg_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_default_arg_entry_d(z) ((struct cp_default_arg_entry_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_default_arg_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_default_arg_entry_d(n, z) ((struct cp_default_arg_entry_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_default_arg_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_default_arg_entry_d(n, z) ((struct cp_default_arg_entry_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_default_arg_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_cp_parser_context() ((struct cp_parser_context *)(ggc_internal_alloc_stat (sizeof (struct cp_parser_context) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_parser_context() ((struct cp_parser_context *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_parser_context) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_parser_context(n) ((struct cp_parser_context *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_parser_context), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_parser_context(n) ((struct cp_parser_context *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_parser_context), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_parser_context(z) ((struct cp_parser_context *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_parser_context) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_parser_context(z) ((struct cp_parser_context *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_parser_context) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_parser_context(n, z) ((struct cp_parser_context *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_parser_context), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_parser_context(n, z) ((struct cp_parser_context *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_parser_context), n MEM_STAT_INFO))) +#define ggc_alloc_cp_lexer() ((struct cp_lexer *)(ggc_internal_alloc_stat (sizeof (struct cp_lexer) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_lexer() ((struct cp_lexer *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_lexer) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_lexer(n) ((struct cp_lexer *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_lexer), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_lexer(n) ((struct cp_lexer *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_lexer), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_lexer(z) ((struct cp_lexer *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_lexer) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_lexer(z) ((struct cp_lexer *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_lexer) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_lexer(n, z) ((struct cp_lexer *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_lexer), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_lexer(n, z) ((struct cp_lexer *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_lexer), n MEM_STAT_INFO))) +#define ggc_alloc_cp_token() ((struct cp_token *)(ggc_internal_alloc_stat (sizeof (struct cp_token) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_token() ((struct cp_token *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_token) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_token(n) ((struct cp_token *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_token), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_token(n) ((struct cp_token *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_token), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_token(z) ((struct cp_token *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_token) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_token(z) ((struct cp_token *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_token) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_token(n, z) ((struct cp_token *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_token), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_token(n, z) ((struct cp_token *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_token), n MEM_STAT_INFO))) +#define ggc_alloc_cp_token_value() ((union cp_token_value *)(ggc_internal_alloc_stat (sizeof (union cp_token_value) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_token_value() ((union cp_token_value *)(ggc_internal_cleared_alloc_stat (sizeof (union cp_token_value) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_token_value(n) ((union cp_token_value *)(ggc_internal_vec_alloc_stat (sizeof (union cp_token_value), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_token_value(n) ((union cp_token_value *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union cp_token_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_token_value(z) ((union cp_token_value *)(ggc_internal_zone_alloc_stat (z, sizeof (union cp_token_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_token_value(z) ((union cp_token_value *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union cp_token_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_token_value(n, z) ((union cp_token_value *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union cp_token_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_token_value(n, z) ((union cp_token_value *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union cp_token_value), n MEM_STAT_INFO))) +#define ggc_alloc_tree_check() ((struct tree_check *)(ggc_internal_alloc_stat (sizeof (struct tree_check) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_check() ((struct tree_check *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_check) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_check(n) ((struct tree_check *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_check), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_check(n) ((struct tree_check *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_check), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_check(z) ((struct tree_check *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_check) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_check(z) ((struct tree_check *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_check) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_check(n, z) ((struct tree_check *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_check), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_check(n, z) ((struct tree_check *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_check), n MEM_STAT_INFO))) +#define ggc_alloc_constexpr_call() ((struct constexpr_call *)(ggc_internal_alloc_stat (sizeof (struct constexpr_call) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constexpr_call() ((struct constexpr_call *)(ggc_internal_cleared_alloc_stat (sizeof (struct constexpr_call) MEM_STAT_INFO))) +#define ggc_alloc_vec_constexpr_call(n) ((struct constexpr_call *)(ggc_internal_vec_alloc_stat (sizeof (struct constexpr_call), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constexpr_call(n) ((struct constexpr_call *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct constexpr_call), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constexpr_call(z) ((struct constexpr_call *)(ggc_internal_zone_alloc_stat (z, sizeof (struct constexpr_call) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constexpr_call(z) ((struct constexpr_call *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct constexpr_call) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_constexpr_call(n, z) ((struct constexpr_call *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct constexpr_call), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constexpr_call(n, z) ((struct constexpr_call *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct constexpr_call), n MEM_STAT_INFO))) +#define ggc_alloc_constexpr_fundef() ((struct constexpr_fundef *)(ggc_internal_alloc_stat (sizeof (struct constexpr_fundef) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constexpr_fundef() ((struct constexpr_fundef *)(ggc_internal_cleared_alloc_stat (sizeof (struct constexpr_fundef) MEM_STAT_INFO))) +#define ggc_alloc_vec_constexpr_fundef(n) ((struct constexpr_fundef *)(ggc_internal_vec_alloc_stat (sizeof (struct constexpr_fundef), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constexpr_fundef(n) ((struct constexpr_fundef *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct constexpr_fundef), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constexpr_fundef(z) ((struct constexpr_fundef *)(ggc_internal_zone_alloc_stat (z, sizeof (struct constexpr_fundef) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constexpr_fundef(z) ((struct constexpr_fundef *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct constexpr_fundef) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_constexpr_fundef(n, z) ((struct constexpr_fundef *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct constexpr_fundef), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constexpr_fundef(n, z) ((struct constexpr_fundef *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct constexpr_fundef), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_deferred_access_gc() ((struct VEC_deferred_access_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_deferred_access_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_deferred_access_gc() ((struct VEC_deferred_access_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_deferred_access_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_deferred_access_gc(n) ((struct VEC_deferred_access_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_deferred_access_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_deferred_access_gc(n) ((struct VEC_deferred_access_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_deferred_access_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_deferred_access_gc(z) ((struct VEC_deferred_access_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_deferred_access_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_deferred_access_gc(z) ((struct VEC_deferred_access_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_deferred_access_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_deferred_access_gc(n, z) ((struct VEC_deferred_access_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_deferred_access_gc(n, z) ((struct VEC_deferred_access_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_deferred_access_base() ((struct VEC_deferred_access_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_deferred_access_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_deferred_access_base() ((struct VEC_deferred_access_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_deferred_access_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_deferred_access_base(n) ((struct VEC_deferred_access_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_deferred_access_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_deferred_access_base(n) ((struct VEC_deferred_access_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_deferred_access_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_deferred_access_base(z) ((struct VEC_deferred_access_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_deferred_access_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_deferred_access_base(z) ((struct VEC_deferred_access_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_deferred_access_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_deferred_access_base(n, z) ((struct VEC_deferred_access_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_deferred_access_base(n, z) ((struct VEC_deferred_access_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_base), n MEM_STAT_INFO))) +#define ggc_alloc_deferred_access() ((struct deferred_access *)(ggc_internal_alloc_stat (sizeof (struct deferred_access) MEM_STAT_INFO))) +#define ggc_alloc_cleared_deferred_access() ((struct deferred_access *)(ggc_internal_cleared_alloc_stat (sizeof (struct deferred_access) MEM_STAT_INFO))) +#define ggc_alloc_vec_deferred_access(n) ((struct deferred_access *)(ggc_internal_vec_alloc_stat (sizeof (struct deferred_access), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_deferred_access(n) ((struct deferred_access *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct deferred_access), n MEM_STAT_INFO))) +#define ggc_alloc_zone_deferred_access(z) ((struct deferred_access *)(ggc_internal_zone_alloc_stat (z, sizeof (struct deferred_access) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_deferred_access(z) ((struct deferred_access *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct deferred_access) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_deferred_access(n, z) ((struct deferred_access *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct deferred_access), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_deferred_access(n, z) ((struct deferred_access *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct deferred_access), n MEM_STAT_INFO))) +#define ggc_alloc_spec_entry() ((struct spec_entry *)(ggc_internal_alloc_stat (sizeof (struct spec_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_spec_entry() ((struct spec_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct spec_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_spec_entry(n) ((struct spec_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct spec_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_spec_entry(n) ((struct spec_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct spec_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_spec_entry(z) ((struct spec_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct spec_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_spec_entry(z) ((struct spec_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct spec_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_spec_entry(n, z) ((struct spec_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct spec_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_spec_entry(n, z) ((struct spec_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct spec_entry), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pending_attribute_p_gc() ((struct VEC_pending_attribute_p_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_pending_attribute_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pending_attribute_p_gc() ((struct VEC_pending_attribute_p_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pending_attribute_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pending_attribute_p_gc(n) ((struct VEC_pending_attribute_p_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pending_attribute_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pending_attribute_p_gc(n) ((struct VEC_pending_attribute_p_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pending_attribute_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pending_attribute_p_gc(z) ((struct VEC_pending_attribute_p_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pending_attribute_p_gc(z) ((struct VEC_pending_attribute_p_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pending_attribute_p_gc(n, z) ((struct VEC_pending_attribute_p_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pending_attribute_p_gc(n, z) ((struct VEC_pending_attribute_p_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pending_attribute_p_base() ((struct VEC_pending_attribute_p_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_pending_attribute_p_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pending_attribute_p_base() ((struct VEC_pending_attribute_p_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pending_attribute_p_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pending_attribute_p_base(n) ((struct VEC_pending_attribute_p_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pending_attribute_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pending_attribute_p_base(n) ((struct VEC_pending_attribute_p_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pending_attribute_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pending_attribute_p_base(z) ((struct VEC_pending_attribute_p_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pending_attribute_p_base(z) ((struct VEC_pending_attribute_p_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pending_attribute_p_base(n, z) ((struct VEC_pending_attribute_p_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pending_attribute_p_base(n, z) ((struct VEC_pending_attribute_p_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pending_attribute_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_pending_attribute() ((struct pending_attribute *)(ggc_internal_alloc_stat (sizeof (struct pending_attribute) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_attribute() ((struct pending_attribute *)(ggc_internal_cleared_alloc_stat (sizeof (struct pending_attribute) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_attribute(n) ((struct pending_attribute *)(ggc_internal_vec_alloc_stat (sizeof (struct pending_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_attribute(n) ((struct pending_attribute *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pending_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_attribute(z) ((struct pending_attribute *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pending_attribute) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_attribute(z) ((struct pending_attribute *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pending_attribute) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pending_attribute(n, z) ((struct pending_attribute *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pending_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_attribute(n, z) ((struct pending_attribute *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pending_attribute), n MEM_STAT_INFO))) +#define ggc_alloc_pending_template() ((struct pending_template *)(ggc_internal_alloc_stat (sizeof (struct pending_template) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_template() ((struct pending_template *)(ggc_internal_cleared_alloc_stat (sizeof (struct pending_template) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_template(n) ((struct pending_template *)(ggc_internal_vec_alloc_stat (sizeof (struct pending_template), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_template(n) ((struct pending_template *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pending_template), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_template(z) ((struct pending_template *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pending_template) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_template(z) ((struct pending_template *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pending_template) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pending_template(n, z) ((struct pending_template *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pending_template), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_template(n, z) ((struct pending_template *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pending_template), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_incomplete_var_gc() ((struct VEC_incomplete_var_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_incomplete_var_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_incomplete_var_gc() ((struct VEC_incomplete_var_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_incomplete_var_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_incomplete_var_gc(n) ((struct VEC_incomplete_var_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_incomplete_var_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_incomplete_var_gc(n) ((struct VEC_incomplete_var_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_incomplete_var_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_incomplete_var_gc(z) ((struct VEC_incomplete_var_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_incomplete_var_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_incomplete_var_gc(z) ((struct VEC_incomplete_var_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_incomplete_var_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_incomplete_var_gc(n, z) ((struct VEC_incomplete_var_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_incomplete_var_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_incomplete_var_gc(n, z) ((struct VEC_incomplete_var_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_incomplete_var_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_incomplete_var_base() ((struct VEC_incomplete_var_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_incomplete_var_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_incomplete_var_base() ((struct VEC_incomplete_var_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_incomplete_var_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_incomplete_var_base(n) ((struct VEC_incomplete_var_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_incomplete_var_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_incomplete_var_base(n) ((struct VEC_incomplete_var_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_incomplete_var_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_incomplete_var_base(z) ((struct VEC_incomplete_var_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_incomplete_var_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_incomplete_var_base(z) ((struct VEC_incomplete_var_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_incomplete_var_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_incomplete_var_base(n, z) ((struct VEC_incomplete_var_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_incomplete_var_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_incomplete_var_base(n, z) ((struct VEC_incomplete_var_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_incomplete_var_base), n MEM_STAT_INFO))) +#define ggc_alloc_incomplete_var_d() ((struct incomplete_var_d *)(ggc_internal_alloc_stat (sizeof (struct incomplete_var_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_incomplete_var_d() ((struct incomplete_var_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct incomplete_var_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_incomplete_var_d(n) ((struct incomplete_var_d *)(ggc_internal_vec_alloc_stat (sizeof (struct incomplete_var_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_incomplete_var_d(n) ((struct incomplete_var_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct incomplete_var_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_incomplete_var_d(z) ((struct incomplete_var_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct incomplete_var_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_incomplete_var_d(z) ((struct incomplete_var_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct incomplete_var_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_incomplete_var_d(n, z) ((struct incomplete_var_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct incomplete_var_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_incomplete_var_d(n, z) ((struct incomplete_var_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct incomplete_var_d), n MEM_STAT_INFO))) +#define ggc_alloc_named_label_use_entry() ((struct named_label_use_entry *)(ggc_internal_alloc_stat (sizeof (struct named_label_use_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_named_label_use_entry() ((struct named_label_use_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct named_label_use_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_named_label_use_entry(n) ((struct named_label_use_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct named_label_use_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_named_label_use_entry(n) ((struct named_label_use_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct named_label_use_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_named_label_use_entry(z) ((struct named_label_use_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct named_label_use_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_named_label_use_entry(z) ((struct named_label_use_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct named_label_use_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_named_label_use_entry(n, z) ((struct named_label_use_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct named_label_use_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_named_label_use_entry(n, z) ((struct named_label_use_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct named_label_use_entry), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_deferred_access_check_gc() ((struct VEC_deferred_access_check_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_deferred_access_check_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_deferred_access_check_gc() ((struct VEC_deferred_access_check_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_deferred_access_check_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_deferred_access_check_gc(n) ((struct VEC_deferred_access_check_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_deferred_access_check_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_deferred_access_check_gc(n) ((struct VEC_deferred_access_check_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_deferred_access_check_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_deferred_access_check_gc(z) ((struct VEC_deferred_access_check_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_deferred_access_check_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_deferred_access_check_gc(z) ((struct VEC_deferred_access_check_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_deferred_access_check_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_deferred_access_check_gc(n, z) ((struct VEC_deferred_access_check_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_check_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_deferred_access_check_gc(n, z) ((struct VEC_deferred_access_check_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_check_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_deferred_access_check_base() ((struct VEC_deferred_access_check_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_deferred_access_check_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_deferred_access_check_base() ((struct VEC_deferred_access_check_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_deferred_access_check_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_deferred_access_check_base(n) ((struct VEC_deferred_access_check_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_deferred_access_check_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_deferred_access_check_base(n) ((struct VEC_deferred_access_check_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_deferred_access_check_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_deferred_access_check_base(z) ((struct VEC_deferred_access_check_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_deferred_access_check_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_deferred_access_check_base(z) ((struct VEC_deferred_access_check_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_deferred_access_check_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_deferred_access_check_base(n, z) ((struct VEC_deferred_access_check_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_check_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_deferred_access_check_base(n, z) ((struct VEC_deferred_access_check_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_deferred_access_check_base), n MEM_STAT_INFO))) +#define ggc_alloc_deferred_access_check() ((struct deferred_access_check *)(ggc_internal_alloc_stat (sizeof (struct deferred_access_check) MEM_STAT_INFO))) +#define ggc_alloc_cleared_deferred_access_check() ((struct deferred_access_check *)(ggc_internal_cleared_alloc_stat (sizeof (struct deferred_access_check) MEM_STAT_INFO))) +#define ggc_alloc_vec_deferred_access_check(n) ((struct deferred_access_check *)(ggc_internal_vec_alloc_stat (sizeof (struct deferred_access_check), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_deferred_access_check(n) ((struct deferred_access_check *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct deferred_access_check), n MEM_STAT_INFO))) +#define ggc_alloc_zone_deferred_access_check(z) ((struct deferred_access_check *)(ggc_internal_zone_alloc_stat (z, sizeof (struct deferred_access_check) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_deferred_access_check(z) ((struct deferred_access_check *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct deferred_access_check) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_deferred_access_check(n, z) ((struct deferred_access_check *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct deferred_access_check), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_deferred_access_check(n, z) ((struct deferred_access_check *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct deferred_access_check), n MEM_STAT_INFO))) +#define ggc_alloc_operator_name_info_t() ((struct operator_name_info_t *)(ggc_internal_alloc_stat (sizeof (struct operator_name_info_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_operator_name_info_t() ((struct operator_name_info_t *)(ggc_internal_cleared_alloc_stat (sizeof (struct operator_name_info_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_operator_name_info_t(n) ((struct operator_name_info_t *)(ggc_internal_vec_alloc_stat (sizeof (struct operator_name_info_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_operator_name_info_t(n) ((struct operator_name_info_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct operator_name_info_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_operator_name_info_t(z) ((struct operator_name_info_t *)(ggc_internal_zone_alloc_stat (z, sizeof (struct operator_name_info_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_operator_name_info_t(z) ((struct operator_name_info_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct operator_name_info_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_operator_name_info_t(n, z) ((struct operator_name_info_t *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct operator_name_info_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_operator_name_info_t(n, z) ((struct operator_name_info_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct operator_name_info_t), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_u() ((struct lang_decl_u *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_u() ((struct lang_decl_u *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_u(n) ((struct lang_decl_u *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_u(n) ((struct lang_decl_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_u(z) ((struct lang_decl_u *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_u(z) ((struct lang_decl_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_u(n, z) ((struct lang_decl_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_u(n, z) ((struct lang_decl_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_u), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_parm() ((struct lang_decl_parm *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_parm) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_parm() ((struct lang_decl_parm *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_parm) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_parm(n) ((struct lang_decl_parm *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_parm), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_parm(n) ((struct lang_decl_parm *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_parm), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_parm(z) ((struct lang_decl_parm *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_parm) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_parm(z) ((struct lang_decl_parm *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_parm) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_parm(n, z) ((struct lang_decl_parm *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_parm), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_parm(n, z) ((struct lang_decl_parm *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_parm), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_ns() ((struct lang_decl_ns *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_ns) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_ns() ((struct lang_decl_ns *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_ns) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_ns(n) ((struct lang_decl_ns *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_ns), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_ns(n) ((struct lang_decl_ns *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_ns), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_ns(z) ((struct lang_decl_ns *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_ns) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_ns(z) ((struct lang_decl_ns *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_ns) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_ns(n, z) ((struct lang_decl_ns *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_ns), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_ns(n, z) ((struct lang_decl_ns *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_ns), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_fn() ((struct lang_decl_fn *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_fn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_fn() ((struct lang_decl_fn *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_fn) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_fn(n) ((struct lang_decl_fn *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_fn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_fn(n) ((struct lang_decl_fn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_fn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_fn(z) ((struct lang_decl_fn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_fn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_fn(z) ((struct lang_decl_fn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_fn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_fn(n, z) ((struct lang_decl_fn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_fn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_fn(n, z) ((struct lang_decl_fn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_fn), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_u3() ((union lang_decl_u3 *)(ggc_internal_alloc_stat (sizeof (union lang_decl_u3) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_u3() ((union lang_decl_u3 *)(ggc_internal_cleared_alloc_stat (sizeof (union lang_decl_u3) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_u3(n) ((union lang_decl_u3 *)(ggc_internal_vec_alloc_stat (sizeof (union lang_decl_u3), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_u3(n) ((union lang_decl_u3 *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union lang_decl_u3), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_u3(z) ((union lang_decl_u3 *)(ggc_internal_zone_alloc_stat (z, sizeof (union lang_decl_u3) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_u3(z) ((union lang_decl_u3 *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union lang_decl_u3) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_u3(n, z) ((union lang_decl_u3 *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union lang_decl_u3), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_u3(n, z) ((union lang_decl_u3 *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union lang_decl_u3), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_u5() ((union lang_decl_u5 *)(ggc_internal_alloc_stat (sizeof (union lang_decl_u5) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_u5() ((union lang_decl_u5 *)(ggc_internal_cleared_alloc_stat (sizeof (union lang_decl_u5) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_u5(n) ((union lang_decl_u5 *)(ggc_internal_vec_alloc_stat (sizeof (union lang_decl_u5), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_u5(n) ((union lang_decl_u5 *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union lang_decl_u5), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_u5(z) ((union lang_decl_u5 *)(ggc_internal_zone_alloc_stat (z, sizeof (union lang_decl_u5) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_u5(z) ((union lang_decl_u5 *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union lang_decl_u5) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_u5(n, z) ((union lang_decl_u5 *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union lang_decl_u5), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_u5(n, z) ((union lang_decl_u5 *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union lang_decl_u5), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_min() ((struct lang_decl_min *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_min) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_min() ((struct lang_decl_min *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_min) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_min(n) ((struct lang_decl_min *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_min), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_min(n) ((struct lang_decl_min *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_min), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_min(z) ((struct lang_decl_min *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_min) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_min(z) ((struct lang_decl_min *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_min) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_min(n, z) ((struct lang_decl_min *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_min), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_min(n, z) ((struct lang_decl_min *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_min), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_u2() ((union lang_decl_u2 *)(ggc_internal_alloc_stat (sizeof (union lang_decl_u2) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_u2() ((union lang_decl_u2 *)(ggc_internal_cleared_alloc_stat (sizeof (union lang_decl_u2) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_u2(n) ((union lang_decl_u2 *)(ggc_internal_vec_alloc_stat (sizeof (union lang_decl_u2), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_u2(n) ((union lang_decl_u2 *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union lang_decl_u2), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_u2(z) ((union lang_decl_u2 *)(ggc_internal_zone_alloc_stat (z, sizeof (union lang_decl_u2) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_u2(z) ((union lang_decl_u2 *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union lang_decl_u2) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_u2(n, z) ((union lang_decl_u2 *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union lang_decl_u2), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_u2(n, z) ((union lang_decl_u2 *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union lang_decl_u2), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl_base() ((struct lang_decl_base *)(ggc_internal_alloc_stat (sizeof (struct lang_decl_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl_base() ((struct lang_decl_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_decl_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl_base(n) ((struct lang_decl_base *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_decl_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl_base(n) ((struct lang_decl_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_decl_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl_base(z) ((struct lang_decl_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_decl_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl_base(z) ((struct lang_decl_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_decl_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl_base(n, z) ((struct lang_decl_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_decl_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl_base(n, z) ((struct lang_decl_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_decl_base), n MEM_STAT_INFO))) +#define ggc_alloc_lang_type_u() ((union lang_type_u *)(ggc_internal_alloc_stat (sizeof (union lang_type_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_type_u() ((union lang_type_u *)(ggc_internal_cleared_alloc_stat (sizeof (union lang_type_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_type_u(n) ((union lang_type_u *)(ggc_internal_vec_alloc_stat (sizeof (union lang_type_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_type_u(n) ((union lang_type_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union lang_type_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_type_u(z) ((union lang_type_u *)(ggc_internal_zone_alloc_stat (z, sizeof (union lang_type_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_type_u(z) ((union lang_type_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union lang_type_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_type_u(n, z) ((union lang_type_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union lang_type_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_type_u(n, z) ((union lang_type_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union lang_type_u), n MEM_STAT_INFO))) +#define ggc_alloc_lang_type_ptrmem() ((struct lang_type_ptrmem *)(ggc_internal_alloc_stat (sizeof (struct lang_type_ptrmem) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_type_ptrmem() ((struct lang_type_ptrmem *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_type_ptrmem) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_type_ptrmem(n) ((struct lang_type_ptrmem *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_type_ptrmem), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_type_ptrmem(n) ((struct lang_type_ptrmem *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_type_ptrmem), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_type_ptrmem(z) ((struct lang_type_ptrmem *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_type_ptrmem) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_type_ptrmem(z) ((struct lang_type_ptrmem *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_type_ptrmem) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_type_ptrmem(n, z) ((struct lang_type_ptrmem *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_type_ptrmem), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_type_ptrmem(n, z) ((struct lang_type_ptrmem *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_type_ptrmem), n MEM_STAT_INFO))) +#define ggc_alloc_lang_type_class() ((struct lang_type_class *)(ggc_internal_alloc_stat (sizeof (struct lang_type_class) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_type_class() ((struct lang_type_class *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_type_class) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_type_class(n) ((struct lang_type_class *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_type_class), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_type_class(n) ((struct lang_type_class *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_type_class), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_type_class(z) ((struct lang_type_class *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_type_class) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_type_class(z) ((struct lang_type_class *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_type_class) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_type_class(n, z) ((struct lang_type_class *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_type_class), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_type_class(n, z) ((struct lang_type_class *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_type_class), n MEM_STAT_INFO))) +#define ggc_alloc_sorted_fields_type(SIZE) ((struct sorted_fields_type *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_sorted_fields_type(SIZE) ((struct sorted_fields_type *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_sorted_fields_type(SIZE, n) ((struct sorted_fields_type *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_sorted_fields_type(SIZE, n) ((struct sorted_fields_type *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_sorted_fields_type(SIZE, z) ((struct sorted_fields_type *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_sorted_fields_type(SIZE, z) ((struct sorted_fields_type *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_sorted_fields_type(SIZE, n, z) ((struct sorted_fields_type *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_sorted_fields_type(SIZE, n, z) ((struct sorted_fields_type *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_lang_type_header() ((struct lang_type_header *)(ggc_internal_alloc_stat (sizeof (struct lang_type_header) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_type_header() ((struct lang_type_header *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_type_header) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_type_header(n) ((struct lang_type_header *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_type_header), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_type_header(n) ((struct lang_type_header *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_type_header), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_type_header(z) ((struct lang_type_header *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_type_header) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_type_header(z) ((struct lang_type_header *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_type_header) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_type_header(n, z) ((struct lang_type_header *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_type_header), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_type_header(n, z) ((struct lang_type_header *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_type_header), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_pair_s_gc() ((struct VEC_tree_pair_s_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_pair_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_pair_s_gc() ((struct VEC_tree_pair_s_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_pair_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_pair_s_gc(n) ((struct VEC_tree_pair_s_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_pair_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_pair_s_gc(n) ((struct VEC_tree_pair_s_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_pair_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_pair_s_gc(z) ((struct VEC_tree_pair_s_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_pair_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_pair_s_gc(z) ((struct VEC_tree_pair_s_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_pair_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_pair_s_gc(n, z) ((struct VEC_tree_pair_s_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_pair_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_pair_s_gc(n, z) ((struct VEC_tree_pair_s_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_pair_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_pair_s_base() ((struct VEC_tree_pair_s_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_pair_s_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_pair_s_base() ((struct VEC_tree_pair_s_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_pair_s_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_pair_s_base(n) ((struct VEC_tree_pair_s_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_pair_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_pair_s_base(n) ((struct VEC_tree_pair_s_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_pair_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_pair_s_base(z) ((struct VEC_tree_pair_s_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_pair_s_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_pair_s_base(z) ((struct VEC_tree_pair_s_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_pair_s_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_pair_s_base(n, z) ((struct VEC_tree_pair_s_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_pair_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_pair_s_base(n, z) ((struct VEC_tree_pair_s_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_pair_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_tree_pair_s() ((struct tree_pair_s *)(ggc_internal_alloc_stat (sizeof (struct tree_pair_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_pair_s() ((struct tree_pair_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_pair_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_pair_s(n) ((struct tree_pair_s *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_pair_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_pair_s(n) ((struct tree_pair_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_pair_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_pair_s(z) ((struct tree_pair_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_pair_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_pair_s(z) ((struct tree_pair_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_pair_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_pair_s(n, z) ((struct tree_pair_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_pair_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_pair_s(n, z) ((struct tree_pair_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_pair_s), n MEM_STAT_INFO))) +#define ggc_alloc_named_label_entry() ((struct named_label_entry *)(ggc_internal_alloc_stat (sizeof (struct named_label_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_named_label_entry() ((struct named_label_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct named_label_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_named_label_entry(n) ((struct named_label_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct named_label_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_named_label_entry(n) ((struct named_label_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct named_label_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_named_label_entry(z) ((struct named_label_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct named_label_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_named_label_entry(z) ((struct named_label_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct named_label_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_named_label_entry(n, z) ((struct named_label_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct named_label_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_named_label_entry(n, z) ((struct named_label_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct named_label_entry), n MEM_STAT_INFO))) +#define ggc_alloc_c_language_function() ((struct c_language_function *)(ggc_internal_alloc_stat (sizeof (struct c_language_function) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_language_function() ((struct c_language_function *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_language_function) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_language_function(n) ((struct c_language_function *)(ggc_internal_vec_alloc_stat (sizeof (struct c_language_function), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_language_function(n) ((struct c_language_function *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_language_function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_language_function(z) ((struct c_language_function *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_language_function) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_language_function(z) ((struct c_language_function *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_language_function) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_language_function(n, z) ((struct c_language_function *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_language_function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_language_function(n, z) ((struct c_language_function *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_language_function), n MEM_STAT_INFO))) +#define ggc_alloc_stmt_tree_s() ((struct stmt_tree_s *)(ggc_internal_alloc_stat (sizeof (struct stmt_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_stmt_tree_s() ((struct stmt_tree_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct stmt_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_stmt_tree_s(n) ((struct stmt_tree_s *)(ggc_internal_vec_alloc_stat (sizeof (struct stmt_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_stmt_tree_s(n) ((struct stmt_tree_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct stmt_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_stmt_tree_s(z) ((struct stmt_tree_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct stmt_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_stmt_tree_s(z) ((struct stmt_tree_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct stmt_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_stmt_tree_s(n, z) ((struct stmt_tree_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct stmt_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_stmt_tree_s(n, z) ((struct stmt_tree_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct stmt_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_tree_template_info() ((struct tree_template_info *)(ggc_internal_alloc_stat (sizeof (struct tree_template_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_template_info() ((struct tree_template_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_template_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_template_info(n) ((struct tree_template_info *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_template_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_template_info(n) ((struct tree_template_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_template_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_template_info(z) ((struct tree_template_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_template_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_template_info(z) ((struct tree_template_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_template_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_template_info(n, z) ((struct tree_template_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_template_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_template_info(n, z) ((struct tree_template_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_template_info), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_qualified_typedef_usage_t_gc() ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_qualified_typedef_usage_t_gc() ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_qualified_typedef_usage_t_gc(n) ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_qualified_typedef_usage_t_gc(n) ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_qualified_typedef_usage_t_gc(z) ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_qualified_typedef_usage_t_gc(z) ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_qualified_typedef_usage_t_gc(n, z) ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_qualified_typedef_usage_t_gc(n, z) ((struct VEC_qualified_typedef_usage_t_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_qualified_typedef_usage_t_base() ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_qualified_typedef_usage_t_base() ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_qualified_typedef_usage_t_base(n) ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_qualified_typedef_usage_t_base(n) ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_qualified_typedef_usage_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_qualified_typedef_usage_t_base(z) ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_qualified_typedef_usage_t_base(z) ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_qualified_typedef_usage_t_base(n, z) ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_qualified_typedef_usage_t_base(n, z) ((struct VEC_qualified_typedef_usage_t_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_qualified_typedef_usage_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_qualified_typedef_usage_s() ((struct qualified_typedef_usage_s *)(ggc_internal_alloc_stat (sizeof (struct qualified_typedef_usage_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_qualified_typedef_usage_s() ((struct qualified_typedef_usage_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct qualified_typedef_usage_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_qualified_typedef_usage_s(n) ((struct qualified_typedef_usage_s *)(ggc_internal_vec_alloc_stat (sizeof (struct qualified_typedef_usage_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_qualified_typedef_usage_s(n) ((struct qualified_typedef_usage_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct qualified_typedef_usage_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_qualified_typedef_usage_s(z) ((struct qualified_typedef_usage_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct qualified_typedef_usage_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_qualified_typedef_usage_s(z) ((struct qualified_typedef_usage_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct qualified_typedef_usage_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_qualified_typedef_usage_s(n, z) ((struct qualified_typedef_usage_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct qualified_typedef_usage_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_qualified_typedef_usage_s(n, z) ((struct qualified_typedef_usage_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct qualified_typedef_usage_s), n MEM_STAT_INFO))) +#define ggc_alloc_tree_lambda_expr() ((struct tree_lambda_expr *)(ggc_internal_alloc_stat (sizeof (struct tree_lambda_expr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_lambda_expr() ((struct tree_lambda_expr *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_lambda_expr) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_lambda_expr(n) ((struct tree_lambda_expr *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_lambda_expr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_lambda_expr(n) ((struct tree_lambda_expr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_lambda_expr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_lambda_expr(z) ((struct tree_lambda_expr *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_lambda_expr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_lambda_expr(z) ((struct tree_lambda_expr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_lambda_expr) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_lambda_expr(n, z) ((struct tree_lambda_expr *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_lambda_expr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_lambda_expr(n, z) ((struct tree_lambda_expr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_lambda_expr), n MEM_STAT_INFO))) +#define ggc_alloc_tree_trait_expr() ((struct tree_trait_expr *)(ggc_internal_alloc_stat (sizeof (struct tree_trait_expr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_trait_expr() ((struct tree_trait_expr *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_trait_expr) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_trait_expr(n) ((struct tree_trait_expr *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_trait_expr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_trait_expr(n) ((struct tree_trait_expr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_trait_expr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_trait_expr(z) ((struct tree_trait_expr *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_trait_expr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_trait_expr(z) ((struct tree_trait_expr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_trait_expr) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_trait_expr(n, z) ((struct tree_trait_expr *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_trait_expr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_trait_expr(n, z) ((struct tree_trait_expr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_trait_expr), n MEM_STAT_INFO))) +#define ggc_alloc_tree_argument_pack_select() ((struct tree_argument_pack_select *)(ggc_internal_alloc_stat (sizeof (struct tree_argument_pack_select) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_argument_pack_select() ((struct tree_argument_pack_select *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_argument_pack_select) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_argument_pack_select(n) ((struct tree_argument_pack_select *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_argument_pack_select), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_argument_pack_select(n) ((struct tree_argument_pack_select *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_argument_pack_select), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_argument_pack_select(z) ((struct tree_argument_pack_select *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_argument_pack_select) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_argument_pack_select(z) ((struct tree_argument_pack_select *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_argument_pack_select) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_argument_pack_select(n, z) ((struct tree_argument_pack_select *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_argument_pack_select), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_argument_pack_select(n, z) ((struct tree_argument_pack_select *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_argument_pack_select), n MEM_STAT_INFO))) +#define ggc_alloc_tree_static_assert() ((struct tree_static_assert *)(ggc_internal_alloc_stat (sizeof (struct tree_static_assert) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_static_assert() ((struct tree_static_assert *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_static_assert) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_static_assert(n) ((struct tree_static_assert *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_static_assert), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_static_assert(n) ((struct tree_static_assert *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_static_assert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_static_assert(z) ((struct tree_static_assert *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_static_assert) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_static_assert(z) ((struct tree_static_assert *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_static_assert) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_static_assert(n, z) ((struct tree_static_assert *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_static_assert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_static_assert(n, z) ((struct tree_static_assert *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_static_assert), n MEM_STAT_INFO))) +#define ggc_alloc_tree_default_arg() ((struct tree_default_arg *)(ggc_internal_alloc_stat (sizeof (struct tree_default_arg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_default_arg() ((struct tree_default_arg *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_default_arg) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_default_arg(n) ((struct tree_default_arg *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_default_arg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_default_arg(n) ((struct tree_default_arg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_default_arg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_default_arg(z) ((struct tree_default_arg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_default_arg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_default_arg(z) ((struct tree_default_arg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_default_arg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_default_arg(n, z) ((struct tree_default_arg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_default_arg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_default_arg(n, z) ((struct tree_default_arg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_default_arg), n MEM_STAT_INFO))) +#define ggc_alloc_cp_token_cache() ((struct cp_token_cache *)(ggc_internal_alloc_stat (sizeof (struct cp_token_cache) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_token_cache() ((struct cp_token_cache *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_token_cache) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_token_cache(n) ((struct cp_token_cache *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_token_cache), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_token_cache(n) ((struct cp_token_cache *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_token_cache), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_token_cache(z) ((struct cp_token_cache *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_token_cache) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_token_cache(z) ((struct cp_token_cache *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_token_cache) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_token_cache(n, z) ((struct cp_token_cache *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_token_cache), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_token_cache(n, z) ((struct cp_token_cache *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_token_cache), n MEM_STAT_INFO))) +#define ggc_alloc_tree_baselink() ((struct tree_baselink *)(ggc_internal_alloc_stat (sizeof (struct tree_baselink) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_baselink() ((struct tree_baselink *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_baselink) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_baselink(n) ((struct tree_baselink *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_baselink), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_baselink(n) ((struct tree_baselink *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_baselink), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_baselink(z) ((struct tree_baselink *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_baselink) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_baselink(z) ((struct tree_baselink *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_baselink) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_baselink(n, z) ((struct tree_baselink *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_baselink), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_baselink(n, z) ((struct tree_baselink *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_baselink), n MEM_STAT_INFO))) +#define ggc_alloc_tree_overload() ((struct tree_overload *)(ggc_internal_alloc_stat (sizeof (struct tree_overload) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_overload() ((struct tree_overload *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_overload) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_overload(n) ((struct tree_overload *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_overload), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_overload(n) ((struct tree_overload *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_overload), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_overload(z) ((struct tree_overload *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_overload) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_overload(z) ((struct tree_overload *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_overload) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_overload(n, z) ((struct tree_overload *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_overload), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_overload(n, z) ((struct tree_overload *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_overload), n MEM_STAT_INFO))) +#define ggc_alloc_ptrmem_cst() ((struct ptrmem_cst *)(ggc_internal_alloc_stat (sizeof (struct ptrmem_cst) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ptrmem_cst() ((struct ptrmem_cst *)(ggc_internal_cleared_alloc_stat (sizeof (struct ptrmem_cst) MEM_STAT_INFO))) +#define ggc_alloc_vec_ptrmem_cst(n) ((struct ptrmem_cst *)(ggc_internal_vec_alloc_stat (sizeof (struct ptrmem_cst), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ptrmem_cst(n) ((struct ptrmem_cst *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ptrmem_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ptrmem_cst(z) ((struct ptrmem_cst *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ptrmem_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ptrmem_cst(z) ((struct ptrmem_cst *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ptrmem_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ptrmem_cst(n, z) ((struct ptrmem_cst *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ptrmem_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ptrmem_cst(n, z) ((struct ptrmem_cst *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ptrmem_cst), n MEM_STAT_INFO))) +#define ggc_alloc_template_parm_index_s() ((struct template_parm_index_s *)(ggc_internal_alloc_stat (sizeof (struct template_parm_index_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_template_parm_index_s() ((struct template_parm_index_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct template_parm_index_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_template_parm_index_s(n) ((struct template_parm_index_s *)(ggc_internal_vec_alloc_stat (sizeof (struct template_parm_index_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_template_parm_index_s(n) ((struct template_parm_index_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct template_parm_index_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_template_parm_index_s(z) ((struct template_parm_index_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct template_parm_index_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_template_parm_index_s(z) ((struct template_parm_index_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct template_parm_index_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_template_parm_index_s(n, z) ((struct template_parm_index_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct template_parm_index_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_template_parm_index_s(n, z) ((struct template_parm_index_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct template_parm_index_s), n MEM_STAT_INFO))) +#define ggc_alloc_lang_identifier() ((struct lang_identifier *)(ggc_internal_alloc_stat (sizeof (struct lang_identifier) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_identifier() ((struct lang_identifier *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_identifier) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_identifier(n) ((struct lang_identifier *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_identifier(n) ((struct lang_identifier *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_identifier(z) ((struct lang_identifier *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_identifier(z) ((struct lang_identifier *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_identifier(n, z) ((struct lang_identifier *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_identifier(n, z) ((struct lang_identifier *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_c_common_identifier() ((struct c_common_identifier *)(ggc_internal_alloc_stat (sizeof (struct c_common_identifier) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_common_identifier() ((struct c_common_identifier *)(ggc_internal_cleared_alloc_stat (sizeof (struct c_common_identifier) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_common_identifier(n) ((struct c_common_identifier *)(ggc_internal_vec_alloc_stat (sizeof (struct c_common_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_common_identifier(n) ((struct c_common_identifier *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct c_common_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_common_identifier(z) ((struct c_common_identifier *)(ggc_internal_zone_alloc_stat (z, sizeof (struct c_common_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_common_identifier(z) ((struct c_common_identifier *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct c_common_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_c_common_identifier(n, z) ((struct c_common_identifier *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct c_common_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_common_identifier(n, z) ((struct c_common_identifier *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct c_common_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_saved_scope() ((struct saved_scope *)(ggc_internal_alloc_stat (sizeof (struct saved_scope) MEM_STAT_INFO))) +#define ggc_alloc_cleared_saved_scope() ((struct saved_scope *)(ggc_internal_cleared_alloc_stat (sizeof (struct saved_scope) MEM_STAT_INFO))) +#define ggc_alloc_vec_saved_scope(n) ((struct saved_scope *)(ggc_internal_vec_alloc_stat (sizeof (struct saved_scope), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_saved_scope(n) ((struct saved_scope *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct saved_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_saved_scope(z) ((struct saved_scope *)(ggc_internal_zone_alloc_stat (z, sizeof (struct saved_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_saved_scope(z) ((struct saved_scope *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct saved_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_saved_scope(n, z) ((struct saved_scope *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct saved_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_saved_scope(n, z) ((struct saved_scope *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct saved_scope), n MEM_STAT_INFO))) +#define ggc_alloc_cxx_int_tree_map() ((struct cxx_int_tree_map *)(ggc_internal_alloc_stat (sizeof (struct cxx_int_tree_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cxx_int_tree_map() ((struct cxx_int_tree_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct cxx_int_tree_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_cxx_int_tree_map(n) ((struct cxx_int_tree_map *)(ggc_internal_vec_alloc_stat (sizeof (struct cxx_int_tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cxx_int_tree_map(n) ((struct cxx_int_tree_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cxx_int_tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cxx_int_tree_map(z) ((struct cxx_int_tree_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cxx_int_tree_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cxx_int_tree_map(z) ((struct cxx_int_tree_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cxx_int_tree_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cxx_int_tree_map(n, z) ((struct cxx_int_tree_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cxx_int_tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cxx_int_tree_map(n, z) ((struct cxx_int_tree_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cxx_int_tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_label_binding_gc() ((struct VEC_cp_label_binding_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_label_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_label_binding_gc() ((struct VEC_cp_label_binding_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_label_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_label_binding_gc(n) ((struct VEC_cp_label_binding_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_label_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_label_binding_gc(n) ((struct VEC_cp_label_binding_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_label_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_label_binding_gc(z) ((struct VEC_cp_label_binding_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_label_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_label_binding_gc(z) ((struct VEC_cp_label_binding_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_label_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_label_binding_gc(n, z) ((struct VEC_cp_label_binding_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_label_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_label_binding_gc(n, z) ((struct VEC_cp_label_binding_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_label_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_label_binding_base() ((struct VEC_cp_label_binding_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_label_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_label_binding_base() ((struct VEC_cp_label_binding_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_label_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_label_binding_base(n) ((struct VEC_cp_label_binding_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_label_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_label_binding_base(n) ((struct VEC_cp_label_binding_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_label_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_label_binding_base(z) ((struct VEC_cp_label_binding_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_label_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_label_binding_base(z) ((struct VEC_cp_label_binding_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_label_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_label_binding_base(n, z) ((struct VEC_cp_label_binding_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_label_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_label_binding_base(n, z) ((struct VEC_cp_label_binding_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_label_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_cp_label_binding() ((struct cp_label_binding *)(ggc_internal_alloc_stat (sizeof (struct cp_label_binding) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_label_binding() ((struct cp_label_binding *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_label_binding) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_label_binding(n) ((struct cp_label_binding *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_label_binding), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_label_binding(n) ((struct cp_label_binding *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_label_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_label_binding(z) ((struct cp_label_binding *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_label_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_label_binding(z) ((struct cp_label_binding *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_label_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_label_binding(n, z) ((struct cp_label_binding *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_label_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_label_binding(n, z) ((struct cp_label_binding *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_label_binding), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_class_binding_gc() ((struct VEC_cp_class_binding_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_class_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_class_binding_gc() ((struct VEC_cp_class_binding_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_class_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_class_binding_gc(n) ((struct VEC_cp_class_binding_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_class_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_class_binding_gc(n) ((struct VEC_cp_class_binding_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_class_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_class_binding_gc(z) ((struct VEC_cp_class_binding_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_class_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_class_binding_gc(z) ((struct VEC_cp_class_binding_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_class_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_class_binding_gc(n, z) ((struct VEC_cp_class_binding_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_class_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_class_binding_gc(n, z) ((struct VEC_cp_class_binding_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_class_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cp_class_binding_base() ((struct VEC_cp_class_binding_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_cp_class_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cp_class_binding_base() ((struct VEC_cp_class_binding_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cp_class_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cp_class_binding_base(n) ((struct VEC_cp_class_binding_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cp_class_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cp_class_binding_base(n) ((struct VEC_cp_class_binding_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cp_class_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cp_class_binding_base(z) ((struct VEC_cp_class_binding_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cp_class_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cp_class_binding_base(z) ((struct VEC_cp_class_binding_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cp_class_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cp_class_binding_base(n, z) ((struct VEC_cp_class_binding_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cp_class_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cp_class_binding_base(n, z) ((struct VEC_cp_class_binding_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cp_class_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_cp_class_binding() ((struct cp_class_binding *)(ggc_internal_alloc_stat (sizeof (struct cp_class_binding) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_class_binding() ((struct cp_class_binding *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_class_binding) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_class_binding(n) ((struct cp_class_binding *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_class_binding), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_class_binding(n) ((struct cp_class_binding *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_class_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_class_binding(z) ((struct cp_class_binding *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_class_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_class_binding(z) ((struct cp_class_binding *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_class_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_class_binding(n, z) ((struct cp_class_binding *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_class_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_class_binding(n, z) ((struct cp_class_binding *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_class_binding), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cxx_saved_binding_gc() ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_cxx_saved_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cxx_saved_binding_gc() ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cxx_saved_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cxx_saved_binding_gc(n) ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cxx_saved_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cxx_saved_binding_gc(n) ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cxx_saved_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cxx_saved_binding_gc(z) ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cxx_saved_binding_gc(z) ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cxx_saved_binding_gc(n, z) ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cxx_saved_binding_gc(n, z) ((struct VEC_cxx_saved_binding_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cxx_saved_binding_base() ((struct VEC_cxx_saved_binding_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_cxx_saved_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cxx_saved_binding_base() ((struct VEC_cxx_saved_binding_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cxx_saved_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cxx_saved_binding_base(n) ((struct VEC_cxx_saved_binding_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cxx_saved_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cxx_saved_binding_base(n) ((struct VEC_cxx_saved_binding_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cxx_saved_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cxx_saved_binding_base(z) ((struct VEC_cxx_saved_binding_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cxx_saved_binding_base(z) ((struct VEC_cxx_saved_binding_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cxx_saved_binding_base(n, z) ((struct VEC_cxx_saved_binding_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cxx_saved_binding_base(n, z) ((struct VEC_cxx_saved_binding_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cxx_saved_binding_base), n MEM_STAT_INFO))) +#define ggc_alloc_cxx_saved_binding() ((struct cxx_saved_binding *)(ggc_internal_alloc_stat (sizeof (struct cxx_saved_binding) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cxx_saved_binding() ((struct cxx_saved_binding *)(ggc_internal_cleared_alloc_stat (sizeof (struct cxx_saved_binding) MEM_STAT_INFO))) +#define ggc_alloc_vec_cxx_saved_binding(n) ((struct cxx_saved_binding *)(ggc_internal_vec_alloc_stat (sizeof (struct cxx_saved_binding), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cxx_saved_binding(n) ((struct cxx_saved_binding *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cxx_saved_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cxx_saved_binding(z) ((struct cxx_saved_binding *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cxx_saved_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cxx_saved_binding(z) ((struct cxx_saved_binding *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cxx_saved_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cxx_saved_binding(n, z) ((struct cxx_saved_binding *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cxx_saved_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cxx_saved_binding(n, z) ((struct cxx_saved_binding *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cxx_saved_binding), n MEM_STAT_INFO))) +#define ggc_alloc_cp_binding_level() ((struct cp_binding_level *)(ggc_internal_alloc_stat (sizeof (struct cp_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_binding_level() ((struct cp_binding_level *)(ggc_internal_cleared_alloc_stat (sizeof (struct cp_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_binding_level(n) ((struct cp_binding_level *)(ggc_internal_vec_alloc_stat (sizeof (struct cp_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_binding_level(n) ((struct cp_binding_level *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cp_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_binding_level(z) ((struct cp_binding_level *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cp_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_binding_level(z) ((struct cp_binding_level *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cp_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cp_binding_level(n, z) ((struct cp_binding_level *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cp_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_binding_level(n, z) ((struct cp_binding_level *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cp_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_cxx_binding() ((struct cxx_binding *)(ggc_internal_alloc_stat (sizeof (struct cxx_binding) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cxx_binding() ((struct cxx_binding *)(ggc_internal_cleared_alloc_stat (sizeof (struct cxx_binding) MEM_STAT_INFO))) +#define ggc_alloc_vec_cxx_binding(n) ((struct cxx_binding *)(ggc_internal_vec_alloc_stat (sizeof (struct cxx_binding), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cxx_binding(n) ((struct cxx_binding *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cxx_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cxx_binding(z) ((struct cxx_binding *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cxx_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cxx_binding(z) ((struct cxx_binding *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cxx_binding) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cxx_binding(n, z) ((struct cxx_binding *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cxx_binding), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cxx_binding(n, z) ((struct cxx_binding *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cxx_binding), n MEM_STAT_INFO))) +#define ggc_alloc_binding_entry_s() ((struct binding_entry_s *)(ggc_internal_alloc_stat (sizeof (struct binding_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_binding_entry_s() ((struct binding_entry_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct binding_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_binding_entry_s(n) ((struct binding_entry_s *)(ggc_internal_vec_alloc_stat (sizeof (struct binding_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_binding_entry_s(n) ((struct binding_entry_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct binding_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_binding_entry_s(z) ((struct binding_entry_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct binding_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_binding_entry_s(z) ((struct binding_entry_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct binding_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_binding_entry_s(n, z) ((struct binding_entry_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct binding_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_binding_entry_s(n, z) ((struct binding_entry_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct binding_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_binding_table_s() ((struct binding_table_s *)(ggc_internal_alloc_stat (sizeof (struct binding_table_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_binding_table_s() ((struct binding_table_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct binding_table_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_binding_table_s(n) ((struct binding_table_s *)(ggc_internal_vec_alloc_stat (sizeof (struct binding_table_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_binding_table_s(n) ((struct binding_table_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct binding_table_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_binding_table_s(z) ((struct binding_table_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct binding_table_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_binding_table_s(z) ((struct binding_table_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct binding_table_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_binding_table_s(n, z) ((struct binding_table_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct binding_table_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_binding_table_s(n, z) ((struct binding_table_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct binding_table_s), n MEM_STAT_INFO))) +#define ggc_alloc_tinst_level() ((struct tinst_level *)(ggc_internal_alloc_stat (sizeof (struct tinst_level) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tinst_level() ((struct tinst_level *)(ggc_internal_cleared_alloc_stat (sizeof (struct tinst_level) MEM_STAT_INFO))) +#define ggc_alloc_vec_tinst_level(n) ((struct tinst_level *)(ggc_internal_vec_alloc_stat (sizeof (struct tinst_level), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tinst_level(n) ((struct tinst_level *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tinst_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tinst_level(z) ((struct tinst_level *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tinst_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tinst_level(z) ((struct tinst_level *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tinst_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tinst_level(n, z) ((struct tinst_level *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tinst_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tinst_level(n, z) ((struct tinst_level *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tinst_level), n MEM_STAT_INFO))) +#define ggc_alloc_globals() ((struct globals *)(ggc_internal_alloc_stat (sizeof (struct globals) MEM_STAT_INFO))) +#define ggc_alloc_cleared_globals() ((struct globals *)(ggc_internal_cleared_alloc_stat (sizeof (struct globals) MEM_STAT_INFO))) +#define ggc_alloc_vec_globals(n) ((struct globals *)(ggc_internal_vec_alloc_stat (sizeof (struct globals), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_globals(n) ((struct globals *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct globals), n MEM_STAT_INFO))) +#define ggc_alloc_zone_globals(z) ((struct globals *)(ggc_internal_zone_alloc_stat (z, sizeof (struct globals) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_globals(z) ((struct globals *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct globals) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_globals(n, z) ((struct globals *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct globals), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_globals(n, z) ((struct globals *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct globals), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tinfo_s_gc() ((struct VEC_tinfo_s_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_tinfo_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tinfo_s_gc() ((struct VEC_tinfo_s_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tinfo_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tinfo_s_gc(n) ((struct VEC_tinfo_s_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tinfo_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tinfo_s_gc(n) ((struct VEC_tinfo_s_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tinfo_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tinfo_s_gc(z) ((struct VEC_tinfo_s_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tinfo_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tinfo_s_gc(z) ((struct VEC_tinfo_s_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tinfo_s_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tinfo_s_gc(n, z) ((struct VEC_tinfo_s_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tinfo_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tinfo_s_gc(n, z) ((struct VEC_tinfo_s_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tinfo_s_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tinfo_s_base() ((struct VEC_tinfo_s_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_tinfo_s_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tinfo_s_base() ((struct VEC_tinfo_s_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tinfo_s_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tinfo_s_base(n) ((struct VEC_tinfo_s_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tinfo_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tinfo_s_base(n) ((struct VEC_tinfo_s_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tinfo_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tinfo_s_base(z) ((struct VEC_tinfo_s_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tinfo_s_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tinfo_s_base(z) ((struct VEC_tinfo_s_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tinfo_s_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tinfo_s_base(n, z) ((struct VEC_tinfo_s_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tinfo_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tinfo_s_base(n, z) ((struct VEC_tinfo_s_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tinfo_s_base), n MEM_STAT_INFO))) +#define ggc_alloc_tinfo_s() ((struct tinfo_s *)(ggc_internal_alloc_stat (sizeof (struct tinfo_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tinfo_s() ((struct tinfo_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct tinfo_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_tinfo_s(n) ((struct tinfo_s *)(ggc_internal_vec_alloc_stat (sizeof (struct tinfo_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tinfo_s(n) ((struct tinfo_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tinfo_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tinfo_s(z) ((struct tinfo_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tinfo_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tinfo_s(z) ((struct tinfo_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tinfo_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tinfo_s(n, z) ((struct tinfo_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tinfo_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tinfo_s(n, z) ((struct tinfo_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tinfo_s), n MEM_STAT_INFO))) +#define ggc_alloc_gnat_binding_level() ((struct gnat_binding_level *)(ggc_internal_alloc_stat (sizeof (struct gnat_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gnat_binding_level() ((struct gnat_binding_level *)(ggc_internal_cleared_alloc_stat (sizeof (struct gnat_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_vec_gnat_binding_level(n) ((struct gnat_binding_level *)(ggc_internal_vec_alloc_stat (sizeof (struct gnat_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gnat_binding_level(n) ((struct gnat_binding_level *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gnat_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gnat_binding_level(z) ((struct gnat_binding_level *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gnat_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gnat_binding_level(z) ((struct gnat_binding_level *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gnat_binding_level) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gnat_binding_level(n, z) ((struct gnat_binding_level *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gnat_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gnat_binding_level(n, z) ((struct gnat_binding_level *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gnat_binding_level), n MEM_STAT_INFO))) +#define ggc_alloc_elab_info() ((struct elab_info *)(ggc_internal_alloc_stat (sizeof (struct elab_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_elab_info() ((struct elab_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct elab_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_elab_info(n) ((struct elab_info *)(ggc_internal_vec_alloc_stat (sizeof (struct elab_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_elab_info(n) ((struct elab_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct elab_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_elab_info(z) ((struct elab_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct elab_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_elab_info(z) ((struct elab_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct elab_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_elab_info(n, z) ((struct elab_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct elab_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_elab_info(n, z) ((struct elab_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct elab_info), n MEM_STAT_INFO))) +#define ggc_alloc_stmt_group() ((struct stmt_group *)(ggc_internal_alloc_stat (sizeof (struct stmt_group) MEM_STAT_INFO))) +#define ggc_alloc_cleared_stmt_group() ((struct stmt_group *)(ggc_internal_cleared_alloc_stat (sizeof (struct stmt_group) MEM_STAT_INFO))) +#define ggc_alloc_vec_stmt_group(n) ((struct stmt_group *)(ggc_internal_vec_alloc_stat (sizeof (struct stmt_group), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_stmt_group(n) ((struct stmt_group *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct stmt_group), n MEM_STAT_INFO))) +#define ggc_alloc_zone_stmt_group(z) ((struct stmt_group *)(ggc_internal_zone_alloc_stat (z, sizeof (struct stmt_group) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_stmt_group(z) ((struct stmt_group *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct stmt_group) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_stmt_group(n, z) ((struct stmt_group *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct stmt_group), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_stmt_group(n, z) ((struct stmt_group *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct stmt_group), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_parm_attr_gc() ((struct VEC_parm_attr_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_parm_attr_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_parm_attr_gc() ((struct VEC_parm_attr_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_parm_attr_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_parm_attr_gc(n) ((struct VEC_parm_attr_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_parm_attr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_parm_attr_gc(n) ((struct VEC_parm_attr_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_parm_attr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_parm_attr_gc(z) ((struct VEC_parm_attr_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_parm_attr_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_parm_attr_gc(z) ((struct VEC_parm_attr_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_parm_attr_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_parm_attr_gc(n, z) ((struct VEC_parm_attr_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_parm_attr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_parm_attr_gc(n, z) ((struct VEC_parm_attr_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_parm_attr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_parm_attr_base() ((struct VEC_parm_attr_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_parm_attr_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_parm_attr_base() ((struct VEC_parm_attr_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_parm_attr_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_parm_attr_base(n) ((struct VEC_parm_attr_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_parm_attr_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_parm_attr_base(n) ((struct VEC_parm_attr_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_parm_attr_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_parm_attr_base(z) ((struct VEC_parm_attr_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_parm_attr_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_parm_attr_base(z) ((struct VEC_parm_attr_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_parm_attr_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_parm_attr_base(n, z) ((struct VEC_parm_attr_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_parm_attr_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_parm_attr_base(n, z) ((struct VEC_parm_attr_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_parm_attr_base), n MEM_STAT_INFO))) +#define ggc_alloc_parm_attr_d() ((struct parm_attr_d *)(ggc_internal_alloc_stat (sizeof (struct parm_attr_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_parm_attr_d() ((struct parm_attr_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct parm_attr_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_parm_attr_d(n) ((struct parm_attr_d *)(ggc_internal_vec_alloc_stat (sizeof (struct parm_attr_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_parm_attr_d(n) ((struct parm_attr_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct parm_attr_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_parm_attr_d(z) ((struct parm_attr_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct parm_attr_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_parm_attr_d(z) ((struct parm_attr_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct parm_attr_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_parm_attr_d(n, z) ((struct parm_attr_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct parm_attr_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_parm_attr_d(n, z) ((struct parm_attr_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct parm_attr_d), n MEM_STAT_INFO))) +#define ggc_alloc_lto_tree_ref_table() ((struct lto_tree_ref_table *)(ggc_internal_alloc_stat (sizeof (struct lto_tree_ref_table) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_tree_ref_table() ((struct lto_tree_ref_table *)(ggc_internal_cleared_alloc_stat (sizeof (struct lto_tree_ref_table) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_tree_ref_table(n) ((struct lto_tree_ref_table *)(ggc_internal_vec_alloc_stat (sizeof (struct lto_tree_ref_table), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_tree_ref_table(n) ((struct lto_tree_ref_table *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lto_tree_ref_table), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_tree_ref_table(z) ((struct lto_tree_ref_table *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lto_tree_ref_table) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_tree_ref_table(z) ((struct lto_tree_ref_table *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lto_tree_ref_table) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lto_tree_ref_table(n, z) ((struct lto_tree_ref_table *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lto_tree_ref_table), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_tree_ref_table(n, z) ((struct lto_tree_ref_table *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lto_tree_ref_table), n MEM_STAT_INFO))) +#define ggc_alloc_lto_in_decl_state() ((struct lto_in_decl_state *)(ggc_internal_alloc_stat (sizeof (struct lto_in_decl_state) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_in_decl_state() ((struct lto_in_decl_state *)(ggc_internal_cleared_alloc_stat (sizeof (struct lto_in_decl_state) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_in_decl_state(n) ((struct lto_in_decl_state *)(ggc_internal_vec_alloc_stat (sizeof (struct lto_in_decl_state), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_in_decl_state(n) ((struct lto_in_decl_state *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lto_in_decl_state), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_in_decl_state(z) ((struct lto_in_decl_state *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lto_in_decl_state) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_in_decl_state(z) ((struct lto_in_decl_state *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lto_in_decl_state) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lto_in_decl_state(n, z) ((struct lto_in_decl_state *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lto_in_decl_state), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_in_decl_state(n, z) ((struct lto_in_decl_state *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lto_in_decl_state), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ipa_edge_args_t_gc() ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ipa_edge_args_t_gc() ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ipa_edge_args_t_gc(n) ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ipa_edge_args_t_gc(n) ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ipa_edge_args_t_gc(z) ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ipa_edge_args_t_gc(z) ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ipa_edge_args_t_gc(n, z) ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ipa_edge_args_t_gc(n, z) ((struct VEC_ipa_edge_args_t_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ipa_edge_args_t_base() ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ipa_edge_args_t_base() ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ipa_edge_args_t_base(n) ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ipa_edge_args_t_base(n) ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ipa_edge_args_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ipa_edge_args_t_base(z) ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ipa_edge_args_t_base(z) ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ipa_edge_args_t_base(n, z) ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ipa_edge_args_t_base(n, z) ((struct VEC_ipa_edge_args_t_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ipa_edge_args_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_jump_func_value() ((union jump_func_value *)(ggc_internal_alloc_stat (sizeof (union jump_func_value) MEM_STAT_INFO))) +#define ggc_alloc_cleared_jump_func_value() ((union jump_func_value *)(ggc_internal_cleared_alloc_stat (sizeof (union jump_func_value) MEM_STAT_INFO))) +#define ggc_alloc_vec_jump_func_value(n) ((union jump_func_value *)(ggc_internal_vec_alloc_stat (sizeof (union jump_func_value), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_jump_func_value(n) ((union jump_func_value *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union jump_func_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_jump_func_value(z) ((union jump_func_value *)(ggc_internal_zone_alloc_stat (z, sizeof (union jump_func_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_jump_func_value(z) ((union jump_func_value *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union jump_func_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_jump_func_value(n, z) ((union jump_func_value *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union jump_func_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_jump_func_value(n, z) ((union jump_func_value *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union jump_func_value), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_member_ptr_cst() ((struct ipa_member_ptr_cst *)(ggc_internal_alloc_stat (sizeof (struct ipa_member_ptr_cst) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_member_ptr_cst() ((struct ipa_member_ptr_cst *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_member_ptr_cst) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_member_ptr_cst(n) ((struct ipa_member_ptr_cst *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_member_ptr_cst), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_member_ptr_cst(n) ((struct ipa_member_ptr_cst *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_member_ptr_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_member_ptr_cst(z) ((struct ipa_member_ptr_cst *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_member_ptr_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_member_ptr_cst(z) ((struct ipa_member_ptr_cst *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_member_ptr_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_member_ptr_cst(n, z) ((struct ipa_member_ptr_cst *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_member_ptr_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_member_ptr_cst(n, z) ((struct ipa_member_ptr_cst *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_member_ptr_cst), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_ancestor_jf_data() ((struct ipa_ancestor_jf_data *)(ggc_internal_alloc_stat (sizeof (struct ipa_ancestor_jf_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_ancestor_jf_data() ((struct ipa_ancestor_jf_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_ancestor_jf_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_ancestor_jf_data(n) ((struct ipa_ancestor_jf_data *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_ancestor_jf_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_ancestor_jf_data(n) ((struct ipa_ancestor_jf_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_ancestor_jf_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_ancestor_jf_data(z) ((struct ipa_ancestor_jf_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_ancestor_jf_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_ancestor_jf_data(z) ((struct ipa_ancestor_jf_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_ancestor_jf_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_ancestor_jf_data(n, z) ((struct ipa_ancestor_jf_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_ancestor_jf_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_ancestor_jf_data(n, z) ((struct ipa_ancestor_jf_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_ancestor_jf_data), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_pass_through_data() ((struct ipa_pass_through_data *)(ggc_internal_alloc_stat (sizeof (struct ipa_pass_through_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_pass_through_data() ((struct ipa_pass_through_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_pass_through_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_pass_through_data(n) ((struct ipa_pass_through_data *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_pass_through_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_pass_through_data(n) ((struct ipa_pass_through_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_pass_through_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_pass_through_data(z) ((struct ipa_pass_through_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_pass_through_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_pass_through_data(z) ((struct ipa_pass_through_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_pass_through_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_pass_through_data(n, z) ((struct ipa_pass_through_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_pass_through_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_pass_through_data(n, z) ((struct ipa_pass_through_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_pass_through_data), n MEM_STAT_INFO))) +#define ggc_alloc_lto_symtab_entry_def() ((struct lto_symtab_entry_def *)(ggc_internal_alloc_stat (sizeof (struct lto_symtab_entry_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_symtab_entry_def() ((struct lto_symtab_entry_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct lto_symtab_entry_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_symtab_entry_def(n) ((struct lto_symtab_entry_def *)(ggc_internal_vec_alloc_stat (sizeof (struct lto_symtab_entry_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_symtab_entry_def(n) ((struct lto_symtab_entry_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lto_symtab_entry_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_symtab_entry_def(z) ((struct lto_symtab_entry_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lto_symtab_entry_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_symtab_entry_def(z) ((struct lto_symtab_entry_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lto_symtab_entry_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lto_symtab_entry_def(n, z) ((struct lto_symtab_entry_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lto_symtab_entry_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_symtab_entry_def(n, z) ((struct lto_symtab_entry_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lto_symtab_entry_def), n MEM_STAT_INFO))) +#define ggc_alloc_heapvar_map() ((struct heapvar_map *)(ggc_internal_alloc_stat (sizeof (struct heapvar_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_heapvar_map() ((struct heapvar_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct heapvar_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_heapvar_map(n) ((struct heapvar_map *)(ggc_internal_vec_alloc_stat (sizeof (struct heapvar_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_heapvar_map(n) ((struct heapvar_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct heapvar_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_heapvar_map(z) ((struct heapvar_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct heapvar_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_heapvar_map(z) ((struct heapvar_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct heapvar_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_heapvar_map(n, z) ((struct heapvar_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct heapvar_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_heapvar_map(n, z) ((struct heapvar_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct heapvar_map), n MEM_STAT_INFO))) +#define ggc_alloc_ssa_operand_memory_d(SIZE) ((struct ssa_operand_memory_d *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_ssa_operand_memory_d(SIZE) ((struct ssa_operand_memory_d *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_ssa_operand_memory_d(SIZE, n) ((struct ssa_operand_memory_d *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ssa_operand_memory_d(SIZE, n) ((struct ssa_operand_memory_d *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_ssa_operand_memory_d(SIZE, z) ((struct ssa_operand_memory_d *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ssa_operand_memory_d(SIZE, z) ((struct ssa_operand_memory_d *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ssa_operand_memory_d(SIZE, n, z) ((struct ssa_operand_memory_d *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ssa_operand_memory_d(SIZE, n, z) ((struct ssa_operand_memory_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_scev_info_str() ((struct scev_info_str *)(ggc_internal_alloc_stat (sizeof (struct scev_info_str) MEM_STAT_INFO))) +#define ggc_alloc_cleared_scev_info_str() ((struct scev_info_str *)(ggc_internal_cleared_alloc_stat (sizeof (struct scev_info_str) MEM_STAT_INFO))) +#define ggc_alloc_vec_scev_info_str(n) ((struct scev_info_str *)(ggc_internal_vec_alloc_stat (sizeof (struct scev_info_str), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_scev_info_str(n) ((struct scev_info_str *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct scev_info_str), n MEM_STAT_INFO))) +#define ggc_alloc_zone_scev_info_str(z) ((struct scev_info_str *)(ggc_internal_zone_alloc_stat (z, sizeof (struct scev_info_str) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_scev_info_str(z) ((struct scev_info_str *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct scev_info_str) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_scev_info_str(n, z) ((struct scev_info_str *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct scev_info_str), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_scev_info_str(n, z) ((struct scev_info_str *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct scev_info_str), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_mem_addr_template_gc() ((struct VEC_mem_addr_template_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_mem_addr_template_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_mem_addr_template_gc() ((struct VEC_mem_addr_template_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_mem_addr_template_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_mem_addr_template_gc(n) ((struct VEC_mem_addr_template_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_mem_addr_template_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_mem_addr_template_gc(n) ((struct VEC_mem_addr_template_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_mem_addr_template_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_mem_addr_template_gc(z) ((struct VEC_mem_addr_template_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_mem_addr_template_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_mem_addr_template_gc(z) ((struct VEC_mem_addr_template_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_mem_addr_template_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_mem_addr_template_gc(n, z) ((struct VEC_mem_addr_template_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_mem_addr_template_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_mem_addr_template_gc(n, z) ((struct VEC_mem_addr_template_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_mem_addr_template_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_mem_addr_template_base() ((struct VEC_mem_addr_template_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_mem_addr_template_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_mem_addr_template_base() ((struct VEC_mem_addr_template_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_mem_addr_template_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_mem_addr_template_base(n) ((struct VEC_mem_addr_template_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_mem_addr_template_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_mem_addr_template_base(n) ((struct VEC_mem_addr_template_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_mem_addr_template_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_mem_addr_template_base(z) ((struct VEC_mem_addr_template_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_mem_addr_template_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_mem_addr_template_base(z) ((struct VEC_mem_addr_template_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_mem_addr_template_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_mem_addr_template_base(n, z) ((struct VEC_mem_addr_template_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_mem_addr_template_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_mem_addr_template_base(n, z) ((struct VEC_mem_addr_template_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_mem_addr_template_base), n MEM_STAT_INFO))) +#define ggc_alloc_mem_addr_template() ((struct mem_addr_template *)(ggc_internal_alloc_stat (sizeof (struct mem_addr_template) MEM_STAT_INFO))) +#define ggc_alloc_cleared_mem_addr_template() ((struct mem_addr_template *)(ggc_internal_cleared_alloc_stat (sizeof (struct mem_addr_template) MEM_STAT_INFO))) +#define ggc_alloc_vec_mem_addr_template(n) ((struct mem_addr_template *)(ggc_internal_vec_alloc_stat (sizeof (struct mem_addr_template), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_mem_addr_template(n) ((struct mem_addr_template *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct mem_addr_template), n MEM_STAT_INFO))) +#define ggc_alloc_zone_mem_addr_template(z) ((struct mem_addr_template *)(ggc_internal_zone_alloc_stat (z, sizeof (struct mem_addr_template) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_mem_addr_template(z) ((struct mem_addr_template *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct mem_addr_template) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_mem_addr_template(n, z) ((struct mem_addr_template *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct mem_addr_template), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_mem_addr_template(n, z) ((struct mem_addr_template *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct mem_addr_template), n MEM_STAT_INFO))) +#define ggc_alloc_ssa_operands() ((struct ssa_operands *)(ggc_internal_alloc_stat (sizeof (struct ssa_operands) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ssa_operands() ((struct ssa_operands *)(ggc_internal_cleared_alloc_stat (sizeof (struct ssa_operands) MEM_STAT_INFO))) +#define ggc_alloc_vec_ssa_operands(n) ((struct ssa_operands *)(ggc_internal_vec_alloc_stat (sizeof (struct ssa_operands), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ssa_operands(n) ((struct ssa_operands *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ssa_operands), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ssa_operands(z) ((struct ssa_operands *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ssa_operands) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ssa_operands(z) ((struct ssa_operands *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ssa_operands) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ssa_operands(n, z) ((struct ssa_operands *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ssa_operands), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ssa_operands(n, z) ((struct ssa_operands *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ssa_operands), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_type_leader_entry_s() ((struct gimple_type_leader_entry_s *)(ggc_internal_alloc_stat (sizeof (struct gimple_type_leader_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_type_leader_entry_s() ((struct gimple_type_leader_entry_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_type_leader_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_type_leader_entry_s(n) ((struct gimple_type_leader_entry_s *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_type_leader_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_type_leader_entry_s(n) ((struct gimple_type_leader_entry_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_type_leader_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_type_leader_entry_s(z) ((struct gimple_type_leader_entry_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_type_leader_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_type_leader_entry_s(z) ((struct gimple_type_leader_entry_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_type_leader_entry_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_type_leader_entry_s(n, z) ((struct gimple_type_leader_entry_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_type_leader_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_type_leader_entry_s(n, z) ((struct gimple_type_leader_entry_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_type_leader_entry_s), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_atomic_store() ((struct gimple_statement_omp_atomic_store *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_atomic_store) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_atomic_store() ((struct gimple_statement_omp_atomic_store *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_atomic_store) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_atomic_store(n) ((struct gimple_statement_omp_atomic_store *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_atomic_store), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_atomic_store(n) ((struct gimple_statement_omp_atomic_store *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_atomic_store), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_atomic_store(z) ((struct gimple_statement_omp_atomic_store *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_store) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_atomic_store(z) ((struct gimple_statement_omp_atomic_store *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_store) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_atomic_store(n, z) ((struct gimple_statement_omp_atomic_store *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_store), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_atomic_store(n, z) ((struct gimple_statement_omp_atomic_store *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_store), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_atomic_load() ((struct gimple_statement_omp_atomic_load *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_atomic_load) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_atomic_load() ((struct gimple_statement_omp_atomic_load *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_atomic_load) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_atomic_load(n) ((struct gimple_statement_omp_atomic_load *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_atomic_load), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_atomic_load(n) ((struct gimple_statement_omp_atomic_load *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_atomic_load), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_atomic_load(z) ((struct gimple_statement_omp_atomic_load *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_load) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_atomic_load(z) ((struct gimple_statement_omp_atomic_load *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_load) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_atomic_load(n, z) ((struct gimple_statement_omp_atomic_load *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_load), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_atomic_load(n, z) ((struct gimple_statement_omp_atomic_load *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_atomic_load), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_single() ((struct gimple_statement_omp_single *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_single) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_single() ((struct gimple_statement_omp_single *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_single) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_single(n) ((struct gimple_statement_omp_single *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_single), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_single(n) ((struct gimple_statement_omp_single *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_single), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_single(z) ((struct gimple_statement_omp_single *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_single) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_single(z) ((struct gimple_statement_omp_single *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_single) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_single(n, z) ((struct gimple_statement_omp_single *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_single), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_single(n, z) ((struct gimple_statement_omp_single *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_single), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_continue() ((struct gimple_statement_omp_continue *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_continue) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_continue() ((struct gimple_statement_omp_continue *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_continue) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_continue(n) ((struct gimple_statement_omp_continue *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_continue), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_continue(n) ((struct gimple_statement_omp_continue *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_continue), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_continue(z) ((struct gimple_statement_omp_continue *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_continue) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_continue(z) ((struct gimple_statement_omp_continue *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_continue) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_continue(n, z) ((struct gimple_statement_omp_continue *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_continue), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_continue(n, z) ((struct gimple_statement_omp_continue *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_continue), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_sections() ((struct gimple_statement_omp_sections *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_sections) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_sections() ((struct gimple_statement_omp_sections *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_sections) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_sections(n) ((struct gimple_statement_omp_sections *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_sections), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_sections(n) ((struct gimple_statement_omp_sections *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_sections), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_sections(z) ((struct gimple_statement_omp_sections *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_sections) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_sections(z) ((struct gimple_statement_omp_sections *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_sections) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_sections(n, z) ((struct gimple_statement_omp_sections *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_sections), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_sections(n, z) ((struct gimple_statement_omp_sections *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_sections), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_task() ((struct gimple_statement_omp_task *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_task) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_task() ((struct gimple_statement_omp_task *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_task) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_task(n) ((struct gimple_statement_omp_task *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_task), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_task(n) ((struct gimple_statement_omp_task *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_task), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_task(z) ((struct gimple_statement_omp_task *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_task) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_task(z) ((struct gimple_statement_omp_task *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_task) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_task(n, z) ((struct gimple_statement_omp_task *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_task), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_task(n, z) ((struct gimple_statement_omp_task *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_task), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_parallel() ((struct gimple_statement_omp_parallel *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_parallel) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_parallel() ((struct gimple_statement_omp_parallel *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_parallel) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_parallel(n) ((struct gimple_statement_omp_parallel *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_parallel(n) ((struct gimple_statement_omp_parallel *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_parallel(z) ((struct gimple_statement_omp_parallel *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_parallel) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_parallel(z) ((struct gimple_statement_omp_parallel *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_parallel) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_parallel(n, z) ((struct gimple_statement_omp_parallel *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_parallel(n, z) ((struct gimple_statement_omp_parallel *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_for() ((struct gimple_statement_omp_for *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_for) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_for() ((struct gimple_statement_omp_for *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_for) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_for(n) ((struct gimple_statement_omp_for *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_for), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_for(n) ((struct gimple_statement_omp_for *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_for), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_for(z) ((struct gimple_statement_omp_for *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_for) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_for(z) ((struct gimple_statement_omp_for *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_for) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_for(n, z) ((struct gimple_statement_omp_for *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_for), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_for(n, z) ((struct gimple_statement_omp_for *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_for), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_omp_for_iter() ((struct gimple_omp_for_iter *)(ggc_internal_alloc_stat (sizeof (struct gimple_omp_for_iter) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_omp_for_iter() ((struct gimple_omp_for_iter *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_omp_for_iter) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_omp_for_iter(n) ((struct gimple_omp_for_iter *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_omp_for_iter), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_omp_for_iter(n) ((struct gimple_omp_for_iter *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_omp_for_iter), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_omp_for_iter(z) ((struct gimple_omp_for_iter *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_omp_for_iter) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_omp_for_iter(z) ((struct gimple_omp_for_iter *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_omp_for_iter) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_omp_for_iter(n, z) ((struct gimple_omp_for_iter *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_omp_for_iter), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_omp_for_iter(n, z) ((struct gimple_omp_for_iter *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_omp_for_iter), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp_critical() ((struct gimple_statement_omp_critical *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp_critical) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp_critical() ((struct gimple_statement_omp_critical *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp_critical) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp_critical(n) ((struct gimple_statement_omp_critical *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp_critical), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp_critical(n) ((struct gimple_statement_omp_critical *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp_critical), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp_critical(z) ((struct gimple_statement_omp_critical *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp_critical) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp_critical(z) ((struct gimple_statement_omp_critical *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp_critical) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp_critical(n, z) ((struct gimple_statement_omp_critical *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_critical), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp_critical(n, z) ((struct gimple_statement_omp_critical *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp_critical), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_asm() ((struct gimple_statement_asm *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_asm) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_asm() ((struct gimple_statement_asm *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_asm) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_asm(n) ((struct gimple_statement_asm *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_asm), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_asm(n) ((struct gimple_statement_asm *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_asm), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_asm(z) ((struct gimple_statement_asm *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_asm) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_asm(z) ((struct gimple_statement_asm *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_asm) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_asm(n, z) ((struct gimple_statement_asm *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_asm), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_asm(n, z) ((struct gimple_statement_asm *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_asm), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_wce() ((struct gimple_statement_wce *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_wce) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_wce() ((struct gimple_statement_wce *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_wce) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_wce(n) ((struct gimple_statement_wce *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_wce), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_wce(n) ((struct gimple_statement_wce *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_wce), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_wce(z) ((struct gimple_statement_wce *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_wce) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_wce(z) ((struct gimple_statement_wce *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_wce) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_wce(n, z) ((struct gimple_statement_wce *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_wce), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_wce(n, z) ((struct gimple_statement_wce *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_wce), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_try() ((struct gimple_statement_try *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_try) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_try() ((struct gimple_statement_try *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_try) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_try(n) ((struct gimple_statement_try *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_try), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_try(n) ((struct gimple_statement_try *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_try), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_try(z) ((struct gimple_statement_try *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_try) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_try(z) ((struct gimple_statement_try *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_try) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_try(n, z) ((struct gimple_statement_try *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_try), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_try(n, z) ((struct gimple_statement_try *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_try), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_eh_ctrl() ((struct gimple_statement_eh_ctrl *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_eh_ctrl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_eh_ctrl() ((struct gimple_statement_eh_ctrl *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_eh_ctrl) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_eh_ctrl(n) ((struct gimple_statement_eh_ctrl *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_eh_ctrl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_eh_ctrl(n) ((struct gimple_statement_eh_ctrl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_eh_ctrl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_eh_ctrl(z) ((struct gimple_statement_eh_ctrl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_eh_ctrl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_eh_ctrl(z) ((struct gimple_statement_eh_ctrl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_eh_ctrl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_eh_ctrl(n, z) ((struct gimple_statement_eh_ctrl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_eh_ctrl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_eh_ctrl(n, z) ((struct gimple_statement_eh_ctrl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_eh_ctrl), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_phi() ((struct gimple_statement_phi *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_phi) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_phi() ((struct gimple_statement_phi *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_phi) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_phi(n) ((struct gimple_statement_phi *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_phi), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_phi(n) ((struct gimple_statement_phi *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_phi), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_phi(z) ((struct gimple_statement_phi *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_phi) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_phi(z) ((struct gimple_statement_phi *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_phi) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_phi(n, z) ((struct gimple_statement_phi *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_phi), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_phi(n, z) ((struct gimple_statement_phi *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_phi), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_eh_mnt() ((struct gimple_statement_eh_mnt *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_eh_mnt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_eh_mnt() ((struct gimple_statement_eh_mnt *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_eh_mnt) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_eh_mnt(n) ((struct gimple_statement_eh_mnt *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_eh_mnt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_eh_mnt(n) ((struct gimple_statement_eh_mnt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_eh_mnt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_eh_mnt(z) ((struct gimple_statement_eh_mnt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_eh_mnt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_eh_mnt(z) ((struct gimple_statement_eh_mnt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_eh_mnt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_eh_mnt(n, z) ((struct gimple_statement_eh_mnt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_eh_mnt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_eh_mnt(n, z) ((struct gimple_statement_eh_mnt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_eh_mnt), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_eh_filter() ((struct gimple_statement_eh_filter *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_eh_filter) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_eh_filter() ((struct gimple_statement_eh_filter *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_eh_filter) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_eh_filter(n) ((struct gimple_statement_eh_filter *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_eh_filter), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_eh_filter(n) ((struct gimple_statement_eh_filter *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_eh_filter), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_eh_filter(z) ((struct gimple_statement_eh_filter *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_eh_filter) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_eh_filter(z) ((struct gimple_statement_eh_filter *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_eh_filter) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_eh_filter(n, z) ((struct gimple_statement_eh_filter *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_eh_filter), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_eh_filter(n, z) ((struct gimple_statement_eh_filter *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_eh_filter), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_catch() ((struct gimple_statement_catch *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_catch) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_catch() ((struct gimple_statement_catch *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_catch) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_catch(n) ((struct gimple_statement_catch *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_catch), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_catch(n) ((struct gimple_statement_catch *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_catch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_catch(z) ((struct gimple_statement_catch *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_catch) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_catch(z) ((struct gimple_statement_catch *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_catch) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_catch(n, z) ((struct gimple_statement_catch *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_catch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_catch(n, z) ((struct gimple_statement_catch *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_catch), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_bind() ((struct gimple_statement_bind *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_bind) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_bind() ((struct gimple_statement_bind *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_bind) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_bind(n) ((struct gimple_statement_bind *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_bind), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_bind(n) ((struct gimple_statement_bind *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_bind), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_bind(z) ((struct gimple_statement_bind *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_bind) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_bind(z) ((struct gimple_statement_bind *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_bind) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_bind(n, z) ((struct gimple_statement_bind *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_bind), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_bind(n, z) ((struct gimple_statement_bind *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_bind), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_omp() ((struct gimple_statement_omp *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_omp) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_omp() ((struct gimple_statement_omp *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_omp) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_omp(n) ((struct gimple_statement_omp *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_omp), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_omp(n) ((struct gimple_statement_omp *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_omp), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_omp(z) ((struct gimple_statement_omp *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_omp) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_omp(z) ((struct gimple_statement_omp *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_omp) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_omp(n, z) ((struct gimple_statement_omp *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_omp), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_omp(n, z) ((struct gimple_statement_omp *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_omp), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_call() ((struct gimple_statement_call *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_call) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_call() ((struct gimple_statement_call *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_call) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_call(n) ((struct gimple_statement_call *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_call), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_call(n) ((struct gimple_statement_call *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_call), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_call(z) ((struct gimple_statement_call *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_call) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_call(z) ((struct gimple_statement_call *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_call) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_call(n, z) ((struct gimple_statement_call *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_call), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_call(n, z) ((struct gimple_statement_call *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_call), n MEM_STAT_INFO))) +#define ggc_alloc_pt_solution() ((struct pt_solution *)(ggc_internal_alloc_stat (sizeof (struct pt_solution) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pt_solution() ((struct pt_solution *)(ggc_internal_cleared_alloc_stat (sizeof (struct pt_solution) MEM_STAT_INFO))) +#define ggc_alloc_vec_pt_solution(n) ((struct pt_solution *)(ggc_internal_vec_alloc_stat (sizeof (struct pt_solution), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pt_solution(n) ((struct pt_solution *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pt_solution), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pt_solution(z) ((struct pt_solution *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pt_solution) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pt_solution(z) ((struct pt_solution *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pt_solution) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pt_solution(n, z) ((struct pt_solution *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pt_solution), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pt_solution(n, z) ((struct pt_solution *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pt_solution), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_with_memory_ops() ((struct gimple_statement_with_memory_ops *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_with_memory_ops) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_with_memory_ops() ((struct gimple_statement_with_memory_ops *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_with_memory_ops) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_with_memory_ops(n) ((struct gimple_statement_with_memory_ops *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_with_memory_ops), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_with_memory_ops(n) ((struct gimple_statement_with_memory_ops *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_with_memory_ops), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_with_memory_ops(z) ((struct gimple_statement_with_memory_ops *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_with_memory_ops(z) ((struct gimple_statement_with_memory_ops *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_with_memory_ops(n, z) ((struct gimple_statement_with_memory_ops *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_with_memory_ops(n, z) ((struct gimple_statement_with_memory_ops *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_with_memory_ops_base() ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_with_memory_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_with_memory_ops_base() ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_with_memory_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_with_memory_ops_base(n) ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_with_memory_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_with_memory_ops_base(n) ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_with_memory_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_with_memory_ops_base(z) ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_with_memory_ops_base(z) ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_with_memory_ops_base(n, z) ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_with_memory_ops_base(n, z) ((struct gimple_statement_with_memory_ops_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_with_memory_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_with_ops() ((struct gimple_statement_with_ops *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_with_ops) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_with_ops() ((struct gimple_statement_with_ops *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_with_ops) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_with_ops(n) ((struct gimple_statement_with_ops *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_with_ops), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_with_ops(n) ((struct gimple_statement_with_ops *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_with_ops), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_with_ops(z) ((struct gimple_statement_with_ops *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_with_ops) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_with_ops(z) ((struct gimple_statement_with_ops *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_with_ops) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_with_ops(n, z) ((struct gimple_statement_with_ops *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_with_ops), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_with_ops(n, z) ((struct gimple_statement_with_ops *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_with_ops), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_with_ops_base() ((struct gimple_statement_with_ops_base *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_with_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_with_ops_base() ((struct gimple_statement_with_ops_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_with_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_with_ops_base(n) ((struct gimple_statement_with_ops_base *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_with_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_with_ops_base(n) ((struct gimple_statement_with_ops_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_with_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_with_ops_base(z) ((struct gimple_statement_with_ops_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_with_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_with_ops_base(z) ((struct gimple_statement_with_ops_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_with_ops_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_with_ops_base(n, z) ((struct gimple_statement_with_ops_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_with_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_with_ops_base(n, z) ((struct gimple_statement_with_ops_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_with_ops_base), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_base() ((struct gimple_statement_base *)(ggc_internal_alloc_stat (sizeof (struct gimple_statement_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_base() ((struct gimple_statement_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_statement_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_base(n) ((struct gimple_statement_base *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_statement_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_base(n) ((struct gimple_statement_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_statement_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_base(z) ((struct gimple_statement_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_statement_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_base(z) ((struct gimple_statement_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_statement_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_base(n, z) ((struct gimple_statement_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_statement_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_base(n, z) ((struct gimple_statement_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_statement_base), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_seq_node_d() ((struct gimple_seq_node_d *)(ggc_internal_alloc_stat (sizeof (struct gimple_seq_node_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_seq_node_d() ((struct gimple_seq_node_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_seq_node_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_seq_node_d(n) ((struct gimple_seq_node_d *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_seq_node_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_seq_node_d(n) ((struct gimple_seq_node_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_seq_node_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_seq_node_d(z) ((struct gimple_seq_node_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_seq_node_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_seq_node_d(z) ((struct gimple_seq_node_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_seq_node_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_seq_node_d(n, z) ((struct gimple_seq_node_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_seq_node_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_seq_node_d(n, z) ((struct gimple_seq_node_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_seq_node_d), n MEM_STAT_INFO))) +#define ggc_alloc_type_hash() ((struct type_hash *)(ggc_internal_alloc_stat (sizeof (struct type_hash) MEM_STAT_INFO))) +#define ggc_alloc_cleared_type_hash() ((struct type_hash *)(ggc_internal_cleared_alloc_stat (sizeof (struct type_hash) MEM_STAT_INFO))) +#define ggc_alloc_vec_type_hash(n) ((struct type_hash *)(ggc_internal_vec_alloc_stat (sizeof (struct type_hash), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_type_hash(n) ((struct type_hash *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct type_hash), n MEM_STAT_INFO))) +#define ggc_alloc_zone_type_hash(z) ((struct type_hash *)(ggc_internal_zone_alloc_stat (z, sizeof (struct type_hash) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_type_hash(z) ((struct type_hash *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct type_hash) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_type_hash(n, z) ((struct type_hash *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct type_hash), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_type_hash(n, z) ((struct type_hash *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct type_hash), n MEM_STAT_INFO))) +#define ggc_alloc_string_pool_data() ((struct string_pool_data *)(ggc_internal_alloc_stat (sizeof (struct string_pool_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_string_pool_data() ((struct string_pool_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct string_pool_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_string_pool_data(n) ((struct string_pool_data *)(ggc_internal_vec_alloc_stat (sizeof (struct string_pool_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_string_pool_data(n) ((struct string_pool_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct string_pool_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_string_pool_data(z) ((struct string_pool_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct string_pool_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_string_pool_data(z) ((struct string_pool_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct string_pool_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_string_pool_data(n, z) ((struct string_pool_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct string_pool_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_string_pool_data(n, z) ((struct string_pool_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct string_pool_data), n MEM_STAT_INFO))) +#define ggc_alloc_initial_value_pair() ((struct initial_value_pair *)(ggc_internal_alloc_stat (sizeof (struct initial_value_pair) MEM_STAT_INFO))) +#define ggc_alloc_cleared_initial_value_pair() ((struct initial_value_pair *)(ggc_internal_cleared_alloc_stat (sizeof (struct initial_value_pair) MEM_STAT_INFO))) +#define ggc_alloc_vec_initial_value_pair(n) ((struct initial_value_pair *)(ggc_internal_vec_alloc_stat (sizeof (struct initial_value_pair), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_initial_value_pair(n) ((struct initial_value_pair *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct initial_value_pair), n MEM_STAT_INFO))) +#define ggc_alloc_zone_initial_value_pair(z) ((struct initial_value_pair *)(ggc_internal_zone_alloc_stat (z, sizeof (struct initial_value_pair) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_initial_value_pair(z) ((struct initial_value_pair *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct initial_value_pair) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_initial_value_pair(n, z) ((struct initial_value_pair *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct initial_value_pair), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_initial_value_pair(n, z) ((struct initial_value_pair *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct initial_value_pair), n MEM_STAT_INFO))) +#define ggc_alloc_temp_slot_address_entry() ((struct temp_slot_address_entry *)(ggc_internal_alloc_stat (sizeof (struct temp_slot_address_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_temp_slot_address_entry() ((struct temp_slot_address_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct temp_slot_address_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_temp_slot_address_entry(n) ((struct temp_slot_address_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct temp_slot_address_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_temp_slot_address_entry(n) ((struct temp_slot_address_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct temp_slot_address_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_temp_slot_address_entry(z) ((struct temp_slot_address_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct temp_slot_address_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_temp_slot_address_entry(z) ((struct temp_slot_address_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct temp_slot_address_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_temp_slot_address_entry(n, z) ((struct temp_slot_address_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct temp_slot_address_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_temp_slot_address_entry(n, z) ((struct temp_slot_address_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct temp_slot_address_entry), n MEM_STAT_INFO))) +#define ggc_alloc_eh_status_u() ((union eh_status_u *)(ggc_internal_alloc_stat (sizeof (union eh_status_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_status_u() ((union eh_status_u *)(ggc_internal_cleared_alloc_stat (sizeof (union eh_status_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_status_u(n) ((union eh_status_u *)(ggc_internal_vec_alloc_stat (sizeof (union eh_status_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_status_u(n) ((union eh_status_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union eh_status_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_status_u(z) ((union eh_status_u *)(ggc_internal_zone_alloc_stat (z, sizeof (union eh_status_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_status_u(z) ((union eh_status_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union eh_status_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_status_u(n, z) ((union eh_status_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union eh_status_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_status_u(n, z) ((union eh_status_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union eh_status_u), n MEM_STAT_INFO))) +#define ggc_alloc_throw_stmt_node() ((struct throw_stmt_node *)(ggc_internal_alloc_stat (sizeof (struct throw_stmt_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_throw_stmt_node() ((struct throw_stmt_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct throw_stmt_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_throw_stmt_node(n) ((struct throw_stmt_node *)(ggc_internal_vec_alloc_stat (sizeof (struct throw_stmt_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_throw_stmt_node(n) ((struct throw_stmt_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct throw_stmt_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_throw_stmt_node(z) ((struct throw_stmt_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct throw_stmt_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_throw_stmt_node(z) ((struct throw_stmt_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct throw_stmt_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_throw_stmt_node(n, z) ((struct throw_stmt_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct throw_stmt_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_throw_stmt_node(n, z) ((struct throw_stmt_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct throw_stmt_node), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_eh_landing_pad_gc() ((struct VEC_eh_landing_pad_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_eh_landing_pad_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_eh_landing_pad_gc() ((struct VEC_eh_landing_pad_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_eh_landing_pad_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_eh_landing_pad_gc(n) ((struct VEC_eh_landing_pad_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_eh_landing_pad_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_eh_landing_pad_gc(n) ((struct VEC_eh_landing_pad_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_eh_landing_pad_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_eh_landing_pad_gc(z) ((struct VEC_eh_landing_pad_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_eh_landing_pad_gc(z) ((struct VEC_eh_landing_pad_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_eh_landing_pad_gc(n, z) ((struct VEC_eh_landing_pad_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_eh_landing_pad_gc(n, z) ((struct VEC_eh_landing_pad_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_eh_landing_pad_base() ((struct VEC_eh_landing_pad_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_eh_landing_pad_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_eh_landing_pad_base() ((struct VEC_eh_landing_pad_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_eh_landing_pad_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_eh_landing_pad_base(n) ((struct VEC_eh_landing_pad_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_eh_landing_pad_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_eh_landing_pad_base(n) ((struct VEC_eh_landing_pad_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_eh_landing_pad_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_eh_landing_pad_base(z) ((struct VEC_eh_landing_pad_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_eh_landing_pad_base(z) ((struct VEC_eh_landing_pad_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_eh_landing_pad_base(n, z) ((struct VEC_eh_landing_pad_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_eh_landing_pad_base(n, z) ((struct VEC_eh_landing_pad_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_eh_landing_pad_base), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_eh_region_gc() ((struct VEC_eh_region_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_eh_region_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_eh_region_gc() ((struct VEC_eh_region_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_eh_region_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_eh_region_gc(n) ((struct VEC_eh_region_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_eh_region_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_eh_region_gc(n) ((struct VEC_eh_region_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_eh_region_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_eh_region_gc(z) ((struct VEC_eh_region_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_eh_region_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_eh_region_gc(z) ((struct VEC_eh_region_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_eh_region_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_eh_region_gc(n, z) ((struct VEC_eh_region_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_eh_region_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_eh_region_gc(n, z) ((struct VEC_eh_region_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_eh_region_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_eh_region_base() ((struct VEC_eh_region_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_eh_region_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_eh_region_base() ((struct VEC_eh_region_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_eh_region_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_eh_region_base(n) ((struct VEC_eh_region_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_eh_region_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_eh_region_base(n) ((struct VEC_eh_region_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_eh_region_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_eh_region_base(z) ((struct VEC_eh_region_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_eh_region_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_eh_region_base(z) ((struct VEC_eh_region_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_eh_region_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_eh_region_base(n, z) ((struct VEC_eh_region_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_eh_region_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_eh_region_base(n, z) ((struct VEC_eh_region_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_eh_region_base), n MEM_STAT_INFO))) +#define ggc_alloc_eh_region_u() ((union eh_region_u *)(ggc_internal_alloc_stat (sizeof (union eh_region_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_region_u() ((union eh_region_u *)(ggc_internal_cleared_alloc_stat (sizeof (union eh_region_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_region_u(n) ((union eh_region_u *)(ggc_internal_vec_alloc_stat (sizeof (union eh_region_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_region_u(n) ((union eh_region_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union eh_region_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_region_u(z) ((union eh_region_u *)(ggc_internal_zone_alloc_stat (z, sizeof (union eh_region_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_region_u(z) ((union eh_region_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union eh_region_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_region_u(n, z) ((union eh_region_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union eh_region_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_region_u(n, z) ((union eh_region_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union eh_region_u), n MEM_STAT_INFO))) +#define ggc_alloc_eh_region_u_must_not_throw() ((struct eh_region_u_must_not_throw *)(ggc_internal_alloc_stat (sizeof (struct eh_region_u_must_not_throw) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_region_u_must_not_throw() ((struct eh_region_u_must_not_throw *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_region_u_must_not_throw) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_region_u_must_not_throw(n) ((struct eh_region_u_must_not_throw *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_region_u_must_not_throw), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_region_u_must_not_throw(n) ((struct eh_region_u_must_not_throw *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_region_u_must_not_throw), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_region_u_must_not_throw(z) ((struct eh_region_u_must_not_throw *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_region_u_must_not_throw) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_region_u_must_not_throw(z) ((struct eh_region_u_must_not_throw *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_region_u_must_not_throw) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_region_u_must_not_throw(n, z) ((struct eh_region_u_must_not_throw *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_region_u_must_not_throw), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_region_u_must_not_throw(n, z) ((struct eh_region_u_must_not_throw *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_region_u_must_not_throw), n MEM_STAT_INFO))) +#define ggc_alloc_eh_region_u_allowed() ((struct eh_region_u_allowed *)(ggc_internal_alloc_stat (sizeof (struct eh_region_u_allowed) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_region_u_allowed() ((struct eh_region_u_allowed *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_region_u_allowed) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_region_u_allowed(n) ((struct eh_region_u_allowed *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_region_u_allowed), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_region_u_allowed(n) ((struct eh_region_u_allowed *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_region_u_allowed), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_region_u_allowed(z) ((struct eh_region_u_allowed *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_region_u_allowed) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_region_u_allowed(z) ((struct eh_region_u_allowed *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_region_u_allowed) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_region_u_allowed(n, z) ((struct eh_region_u_allowed *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_region_u_allowed), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_region_u_allowed(n, z) ((struct eh_region_u_allowed *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_region_u_allowed), n MEM_STAT_INFO))) +#define ggc_alloc_eh_region_u_try() ((struct eh_region_u_try *)(ggc_internal_alloc_stat (sizeof (struct eh_region_u_try) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_region_u_try() ((struct eh_region_u_try *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_region_u_try) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_region_u_try(n) ((struct eh_region_u_try *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_region_u_try), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_region_u_try(n) ((struct eh_region_u_try *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_region_u_try), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_region_u_try(z) ((struct eh_region_u_try *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_region_u_try) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_region_u_try(z) ((struct eh_region_u_try *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_region_u_try) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_region_u_try(n, z) ((struct eh_region_u_try *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_region_u_try), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_region_u_try(n, z) ((struct eh_region_u_try *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_region_u_try), n MEM_STAT_INFO))) +#define ggc_alloc_eh_catch_d() ((struct eh_catch_d *)(ggc_internal_alloc_stat (sizeof (struct eh_catch_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_catch_d() ((struct eh_catch_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_catch_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_catch_d(n) ((struct eh_catch_d *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_catch_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_catch_d(n) ((struct eh_catch_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_catch_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_catch_d(z) ((struct eh_catch_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_catch_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_catch_d(z) ((struct eh_catch_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_catch_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_catch_d(n, z) ((struct eh_catch_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_catch_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_catch_d(n, z) ((struct eh_catch_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_catch_d), n MEM_STAT_INFO))) +#define ggc_alloc_eh_landing_pad_d() ((struct eh_landing_pad_d *)(ggc_internal_alloc_stat (sizeof (struct eh_landing_pad_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_landing_pad_d() ((struct eh_landing_pad_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_landing_pad_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_landing_pad_d(n) ((struct eh_landing_pad_d *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_landing_pad_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_landing_pad_d(n) ((struct eh_landing_pad_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_landing_pad_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_landing_pad_d(z) ((struct eh_landing_pad_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_landing_pad_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_landing_pad_d(z) ((struct eh_landing_pad_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_landing_pad_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_landing_pad_d(n, z) ((struct eh_landing_pad_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_landing_pad_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_landing_pad_d(n, z) ((struct eh_landing_pad_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_landing_pad_d), n MEM_STAT_INFO))) +#define ggc_alloc_eh_region_d() ((struct eh_region_d *)(ggc_internal_alloc_stat (sizeof (struct eh_region_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_region_d() ((struct eh_region_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_region_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_region_d(n) ((struct eh_region_d *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_region_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_region_d(n) ((struct eh_region_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_region_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_region_d(z) ((struct eh_region_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_region_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_region_d(z) ((struct eh_region_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_region_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_region_d(n, z) ((struct eh_region_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_region_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_region_d(n, z) ((struct eh_region_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_region_d), n MEM_STAT_INFO))) +#define ggc_alloc_type_ent() ((struct type_ent *)(ggc_internal_alloc_stat (sizeof (struct type_ent) MEM_STAT_INFO))) +#define ggc_alloc_cleared_type_ent() ((struct type_ent *)(ggc_internal_cleared_alloc_stat (sizeof (struct type_ent) MEM_STAT_INFO))) +#define ggc_alloc_vec_type_ent(n) ((struct type_ent *)(ggc_internal_vec_alloc_stat (sizeof (struct type_ent), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_type_ent(n) ((struct type_ent *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct type_ent), n MEM_STAT_INFO))) +#define ggc_alloc_zone_type_ent(z) ((struct type_ent *)(ggc_internal_zone_alloc_stat (z, sizeof (struct type_ent) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_type_ent(z) ((struct type_ent *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct type_ent) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_type_ent(n, z) ((struct type_ent *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct type_ent), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_type_ent(n, z) ((struct type_ent *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct type_ent), n MEM_STAT_INFO))) +#define ggc_alloc_saved_module_scope() ((struct saved_module_scope *)(ggc_internal_alloc_stat (sizeof (struct saved_module_scope) MEM_STAT_INFO))) +#define ggc_alloc_cleared_saved_module_scope() ((struct saved_module_scope *)(ggc_internal_cleared_alloc_stat (sizeof (struct saved_module_scope) MEM_STAT_INFO))) +#define ggc_alloc_vec_saved_module_scope(n) ((struct saved_module_scope *)(ggc_internal_vec_alloc_stat (sizeof (struct saved_module_scope), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_saved_module_scope(n) ((struct saved_module_scope *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct saved_module_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_saved_module_scope(z) ((struct saved_module_scope *)(ggc_internal_zone_alloc_stat (z, sizeof (struct saved_module_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_saved_module_scope(z) ((struct saved_module_scope *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct saved_module_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_saved_module_scope(n, z) ((struct saved_module_scope *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct saved_module_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_saved_module_scope(n, z) ((struct saved_module_scope *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct saved_module_scope), n MEM_STAT_INFO))) +#define ggc_alloc_vcall_insn() ((struct vcall_insn *)(ggc_internal_alloc_stat (sizeof (struct vcall_insn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_vcall_insn() ((struct vcall_insn *)(ggc_internal_cleared_alloc_stat (sizeof (struct vcall_insn) MEM_STAT_INFO))) +#define ggc_alloc_vec_vcall_insn(n) ((struct vcall_insn *)(ggc_internal_vec_alloc_stat (sizeof (struct vcall_insn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_vcall_insn(n) ((struct vcall_insn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct vcall_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_vcall_insn(z) ((struct vcall_insn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct vcall_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vcall_insn(z) ((struct vcall_insn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct vcall_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_vcall_insn(n, z) ((struct vcall_insn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct vcall_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_vcall_insn(n, z) ((struct vcall_insn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct vcall_insn), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_vcall_entry_gc() ((struct VEC_vcall_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_vcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_vcall_entry_gc() ((struct VEC_vcall_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_vcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_vcall_entry_gc(n) ((struct VEC_vcall_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_vcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_vcall_entry_gc(n) ((struct VEC_vcall_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_vcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_vcall_entry_gc(z) ((struct VEC_vcall_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_vcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_vcall_entry_gc(z) ((struct VEC_vcall_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_vcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_vcall_entry_gc(n, z) ((struct VEC_vcall_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_vcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_vcall_entry_gc(n, z) ((struct VEC_vcall_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_vcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_vcall_entry_base() ((struct VEC_vcall_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_vcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_vcall_entry_base() ((struct VEC_vcall_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_vcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_vcall_entry_base(n) ((struct VEC_vcall_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_vcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_vcall_entry_base(n) ((struct VEC_vcall_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_vcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_vcall_entry_base(z) ((struct VEC_vcall_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_vcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_vcall_entry_base(z) ((struct VEC_vcall_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_vcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_vcall_entry_base(n, z) ((struct VEC_vcall_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_vcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_vcall_entry_base(n, z) ((struct VEC_vcall_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_vcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_vcall_struct() ((struct vcall_struct *)(ggc_internal_alloc_stat (sizeof (struct vcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_vcall_struct() ((struct vcall_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct vcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_vcall_struct(n) ((struct vcall_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct vcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_vcall_struct(n) ((struct vcall_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct vcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_vcall_struct(z) ((struct vcall_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct vcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vcall_struct(z) ((struct vcall_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct vcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_vcall_struct(n, z) ((struct vcall_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct vcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_vcall_struct(n, z) ((struct vcall_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct vcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_dcall_entry_gc() ((struct VEC_dcall_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_dcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_dcall_entry_gc() ((struct VEC_dcall_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_dcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_dcall_entry_gc(n) ((struct VEC_dcall_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_dcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_dcall_entry_gc(n) ((struct VEC_dcall_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_dcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_dcall_entry_gc(z) ((struct VEC_dcall_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_dcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_dcall_entry_gc(z) ((struct VEC_dcall_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_dcall_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_dcall_entry_gc(n, z) ((struct VEC_dcall_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_dcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_dcall_entry_gc(n, z) ((struct VEC_dcall_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_dcall_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_dcall_entry_base() ((struct VEC_dcall_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_dcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_dcall_entry_base() ((struct VEC_dcall_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_dcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_dcall_entry_base(n) ((struct VEC_dcall_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_dcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_dcall_entry_base(n) ((struct VEC_dcall_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_dcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_dcall_entry_base(z) ((struct VEC_dcall_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_dcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_dcall_entry_base(z) ((struct VEC_dcall_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_dcall_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_dcall_entry_base(n, z) ((struct VEC_dcall_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_dcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_dcall_entry_base(n, z) ((struct VEC_dcall_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_dcall_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_dcall_struct() ((struct dcall_struct *)(ggc_internal_alloc_stat (sizeof (struct dcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dcall_struct() ((struct dcall_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dcall_struct(n) ((struct dcall_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dcall_struct(n) ((struct dcall_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dcall_struct(z) ((struct dcall_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dcall_struct(z) ((struct dcall_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dcall_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dcall_struct(n, z) ((struct dcall_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dcall_struct(n, z) ((struct dcall_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dcall_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cached_dw_loc_list_def() ((struct cached_dw_loc_list_def *)(ggc_internal_alloc_stat (sizeof (struct cached_dw_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cached_dw_loc_list_def() ((struct cached_dw_loc_list_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct cached_dw_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_cached_dw_loc_list_def(n) ((struct cached_dw_loc_list_def *)(ggc_internal_vec_alloc_stat (sizeof (struct cached_dw_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cached_dw_loc_list_def(n) ((struct cached_dw_loc_list_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cached_dw_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cached_dw_loc_list_def(z) ((struct cached_dw_loc_list_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cached_dw_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cached_dw_loc_list_def(z) ((struct cached_dw_loc_list_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cached_dw_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cached_dw_loc_list_def(n, z) ((struct cached_dw_loc_list_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cached_dw_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cached_dw_loc_list_def(n, z) ((struct cached_dw_loc_list_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cached_dw_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_var_loc_list_def() ((struct var_loc_list_def *)(ggc_internal_alloc_stat (sizeof (struct var_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_var_loc_list_def() ((struct var_loc_list_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct var_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_var_loc_list_def(n) ((struct var_loc_list_def *)(ggc_internal_vec_alloc_stat (sizeof (struct var_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_var_loc_list_def(n) ((struct var_loc_list_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct var_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_var_loc_list_def(z) ((struct var_loc_list_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct var_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_var_loc_list_def(z) ((struct var_loc_list_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct var_loc_list_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_var_loc_list_def(n, z) ((struct var_loc_list_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct var_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_var_loc_list_def(n, z) ((struct var_loc_list_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct var_loc_list_def), n MEM_STAT_INFO))) +#define ggc_alloc_var_loc_node() ((struct var_loc_node *)(ggc_internal_alloc_stat (sizeof (struct var_loc_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_var_loc_node() ((struct var_loc_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct var_loc_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_var_loc_node(n) ((struct var_loc_node *)(ggc_internal_vec_alloc_stat (sizeof (struct var_loc_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_var_loc_node(n) ((struct var_loc_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct var_loc_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_var_loc_node(z) ((struct var_loc_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct var_loc_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_var_loc_node(z) ((struct var_loc_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct var_loc_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_var_loc_node(n, z) ((struct var_loc_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct var_loc_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_var_loc_node(n, z) ((struct var_loc_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct var_loc_node), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_die_arg_entry_gc() ((struct VEC_die_arg_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_die_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_die_arg_entry_gc() ((struct VEC_die_arg_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_die_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_die_arg_entry_gc(n) ((struct VEC_die_arg_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_die_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_die_arg_entry_gc(n) ((struct VEC_die_arg_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_die_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_die_arg_entry_gc(z) ((struct VEC_die_arg_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_die_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_die_arg_entry_gc(z) ((struct VEC_die_arg_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_die_arg_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_die_arg_entry_gc(n, z) ((struct VEC_die_arg_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_die_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_die_arg_entry_gc(n, z) ((struct VEC_die_arg_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_die_arg_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_die_arg_entry_base() ((struct VEC_die_arg_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_die_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_die_arg_entry_base() ((struct VEC_die_arg_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_die_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_die_arg_entry_base(n) ((struct VEC_die_arg_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_die_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_die_arg_entry_base(n) ((struct VEC_die_arg_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_die_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_die_arg_entry_base(z) ((struct VEC_die_arg_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_die_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_die_arg_entry_base(z) ((struct VEC_die_arg_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_die_arg_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_die_arg_entry_base(n, z) ((struct VEC_die_arg_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_die_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_die_arg_entry_base(n, z) ((struct VEC_die_arg_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_die_arg_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_die_arg_entry_struct() ((struct die_arg_entry_struct *)(ggc_internal_alloc_stat (sizeof (struct die_arg_entry_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_die_arg_entry_struct() ((struct die_arg_entry_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct die_arg_entry_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_die_arg_entry_struct(n) ((struct die_arg_entry_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct die_arg_entry_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_die_arg_entry_struct(n) ((struct die_arg_entry_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct die_arg_entry_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_die_arg_entry_struct(z) ((struct die_arg_entry_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct die_arg_entry_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_die_arg_entry_struct(z) ((struct die_arg_entry_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct die_arg_entry_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_die_arg_entry_struct(n, z) ((struct die_arg_entry_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct die_arg_entry_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_die_arg_entry_struct(n, z) ((struct die_arg_entry_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct die_arg_entry_struct), n MEM_STAT_INFO))) +#define ggc_alloc_limbo_die_struct() ((struct limbo_die_struct *)(ggc_internal_alloc_stat (sizeof (struct limbo_die_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_limbo_die_struct() ((struct limbo_die_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct limbo_die_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_limbo_die_struct(n) ((struct limbo_die_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct limbo_die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_limbo_die_struct(n) ((struct limbo_die_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct limbo_die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_limbo_die_struct(z) ((struct limbo_die_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct limbo_die_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_limbo_die_struct(z) ((struct limbo_die_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct limbo_die_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_limbo_die_struct(n, z) ((struct limbo_die_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct limbo_die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_limbo_die_struct(n, z) ((struct limbo_die_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct limbo_die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_macinfo_entry_gc() ((struct VEC_macinfo_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_macinfo_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_macinfo_entry_gc() ((struct VEC_macinfo_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_macinfo_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_macinfo_entry_gc(n) ((struct VEC_macinfo_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_macinfo_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_macinfo_entry_gc(n) ((struct VEC_macinfo_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_macinfo_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_macinfo_entry_gc(z) ((struct VEC_macinfo_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_macinfo_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_macinfo_entry_gc(z) ((struct VEC_macinfo_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_macinfo_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_macinfo_entry_gc(n, z) ((struct VEC_macinfo_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_macinfo_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_macinfo_entry_gc(n, z) ((struct VEC_macinfo_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_macinfo_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_macinfo_entry_base() ((struct VEC_macinfo_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_macinfo_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_macinfo_entry_base() ((struct VEC_macinfo_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_macinfo_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_macinfo_entry_base(n) ((struct VEC_macinfo_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_macinfo_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_macinfo_entry_base(n) ((struct VEC_macinfo_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_macinfo_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_macinfo_entry_base(z) ((struct VEC_macinfo_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_macinfo_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_macinfo_entry_base(z) ((struct VEC_macinfo_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_macinfo_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_macinfo_entry_base(n, z) ((struct VEC_macinfo_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_macinfo_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_macinfo_entry_base(n, z) ((struct VEC_macinfo_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_macinfo_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_macinfo_struct() ((struct macinfo_struct *)(ggc_internal_alloc_stat (sizeof (struct macinfo_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_macinfo_struct() ((struct macinfo_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct macinfo_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_macinfo_struct(n) ((struct macinfo_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct macinfo_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_macinfo_struct(n) ((struct macinfo_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct macinfo_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_macinfo_struct(z) ((struct macinfo_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct macinfo_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_macinfo_struct(z) ((struct macinfo_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct macinfo_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_macinfo_struct(n, z) ((struct macinfo_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct macinfo_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_macinfo_struct(n, z) ((struct macinfo_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct macinfo_struct), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pubname_entry_gc() ((struct VEC_pubname_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_pubname_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pubname_entry_gc() ((struct VEC_pubname_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pubname_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pubname_entry_gc(n) ((struct VEC_pubname_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pubname_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pubname_entry_gc(n) ((struct VEC_pubname_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pubname_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pubname_entry_gc(z) ((struct VEC_pubname_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pubname_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pubname_entry_gc(z) ((struct VEC_pubname_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pubname_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pubname_entry_gc(n, z) ((struct VEC_pubname_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pubname_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pubname_entry_gc(n, z) ((struct VEC_pubname_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pubname_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_pubname_entry_base() ((struct VEC_pubname_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_pubname_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_pubname_entry_base() ((struct VEC_pubname_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_pubname_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_pubname_entry_base(n) ((struct VEC_pubname_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_pubname_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_pubname_entry_base(n) ((struct VEC_pubname_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_pubname_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_pubname_entry_base(z) ((struct VEC_pubname_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_pubname_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_pubname_entry_base(z) ((struct VEC_pubname_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_pubname_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_pubname_entry_base(n, z) ((struct VEC_pubname_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_pubname_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_pubname_entry_base(n, z) ((struct VEC_pubname_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_pubname_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_die_symbol_or_type_node() ((union die_symbol_or_type_node *)(ggc_internal_alloc_stat (sizeof (union die_symbol_or_type_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_die_symbol_or_type_node() ((union die_symbol_or_type_node *)(ggc_internal_cleared_alloc_stat (sizeof (union die_symbol_or_type_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_die_symbol_or_type_node(n) ((union die_symbol_or_type_node *)(ggc_internal_vec_alloc_stat (sizeof (union die_symbol_or_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_die_symbol_or_type_node(n) ((union die_symbol_or_type_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union die_symbol_or_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_die_symbol_or_type_node(z) ((union die_symbol_or_type_node *)(ggc_internal_zone_alloc_stat (z, sizeof (union die_symbol_or_type_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_die_symbol_or_type_node(z) ((union die_symbol_or_type_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union die_symbol_or_type_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_die_symbol_or_type_node(n, z) ((union die_symbol_or_type_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union die_symbol_or_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_die_symbol_or_type_node(n, z) ((union die_symbol_or_type_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union die_symbol_or_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_dw_attr_node_gc() ((struct VEC_dw_attr_node_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_dw_attr_node_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_dw_attr_node_gc() ((struct VEC_dw_attr_node_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_dw_attr_node_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_dw_attr_node_gc(n) ((struct VEC_dw_attr_node_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_dw_attr_node_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_dw_attr_node_gc(n) ((struct VEC_dw_attr_node_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_dw_attr_node_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_dw_attr_node_gc(z) ((struct VEC_dw_attr_node_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_dw_attr_node_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_dw_attr_node_gc(z) ((struct VEC_dw_attr_node_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_dw_attr_node_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_dw_attr_node_gc(n, z) ((struct VEC_dw_attr_node_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_dw_attr_node_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_dw_attr_node_gc(n, z) ((struct VEC_dw_attr_node_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_dw_attr_node_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_dw_attr_node_base() ((struct VEC_dw_attr_node_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_dw_attr_node_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_dw_attr_node_base() ((struct VEC_dw_attr_node_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_dw_attr_node_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_dw_attr_node_base(n) ((struct VEC_dw_attr_node_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_dw_attr_node_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_dw_attr_node_base(n) ((struct VEC_dw_attr_node_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_dw_attr_node_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_dw_attr_node_base(z) ((struct VEC_dw_attr_node_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_dw_attr_node_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_dw_attr_node_base(z) ((struct VEC_dw_attr_node_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_dw_attr_node_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_dw_attr_node_base(n, z) ((struct VEC_dw_attr_node_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_dw_attr_node_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_dw_attr_node_base(n, z) ((struct VEC_dw_attr_node_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_dw_attr_node_base), n MEM_STAT_INFO))) +#define ggc_alloc_comdat_type_struct() ((struct comdat_type_struct *)(ggc_internal_alloc_stat (sizeof (struct comdat_type_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_comdat_type_struct() ((struct comdat_type_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct comdat_type_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_comdat_type_struct(n) ((struct comdat_type_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct comdat_type_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_comdat_type_struct(n) ((struct comdat_type_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct comdat_type_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_comdat_type_struct(z) ((struct comdat_type_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct comdat_type_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_comdat_type_struct(z) ((struct comdat_type_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct comdat_type_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_comdat_type_struct(n, z) ((struct comdat_type_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct comdat_type_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_comdat_type_struct(n, z) ((struct comdat_type_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct comdat_type_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_ranges_by_label_struct() ((struct dw_ranges_by_label_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_ranges_by_label_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_ranges_by_label_struct() ((struct dw_ranges_by_label_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_ranges_by_label_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_ranges_by_label_struct(n) ((struct dw_ranges_by_label_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_ranges_by_label_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_ranges_by_label_struct(n) ((struct dw_ranges_by_label_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_ranges_by_label_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_ranges_by_label_struct(z) ((struct dw_ranges_by_label_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_ranges_by_label_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_ranges_by_label_struct(z) ((struct dw_ranges_by_label_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_ranges_by_label_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_ranges_by_label_struct(n, z) ((struct dw_ranges_by_label_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_ranges_by_label_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_ranges_by_label_struct(n, z) ((struct dw_ranges_by_label_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_ranges_by_label_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_ranges_struct() ((struct dw_ranges_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_ranges_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_ranges_struct() ((struct dw_ranges_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_ranges_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_ranges_struct(n) ((struct dw_ranges_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_ranges_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_ranges_struct(n) ((struct dw_ranges_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_ranges_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_ranges_struct(z) ((struct dw_ranges_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_ranges_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_ranges_struct(z) ((struct dw_ranges_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_ranges_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_ranges_struct(n, z) ((struct dw_ranges_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_ranges_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_ranges_struct(n, z) ((struct dw_ranges_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_ranges_struct), n MEM_STAT_INFO))) +#define ggc_alloc_pubname_struct() ((struct pubname_struct *)(ggc_internal_alloc_stat (sizeof (struct pubname_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pubname_struct() ((struct pubname_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct pubname_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_pubname_struct(n) ((struct pubname_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct pubname_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pubname_struct(n) ((struct pubname_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct pubname_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pubname_struct(z) ((struct pubname_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct pubname_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pubname_struct(z) ((struct pubname_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct pubname_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_pubname_struct(n, z) ((struct pubname_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct pubname_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pubname_struct(n, z) ((struct pubname_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct pubname_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_separate_line_info_struct() ((struct dw_separate_line_info_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_separate_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_separate_line_info_struct() ((struct dw_separate_line_info_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_separate_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_separate_line_info_struct(n) ((struct dw_separate_line_info_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_separate_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_separate_line_info_struct(n) ((struct dw_separate_line_info_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_separate_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_separate_line_info_struct(z) ((struct dw_separate_line_info_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_separate_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_separate_line_info_struct(z) ((struct dw_separate_line_info_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_separate_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_separate_line_info_struct(n, z) ((struct dw_separate_line_info_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_separate_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_separate_line_info_struct(n, z) ((struct dw_separate_line_info_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_separate_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_line_info_struct() ((struct dw_line_info_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_line_info_struct() ((struct dw_line_info_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_line_info_struct(n) ((struct dw_line_info_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_line_info_struct(n) ((struct dw_line_info_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_line_info_struct(z) ((struct dw_line_info_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_line_info_struct(z) ((struct dw_line_info_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_line_info_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_line_info_struct(n, z) ((struct dw_line_info_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_line_info_struct(n, z) ((struct dw_line_info_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_line_info_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_attr_struct() ((struct dw_attr_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_attr_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_attr_struct() ((struct dw_attr_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_attr_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_attr_struct(n) ((struct dw_attr_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_attr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_attr_struct(n) ((struct dw_attr_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_attr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_attr_struct(z) ((struct dw_attr_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_attr_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_attr_struct(z) ((struct dw_attr_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_attr_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_attr_struct(n, z) ((struct dw_attr_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_attr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_attr_struct(n, z) ((struct dw_attr_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_attr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_val_struct_union() ((union dw_val_struct_union *)(ggc_internal_alloc_stat (sizeof (union dw_val_struct_union) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_val_struct_union() ((union dw_val_struct_union *)(ggc_internal_cleared_alloc_stat (sizeof (union dw_val_struct_union) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_val_struct_union(n) ((union dw_val_struct_union *)(ggc_internal_vec_alloc_stat (sizeof (union dw_val_struct_union), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_val_struct_union(n) ((union dw_val_struct_union *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union dw_val_struct_union), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_val_struct_union(z) ((union dw_val_struct_union *)(ggc_internal_zone_alloc_stat (z, sizeof (union dw_val_struct_union) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_val_struct_union(z) ((union dw_val_struct_union *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union dw_val_struct_union) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_val_struct_union(n, z) ((union dw_val_struct_union *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union dw_val_struct_union), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_val_struct_union(n, z) ((union dw_val_struct_union *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union dw_val_struct_union), n MEM_STAT_INFO))) +#define ggc_alloc_dw_val_vms_delta_union() ((struct dw_val_vms_delta_union *)(ggc_internal_alloc_stat (sizeof (struct dw_val_vms_delta_union) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_val_vms_delta_union() ((struct dw_val_vms_delta_union *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_val_vms_delta_union) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_val_vms_delta_union(n) ((struct dw_val_vms_delta_union *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_val_vms_delta_union), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_val_vms_delta_union(n) ((struct dw_val_vms_delta_union *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_val_vms_delta_union), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_val_vms_delta_union(z) ((struct dw_val_vms_delta_union *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_val_vms_delta_union) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_val_vms_delta_union(z) ((struct dw_val_vms_delta_union *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_val_vms_delta_union) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_val_vms_delta_union(n, z) ((struct dw_val_vms_delta_union *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_val_vms_delta_union), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_val_vms_delta_union(n, z) ((struct dw_val_vms_delta_union *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_val_vms_delta_union), n MEM_STAT_INFO))) +#define ggc_alloc_dw_val_die_union() ((struct dw_val_die_union *)(ggc_internal_alloc_stat (sizeof (struct dw_val_die_union) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_val_die_union() ((struct dw_val_die_union *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_val_die_union) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_val_die_union(n) ((struct dw_val_die_union *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_val_die_union), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_val_die_union(n) ((struct dw_val_die_union *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_val_die_union), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_val_die_union(z) ((struct dw_val_die_union *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_val_die_union) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_val_die_union(z) ((struct dw_val_die_union *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_val_die_union) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_val_die_union(n, z) ((struct dw_val_die_union *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_val_die_union), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_val_die_union(n, z) ((struct dw_val_die_union *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_val_die_union), n MEM_STAT_INFO))) +#define ggc_alloc_dw_vec_struct() ((struct dw_vec_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_vec_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_vec_struct() ((struct dw_vec_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_vec_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_vec_struct(n) ((struct dw_vec_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_vec_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_vec_struct(n) ((struct dw_vec_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_vec_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_vec_struct(z) ((struct dw_vec_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_vec_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_vec_struct(z) ((struct dw_vec_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_vec_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_vec_struct(n, z) ((struct dw_vec_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_vec_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_vec_struct(n, z) ((struct dw_vec_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_vec_struct), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_deferred_locations_gc() ((struct VEC_deferred_locations_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_deferred_locations_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_deferred_locations_gc() ((struct VEC_deferred_locations_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_deferred_locations_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_deferred_locations_gc(n) ((struct VEC_deferred_locations_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_deferred_locations_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_deferred_locations_gc(n) ((struct VEC_deferred_locations_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_deferred_locations_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_deferred_locations_gc(z) ((struct VEC_deferred_locations_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_deferred_locations_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_deferred_locations_gc(z) ((struct VEC_deferred_locations_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_deferred_locations_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_deferred_locations_gc(n, z) ((struct VEC_deferred_locations_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_deferred_locations_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_deferred_locations_gc(n, z) ((struct VEC_deferred_locations_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_deferred_locations_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_deferred_locations_base() ((struct VEC_deferred_locations_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_deferred_locations_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_deferred_locations_base() ((struct VEC_deferred_locations_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_deferred_locations_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_deferred_locations_base(n) ((struct VEC_deferred_locations_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_deferred_locations_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_deferred_locations_base(n) ((struct VEC_deferred_locations_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_deferred_locations_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_deferred_locations_base(z) ((struct VEC_deferred_locations_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_deferred_locations_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_deferred_locations_base(z) ((struct VEC_deferred_locations_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_deferred_locations_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_deferred_locations_base(n, z) ((struct VEC_deferred_locations_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_deferred_locations_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_deferred_locations_base(n, z) ((struct VEC_deferred_locations_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_deferred_locations_base), n MEM_STAT_INFO))) +#define ggc_alloc_deferred_locations_struct() ((struct deferred_locations_struct *)(ggc_internal_alloc_stat (sizeof (struct deferred_locations_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_deferred_locations_struct() ((struct deferred_locations_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct deferred_locations_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_deferred_locations_struct(n) ((struct deferred_locations_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct deferred_locations_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_deferred_locations_struct(n) ((struct deferred_locations_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct deferred_locations_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_deferred_locations_struct(z) ((struct deferred_locations_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct deferred_locations_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_deferred_locations_struct(z) ((struct deferred_locations_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct deferred_locations_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_deferred_locations_struct(n, z) ((struct deferred_locations_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct deferred_locations_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_deferred_locations_struct(n, z) ((struct deferred_locations_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct deferred_locations_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_loc_list_struct() ((struct dw_loc_list_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_loc_list_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_loc_list_struct() ((struct dw_loc_list_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_loc_list_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_loc_list_struct(n) ((struct dw_loc_list_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_loc_list_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_loc_list_struct(n) ((struct dw_loc_list_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_loc_list_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_loc_list_struct(z) ((struct dw_loc_list_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_loc_list_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_loc_list_struct(z) ((struct dw_loc_list_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_loc_list_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_loc_list_struct(n, z) ((struct dw_loc_list_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_loc_list_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_loc_list_struct(n, z) ((struct dw_loc_list_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_loc_list_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_val_struct() ((struct dw_val_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_val_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_val_struct() ((struct dw_val_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_val_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_val_struct(n) ((struct dw_val_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_val_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_val_struct(n) ((struct dw_val_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_val_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_val_struct(z) ((struct dw_val_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_val_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_val_struct(z) ((struct dw_val_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_val_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_val_struct(n, z) ((struct dw_val_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_val_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_val_struct(n, z) ((struct dw_val_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_val_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dwarf_file_data() ((struct dwarf_file_data *)(ggc_internal_alloc_stat (sizeof (struct dwarf_file_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dwarf_file_data() ((struct dwarf_file_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct dwarf_file_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_dwarf_file_data(n) ((struct dwarf_file_data *)(ggc_internal_vec_alloc_stat (sizeof (struct dwarf_file_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dwarf_file_data(n) ((struct dwarf_file_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dwarf_file_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dwarf_file_data(z) ((struct dwarf_file_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dwarf_file_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dwarf_file_data(z) ((struct dwarf_file_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dwarf_file_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dwarf_file_data(n, z) ((struct dwarf_file_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dwarf_file_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dwarf_file_data(n, z) ((struct dwarf_file_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dwarf_file_data), n MEM_STAT_INFO))) +#define ggc_alloc_reg_saved_in_data() ((struct reg_saved_in_data *)(ggc_internal_alloc_stat (sizeof (struct reg_saved_in_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_reg_saved_in_data() ((struct reg_saved_in_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct reg_saved_in_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_reg_saved_in_data(n) ((struct reg_saved_in_data *)(ggc_internal_vec_alloc_stat (sizeof (struct reg_saved_in_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_reg_saved_in_data(n) ((struct reg_saved_in_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct reg_saved_in_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_reg_saved_in_data(z) ((struct reg_saved_in_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct reg_saved_in_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_reg_saved_in_data(z) ((struct reg_saved_in_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct reg_saved_in_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_reg_saved_in_data(n, z) ((struct reg_saved_in_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct reg_saved_in_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_reg_saved_in_data(n, z) ((struct reg_saved_in_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct reg_saved_in_data), n MEM_STAT_INFO))) +#define ggc_alloc_queued_reg_save() ((struct queued_reg_save *)(ggc_internal_alloc_stat (sizeof (struct queued_reg_save) MEM_STAT_INFO))) +#define ggc_alloc_cleared_queued_reg_save() ((struct queued_reg_save *)(ggc_internal_cleared_alloc_stat (sizeof (struct queued_reg_save) MEM_STAT_INFO))) +#define ggc_alloc_vec_queued_reg_save(n) ((struct queued_reg_save *)(ggc_internal_vec_alloc_stat (sizeof (struct queued_reg_save), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_queued_reg_save(n) ((struct queued_reg_save *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct queued_reg_save), n MEM_STAT_INFO))) +#define ggc_alloc_zone_queued_reg_save(z) ((struct queued_reg_save *)(ggc_internal_zone_alloc_stat (z, sizeof (struct queued_reg_save) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_queued_reg_save(z) ((struct queued_reg_save *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct queued_reg_save) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_queued_reg_save(n, z) ((struct queued_reg_save *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct queued_reg_save), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_queued_reg_save(n, z) ((struct queued_reg_save *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct queued_reg_save), n MEM_STAT_INFO))) +#define ggc_alloc_indirect_string_node() ((struct indirect_string_node *)(ggc_internal_alloc_stat (sizeof (struct indirect_string_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_indirect_string_node() ((struct indirect_string_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct indirect_string_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_indirect_string_node(n) ((struct indirect_string_node *)(ggc_internal_vec_alloc_stat (sizeof (struct indirect_string_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_indirect_string_node(n) ((struct indirect_string_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct indirect_string_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_indirect_string_node(z) ((struct indirect_string_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct indirect_string_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_indirect_string_node(z) ((struct indirect_string_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct indirect_string_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_indirect_string_node(n, z) ((struct indirect_string_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct indirect_string_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_indirect_string_node(n, z) ((struct indirect_string_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct indirect_string_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_loc_descr_struct() ((struct dw_loc_descr_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_loc_descr_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_loc_descr_struct() ((struct dw_loc_descr_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_loc_descr_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_loc_descr_struct(n) ((struct dw_loc_descr_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_loc_descr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_loc_descr_struct(n) ((struct dw_loc_descr_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_loc_descr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_loc_descr_struct(z) ((struct dw_loc_descr_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_loc_descr_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_loc_descr_struct(z) ((struct dw_loc_descr_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_loc_descr_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_loc_descr_struct(n, z) ((struct dw_loc_descr_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_loc_descr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_loc_descr_struct(n, z) ((struct dw_loc_descr_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_loc_descr_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_cfi_oprnd_struct() ((union dw_cfi_oprnd_struct *)(ggc_internal_alloc_stat (sizeof (union dw_cfi_oprnd_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_cfi_oprnd_struct() ((union dw_cfi_oprnd_struct *)(ggc_internal_cleared_alloc_stat (sizeof (union dw_cfi_oprnd_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_cfi_oprnd_struct(n) ((union dw_cfi_oprnd_struct *)(ggc_internal_vec_alloc_stat (sizeof (union dw_cfi_oprnd_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_cfi_oprnd_struct(n) ((union dw_cfi_oprnd_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union dw_cfi_oprnd_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_cfi_oprnd_struct(z) ((union dw_cfi_oprnd_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (union dw_cfi_oprnd_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_cfi_oprnd_struct(z) ((union dw_cfi_oprnd_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union dw_cfi_oprnd_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_cfi_oprnd_struct(n, z) ((union dw_cfi_oprnd_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union dw_cfi_oprnd_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_cfi_oprnd_struct(n, z) ((union dw_cfi_oprnd_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union dw_cfi_oprnd_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_fde_struct() ((struct dw_fde_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_fde_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_fde_struct() ((struct dw_fde_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_fde_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_fde_struct(n) ((struct dw_fde_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_fde_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_fde_struct(n) ((struct dw_fde_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_fde_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_fde_struct(z) ((struct dw_fde_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_fde_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_fde_struct(z) ((struct dw_fde_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_fde_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_fde_struct(n, z) ((struct dw_fde_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_fde_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_fde_struct(n, z) ((struct dw_fde_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_fde_struct), n MEM_STAT_INFO))) +#define ggc_alloc_dw_cfi_struct() ((struct dw_cfi_struct *)(ggc_internal_alloc_stat (sizeof (struct dw_cfi_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_cfi_struct() ((struct dw_cfi_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct dw_cfi_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_cfi_struct(n) ((struct dw_cfi_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct dw_cfi_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_cfi_struct(n) ((struct dw_cfi_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct dw_cfi_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_cfi_struct(z) ((struct dw_cfi_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct dw_cfi_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_cfi_struct(z) ((struct dw_cfi_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct dw_cfi_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_dw_cfi_struct(n, z) ((struct dw_cfi_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct dw_cfi_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_cfi_struct(n, z) ((struct dw_cfi_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct dw_cfi_struct), n MEM_STAT_INFO))) +#define ggc_alloc_typeinfo() ((struct typeinfo *)(ggc_internal_alloc_stat (sizeof (struct typeinfo) MEM_STAT_INFO))) +#define ggc_alloc_cleared_typeinfo() ((struct typeinfo *)(ggc_internal_cleared_alloc_stat (sizeof (struct typeinfo) MEM_STAT_INFO))) +#define ggc_alloc_vec_typeinfo(n) ((struct typeinfo *)(ggc_internal_vec_alloc_stat (sizeof (struct typeinfo), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_typeinfo(n) ((struct typeinfo *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct typeinfo), n MEM_STAT_INFO))) +#define ggc_alloc_zone_typeinfo(z) ((struct typeinfo *)(ggc_internal_zone_alloc_stat (z, sizeof (struct typeinfo) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_typeinfo(z) ((struct typeinfo *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct typeinfo) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_typeinfo(n, z) ((struct typeinfo *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct typeinfo), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_typeinfo(n, z) ((struct typeinfo *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct typeinfo), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_edge_args() ((struct ipa_edge_args *)(ggc_internal_alloc_stat (sizeof (struct ipa_edge_args) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_edge_args() ((struct ipa_edge_args *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_edge_args) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_edge_args(n) ((struct ipa_edge_args *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_edge_args), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_edge_args(n) ((struct ipa_edge_args *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_edge_args), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_edge_args(z) ((struct ipa_edge_args *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_edge_args) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_edge_args(z) ((struct ipa_edge_args *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_edge_args) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_edge_args(n, z) ((struct ipa_edge_args *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_edge_args), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_edge_args(n, z) ((struct ipa_edge_args *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_edge_args), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_jump_func() ((struct ipa_jump_func *)(ggc_internal_alloc_stat (sizeof (struct ipa_jump_func) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_jump_func() ((struct ipa_jump_func *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_jump_func) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_jump_func(n) ((struct ipa_jump_func *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_jump_func), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_jump_func(n) ((struct ipa_jump_func *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_jump_func), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_jump_func(z) ((struct ipa_jump_func *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_jump_func) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_jump_func(z) ((struct ipa_jump_func *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_jump_func) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_jump_func(n, z) ((struct ipa_jump_func *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_jump_func), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_jump_func(n, z) ((struct ipa_jump_func *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_jump_func), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_alias_set_entry_gc() ((struct VEC_alias_set_entry_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_alias_set_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_alias_set_entry_gc() ((struct VEC_alias_set_entry_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_alias_set_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_alias_set_entry_gc(n) ((struct VEC_alias_set_entry_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_alias_set_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_alias_set_entry_gc(n) ((struct VEC_alias_set_entry_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_alias_set_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_alias_set_entry_gc(z) ((struct VEC_alias_set_entry_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_alias_set_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_alias_set_entry_gc(z) ((struct VEC_alias_set_entry_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_alias_set_entry_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_alias_set_entry_gc(n, z) ((struct VEC_alias_set_entry_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_alias_set_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_alias_set_entry_gc(n, z) ((struct VEC_alias_set_entry_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_alias_set_entry_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_alias_set_entry_base() ((struct VEC_alias_set_entry_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_alias_set_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_alias_set_entry_base() ((struct VEC_alias_set_entry_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_alias_set_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_alias_set_entry_base(n) ((struct VEC_alias_set_entry_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_alias_set_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_alias_set_entry_base(n) ((struct VEC_alias_set_entry_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_alias_set_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_alias_set_entry_base(z) ((struct VEC_alias_set_entry_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_alias_set_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_alias_set_entry_base(z) ((struct VEC_alias_set_entry_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_alias_set_entry_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_alias_set_entry_base(n, z) ((struct VEC_alias_set_entry_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_alias_set_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_alias_set_entry_base(n, z) ((struct VEC_alias_set_entry_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_alias_set_entry_base), n MEM_STAT_INFO))) +#define ggc_alloc_alias_set_entry_d() ((struct alias_set_entry_d *)(ggc_internal_alloc_stat (sizeof (struct alias_set_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_alias_set_entry_d() ((struct alias_set_entry_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct alias_set_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_alias_set_entry_d(n) ((struct alias_set_entry_d *)(ggc_internal_vec_alloc_stat (sizeof (struct alias_set_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_alias_set_entry_d(n) ((struct alias_set_entry_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct alias_set_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_alias_set_entry_d(z) ((struct alias_set_entry_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct alias_set_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_alias_set_entry_d(z) ((struct alias_set_entry_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct alias_set_entry_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_alias_set_entry_d(n, z) ((struct alias_set_entry_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct alias_set_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_alias_set_entry_d(n, z) ((struct alias_set_entry_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct alias_set_entry_d), n MEM_STAT_INFO))) +#define ggc_alloc_constant_descriptor_tree() ((struct constant_descriptor_tree *)(ggc_internal_alloc_stat (sizeof (struct constant_descriptor_tree) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constant_descriptor_tree() ((struct constant_descriptor_tree *)(ggc_internal_cleared_alloc_stat (sizeof (struct constant_descriptor_tree) MEM_STAT_INFO))) +#define ggc_alloc_vec_constant_descriptor_tree(n) ((struct constant_descriptor_tree *)(ggc_internal_vec_alloc_stat (sizeof (struct constant_descriptor_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constant_descriptor_tree(n) ((struct constant_descriptor_tree *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct constant_descriptor_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constant_descriptor_tree(z) ((struct constant_descriptor_tree *)(ggc_internal_zone_alloc_stat (z, sizeof (struct constant_descriptor_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constant_descriptor_tree(z) ((struct constant_descriptor_tree *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct constant_descriptor_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_constant_descriptor_tree(n, z) ((struct constant_descriptor_tree *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct constant_descriptor_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constant_descriptor_tree(n, z) ((struct constant_descriptor_tree *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct constant_descriptor_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_sym() ((struct cgraph_sym *)(ggc_internal_alloc_stat (sizeof (struct cgraph_sym) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_sym() ((struct cgraph_sym *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_sym) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_sym(n) ((struct cgraph_sym *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_sym), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_sym(n) ((struct cgraph_sym *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_sym), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_sym(z) ((struct cgraph_sym *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_sym) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_sym(z) ((struct cgraph_sym *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_sym) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_sym(n, z) ((struct cgraph_sym *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_sym), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_sym(n, z) ((struct cgraph_sym *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_sym), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_mod_info() ((struct cgraph_mod_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_mod_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_mod_info() ((struct cgraph_mod_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_mod_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_mod_info(n) ((struct cgraph_mod_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_mod_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_mod_info(n) ((struct cgraph_mod_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_mod_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_mod_info(z) ((struct cgraph_mod_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_mod_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_mod_info(z) ((struct cgraph_mod_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_mod_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_mod_info(n, z) ((struct cgraph_mod_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_mod_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_mod_info(n, z) ((struct cgraph_mod_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_mod_info), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_asm_node() ((struct cgraph_asm_node *)(ggc_internal_alloc_stat (sizeof (struct cgraph_asm_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_asm_node() ((struct cgraph_asm_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_asm_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_asm_node(n) ((struct cgraph_asm_node *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_asm_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_asm_node(n) ((struct cgraph_asm_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_asm_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_asm_node(z) ((struct cgraph_asm_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_asm_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_asm_node(z) ((struct cgraph_asm_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_asm_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_asm_node(n, z) ((struct cgraph_asm_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_asm_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_asm_node(n, z) ((struct cgraph_asm_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_asm_node), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_indirect_call_info() ((struct cgraph_indirect_call_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_indirect_call_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_indirect_call_info() ((struct cgraph_indirect_call_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_indirect_call_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_indirect_call_info(n) ((struct cgraph_indirect_call_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_indirect_call_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_indirect_call_info(n) ((struct cgraph_indirect_call_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_indirect_call_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_indirect_call_info(z) ((struct cgraph_indirect_call_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_indirect_call_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_indirect_call_info(z) ((struct cgraph_indirect_call_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_indirect_call_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_indirect_call_info(n, z) ((struct cgraph_indirect_call_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_indirect_call_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_indirect_call_info(n, z) ((struct cgraph_indirect_call_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_indirect_call_info), n MEM_STAT_INFO))) +#define ggc_alloc_varpool_node_set_def() ((struct varpool_node_set_def *)(ggc_internal_alloc_stat (sizeof (struct varpool_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varpool_node_set_def() ((struct varpool_node_set_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct varpool_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_varpool_node_set_def(n) ((struct varpool_node_set_def *)(ggc_internal_vec_alloc_stat (sizeof (struct varpool_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varpool_node_set_def(n) ((struct varpool_node_set_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct varpool_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varpool_node_set_def(z) ((struct varpool_node_set_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct varpool_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varpool_node_set_def(z) ((struct varpool_node_set_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct varpool_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_varpool_node_set_def(n, z) ((struct varpool_node_set_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct varpool_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varpool_node_set_def(n, z) ((struct varpool_node_set_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct varpool_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_varpool_node_set_element_def() ((struct varpool_node_set_element_def *)(ggc_internal_alloc_stat (sizeof (struct varpool_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varpool_node_set_element_def() ((struct varpool_node_set_element_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct varpool_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_varpool_node_set_element_def(n) ((struct varpool_node_set_element_def *)(ggc_internal_vec_alloc_stat (sizeof (struct varpool_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varpool_node_set_element_def(n) ((struct varpool_node_set_element_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct varpool_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varpool_node_set_element_def(z) ((struct varpool_node_set_element_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct varpool_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varpool_node_set_element_def(z) ((struct varpool_node_set_element_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct varpool_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_varpool_node_set_element_def(n, z) ((struct varpool_node_set_element_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct varpool_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varpool_node_set_element_def(n, z) ((struct varpool_node_set_element_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct varpool_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_varpool_node_ptr_gc() ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_varpool_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_varpool_node_ptr_gc() ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_varpool_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_varpool_node_ptr_gc(n) ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_varpool_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_varpool_node_ptr_gc(n) ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_varpool_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_varpool_node_ptr_gc(z) ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_varpool_node_ptr_gc(z) ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_varpool_node_ptr_gc(n, z) ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_varpool_node_ptr_gc(n, z) ((struct VEC_varpool_node_ptr_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_varpool_node_ptr_base() ((struct VEC_varpool_node_ptr_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_varpool_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_varpool_node_ptr_base() ((struct VEC_varpool_node_ptr_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_varpool_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_varpool_node_ptr_base(n) ((struct VEC_varpool_node_ptr_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_varpool_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_varpool_node_ptr_base(n) ((struct VEC_varpool_node_ptr_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_varpool_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_varpool_node_ptr_base(z) ((struct VEC_varpool_node_ptr_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_varpool_node_ptr_base(z) ((struct VEC_varpool_node_ptr_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_varpool_node_ptr_base(n, z) ((struct VEC_varpool_node_ptr_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_varpool_node_ptr_base(n, z) ((struct VEC_varpool_node_ptr_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_varpool_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_node_set_def() ((struct cgraph_node_set_def *)(ggc_internal_alloc_stat (sizeof (struct cgraph_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_node_set_def() ((struct cgraph_node_set_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_node_set_def(n) ((struct cgraph_node_set_def *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_node_set_def(n) ((struct cgraph_node_set_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_node_set_def(z) ((struct cgraph_node_set_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_node_set_def(z) ((struct cgraph_node_set_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_node_set_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_node_set_def(n, z) ((struct cgraph_node_set_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_node_set_def(n, z) ((struct cgraph_node_set_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_node_set_def), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_node_set_element_def() ((struct cgraph_node_set_element_def *)(ggc_internal_alloc_stat (sizeof (struct cgraph_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_node_set_element_def() ((struct cgraph_node_set_element_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_node_set_element_def(n) ((struct cgraph_node_set_element_def *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_node_set_element_def(n) ((struct cgraph_node_set_element_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_node_set_element_def(z) ((struct cgraph_node_set_element_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_node_set_element_def(z) ((struct cgraph_node_set_element_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_node_set_element_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_node_set_element_def(n, z) ((struct cgraph_node_set_element_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_node_set_element_def(n, z) ((struct cgraph_node_set_element_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_node_set_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cgraph_node_ptr_gc() ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cgraph_node_ptr_gc() ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cgraph_node_ptr_gc(n) ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cgraph_node_ptr_gc(n) ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cgraph_node_ptr_gc(z) ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cgraph_node_ptr_gc(z) ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cgraph_node_ptr_gc(n, z) ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cgraph_node_ptr_gc(n, z) ((struct VEC_cgraph_node_ptr_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_cgraph_node_ptr_base() ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_cgraph_node_ptr_base() ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_cgraph_node_ptr_base(n) ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_cgraph_node_ptr_base(n) ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_cgraph_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_cgraph_node_ptr_base(z) ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_cgraph_node_ptr_base(z) ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_cgraph_node_ptr_base(n, z) ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_cgraph_node_ptr_base(n, z) ((struct VEC_cgraph_node_ptr_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_cgraph_node_ptr_base), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_edge() ((struct cgraph_edge *)(ggc_internal_alloc_stat (sizeof (struct cgraph_edge) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_edge() ((struct cgraph_edge *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_edge) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_edge(n) ((struct cgraph_edge *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_edge), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_edge(n) ((struct cgraph_edge *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_edge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_edge(z) ((struct cgraph_edge *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_edge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_edge(z) ((struct cgraph_edge *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_edge) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_edge(n, z) ((struct cgraph_edge *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_edge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_edge(n, z) ((struct cgraph_edge *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_edge), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_clone_info() ((struct cgraph_clone_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_clone_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_clone_info() ((struct cgraph_clone_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_clone_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_clone_info(n) ((struct cgraph_clone_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_clone_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_clone_info(n) ((struct cgraph_clone_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_clone_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_clone_info(z) ((struct cgraph_clone_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_clone_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_clone_info(z) ((struct cgraph_clone_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_clone_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_clone_info(n, z) ((struct cgraph_clone_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_clone_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_clone_info(n, z) ((struct cgraph_clone_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_clone_info), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ipa_replace_map_p_gc() ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ipa_replace_map_p_gc() ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ipa_replace_map_p_gc(n) ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ipa_replace_map_p_gc(n) ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ipa_replace_map_p_gc(z) ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ipa_replace_map_p_gc(z) ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ipa_replace_map_p_gc(n, z) ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ipa_replace_map_p_gc(n, z) ((struct VEC_ipa_replace_map_p_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ipa_replace_map_p_base() ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ipa_replace_map_p_base() ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ipa_replace_map_p_base(n) ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ipa_replace_map_p_base(n) ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ipa_replace_map_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ipa_replace_map_p_base(z) ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ipa_replace_map_p_base(z) ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ipa_replace_map_p_base(n, z) ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ipa_replace_map_p_base(n, z) ((struct VEC_ipa_replace_map_p_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ipa_replace_map_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_replace_map() ((struct ipa_replace_map *)(ggc_internal_alloc_stat (sizeof (struct ipa_replace_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_replace_map() ((struct ipa_replace_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_replace_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_replace_map(n) ((struct ipa_replace_map *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_replace_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_replace_map(n) ((struct ipa_replace_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_replace_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_replace_map(z) ((struct ipa_replace_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_replace_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_replace_map(z) ((struct ipa_replace_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_replace_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_replace_map(n, z) ((struct ipa_replace_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_replace_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_replace_map(n, z) ((struct ipa_replace_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_replace_map), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_rtl_info() ((struct cgraph_rtl_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_rtl_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_rtl_info() ((struct cgraph_rtl_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_rtl_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_rtl_info(n) ((struct cgraph_rtl_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_rtl_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_rtl_info(n) ((struct cgraph_rtl_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_rtl_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_rtl_info(z) ((struct cgraph_rtl_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_rtl_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_rtl_info(z) ((struct cgraph_rtl_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_rtl_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_rtl_info(n, z) ((struct cgraph_rtl_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_rtl_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_rtl_info(n, z) ((struct cgraph_rtl_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_rtl_info), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_global_info() ((struct cgraph_global_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_global_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_global_info() ((struct cgraph_global_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_global_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_global_info(n) ((struct cgraph_global_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_global_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_global_info(n) ((struct cgraph_global_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_global_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_global_info(z) ((struct cgraph_global_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_global_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_global_info(z) ((struct cgraph_global_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_global_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_global_info(n, z) ((struct cgraph_global_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_global_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_global_info(n, z) ((struct cgraph_global_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_global_info), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_local_info() ((struct cgraph_local_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_local_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_local_info() ((struct cgraph_local_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_local_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_local_info(n) ((struct cgraph_local_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_local_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_local_info(n) ((struct cgraph_local_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_local_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_local_info(z) ((struct cgraph_local_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_local_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_local_info(z) ((struct cgraph_local_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_local_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_local_info(n, z) ((struct cgraph_local_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_local_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_local_info(n, z) ((struct cgraph_local_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_local_info), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_thunk_info() ((struct cgraph_thunk_info *)(ggc_internal_alloc_stat (sizeof (struct cgraph_thunk_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_thunk_info() ((struct cgraph_thunk_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_thunk_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_thunk_info(n) ((struct cgraph_thunk_info *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_thunk_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_thunk_info(n) ((struct cgraph_thunk_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_thunk_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_thunk_info(z) ((struct cgraph_thunk_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_thunk_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_thunk_info(z) ((struct cgraph_thunk_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_thunk_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_thunk_info(n, z) ((struct cgraph_thunk_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_thunk_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_thunk_info(n, z) ((struct cgraph_thunk_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_thunk_info), n MEM_STAT_INFO))) +#define ggc_alloc_inline_summary() ((struct inline_summary *)(ggc_internal_alloc_stat (sizeof (struct inline_summary) MEM_STAT_INFO))) +#define ggc_alloc_cleared_inline_summary() ((struct inline_summary *)(ggc_internal_cleared_alloc_stat (sizeof (struct inline_summary) MEM_STAT_INFO))) +#define ggc_alloc_vec_inline_summary(n) ((struct inline_summary *)(ggc_internal_vec_alloc_stat (sizeof (struct inline_summary), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_inline_summary(n) ((struct inline_summary *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct inline_summary), n MEM_STAT_INFO))) +#define ggc_alloc_zone_inline_summary(z) ((struct inline_summary *)(ggc_internal_zone_alloc_stat (z, sizeof (struct inline_summary) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_inline_summary(z) ((struct inline_summary *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct inline_summary) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_inline_summary(n, z) ((struct inline_summary *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct inline_summary), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_inline_summary(n, z) ((struct inline_summary *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct inline_summary), n MEM_STAT_INFO))) +#define ggc_alloc_lto_file_decl_data() ((struct lto_file_decl_data *)(ggc_internal_alloc_stat (sizeof (struct lto_file_decl_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_file_decl_data() ((struct lto_file_decl_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct lto_file_decl_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_file_decl_data(n) ((struct lto_file_decl_data *)(ggc_internal_vec_alloc_stat (sizeof (struct lto_file_decl_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_file_decl_data(n) ((struct lto_file_decl_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lto_file_decl_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_file_decl_data(z) ((struct lto_file_decl_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lto_file_decl_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_file_decl_data(z) ((struct lto_file_decl_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lto_file_decl_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lto_file_decl_data(n, z) ((struct lto_file_decl_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lto_file_decl_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_file_decl_data(n, z) ((struct lto_file_decl_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lto_file_decl_data), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_ref_list() ((struct ipa_ref_list *)(ggc_internal_alloc_stat (sizeof (struct ipa_ref_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_ref_list() ((struct ipa_ref_list *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_ref_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_ref_list(n) ((struct ipa_ref_list *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_ref_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_ref_list(n) ((struct ipa_ref_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_ref_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_ref_list(z) ((struct ipa_ref_list *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_ref_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_ref_list(z) ((struct ipa_ref_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_ref_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_ref_list(n, z) ((struct ipa_ref_list *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_ref_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_ref_list(n, z) ((struct ipa_ref_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_ref_list), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ipa_ref_t_gc() ((struct VEC_ipa_ref_t_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_ipa_ref_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ipa_ref_t_gc() ((struct VEC_ipa_ref_t_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ipa_ref_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ipa_ref_t_gc(n) ((struct VEC_ipa_ref_t_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ipa_ref_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ipa_ref_t_gc(n) ((struct VEC_ipa_ref_t_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ipa_ref_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ipa_ref_t_gc(z) ((struct VEC_ipa_ref_t_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ipa_ref_t_gc(z) ((struct VEC_ipa_ref_t_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ipa_ref_t_gc(n, z) ((struct VEC_ipa_ref_t_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ipa_ref_t_gc(n, z) ((struct VEC_ipa_ref_t_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_ipa_ref_t_base() ((struct VEC_ipa_ref_t_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_ipa_ref_t_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_ipa_ref_t_base() ((struct VEC_ipa_ref_t_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_ipa_ref_t_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_ipa_ref_t_base(n) ((struct VEC_ipa_ref_t_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_ipa_ref_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_ipa_ref_t_base(n) ((struct VEC_ipa_ref_t_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_ipa_ref_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_ipa_ref_t_base(z) ((struct VEC_ipa_ref_t_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_ipa_ref_t_base(z) ((struct VEC_ipa_ref_t_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_ipa_ref_t_base(n, z) ((struct VEC_ipa_ref_t_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_ipa_ref_t_base(n, z) ((struct VEC_ipa_ref_t_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_ipa_ref_t_base), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_ref() ((struct ipa_ref *)(ggc_internal_alloc_stat (sizeof (struct ipa_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_ref() ((struct ipa_ref *)(ggc_internal_cleared_alloc_stat (sizeof (struct ipa_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_ref(n) ((struct ipa_ref *)(ggc_internal_vec_alloc_stat (sizeof (struct ipa_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_ref(n) ((struct ipa_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ipa_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_ref(z) ((struct ipa_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ipa_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_ref(z) ((struct ipa_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ipa_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_ref(n, z) ((struct ipa_ref *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ipa_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_ref(n, z) ((struct ipa_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ipa_ref), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_ref_ptr_u() ((union ipa_ref_ptr_u *)(ggc_internal_alloc_stat (sizeof (union ipa_ref_ptr_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_ref_ptr_u() ((union ipa_ref_ptr_u *)(ggc_internal_cleared_alloc_stat (sizeof (union ipa_ref_ptr_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_ref_ptr_u(n) ((union ipa_ref_ptr_u *)(ggc_internal_vec_alloc_stat (sizeof (union ipa_ref_ptr_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_ref_ptr_u(n) ((union ipa_ref_ptr_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union ipa_ref_ptr_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_ref_ptr_u(z) ((union ipa_ref_ptr_u *)(ggc_internal_zone_alloc_stat (z, sizeof (union ipa_ref_ptr_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_ref_ptr_u(z) ((union ipa_ref_ptr_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union ipa_ref_ptr_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ipa_ref_ptr_u(n, z) ((union ipa_ref_ptr_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union ipa_ref_ptr_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_ref_ptr_u(n, z) ((union ipa_ref_ptr_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union ipa_ref_ptr_u), n MEM_STAT_INFO))) +#define ggc_alloc_varpool_node() ((struct varpool_node *)(ggc_internal_alloc_stat (sizeof (struct varpool_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varpool_node() ((struct varpool_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct varpool_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_varpool_node(n) ((struct varpool_node *)(ggc_internal_vec_alloc_stat (sizeof (struct varpool_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varpool_node(n) ((struct varpool_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct varpool_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varpool_node(z) ((struct varpool_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct varpool_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varpool_node(z) ((struct varpool_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct varpool_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_varpool_node(n, z) ((struct varpool_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct varpool_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varpool_node(n, z) ((struct varpool_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct varpool_node), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_node() ((struct cgraph_node *)(ggc_internal_alloc_stat (sizeof (struct cgraph_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_node() ((struct cgraph_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct cgraph_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_node(n) ((struct cgraph_node *)(ggc_internal_vec_alloc_stat (sizeof (struct cgraph_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_node(n) ((struct cgraph_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cgraph_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_node(z) ((struct cgraph_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cgraph_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_node(z) ((struct cgraph_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cgraph_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cgraph_node(n, z) ((struct cgraph_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cgraph_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_node(n, z) ((struct cgraph_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cgraph_node), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_basic_block_gc() ((struct VEC_basic_block_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_basic_block_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_basic_block_gc() ((struct VEC_basic_block_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_basic_block_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_basic_block_gc(n) ((struct VEC_basic_block_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_basic_block_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_basic_block_gc(n) ((struct VEC_basic_block_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_basic_block_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_basic_block_gc(z) ((struct VEC_basic_block_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_basic_block_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_basic_block_gc(z) ((struct VEC_basic_block_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_basic_block_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_basic_block_gc(n, z) ((struct VEC_basic_block_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_basic_block_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_basic_block_gc(n, z) ((struct VEC_basic_block_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_basic_block_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_basic_block_base() ((struct VEC_basic_block_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_basic_block_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_basic_block_base() ((struct VEC_basic_block_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_basic_block_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_basic_block_base(n) ((struct VEC_basic_block_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_basic_block_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_basic_block_base(n) ((struct VEC_basic_block_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_basic_block_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_basic_block_base(z) ((struct VEC_basic_block_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_basic_block_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_basic_block_base(z) ((struct VEC_basic_block_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_basic_block_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_basic_block_base(n, z) ((struct VEC_basic_block_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_basic_block_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_basic_block_base(n, z) ((struct VEC_basic_block_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_basic_block_base), n MEM_STAT_INFO))) +#define ggc_alloc_basic_block_il_dependent() ((union basic_block_il_dependent *)(ggc_internal_alloc_stat (sizeof (union basic_block_il_dependent) MEM_STAT_INFO))) +#define ggc_alloc_cleared_basic_block_il_dependent() ((union basic_block_il_dependent *)(ggc_internal_cleared_alloc_stat (sizeof (union basic_block_il_dependent) MEM_STAT_INFO))) +#define ggc_alloc_vec_basic_block_il_dependent(n) ((union basic_block_il_dependent *)(ggc_internal_vec_alloc_stat (sizeof (union basic_block_il_dependent), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_basic_block_il_dependent(n) ((union basic_block_il_dependent *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union basic_block_il_dependent), n MEM_STAT_INFO))) +#define ggc_alloc_zone_basic_block_il_dependent(z) ((union basic_block_il_dependent *)(ggc_internal_zone_alloc_stat (z, sizeof (union basic_block_il_dependent) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_basic_block_il_dependent(z) ((union basic_block_il_dependent *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union basic_block_il_dependent) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_basic_block_il_dependent(n, z) ((union basic_block_il_dependent *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union basic_block_il_dependent), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_basic_block_il_dependent(n, z) ((union basic_block_il_dependent *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union basic_block_il_dependent), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_bb_info() ((struct gimple_bb_info *)(ggc_internal_alloc_stat (sizeof (struct gimple_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_bb_info() ((struct gimple_bb_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_bb_info(n) ((struct gimple_bb_info *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_bb_info(n) ((struct gimple_bb_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_bb_info(z) ((struct gimple_bb_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_bb_info(z) ((struct gimple_bb_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_bb_info(n, z) ((struct gimple_bb_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_bb_info(n, z) ((struct gimple_bb_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_rtl_bb_info() ((struct rtl_bb_info *)(ggc_internal_alloc_stat (sizeof (struct rtl_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtl_bb_info() ((struct rtl_bb_info *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtl_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtl_bb_info(n) ((struct rtl_bb_info *)(ggc_internal_vec_alloc_stat (sizeof (struct rtl_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtl_bb_info(n) ((struct rtl_bb_info *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtl_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtl_bb_info(z) ((struct rtl_bb_info *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtl_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtl_bb_info(z) ((struct rtl_bb_info *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtl_bb_info) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtl_bb_info(n, z) ((struct rtl_bb_info *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtl_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtl_bb_info(n, z) ((struct rtl_bb_info *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtl_bb_info), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_edge_gc() ((struct VEC_edge_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_edge_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_edge_gc() ((struct VEC_edge_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_edge_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_edge_gc(n) ((struct VEC_edge_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_edge_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_edge_gc(n) ((struct VEC_edge_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_edge_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_edge_gc(z) ((struct VEC_edge_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_edge_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_edge_gc(z) ((struct VEC_edge_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_edge_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_edge_gc(n, z) ((struct VEC_edge_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_edge_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_edge_gc(n, z) ((struct VEC_edge_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_edge_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_edge_base() ((struct VEC_edge_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_edge_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_edge_base() ((struct VEC_edge_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_edge_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_edge_base(n) ((struct VEC_edge_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_edge_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_edge_base(n) ((struct VEC_edge_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_edge_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_edge_base(z) ((struct VEC_edge_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_edge_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_edge_base(z) ((struct VEC_edge_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_edge_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_edge_base(n, z) ((struct VEC_edge_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_edge_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_edge_base(n, z) ((struct VEC_edge_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_edge_base), n MEM_STAT_INFO))) +#define ggc_alloc_edge_def_insns() ((union edge_def_insns *)(ggc_internal_alloc_stat (sizeof (union edge_def_insns) MEM_STAT_INFO))) +#define ggc_alloc_cleared_edge_def_insns() ((union edge_def_insns *)(ggc_internal_cleared_alloc_stat (sizeof (union edge_def_insns) MEM_STAT_INFO))) +#define ggc_alloc_vec_edge_def_insns(n) ((union edge_def_insns *)(ggc_internal_vec_alloc_stat (sizeof (union edge_def_insns), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_edge_def_insns(n) ((union edge_def_insns *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union edge_def_insns), n MEM_STAT_INFO))) +#define ggc_alloc_zone_edge_def_insns(z) ((union edge_def_insns *)(ggc_internal_zone_alloc_stat (z, sizeof (union edge_def_insns) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_edge_def_insns(z) ((union edge_def_insns *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union edge_def_insns) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_edge_def_insns(n, z) ((union edge_def_insns *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union edge_def_insns), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_edge_def_insns(n, z) ((union edge_def_insns *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union edge_def_insns), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_loop_p_gc() ((struct VEC_loop_p_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_loop_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_loop_p_gc() ((struct VEC_loop_p_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_loop_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_loop_p_gc(n) ((struct VEC_loop_p_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_loop_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_loop_p_gc(n) ((struct VEC_loop_p_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_loop_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_loop_p_gc(z) ((struct VEC_loop_p_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_loop_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_loop_p_gc(z) ((struct VEC_loop_p_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_loop_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_loop_p_gc(n, z) ((struct VEC_loop_p_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_loop_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_loop_p_gc(n, z) ((struct VEC_loop_p_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_loop_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_loop_p_base() ((struct VEC_loop_p_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_loop_p_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_loop_p_base() ((struct VEC_loop_p_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_loop_p_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_loop_p_base(n) ((struct VEC_loop_p_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_loop_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_loop_p_base(n) ((struct VEC_loop_p_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_loop_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_loop_p_base(z) ((struct VEC_loop_p_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_loop_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_loop_p_base(z) ((struct VEC_loop_p_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_loop_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_loop_p_base(n, z) ((struct VEC_loop_p_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_loop_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_loop_p_base(n, z) ((struct VEC_loop_p_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_loop_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_loop() ((struct loop *)(ggc_internal_alloc_stat (sizeof (struct loop) MEM_STAT_INFO))) +#define ggc_alloc_cleared_loop() ((struct loop *)(ggc_internal_cleared_alloc_stat (sizeof (struct loop) MEM_STAT_INFO))) +#define ggc_alloc_vec_loop(n) ((struct loop *)(ggc_internal_vec_alloc_stat (sizeof (struct loop), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_loop(n) ((struct loop *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct loop), n MEM_STAT_INFO))) +#define ggc_alloc_zone_loop(z) ((struct loop *)(ggc_internal_zone_alloc_stat (z, sizeof (struct loop) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_loop(z) ((struct loop *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct loop) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_loop(n, z) ((struct loop *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct loop), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_loop(n, z) ((struct loop *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct loop), n MEM_STAT_INFO))) +#define ggc_alloc_loop_exit() ((struct loop_exit *)(ggc_internal_alloc_stat (sizeof (struct loop_exit) MEM_STAT_INFO))) +#define ggc_alloc_cleared_loop_exit() ((struct loop_exit *)(ggc_internal_cleared_alloc_stat (sizeof (struct loop_exit) MEM_STAT_INFO))) +#define ggc_alloc_vec_loop_exit(n) ((struct loop_exit *)(ggc_internal_vec_alloc_stat (sizeof (struct loop_exit), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_loop_exit(n) ((struct loop_exit *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct loop_exit), n MEM_STAT_INFO))) +#define ggc_alloc_zone_loop_exit(z) ((struct loop_exit *)(ggc_internal_zone_alloc_stat (z, sizeof (struct loop_exit) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_loop_exit(z) ((struct loop_exit *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct loop_exit) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_loop_exit(n, z) ((struct loop_exit *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct loop_exit), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_loop_exit(n, z) ((struct loop_exit *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct loop_exit), n MEM_STAT_INFO))) +#define ggc_alloc_nb_iter_bound() ((struct nb_iter_bound *)(ggc_internal_alloc_stat (sizeof (struct nb_iter_bound) MEM_STAT_INFO))) +#define ggc_alloc_cleared_nb_iter_bound() ((struct nb_iter_bound *)(ggc_internal_cleared_alloc_stat (sizeof (struct nb_iter_bound) MEM_STAT_INFO))) +#define ggc_alloc_vec_nb_iter_bound(n) ((struct nb_iter_bound *)(ggc_internal_vec_alloc_stat (sizeof (struct nb_iter_bound), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_nb_iter_bound(n) ((struct nb_iter_bound *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct nb_iter_bound), n MEM_STAT_INFO))) +#define ggc_alloc_zone_nb_iter_bound(z) ((struct nb_iter_bound *)(ggc_internal_zone_alloc_stat (z, sizeof (struct nb_iter_bound) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_nb_iter_bound(z) ((struct nb_iter_bound *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct nb_iter_bound) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_nb_iter_bound(n, z) ((struct nb_iter_bound *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct nb_iter_bound), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_nb_iter_bound(n, z) ((struct nb_iter_bound *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct nb_iter_bound), n MEM_STAT_INFO))) +#define ggc_alloc_lpt_decision() ((struct lpt_decision *)(ggc_internal_alloc_stat (sizeof (struct lpt_decision) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lpt_decision() ((struct lpt_decision *)(ggc_internal_cleared_alloc_stat (sizeof (struct lpt_decision) MEM_STAT_INFO))) +#define ggc_alloc_vec_lpt_decision(n) ((struct lpt_decision *)(ggc_internal_vec_alloc_stat (sizeof (struct lpt_decision), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lpt_decision(n) ((struct lpt_decision *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lpt_decision), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lpt_decision(z) ((struct lpt_decision *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lpt_decision) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lpt_decision(z) ((struct lpt_decision *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lpt_decision) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lpt_decision(n, z) ((struct lpt_decision *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lpt_decision), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lpt_decision(n, z) ((struct lpt_decision *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lpt_decision), n MEM_STAT_INFO))) +#define ggc_alloc_noswitch_section() ((struct noswitch_section *)(ggc_internal_alloc_stat (sizeof (struct noswitch_section) MEM_STAT_INFO))) +#define ggc_alloc_cleared_noswitch_section() ((struct noswitch_section *)(ggc_internal_cleared_alloc_stat (sizeof (struct noswitch_section) MEM_STAT_INFO))) +#define ggc_alloc_vec_noswitch_section(n) ((struct noswitch_section *)(ggc_internal_vec_alloc_stat (sizeof (struct noswitch_section), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_noswitch_section(n) ((struct noswitch_section *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct noswitch_section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_noswitch_section(z) ((struct noswitch_section *)(ggc_internal_zone_alloc_stat (z, sizeof (struct noswitch_section) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_noswitch_section(z) ((struct noswitch_section *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct noswitch_section) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_noswitch_section(n, z) ((struct noswitch_section *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct noswitch_section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_noswitch_section(n, z) ((struct noswitch_section *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct noswitch_section), n MEM_STAT_INFO))) +#define ggc_alloc_unnamed_section() ((struct unnamed_section *)(ggc_internal_alloc_stat (sizeof (struct unnamed_section) MEM_STAT_INFO))) +#define ggc_alloc_cleared_unnamed_section() ((struct unnamed_section *)(ggc_internal_cleared_alloc_stat (sizeof (struct unnamed_section) MEM_STAT_INFO))) +#define ggc_alloc_vec_unnamed_section(n) ((struct unnamed_section *)(ggc_internal_vec_alloc_stat (sizeof (struct unnamed_section), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_unnamed_section(n) ((struct unnamed_section *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct unnamed_section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_unnamed_section(z) ((struct unnamed_section *)(ggc_internal_zone_alloc_stat (z, sizeof (struct unnamed_section) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_unnamed_section(z) ((struct unnamed_section *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct unnamed_section) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_unnamed_section(n, z) ((struct unnamed_section *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct unnamed_section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_unnamed_section(n, z) ((struct unnamed_section *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct unnamed_section), n MEM_STAT_INFO))) +#define ggc_alloc_named_section() ((struct named_section *)(ggc_internal_alloc_stat (sizeof (struct named_section) MEM_STAT_INFO))) +#define ggc_alloc_cleared_named_section() ((struct named_section *)(ggc_internal_cleared_alloc_stat (sizeof (struct named_section) MEM_STAT_INFO))) +#define ggc_alloc_vec_named_section(n) ((struct named_section *)(ggc_internal_vec_alloc_stat (sizeof (struct named_section), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_named_section(n) ((struct named_section *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct named_section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_named_section(z) ((struct named_section *)(ggc_internal_zone_alloc_stat (z, sizeof (struct named_section) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_named_section(z) ((struct named_section *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct named_section) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_named_section(n, z) ((struct named_section *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct named_section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_named_section(n, z) ((struct named_section *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct named_section), n MEM_STAT_INFO))) +#define ggc_alloc_section_common() ((struct section_common *)(ggc_internal_alloc_stat (sizeof (struct section_common) MEM_STAT_INFO))) +#define ggc_alloc_cleared_section_common() ((struct section_common *)(ggc_internal_cleared_alloc_stat (sizeof (struct section_common) MEM_STAT_INFO))) +#define ggc_alloc_vec_section_common(n) ((struct section_common *)(ggc_internal_vec_alloc_stat (sizeof (struct section_common), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_section_common(n) ((struct section_common *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct section_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_section_common(z) ((struct section_common *)(ggc_internal_zone_alloc_stat (z, sizeof (struct section_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_section_common(z) ((struct section_common *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct section_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_section_common(n, z) ((struct section_common *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct section_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_section_common(n, z) ((struct section_common *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct section_common), n MEM_STAT_INFO))) +#define ggc_alloc_types_used_by_vars_entry() ((struct types_used_by_vars_entry *)(ggc_internal_alloc_stat (sizeof (struct types_used_by_vars_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_types_used_by_vars_entry() ((struct types_used_by_vars_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct types_used_by_vars_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_types_used_by_vars_entry(n) ((struct types_used_by_vars_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct types_used_by_vars_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_types_used_by_vars_entry(n) ((struct types_used_by_vars_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct types_used_by_vars_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_types_used_by_vars_entry(z) ((struct types_used_by_vars_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct types_used_by_vars_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_types_used_by_vars_entry(z) ((struct types_used_by_vars_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct types_used_by_vars_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_types_used_by_vars_entry(n, z) ((struct types_used_by_vars_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct types_used_by_vars_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_types_used_by_vars_entry(n, z) ((struct types_used_by_vars_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct types_used_by_vars_entry), n MEM_STAT_INFO))) +#define ggc_alloc_language_function() ((struct language_function *)(ggc_internal_alloc_stat (sizeof (struct language_function) MEM_STAT_INFO))) +#define ggc_alloc_cleared_language_function() ((struct language_function *)(ggc_internal_cleared_alloc_stat (sizeof (struct language_function) MEM_STAT_INFO))) +#define ggc_alloc_vec_language_function(n) ((struct language_function *)(ggc_internal_vec_alloc_stat (sizeof (struct language_function), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_language_function(n) ((struct language_function *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct language_function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_language_function(z) ((struct language_function *)(ggc_internal_zone_alloc_stat (z, sizeof (struct language_function) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_language_function(z) ((struct language_function *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct language_function) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_language_function(n, z) ((struct language_function *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct language_function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_language_function(n, z) ((struct language_function *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct language_function), n MEM_STAT_INFO))) +#define ggc_alloc_loops() ((struct loops *)(ggc_internal_alloc_stat (sizeof (struct loops) MEM_STAT_INFO))) +#define ggc_alloc_cleared_loops() ((struct loops *)(ggc_internal_cleared_alloc_stat (sizeof (struct loops) MEM_STAT_INFO))) +#define ggc_alloc_vec_loops(n) ((struct loops *)(ggc_internal_vec_alloc_stat (sizeof (struct loops), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_loops(n) ((struct loops *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct loops), n MEM_STAT_INFO))) +#define ggc_alloc_zone_loops(z) ((struct loops *)(ggc_internal_zone_alloc_stat (z, sizeof (struct loops) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_loops(z) ((struct loops *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct loops) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_loops(n, z) ((struct loops *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct loops), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_loops(n, z) ((struct loops *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct loops), n MEM_STAT_INFO))) +#define ggc_alloc_control_flow_graph() ((struct control_flow_graph *)(ggc_internal_alloc_stat (sizeof (struct control_flow_graph) MEM_STAT_INFO))) +#define ggc_alloc_cleared_control_flow_graph() ((struct control_flow_graph *)(ggc_internal_cleared_alloc_stat (sizeof (struct control_flow_graph) MEM_STAT_INFO))) +#define ggc_alloc_vec_control_flow_graph(n) ((struct control_flow_graph *)(ggc_internal_vec_alloc_stat (sizeof (struct control_flow_graph), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_control_flow_graph(n) ((struct control_flow_graph *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct control_flow_graph), n MEM_STAT_INFO))) +#define ggc_alloc_zone_control_flow_graph(z) ((struct control_flow_graph *)(ggc_internal_zone_alloc_stat (z, sizeof (struct control_flow_graph) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_control_flow_graph(z) ((struct control_flow_graph *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct control_flow_graph) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_control_flow_graph(n, z) ((struct control_flow_graph *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct control_flow_graph), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_control_flow_graph(n, z) ((struct control_flow_graph *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct control_flow_graph), n MEM_STAT_INFO))) +#define ggc_alloc_eh_status() ((struct eh_status *)(ggc_internal_alloc_stat (sizeof (struct eh_status) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_status() ((struct eh_status *)(ggc_internal_cleared_alloc_stat (sizeof (struct eh_status) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_status(n) ((struct eh_status *)(ggc_internal_vec_alloc_stat (sizeof (struct eh_status), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_status(n) ((struct eh_status *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct eh_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_status(z) ((struct eh_status *)(ggc_internal_zone_alloc_stat (z, sizeof (struct eh_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_status(z) ((struct eh_status *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct eh_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_eh_status(n, z) ((struct eh_status *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct eh_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_status(n, z) ((struct eh_status *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct eh_status), n MEM_STAT_INFO))) +#define ggc_alloc_stack_usage() ((struct stack_usage *)(ggc_internal_alloc_stat (sizeof (struct stack_usage) MEM_STAT_INFO))) +#define ggc_alloc_cleared_stack_usage() ((struct stack_usage *)(ggc_internal_cleared_alloc_stat (sizeof (struct stack_usage) MEM_STAT_INFO))) +#define ggc_alloc_vec_stack_usage(n) ((struct stack_usage *)(ggc_internal_vec_alloc_stat (sizeof (struct stack_usage), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_stack_usage(n) ((struct stack_usage *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct stack_usage), n MEM_STAT_INFO))) +#define ggc_alloc_zone_stack_usage(z) ((struct stack_usage *)(ggc_internal_zone_alloc_stat (z, sizeof (struct stack_usage) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_stack_usage(z) ((struct stack_usage *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct stack_usage) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_stack_usage(n, z) ((struct stack_usage *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct stack_usage), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_stack_usage(n, z) ((struct stack_usage *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct stack_usage), n MEM_STAT_INFO))) +#define ggc_alloc_rtl_data() ((struct rtl_data *)(ggc_internal_alloc_stat (sizeof (struct rtl_data) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtl_data() ((struct rtl_data *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtl_data) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtl_data(n) ((struct rtl_data *)(ggc_internal_vec_alloc_stat (sizeof (struct rtl_data), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtl_data(n) ((struct rtl_data *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtl_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtl_data(z) ((struct rtl_data *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtl_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtl_data(z) ((struct rtl_data *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtl_data) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtl_data(n, z) ((struct rtl_data *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtl_data), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtl_data(n, z) ((struct rtl_data *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtl_data), n MEM_STAT_INFO))) +#define ggc_alloc_initial_value_struct() ((struct initial_value_struct *)(ggc_internal_alloc_stat (sizeof (struct initial_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_initial_value_struct() ((struct initial_value_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct initial_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_initial_value_struct(n) ((struct initial_value_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct initial_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_initial_value_struct(n) ((struct initial_value_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct initial_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_initial_value_struct(z) ((struct initial_value_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct initial_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_initial_value_struct(z) ((struct initial_value_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct initial_value_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_initial_value_struct(n, z) ((struct initial_value_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct initial_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_initial_value_struct(n, z) ((struct initial_value_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct initial_value_struct), n MEM_STAT_INFO))) +#define ggc_alloc_frame_space() ((struct frame_space *)(ggc_internal_alloc_stat (sizeof (struct frame_space) MEM_STAT_INFO))) +#define ggc_alloc_cleared_frame_space() ((struct frame_space *)(ggc_internal_cleared_alloc_stat (sizeof (struct frame_space) MEM_STAT_INFO))) +#define ggc_alloc_vec_frame_space(n) ((struct frame_space *)(ggc_internal_vec_alloc_stat (sizeof (struct frame_space), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_frame_space(n) ((struct frame_space *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct frame_space), n MEM_STAT_INFO))) +#define ggc_alloc_zone_frame_space(z) ((struct frame_space *)(ggc_internal_zone_alloc_stat (z, sizeof (struct frame_space) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_frame_space(z) ((struct frame_space *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct frame_space) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_frame_space(n, z) ((struct frame_space *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct frame_space), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_frame_space(n, z) ((struct frame_space *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct frame_space), n MEM_STAT_INFO))) +#define ggc_alloc_function_subsections() ((struct function_subsections *)(ggc_internal_alloc_stat (sizeof (struct function_subsections) MEM_STAT_INFO))) +#define ggc_alloc_cleared_function_subsections() ((struct function_subsections *)(ggc_internal_cleared_alloc_stat (sizeof (struct function_subsections) MEM_STAT_INFO))) +#define ggc_alloc_vec_function_subsections(n) ((struct function_subsections *)(ggc_internal_vec_alloc_stat (sizeof (struct function_subsections), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_function_subsections(n) ((struct function_subsections *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct function_subsections), n MEM_STAT_INFO))) +#define ggc_alloc_zone_function_subsections(z) ((struct function_subsections *)(ggc_internal_zone_alloc_stat (z, sizeof (struct function_subsections) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_function_subsections(z) ((struct function_subsections *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct function_subsections) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_function_subsections(n, z) ((struct function_subsections *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct function_subsections), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_function_subsections(n, z) ((struct function_subsections *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct function_subsections), n MEM_STAT_INFO))) +#define ggc_alloc_incoming_args() ((struct incoming_args *)(ggc_internal_alloc_stat (sizeof (struct incoming_args) MEM_STAT_INFO))) +#define ggc_alloc_cleared_incoming_args() ((struct incoming_args *)(ggc_internal_cleared_alloc_stat (sizeof (struct incoming_args) MEM_STAT_INFO))) +#define ggc_alloc_vec_incoming_args(n) ((struct incoming_args *)(ggc_internal_vec_alloc_stat (sizeof (struct incoming_args), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_incoming_args(n) ((struct incoming_args *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct incoming_args), n MEM_STAT_INFO))) +#define ggc_alloc_zone_incoming_args(z) ((struct incoming_args *)(ggc_internal_zone_alloc_stat (z, sizeof (struct incoming_args) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_incoming_args(z) ((struct incoming_args *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct incoming_args) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_incoming_args(n, z) ((struct incoming_args *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct incoming_args), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_incoming_args(n, z) ((struct incoming_args *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct incoming_args), n MEM_STAT_INFO))) +#define ggc_alloc_varasm_status() ((struct varasm_status *)(ggc_internal_alloc_stat (sizeof (struct varasm_status) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varasm_status() ((struct varasm_status *)(ggc_internal_cleared_alloc_stat (sizeof (struct varasm_status) MEM_STAT_INFO))) +#define ggc_alloc_vec_varasm_status(n) ((struct varasm_status *)(ggc_internal_vec_alloc_stat (sizeof (struct varasm_status), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varasm_status(n) ((struct varasm_status *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct varasm_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varasm_status(z) ((struct varasm_status *)(ggc_internal_zone_alloc_stat (z, sizeof (struct varasm_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varasm_status(z) ((struct varasm_status *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct varasm_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_varasm_status(n, z) ((struct varasm_status *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct varasm_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varasm_status(n, z) ((struct varasm_status *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct varasm_status), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_constant_pool() ((struct rtx_constant_pool *)(ggc_internal_alloc_stat (sizeof (struct rtx_constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_constant_pool() ((struct rtx_constant_pool *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_constant_pool(n) ((struct rtx_constant_pool *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_constant_pool(n) ((struct rtx_constant_pool *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_constant_pool(z) ((struct rtx_constant_pool *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_constant_pool(z) ((struct rtx_constant_pool *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_constant_pool(n, z) ((struct rtx_constant_pool *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_constant_pool(n, z) ((struct rtx_constant_pool *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_temp_slot_p_gc() ((struct VEC_temp_slot_p_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_temp_slot_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_temp_slot_p_gc() ((struct VEC_temp_slot_p_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_temp_slot_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_temp_slot_p_gc(n) ((struct VEC_temp_slot_p_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_temp_slot_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_temp_slot_p_gc(n) ((struct VEC_temp_slot_p_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_temp_slot_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_temp_slot_p_gc(z) ((struct VEC_temp_slot_p_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_temp_slot_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_temp_slot_p_gc(z) ((struct VEC_temp_slot_p_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_temp_slot_p_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_temp_slot_p_gc(n, z) ((struct VEC_temp_slot_p_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_temp_slot_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_temp_slot_p_gc(n, z) ((struct VEC_temp_slot_p_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_temp_slot_p_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_temp_slot_p_base() ((struct VEC_temp_slot_p_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_temp_slot_p_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_temp_slot_p_base() ((struct VEC_temp_slot_p_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_temp_slot_p_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_temp_slot_p_base(n) ((struct VEC_temp_slot_p_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_temp_slot_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_temp_slot_p_base(n) ((struct VEC_temp_slot_p_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_temp_slot_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_temp_slot_p_base(z) ((struct VEC_temp_slot_p_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_temp_slot_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_temp_slot_p_base(z) ((struct VEC_temp_slot_p_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_temp_slot_p_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_temp_slot_p_base(n, z) ((struct VEC_temp_slot_p_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_temp_slot_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_temp_slot_p_base(n, z) ((struct VEC_temp_slot_p_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_temp_slot_p_base), n MEM_STAT_INFO))) +#define ggc_alloc_temp_slot() ((struct temp_slot *)(ggc_internal_alloc_stat (sizeof (struct temp_slot) MEM_STAT_INFO))) +#define ggc_alloc_cleared_temp_slot() ((struct temp_slot *)(ggc_internal_cleared_alloc_stat (sizeof (struct temp_slot) MEM_STAT_INFO))) +#define ggc_alloc_vec_temp_slot(n) ((struct temp_slot *)(ggc_internal_vec_alloc_stat (sizeof (struct temp_slot), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_temp_slot(n) ((struct temp_slot *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct temp_slot), n MEM_STAT_INFO))) +#define ggc_alloc_zone_temp_slot(z) ((struct temp_slot *)(ggc_internal_zone_alloc_stat (z, sizeof (struct temp_slot) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_temp_slot(z) ((struct temp_slot *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct temp_slot) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_temp_slot(n, z) ((struct temp_slot *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct temp_slot), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_temp_slot(n, z) ((struct temp_slot *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct temp_slot), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_df() ((struct gimple_df *)(ggc_internal_alloc_stat (sizeof (struct gimple_df) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_df() ((struct gimple_df *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_df) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_df(n) ((struct gimple_df *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_df), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_df(n) ((struct gimple_df *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_df), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_df(z) ((struct gimple_df *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_df) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_df(z) ((struct gimple_df *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_df) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_df(n, z) ((struct gimple_df *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_df), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_df(n, z) ((struct gimple_df *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_df), n MEM_STAT_INFO))) +#define ggc_alloc_rtl_eh() ((struct rtl_eh *)(ggc_internal_alloc_stat (sizeof (struct rtl_eh) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtl_eh() ((struct rtl_eh *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtl_eh) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtl_eh(n) ((struct rtl_eh *)(ggc_internal_vec_alloc_stat (sizeof (struct rtl_eh), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtl_eh(n) ((struct rtl_eh *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtl_eh), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtl_eh(z) ((struct rtl_eh *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtl_eh) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtl_eh(z) ((struct rtl_eh *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtl_eh) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtl_eh(n, z) ((struct rtl_eh *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtl_eh), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtl_eh(n, z) ((struct rtl_eh *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtl_eh), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_call_site_record_gc() ((struct VEC_call_site_record_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_call_site_record_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_call_site_record_gc() ((struct VEC_call_site_record_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_call_site_record_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_call_site_record_gc(n) ((struct VEC_call_site_record_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_call_site_record_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_call_site_record_gc(n) ((struct VEC_call_site_record_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_call_site_record_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_call_site_record_gc(z) ((struct VEC_call_site_record_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_call_site_record_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_call_site_record_gc(z) ((struct VEC_call_site_record_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_call_site_record_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_call_site_record_gc(n, z) ((struct VEC_call_site_record_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_call_site_record_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_call_site_record_gc(n, z) ((struct VEC_call_site_record_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_call_site_record_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_call_site_record_base() ((struct VEC_call_site_record_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_call_site_record_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_call_site_record_base() ((struct VEC_call_site_record_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_call_site_record_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_call_site_record_base(n) ((struct VEC_call_site_record_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_call_site_record_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_call_site_record_base(n) ((struct VEC_call_site_record_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_call_site_record_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_call_site_record_base(z) ((struct VEC_call_site_record_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_call_site_record_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_call_site_record_base(z) ((struct VEC_call_site_record_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_call_site_record_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_call_site_record_base(n, z) ((struct VEC_call_site_record_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_call_site_record_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_call_site_record_base(n, z) ((struct VEC_call_site_record_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_call_site_record_base), n MEM_STAT_INFO))) +#define ggc_alloc_call_site_record_d() ((struct call_site_record_d *)(ggc_internal_alloc_stat (sizeof (struct call_site_record_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_call_site_record_d() ((struct call_site_record_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct call_site_record_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_call_site_record_d(n) ((struct call_site_record_d *)(ggc_internal_vec_alloc_stat (sizeof (struct call_site_record_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_call_site_record_d(n) ((struct call_site_record_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct call_site_record_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_call_site_record_d(z) ((struct call_site_record_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct call_site_record_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_call_site_record_d(z) ((struct call_site_record_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct call_site_record_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_call_site_record_d(n, z) ((struct call_site_record_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct call_site_record_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_call_site_record_d(n, z) ((struct call_site_record_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct call_site_record_d), n MEM_STAT_INFO))) +#define ggc_alloc_expr_status() ((struct expr_status *)(ggc_internal_alloc_stat (sizeof (struct expr_status) MEM_STAT_INFO))) +#define ggc_alloc_cleared_expr_status() ((struct expr_status *)(ggc_internal_cleared_alloc_stat (sizeof (struct expr_status) MEM_STAT_INFO))) +#define ggc_alloc_vec_expr_status(n) ((struct expr_status *)(ggc_internal_vec_alloc_stat (sizeof (struct expr_status), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_expr_status(n) ((struct expr_status *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct expr_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_expr_status(z) ((struct expr_status *)(ggc_internal_zone_alloc_stat (z, sizeof (struct expr_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_expr_status(z) ((struct expr_status *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct expr_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_expr_status(n, z) ((struct expr_status *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct expr_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_expr_status(n, z) ((struct expr_status *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct expr_status), n MEM_STAT_INFO))) +#define ggc_alloc_emit_status() ((struct emit_status *)(ggc_internal_alloc_stat (sizeof (struct emit_status) MEM_STAT_INFO))) +#define ggc_alloc_cleared_emit_status() ((struct emit_status *)(ggc_internal_cleared_alloc_stat (sizeof (struct emit_status) MEM_STAT_INFO))) +#define ggc_alloc_vec_emit_status(n) ((struct emit_status *)(ggc_internal_vec_alloc_stat (sizeof (struct emit_status), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_emit_status(n) ((struct emit_status *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct emit_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_emit_status(z) ((struct emit_status *)(ggc_internal_zone_alloc_stat (z, sizeof (struct emit_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_emit_status(z) ((struct emit_status *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct emit_status) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_emit_status(n, z) ((struct emit_status *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct emit_status), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_emit_status(n, z) ((struct emit_status *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct emit_status), n MEM_STAT_INFO))) +#define ggc_alloc_sequence_stack() ((struct sequence_stack *)(ggc_internal_alloc_stat (sizeof (struct sequence_stack) MEM_STAT_INFO))) +#define ggc_alloc_cleared_sequence_stack() ((struct sequence_stack *)(ggc_internal_cleared_alloc_stat (sizeof (struct sequence_stack) MEM_STAT_INFO))) +#define ggc_alloc_vec_sequence_stack(n) ((struct sequence_stack *)(ggc_internal_vec_alloc_stat (sizeof (struct sequence_stack), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_sequence_stack(n) ((struct sequence_stack *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct sequence_stack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_sequence_stack(z) ((struct sequence_stack *)(ggc_internal_zone_alloc_stat (z, sizeof (struct sequence_stack) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_sequence_stack(z) ((struct sequence_stack *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct sequence_stack) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_sequence_stack(n, z) ((struct sequence_stack *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct sequence_stack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_sequence_stack(n, z) ((struct sequence_stack *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct sequence_stack), n MEM_STAT_INFO))) +#define ggc_alloc_target_libfuncs() ((struct target_libfuncs *)(ggc_internal_alloc_stat (sizeof (struct target_libfuncs) MEM_STAT_INFO))) +#define ggc_alloc_cleared_target_libfuncs() ((struct target_libfuncs *)(ggc_internal_cleared_alloc_stat (sizeof (struct target_libfuncs) MEM_STAT_INFO))) +#define ggc_alloc_vec_target_libfuncs(n) ((struct target_libfuncs *)(ggc_internal_vec_alloc_stat (sizeof (struct target_libfuncs), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_target_libfuncs(n) ((struct target_libfuncs *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct target_libfuncs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_target_libfuncs(z) ((struct target_libfuncs *)(ggc_internal_zone_alloc_stat (z, sizeof (struct target_libfuncs) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_target_libfuncs(z) ((struct target_libfuncs *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct target_libfuncs) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_target_libfuncs(n, z) ((struct target_libfuncs *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct target_libfuncs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_target_libfuncs(n, z) ((struct target_libfuncs *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct target_libfuncs), n MEM_STAT_INFO))) +#define ggc_alloc_libfunc_entry() ((struct libfunc_entry *)(ggc_internal_alloc_stat (sizeof (struct libfunc_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_libfunc_entry() ((struct libfunc_entry *)(ggc_internal_cleared_alloc_stat (sizeof (struct libfunc_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_libfunc_entry(n) ((struct libfunc_entry *)(ggc_internal_vec_alloc_stat (sizeof (struct libfunc_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_libfunc_entry(n) ((struct libfunc_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct libfunc_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_libfunc_entry(z) ((struct libfunc_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (struct libfunc_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_libfunc_entry(z) ((struct libfunc_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct libfunc_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_libfunc_entry(n, z) ((struct libfunc_entry *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct libfunc_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_libfunc_entry(n, z) ((struct libfunc_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct libfunc_entry), n MEM_STAT_INFO))) +#define ggc_alloc_tree_priority_map() ((struct tree_priority_map *)(ggc_internal_alloc_stat (sizeof (struct tree_priority_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_priority_map() ((struct tree_priority_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_priority_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_priority_map(n) ((struct tree_priority_map *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_priority_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_priority_map(n) ((struct tree_priority_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_priority_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_priority_map(z) ((struct tree_priority_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_priority_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_priority_map(z) ((struct tree_priority_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_priority_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_priority_map(n, z) ((struct tree_priority_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_priority_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_priority_map(n, z) ((struct tree_priority_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_priority_map), n MEM_STAT_INFO))) +#define ggc_alloc_tree_int_map() ((struct tree_int_map *)(ggc_internal_alloc_stat (sizeof (struct tree_int_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_int_map() ((struct tree_int_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_int_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_int_map(n) ((struct tree_int_map *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_int_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_int_map(n) ((struct tree_int_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_int_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_int_map(z) ((struct tree_int_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_int_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_int_map(z) ((struct tree_int_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_int_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_int_map(n, z) ((struct tree_int_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_int_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_int_map(n, z) ((struct tree_int_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_int_map), n MEM_STAT_INFO))) +#define ggc_alloc_tree_decl_map() ((struct tree_decl_map *)(ggc_internal_alloc_stat (sizeof (struct tree_decl_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_decl_map() ((struct tree_decl_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_decl_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_decl_map(n) ((struct tree_decl_map *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_decl_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_decl_map(n) ((struct tree_decl_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_decl_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_decl_map(z) ((struct tree_decl_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_decl_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_decl_map(z) ((struct tree_decl_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_decl_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_decl_map(n, z) ((struct tree_decl_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_decl_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_decl_map(n, z) ((struct tree_decl_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_decl_map), n MEM_STAT_INFO))) +#define ggc_alloc_tree_map() ((struct tree_map *)(ggc_internal_alloc_stat (sizeof (struct tree_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_map() ((struct tree_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_map(n) ((struct tree_map *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_map(n) ((struct tree_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_map(z) ((struct tree_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_map(z) ((struct tree_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_map(n, z) ((struct tree_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_map(n, z) ((struct tree_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_map), n MEM_STAT_INFO))) +#define ggc_alloc_tree_map_base() ((struct tree_map_base *)(ggc_internal_alloc_stat (sizeof (struct tree_map_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_map_base() ((struct tree_map_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_map_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_map_base(n) ((struct tree_map_base *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_map_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_map_base(n) ((struct tree_map_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_map_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_map_base(z) ((struct tree_map_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_map_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_map_base(z) ((struct tree_map_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_map_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_map_base(n, z) ((struct tree_map_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_map_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_map_base(n, z) ((struct tree_map_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_map_base), n MEM_STAT_INFO))) +#define ggc_alloc_lang_tree_node() ((struct lang_tree_node *)(ggc_internal_alloc_stat (sizeof (struct lang_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_tree_node() ((struct lang_tree_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct lang_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_tree_node(n) ((struct lang_tree_node *)(ggc_internal_vec_alloc_stat (sizeof (struct lang_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_tree_node(n) ((struct lang_tree_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct lang_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_tree_node(z) ((struct lang_tree_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct lang_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_tree_node(z) ((struct lang_tree_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct lang_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_tree_node(n, z) ((struct lang_tree_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct lang_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_tree_node(n, z) ((struct lang_tree_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct lang_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_tree_target_option() ((struct tree_target_option *)(ggc_internal_alloc_stat (sizeof (struct tree_target_option) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_target_option() ((struct tree_target_option *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_target_option) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_target_option(n) ((struct tree_target_option *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_target_option(n) ((struct tree_target_option *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_target_option(z) ((struct tree_target_option *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_target_option) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_target_option(z) ((struct tree_target_option *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_target_option) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_target_option(n, z) ((struct tree_target_option *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_target_option(n, z) ((struct tree_target_option *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_tree_optimization_option() ((struct tree_optimization_option *)(ggc_internal_alloc_stat (sizeof (struct tree_optimization_option) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_optimization_option() ((struct tree_optimization_option *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_optimization_option) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_optimization_option(n) ((struct tree_optimization_option *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_optimization_option), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_optimization_option(n) ((struct tree_optimization_option *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_optimization_option), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_optimization_option(z) ((struct tree_optimization_option *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_optimization_option) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_optimization_option(z) ((struct tree_optimization_option *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_optimization_option) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_optimization_option(n, z) ((struct tree_optimization_option *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_optimization_option), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_optimization_option(n, z) ((struct tree_optimization_option *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_optimization_option), n MEM_STAT_INFO))) +#define ggc_alloc_tree_statement_list() ((struct tree_statement_list *)(ggc_internal_alloc_stat (sizeof (struct tree_statement_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_statement_list() ((struct tree_statement_list *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_statement_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_statement_list(n) ((struct tree_statement_list *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_statement_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_statement_list(n) ((struct tree_statement_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_statement_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_statement_list(z) ((struct tree_statement_list *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_statement_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_statement_list(z) ((struct tree_statement_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_statement_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_statement_list(n, z) ((struct tree_statement_list *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_statement_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_statement_list(n, z) ((struct tree_statement_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_statement_list), n MEM_STAT_INFO))) +#define ggc_alloc_tree_statement_list_node() ((struct tree_statement_list_node *)(ggc_internal_alloc_stat (sizeof (struct tree_statement_list_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_statement_list_node() ((struct tree_statement_list_node *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_statement_list_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_statement_list_node(n) ((struct tree_statement_list_node *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_statement_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_statement_list_node(n) ((struct tree_statement_list_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_statement_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_statement_list_node(z) ((struct tree_statement_list_node *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_statement_list_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_statement_list_node(z) ((struct tree_statement_list_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_statement_list_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_statement_list_node(n, z) ((struct tree_statement_list_node *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_statement_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_statement_list_node(n, z) ((struct tree_statement_list_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_statement_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_tree_type_decl() ((struct tree_type_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_type_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_type_decl() ((struct tree_type_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_type_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_type_decl(n) ((struct tree_type_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_type_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_type_decl(n) ((struct tree_type_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_type_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_type_decl(z) ((struct tree_type_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_type_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_type_decl(z) ((struct tree_type_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_type_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_type_decl(n, z) ((struct tree_type_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_type_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_type_decl(n, z) ((struct tree_type_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_type_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_translation_unit_decl() ((struct tree_translation_unit_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_translation_unit_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_translation_unit_decl() ((struct tree_translation_unit_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_translation_unit_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_translation_unit_decl(n) ((struct tree_translation_unit_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_translation_unit_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_translation_unit_decl(n) ((struct tree_translation_unit_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_translation_unit_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_translation_unit_decl(z) ((struct tree_translation_unit_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_translation_unit_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_translation_unit_decl(z) ((struct tree_translation_unit_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_translation_unit_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_translation_unit_decl(n, z) ((struct tree_translation_unit_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_translation_unit_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_translation_unit_decl(n, z) ((struct tree_translation_unit_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_translation_unit_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_function_decl() ((struct tree_function_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_function_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_function_decl() ((struct tree_function_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_function_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_function_decl(n) ((struct tree_function_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_function_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_function_decl(n) ((struct tree_function_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_function_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_function_decl(z) ((struct tree_function_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_function_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_function_decl(z) ((struct tree_function_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_function_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_function_decl(n, z) ((struct tree_function_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_function_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_function_decl(n, z) ((struct tree_function_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_function_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_decl_non_common() ((struct tree_decl_non_common *)(ggc_internal_alloc_stat (sizeof (struct tree_decl_non_common) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_decl_non_common() ((struct tree_decl_non_common *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_decl_non_common) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_decl_non_common(n) ((struct tree_decl_non_common *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_decl_non_common), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_decl_non_common(n) ((struct tree_decl_non_common *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_decl_non_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_decl_non_common(z) ((struct tree_decl_non_common *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_decl_non_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_decl_non_common(z) ((struct tree_decl_non_common *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_decl_non_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_decl_non_common(n, z) ((struct tree_decl_non_common *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_decl_non_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_decl_non_common(n, z) ((struct tree_decl_non_common *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_decl_non_common), n MEM_STAT_INFO))) +#define ggc_alloc_tree_var_decl() ((struct tree_var_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_var_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_var_decl() ((struct tree_var_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_var_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_var_decl(n) ((struct tree_var_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_var_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_var_decl(n) ((struct tree_var_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_var_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_var_decl(z) ((struct tree_var_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_var_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_var_decl(z) ((struct tree_var_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_var_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_var_decl(n, z) ((struct tree_var_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_var_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_var_decl(n, z) ((struct tree_var_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_var_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_decl_with_vis() ((struct tree_decl_with_vis *)(ggc_internal_alloc_stat (sizeof (struct tree_decl_with_vis) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_decl_with_vis() ((struct tree_decl_with_vis *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_decl_with_vis) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_decl_with_vis(n) ((struct tree_decl_with_vis *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_decl_with_vis), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_decl_with_vis(n) ((struct tree_decl_with_vis *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_decl_with_vis), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_decl_with_vis(z) ((struct tree_decl_with_vis *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_decl_with_vis) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_decl_with_vis(z) ((struct tree_decl_with_vis *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_decl_with_vis) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_decl_with_vis(n, z) ((struct tree_decl_with_vis *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_decl_with_vis), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_decl_with_vis(n, z) ((struct tree_decl_with_vis *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_decl_with_vis), n MEM_STAT_INFO))) +#define ggc_alloc_tree_parm_decl() ((struct tree_parm_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_parm_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_parm_decl() ((struct tree_parm_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_parm_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_parm_decl(n) ((struct tree_parm_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_parm_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_parm_decl(n) ((struct tree_parm_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_parm_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_parm_decl(z) ((struct tree_parm_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_parm_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_parm_decl(z) ((struct tree_parm_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_parm_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_parm_decl(n, z) ((struct tree_parm_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_parm_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_parm_decl(n, z) ((struct tree_parm_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_parm_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_const_decl() ((struct tree_const_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_const_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_const_decl() ((struct tree_const_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_const_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_const_decl(n) ((struct tree_const_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_const_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_const_decl(n) ((struct tree_const_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_const_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_const_decl(z) ((struct tree_const_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_const_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_const_decl(z) ((struct tree_const_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_const_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_const_decl(n, z) ((struct tree_const_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_const_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_const_decl(n, z) ((struct tree_const_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_const_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_result_decl() ((struct tree_result_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_result_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_result_decl() ((struct tree_result_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_result_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_result_decl(n) ((struct tree_result_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_result_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_result_decl(n) ((struct tree_result_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_result_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_result_decl(z) ((struct tree_result_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_result_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_result_decl(z) ((struct tree_result_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_result_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_result_decl(n, z) ((struct tree_result_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_result_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_result_decl(n, z) ((struct tree_result_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_result_decl), n MEM_STAT_INFO))) +#define ggc_alloc_var_ann_d() ((struct var_ann_d *)(ggc_internal_alloc_stat (sizeof (struct var_ann_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_var_ann_d() ((struct var_ann_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct var_ann_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_var_ann_d(n) ((struct var_ann_d *)(ggc_internal_vec_alloc_stat (sizeof (struct var_ann_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_var_ann_d(n) ((struct var_ann_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct var_ann_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_var_ann_d(z) ((struct var_ann_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct var_ann_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_var_ann_d(z) ((struct var_ann_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct var_ann_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_var_ann_d(n, z) ((struct var_ann_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct var_ann_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_var_ann_d(n, z) ((struct var_ann_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct var_ann_d), n MEM_STAT_INFO))) +#define ggc_alloc_tree_label_decl() ((struct tree_label_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_label_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_label_decl() ((struct tree_label_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_label_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_label_decl(n) ((struct tree_label_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_label_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_label_decl(n) ((struct tree_label_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_label_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_label_decl(z) ((struct tree_label_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_label_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_label_decl(z) ((struct tree_label_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_label_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_label_decl(n, z) ((struct tree_label_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_label_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_label_decl(n, z) ((struct tree_label_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_label_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_field_decl() ((struct tree_field_decl *)(ggc_internal_alloc_stat (sizeof (struct tree_field_decl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_field_decl() ((struct tree_field_decl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_field_decl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_field_decl(n) ((struct tree_field_decl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_field_decl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_field_decl(n) ((struct tree_field_decl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_field_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_field_decl(z) ((struct tree_field_decl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_field_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_field_decl(z) ((struct tree_field_decl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_field_decl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_field_decl(n, z) ((struct tree_field_decl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_field_decl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_field_decl(n, z) ((struct tree_field_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_field_decl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_decl_with_rtl() ((struct tree_decl_with_rtl *)(ggc_internal_alloc_stat (sizeof (struct tree_decl_with_rtl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_decl_with_rtl() ((struct tree_decl_with_rtl *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_decl_with_rtl) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_decl_with_rtl(n) ((struct tree_decl_with_rtl *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_decl_with_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_decl_with_rtl(n) ((struct tree_decl_with_rtl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_decl_with_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_decl_with_rtl(z) ((struct tree_decl_with_rtl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_decl_with_rtl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_decl_with_rtl(z) ((struct tree_decl_with_rtl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_decl_with_rtl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_decl_with_rtl(n, z) ((struct tree_decl_with_rtl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_decl_with_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_decl_with_rtl(n, z) ((struct tree_decl_with_rtl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_decl_with_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_tree_decl_common() ((struct tree_decl_common *)(ggc_internal_alloc_stat (sizeof (struct tree_decl_common) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_decl_common() ((struct tree_decl_common *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_decl_common) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_decl_common(n) ((struct tree_decl_common *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_decl_common), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_decl_common(n) ((struct tree_decl_common *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_decl_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_decl_common(z) ((struct tree_decl_common *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_decl_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_decl_common(z) ((struct tree_decl_common *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_decl_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_decl_common(n, z) ((struct tree_decl_common *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_decl_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_decl_common(n, z) ((struct tree_decl_common *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_decl_common), n MEM_STAT_INFO))) +#define ggc_alloc_lang_decl(SIZE) ((struct lang_decl *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_decl(SIZE) ((struct lang_decl *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_decl(SIZE, n) ((struct lang_decl *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_decl(SIZE, n) ((struct lang_decl *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_decl(SIZE, z) ((struct lang_decl *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_decl(SIZE, z) ((struct lang_decl *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_decl(SIZE, n, z) ((struct lang_decl *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_decl(SIZE, n, z) ((struct lang_decl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_tree_decl_minimal() ((struct tree_decl_minimal *)(ggc_internal_alloc_stat (sizeof (struct tree_decl_minimal) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_decl_minimal() ((struct tree_decl_minimal *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_decl_minimal) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_decl_minimal(n) ((struct tree_decl_minimal *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_decl_minimal), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_decl_minimal(n) ((struct tree_decl_minimal *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_decl_minimal), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_decl_minimal(z) ((struct tree_decl_minimal *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_decl_minimal) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_decl_minimal(z) ((struct tree_decl_minimal *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_decl_minimal) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_decl_minimal(n, z) ((struct tree_decl_minimal *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_decl_minimal), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_decl_minimal(n, z) ((struct tree_decl_minimal *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_decl_minimal), n MEM_STAT_INFO))) +#define ggc_alloc_tree_binfo() ((struct tree_binfo *)(ggc_internal_alloc_stat (sizeof (struct tree_binfo) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_binfo() ((struct tree_binfo *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_binfo) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_binfo(n) ((struct tree_binfo *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_binfo), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_binfo(n) ((struct tree_binfo *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_binfo), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_binfo(z) ((struct tree_binfo *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_binfo) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_binfo(z) ((struct tree_binfo *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_binfo) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_binfo(n, z) ((struct tree_binfo *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_binfo), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_binfo(n, z) ((struct tree_binfo *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_binfo), n MEM_STAT_INFO))) +#define ggc_alloc_tree_type() ((struct tree_type *)(ggc_internal_alloc_stat (sizeof (struct tree_type) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_type() ((struct tree_type *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_type) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_type(n) ((struct tree_type *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_type), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_type(n) ((struct tree_type *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_type), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_type(z) ((struct tree_type *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_type) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_type(z) ((struct tree_type *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_type) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_type(n, z) ((struct tree_type *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_type), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_type(n, z) ((struct tree_type *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_type), n MEM_STAT_INFO))) +#define ggc_alloc_lang_type(SIZE) ((struct lang_type *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_lang_type(SIZE) ((struct lang_type *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_lang_type(SIZE, n) ((struct lang_type *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lang_type(SIZE, n) ((struct lang_type *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_lang_type(SIZE, z) ((struct lang_type *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lang_type(SIZE, z) ((struct lang_type *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_lang_type(SIZE, n, z) ((struct lang_type *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lang_type(SIZE, n, z) ((struct lang_type *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_tree_type_symtab() ((union tree_type_symtab *)(ggc_internal_alloc_stat (sizeof (union tree_type_symtab) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_type_symtab() ((union tree_type_symtab *)(ggc_internal_cleared_alloc_stat (sizeof (union tree_type_symtab) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_type_symtab(n) ((union tree_type_symtab *)(ggc_internal_vec_alloc_stat (sizeof (union tree_type_symtab), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_type_symtab(n) ((union tree_type_symtab *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union tree_type_symtab), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_type_symtab(z) ((union tree_type_symtab *)(ggc_internal_zone_alloc_stat (z, sizeof (union tree_type_symtab) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_type_symtab(z) ((union tree_type_symtab *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union tree_type_symtab) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_type_symtab(n, z) ((union tree_type_symtab *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union tree_type_symtab), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_type_symtab(n, z) ((union tree_type_symtab *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union tree_type_symtab), n MEM_STAT_INFO))) +#define ggc_alloc_die_struct() ((struct die_struct *)(ggc_internal_alloc_stat (sizeof (struct die_struct) MEM_STAT_INFO))) +#define ggc_alloc_cleared_die_struct() ((struct die_struct *)(ggc_internal_cleared_alloc_stat (sizeof (struct die_struct) MEM_STAT_INFO))) +#define ggc_alloc_vec_die_struct(n) ((struct die_struct *)(ggc_internal_vec_alloc_stat (sizeof (struct die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_die_struct(n) ((struct die_struct *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_die_struct(z) ((struct die_struct *)(ggc_internal_zone_alloc_stat (z, sizeof (struct die_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_die_struct(z) ((struct die_struct *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct die_struct) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_die_struct(n, z) ((struct die_struct *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_die_struct(n, z) ((struct die_struct *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct die_struct), n MEM_STAT_INFO))) +#define ggc_alloc_tree_block() ((struct tree_block *)(ggc_internal_alloc_stat (sizeof (struct tree_block) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_block() ((struct tree_block *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_block) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_block(n) ((struct tree_block *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_block), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_block(n) ((struct tree_block *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_block), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_block(z) ((struct tree_block *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_block(z) ((struct tree_block *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_block(n, z) ((struct tree_block *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_block), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_block(n, z) ((struct tree_block *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_block), n MEM_STAT_INFO))) +#define ggc_alloc_tree_omp_clause() ((struct tree_omp_clause *)(ggc_internal_alloc_stat (sizeof (struct tree_omp_clause) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_omp_clause() ((struct tree_omp_clause *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_omp_clause) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_omp_clause(n) ((struct tree_omp_clause *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_omp_clause), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_omp_clause(n) ((struct tree_omp_clause *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_omp_clause), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_omp_clause(z) ((struct tree_omp_clause *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_omp_clause) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_omp_clause(z) ((struct tree_omp_clause *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_omp_clause) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_omp_clause(n, z) ((struct tree_omp_clause *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_omp_clause), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_omp_clause(n, z) ((struct tree_omp_clause *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_omp_clause), n MEM_STAT_INFO))) +#define ggc_alloc_phi_arg_d() ((struct phi_arg_d *)(ggc_internal_alloc_stat (sizeof (struct phi_arg_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_phi_arg_d() ((struct phi_arg_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct phi_arg_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_phi_arg_d(n) ((struct phi_arg_d *)(ggc_internal_vec_alloc_stat (sizeof (struct phi_arg_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_phi_arg_d(n) ((struct phi_arg_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct phi_arg_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_phi_arg_d(z) ((struct phi_arg_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct phi_arg_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_phi_arg_d(z) ((struct phi_arg_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct phi_arg_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_phi_arg_d(n, z) ((struct phi_arg_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct phi_arg_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_phi_arg_d(n, z) ((struct phi_arg_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct phi_arg_d), n MEM_STAT_INFO))) +#define ggc_alloc_tree_ssa_name() ((struct tree_ssa_name *)(ggc_internal_alloc_stat (sizeof (struct tree_ssa_name) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_ssa_name() ((struct tree_ssa_name *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_ssa_name) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_ssa_name(n) ((struct tree_ssa_name *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_ssa_name), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_ssa_name(n) ((struct tree_ssa_name *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_ssa_name), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_ssa_name(z) ((struct tree_ssa_name *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_ssa_name) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_ssa_name(z) ((struct tree_ssa_name *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_ssa_name) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_ssa_name(n, z) ((struct tree_ssa_name *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_ssa_name), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_ssa_name(n, z) ((struct tree_ssa_name *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_ssa_name), n MEM_STAT_INFO))) +#define ggc_alloc_ssa_use_operand_d() ((struct ssa_use_operand_d *)(ggc_internal_alloc_stat (sizeof (struct ssa_use_operand_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ssa_use_operand_d() ((struct ssa_use_operand_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct ssa_use_operand_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_ssa_use_operand_d(n) ((struct ssa_use_operand_d *)(ggc_internal_vec_alloc_stat (sizeof (struct ssa_use_operand_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ssa_use_operand_d(n) ((struct ssa_use_operand_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ssa_use_operand_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ssa_use_operand_d(z) ((struct ssa_use_operand_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ssa_use_operand_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ssa_use_operand_d(z) ((struct ssa_use_operand_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ssa_use_operand_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ssa_use_operand_d(n, z) ((struct ssa_use_operand_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ssa_use_operand_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ssa_use_operand_d(n, z) ((struct ssa_use_operand_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ssa_use_operand_d), n MEM_STAT_INFO))) +#define ggc_alloc_ptr_info_def() ((struct ptr_info_def *)(ggc_internal_alloc_stat (sizeof (struct ptr_info_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ptr_info_def() ((struct ptr_info_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct ptr_info_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_ptr_info_def(n) ((struct ptr_info_def *)(ggc_internal_vec_alloc_stat (sizeof (struct ptr_info_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ptr_info_def(n) ((struct ptr_info_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ptr_info_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ptr_info_def(z) ((struct ptr_info_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ptr_info_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ptr_info_def(z) ((struct ptr_info_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ptr_info_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ptr_info_def(n, z) ((struct ptr_info_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ptr_info_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ptr_info_def(n, z) ((struct ptr_info_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ptr_info_def), n MEM_STAT_INFO))) +#define ggc_alloc_tree_exp() ((struct tree_exp *)(ggc_internal_alloc_stat (sizeof (struct tree_exp) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_exp() ((struct tree_exp *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_exp) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_exp(n) ((struct tree_exp *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_exp), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_exp(n) ((struct tree_exp *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_exp), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_exp(z) ((struct tree_exp *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_exp) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_exp(z) ((struct tree_exp *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_exp) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_exp(n, z) ((struct tree_exp *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_exp), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_exp(n, z) ((struct tree_exp *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_exp), n MEM_STAT_INFO))) +#define ggc_alloc_tree_exp_subunion() ((union tree_exp_subunion *)(ggc_internal_alloc_stat (sizeof (union tree_exp_subunion) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_exp_subunion() ((union tree_exp_subunion *)(ggc_internal_cleared_alloc_stat (sizeof (union tree_exp_subunion) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_exp_subunion(n) ((union tree_exp_subunion *)(ggc_internal_vec_alloc_stat (sizeof (union tree_exp_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_exp_subunion(n) ((union tree_exp_subunion *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union tree_exp_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_exp_subunion(z) ((union tree_exp_subunion *)(ggc_internal_zone_alloc_stat (z, sizeof (union tree_exp_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_exp_subunion(z) ((union tree_exp_subunion *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union tree_exp_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_exp_subunion(n, z) ((union tree_exp_subunion *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union tree_exp_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_exp_subunion(n, z) ((union tree_exp_subunion *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union tree_exp_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_tree_constructor() ((struct tree_constructor *)(ggc_internal_alloc_stat (sizeof (struct tree_constructor) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_constructor() ((struct tree_constructor *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_constructor) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_constructor(n) ((struct tree_constructor *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_constructor), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_constructor(n) ((struct tree_constructor *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_constructor), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_constructor(z) ((struct tree_constructor *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_constructor) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_constructor(z) ((struct tree_constructor *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_constructor) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_constructor(n, z) ((struct tree_constructor *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_constructor), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_constructor(n, z) ((struct tree_constructor *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_constructor), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_constructor_elt_gc() ((struct VEC_constructor_elt_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_constructor_elt_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_constructor_elt_gc() ((struct VEC_constructor_elt_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_constructor_elt_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_constructor_elt_gc(n) ((struct VEC_constructor_elt_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_constructor_elt_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_constructor_elt_gc(n) ((struct VEC_constructor_elt_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_constructor_elt_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_constructor_elt_gc(z) ((struct VEC_constructor_elt_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_constructor_elt_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_constructor_elt_gc(z) ((struct VEC_constructor_elt_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_constructor_elt_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_constructor_elt_gc(n, z) ((struct VEC_constructor_elt_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_constructor_elt_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_constructor_elt_gc(n, z) ((struct VEC_constructor_elt_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_constructor_elt_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_constructor_elt_base() ((struct VEC_constructor_elt_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_constructor_elt_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_constructor_elt_base() ((struct VEC_constructor_elt_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_constructor_elt_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_constructor_elt_base(n) ((struct VEC_constructor_elt_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_constructor_elt_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_constructor_elt_base(n) ((struct VEC_constructor_elt_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_constructor_elt_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_constructor_elt_base(z) ((struct VEC_constructor_elt_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_constructor_elt_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_constructor_elt_base(z) ((struct VEC_constructor_elt_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_constructor_elt_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_constructor_elt_base(n, z) ((struct VEC_constructor_elt_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_constructor_elt_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_constructor_elt_base(n, z) ((struct VEC_constructor_elt_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_constructor_elt_base), n MEM_STAT_INFO))) +#define ggc_alloc_constructor_elt_d() ((struct constructor_elt_d *)(ggc_internal_alloc_stat (sizeof (struct constructor_elt_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constructor_elt_d() ((struct constructor_elt_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct constructor_elt_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_constructor_elt_d(n) ((struct constructor_elt_d *)(ggc_internal_vec_alloc_stat (sizeof (struct constructor_elt_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constructor_elt_d(n) ((struct constructor_elt_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct constructor_elt_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constructor_elt_d(z) ((struct constructor_elt_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct constructor_elt_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constructor_elt_d(z) ((struct constructor_elt_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct constructor_elt_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_constructor_elt_d(n, z) ((struct constructor_elt_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct constructor_elt_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constructor_elt_d(n, z) ((struct constructor_elt_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct constructor_elt_d), n MEM_STAT_INFO))) +#define ggc_alloc_tree_vec() ((struct tree_vec *)(ggc_internal_alloc_stat (sizeof (struct tree_vec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_vec() ((struct tree_vec *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_vec) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_vec(n) ((struct tree_vec *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_vec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_vec(n) ((struct tree_vec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_vec(z) ((struct tree_vec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_vec(z) ((struct tree_vec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_vec(n, z) ((struct tree_vec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_vec(n, z) ((struct tree_vec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_vec), n MEM_STAT_INFO))) +#define ggc_alloc_tree_list() ((struct tree_list *)(ggc_internal_alloc_stat (sizeof (struct tree_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_list() ((struct tree_list *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_list(n) ((struct tree_list *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_list(n) ((struct tree_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_list(z) ((struct tree_list *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_list(z) ((struct tree_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_list(n, z) ((struct tree_list *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_list(n, z) ((struct tree_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_list), n MEM_STAT_INFO))) +#define ggc_alloc_tree_identifier() ((struct tree_identifier *)(ggc_internal_alloc_stat (sizeof (struct tree_identifier) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_identifier() ((struct tree_identifier *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_identifier) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_identifier(n) ((struct tree_identifier *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_identifier(n) ((struct tree_identifier *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_identifier(z) ((struct tree_identifier *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_identifier(z) ((struct tree_identifier *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_identifier(n, z) ((struct tree_identifier *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_identifier(n, z) ((struct tree_identifier *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_tree_vector() ((struct tree_vector *)(ggc_internal_alloc_stat (sizeof (struct tree_vector) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_vector() ((struct tree_vector *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_vector) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_vector(n) ((struct tree_vector *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_vector), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_vector(n) ((struct tree_vector *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_vector), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_vector(z) ((struct tree_vector *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_vector) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_vector(z) ((struct tree_vector *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_vector) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_vector(n, z) ((struct tree_vector *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_vector), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_vector(n, z) ((struct tree_vector *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_vector), n MEM_STAT_INFO))) +#define ggc_alloc_tree_complex() ((struct tree_complex *)(ggc_internal_alloc_stat (sizeof (struct tree_complex) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_complex() ((struct tree_complex *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_complex) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_complex(n) ((struct tree_complex *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_complex), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_complex(n) ((struct tree_complex *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_complex), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_complex(z) ((struct tree_complex *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_complex) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_complex(z) ((struct tree_complex *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_complex) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_complex(n, z) ((struct tree_complex *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_complex), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_complex(n, z) ((struct tree_complex *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_complex), n MEM_STAT_INFO))) +#define ggc_alloc_tree_string() ((struct tree_string *)(ggc_internal_alloc_stat (sizeof (struct tree_string) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_string() ((struct tree_string *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_string) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_string(n) ((struct tree_string *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_string), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_string(n) ((struct tree_string *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_string), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_string(z) ((struct tree_string *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_string) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_string(z) ((struct tree_string *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_string) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_string(n, z) ((struct tree_string *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_string), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_string(n, z) ((struct tree_string *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_string), n MEM_STAT_INFO))) +#define ggc_alloc_tree_fixed_cst() ((struct tree_fixed_cst *)(ggc_internal_alloc_stat (sizeof (struct tree_fixed_cst) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_fixed_cst() ((struct tree_fixed_cst *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_fixed_cst) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_fixed_cst(n) ((struct tree_fixed_cst *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_fixed_cst), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_fixed_cst(n) ((struct tree_fixed_cst *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_fixed_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_fixed_cst(z) ((struct tree_fixed_cst *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_fixed_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_fixed_cst(z) ((struct tree_fixed_cst *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_fixed_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_fixed_cst(n, z) ((struct tree_fixed_cst *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_fixed_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_fixed_cst(n, z) ((struct tree_fixed_cst *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_fixed_cst), n MEM_STAT_INFO))) +#define ggc_alloc_tree_real_cst() ((struct tree_real_cst *)(ggc_internal_alloc_stat (sizeof (struct tree_real_cst) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_real_cst() ((struct tree_real_cst *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_real_cst) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_real_cst(n) ((struct tree_real_cst *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_real_cst), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_real_cst(n) ((struct tree_real_cst *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_real_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_real_cst(z) ((struct tree_real_cst *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_real_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_real_cst(z) ((struct tree_real_cst *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_real_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_real_cst(n, z) ((struct tree_real_cst *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_real_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_real_cst(n, z) ((struct tree_real_cst *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_real_cst), n MEM_STAT_INFO))) +#define ggc_alloc_tree_int_cst() ((struct tree_int_cst *)(ggc_internal_alloc_stat (sizeof (struct tree_int_cst) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_int_cst() ((struct tree_int_cst *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_int_cst) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_int_cst(n) ((struct tree_int_cst *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_int_cst), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_int_cst(n) ((struct tree_int_cst *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_int_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_int_cst(z) ((struct tree_int_cst *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_int_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_int_cst(z) ((struct tree_int_cst *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_int_cst) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_int_cst(n, z) ((struct tree_int_cst *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_int_cst), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_int_cst(n, z) ((struct tree_int_cst *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_int_cst), n MEM_STAT_INFO))) +#define ggc_alloc_tree_common() ((struct tree_common *)(ggc_internal_alloc_stat (sizeof (struct tree_common) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_common() ((struct tree_common *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_common) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_common(n) ((struct tree_common *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_common), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_common(n) ((struct tree_common *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_common(z) ((struct tree_common *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_common(z) ((struct tree_common *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_common) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_common(n, z) ((struct tree_common *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_common), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_common(n, z) ((struct tree_common *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_common), n MEM_STAT_INFO))) +#define ggc_alloc_tree_base() ((struct tree_base *)(ggc_internal_alloc_stat (sizeof (struct tree_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_base() ((struct tree_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct tree_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_base(n) ((struct tree_base *)(ggc_internal_vec_alloc_stat (sizeof (struct tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_base(n) ((struct tree_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_base(z) ((struct tree_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct tree_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_base(z) ((struct tree_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct tree_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_base(n, z) ((struct tree_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_base(n, z) ((struct tree_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_alias_pair_gc() ((struct VEC_alias_pair_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_alias_pair_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_alias_pair_gc() ((struct VEC_alias_pair_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_alias_pair_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_alias_pair_gc(n) ((struct VEC_alias_pair_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_alias_pair_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_alias_pair_gc(n) ((struct VEC_alias_pair_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_alias_pair_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_alias_pair_gc(z) ((struct VEC_alias_pair_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_alias_pair_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_alias_pair_gc(z) ((struct VEC_alias_pair_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_alias_pair_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_alias_pair_gc(n, z) ((struct VEC_alias_pair_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_alias_pair_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_alias_pair_gc(n, z) ((struct VEC_alias_pair_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_alias_pair_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_alias_pair_base() ((struct VEC_alias_pair_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_alias_pair_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_alias_pair_base() ((struct VEC_alias_pair_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_alias_pair_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_alias_pair_base(n) ((struct VEC_alias_pair_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_alias_pair_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_alias_pair_base(n) ((struct VEC_alias_pair_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_alias_pair_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_alias_pair_base(z) ((struct VEC_alias_pair_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_alias_pair_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_alias_pair_base(z) ((struct VEC_alias_pair_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_alias_pair_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_alias_pair_base(n, z) ((struct VEC_alias_pair_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_alias_pair_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_alias_pair_base(n, z) ((struct VEC_alias_pair_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_alias_pair_base), n MEM_STAT_INFO))) +#define ggc_alloc_alias_pair() ((struct alias_pair *)(ggc_internal_alloc_stat (sizeof (struct alias_pair) MEM_STAT_INFO))) +#define ggc_alloc_cleared_alias_pair() ((struct alias_pair *)(ggc_internal_cleared_alloc_stat (sizeof (struct alias_pair) MEM_STAT_INFO))) +#define ggc_alloc_vec_alias_pair(n) ((struct alias_pair *)(ggc_internal_vec_alloc_stat (sizeof (struct alias_pair), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_alias_pair(n) ((struct alias_pair *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct alias_pair), n MEM_STAT_INFO))) +#define ggc_alloc_zone_alias_pair(z) ((struct alias_pair *)(ggc_internal_zone_alloc_stat (z, sizeof (struct alias_pair) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_alias_pair(z) ((struct alias_pair *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct alias_pair) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_alias_pair(n, z) ((struct alias_pair *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct alias_pair), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_alias_pair(n, z) ((struct alias_pair *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct alias_pair), n MEM_STAT_INFO))) +#define ggc_alloc_target_rtl() ((struct target_rtl *)(ggc_internal_alloc_stat (sizeof (struct target_rtl) MEM_STAT_INFO))) +#define ggc_alloc_cleared_target_rtl() ((struct target_rtl *)(ggc_internal_cleared_alloc_stat (sizeof (struct target_rtl) MEM_STAT_INFO))) +#define ggc_alloc_vec_target_rtl(n) ((struct target_rtl *)(ggc_internal_vec_alloc_stat (sizeof (struct target_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_target_rtl(n) ((struct target_rtl *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct target_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_target_rtl(z) ((struct target_rtl *)(ggc_internal_zone_alloc_stat (z, sizeof (struct target_rtl) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_target_rtl(z) ((struct target_rtl *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct target_rtl) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_target_rtl(n, z) ((struct target_rtl *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct target_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_target_rtl(n, z) ((struct target_rtl *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct target_rtl), n MEM_STAT_INFO))) +#define ggc_alloc_function() ((struct function *)(ggc_internal_alloc_stat (sizeof (struct function) MEM_STAT_INFO))) +#define ggc_alloc_cleared_function() ((struct function *)(ggc_internal_cleared_alloc_stat (sizeof (struct function) MEM_STAT_INFO))) +#define ggc_alloc_vec_function(n) ((struct function *)(ggc_internal_vec_alloc_stat (sizeof (struct function), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_function(n) ((struct function *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_function(z) ((struct function *)(ggc_internal_zone_alloc_stat (z, sizeof (struct function) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_function(z) ((struct function *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct function) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_function(n, z) ((struct function *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_function(n, z) ((struct function *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct function), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_subunion() ((union rtx_def_subunion *)(ggc_internal_alloc_stat (sizeof (union rtx_def_subunion) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_subunion() ((union rtx_def_subunion *)(ggc_internal_cleared_alloc_stat (sizeof (union rtx_def_subunion) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_subunion(n) ((union rtx_def_subunion *)(ggc_internal_vec_alloc_stat (sizeof (union rtx_def_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_subunion(n) ((union rtx_def_subunion *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union rtx_def_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_subunion(z) ((union rtx_def_subunion *)(ggc_internal_zone_alloc_stat (z, sizeof (union rtx_def_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_subunion(z) ((union rtx_def_subunion *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union rtx_def_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_subunion(n, z) ((union rtx_def_subunion *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union rtx_def_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_subunion(n, z) ((union rtx_def_subunion *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union rtx_def_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_debug_implicit_ptr() ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_debug_implicit_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_debug_implicit_ptr() ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_debug_implicit_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_debug_implicit_ptr(n) ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_debug_implicit_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_debug_implicit_ptr(n) ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_debug_implicit_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_debug_implicit_ptr(z) ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_debug_implicit_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_debug_implicit_ptr(z) ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_debug_implicit_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_debug_implicit_ptr(n, z) ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_debug_implicit_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_debug_implicit_ptr(n, z) ((struct rtx_def_debug_implicit_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_debug_implicit_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_var_location() ((struct rtx_def_var_location *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_var_location) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_var_location() ((struct rtx_def_var_location *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_var_location) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_var_location(n) ((struct rtx_def_var_location *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_var_location), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_var_location(n) ((struct rtx_def_var_location *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_var_location), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_var_location(z) ((struct rtx_def_var_location *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_var_location) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_var_location(z) ((struct rtx_def_var_location *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_var_location) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_var_location(n, z) ((struct rtx_def_var_location *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_var_location), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_var_location(n, z) ((struct rtx_def_var_location *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_var_location), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_fma() ((struct rtx_def_fma *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_fma) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_fma() ((struct rtx_def_fma *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_fma) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_fma(n) ((struct rtx_def_fma *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_fma), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_fma(n) ((struct rtx_def_fma *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_fma), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_fma(z) ((struct rtx_def_fma *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_fma) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_fma(z) ((struct rtx_def_fma *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_fma) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_fma(n, z) ((struct rtx_def_fma *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_fma), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_fma(n, z) ((struct rtx_def_fma *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_fma), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_truncate() ((struct rtx_def_us_truncate *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_truncate) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_truncate() ((struct rtx_def_us_truncate *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_truncate) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_truncate(n) ((struct rtx_def_us_truncate *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_truncate(n) ((struct rtx_def_us_truncate *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_truncate(z) ((struct rtx_def_us_truncate *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_truncate(z) ((struct rtx_def_us_truncate *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_truncate(n, z) ((struct rtx_def_us_truncate *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_truncate(n, z) ((struct rtx_def_us_truncate *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_truncate() ((struct rtx_def_ss_truncate *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_truncate) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_truncate() ((struct rtx_def_ss_truncate *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_truncate) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_truncate(n) ((struct rtx_def_ss_truncate *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_truncate(n) ((struct rtx_def_ss_truncate *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_truncate(z) ((struct rtx_def_ss_truncate *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_truncate(z) ((struct rtx_def_ss_truncate *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_truncate(n, z) ((struct rtx_def_ss_truncate *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_truncate(n, z) ((struct rtx_def_ss_truncate *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_minus() ((struct rtx_def_us_minus *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_minus) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_minus() ((struct rtx_def_us_minus *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_minus) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_minus(n) ((struct rtx_def_us_minus *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_minus), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_minus(n) ((struct rtx_def_us_minus *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_minus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_minus(z) ((struct rtx_def_us_minus *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_minus) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_minus(z) ((struct rtx_def_us_minus *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_minus) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_minus(n, z) ((struct rtx_def_us_minus *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_minus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_minus(n, z) ((struct rtx_def_us_minus *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_minus), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_ashift() ((struct rtx_def_us_ashift *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_ashift) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_ashift() ((struct rtx_def_us_ashift *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_ashift) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_ashift(n) ((struct rtx_def_us_ashift *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_ashift(n) ((struct rtx_def_us_ashift *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_ashift(z) ((struct rtx_def_us_ashift *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_ashift) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_ashift(z) ((struct rtx_def_us_ashift *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_ashift) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_ashift(n, z) ((struct rtx_def_us_ashift *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_ashift(n, z) ((struct rtx_def_us_ashift *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_ashift() ((struct rtx_def_ss_ashift *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_ashift) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_ashift() ((struct rtx_def_ss_ashift *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_ashift) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_ashift(n) ((struct rtx_def_ss_ashift *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_ashift(n) ((struct rtx_def_ss_ashift *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_ashift(z) ((struct rtx_def_ss_ashift *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_ashift) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_ashift(z) ((struct rtx_def_ss_ashift *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_ashift) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_ashift(n, z) ((struct rtx_def_ss_ashift *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_ashift(n, z) ((struct rtx_def_ss_ashift *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_abs() ((struct rtx_def_ss_abs *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_abs) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_abs() ((struct rtx_def_ss_abs *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_abs) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_abs(n) ((struct rtx_def_ss_abs *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_abs), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_abs(n) ((struct rtx_def_ss_abs *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_abs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_abs(z) ((struct rtx_def_ss_abs *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_abs) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_abs(z) ((struct rtx_def_ss_abs *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_abs) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_abs(n, z) ((struct rtx_def_ss_abs *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_abs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_abs(n, z) ((struct rtx_def_ss_abs *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_abs), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_neg() ((struct rtx_def_us_neg *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_neg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_neg() ((struct rtx_def_us_neg *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_neg) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_neg(n) ((struct rtx_def_us_neg *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_neg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_neg(n) ((struct rtx_def_us_neg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_neg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_neg(z) ((struct rtx_def_us_neg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_neg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_neg(z) ((struct rtx_def_us_neg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_neg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_neg(n, z) ((struct rtx_def_us_neg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_neg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_neg(n, z) ((struct rtx_def_us_neg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_neg), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_neg() ((struct rtx_def_ss_neg *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_neg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_neg() ((struct rtx_def_ss_neg *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_neg) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_neg(n) ((struct rtx_def_ss_neg *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_neg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_neg(n) ((struct rtx_def_ss_neg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_neg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_neg(z) ((struct rtx_def_ss_neg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_neg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_neg(z) ((struct rtx_def_ss_neg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_neg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_neg(n, z) ((struct rtx_def_ss_neg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_neg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_neg(n, z) ((struct rtx_def_ss_neg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_neg), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_minus() ((struct rtx_def_ss_minus *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_minus) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_minus() ((struct rtx_def_ss_minus *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_minus) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_minus(n) ((struct rtx_def_ss_minus *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_minus), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_minus(n) ((struct rtx_def_ss_minus *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_minus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_minus(z) ((struct rtx_def_ss_minus *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_minus) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_minus(z) ((struct rtx_def_ss_minus *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_minus) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_minus(n, z) ((struct rtx_def_ss_minus *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_minus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_minus(n, z) ((struct rtx_def_ss_minus *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_minus), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_plus() ((struct rtx_def_us_plus *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_plus) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_plus() ((struct rtx_def_us_plus *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_plus) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_plus(n) ((struct rtx_def_us_plus *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_plus), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_plus(n) ((struct rtx_def_us_plus *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_plus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_plus(z) ((struct rtx_def_us_plus *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_plus) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_plus(z) ((struct rtx_def_us_plus *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_plus) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_plus(n, z) ((struct rtx_def_us_plus *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_plus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_plus(n, z) ((struct rtx_def_us_plus *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_plus), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_plus() ((struct rtx_def_ss_plus *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_plus) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_plus() ((struct rtx_def_ss_plus *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_plus) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_plus(n) ((struct rtx_def_ss_plus *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_plus), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_plus(n) ((struct rtx_def_ss_plus *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_plus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_plus(z) ((struct rtx_def_ss_plus *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_plus) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_plus(z) ((struct rtx_def_ss_plus *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_plus) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_plus(n, z) ((struct rtx_def_ss_plus *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_plus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_plus(n, z) ((struct rtx_def_ss_plus *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_plus), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_vec_duplicate() ((struct rtx_def_vec_duplicate *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_vec_duplicate) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_vec_duplicate() ((struct rtx_def_vec_duplicate *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_vec_duplicate) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_vec_duplicate(n) ((struct rtx_def_vec_duplicate *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_vec_duplicate), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_vec_duplicate(n) ((struct rtx_def_vec_duplicate *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_vec_duplicate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_vec_duplicate(z) ((struct rtx_def_vec_duplicate *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_vec_duplicate) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_vec_duplicate(z) ((struct rtx_def_vec_duplicate *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_vec_duplicate) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_vec_duplicate(n, z) ((struct rtx_def_vec_duplicate *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_vec_duplicate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_vec_duplicate(n, z) ((struct rtx_def_vec_duplicate *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_vec_duplicate), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_vec_concat() ((struct rtx_def_vec_concat *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_vec_concat) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_vec_concat() ((struct rtx_def_vec_concat *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_vec_concat) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_vec_concat(n) ((struct rtx_def_vec_concat *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_vec_concat), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_vec_concat(n) ((struct rtx_def_vec_concat *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_vec_concat), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_vec_concat(z) ((struct rtx_def_vec_concat *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_vec_concat) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_vec_concat(z) ((struct rtx_def_vec_concat *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_vec_concat) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_vec_concat(n, z) ((struct rtx_def_vec_concat *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_vec_concat), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_vec_concat(n, z) ((struct rtx_def_vec_concat *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_vec_concat), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_vec_select() ((struct rtx_def_vec_select *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_vec_select) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_vec_select() ((struct rtx_def_vec_select *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_vec_select) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_vec_select(n) ((struct rtx_def_vec_select *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_vec_select), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_vec_select(n) ((struct rtx_def_vec_select *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_vec_select), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_vec_select(z) ((struct rtx_def_vec_select *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_vec_select) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_vec_select(z) ((struct rtx_def_vec_select *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_vec_select) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_vec_select(n, z) ((struct rtx_def_vec_select *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_vec_select), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_vec_select(n, z) ((struct rtx_def_vec_select *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_vec_select), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_vec_merge() ((struct rtx_def_vec_merge *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_vec_merge) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_vec_merge() ((struct rtx_def_vec_merge *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_vec_merge) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_vec_merge(n) ((struct rtx_def_vec_merge *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_vec_merge), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_vec_merge(n) ((struct rtx_def_vec_merge *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_vec_merge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_vec_merge(z) ((struct rtx_def_vec_merge *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_vec_merge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_vec_merge(z) ((struct rtx_def_vec_merge *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_vec_merge) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_vec_merge(n, z) ((struct rtx_def_vec_merge *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_vec_merge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_vec_merge(n, z) ((struct rtx_def_vec_merge *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_vec_merge), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_lo_sum() ((struct rtx_def_lo_sum *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_lo_sum) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_lo_sum() ((struct rtx_def_lo_sum *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_lo_sum) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_lo_sum(n) ((struct rtx_def_lo_sum *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_lo_sum), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_lo_sum(n) ((struct rtx_def_lo_sum *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_lo_sum), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_lo_sum(z) ((struct rtx_def_lo_sum *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_lo_sum) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_lo_sum(z) ((struct rtx_def_lo_sum *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_lo_sum) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_lo_sum(n, z) ((struct rtx_def_lo_sum *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_lo_sum), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_lo_sum(n, z) ((struct rtx_def_lo_sum *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_lo_sum), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_high() ((struct rtx_def_high *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_high) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_high() ((struct rtx_def_high *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_high) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_high(n) ((struct rtx_def_high *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_high), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_high(n) ((struct rtx_def_high *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_high), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_high(z) ((struct rtx_def_high *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_high) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_high(z) ((struct rtx_def_high *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_high) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_high(n, z) ((struct rtx_def_high *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_high), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_high(n, z) ((struct rtx_def_high *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_high), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_zero_extract() ((struct rtx_def_zero_extract *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_zero_extract) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_zero_extract() ((struct rtx_def_zero_extract *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_zero_extract) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_zero_extract(n) ((struct rtx_def_zero_extract *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_zero_extract), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_zero_extract(n) ((struct rtx_def_zero_extract *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_zero_extract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_zero_extract(z) ((struct rtx_def_zero_extract *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_zero_extract) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_zero_extract(z) ((struct rtx_def_zero_extract *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_zero_extract) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_zero_extract(n, z) ((struct rtx_def_zero_extract *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_zero_extract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_zero_extract(n, z) ((struct rtx_def_zero_extract *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_zero_extract), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_sign_extract() ((struct rtx_def_sign_extract *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_sign_extract) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_sign_extract() ((struct rtx_def_sign_extract *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_sign_extract) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_sign_extract(n) ((struct rtx_def_sign_extract *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_sign_extract), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_sign_extract(n) ((struct rtx_def_sign_extract *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_sign_extract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_sign_extract(z) ((struct rtx_def_sign_extract *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_sign_extract) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_sign_extract(z) ((struct rtx_def_sign_extract *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_sign_extract) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_sign_extract(n, z) ((struct rtx_def_sign_extract *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_sign_extract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_sign_extract(n, z) ((struct rtx_def_sign_extract *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_sign_extract), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_parity() ((struct rtx_def_parity *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_parity) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_parity() ((struct rtx_def_parity *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_parity) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_parity(n) ((struct rtx_def_parity *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_parity), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_parity(n) ((struct rtx_def_parity *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_parity), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_parity(z) ((struct rtx_def_parity *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_parity) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_parity(z) ((struct rtx_def_parity *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_parity) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_parity(n, z) ((struct rtx_def_parity *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_parity), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_parity(n, z) ((struct rtx_def_parity *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_parity), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_popcount() ((struct rtx_def_popcount *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_popcount) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_popcount() ((struct rtx_def_popcount *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_popcount) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_popcount(n) ((struct rtx_def_popcount *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_popcount), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_popcount(n) ((struct rtx_def_popcount *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_popcount), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_popcount(z) ((struct rtx_def_popcount *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_popcount) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_popcount(z) ((struct rtx_def_popcount *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_popcount) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_popcount(n, z) ((struct rtx_def_popcount *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_popcount), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_popcount(n, z) ((struct rtx_def_popcount *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_popcount), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ctz() ((struct rtx_def_ctz *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ctz) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ctz() ((struct rtx_def_ctz *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ctz) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ctz(n) ((struct rtx_def_ctz *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ctz), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ctz(n) ((struct rtx_def_ctz *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ctz), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ctz(z) ((struct rtx_def_ctz *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ctz) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ctz(z) ((struct rtx_def_ctz *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ctz) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ctz(n, z) ((struct rtx_def_ctz *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ctz), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ctz(n, z) ((struct rtx_def_ctz *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ctz), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_clz() ((struct rtx_def_clz *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_clz) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_clz() ((struct rtx_def_clz *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_clz) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_clz(n) ((struct rtx_def_clz *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_clz), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_clz(n) ((struct rtx_def_clz *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_clz), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_clz(z) ((struct rtx_def_clz *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_clz) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_clz(z) ((struct rtx_def_clz *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_clz) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_clz(n, z) ((struct rtx_def_clz *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_clz), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_clz(n, z) ((struct rtx_def_clz *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_clz), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ffs() ((struct rtx_def_ffs *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ffs) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ffs() ((struct rtx_def_ffs *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ffs) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ffs(n) ((struct rtx_def_ffs *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ffs), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ffs(n) ((struct rtx_def_ffs *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ffs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ffs(z) ((struct rtx_def_ffs *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ffs) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ffs(z) ((struct rtx_def_ffs *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ffs) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ffs(n, z) ((struct rtx_def_ffs *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ffs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ffs(n, z) ((struct rtx_def_ffs *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ffs), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_bswap() ((struct rtx_def_bswap *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_bswap) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_bswap() ((struct rtx_def_bswap *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_bswap) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_bswap(n) ((struct rtx_def_bswap *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_bswap), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_bswap(n) ((struct rtx_def_bswap *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_bswap), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_bswap(z) ((struct rtx_def_bswap *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_bswap) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_bswap(z) ((struct rtx_def_bswap *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_bswap) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_bswap(n, z) ((struct rtx_def_bswap *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_bswap), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_bswap(n, z) ((struct rtx_def_bswap *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_bswap), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_sqrt() ((struct rtx_def_sqrt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_sqrt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_sqrt() ((struct rtx_def_sqrt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_sqrt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_sqrt(n) ((struct rtx_def_sqrt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_sqrt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_sqrt(n) ((struct rtx_def_sqrt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_sqrt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_sqrt(z) ((struct rtx_def_sqrt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_sqrt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_sqrt(z) ((struct rtx_def_sqrt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_sqrt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_sqrt(n, z) ((struct rtx_def_sqrt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_sqrt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_sqrt(n, z) ((struct rtx_def_sqrt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_sqrt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_abs() ((struct rtx_def_abs *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_abs) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_abs() ((struct rtx_def_abs *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_abs) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_abs(n) ((struct rtx_def_abs *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_abs), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_abs(n) ((struct rtx_def_abs *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_abs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_abs(z) ((struct rtx_def_abs *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_abs) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_abs(z) ((struct rtx_def_abs *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_abs) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_abs(n, z) ((struct rtx_def_abs *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_abs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_abs(n, z) ((struct rtx_def_abs *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_abs), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unsigned_sat_fract() ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unsigned_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unsigned_sat_fract() ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unsigned_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unsigned_sat_fract(n) ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unsigned_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unsigned_sat_fract(n) ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unsigned_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unsigned_sat_fract(z) ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unsigned_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unsigned_sat_fract(z) ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unsigned_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unsigned_sat_fract(n, z) ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unsigned_sat_fract(n, z) ((struct rtx_def_unsigned_sat_fract *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_sat_fract() ((struct rtx_def_sat_fract *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_sat_fract() ((struct rtx_def_sat_fract *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_sat_fract(n) ((struct rtx_def_sat_fract *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_sat_fract(n) ((struct rtx_def_sat_fract *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_sat_fract(z) ((struct rtx_def_sat_fract *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_sat_fract(z) ((struct rtx_def_sat_fract *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_sat_fract) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_sat_fract(n, z) ((struct rtx_def_sat_fract *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_sat_fract(n, z) ((struct rtx_def_sat_fract *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_sat_fract), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unsigned_fract_convert() ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unsigned_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unsigned_fract_convert() ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unsigned_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unsigned_fract_convert(n) ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unsigned_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unsigned_fract_convert(n) ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unsigned_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unsigned_fract_convert(z) ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unsigned_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unsigned_fract_convert(z) ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unsigned_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unsigned_fract_convert(n, z) ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unsigned_fract_convert(n, z) ((struct rtx_def_unsigned_fract_convert *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_fract_convert() ((struct rtx_def_fract_convert *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_fract_convert() ((struct rtx_def_fract_convert *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_fract_convert(n) ((struct rtx_def_fract_convert *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_fract_convert(n) ((struct rtx_def_fract_convert *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_fract_convert(z) ((struct rtx_def_fract_convert *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_fract_convert(z) ((struct rtx_def_fract_convert *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_fract_convert) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_fract_convert(n, z) ((struct rtx_def_fract_convert *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_fract_convert(n, z) ((struct rtx_def_fract_convert *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_fract_convert), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unsigned_fix() ((struct rtx_def_unsigned_fix *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unsigned_fix) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unsigned_fix() ((struct rtx_def_unsigned_fix *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unsigned_fix) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unsigned_fix(n) ((struct rtx_def_unsigned_fix *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unsigned_fix), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unsigned_fix(n) ((struct rtx_def_unsigned_fix *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unsigned_fix), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unsigned_fix(z) ((struct rtx_def_unsigned_fix *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unsigned_fix) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unsigned_fix(z) ((struct rtx_def_unsigned_fix *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unsigned_fix) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unsigned_fix(n, z) ((struct rtx_def_unsigned_fix *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_fix), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unsigned_fix(n, z) ((struct rtx_def_unsigned_fix *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_fix), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unsigned_float() ((struct rtx_def_unsigned_float *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unsigned_float) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unsigned_float() ((struct rtx_def_unsigned_float *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unsigned_float) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unsigned_float(n) ((struct rtx_def_unsigned_float *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unsigned_float), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unsigned_float(n) ((struct rtx_def_unsigned_float *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unsigned_float), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unsigned_float(z) ((struct rtx_def_unsigned_float *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unsigned_float) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unsigned_float(z) ((struct rtx_def_unsigned_float *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unsigned_float) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unsigned_float(n, z) ((struct rtx_def_unsigned_float *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_float), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unsigned_float(n, z) ((struct rtx_def_unsigned_float *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unsigned_float), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_fix() ((struct rtx_def_fix *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_fix) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_fix() ((struct rtx_def_fix *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_fix) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_fix(n) ((struct rtx_def_fix *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_fix), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_fix(n) ((struct rtx_def_fix *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_fix), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_fix(z) ((struct rtx_def_fix *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_fix) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_fix(z) ((struct rtx_def_fix *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_fix) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_fix(n, z) ((struct rtx_def_fix *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_fix), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_fix(n, z) ((struct rtx_def_fix *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_fix), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_float() ((struct rtx_def_float *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_float) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_float() ((struct rtx_def_float *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_float) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_float(n) ((struct rtx_def_float *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_float), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_float(n) ((struct rtx_def_float *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_float), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_float(z) ((struct rtx_def_float *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_float) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_float(z) ((struct rtx_def_float *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_float) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_float(n, z) ((struct rtx_def_float *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_float), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_float(n, z) ((struct rtx_def_float *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_float), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_float_truncate() ((struct rtx_def_float_truncate *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_float_truncate) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_float_truncate() ((struct rtx_def_float_truncate *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_float_truncate) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_float_truncate(n) ((struct rtx_def_float_truncate *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_float_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_float_truncate(n) ((struct rtx_def_float_truncate *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_float_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_float_truncate(z) ((struct rtx_def_float_truncate *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_float_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_float_truncate(z) ((struct rtx_def_float_truncate *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_float_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_float_truncate(n, z) ((struct rtx_def_float_truncate *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_float_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_float_truncate(n, z) ((struct rtx_def_float_truncate *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_float_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_float_extend() ((struct rtx_def_float_extend *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_float_extend) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_float_extend() ((struct rtx_def_float_extend *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_float_extend) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_float_extend(n) ((struct rtx_def_float_extend *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_float_extend), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_float_extend(n) ((struct rtx_def_float_extend *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_float_extend), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_float_extend(z) ((struct rtx_def_float_extend *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_float_extend) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_float_extend(z) ((struct rtx_def_float_extend *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_float_extend) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_float_extend(n, z) ((struct rtx_def_float_extend *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_float_extend), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_float_extend(n, z) ((struct rtx_def_float_extend *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_float_extend), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_truncate() ((struct rtx_def_truncate *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_truncate) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_truncate() ((struct rtx_def_truncate *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_truncate) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_truncate(n) ((struct rtx_def_truncate *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_truncate(n) ((struct rtx_def_truncate *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_truncate(z) ((struct rtx_def_truncate *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_truncate(z) ((struct rtx_def_truncate *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_truncate) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_truncate(n, z) ((struct rtx_def_truncate *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_truncate(n, z) ((struct rtx_def_truncate *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_truncate), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_zero_extend() ((struct rtx_def_zero_extend *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_zero_extend) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_zero_extend() ((struct rtx_def_zero_extend *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_zero_extend) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_zero_extend(n) ((struct rtx_def_zero_extend *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_zero_extend), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_zero_extend(n) ((struct rtx_def_zero_extend *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_zero_extend), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_zero_extend(z) ((struct rtx_def_zero_extend *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_zero_extend) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_zero_extend(z) ((struct rtx_def_zero_extend *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_zero_extend) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_zero_extend(n, z) ((struct rtx_def_zero_extend *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_zero_extend), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_zero_extend(n, z) ((struct rtx_def_zero_extend *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_zero_extend), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_sign_extend() ((struct rtx_def_sign_extend *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_sign_extend) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_sign_extend() ((struct rtx_def_sign_extend *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_sign_extend) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_sign_extend(n) ((struct rtx_def_sign_extend *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_sign_extend), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_sign_extend(n) ((struct rtx_def_sign_extend *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_sign_extend), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_sign_extend(z) ((struct rtx_def_sign_extend *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_sign_extend) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_sign_extend(z) ((struct rtx_def_sign_extend *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_sign_extend) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_sign_extend(n, z) ((struct rtx_def_sign_extend *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_sign_extend), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_sign_extend(n, z) ((struct rtx_def_sign_extend *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_sign_extend), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ltgt() ((struct rtx_def_ltgt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ltgt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ltgt() ((struct rtx_def_ltgt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ltgt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ltgt(n) ((struct rtx_def_ltgt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ltgt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ltgt(n) ((struct rtx_def_ltgt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ltgt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ltgt(z) ((struct rtx_def_ltgt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ltgt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ltgt(z) ((struct rtx_def_ltgt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ltgt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ltgt(n, z) ((struct rtx_def_ltgt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ltgt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ltgt(n, z) ((struct rtx_def_ltgt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ltgt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unlt() ((struct rtx_def_unlt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unlt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unlt() ((struct rtx_def_unlt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unlt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unlt(n) ((struct rtx_def_unlt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unlt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unlt(n) ((struct rtx_def_unlt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unlt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unlt(z) ((struct rtx_def_unlt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unlt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unlt(z) ((struct rtx_def_unlt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unlt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unlt(n, z) ((struct rtx_def_unlt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unlt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unlt(n, z) ((struct rtx_def_unlt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unlt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unle() ((struct rtx_def_unle *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unle) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unle() ((struct rtx_def_unle *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unle) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unle(n) ((struct rtx_def_unle *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unle), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unle(n) ((struct rtx_def_unle *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unle), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unle(z) ((struct rtx_def_unle *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unle) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unle(z) ((struct rtx_def_unle *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unle) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unle(n, z) ((struct rtx_def_unle *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unle), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unle(n, z) ((struct rtx_def_unle *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unle), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ungt() ((struct rtx_def_ungt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ungt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ungt() ((struct rtx_def_ungt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ungt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ungt(n) ((struct rtx_def_ungt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ungt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ungt(n) ((struct rtx_def_ungt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ungt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ungt(z) ((struct rtx_def_ungt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ungt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ungt(z) ((struct rtx_def_ungt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ungt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ungt(n, z) ((struct rtx_def_ungt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ungt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ungt(n, z) ((struct rtx_def_ungt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ungt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unge() ((struct rtx_def_unge *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unge) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unge() ((struct rtx_def_unge *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unge) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unge(n) ((struct rtx_def_unge *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unge), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unge(n) ((struct rtx_def_unge *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unge(z) ((struct rtx_def_unge *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unge(z) ((struct rtx_def_unge *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unge) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unge(n, z) ((struct rtx_def_unge *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unge(n, z) ((struct rtx_def_unge *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unge), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_uneq() ((struct rtx_def_uneq *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_uneq) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_uneq() ((struct rtx_def_uneq *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_uneq) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_uneq(n) ((struct rtx_def_uneq *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_uneq), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_uneq(n) ((struct rtx_def_uneq *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_uneq), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_uneq(z) ((struct rtx_def_uneq *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_uneq) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_uneq(z) ((struct rtx_def_uneq *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_uneq) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_uneq(n, z) ((struct rtx_def_uneq *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_uneq), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_uneq(n, z) ((struct rtx_def_uneq *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_uneq), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ordered() ((struct rtx_def_ordered *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ordered) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ordered() ((struct rtx_def_ordered *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ordered) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ordered(n) ((struct rtx_def_ordered *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ordered), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ordered(n) ((struct rtx_def_ordered *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ordered), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ordered(z) ((struct rtx_def_ordered *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ordered) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ordered(z) ((struct rtx_def_ordered *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ordered) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ordered(n, z) ((struct rtx_def_ordered *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ordered), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ordered(n, z) ((struct rtx_def_ordered *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ordered), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unordered() ((struct rtx_def_unordered *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unordered) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unordered() ((struct rtx_def_unordered *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unordered) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unordered(n) ((struct rtx_def_unordered *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unordered), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unordered(n) ((struct rtx_def_unordered *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unordered), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unordered(z) ((struct rtx_def_unordered *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unordered) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unordered(z) ((struct rtx_def_unordered *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unordered) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unordered(n, z) ((struct rtx_def_unordered *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unordered), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unordered(n, z) ((struct rtx_def_unordered *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unordered), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ltu() ((struct rtx_def_ltu *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ltu) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ltu() ((struct rtx_def_ltu *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ltu) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ltu(n) ((struct rtx_def_ltu *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ltu), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ltu(n) ((struct rtx_def_ltu *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ltu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ltu(z) ((struct rtx_def_ltu *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ltu) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ltu(z) ((struct rtx_def_ltu *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ltu) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ltu(n, z) ((struct rtx_def_ltu *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ltu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ltu(n, z) ((struct rtx_def_ltu *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ltu), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_leu() ((struct rtx_def_leu *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_leu) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_leu() ((struct rtx_def_leu *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_leu) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_leu(n) ((struct rtx_def_leu *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_leu), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_leu(n) ((struct rtx_def_leu *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_leu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_leu(z) ((struct rtx_def_leu *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_leu) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_leu(z) ((struct rtx_def_leu *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_leu) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_leu(n, z) ((struct rtx_def_leu *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_leu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_leu(n, z) ((struct rtx_def_leu *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_leu), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_gtu() ((struct rtx_def_gtu *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_gtu) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_gtu() ((struct rtx_def_gtu *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_gtu) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_gtu(n) ((struct rtx_def_gtu *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_gtu), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_gtu(n) ((struct rtx_def_gtu *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_gtu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_gtu(z) ((struct rtx_def_gtu *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_gtu) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_gtu(z) ((struct rtx_def_gtu *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_gtu) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_gtu(n, z) ((struct rtx_def_gtu *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_gtu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_gtu(n, z) ((struct rtx_def_gtu *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_gtu), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_geu() ((struct rtx_def_geu *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_geu) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_geu() ((struct rtx_def_geu *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_geu) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_geu(n) ((struct rtx_def_geu *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_geu), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_geu(n) ((struct rtx_def_geu *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_geu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_geu(z) ((struct rtx_def_geu *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_geu) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_geu(z) ((struct rtx_def_geu *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_geu) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_geu(n, z) ((struct rtx_def_geu *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_geu), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_geu(n, z) ((struct rtx_def_geu *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_geu), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_lt() ((struct rtx_def_lt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_lt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_lt() ((struct rtx_def_lt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_lt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_lt(n) ((struct rtx_def_lt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_lt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_lt(n) ((struct rtx_def_lt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_lt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_lt(z) ((struct rtx_def_lt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_lt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_lt(z) ((struct rtx_def_lt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_lt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_lt(n, z) ((struct rtx_def_lt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_lt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_lt(n, z) ((struct rtx_def_lt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_lt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_le() ((struct rtx_def_le *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_le) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_le() ((struct rtx_def_le *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_le) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_le(n) ((struct rtx_def_le *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_le), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_le(n) ((struct rtx_def_le *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_le), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_le(z) ((struct rtx_def_le *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_le) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_le(z) ((struct rtx_def_le *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_le) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_le(n, z) ((struct rtx_def_le *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_le), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_le(n, z) ((struct rtx_def_le *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_le), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_gt() ((struct rtx_def_gt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_gt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_gt() ((struct rtx_def_gt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_gt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_gt(n) ((struct rtx_def_gt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_gt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_gt(n) ((struct rtx_def_gt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_gt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_gt(z) ((struct rtx_def_gt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_gt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_gt(z) ((struct rtx_def_gt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_gt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_gt(n, z) ((struct rtx_def_gt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_gt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_gt(n, z) ((struct rtx_def_gt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_gt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ge() ((struct rtx_def_ge *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ge) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ge() ((struct rtx_def_ge *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ge) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ge(n) ((struct rtx_def_ge *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ge), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ge(n) ((struct rtx_def_ge *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ge(z) ((struct rtx_def_ge *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ge(z) ((struct rtx_def_ge *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ge) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ge(n, z) ((struct rtx_def_ge *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ge(n, z) ((struct rtx_def_ge *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ge), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_eq() ((struct rtx_def_eq *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_eq) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_eq() ((struct rtx_def_eq *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_eq) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_eq(n) ((struct rtx_def_eq *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_eq), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_eq(n) ((struct rtx_def_eq *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_eq), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_eq(z) ((struct rtx_def_eq *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_eq) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_eq(z) ((struct rtx_def_eq *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_eq) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_eq(n, z) ((struct rtx_def_eq *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_eq), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_eq(n, z) ((struct rtx_def_eq *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_eq), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ne() ((struct rtx_def_ne *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ne) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ne() ((struct rtx_def_ne *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ne) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ne(n) ((struct rtx_def_ne *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ne), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ne(n) ((struct rtx_def_ne *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ne), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ne(z) ((struct rtx_def_ne *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ne) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ne(z) ((struct rtx_def_ne *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ne) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ne(n, z) ((struct rtx_def_ne *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ne), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ne(n, z) ((struct rtx_def_ne *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ne), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_post_modify() ((struct rtx_def_post_modify *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_post_modify) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_post_modify() ((struct rtx_def_post_modify *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_post_modify) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_post_modify(n) ((struct rtx_def_post_modify *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_post_modify), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_post_modify(n) ((struct rtx_def_post_modify *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_post_modify), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_post_modify(z) ((struct rtx_def_post_modify *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_post_modify) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_post_modify(z) ((struct rtx_def_post_modify *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_post_modify) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_post_modify(n, z) ((struct rtx_def_post_modify *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_post_modify), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_post_modify(n, z) ((struct rtx_def_post_modify *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_post_modify), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_pre_modify() ((struct rtx_def_pre_modify *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_pre_modify) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_pre_modify() ((struct rtx_def_pre_modify *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_pre_modify) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_pre_modify(n) ((struct rtx_def_pre_modify *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_pre_modify), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_pre_modify(n) ((struct rtx_def_pre_modify *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_pre_modify), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_pre_modify(z) ((struct rtx_def_pre_modify *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_pre_modify) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_pre_modify(z) ((struct rtx_def_pre_modify *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_pre_modify) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_pre_modify(n, z) ((struct rtx_def_pre_modify *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_pre_modify), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_pre_modify(n, z) ((struct rtx_def_pre_modify *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_pre_modify), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_post_inc() ((struct rtx_def_post_inc *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_post_inc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_post_inc() ((struct rtx_def_post_inc *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_post_inc) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_post_inc(n) ((struct rtx_def_post_inc *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_post_inc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_post_inc(n) ((struct rtx_def_post_inc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_post_inc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_post_inc(z) ((struct rtx_def_post_inc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_post_inc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_post_inc(z) ((struct rtx_def_post_inc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_post_inc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_post_inc(n, z) ((struct rtx_def_post_inc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_post_inc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_post_inc(n, z) ((struct rtx_def_post_inc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_post_inc), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_post_dec() ((struct rtx_def_post_dec *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_post_dec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_post_dec() ((struct rtx_def_post_dec *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_post_dec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_post_dec(n) ((struct rtx_def_post_dec *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_post_dec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_post_dec(n) ((struct rtx_def_post_dec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_post_dec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_post_dec(z) ((struct rtx_def_post_dec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_post_dec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_post_dec(z) ((struct rtx_def_post_dec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_post_dec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_post_dec(n, z) ((struct rtx_def_post_dec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_post_dec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_post_dec(n, z) ((struct rtx_def_post_dec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_post_dec), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_pre_inc() ((struct rtx_def_pre_inc *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_pre_inc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_pre_inc() ((struct rtx_def_pre_inc *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_pre_inc) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_pre_inc(n) ((struct rtx_def_pre_inc *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_pre_inc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_pre_inc(n) ((struct rtx_def_pre_inc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_pre_inc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_pre_inc(z) ((struct rtx_def_pre_inc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_pre_inc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_pre_inc(z) ((struct rtx_def_pre_inc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_pre_inc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_pre_inc(n, z) ((struct rtx_def_pre_inc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_pre_inc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_pre_inc(n, z) ((struct rtx_def_pre_inc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_pre_inc), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_pre_dec() ((struct rtx_def_pre_dec *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_pre_dec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_pre_dec() ((struct rtx_def_pre_dec *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_pre_dec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_pre_dec(n) ((struct rtx_def_pre_dec *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_pre_dec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_pre_dec(n) ((struct rtx_def_pre_dec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_pre_dec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_pre_dec(z) ((struct rtx_def_pre_dec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_pre_dec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_pre_dec(z) ((struct rtx_def_pre_dec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_pre_dec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_pre_dec(n, z) ((struct rtx_def_pre_dec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_pre_dec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_pre_dec(n, z) ((struct rtx_def_pre_dec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_pre_dec), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_umax() ((struct rtx_def_umax *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_umax) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_umax() ((struct rtx_def_umax *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_umax) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_umax(n) ((struct rtx_def_umax *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_umax), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_umax(n) ((struct rtx_def_umax *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_umax), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_umax(z) ((struct rtx_def_umax *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_umax) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_umax(z) ((struct rtx_def_umax *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_umax) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_umax(n, z) ((struct rtx_def_umax *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_umax), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_umax(n, z) ((struct rtx_def_umax *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_umax), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_umin() ((struct rtx_def_umin *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_umin) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_umin() ((struct rtx_def_umin *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_umin) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_umin(n) ((struct rtx_def_umin *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_umin), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_umin(n) ((struct rtx_def_umin *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_umin), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_umin(z) ((struct rtx_def_umin *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_umin) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_umin(z) ((struct rtx_def_umin *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_umin) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_umin(n, z) ((struct rtx_def_umin *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_umin), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_umin(n, z) ((struct rtx_def_umin *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_umin), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_smax() ((struct rtx_def_smax *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_smax) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_smax() ((struct rtx_def_smax *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_smax) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_smax(n) ((struct rtx_def_smax *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_smax), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_smax(n) ((struct rtx_def_smax *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_smax), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_smax(z) ((struct rtx_def_smax *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_smax) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_smax(z) ((struct rtx_def_smax *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_smax) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_smax(n, z) ((struct rtx_def_smax *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_smax), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_smax(n, z) ((struct rtx_def_smax *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_smax), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_smin() ((struct rtx_def_smin *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_smin) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_smin() ((struct rtx_def_smin *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_smin) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_smin(n) ((struct rtx_def_smin *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_smin), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_smin(n) ((struct rtx_def_smin *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_smin), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_smin(z) ((struct rtx_def_smin *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_smin) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_smin(z) ((struct rtx_def_smin *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_smin) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_smin(n, z) ((struct rtx_def_smin *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_smin), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_smin(n, z) ((struct rtx_def_smin *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_smin), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_rotatert() ((struct rtx_def_rotatert *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_rotatert) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_rotatert() ((struct rtx_def_rotatert *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_rotatert) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_rotatert(n) ((struct rtx_def_rotatert *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_rotatert), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_rotatert(n) ((struct rtx_def_rotatert *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_rotatert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_rotatert(z) ((struct rtx_def_rotatert *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_rotatert) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_rotatert(z) ((struct rtx_def_rotatert *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_rotatert) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_rotatert(n, z) ((struct rtx_def_rotatert *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_rotatert), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_rotatert(n, z) ((struct rtx_def_rotatert *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_rotatert), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_lshiftrt() ((struct rtx_def_lshiftrt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_lshiftrt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_lshiftrt() ((struct rtx_def_lshiftrt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_lshiftrt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_lshiftrt(n) ((struct rtx_def_lshiftrt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_lshiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_lshiftrt(n) ((struct rtx_def_lshiftrt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_lshiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_lshiftrt(z) ((struct rtx_def_lshiftrt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_lshiftrt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_lshiftrt(z) ((struct rtx_def_lshiftrt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_lshiftrt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_lshiftrt(n, z) ((struct rtx_def_lshiftrt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_lshiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_lshiftrt(n, z) ((struct rtx_def_lshiftrt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_lshiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ashiftrt() ((struct rtx_def_ashiftrt *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ashiftrt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ashiftrt() ((struct rtx_def_ashiftrt *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ashiftrt) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ashiftrt(n) ((struct rtx_def_ashiftrt *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ashiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ashiftrt(n) ((struct rtx_def_ashiftrt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ashiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ashiftrt(z) ((struct rtx_def_ashiftrt *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ashiftrt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ashiftrt(z) ((struct rtx_def_ashiftrt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ashiftrt) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ashiftrt(n, z) ((struct rtx_def_ashiftrt *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ashiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ashiftrt(n, z) ((struct rtx_def_ashiftrt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ashiftrt), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_rotate() ((struct rtx_def_rotate *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_rotate) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_rotate() ((struct rtx_def_rotate *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_rotate) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_rotate(n) ((struct rtx_def_rotate *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_rotate), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_rotate(n) ((struct rtx_def_rotate *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_rotate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_rotate(z) ((struct rtx_def_rotate *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_rotate) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_rotate(z) ((struct rtx_def_rotate *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_rotate) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_rotate(n, z) ((struct rtx_def_rotate *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_rotate), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_rotate(n, z) ((struct rtx_def_rotate *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_rotate), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ashift() ((struct rtx_def_ashift *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ashift) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ashift() ((struct rtx_def_ashift *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ashift) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ashift(n) ((struct rtx_def_ashift *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ashift(n) ((struct rtx_def_ashift *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ashift(z) ((struct rtx_def_ashift *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ashift) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ashift(z) ((struct rtx_def_ashift *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ashift) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ashift(n, z) ((struct rtx_def_ashift *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ashift(n, z) ((struct rtx_def_ashift *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ashift), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_not() ((struct rtx_def_not *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_not) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_not() ((struct rtx_def_not *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_not) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_not(n) ((struct rtx_def_not *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_not), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_not(n) ((struct rtx_def_not *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_not), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_not(z) ((struct rtx_def_not *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_not) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_not(z) ((struct rtx_def_not *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_not) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_not(n, z) ((struct rtx_def_not *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_not), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_not(n, z) ((struct rtx_def_not *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_not), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_xor() ((struct rtx_def_xor *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_xor) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_xor() ((struct rtx_def_xor *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_xor) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_xor(n) ((struct rtx_def_xor *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_xor), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_xor(n) ((struct rtx_def_xor *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_xor), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_xor(z) ((struct rtx_def_xor *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_xor) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_xor(z) ((struct rtx_def_xor *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_xor) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_xor(n, z) ((struct rtx_def_xor *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_xor), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_xor(n, z) ((struct rtx_def_xor *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_xor), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ior() ((struct rtx_def_ior *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ior) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ior() ((struct rtx_def_ior *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ior) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ior(n) ((struct rtx_def_ior *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ior), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ior(n) ((struct rtx_def_ior *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ior), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ior(z) ((struct rtx_def_ior *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ior) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ior(z) ((struct rtx_def_ior *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ior) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ior(n, z) ((struct rtx_def_ior *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ior), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ior(n, z) ((struct rtx_def_ior *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ior), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_and() ((struct rtx_def_and *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_and) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_and() ((struct rtx_def_and *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_and) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_and(n) ((struct rtx_def_and *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_and), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_and(n) ((struct rtx_def_and *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_and), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_and(z) ((struct rtx_def_and *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_and) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_and(z) ((struct rtx_def_and *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_and) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_and(n, z) ((struct rtx_def_and *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_and), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_and(n, z) ((struct rtx_def_and *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_and), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_umod() ((struct rtx_def_umod *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_umod) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_umod() ((struct rtx_def_umod *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_umod) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_umod(n) ((struct rtx_def_umod *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_umod), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_umod(n) ((struct rtx_def_umod *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_umod), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_umod(z) ((struct rtx_def_umod *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_umod) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_umod(z) ((struct rtx_def_umod *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_umod) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_umod(n, z) ((struct rtx_def_umod *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_umod), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_umod(n, z) ((struct rtx_def_umod *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_umod), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_udiv() ((struct rtx_def_udiv *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_udiv) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_udiv() ((struct rtx_def_udiv *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_udiv) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_udiv(n) ((struct rtx_def_udiv *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_udiv), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_udiv(n) ((struct rtx_def_udiv *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_udiv), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_udiv(z) ((struct rtx_def_udiv *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_udiv) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_udiv(z) ((struct rtx_def_udiv *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_udiv) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_udiv(n, z) ((struct rtx_def_udiv *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_udiv), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_udiv(n, z) ((struct rtx_def_udiv *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_udiv), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_mod() ((struct rtx_def_mod *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_mod) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_mod() ((struct rtx_def_mod *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_mod) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_mod(n) ((struct rtx_def_mod *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_mod), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_mod(n) ((struct rtx_def_mod *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_mod), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_mod(z) ((struct rtx_def_mod *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_mod) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_mod(z) ((struct rtx_def_mod *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_mod) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_mod(n, z) ((struct rtx_def_mod *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_mod), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_mod(n, z) ((struct rtx_def_mod *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_mod), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_div() ((struct rtx_def_us_div *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_div) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_div() ((struct rtx_def_us_div *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_div) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_div(n) ((struct rtx_def_us_div *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_div), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_div(n) ((struct rtx_def_us_div *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_div), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_div(z) ((struct rtx_def_us_div *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_div) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_div(z) ((struct rtx_def_us_div *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_div) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_div(n, z) ((struct rtx_def_us_div *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_div), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_div(n, z) ((struct rtx_def_us_div *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_div), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_div() ((struct rtx_def_ss_div *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_div) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_div() ((struct rtx_def_ss_div *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_div) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_div(n) ((struct rtx_def_ss_div *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_div), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_div(n) ((struct rtx_def_ss_div *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_div), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_div(z) ((struct rtx_def_ss_div *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_div) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_div(z) ((struct rtx_def_ss_div *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_div) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_div(n, z) ((struct rtx_def_ss_div *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_div), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_div(n, z) ((struct rtx_def_ss_div *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_div), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_div() ((struct rtx_def_div *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_div) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_div() ((struct rtx_def_div *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_div) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_div(n) ((struct rtx_def_div *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_div), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_div(n) ((struct rtx_def_div *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_div), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_div(z) ((struct rtx_def_div *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_div) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_div(z) ((struct rtx_def_div *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_div) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_div(n, z) ((struct rtx_def_div *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_div), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_div(n, z) ((struct rtx_def_div *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_div), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_us_mult() ((struct rtx_def_us_mult *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_us_mult) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_us_mult() ((struct rtx_def_us_mult *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_us_mult) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_us_mult(n) ((struct rtx_def_us_mult *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_us_mult), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_us_mult(n) ((struct rtx_def_us_mult *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_us_mult), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_us_mult(z) ((struct rtx_def_us_mult *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_us_mult) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_us_mult(z) ((struct rtx_def_us_mult *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_us_mult) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_us_mult(n, z) ((struct rtx_def_us_mult *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_us_mult), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_us_mult(n, z) ((struct rtx_def_us_mult *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_us_mult), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_ss_mult() ((struct rtx_def_ss_mult *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_ss_mult) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_ss_mult() ((struct rtx_def_ss_mult *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_ss_mult) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_ss_mult(n) ((struct rtx_def_ss_mult *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_ss_mult), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_ss_mult(n) ((struct rtx_def_ss_mult *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_ss_mult), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_ss_mult(z) ((struct rtx_def_ss_mult *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_ss_mult) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_ss_mult(z) ((struct rtx_def_ss_mult *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_ss_mult) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_ss_mult(n, z) ((struct rtx_def_ss_mult *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_ss_mult), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_ss_mult(n, z) ((struct rtx_def_ss_mult *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_ss_mult), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_mult() ((struct rtx_def_mult *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_mult) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_mult() ((struct rtx_def_mult *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_mult) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_mult(n) ((struct rtx_def_mult *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_mult), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_mult(n) ((struct rtx_def_mult *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_mult), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_mult(z) ((struct rtx_def_mult *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_mult) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_mult(z) ((struct rtx_def_mult *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_mult) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_mult(n, z) ((struct rtx_def_mult *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_mult), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_mult(n, z) ((struct rtx_def_mult *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_mult), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_neg() ((struct rtx_def_neg *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_neg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_neg() ((struct rtx_def_neg *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_neg) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_neg(n) ((struct rtx_def_neg *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_neg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_neg(n) ((struct rtx_def_neg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_neg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_neg(z) ((struct rtx_def_neg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_neg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_neg(z) ((struct rtx_def_neg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_neg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_neg(n, z) ((struct rtx_def_neg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_neg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_neg(n, z) ((struct rtx_def_neg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_neg), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_minus() ((struct rtx_def_minus *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_minus) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_minus() ((struct rtx_def_minus *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_minus) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_minus(n) ((struct rtx_def_minus *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_minus), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_minus(n) ((struct rtx_def_minus *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_minus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_minus(z) ((struct rtx_def_minus *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_minus) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_minus(z) ((struct rtx_def_minus *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_minus) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_minus(n, z) ((struct rtx_def_minus *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_minus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_minus(n, z) ((struct rtx_def_minus *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_minus), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_plus() ((struct rtx_def_plus *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_plus) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_plus() ((struct rtx_def_plus *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_plus) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_plus(n) ((struct rtx_def_plus *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_plus), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_plus(n) ((struct rtx_def_plus *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_plus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_plus(z) ((struct rtx_def_plus *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_plus) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_plus(z) ((struct rtx_def_plus *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_plus) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_plus(n, z) ((struct rtx_def_plus *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_plus), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_plus(n, z) ((struct rtx_def_plus *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_plus), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_compare() ((struct rtx_def_compare *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_compare) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_compare() ((struct rtx_def_compare *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_compare) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_compare(n) ((struct rtx_def_compare *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_compare), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_compare(n) ((struct rtx_def_compare *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_compare), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_compare(z) ((struct rtx_def_compare *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_compare) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_compare(z) ((struct rtx_def_compare *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_compare) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_compare(n, z) ((struct rtx_def_compare *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_compare), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_compare(n, z) ((struct rtx_def_compare *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_compare), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_if_then_else() ((struct rtx_def_if_then_else *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_if_then_else) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_if_then_else() ((struct rtx_def_if_then_else *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_if_then_else) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_if_then_else(n) ((struct rtx_def_if_then_else *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_if_then_else), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_if_then_else(n) ((struct rtx_def_if_then_else *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_if_then_else), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_if_then_else(z) ((struct rtx_def_if_then_else *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_if_then_else) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_if_then_else(z) ((struct rtx_def_if_then_else *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_if_then_else) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_if_then_else(n, z) ((struct rtx_def_if_then_else *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_if_then_else), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_if_then_else(n, z) ((struct rtx_def_if_then_else *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_if_then_else), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_cc0() ((struct rtx_def_cc0 *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_cc0) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_cc0() ((struct rtx_def_cc0 *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_cc0) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_cc0(n) ((struct rtx_def_cc0 *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_cc0), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_cc0(n) ((struct rtx_def_cc0 *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_cc0), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_cc0(z) ((struct rtx_def_cc0 *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_cc0) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_cc0(z) ((struct rtx_def_cc0 *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_cc0) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_cc0(n, z) ((struct rtx_def_cc0 *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_cc0), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_cc0(n, z) ((struct rtx_def_cc0 *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_cc0), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_symbol_ref() ((struct rtx_def_symbol_ref *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_symbol_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_symbol_ref() ((struct rtx_def_symbol_ref *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_symbol_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_symbol_ref(n) ((struct rtx_def_symbol_ref *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_symbol_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_symbol_ref(n) ((struct rtx_def_symbol_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_symbol_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_symbol_ref(z) ((struct rtx_def_symbol_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_symbol_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_symbol_ref(z) ((struct rtx_def_symbol_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_symbol_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_symbol_ref(n, z) ((struct rtx_def_symbol_ref *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_symbol_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_symbol_ref(n, z) ((struct rtx_def_symbol_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_symbol_ref), n MEM_STAT_INFO))) +#define ggc_alloc_fake_union_1() ((union fake_union_1 *)(ggc_internal_alloc_stat (sizeof (union fake_union_1) MEM_STAT_INFO))) +#define ggc_alloc_cleared_fake_union_1() ((union fake_union_1 *)(ggc_internal_cleared_alloc_stat (sizeof (union fake_union_1) MEM_STAT_INFO))) +#define ggc_alloc_vec_fake_union_1(n) ((union fake_union_1 *)(ggc_internal_vec_alloc_stat (sizeof (union fake_union_1), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_fake_union_1(n) ((union fake_union_1 *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union fake_union_1), n MEM_STAT_INFO))) +#define ggc_alloc_zone_fake_union_1(z) ((union fake_union_1 *)(ggc_internal_zone_alloc_stat (z, sizeof (union fake_union_1) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_fake_union_1(z) ((union fake_union_1 *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union fake_union_1) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_fake_union_1(n, z) ((union fake_union_1 *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union fake_union_1), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_fake_union_1(n, z) ((union fake_union_1 *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union fake_union_1), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_label_ref() ((struct rtx_def_label_ref *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_label_ref() ((struct rtx_def_label_ref *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_label_ref(n) ((struct rtx_def_label_ref *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_label_ref(n) ((struct rtx_def_label_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_label_ref(z) ((struct rtx_def_label_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_label_ref(z) ((struct rtx_def_label_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_label_ref(n, z) ((struct rtx_def_label_ref *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_label_ref(n, z) ((struct rtx_def_label_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_mem() ((struct rtx_def_mem *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_mem) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_mem() ((struct rtx_def_mem *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_mem) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_mem(n) ((struct rtx_def_mem *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_mem), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_mem(n) ((struct rtx_def_mem *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_mem), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_mem(z) ((struct rtx_def_mem *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_mem) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_mem(z) ((struct rtx_def_mem *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_mem) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_mem(n, z) ((struct rtx_def_mem *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_mem), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_mem(n, z) ((struct rtx_def_mem *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_mem), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_concatn() ((struct rtx_def_concatn *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_concatn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_concatn() ((struct rtx_def_concatn *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_concatn) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_concatn(n) ((struct rtx_def_concatn *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_concatn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_concatn(n) ((struct rtx_def_concatn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_concatn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_concatn(z) ((struct rtx_def_concatn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_concatn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_concatn(z) ((struct rtx_def_concatn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_concatn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_concatn(n, z) ((struct rtx_def_concatn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_concatn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_concatn(n, z) ((struct rtx_def_concatn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_concatn), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_concat() ((struct rtx_def_concat *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_concat) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_concat() ((struct rtx_def_concat *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_concat) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_concat(n) ((struct rtx_def_concat *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_concat), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_concat(n) ((struct rtx_def_concat *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_concat), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_concat(z) ((struct rtx_def_concat *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_concat) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_concat(z) ((struct rtx_def_concat *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_concat) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_concat(n, z) ((struct rtx_def_concat *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_concat), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_concat(n, z) ((struct rtx_def_concat *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_concat), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_strict_low_part() ((struct rtx_def_strict_low_part *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_strict_low_part) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_strict_low_part() ((struct rtx_def_strict_low_part *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_strict_low_part) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_strict_low_part(n) ((struct rtx_def_strict_low_part *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_strict_low_part), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_strict_low_part(n) ((struct rtx_def_strict_low_part *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_strict_low_part), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_strict_low_part(z) ((struct rtx_def_strict_low_part *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_strict_low_part) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_strict_low_part(z) ((struct rtx_def_strict_low_part *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_strict_low_part) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_strict_low_part(n, z) ((struct rtx_def_strict_low_part *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_strict_low_part), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_strict_low_part(n, z) ((struct rtx_def_strict_low_part *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_strict_low_part), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_subreg() ((struct rtx_def_subreg *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_subreg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_subreg() ((struct rtx_def_subreg *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_subreg) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_subreg(n) ((struct rtx_def_subreg *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_subreg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_subreg(n) ((struct rtx_def_subreg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_subreg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_subreg(z) ((struct rtx_def_subreg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_subreg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_subreg(z) ((struct rtx_def_subreg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_subreg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_subreg(n, z) ((struct rtx_def_subreg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_subreg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_subreg(n, z) ((struct rtx_def_subreg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_subreg), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_scratch() ((struct rtx_def_scratch *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_scratch) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_scratch() ((struct rtx_def_scratch *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_scratch) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_scratch(n) ((struct rtx_def_scratch *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_scratch), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_scratch(n) ((struct rtx_def_scratch *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_scratch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_scratch(z) ((struct rtx_def_scratch *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_scratch) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_scratch(z) ((struct rtx_def_scratch *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_scratch) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_scratch(n, z) ((struct rtx_def_scratch *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_scratch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_scratch(n, z) ((struct rtx_def_scratch *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_scratch), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_reg() ((struct rtx_def_reg *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_reg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_reg() ((struct rtx_def_reg *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_reg) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_reg(n) ((struct rtx_def_reg *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_reg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_reg(n) ((struct rtx_def_reg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_reg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_reg(z) ((struct rtx_def_reg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_reg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_reg(z) ((struct rtx_def_reg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_reg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_reg(n, z) ((struct rtx_def_reg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_reg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_reg(n, z) ((struct rtx_def_reg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_reg), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_pc() ((struct rtx_def_pc *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_pc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_pc() ((struct rtx_def_pc *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_pc) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_pc(n) ((struct rtx_def_pc *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_pc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_pc(n) ((struct rtx_def_pc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_pc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_pc(z) ((struct rtx_def_pc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_pc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_pc(z) ((struct rtx_def_pc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_pc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_pc(n, z) ((struct rtx_def_pc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_pc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_pc(n, z) ((struct rtx_def_pc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_pc), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_const() ((struct rtx_def_const *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_const) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_const() ((struct rtx_def_const *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_const) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_const(n) ((struct rtx_def_const *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_const), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_const(n) ((struct rtx_def_const *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_const), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_const(z) ((struct rtx_def_const *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_const) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_const(z) ((struct rtx_def_const *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_const) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_const(n, z) ((struct rtx_def_const *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_const), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_const(n, z) ((struct rtx_def_const *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_const), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_const_string() ((struct rtx_def_const_string *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_const_string) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_const_string() ((struct rtx_def_const_string *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_const_string) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_const_string(n) ((struct rtx_def_const_string *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_const_string), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_const_string(n) ((struct rtx_def_const_string *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_const_string), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_const_string(z) ((struct rtx_def_const_string *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_const_string) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_const_string(z) ((struct rtx_def_const_string *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_const_string) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_const_string(n, z) ((struct rtx_def_const_string *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_const_string), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_const_string(n, z) ((struct rtx_def_const_string *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_const_string), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_const_vector() ((struct rtx_def_const_vector *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_const_vector) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_const_vector() ((struct rtx_def_const_vector *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_const_vector) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_const_vector(n) ((struct rtx_def_const_vector *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_const_vector), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_const_vector(n) ((struct rtx_def_const_vector *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_const_vector), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_const_vector(z) ((struct rtx_def_const_vector *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_const_vector) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_const_vector(z) ((struct rtx_def_const_vector *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_const_vector) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_const_vector(n, z) ((struct rtx_def_const_vector *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_const_vector), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_const_vector(n, z) ((struct rtx_def_const_vector *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_const_vector), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_const_double() ((struct rtx_def_const_double *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_const_double) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_const_double() ((struct rtx_def_const_double *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_const_double) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_const_double(n) ((struct rtx_def_const_double *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_const_double), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_const_double(n) ((struct rtx_def_const_double *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_const_double), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_const_double(z) ((struct rtx_def_const_double *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_const_double) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_const_double(z) ((struct rtx_def_const_double *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_const_double) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_const_double(n, z) ((struct rtx_def_const_double *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_const_double), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_const_double(n, z) ((struct rtx_def_const_double *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_const_double), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_const_fixed() ((struct rtx_def_const_fixed *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_const_fixed) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_const_fixed() ((struct rtx_def_const_fixed *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_const_fixed) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_const_fixed(n) ((struct rtx_def_const_fixed *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_const_fixed), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_const_fixed(n) ((struct rtx_def_const_fixed *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_const_fixed), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_const_fixed(z) ((struct rtx_def_const_fixed *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_const_fixed) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_const_fixed(z) ((struct rtx_def_const_fixed *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_const_fixed) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_const_fixed(n, z) ((struct rtx_def_const_fixed *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_const_fixed), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_const_fixed(n, z) ((struct rtx_def_const_fixed *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_const_fixed), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_const_int() ((struct rtx_def_const_int *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_const_int) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_const_int() ((struct rtx_def_const_int *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_const_int) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_const_int(n) ((struct rtx_def_const_int *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_const_int), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_const_int(n) ((struct rtx_def_const_int *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_const_int), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_const_int(z) ((struct rtx_def_const_int *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_const_int) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_const_int(z) ((struct rtx_def_const_int *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_const_int) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_const_int(n, z) ((struct rtx_def_const_int *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_const_int), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_const_int(n, z) ((struct rtx_def_const_int *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_const_int), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_trap_if() ((struct rtx_def_trap_if *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_trap_if) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_trap_if() ((struct rtx_def_trap_if *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_trap_if) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_trap_if(n) ((struct rtx_def_trap_if *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_trap_if), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_trap_if(n) ((struct rtx_def_trap_if *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_trap_if), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_trap_if(z) ((struct rtx_def_trap_if *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_trap_if) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_trap_if(z) ((struct rtx_def_trap_if *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_trap_if) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_trap_if(n, z) ((struct rtx_def_trap_if *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_trap_if), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_trap_if(n, z) ((struct rtx_def_trap_if *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_trap_if), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_eh_return() ((struct rtx_def_eh_return *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_eh_return) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_eh_return() ((struct rtx_def_eh_return *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_eh_return) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_eh_return(n) ((struct rtx_def_eh_return *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_eh_return), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_eh_return(n) ((struct rtx_def_eh_return *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_eh_return), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_eh_return(z) ((struct rtx_def_eh_return *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_eh_return) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_eh_return(z) ((struct rtx_def_eh_return *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_eh_return) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_eh_return(n, z) ((struct rtx_def_eh_return *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_eh_return), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_eh_return(n, z) ((struct rtx_def_eh_return *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_eh_return), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_return() ((struct rtx_def_return *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_return) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_return() ((struct rtx_def_return *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_return) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_return(n) ((struct rtx_def_return *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_return), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_return(n) ((struct rtx_def_return *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_return), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_return(z) ((struct rtx_def_return *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_return) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_return(z) ((struct rtx_def_return *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_return) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_return(n, z) ((struct rtx_def_return *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_return), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_return(n, z) ((struct rtx_def_return *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_return), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_call() ((struct rtx_def_call *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_call) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_call() ((struct rtx_def_call *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_call) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_call(n) ((struct rtx_def_call *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_call), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_call(n) ((struct rtx_def_call *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_call), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_call(z) ((struct rtx_def_call *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_call) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_call(z) ((struct rtx_def_call *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_call) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_call(n, z) ((struct rtx_def_call *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_call), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_call(n, z) ((struct rtx_def_call *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_call), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_clobber() ((struct rtx_def_clobber *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_clobber) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_clobber() ((struct rtx_def_clobber *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_clobber) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_clobber(n) ((struct rtx_def_clobber *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_clobber), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_clobber(n) ((struct rtx_def_clobber *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_clobber), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_clobber(z) ((struct rtx_def_clobber *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_clobber) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_clobber(z) ((struct rtx_def_clobber *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_clobber) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_clobber(n, z) ((struct rtx_def_clobber *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_clobber), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_clobber(n, z) ((struct rtx_def_clobber *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_clobber), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_use() ((struct rtx_def_use *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_use) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_use() ((struct rtx_def_use *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_use) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_use(n) ((struct rtx_def_use *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_use), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_use(n) ((struct rtx_def_use *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_use), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_use(z) ((struct rtx_def_use *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_use) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_use(z) ((struct rtx_def_use *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_use) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_use(n, z) ((struct rtx_def_use *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_use), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_use(n, z) ((struct rtx_def_use *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_use), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_set() ((struct rtx_def_set *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_set) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_set() ((struct rtx_def_set *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_set) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_set(n) ((struct rtx_def_set *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_set), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_set(n) ((struct rtx_def_set *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_set), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_set(z) ((struct rtx_def_set *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_set) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_set(z) ((struct rtx_def_set *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_set) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_set(n, z) ((struct rtx_def_set *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_set), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_set(n, z) ((struct rtx_def_set *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_set), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_prefetch() ((struct rtx_def_prefetch *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_prefetch) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_prefetch() ((struct rtx_def_prefetch *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_prefetch) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_prefetch(n) ((struct rtx_def_prefetch *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_prefetch), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_prefetch(n) ((struct rtx_def_prefetch *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_prefetch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_prefetch(z) ((struct rtx_def_prefetch *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_prefetch) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_prefetch(z) ((struct rtx_def_prefetch *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_prefetch) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_prefetch(n, z) ((struct rtx_def_prefetch *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_prefetch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_prefetch(n, z) ((struct rtx_def_prefetch *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_prefetch), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_addr_diff_vec() ((struct rtx_def_addr_diff_vec *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_addr_diff_vec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_addr_diff_vec() ((struct rtx_def_addr_diff_vec *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_addr_diff_vec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_addr_diff_vec(n) ((struct rtx_def_addr_diff_vec *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_addr_diff_vec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_addr_diff_vec(n) ((struct rtx_def_addr_diff_vec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_addr_diff_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_addr_diff_vec(z) ((struct rtx_def_addr_diff_vec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_addr_diff_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_addr_diff_vec(z) ((struct rtx_def_addr_diff_vec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_addr_diff_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_addr_diff_vec(n, z) ((struct rtx_def_addr_diff_vec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_addr_diff_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_addr_diff_vec(n, z) ((struct rtx_def_addr_diff_vec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_addr_diff_vec), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_addr_vec() ((struct rtx_def_addr_vec *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_addr_vec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_addr_vec() ((struct rtx_def_addr_vec *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_addr_vec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_addr_vec(n) ((struct rtx_def_addr_vec *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_addr_vec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_addr_vec(n) ((struct rtx_def_addr_vec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_addr_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_addr_vec(z) ((struct rtx_def_addr_vec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_addr_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_addr_vec(z) ((struct rtx_def_addr_vec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_addr_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_addr_vec(n, z) ((struct rtx_def_addr_vec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_addr_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_addr_vec(n, z) ((struct rtx_def_addr_vec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_addr_vec), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unspec_volatile() ((struct rtx_def_unspec_volatile *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unspec_volatile) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unspec_volatile() ((struct rtx_def_unspec_volatile *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unspec_volatile) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unspec_volatile(n) ((struct rtx_def_unspec_volatile *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unspec_volatile), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unspec_volatile(n) ((struct rtx_def_unspec_volatile *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unspec_volatile), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unspec_volatile(z) ((struct rtx_def_unspec_volatile *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unspec_volatile) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unspec_volatile(z) ((struct rtx_def_unspec_volatile *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unspec_volatile) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unspec_volatile(n, z) ((struct rtx_def_unspec_volatile *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unspec_volatile), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unspec_volatile(n, z) ((struct rtx_def_unspec_volatile *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unspec_volatile), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_unspec() ((struct rtx_def_unspec *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_unspec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_unspec() ((struct rtx_def_unspec *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_unspec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_unspec(n) ((struct rtx_def_unspec *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_unspec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_unspec(n) ((struct rtx_def_unspec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_unspec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_unspec(z) ((struct rtx_def_unspec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_unspec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_unspec(z) ((struct rtx_def_unspec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_unspec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_unspec(n, z) ((struct rtx_def_unspec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_unspec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_unspec(n, z) ((struct rtx_def_unspec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_unspec), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_asm_operands() ((struct rtx_def_asm_operands *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_asm_operands) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_asm_operands() ((struct rtx_def_asm_operands *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_asm_operands) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_asm_operands(n) ((struct rtx_def_asm_operands *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_asm_operands), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_asm_operands(n) ((struct rtx_def_asm_operands *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_asm_operands), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_asm_operands(z) ((struct rtx_def_asm_operands *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_asm_operands) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_asm_operands(z) ((struct rtx_def_asm_operands *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_asm_operands) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_asm_operands(n, z) ((struct rtx_def_asm_operands *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_asm_operands), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_asm_operands(n, z) ((struct rtx_def_asm_operands *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_asm_operands), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_asm_input() ((struct rtx_def_asm_input *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_asm_input) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_asm_input() ((struct rtx_def_asm_input *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_asm_input) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_asm_input(n) ((struct rtx_def_asm_input *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_asm_input), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_asm_input(n) ((struct rtx_def_asm_input *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_asm_input), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_asm_input(z) ((struct rtx_def_asm_input *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_asm_input) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_asm_input(z) ((struct rtx_def_asm_input *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_asm_input) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_asm_input(n, z) ((struct rtx_def_asm_input *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_asm_input), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_asm_input(n, z) ((struct rtx_def_asm_input *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_asm_input), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_parallel() ((struct rtx_def_parallel *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_parallel) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_parallel() ((struct rtx_def_parallel *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_parallel) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_parallel(n) ((struct rtx_def_parallel *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_parallel(n) ((struct rtx_def_parallel *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_parallel(z) ((struct rtx_def_parallel *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_parallel) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_parallel(z) ((struct rtx_def_parallel *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_parallel) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_parallel(n, z) ((struct rtx_def_parallel *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_parallel(n, z) ((struct rtx_def_parallel *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_parallel), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_cond_exec() ((struct rtx_def_cond_exec *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_cond_exec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_cond_exec() ((struct rtx_def_cond_exec *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_cond_exec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_cond_exec(n) ((struct rtx_def_cond_exec *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_cond_exec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_cond_exec(n) ((struct rtx_def_cond_exec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_cond_exec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_cond_exec(z) ((struct rtx_def_cond_exec *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_cond_exec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_cond_exec(z) ((struct rtx_def_cond_exec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_cond_exec) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_cond_exec(n, z) ((struct rtx_def_cond_exec *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_cond_exec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_cond_exec(n, z) ((struct rtx_def_cond_exec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_cond_exec), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_note() ((struct rtx_def_note *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_note) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_note() ((struct rtx_def_note *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_note) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_note(n) ((struct rtx_def_note *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_note), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_note(n) ((struct rtx_def_note *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_note), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_note(z) ((struct rtx_def_note *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_note) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_note(z) ((struct rtx_def_note *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_note) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_note(n, z) ((struct rtx_def_note *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_note), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_note(n, z) ((struct rtx_def_note *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_note), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_code_label() ((struct rtx_def_code_label *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_code_label) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_code_label() ((struct rtx_def_code_label *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_code_label) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_code_label(n) ((struct rtx_def_code_label *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_code_label), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_code_label(n) ((struct rtx_def_code_label *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_code_label), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_code_label(z) ((struct rtx_def_code_label *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_code_label) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_code_label(z) ((struct rtx_def_code_label *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_code_label) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_code_label(n, z) ((struct rtx_def_code_label *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_code_label), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_code_label(n, z) ((struct rtx_def_code_label *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_code_label), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_barrier() ((struct rtx_def_barrier *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_barrier) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_barrier() ((struct rtx_def_barrier *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_barrier) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_barrier(n) ((struct rtx_def_barrier *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_barrier), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_barrier(n) ((struct rtx_def_barrier *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_barrier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_barrier(z) ((struct rtx_def_barrier *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_barrier) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_barrier(z) ((struct rtx_def_barrier *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_barrier) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_barrier(n, z) ((struct rtx_def_barrier *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_barrier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_barrier(n, z) ((struct rtx_def_barrier *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_barrier), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_call_insn() ((struct rtx_def_call_insn *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_call_insn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_call_insn() ((struct rtx_def_call_insn *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_call_insn) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_call_insn(n) ((struct rtx_def_call_insn *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_call_insn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_call_insn(n) ((struct rtx_def_call_insn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_call_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_call_insn(z) ((struct rtx_def_call_insn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_call_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_call_insn(z) ((struct rtx_def_call_insn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_call_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_call_insn(n, z) ((struct rtx_def_call_insn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_call_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_call_insn(n, z) ((struct rtx_def_call_insn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_call_insn), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_jump_insn() ((struct rtx_def_jump_insn *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_jump_insn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_jump_insn() ((struct rtx_def_jump_insn *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_jump_insn) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_jump_insn(n) ((struct rtx_def_jump_insn *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_jump_insn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_jump_insn(n) ((struct rtx_def_jump_insn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_jump_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_jump_insn(z) ((struct rtx_def_jump_insn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_jump_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_jump_insn(z) ((struct rtx_def_jump_insn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_jump_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_jump_insn(n, z) ((struct rtx_def_jump_insn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_jump_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_jump_insn(n, z) ((struct rtx_def_jump_insn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_jump_insn), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_insn() ((struct rtx_def_insn *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_insn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_insn() ((struct rtx_def_insn *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_insn) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_insn(n) ((struct rtx_def_insn *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_insn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_insn(n) ((struct rtx_def_insn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_insn(z) ((struct rtx_def_insn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_insn(z) ((struct rtx_def_insn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_insn(n, z) ((struct rtx_def_insn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_insn(n, z) ((struct rtx_def_insn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_insn), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_debug_insn() ((struct rtx_def_debug_insn *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_debug_insn) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_debug_insn() ((struct rtx_def_debug_insn *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_debug_insn) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_debug_insn(n) ((struct rtx_def_debug_insn *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_debug_insn), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_debug_insn(n) ((struct rtx_def_debug_insn *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_debug_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_debug_insn(z) ((struct rtx_def_debug_insn *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_debug_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_debug_insn(z) ((struct rtx_def_debug_insn *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_debug_insn) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_debug_insn(n, z) ((struct rtx_def_debug_insn *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_debug_insn), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_debug_insn(n, z) ((struct rtx_def_debug_insn *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_debug_insn), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_address() ((struct rtx_def_address *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_address) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_address() ((struct rtx_def_address *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_address) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_address(n) ((struct rtx_def_address *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_address), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_address(n) ((struct rtx_def_address *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_address), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_address(z) ((struct rtx_def_address *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_address) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_address(z) ((struct rtx_def_address *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_address) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_address(n, z) ((struct rtx_def_address *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_address), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_address(n, z) ((struct rtx_def_address *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_address), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_sequence() ((struct rtx_def_sequence *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_sequence) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_sequence() ((struct rtx_def_sequence *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_sequence) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_sequence(n) ((struct rtx_def_sequence *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_sequence), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_sequence(n) ((struct rtx_def_sequence *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_sequence), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_sequence(z) ((struct rtx_def_sequence *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_sequence) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_sequence(z) ((struct rtx_def_sequence *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_sequence) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_sequence(n, z) ((struct rtx_def_sequence *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_sequence), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_sequence(n, z) ((struct rtx_def_sequence *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_sequence), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_insn_list() ((struct rtx_def_insn_list *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_insn_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_insn_list() ((struct rtx_def_insn_list *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_insn_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_insn_list(n) ((struct rtx_def_insn_list *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_insn_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_insn_list(n) ((struct rtx_def_insn_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_insn_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_insn_list(z) ((struct rtx_def_insn_list *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_insn_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_insn_list(z) ((struct rtx_def_insn_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_insn_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_insn_list(n, z) ((struct rtx_def_insn_list *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_insn_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_insn_list(n, z) ((struct rtx_def_insn_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_insn_list), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_expr_list() ((struct rtx_def_expr_list *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_expr_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_expr_list() ((struct rtx_def_expr_list *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_expr_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_expr_list(n) ((struct rtx_def_expr_list *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_expr_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_expr_list(n) ((struct rtx_def_expr_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_expr_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_expr_list(z) ((struct rtx_def_expr_list *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_expr_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_expr_list(z) ((struct rtx_def_expr_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_expr_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_expr_list(n, z) ((struct rtx_def_expr_list *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_expr_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_expr_list(n, z) ((struct rtx_def_expr_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_expr_list), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_debug_expr() ((struct rtx_def_debug_expr *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_debug_expr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_debug_expr() ((struct rtx_def_debug_expr *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_debug_expr) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_debug_expr(n) ((struct rtx_def_debug_expr *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_debug_expr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_debug_expr(n) ((struct rtx_def_debug_expr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_debug_expr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_debug_expr(z) ((struct rtx_def_debug_expr *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_debug_expr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_debug_expr(z) ((struct rtx_def_debug_expr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_debug_expr) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_debug_expr(n, z) ((struct rtx_def_debug_expr *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_debug_expr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_debug_expr(n, z) ((struct rtx_def_debug_expr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_debug_expr), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_value() ((struct rtx_def_value *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_value) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_value() ((struct rtx_def_value *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_value) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_value(n) ((struct rtx_def_value *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_value), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_value(n) ((struct rtx_def_value *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_value(z) ((struct rtx_def_value *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_value(z) ((struct rtx_def_value *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_value(n, z) ((struct rtx_def_value *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_value(n, z) ((struct rtx_def_value *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_value), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_UnKnown() ((struct rtx_def_UnKnown *)(ggc_internal_alloc_stat (sizeof (struct rtx_def_UnKnown) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_UnKnown() ((struct rtx_def_UnKnown *)(ggc_internal_cleared_alloc_stat (sizeof (struct rtx_def_UnKnown) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_UnKnown(n) ((struct rtx_def_UnKnown *)(ggc_internal_vec_alloc_stat (sizeof (struct rtx_def_UnKnown), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_UnKnown(n) ((struct rtx_def_UnKnown *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct rtx_def_UnKnown), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_UnKnown(z) ((struct rtx_def_UnKnown *)(ggc_internal_zone_alloc_stat (z, sizeof (struct rtx_def_UnKnown) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_UnKnown(z) ((struct rtx_def_UnKnown *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct rtx_def_UnKnown) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_UnKnown(n, z) ((struct rtx_def_UnKnown *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct rtx_def_UnKnown), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_UnKnown(n, z) ((struct rtx_def_UnKnown *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct rtx_def_UnKnown), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_symbol_subunion() ((union rtx_def_symbol_subunion *)(ggc_internal_alloc_stat (sizeof (union rtx_def_symbol_subunion) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_symbol_subunion() ((union rtx_def_symbol_subunion *)(ggc_internal_cleared_alloc_stat (sizeof (union rtx_def_symbol_subunion) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_symbol_subunion(n) ((union rtx_def_symbol_subunion *)(ggc_internal_vec_alloc_stat (sizeof (union rtx_def_symbol_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_symbol_subunion(n) ((union rtx_def_symbol_subunion *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union rtx_def_symbol_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_symbol_subunion(z) ((union rtx_def_symbol_subunion *)(ggc_internal_zone_alloc_stat (z, sizeof (union rtx_def_symbol_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_symbol_subunion(z) ((union rtx_def_symbol_subunion *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union rtx_def_symbol_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_symbol_subunion(n, z) ((union rtx_def_symbol_subunion *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union rtx_def_symbol_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_symbol_subunion(n, z) ((union rtx_def_symbol_subunion *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union rtx_def_symbol_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def_note_subunion() ((union rtx_def_note_subunion *)(ggc_internal_alloc_stat (sizeof (union rtx_def_note_subunion) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def_note_subunion() ((union rtx_def_note_subunion *)(ggc_internal_cleared_alloc_stat (sizeof (union rtx_def_note_subunion) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def_note_subunion(n) ((union rtx_def_note_subunion *)(ggc_internal_vec_alloc_stat (sizeof (union rtx_def_note_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def_note_subunion(n) ((union rtx_def_note_subunion *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union rtx_def_note_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def_note_subunion(z) ((union rtx_def_note_subunion *)(ggc_internal_zone_alloc_stat (z, sizeof (union rtx_def_note_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def_note_subunion(z) ((union rtx_def_note_subunion *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union rtx_def_note_subunion) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def_note_subunion(n, z) ((union rtx_def_note_subunion *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union rtx_def_note_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def_note_subunion(n, z) ((union rtx_def_note_subunion *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union rtx_def_note_subunion), n MEM_STAT_INFO))) +#define ggc_alloc_constant_descriptor_rtx() ((struct constant_descriptor_rtx *)(ggc_internal_alloc_stat (sizeof (struct constant_descriptor_rtx) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constant_descriptor_rtx() ((struct constant_descriptor_rtx *)(ggc_internal_cleared_alloc_stat (sizeof (struct constant_descriptor_rtx) MEM_STAT_INFO))) +#define ggc_alloc_vec_constant_descriptor_rtx(n) ((struct constant_descriptor_rtx *)(ggc_internal_vec_alloc_stat (sizeof (struct constant_descriptor_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constant_descriptor_rtx(n) ((struct constant_descriptor_rtx *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct constant_descriptor_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constant_descriptor_rtx(z) ((struct constant_descriptor_rtx *)(ggc_internal_zone_alloc_stat (z, sizeof (struct constant_descriptor_rtx) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constant_descriptor_rtx(z) ((struct constant_descriptor_rtx *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct constant_descriptor_rtx) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_constant_descriptor_rtx(n, z) ((struct constant_descriptor_rtx *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct constant_descriptor_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constant_descriptor_rtx(n, z) ((struct constant_descriptor_rtx *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct constant_descriptor_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_fixed_value() ((struct fixed_value *)(ggc_internal_alloc_stat (sizeof (struct fixed_value) MEM_STAT_INFO))) +#define ggc_alloc_cleared_fixed_value() ((struct fixed_value *)(ggc_internal_cleared_alloc_stat (sizeof (struct fixed_value) MEM_STAT_INFO))) +#define ggc_alloc_vec_fixed_value(n) ((struct fixed_value *)(ggc_internal_vec_alloc_stat (sizeof (struct fixed_value), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_fixed_value(n) ((struct fixed_value *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct fixed_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_fixed_value(z) ((struct fixed_value *)(ggc_internal_zone_alloc_stat (z, sizeof (struct fixed_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_fixed_value(z) ((struct fixed_value *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct fixed_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_fixed_value(n, z) ((struct fixed_value *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct fixed_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_fixed_value(n, z) ((struct fixed_value *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct fixed_value), n MEM_STAT_INFO))) +#define ggc_alloc_real_value() ((struct real_value *)(ggc_internal_alloc_stat (sizeof (struct real_value) MEM_STAT_INFO))) +#define ggc_alloc_cleared_real_value() ((struct real_value *)(ggc_internal_cleared_alloc_stat (sizeof (struct real_value) MEM_STAT_INFO))) +#define ggc_alloc_vec_real_value(n) ((struct real_value *)(ggc_internal_vec_alloc_stat (sizeof (struct real_value), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_real_value(n) ((struct real_value *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct real_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_real_value(z) ((struct real_value *)(ggc_internal_zone_alloc_stat (z, sizeof (struct real_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_real_value(z) ((struct real_value *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct real_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_real_value(n, z) ((struct real_value *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct real_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_real_value(n, z) ((struct real_value *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct real_value), n MEM_STAT_INFO))) +#define ggc_alloc_block_symbol() ((struct block_symbol *)(ggc_internal_alloc_stat (sizeof (struct block_symbol) MEM_STAT_INFO))) +#define ggc_alloc_cleared_block_symbol() ((struct block_symbol *)(ggc_internal_cleared_alloc_stat (sizeof (struct block_symbol) MEM_STAT_INFO))) +#define ggc_alloc_vec_block_symbol(n) ((struct block_symbol *)(ggc_internal_vec_alloc_stat (sizeof (struct block_symbol), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_block_symbol(n) ((struct block_symbol *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct block_symbol), n MEM_STAT_INFO))) +#define ggc_alloc_zone_block_symbol(z) ((struct block_symbol *)(ggc_internal_zone_alloc_stat (z, sizeof (struct block_symbol) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_block_symbol(z) ((struct block_symbol *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct block_symbol) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_block_symbol(n, z) ((struct block_symbol *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct block_symbol), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_block_symbol(n, z) ((struct block_symbol *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct block_symbol), n MEM_STAT_INFO))) +#define ggc_alloc_object_block() ((struct object_block *)(ggc_internal_alloc_stat (sizeof (struct object_block) MEM_STAT_INFO))) +#define ggc_alloc_cleared_object_block() ((struct object_block *)(ggc_internal_cleared_alloc_stat (sizeof (struct object_block) MEM_STAT_INFO))) +#define ggc_alloc_vec_object_block(n) ((struct object_block *)(ggc_internal_vec_alloc_stat (sizeof (struct object_block), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_object_block(n) ((struct object_block *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct object_block), n MEM_STAT_INFO))) +#define ggc_alloc_zone_object_block(z) ((struct object_block *)(ggc_internal_zone_alloc_stat (z, sizeof (struct object_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_object_block(z) ((struct object_block *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct object_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_object_block(n, z) ((struct object_block *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct object_block), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_object_block(n, z) ((struct object_block *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct object_block), n MEM_STAT_INFO))) +#define ggc_alloc_reg_attrs() ((struct reg_attrs *)(ggc_internal_alloc_stat (sizeof (struct reg_attrs) MEM_STAT_INFO))) +#define ggc_alloc_cleared_reg_attrs() ((struct reg_attrs *)(ggc_internal_cleared_alloc_stat (sizeof (struct reg_attrs) MEM_STAT_INFO))) +#define ggc_alloc_vec_reg_attrs(n) ((struct reg_attrs *)(ggc_internal_vec_alloc_stat (sizeof (struct reg_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_reg_attrs(n) ((struct reg_attrs *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct reg_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_reg_attrs(z) ((struct reg_attrs *)(ggc_internal_zone_alloc_stat (z, sizeof (struct reg_attrs) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_reg_attrs(z) ((struct reg_attrs *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct reg_attrs) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_reg_attrs(n, z) ((struct reg_attrs *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct reg_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_reg_attrs(n, z) ((struct reg_attrs *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct reg_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_mem_attrs() ((struct mem_attrs *)(ggc_internal_alloc_stat (sizeof (struct mem_attrs) MEM_STAT_INFO))) +#define ggc_alloc_cleared_mem_attrs() ((struct mem_attrs *)(ggc_internal_cleared_alloc_stat (sizeof (struct mem_attrs) MEM_STAT_INFO))) +#define ggc_alloc_vec_mem_attrs(n) ((struct mem_attrs *)(ggc_internal_vec_alloc_stat (sizeof (struct mem_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_mem_attrs(n) ((struct mem_attrs *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct mem_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_mem_attrs(z) ((struct mem_attrs *)(ggc_internal_zone_alloc_stat (z, sizeof (struct mem_attrs) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_mem_attrs(z) ((struct mem_attrs *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct mem_attrs) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_mem_attrs(n, z) ((struct mem_attrs *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct mem_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_mem_attrs(n, z) ((struct mem_attrs *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct mem_attrs), n MEM_STAT_INFO))) +#define ggc_alloc_bitmap_obstack() ((struct bitmap_obstack *)(ggc_internal_alloc_stat (sizeof (struct bitmap_obstack) MEM_STAT_INFO))) +#define ggc_alloc_cleared_bitmap_obstack() ((struct bitmap_obstack *)(ggc_internal_cleared_alloc_stat (sizeof (struct bitmap_obstack) MEM_STAT_INFO))) +#define ggc_alloc_vec_bitmap_obstack(n) ((struct bitmap_obstack *)(ggc_internal_vec_alloc_stat (sizeof (struct bitmap_obstack), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_bitmap_obstack(n) ((struct bitmap_obstack *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct bitmap_obstack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_bitmap_obstack(z) ((struct bitmap_obstack *)(ggc_internal_zone_alloc_stat (z, sizeof (struct bitmap_obstack) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_bitmap_obstack(z) ((struct bitmap_obstack *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct bitmap_obstack) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_bitmap_obstack(n, z) ((struct bitmap_obstack *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct bitmap_obstack), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_bitmap_obstack(n, z) ((struct bitmap_obstack *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct bitmap_obstack), n MEM_STAT_INFO))) +#define ggc_alloc_bitmap_element_def() ((struct bitmap_element_def *)(ggc_internal_alloc_stat (sizeof (struct bitmap_element_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_bitmap_element_def() ((struct bitmap_element_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct bitmap_element_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_bitmap_element_def(n) ((struct bitmap_element_def *)(ggc_internal_vec_alloc_stat (sizeof (struct bitmap_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_bitmap_element_def(n) ((struct bitmap_element_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct bitmap_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_bitmap_element_def(z) ((struct bitmap_element_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct bitmap_element_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_bitmap_element_def(z) ((struct bitmap_element_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct bitmap_element_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_bitmap_element_def(n, z) ((struct bitmap_element_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct bitmap_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_bitmap_element_def(n, z) ((struct bitmap_element_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct bitmap_element_def), n MEM_STAT_INFO))) +#define ggc_alloc_splay_tree_s() ((struct splay_tree_s *)(ggc_internal_alloc_stat (sizeof (struct splay_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_splay_tree_s() ((struct splay_tree_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct splay_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_splay_tree_s(n) ((struct splay_tree_s *)(ggc_internal_vec_alloc_stat (sizeof (struct splay_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_splay_tree_s(n) ((struct splay_tree_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct splay_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_splay_tree_s(z) ((struct splay_tree_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct splay_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_splay_tree_s(z) ((struct splay_tree_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct splay_tree_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_splay_tree_s(n, z) ((struct splay_tree_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct splay_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_splay_tree_s(n, z) ((struct splay_tree_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct splay_tree_s), n MEM_STAT_INFO))) +#define ggc_alloc_splay_tree_node_s() ((struct splay_tree_node_s *)(ggc_internal_alloc_stat (sizeof (struct splay_tree_node_s) MEM_STAT_INFO))) +#define ggc_alloc_cleared_splay_tree_node_s() ((struct splay_tree_node_s *)(ggc_internal_cleared_alloc_stat (sizeof (struct splay_tree_node_s) MEM_STAT_INFO))) +#define ggc_alloc_vec_splay_tree_node_s(n) ((struct splay_tree_node_s *)(ggc_internal_vec_alloc_stat (sizeof (struct splay_tree_node_s), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_splay_tree_node_s(n) ((struct splay_tree_node_s *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct splay_tree_node_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_splay_tree_node_s(z) ((struct splay_tree_node_s *)(ggc_internal_zone_alloc_stat (z, sizeof (struct splay_tree_node_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_splay_tree_node_s(z) ((struct splay_tree_node_s *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct splay_tree_node_s) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_splay_tree_node_s(n, z) ((struct splay_tree_node_s *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct splay_tree_node_s), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_splay_tree_node_s(n, z) ((struct splay_tree_node_s *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct splay_tree_node_s), n MEM_STAT_INFO))) +#define ggc_alloc_htab() ((struct htab *)(ggc_internal_alloc_stat (sizeof (struct htab) MEM_STAT_INFO))) +#define ggc_alloc_cleared_htab() ((struct htab *)(ggc_internal_cleared_alloc_stat (sizeof (struct htab) MEM_STAT_INFO))) +#define ggc_alloc_vec_htab(n) ((struct htab *)(ggc_internal_vec_alloc_stat (sizeof (struct htab), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_htab(n) ((struct htab *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct htab), n MEM_STAT_INFO))) +#define ggc_alloc_zone_htab(z) ((struct htab *)(ggc_internal_zone_alloc_stat (z, sizeof (struct htab) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_htab(z) ((struct htab *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct htab) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_htab(n, z) ((struct htab *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct htab), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_htab(n, z) ((struct htab *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct htab), n MEM_STAT_INFO))) +#define ggc_alloc_machine_function() ((struct machine_function *)(ggc_internal_alloc_stat (sizeof (struct machine_function) MEM_STAT_INFO))) +#define ggc_alloc_cleared_machine_function() ((struct machine_function *)(ggc_internal_cleared_alloc_stat (sizeof (struct machine_function) MEM_STAT_INFO))) +#define ggc_alloc_vec_machine_function(n) ((struct machine_function *)(ggc_internal_vec_alloc_stat (sizeof (struct machine_function), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_machine_function(n) ((struct machine_function *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct machine_function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_machine_function(z) ((struct machine_function *)(ggc_internal_zone_alloc_stat (z, sizeof (struct machine_function) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_machine_function(z) ((struct machine_function *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct machine_function) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_machine_function(n, z) ((struct machine_function *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct machine_function), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_machine_function(n, z) ((struct machine_function *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct machine_function), n MEM_STAT_INFO))) +#define ggc_alloc_arm_stack_offsets() ((struct arm_stack_offsets *)(ggc_internal_alloc_stat (sizeof (struct arm_stack_offsets) MEM_STAT_INFO))) +#define ggc_alloc_cleared_arm_stack_offsets() ((struct arm_stack_offsets *)(ggc_internal_cleared_alloc_stat (sizeof (struct arm_stack_offsets) MEM_STAT_INFO))) +#define ggc_alloc_vec_arm_stack_offsets(n) ((struct arm_stack_offsets *)(ggc_internal_vec_alloc_stat (sizeof (struct arm_stack_offsets), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_arm_stack_offsets(n) ((struct arm_stack_offsets *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct arm_stack_offsets), n MEM_STAT_INFO))) +#define ggc_alloc_zone_arm_stack_offsets(z) ((struct arm_stack_offsets *)(ggc_internal_zone_alloc_stat (z, sizeof (struct arm_stack_offsets) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_arm_stack_offsets(z) ((struct arm_stack_offsets *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct arm_stack_offsets) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_arm_stack_offsets(n, z) ((struct arm_stack_offsets *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct arm_stack_offsets), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_arm_stack_offsets(n, z) ((struct arm_stack_offsets *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct arm_stack_offsets), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_rtx_gc() ((struct VEC_rtx_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_rtx_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_rtx_gc() ((struct VEC_rtx_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_rtx_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_rtx_gc(n) ((struct VEC_rtx_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_rtx_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_rtx_gc(n) ((struct VEC_rtx_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_rtx_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_rtx_gc(z) ((struct VEC_rtx_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_rtx_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_rtx_gc(z) ((struct VEC_rtx_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_rtx_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_rtx_gc(n, z) ((struct VEC_rtx_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_rtx_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_rtx_gc(n, z) ((struct VEC_rtx_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_rtx_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_rtx_base() ((struct VEC_rtx_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_rtx_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_rtx_base() ((struct VEC_rtx_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_rtx_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_rtx_base(n) ((struct VEC_rtx_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_rtx_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_rtx_base(n) ((struct VEC_rtx_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_rtx_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_rtx_base(z) ((struct VEC_rtx_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_rtx_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_rtx_base(z) ((struct VEC_rtx_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_rtx_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_rtx_base(n, z) ((struct VEC_rtx_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_rtx_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_rtx_base(n, z) ((struct VEC_rtx_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_rtx_base), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_gimple_gc() ((struct VEC_gimple_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_gimple_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_gimple_gc() ((struct VEC_gimple_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_gimple_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_gimple_gc(n) ((struct VEC_gimple_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_gimple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_gimple_gc(n) ((struct VEC_gimple_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_gimple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_gimple_gc(z) ((struct VEC_gimple_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_gimple_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_gimple_gc(z) ((struct VEC_gimple_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_gimple_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_gimple_gc(n, z) ((struct VEC_gimple_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_gimple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_gimple_gc(n, z) ((struct VEC_gimple_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_gimple_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_gimple_base() ((struct VEC_gimple_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_gimple_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_gimple_base() ((struct VEC_gimple_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_gimple_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_gimple_base(n) ((struct VEC_gimple_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_gimple_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_gimple_base(n) ((struct VEC_gimple_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_gimple_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_gimple_base(z) ((struct VEC_gimple_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_gimple_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_gimple_base(z) ((struct VEC_gimple_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_gimple_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_gimple_base(n, z) ((struct VEC_gimple_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_gimple_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_gimple_base(n, z) ((struct VEC_gimple_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_gimple_base), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_gc() ((struct VEC_tree_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_gc() ((struct VEC_tree_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_gc(n) ((struct VEC_tree_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_gc(n) ((struct VEC_tree_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_gc(z) ((struct VEC_tree_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_gc(z) ((struct VEC_tree_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_gc(n, z) ((struct VEC_tree_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_gc(n, z) ((struct VEC_tree_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_none() ((struct VEC_tree_none *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_none) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_none() ((struct VEC_tree_none *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_none) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_none(n) ((struct VEC_tree_none *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_none), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_none(n) ((struct VEC_tree_none *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_none), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_none(z) ((struct VEC_tree_none *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_none) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_none(z) ((struct VEC_tree_none *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_none) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_none(n, z) ((struct VEC_tree_none *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_none), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_none(n, z) ((struct VEC_tree_none *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_none), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_tree_base() ((struct VEC_tree_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_tree_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_tree_base() ((struct VEC_tree_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_tree_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_tree_base(n) ((struct VEC_tree_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_tree_base(n) ((struct VEC_tree_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_tree_base(z) ((struct VEC_tree_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_tree_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_tree_base(z) ((struct VEC_tree_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_tree_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_tree_base(n, z) ((struct VEC_tree_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_tree_base(n, z) ((struct VEC_tree_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_tree_base), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_uchar_gc() ((struct VEC_uchar_gc *)(ggc_internal_alloc_stat (sizeof (struct VEC_uchar_gc) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_uchar_gc() ((struct VEC_uchar_gc *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_uchar_gc) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_uchar_gc(n) ((struct VEC_uchar_gc *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_uchar_gc), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_uchar_gc(n) ((struct VEC_uchar_gc *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_uchar_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_uchar_gc(z) ((struct VEC_uchar_gc *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_uchar_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_uchar_gc(z) ((struct VEC_uchar_gc *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_uchar_gc) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_uchar_gc(n, z) ((struct VEC_uchar_gc *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_uchar_gc), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_uchar_gc(n, z) ((struct VEC_uchar_gc *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_uchar_gc), n MEM_STAT_INFO))) +#define ggc_alloc_VEC_uchar_base() ((struct VEC_uchar_base *)(ggc_internal_alloc_stat (sizeof (struct VEC_uchar_base) MEM_STAT_INFO))) +#define ggc_alloc_cleared_VEC_uchar_base() ((struct VEC_uchar_base *)(ggc_internal_cleared_alloc_stat (sizeof (struct VEC_uchar_base) MEM_STAT_INFO))) +#define ggc_alloc_vec_VEC_uchar_base(n) ((struct VEC_uchar_base *)(ggc_internal_vec_alloc_stat (sizeof (struct VEC_uchar_base), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_VEC_uchar_base(n) ((struct VEC_uchar_base *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct VEC_uchar_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_VEC_uchar_base(z) ((struct VEC_uchar_base *)(ggc_internal_zone_alloc_stat (z, sizeof (struct VEC_uchar_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_VEC_uchar_base(z) ((struct VEC_uchar_base *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct VEC_uchar_base) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_VEC_uchar_base(n, z) ((struct VEC_uchar_base *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct VEC_uchar_base), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_VEC_uchar_base(n, z) ((struct VEC_uchar_base *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct VEC_uchar_base), n MEM_STAT_INFO))) +#define ggc_alloc_basic_block_def() ((struct basic_block_def *)(ggc_internal_alloc_stat (sizeof (struct basic_block_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_basic_block_def() ((struct basic_block_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct basic_block_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_basic_block_def(n) ((struct basic_block_def *)(ggc_internal_vec_alloc_stat (sizeof (struct basic_block_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_basic_block_def(n) ((struct basic_block_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct basic_block_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_basic_block_def(z) ((struct basic_block_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct basic_block_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_basic_block_def(z) ((struct basic_block_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct basic_block_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_basic_block_def(n, z) ((struct basic_block_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct basic_block_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_basic_block_def(n, z) ((struct basic_block_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct basic_block_def), n MEM_STAT_INFO))) +#define ggc_alloc_edge_def() ((struct edge_def *)(ggc_internal_alloc_stat (sizeof (struct edge_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_edge_def() ((struct edge_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct edge_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_edge_def(n) ((struct edge_def *)(ggc_internal_vec_alloc_stat (sizeof (struct edge_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_edge_def(n) ((struct edge_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct edge_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_edge_def(z) ((struct edge_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct edge_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_edge_def(z) ((struct edge_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct edge_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_edge_def(n, z) ((struct edge_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct edge_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_edge_def(n, z) ((struct edge_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct edge_def), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_seq_d() ((struct gimple_seq_d *)(ggc_internal_alloc_stat (sizeof (struct gimple_seq_d) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_seq_d() ((struct gimple_seq_d *)(ggc_internal_cleared_alloc_stat (sizeof (struct gimple_seq_d) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_seq_d(n) ((struct gimple_seq_d *)(ggc_internal_vec_alloc_stat (sizeof (struct gimple_seq_d), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_seq_d(n) ((struct gimple_seq_d *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct gimple_seq_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_seq_d(z) ((struct gimple_seq_d *)(ggc_internal_zone_alloc_stat (z, sizeof (struct gimple_seq_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_seq_d(z) ((struct gimple_seq_d *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct gimple_seq_d) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_seq_d(n, z) ((struct gimple_seq_d *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct gimple_seq_d), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_seq_d(n, z) ((struct gimple_seq_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct gimple_seq_d), n MEM_STAT_INFO))) +#define ggc_alloc_cl_optimization() ((struct cl_optimization *)(ggc_internal_alloc_stat (sizeof (struct cl_optimization) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cl_optimization() ((struct cl_optimization *)(ggc_internal_cleared_alloc_stat (sizeof (struct cl_optimization) MEM_STAT_INFO))) +#define ggc_alloc_vec_cl_optimization(n) ((struct cl_optimization *)(ggc_internal_vec_alloc_stat (sizeof (struct cl_optimization), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cl_optimization(n) ((struct cl_optimization *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cl_optimization), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cl_optimization(z) ((struct cl_optimization *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cl_optimization) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cl_optimization(z) ((struct cl_optimization *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cl_optimization) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cl_optimization(n, z) ((struct cl_optimization *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cl_optimization), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cl_optimization(n, z) ((struct cl_optimization *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cl_optimization), n MEM_STAT_INFO))) +#define ggc_alloc_cl_target_option() ((struct cl_target_option *)(ggc_internal_alloc_stat (sizeof (struct cl_target_option) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cl_target_option() ((struct cl_target_option *)(ggc_internal_cleared_alloc_stat (sizeof (struct cl_target_option) MEM_STAT_INFO))) +#define ggc_alloc_vec_cl_target_option(n) ((struct cl_target_option *)(ggc_internal_vec_alloc_stat (sizeof (struct cl_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cl_target_option(n) ((struct cl_target_option *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cl_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cl_target_option(z) ((struct cl_target_option *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cl_target_option) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cl_target_option(z) ((struct cl_target_option *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cl_target_option) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cl_target_option(n, z) ((struct cl_target_option *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cl_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cl_target_option(n, z) ((struct cl_target_option *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cl_target_option), n MEM_STAT_INFO))) +#define ggc_alloc_section() ((union section *)(ggc_internal_alloc_stat (sizeof (union section) MEM_STAT_INFO))) +#define ggc_alloc_cleared_section() ((union section *)(ggc_internal_cleared_alloc_stat (sizeof (union section) MEM_STAT_INFO))) +#define ggc_alloc_vec_section(n) ((union section *)(ggc_internal_vec_alloc_stat (sizeof (union section), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_section(n) ((union section *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_section(z) ((union section *)(ggc_internal_zone_alloc_stat (z, sizeof (union section) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_section(z) ((union section *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union section) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_section(n, z) ((union section *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union section), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_section(n, z) ((union section *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union section), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_statement_d(SIZE) ((union gimple_statement_d *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_statement_d(SIZE) ((union gimple_statement_d *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_statement_d(SIZE, n) ((union gimple_statement_d *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_statement_d(SIZE, n) ((union gimple_statement_d *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_statement_d(SIZE, z) ((union gimple_statement_d *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_statement_d(SIZE, z) ((union gimple_statement_d *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_gimple_statement_d(SIZE, n, z) ((union gimple_statement_d *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_statement_d(SIZE, n, z) ((union gimple_statement_d *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_rtvec_def(SIZE) ((struct rtvec_def *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtvec_def(SIZE) ((struct rtvec_def *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_rtvec_def(SIZE, n) ((struct rtvec_def *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtvec_def(SIZE, n) ((struct rtvec_def *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtvec_def(SIZE, z) ((struct rtvec_def *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtvec_def(SIZE, z) ((struct rtvec_def *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtvec_def(SIZE, n, z) ((struct rtvec_def *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtvec_def(SIZE, n, z) ((struct rtvec_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_rtx_def(SIZE) ((struct rtx_def *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx_def(SIZE) ((struct rtx_def *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx_def(SIZE, n) ((struct rtx_def *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx_def(SIZE, n) ((struct rtx_def *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx_def(SIZE, z) ((struct rtx_def *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx_def(SIZE, z) ((struct rtx_def *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_rtx_def(SIZE, n, z) ((struct rtx_def *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx_def(SIZE, n, z) ((struct rtx_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_bitmap_head_def() ((struct bitmap_head_def *)(ggc_internal_alloc_stat (sizeof (struct bitmap_head_def) MEM_STAT_INFO))) +#define ggc_alloc_cleared_bitmap_head_def() ((struct bitmap_head_def *)(ggc_internal_cleared_alloc_stat (sizeof (struct bitmap_head_def) MEM_STAT_INFO))) +#define ggc_alloc_vec_bitmap_head_def(n) ((struct bitmap_head_def *)(ggc_internal_vec_alloc_stat (sizeof (struct bitmap_head_def), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_bitmap_head_def(n) ((struct bitmap_head_def *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct bitmap_head_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_bitmap_head_def(z) ((struct bitmap_head_def *)(ggc_internal_zone_alloc_stat (z, sizeof (struct bitmap_head_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_bitmap_head_def(z) ((struct bitmap_head_def *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct bitmap_head_def) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_bitmap_head_def(n, z) ((struct bitmap_head_def *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct bitmap_head_def), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_bitmap_head_def(n, z) ((struct bitmap_head_def *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct bitmap_head_def), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_macro_u() ((union cpp_macro_u *)(ggc_internal_alloc_stat (sizeof (union cpp_macro_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_macro_u() ((union cpp_macro_u *)(ggc_internal_cleared_alloc_stat (sizeof (union cpp_macro_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_macro_u(n) ((union cpp_macro_u *)(ggc_internal_vec_alloc_stat (sizeof (union cpp_macro_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_macro_u(n) ((union cpp_macro_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union cpp_macro_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_macro_u(z) ((union cpp_macro_u *)(ggc_internal_zone_alloc_stat (z, sizeof (union cpp_macro_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_macro_u(z) ((union cpp_macro_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union cpp_macro_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_macro_u(n, z) ((union cpp_macro_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union cpp_macro_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_macro_u(n, z) ((union cpp_macro_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union cpp_macro_u), n MEM_STAT_INFO))) +#define ggc_alloc_ht_identifier() ((struct ht_identifier *)(ggc_internal_alloc_stat (sizeof (struct ht_identifier) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ht_identifier() ((struct ht_identifier *)(ggc_internal_cleared_alloc_stat (sizeof (struct ht_identifier) MEM_STAT_INFO))) +#define ggc_alloc_vec_ht_identifier(n) ((struct ht_identifier *)(ggc_internal_vec_alloc_stat (sizeof (struct ht_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ht_identifier(n) ((struct ht_identifier *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct ht_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ht_identifier(z) ((struct ht_identifier *)(ggc_internal_zone_alloc_stat (z, sizeof (struct ht_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ht_identifier(z) ((struct ht_identifier *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct ht_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_ht_identifier(n, z) ((struct ht_identifier *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct ht_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ht_identifier(n, z) ((struct ht_identifier *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct ht_identifier), n MEM_STAT_INFO))) +#define ggc_alloc__cpp_hashnode_value() ((union _cpp_hashnode_value *)(ggc_internal_alloc_stat (sizeof (union _cpp_hashnode_value) MEM_STAT_INFO))) +#define ggc_alloc_cleared__cpp_hashnode_value() ((union _cpp_hashnode_value *)(ggc_internal_cleared_alloc_stat (sizeof (union _cpp_hashnode_value) MEM_STAT_INFO))) +#define ggc_alloc_vec__cpp_hashnode_value(n) ((union _cpp_hashnode_value *)(ggc_internal_vec_alloc_stat (sizeof (union _cpp_hashnode_value), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec__cpp_hashnode_value(n) ((union _cpp_hashnode_value *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union _cpp_hashnode_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone__cpp_hashnode_value(z) ((union _cpp_hashnode_value *)(ggc_internal_zone_alloc_stat (z, sizeof (union _cpp_hashnode_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared__cpp_hashnode_value(z) ((union _cpp_hashnode_value *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union _cpp_hashnode_value) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec__cpp_hashnode_value(n, z) ((union _cpp_hashnode_value *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union _cpp_hashnode_value), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec__cpp_hashnode_value(n, z) ((union _cpp_hashnode_value *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union _cpp_hashnode_value), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_token_u() ((union cpp_token_u *)(ggc_internal_alloc_stat (sizeof (union cpp_token_u) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_token_u() ((union cpp_token_u *)(ggc_internal_cleared_alloc_stat (sizeof (union cpp_token_u) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_token_u(n) ((union cpp_token_u *)(ggc_internal_vec_alloc_stat (sizeof (union cpp_token_u), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_token_u(n) ((union cpp_token_u *)(ggc_internal_cleared_vec_alloc_stat (sizeof (union cpp_token_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_token_u(z) ((union cpp_token_u *)(ggc_internal_zone_alloc_stat (z, sizeof (union cpp_token_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_token_u(z) ((union cpp_token_u *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (union cpp_token_u) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_token_u(n, z) ((union cpp_token_u *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (union cpp_token_u), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_token_u(n, z) ((union cpp_token_u *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (union cpp_token_u), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_identifier() ((struct cpp_identifier *)(ggc_internal_alloc_stat (sizeof (struct cpp_identifier) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_identifier() ((struct cpp_identifier *)(ggc_internal_cleared_alloc_stat (sizeof (struct cpp_identifier) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_identifier(n) ((struct cpp_identifier *)(ggc_internal_vec_alloc_stat (sizeof (struct cpp_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_identifier(n) ((struct cpp_identifier *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cpp_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_identifier(z) ((struct cpp_identifier *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cpp_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_identifier(z) ((struct cpp_identifier *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cpp_identifier) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_identifier(n, z) ((struct cpp_identifier *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cpp_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_identifier(n, z) ((struct cpp_identifier *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cpp_identifier), n MEM_STAT_INFO))) +#define ggc_alloc_tree_node(SIZE) ((union tree_node *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_node(SIZE) ((union tree_node *)(ggc_internal_cleared_alloc_stat (SIZE MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_node(SIZE, n) ((union tree_node *)(ggc_internal_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_node(SIZE, n) ((union tree_node *)(ggc_internal_cleared_vec_alloc_stat (SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_node(SIZE, z) ((union tree_node *)(ggc_internal_zone_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_node(SIZE, z) ((union tree_node *)(ggc_internal_zone_cleared_alloc_stat (z, SIZE MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_tree_node(SIZE, n, z) ((union tree_node *)(ggc_internal_zone_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_node(SIZE, n, z) ((union tree_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, SIZE, n MEM_STAT_INFO))) +#define ggc_alloc_cpp_macro_arg() ((struct cpp_macro_arg *)(ggc_internal_alloc_stat (sizeof (struct cpp_macro_arg) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_macro_arg() ((struct cpp_macro_arg *)(ggc_internal_cleared_alloc_stat (sizeof (struct cpp_macro_arg) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_macro_arg(n) ((struct cpp_macro_arg *)(ggc_internal_vec_alloc_stat (sizeof (struct cpp_macro_arg), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_macro_arg(n) ((struct cpp_macro_arg *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cpp_macro_arg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_macro_arg(z) ((struct cpp_macro_arg *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cpp_macro_arg) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_macro_arg(z) ((struct cpp_macro_arg *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cpp_macro_arg) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_macro_arg(n, z) ((struct cpp_macro_arg *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cpp_macro_arg), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_macro_arg(n, z) ((struct cpp_macro_arg *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cpp_macro_arg), n MEM_STAT_INFO))) +#define ggc_alloc_answer() ((struct answer *)(ggc_internal_alloc_stat (sizeof (struct answer) MEM_STAT_INFO))) +#define ggc_alloc_cleared_answer() ((struct answer *)(ggc_internal_cleared_alloc_stat (sizeof (struct answer) MEM_STAT_INFO))) +#define ggc_alloc_vec_answer(n) ((struct answer *)(ggc_internal_vec_alloc_stat (sizeof (struct answer), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_answer(n) ((struct answer *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct answer), n MEM_STAT_INFO))) +#define ggc_alloc_zone_answer(z) ((struct answer *)(ggc_internal_zone_alloc_stat (z, sizeof (struct answer) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_answer(z) ((struct answer *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct answer) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_answer(n, z) ((struct answer *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct answer), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_answer(n, z) ((struct answer *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct answer), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_macro() ((struct cpp_macro *)(ggc_internal_alloc_stat (sizeof (struct cpp_macro) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_macro() ((struct cpp_macro *)(ggc_internal_cleared_alloc_stat (sizeof (struct cpp_macro) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_macro(n) ((struct cpp_macro *)(ggc_internal_vec_alloc_stat (sizeof (struct cpp_macro), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_macro(n) ((struct cpp_macro *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cpp_macro), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_macro(z) ((struct cpp_macro *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cpp_macro) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_macro(z) ((struct cpp_macro *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cpp_macro) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_macro(n, z) ((struct cpp_macro *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cpp_macro), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_macro(n, z) ((struct cpp_macro *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cpp_macro), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_hashnode() ((struct cpp_hashnode *)(ggc_internal_alloc_stat (sizeof (struct cpp_hashnode) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_hashnode() ((struct cpp_hashnode *)(ggc_internal_cleared_alloc_stat (sizeof (struct cpp_hashnode) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_hashnode(n) ((struct cpp_hashnode *)(ggc_internal_vec_alloc_stat (sizeof (struct cpp_hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_hashnode(n) ((struct cpp_hashnode *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cpp_hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_hashnode(z) ((struct cpp_hashnode *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cpp_hashnode) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_hashnode(z) ((struct cpp_hashnode *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cpp_hashnode) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_hashnode(n, z) ((struct cpp_hashnode *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cpp_hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_hashnode(n, z) ((struct cpp_hashnode *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cpp_hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_string() ((struct cpp_string *)(ggc_internal_alloc_stat (sizeof (struct cpp_string) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_string() ((struct cpp_string *)(ggc_internal_cleared_alloc_stat (sizeof (struct cpp_string) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_string(n) ((struct cpp_string *)(ggc_internal_vec_alloc_stat (sizeof (struct cpp_string), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_string(n) ((struct cpp_string *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cpp_string), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_string(z) ((struct cpp_string *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cpp_string) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_string(z) ((struct cpp_string *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cpp_string) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_string(n, z) ((struct cpp_string *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cpp_string), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_string(n, z) ((struct cpp_string *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cpp_string), n MEM_STAT_INFO))) +#define ggc_alloc_cpp_token() ((struct cpp_token *)(ggc_internal_alloc_stat (sizeof (struct cpp_token) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cpp_token() ((struct cpp_token *)(ggc_internal_cleared_alloc_stat (sizeof (struct cpp_token) MEM_STAT_INFO))) +#define ggc_alloc_vec_cpp_token(n) ((struct cpp_token *)(ggc_internal_vec_alloc_stat (sizeof (struct cpp_token), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cpp_token(n) ((struct cpp_token *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct cpp_token), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cpp_token(z) ((struct cpp_token *)(ggc_internal_zone_alloc_stat (z, sizeof (struct cpp_token) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cpp_token(z) ((struct cpp_token *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct cpp_token) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_cpp_token(n, z) ((struct cpp_token *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct cpp_token), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cpp_token(n, z) ((struct cpp_token *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct cpp_token), n MEM_STAT_INFO))) +#define ggc_alloc_line_maps() ((struct line_maps *)(ggc_internal_alloc_stat (sizeof (struct line_maps) MEM_STAT_INFO))) +#define ggc_alloc_cleared_line_maps() ((struct line_maps *)(ggc_internal_cleared_alloc_stat (sizeof (struct line_maps) MEM_STAT_INFO))) +#define ggc_alloc_vec_line_maps(n) ((struct line_maps *)(ggc_internal_vec_alloc_stat (sizeof (struct line_maps), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_line_maps(n) ((struct line_maps *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct line_maps), n MEM_STAT_INFO))) +#define ggc_alloc_zone_line_maps(z) ((struct line_maps *)(ggc_internal_zone_alloc_stat (z, sizeof (struct line_maps) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_line_maps(z) ((struct line_maps *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct line_maps) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_line_maps(n, z) ((struct line_maps *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct line_maps), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_line_maps(n, z) ((struct line_maps *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct line_maps), n MEM_STAT_INFO))) +#define ggc_alloc_line_map() ((struct line_map *)(ggc_internal_alloc_stat (sizeof (struct line_map) MEM_STAT_INFO))) +#define ggc_alloc_cleared_line_map() ((struct line_map *)(ggc_internal_cleared_alloc_stat (sizeof (struct line_map) MEM_STAT_INFO))) +#define ggc_alloc_vec_line_map(n) ((struct line_map *)(ggc_internal_vec_alloc_stat (sizeof (struct line_map), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_line_map(n) ((struct line_map *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct line_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_line_map(z) ((struct line_map *)(ggc_internal_zone_alloc_stat (z, sizeof (struct line_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_line_map(z) ((struct line_map *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (struct line_map) MEM_STAT_INFO))) +#define ggc_alloc_zone_vec_line_map(n, z) ((struct line_map *)(ggc_internal_zone_vec_alloc_stat (z, sizeof (struct line_map), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_line_map(n, z) ((struct line_map *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (struct line_map), n MEM_STAT_INFO))) + +/* Allocators for known typedefs. */ +#define ggc_alloc_c_saved_builtin() ((c_saved_builtin *)(ggc_internal_alloc_stat (sizeof (c_saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_saved_builtin() ((c_saved_builtin *)(ggc_internal_cleared_alloc_stat (sizeof (c_saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_saved_builtin(n) ((c_saved_builtin *)(ggc_internal_vec_alloc_stat (sizeof (c_saved_builtin), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_saved_builtin(n) ((c_saved_builtin *)(ggc_internal_cleared_vec_alloc_stat (sizeof (c_saved_builtin), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_saved_builtin(z) ((c_saved_builtin *)(ggc_internal_zone_alloc_stat (z, sizeof (c_saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_saved_builtin(z) ((c_saved_builtin *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (c_saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_saved_builtin(n, z) ((c_saved_builtin *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (c_saved_builtin), n MEM_STAT_INFO))) +#define ggc_alloc_c_binding_ptr() ((c_binding_ptr *)(ggc_internal_alloc_stat (sizeof (c_binding_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_binding_ptr() ((c_binding_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (c_binding_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_binding_ptr(n) ((c_binding_ptr *)(ggc_internal_vec_alloc_stat (sizeof (c_binding_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_binding_ptr(n) ((c_binding_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (c_binding_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_binding_ptr(z) ((c_binding_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (c_binding_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_binding_ptr(z) ((c_binding_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (c_binding_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_binding_ptr(n, z) ((c_binding_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (c_binding_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_c_goto_bindings_p() ((c_goto_bindings_p *)(ggc_internal_alloc_stat (sizeof (c_goto_bindings_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_c_goto_bindings_p() ((c_goto_bindings_p *)(ggc_internal_cleared_alloc_stat (sizeof (c_goto_bindings_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_c_goto_bindings_p(n) ((c_goto_bindings_p *)(ggc_internal_vec_alloc_stat (sizeof (c_goto_bindings_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_c_goto_bindings_p(n) ((c_goto_bindings_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (c_goto_bindings_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_c_goto_bindings_p(z) ((c_goto_bindings_p *)(ggc_internal_zone_alloc_stat (z, sizeof (c_goto_bindings_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_c_goto_bindings_p(z) ((c_goto_bindings_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (c_goto_bindings_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_c_goto_bindings_p(n, z) ((c_goto_bindings_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (c_goto_bindings_p), n MEM_STAT_INFO))) +#define ggc_alloc_attr() ((attr *)(ggc_internal_alloc_stat (sizeof (attr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_attr() ((attr *)(ggc_internal_cleared_alloc_stat (sizeof (attr) MEM_STAT_INFO))) +#define ggc_alloc_vec_attr(n) ((attr *)(ggc_internal_vec_alloc_stat (sizeof (attr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_attr(n) ((attr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (attr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_attr(z) ((attr *)(ggc_internal_zone_alloc_stat (z, sizeof (attr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_attr(z) ((attr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (attr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_attr(n, z) ((attr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (attr), n MEM_STAT_INFO))) +#define ggc_alloc_hash() ((hash *)(ggc_internal_alloc_stat (sizeof (hash) MEM_STAT_INFO))) +#define ggc_alloc_cleared_hash() ((hash *)(ggc_internal_cleared_alloc_stat (sizeof (hash) MEM_STAT_INFO))) +#define ggc_alloc_vec_hash(n) ((hash *)(ggc_internal_vec_alloc_stat (sizeof (hash), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_hash(n) ((hash *)(ggc_internal_cleared_vec_alloc_stat (sizeof (hash), n MEM_STAT_INFO))) +#define ggc_alloc_zone_hash(z) ((hash *)(ggc_internal_zone_alloc_stat (z, sizeof (hash) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_hash(z) ((hash *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (hash) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_hash(n, z) ((hash *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (hash), n MEM_STAT_INFO))) +#define ggc_alloc_ltrans_partition() ((ltrans_partition *)(ggc_internal_alloc_stat (sizeof (ltrans_partition) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ltrans_partition() ((ltrans_partition *)(ggc_internal_cleared_alloc_stat (sizeof (ltrans_partition) MEM_STAT_INFO))) +#define ggc_alloc_vec_ltrans_partition(n) ((ltrans_partition *)(ggc_internal_vec_alloc_stat (sizeof (ltrans_partition), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ltrans_partition(n) ((ltrans_partition *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ltrans_partition), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ltrans_partition(z) ((ltrans_partition *)(ggc_internal_zone_alloc_stat (z, sizeof (ltrans_partition) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ltrans_partition(z) ((ltrans_partition *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ltrans_partition) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ltrans_partition(n, z) ((ltrans_partition *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ltrans_partition), n MEM_STAT_INFO))) +#define ggc_alloc_method_entry() ((method_entry *)(ggc_internal_alloc_stat (sizeof (method_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_method_entry() ((method_entry *)(ggc_internal_cleared_alloc_stat (sizeof (method_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_method_entry(n) ((method_entry *)(ggc_internal_vec_alloc_stat (sizeof (method_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_method_entry(n) ((method_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (method_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_method_entry(z) ((method_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (method_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_method_entry(z) ((method_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (method_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_method_entry(n, z) ((method_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (method_entry), n MEM_STAT_INFO))) +#define ggc_alloc_constant_pool() ((constant_pool *)(ggc_internal_alloc_stat (sizeof (constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constant_pool() ((constant_pool *)(ggc_internal_cleared_alloc_stat (sizeof (constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_vec_constant_pool(n) ((constant_pool *)(ggc_internal_vec_alloc_stat (sizeof (constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constant_pool(n) ((constant_pool *)(ggc_internal_cleared_vec_alloc_stat (sizeof (constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constant_pool(z) ((constant_pool *)(ggc_internal_zone_alloc_stat (z, sizeof (constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constant_pool(z) ((constant_pool *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (constant_pool) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constant_pool(n, z) ((constant_pool *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (constant_pool), n MEM_STAT_INFO))) +#define ggc_alloc_go_char_p() ((go_char_p *)(ggc_internal_alloc_stat (sizeof (go_char_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_go_char_p() ((go_char_p *)(ggc_internal_cleared_alloc_stat (sizeof (go_char_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_go_char_p(n) ((go_char_p *)(ggc_internal_vec_alloc_stat (sizeof (go_char_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_go_char_p(n) ((go_char_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (go_char_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_go_char_p(z) ((go_char_p *)(ggc_internal_zone_alloc_stat (z, sizeof (go_char_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_go_char_p(z) ((go_char_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (go_char_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_go_char_p(n, z) ((go_char_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (go_char_p), n MEM_STAT_INFO))) +#define ggc_alloc_saved_builtin() ((saved_builtin *)(ggc_internal_alloc_stat (sizeof (saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_cleared_saved_builtin() ((saved_builtin *)(ggc_internal_cleared_alloc_stat (sizeof (saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_vec_saved_builtin(n) ((saved_builtin *)(ggc_internal_vec_alloc_stat (sizeof (saved_builtin), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_saved_builtin(n) ((saved_builtin *)(ggc_internal_cleared_vec_alloc_stat (sizeof (saved_builtin), n MEM_STAT_INFO))) +#define ggc_alloc_zone_saved_builtin(z) ((saved_builtin *)(ggc_internal_zone_alloc_stat (z, sizeof (saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_saved_builtin(z) ((saved_builtin *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (saved_builtin) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_saved_builtin(n, z) ((saved_builtin *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (saved_builtin), n MEM_STAT_INFO))) +#define ggc_alloc_pending_redefinition() ((pending_redefinition *)(ggc_internal_alloc_stat (sizeof (pending_redefinition) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_redefinition() ((pending_redefinition *)(ggc_internal_cleared_alloc_stat (sizeof (pending_redefinition) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_redefinition(n) ((pending_redefinition *)(ggc_internal_vec_alloc_stat (sizeof (pending_redefinition), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_redefinition(n) ((pending_redefinition *)(ggc_internal_cleared_vec_alloc_stat (sizeof (pending_redefinition), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_redefinition(z) ((pending_redefinition *)(ggc_internal_zone_alloc_stat (z, sizeof (pending_redefinition) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_redefinition(z) ((pending_redefinition *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (pending_redefinition) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_redefinition(n, z) ((pending_redefinition *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (pending_redefinition), n MEM_STAT_INFO))) +#define ggc_alloc_pending_weak() ((pending_weak *)(ggc_internal_alloc_stat (sizeof (pending_weak) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_weak() ((pending_weak *)(ggc_internal_cleared_alloc_stat (sizeof (pending_weak) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_weak(n) ((pending_weak *)(ggc_internal_vec_alloc_stat (sizeof (pending_weak), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_weak(n) ((pending_weak *)(ggc_internal_cleared_vec_alloc_stat (sizeof (pending_weak), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_weak(z) ((pending_weak *)(ggc_internal_zone_alloc_stat (z, sizeof (pending_weak) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_weak(z) ((pending_weak *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (pending_weak) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_weak(n, z) ((pending_weak *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (pending_weak), n MEM_STAT_INFO))) +#define ggc_alloc_stmt_tree() ((stmt_tree *)(ggc_internal_alloc_stat (sizeof (stmt_tree) MEM_STAT_INFO))) +#define ggc_alloc_cleared_stmt_tree() ((stmt_tree *)(ggc_internal_cleared_alloc_stat (sizeof (stmt_tree) MEM_STAT_INFO))) +#define ggc_alloc_vec_stmt_tree(n) ((stmt_tree *)(ggc_internal_vec_alloc_stat (sizeof (stmt_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_stmt_tree(n) ((stmt_tree *)(ggc_internal_cleared_vec_alloc_stat (sizeof (stmt_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_stmt_tree(z) ((stmt_tree *)(ggc_internal_zone_alloc_stat (z, sizeof (stmt_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_stmt_tree(z) ((stmt_tree *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (stmt_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_stmt_tree(n, z) ((stmt_tree *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (stmt_tree), n MEM_STAT_INFO))) +#define ggc_alloc_tree_gc_vec() ((tree_gc_vec *)(ggc_internal_alloc_stat (sizeof (tree_gc_vec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_gc_vec() ((tree_gc_vec *)(ggc_internal_cleared_alloc_stat (sizeof (tree_gc_vec) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_gc_vec(n) ((tree_gc_vec *)(ggc_internal_vec_alloc_stat (sizeof (tree_gc_vec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_gc_vec(n) ((tree_gc_vec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (tree_gc_vec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_gc_vec(z) ((tree_gc_vec *)(ggc_internal_zone_alloc_stat (z, sizeof (tree_gc_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_gc_vec(z) ((tree_gc_vec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (tree_gc_vec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_gc_vec(n, z) ((tree_gc_vec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (tree_gc_vec), n MEM_STAT_INFO))) +#define ggc_alloc_const_char_p() ((const_char_p *)(ggc_internal_alloc_stat (sizeof (const_char_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_char_p() ((const_char_p *)(ggc_internal_cleared_alloc_stat (sizeof (const_char_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_char_p(n) ((const_char_p *)(ggc_internal_vec_alloc_stat (sizeof (const_char_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_char_p(n) ((const_char_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_char_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_char_p(z) ((const_char_p *)(ggc_internal_zone_alloc_stat (z, sizeof (const_char_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_char_p(z) ((const_char_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_char_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_char_p(n, z) ((const_char_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_char_p), n MEM_STAT_INFO))) +#define ggc_alloc_cp_unparsed_functions_entry() ((cp_unparsed_functions_entry *)(ggc_internal_alloc_stat (sizeof (cp_unparsed_functions_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_unparsed_functions_entry() ((cp_unparsed_functions_entry *)(ggc_internal_cleared_alloc_stat (sizeof (cp_unparsed_functions_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_unparsed_functions_entry(n) ((cp_unparsed_functions_entry *)(ggc_internal_vec_alloc_stat (sizeof (cp_unparsed_functions_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_unparsed_functions_entry(n) ((cp_unparsed_functions_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cp_unparsed_functions_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_unparsed_functions_entry(z) ((cp_unparsed_functions_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (cp_unparsed_functions_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_unparsed_functions_entry(z) ((cp_unparsed_functions_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cp_unparsed_functions_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_unparsed_functions_entry(n, z) ((cp_unparsed_functions_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cp_unparsed_functions_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cp_default_arg_entry() ((cp_default_arg_entry *)(ggc_internal_alloc_stat (sizeof (cp_default_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_default_arg_entry() ((cp_default_arg_entry *)(ggc_internal_cleared_alloc_stat (sizeof (cp_default_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_default_arg_entry(n) ((cp_default_arg_entry *)(ggc_internal_vec_alloc_stat (sizeof (cp_default_arg_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_default_arg_entry(n) ((cp_default_arg_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cp_default_arg_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_default_arg_entry(z) ((cp_default_arg_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (cp_default_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_default_arg_entry(z) ((cp_default_arg_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cp_default_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_default_arg_entry(n, z) ((cp_default_arg_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cp_default_arg_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cp_token_position() ((cp_token_position *)(ggc_internal_alloc_stat (sizeof (cp_token_position) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cp_token_position() ((cp_token_position *)(ggc_internal_cleared_alloc_stat (sizeof (cp_token_position) MEM_STAT_INFO))) +#define ggc_alloc_vec_cp_token_position(n) ((cp_token_position *)(ggc_internal_vec_alloc_stat (sizeof (cp_token_position), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cp_token_position(n) ((cp_token_position *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cp_token_position), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cp_token_position(z) ((cp_token_position *)(ggc_internal_zone_alloc_stat (z, sizeof (cp_token_position) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cp_token_position(z) ((cp_token_position *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cp_token_position) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cp_token_position(n, z) ((cp_token_position *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cp_token_position), n MEM_STAT_INFO))) +#define ggc_alloc_pending_attribute_p() ((pending_attribute_p *)(ggc_internal_alloc_stat (sizeof (pending_attribute_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pending_attribute_p() ((pending_attribute_p *)(ggc_internal_cleared_alloc_stat (sizeof (pending_attribute_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_pending_attribute_p(n) ((pending_attribute_p *)(ggc_internal_vec_alloc_stat (sizeof (pending_attribute_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pending_attribute_p(n) ((pending_attribute_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (pending_attribute_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pending_attribute_p(z) ((pending_attribute_p *)(ggc_internal_zone_alloc_stat (z, sizeof (pending_attribute_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pending_attribute_p(z) ((pending_attribute_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (pending_attribute_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pending_attribute_p(n, z) ((pending_attribute_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (pending_attribute_p), n MEM_STAT_INFO))) +#define ggc_alloc_incomplete_var() ((incomplete_var *)(ggc_internal_alloc_stat (sizeof (incomplete_var) MEM_STAT_INFO))) +#define ggc_alloc_cleared_incomplete_var() ((incomplete_var *)(ggc_internal_cleared_alloc_stat (sizeof (incomplete_var) MEM_STAT_INFO))) +#define ggc_alloc_vec_incomplete_var(n) ((incomplete_var *)(ggc_internal_vec_alloc_stat (sizeof (incomplete_var), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_incomplete_var(n) ((incomplete_var *)(ggc_internal_cleared_vec_alloc_stat (sizeof (incomplete_var), n MEM_STAT_INFO))) +#define ggc_alloc_zone_incomplete_var(z) ((incomplete_var *)(ggc_internal_zone_alloc_stat (z, sizeof (incomplete_var) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_incomplete_var(z) ((incomplete_var *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (incomplete_var) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_incomplete_var(n, z) ((incomplete_var *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (incomplete_var), n MEM_STAT_INFO))) +#define ggc_alloc_tree_pair_p() ((tree_pair_p *)(ggc_internal_alloc_stat (sizeof (tree_pair_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree_pair_p() ((tree_pair_p *)(ggc_internal_cleared_alloc_stat (sizeof (tree_pair_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree_pair_p(n) ((tree_pair_p *)(ggc_internal_vec_alloc_stat (sizeof (tree_pair_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree_pair_p(n) ((tree_pair_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (tree_pair_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree_pair_p(z) ((tree_pair_p *)(ggc_internal_zone_alloc_stat (z, sizeof (tree_pair_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree_pair_p(z) ((tree_pair_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (tree_pair_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree_pair_p(n, z) ((tree_pair_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (tree_pair_p), n MEM_STAT_INFO))) +#define ggc_alloc_qualified_typedef_usage_t() ((qualified_typedef_usage_t *)(ggc_internal_alloc_stat (sizeof (qualified_typedef_usage_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_qualified_typedef_usage_t() ((qualified_typedef_usage_t *)(ggc_internal_cleared_alloc_stat (sizeof (qualified_typedef_usage_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_qualified_typedef_usage_t(n) ((qualified_typedef_usage_t *)(ggc_internal_vec_alloc_stat (sizeof (qualified_typedef_usage_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_qualified_typedef_usage_t(n) ((qualified_typedef_usage_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (qualified_typedef_usage_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_qualified_typedef_usage_t(z) ((qualified_typedef_usage_t *)(ggc_internal_zone_alloc_stat (z, sizeof (qualified_typedef_usage_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_qualified_typedef_usage_t(z) ((qualified_typedef_usage_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (qualified_typedef_usage_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_qualified_typedef_usage_t(n, z) ((qualified_typedef_usage_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (qualified_typedef_usage_t), n MEM_STAT_INFO))) +#define ggc_alloc_ptrmem_cst_t() ((ptrmem_cst_t *)(ggc_internal_alloc_stat (sizeof (ptrmem_cst_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ptrmem_cst_t() ((ptrmem_cst_t *)(ggc_internal_cleared_alloc_stat (sizeof (ptrmem_cst_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_ptrmem_cst_t(n) ((ptrmem_cst_t *)(ggc_internal_vec_alloc_stat (sizeof (ptrmem_cst_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ptrmem_cst_t(n) ((ptrmem_cst_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ptrmem_cst_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ptrmem_cst_t(z) ((ptrmem_cst_t *)(ggc_internal_zone_alloc_stat (z, sizeof (ptrmem_cst_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ptrmem_cst_t(z) ((ptrmem_cst_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ptrmem_cst_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ptrmem_cst_t(n, z) ((ptrmem_cst_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ptrmem_cst_t), n MEM_STAT_INFO))) +#define ggc_alloc_template_parm_index() ((template_parm_index *)(ggc_internal_alloc_stat (sizeof (template_parm_index) MEM_STAT_INFO))) +#define ggc_alloc_cleared_template_parm_index() ((template_parm_index *)(ggc_internal_cleared_alloc_stat (sizeof (template_parm_index) MEM_STAT_INFO))) +#define ggc_alloc_vec_template_parm_index(n) ((template_parm_index *)(ggc_internal_vec_alloc_stat (sizeof (template_parm_index), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_template_parm_index(n) ((template_parm_index *)(ggc_internal_cleared_vec_alloc_stat (sizeof (template_parm_index), n MEM_STAT_INFO))) +#define ggc_alloc_zone_template_parm_index(z) ((template_parm_index *)(ggc_internal_zone_alloc_stat (z, sizeof (template_parm_index) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_template_parm_index(z) ((template_parm_index *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (template_parm_index) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_template_parm_index(n, z) ((template_parm_index *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (template_parm_index), n MEM_STAT_INFO))) +#define ggc_alloc_cxx_scope() ((cxx_scope *)(ggc_internal_alloc_stat (sizeof (cxx_scope) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cxx_scope() ((cxx_scope *)(ggc_internal_cleared_alloc_stat (sizeof (cxx_scope) MEM_STAT_INFO))) +#define ggc_alloc_vec_cxx_scope(n) ((cxx_scope *)(ggc_internal_vec_alloc_stat (sizeof (cxx_scope), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cxx_scope(n) ((cxx_scope *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cxx_scope), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cxx_scope(z) ((cxx_scope *)(ggc_internal_zone_alloc_stat (z, sizeof (cxx_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cxx_scope(z) ((cxx_scope *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cxx_scope) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cxx_scope(n, z) ((cxx_scope *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cxx_scope), n MEM_STAT_INFO))) +#define ggc_alloc_binding_entry() ((binding_entry *)(ggc_internal_alloc_stat (sizeof (binding_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_binding_entry() ((binding_entry *)(ggc_internal_cleared_alloc_stat (sizeof (binding_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_binding_entry(n) ((binding_entry *)(ggc_internal_vec_alloc_stat (sizeof (binding_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_binding_entry(n) ((binding_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (binding_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_binding_entry(z) ((binding_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (binding_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_binding_entry(z) ((binding_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (binding_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_binding_entry(n, z) ((binding_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (binding_entry), n MEM_STAT_INFO))) +#define ggc_alloc_binding_table() ((binding_table *)(ggc_internal_alloc_stat (sizeof (binding_table) MEM_STAT_INFO))) +#define ggc_alloc_cleared_binding_table() ((binding_table *)(ggc_internal_cleared_alloc_stat (sizeof (binding_table) MEM_STAT_INFO))) +#define ggc_alloc_vec_binding_table(n) ((binding_table *)(ggc_internal_vec_alloc_stat (sizeof (binding_table), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_binding_table(n) ((binding_table *)(ggc_internal_cleared_vec_alloc_stat (sizeof (binding_table), n MEM_STAT_INFO))) +#define ggc_alloc_zone_binding_table(z) ((binding_table *)(ggc_internal_zone_alloc_stat (z, sizeof (binding_table) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_binding_table(z) ((binding_table *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (binding_table) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_binding_table(n, z) ((binding_table *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (binding_table), n MEM_STAT_INFO))) +#define ggc_alloc_parm_attr() ((parm_attr *)(ggc_internal_alloc_stat (sizeof (parm_attr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_parm_attr() ((parm_attr *)(ggc_internal_cleared_alloc_stat (sizeof (parm_attr) MEM_STAT_INFO))) +#define ggc_alloc_vec_parm_attr(n) ((parm_attr *)(ggc_internal_vec_alloc_stat (sizeof (parm_attr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_parm_attr(n) ((parm_attr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (parm_attr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_parm_attr(z) ((parm_attr *)(ggc_internal_zone_alloc_stat (z, sizeof (parm_attr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_parm_attr(z) ((parm_attr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (parm_attr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_parm_attr(n, z) ((parm_attr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (parm_attr), n MEM_STAT_INFO))) +#define ggc_alloc_lto_file_decl_data_ptr() ((lto_file_decl_data_ptr *)(ggc_internal_alloc_stat (sizeof (lto_file_decl_data_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_file_decl_data_ptr() ((lto_file_decl_data_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (lto_file_decl_data_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_file_decl_data_ptr(n) ((lto_file_decl_data_ptr *)(ggc_internal_vec_alloc_stat (sizeof (lto_file_decl_data_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_file_decl_data_ptr(n) ((lto_file_decl_data_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (lto_file_decl_data_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_file_decl_data_ptr(z) ((lto_file_decl_data_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (lto_file_decl_data_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_file_decl_data_ptr(z) ((lto_file_decl_data_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (lto_file_decl_data_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_file_decl_data_ptr(n, z) ((lto_file_decl_data_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (lto_file_decl_data_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_lto_in_decl_state_ptr() ((lto_in_decl_state_ptr *)(ggc_internal_alloc_stat (sizeof (lto_in_decl_state_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_in_decl_state_ptr() ((lto_in_decl_state_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (lto_in_decl_state_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_in_decl_state_ptr(n) ((lto_in_decl_state_ptr *)(ggc_internal_vec_alloc_stat (sizeof (lto_in_decl_state_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_in_decl_state_ptr(n) ((lto_in_decl_state_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (lto_in_decl_state_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_in_decl_state_ptr(z) ((lto_in_decl_state_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (lto_in_decl_state_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_in_decl_state_ptr(z) ((lto_in_decl_state_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (lto_in_decl_state_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_in_decl_state_ptr(n, z) ((lto_in_decl_state_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (lto_in_decl_state_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_edge_args_t() ((ipa_edge_args_t *)(ggc_internal_alloc_stat (sizeof (ipa_edge_args_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_edge_args_t() ((ipa_edge_args_t *)(ggc_internal_cleared_alloc_stat (sizeof (ipa_edge_args_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_edge_args_t(n) ((ipa_edge_args_t *)(ggc_internal_vec_alloc_stat (sizeof (ipa_edge_args_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_edge_args_t(n) ((ipa_edge_args_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ipa_edge_args_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_edge_args_t(z) ((ipa_edge_args_t *)(ggc_internal_zone_alloc_stat (z, sizeof (ipa_edge_args_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_edge_args_t(z) ((ipa_edge_args_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ipa_edge_args_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_edge_args_t(n, z) ((ipa_edge_args_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ipa_edge_args_t), n MEM_STAT_INFO))) +#define ggc_alloc_lto_symtab_entry_t() ((lto_symtab_entry_t *)(ggc_internal_alloc_stat (sizeof (lto_symtab_entry_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_lto_symtab_entry_t() ((lto_symtab_entry_t *)(ggc_internal_cleared_alloc_stat (sizeof (lto_symtab_entry_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_lto_symtab_entry_t(n) ((lto_symtab_entry_t *)(ggc_internal_vec_alloc_stat (sizeof (lto_symtab_entry_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_lto_symtab_entry_t(n) ((lto_symtab_entry_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (lto_symtab_entry_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_lto_symtab_entry_t(z) ((lto_symtab_entry_t *)(ggc_internal_zone_alloc_stat (z, sizeof (lto_symtab_entry_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_lto_symtab_entry_t(z) ((lto_symtab_entry_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (lto_symtab_entry_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_lto_symtab_entry_t(n, z) ((lto_symtab_entry_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (lto_symtab_entry_t), n MEM_STAT_INFO))) +#define ggc_alloc_char_ptr() ((char_ptr *)(ggc_internal_alloc_stat (sizeof (char_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_char_ptr() ((char_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (char_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_char_ptr(n) ((char_ptr *)(ggc_internal_vec_alloc_stat (sizeof (char_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_char_ptr(n) ((char_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (char_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_char_ptr(z) ((char_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (char_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_char_ptr(z) ((char_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (char_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_char_ptr(n, z) ((char_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (char_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_use_operand_p() ((use_operand_p *)(ggc_internal_alloc_stat (sizeof (use_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_use_operand_p() ((use_operand_p *)(ggc_internal_cleared_alloc_stat (sizeof (use_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_use_operand_p(n) ((use_operand_p *)(ggc_internal_vec_alloc_stat (sizeof (use_operand_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_use_operand_p(n) ((use_operand_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (use_operand_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_use_operand_p(z) ((use_operand_p *)(ggc_internal_zone_alloc_stat (z, sizeof (use_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_use_operand_p(z) ((use_operand_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (use_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_use_operand_p(n, z) ((use_operand_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (use_operand_p), n MEM_STAT_INFO))) +#define ggc_alloc_def_operand_p() ((def_operand_p *)(ggc_internal_alloc_stat (sizeof (def_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_def_operand_p() ((def_operand_p *)(ggc_internal_cleared_alloc_stat (sizeof (def_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_def_operand_p(n) ((def_operand_p *)(ggc_internal_vec_alloc_stat (sizeof (def_operand_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_def_operand_p(n) ((def_operand_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (def_operand_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_def_operand_p(z) ((def_operand_p *)(ggc_internal_zone_alloc_stat (z, sizeof (def_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_def_operand_p(z) ((def_operand_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (def_operand_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_def_operand_p(n, z) ((def_operand_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (def_operand_p), n MEM_STAT_INFO))) +#define ggc_alloc_char_p() ((char_p *)(ggc_internal_alloc_stat (sizeof (char_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_char_p() ((char_p *)(ggc_internal_cleared_alloc_stat (sizeof (char_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_char_p(n) ((char_p *)(ggc_internal_vec_alloc_stat (sizeof (char_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_char_p(n) ((char_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (char_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_char_p(z) ((char_p *)(ggc_internal_zone_alloc_stat (z, sizeof (char_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_char_p(z) ((char_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (char_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_char_p(n, z) ((char_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (char_p), n MEM_STAT_INFO))) +#define ggc_alloc_var_ann_t() ((var_ann_t *)(ggc_internal_alloc_stat (sizeof (var_ann_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_var_ann_t() ((var_ann_t *)(ggc_internal_cleared_alloc_stat (sizeof (var_ann_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_var_ann_t(n) ((var_ann_t *)(ggc_internal_vec_alloc_stat (sizeof (var_ann_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_var_ann_t(n) ((var_ann_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (var_ann_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_var_ann_t(z) ((var_ann_t *)(ggc_internal_zone_alloc_stat (z, sizeof (var_ann_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_var_ann_t(z) ((var_ann_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (var_ann_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_var_ann_t(n, z) ((var_ann_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (var_ann_t), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_type_leader_entry() ((gimple_type_leader_entry *)(ggc_internal_alloc_stat (sizeof (gimple_type_leader_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_type_leader_entry() ((gimple_type_leader_entry *)(ggc_internal_cleared_alloc_stat (sizeof (gimple_type_leader_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_type_leader_entry(n) ((gimple_type_leader_entry *)(ggc_internal_vec_alloc_stat (sizeof (gimple_type_leader_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_type_leader_entry(n) ((gimple_type_leader_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (gimple_type_leader_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_type_leader_entry(z) ((gimple_type_leader_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (gimple_type_leader_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_type_leader_entry(z) ((gimple_type_leader_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (gimple_type_leader_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_type_leader_entry(n, z) ((gimple_type_leader_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (gimple_type_leader_entry), n MEM_STAT_INFO))) +#define ggc_alloc_const_gimple_seq_node() ((const_gimple_seq_node *)(ggc_internal_alloc_stat (sizeof (const_gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_gimple_seq_node() ((const_gimple_seq_node *)(ggc_internal_cleared_alloc_stat (sizeof (const_gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_gimple_seq_node(n) ((const_gimple_seq_node *)(ggc_internal_vec_alloc_stat (sizeof (const_gimple_seq_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_gimple_seq_node(n) ((const_gimple_seq_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_gimple_seq_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_gimple_seq_node(z) ((const_gimple_seq_node *)(ggc_internal_zone_alloc_stat (z, sizeof (const_gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_gimple_seq_node(z) ((const_gimple_seq_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_gimple_seq_node(n, z) ((const_gimple_seq_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_gimple_seq_node), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_seq_node() ((gimple_seq_node *)(ggc_internal_alloc_stat (sizeof (gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_seq_node() ((gimple_seq_node *)(ggc_internal_cleared_alloc_stat (sizeof (gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_seq_node(n) ((gimple_seq_node *)(ggc_internal_vec_alloc_stat (sizeof (gimple_seq_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_seq_node(n) ((gimple_seq_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (gimple_seq_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_seq_node(z) ((gimple_seq_node *)(ggc_internal_zone_alloc_stat (z, sizeof (gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_seq_node(z) ((gimple_seq_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (gimple_seq_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_seq_node(n, z) ((gimple_seq_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (gimple_seq_node), n MEM_STAT_INFO))) +#define ggc_alloc_function_p() ((function_p *)(ggc_internal_alloc_stat (sizeof (function_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_function_p() ((function_p *)(ggc_internal_cleared_alloc_stat (sizeof (function_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_function_p(n) ((function_p *)(ggc_internal_vec_alloc_stat (sizeof (function_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_function_p(n) ((function_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (function_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_function_p(z) ((function_p *)(ggc_internal_zone_alloc_stat (z, sizeof (function_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_function_p(z) ((function_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (function_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_function_p(n, z) ((function_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (function_p), n MEM_STAT_INFO))) +#define ggc_alloc_eh_region() ((eh_region *)(ggc_internal_alloc_stat (sizeof (eh_region) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_region() ((eh_region *)(ggc_internal_cleared_alloc_stat (sizeof (eh_region) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_region(n) ((eh_region *)(ggc_internal_vec_alloc_stat (sizeof (eh_region), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_region(n) ((eh_region *)(ggc_internal_cleared_vec_alloc_stat (sizeof (eh_region), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_region(z) ((eh_region *)(ggc_internal_zone_alloc_stat (z, sizeof (eh_region) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_region(z) ((eh_region *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (eh_region) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_region(n, z) ((eh_region *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (eh_region), n MEM_STAT_INFO))) +#define ggc_alloc_eh_catch() ((eh_catch *)(ggc_internal_alloc_stat (sizeof (eh_catch) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_catch() ((eh_catch *)(ggc_internal_cleared_alloc_stat (sizeof (eh_catch) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_catch(n) ((eh_catch *)(ggc_internal_vec_alloc_stat (sizeof (eh_catch), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_catch(n) ((eh_catch *)(ggc_internal_cleared_vec_alloc_stat (sizeof (eh_catch), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_catch(z) ((eh_catch *)(ggc_internal_zone_alloc_stat (z, sizeof (eh_catch) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_catch(z) ((eh_catch *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (eh_catch) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_catch(n, z) ((eh_catch *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (eh_catch), n MEM_STAT_INFO))) +#define ggc_alloc_eh_landing_pad() ((eh_landing_pad *)(ggc_internal_alloc_stat (sizeof (eh_landing_pad) MEM_STAT_INFO))) +#define ggc_alloc_cleared_eh_landing_pad() ((eh_landing_pad *)(ggc_internal_cleared_alloc_stat (sizeof (eh_landing_pad) MEM_STAT_INFO))) +#define ggc_alloc_vec_eh_landing_pad(n) ((eh_landing_pad *)(ggc_internal_vec_alloc_stat (sizeof (eh_landing_pad), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_eh_landing_pad(n) ((eh_landing_pad *)(ggc_internal_cleared_vec_alloc_stat (sizeof (eh_landing_pad), n MEM_STAT_INFO))) +#define ggc_alloc_zone_eh_landing_pad(z) ((eh_landing_pad *)(ggc_internal_zone_alloc_stat (z, sizeof (eh_landing_pad) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_eh_landing_pad(z) ((eh_landing_pad *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (eh_landing_pad) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_eh_landing_pad(n, z) ((eh_landing_pad *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (eh_landing_pad), n MEM_STAT_INFO))) +#define ggc_alloc_vcall_entry() ((vcall_entry *)(ggc_internal_alloc_stat (sizeof (vcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_vcall_entry() ((vcall_entry *)(ggc_internal_cleared_alloc_stat (sizeof (vcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_vcall_entry(n) ((vcall_entry *)(ggc_internal_vec_alloc_stat (sizeof (vcall_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_vcall_entry(n) ((vcall_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (vcall_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_vcall_entry(z) ((vcall_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (vcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vcall_entry(z) ((vcall_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (vcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_vcall_entry(n, z) ((vcall_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (vcall_entry), n MEM_STAT_INFO))) +#define ggc_alloc_dcall_entry() ((dcall_entry *)(ggc_internal_alloc_stat (sizeof (dcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dcall_entry() ((dcall_entry *)(ggc_internal_cleared_alloc_stat (sizeof (dcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_dcall_entry(n) ((dcall_entry *)(ggc_internal_vec_alloc_stat (sizeof (dcall_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dcall_entry(n) ((dcall_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dcall_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dcall_entry(z) ((dcall_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (dcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dcall_entry(z) ((dcall_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dcall_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dcall_entry(n, z) ((dcall_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dcall_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cached_dw_loc_list() ((cached_dw_loc_list *)(ggc_internal_alloc_stat (sizeof (cached_dw_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cached_dw_loc_list() ((cached_dw_loc_list *)(ggc_internal_cleared_alloc_stat (sizeof (cached_dw_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_cached_dw_loc_list(n) ((cached_dw_loc_list *)(ggc_internal_vec_alloc_stat (sizeof (cached_dw_loc_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cached_dw_loc_list(n) ((cached_dw_loc_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cached_dw_loc_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cached_dw_loc_list(z) ((cached_dw_loc_list *)(ggc_internal_zone_alloc_stat (z, sizeof (cached_dw_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cached_dw_loc_list(z) ((cached_dw_loc_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cached_dw_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cached_dw_loc_list(n, z) ((cached_dw_loc_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cached_dw_loc_list), n MEM_STAT_INFO))) +#define ggc_alloc_var_loc_list() ((var_loc_list *)(ggc_internal_alloc_stat (sizeof (var_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_cleared_var_loc_list() ((var_loc_list *)(ggc_internal_cleared_alloc_stat (sizeof (var_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_vec_var_loc_list(n) ((var_loc_list *)(ggc_internal_vec_alloc_stat (sizeof (var_loc_list), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_var_loc_list(n) ((var_loc_list *)(ggc_internal_cleared_vec_alloc_stat (sizeof (var_loc_list), n MEM_STAT_INFO))) +#define ggc_alloc_zone_var_loc_list(z) ((var_loc_list *)(ggc_internal_zone_alloc_stat (z, sizeof (var_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_var_loc_list(z) ((var_loc_list *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (var_loc_list) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_var_loc_list(n, z) ((var_loc_list *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (var_loc_list), n MEM_STAT_INFO))) +#define ggc_alloc_die_arg_entry() ((die_arg_entry *)(ggc_internal_alloc_stat (sizeof (die_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_die_arg_entry() ((die_arg_entry *)(ggc_internal_cleared_alloc_stat (sizeof (die_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_die_arg_entry(n) ((die_arg_entry *)(ggc_internal_vec_alloc_stat (sizeof (die_arg_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_die_arg_entry(n) ((die_arg_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (die_arg_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_die_arg_entry(z) ((die_arg_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (die_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_die_arg_entry(z) ((die_arg_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (die_arg_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_die_arg_entry(n, z) ((die_arg_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (die_arg_entry), n MEM_STAT_INFO))) +#define ggc_alloc_limbo_die_node() ((limbo_die_node *)(ggc_internal_alloc_stat (sizeof (limbo_die_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_limbo_die_node() ((limbo_die_node *)(ggc_internal_cleared_alloc_stat (sizeof (limbo_die_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_limbo_die_node(n) ((limbo_die_node *)(ggc_internal_vec_alloc_stat (sizeof (limbo_die_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_limbo_die_node(n) ((limbo_die_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (limbo_die_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_limbo_die_node(z) ((limbo_die_node *)(ggc_internal_zone_alloc_stat (z, sizeof (limbo_die_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_limbo_die_node(z) ((limbo_die_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (limbo_die_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_limbo_die_node(n, z) ((limbo_die_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (limbo_die_node), n MEM_STAT_INFO))) +#define ggc_alloc_comdat_type_node() ((comdat_type_node *)(ggc_internal_alloc_stat (sizeof (comdat_type_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_comdat_type_node() ((comdat_type_node *)(ggc_internal_cleared_alloc_stat (sizeof (comdat_type_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_comdat_type_node(n) ((comdat_type_node *)(ggc_internal_vec_alloc_stat (sizeof (comdat_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_comdat_type_node(n) ((comdat_type_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (comdat_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_comdat_type_node(z) ((comdat_type_node *)(ggc_internal_zone_alloc_stat (z, sizeof (comdat_type_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_comdat_type_node(z) ((comdat_type_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (comdat_type_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_comdat_type_node(n, z) ((comdat_type_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (comdat_type_node), n MEM_STAT_INFO))) +#define ggc_alloc_macinfo_entry() ((macinfo_entry *)(ggc_internal_alloc_stat (sizeof (macinfo_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_macinfo_entry() ((macinfo_entry *)(ggc_internal_cleared_alloc_stat (sizeof (macinfo_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_macinfo_entry(n) ((macinfo_entry *)(ggc_internal_vec_alloc_stat (sizeof (macinfo_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_macinfo_entry(n) ((macinfo_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (macinfo_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_macinfo_entry(z) ((macinfo_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (macinfo_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_macinfo_entry(z) ((macinfo_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (macinfo_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_macinfo_entry(n, z) ((macinfo_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (macinfo_entry), n MEM_STAT_INFO))) +#define ggc_alloc_pubname_entry() ((pubname_entry *)(ggc_internal_alloc_stat (sizeof (pubname_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pubname_entry() ((pubname_entry *)(ggc_internal_cleared_alloc_stat (sizeof (pubname_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_pubname_entry(n) ((pubname_entry *)(ggc_internal_vec_alloc_stat (sizeof (pubname_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pubname_entry(n) ((pubname_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (pubname_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pubname_entry(z) ((pubname_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (pubname_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pubname_entry(z) ((pubname_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (pubname_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pubname_entry(n, z) ((pubname_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (pubname_entry), n MEM_STAT_INFO))) +#define ggc_alloc_die_node() ((die_node *)(ggc_internal_alloc_stat (sizeof (die_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_die_node() ((die_node *)(ggc_internal_cleared_alloc_stat (sizeof (die_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_die_node(n) ((die_node *)(ggc_internal_vec_alloc_stat (sizeof (die_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_die_node(n) ((die_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (die_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_die_node(z) ((die_node *)(ggc_internal_zone_alloc_stat (z, sizeof (die_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_die_node(z) ((die_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (die_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_die_node(n, z) ((die_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (die_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_attr_node() ((dw_attr_node *)(ggc_internal_alloc_stat (sizeof (dw_attr_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_attr_node() ((dw_attr_node *)(ggc_internal_cleared_alloc_stat (sizeof (dw_attr_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_attr_node(n) ((dw_attr_node *)(ggc_internal_vec_alloc_stat (sizeof (dw_attr_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_attr_node(n) ((dw_attr_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_attr_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_attr_node(z) ((dw_attr_node *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_attr_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_attr_node(z) ((dw_attr_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_attr_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_attr_node(n, z) ((dw_attr_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_attr_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_separate_line_info_entry() ((dw_separate_line_info_entry *)(ggc_internal_alloc_stat (sizeof (dw_separate_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_separate_line_info_entry() ((dw_separate_line_info_entry *)(ggc_internal_cleared_alloc_stat (sizeof (dw_separate_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_separate_line_info_entry(n) ((dw_separate_line_info_entry *)(ggc_internal_vec_alloc_stat (sizeof (dw_separate_line_info_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_separate_line_info_entry(n) ((dw_separate_line_info_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_separate_line_info_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_separate_line_info_entry(z) ((dw_separate_line_info_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_separate_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_separate_line_info_entry(z) ((dw_separate_line_info_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_separate_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_separate_line_info_entry(n, z) ((dw_separate_line_info_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_separate_line_info_entry), n MEM_STAT_INFO))) +#define ggc_alloc_dw_line_info_entry() ((dw_line_info_entry *)(ggc_internal_alloc_stat (sizeof (dw_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_line_info_entry() ((dw_line_info_entry *)(ggc_internal_cleared_alloc_stat (sizeof (dw_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_line_info_entry(n) ((dw_line_info_entry *)(ggc_internal_vec_alloc_stat (sizeof (dw_line_info_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_line_info_entry(n) ((dw_line_info_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_line_info_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_line_info_entry(z) ((dw_line_info_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_line_info_entry(z) ((dw_line_info_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_line_info_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_line_info_entry(n, z) ((dw_line_info_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_line_info_entry), n MEM_STAT_INFO))) +#define ggc_alloc_comdat_type_node_ref() ((comdat_type_node_ref *)(ggc_internal_alloc_stat (sizeof (comdat_type_node_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_comdat_type_node_ref() ((comdat_type_node_ref *)(ggc_internal_cleared_alloc_stat (sizeof (comdat_type_node_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_comdat_type_node_ref(n) ((comdat_type_node_ref *)(ggc_internal_vec_alloc_stat (sizeof (comdat_type_node_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_comdat_type_node_ref(n) ((comdat_type_node_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (comdat_type_node_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_comdat_type_node_ref(z) ((comdat_type_node_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (comdat_type_node_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_comdat_type_node_ref(z) ((comdat_type_node_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (comdat_type_node_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_comdat_type_node_ref(n, z) ((comdat_type_node_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (comdat_type_node_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_ranges_by_label_ref() ((dw_ranges_by_label_ref *)(ggc_internal_alloc_stat (sizeof (dw_ranges_by_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_ranges_by_label_ref() ((dw_ranges_by_label_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_ranges_by_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_ranges_by_label_ref(n) ((dw_ranges_by_label_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_ranges_by_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_ranges_by_label_ref(n) ((dw_ranges_by_label_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_ranges_by_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_ranges_by_label_ref(z) ((dw_ranges_by_label_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_ranges_by_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_ranges_by_label_ref(z) ((dw_ranges_by_label_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_ranges_by_label_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_ranges_by_label_ref(n, z) ((dw_ranges_by_label_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_ranges_by_label_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_ranges_ref() ((dw_ranges_ref *)(ggc_internal_alloc_stat (sizeof (dw_ranges_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_ranges_ref() ((dw_ranges_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_ranges_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_ranges_ref(n) ((dw_ranges_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_ranges_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_ranges_ref(n) ((dw_ranges_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_ranges_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_ranges_ref(z) ((dw_ranges_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_ranges_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_ranges_ref(z) ((dw_ranges_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_ranges_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_ranges_ref(n, z) ((dw_ranges_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_ranges_ref), n MEM_STAT_INFO))) +#define ggc_alloc_pubname_ref() ((pubname_ref *)(ggc_internal_alloc_stat (sizeof (pubname_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_pubname_ref() ((pubname_ref *)(ggc_internal_cleared_alloc_stat (sizeof (pubname_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_pubname_ref(n) ((pubname_ref *)(ggc_internal_vec_alloc_stat (sizeof (pubname_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_pubname_ref(n) ((pubname_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (pubname_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_pubname_ref(z) ((pubname_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (pubname_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_pubname_ref(z) ((pubname_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (pubname_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_pubname_ref(n, z) ((pubname_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (pubname_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_separate_line_info_ref() ((dw_separate_line_info_ref *)(ggc_internal_alloc_stat (sizeof (dw_separate_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_separate_line_info_ref() ((dw_separate_line_info_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_separate_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_separate_line_info_ref(n) ((dw_separate_line_info_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_separate_line_info_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_separate_line_info_ref(n) ((dw_separate_line_info_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_separate_line_info_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_separate_line_info_ref(z) ((dw_separate_line_info_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_separate_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_separate_line_info_ref(z) ((dw_separate_line_info_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_separate_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_separate_line_info_ref(n, z) ((dw_separate_line_info_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_separate_line_info_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_line_info_ref() ((dw_line_info_ref *)(ggc_internal_alloc_stat (sizeof (dw_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_line_info_ref() ((dw_line_info_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_line_info_ref(n) ((dw_line_info_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_line_info_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_line_info_ref(n) ((dw_line_info_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_line_info_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_line_info_ref(z) ((dw_line_info_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_line_info_ref(z) ((dw_line_info_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_line_info_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_line_info_ref(n, z) ((dw_line_info_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_line_info_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_attr_ref() ((dw_attr_ref *)(ggc_internal_alloc_stat (sizeof (dw_attr_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_attr_ref() ((dw_attr_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_attr_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_attr_ref(n) ((dw_attr_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_attr_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_attr_ref(n) ((dw_attr_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_attr_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_attr_ref(z) ((dw_attr_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_attr_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_attr_ref(z) ((dw_attr_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_attr_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_attr_ref(n, z) ((dw_attr_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_attr_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_loc_list_node() ((dw_loc_list_node *)(ggc_internal_alloc_stat (sizeof (dw_loc_list_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_loc_list_node() ((dw_loc_list_node *)(ggc_internal_cleared_alloc_stat (sizeof (dw_loc_list_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_loc_list_node(n) ((dw_loc_list_node *)(ggc_internal_vec_alloc_stat (sizeof (dw_loc_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_loc_list_node(n) ((dw_loc_list_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_loc_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_loc_list_node(z) ((dw_loc_list_node *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_loc_list_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_loc_list_node(z) ((dw_loc_list_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_loc_list_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_loc_list_node(n, z) ((dw_loc_list_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_loc_list_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_loc_descr_node() ((dw_loc_descr_node *)(ggc_internal_alloc_stat (sizeof (dw_loc_descr_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_loc_descr_node() ((dw_loc_descr_node *)(ggc_internal_cleared_alloc_stat (sizeof (dw_loc_descr_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_loc_descr_node(n) ((dw_loc_descr_node *)(ggc_internal_vec_alloc_stat (sizeof (dw_loc_descr_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_loc_descr_node(n) ((dw_loc_descr_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_loc_descr_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_loc_descr_node(z) ((dw_loc_descr_node *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_loc_descr_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_loc_descr_node(z) ((dw_loc_descr_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_loc_descr_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_loc_descr_node(n, z) ((dw_loc_descr_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_loc_descr_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_val_node() ((dw_val_node *)(ggc_internal_alloc_stat (sizeof (dw_val_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_val_node() ((dw_val_node *)(ggc_internal_cleared_alloc_stat (sizeof (dw_val_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_val_node(n) ((dw_val_node *)(ggc_internal_vec_alloc_stat (sizeof (dw_val_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_val_node(n) ((dw_val_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_val_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_val_node(z) ((dw_val_node *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_val_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_val_node(z) ((dw_val_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_val_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_val_node(n, z) ((dw_val_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_val_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_vec_const() ((dw_vec_const *)(ggc_internal_alloc_stat (sizeof (dw_vec_const) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_vec_const() ((dw_vec_const *)(ggc_internal_cleared_alloc_stat (sizeof (dw_vec_const) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_vec_const(n) ((dw_vec_const *)(ggc_internal_vec_alloc_stat (sizeof (dw_vec_const), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_vec_const(n) ((dw_vec_const *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_vec_const), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_vec_const(z) ((dw_vec_const *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_vec_const) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_vec_const(z) ((dw_vec_const *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_vec_const) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_vec_const(n, z) ((dw_vec_const *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_vec_const), n MEM_STAT_INFO))) +#define ggc_alloc_deferred_locations() ((deferred_locations *)(ggc_internal_alloc_stat (sizeof (deferred_locations) MEM_STAT_INFO))) +#define ggc_alloc_cleared_deferred_locations() ((deferred_locations *)(ggc_internal_cleared_alloc_stat (sizeof (deferred_locations) MEM_STAT_INFO))) +#define ggc_alloc_vec_deferred_locations(n) ((deferred_locations *)(ggc_internal_vec_alloc_stat (sizeof (deferred_locations), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_deferred_locations(n) ((deferred_locations *)(ggc_internal_cleared_vec_alloc_stat (sizeof (deferred_locations), n MEM_STAT_INFO))) +#define ggc_alloc_zone_deferred_locations(z) ((deferred_locations *)(ggc_internal_zone_alloc_stat (z, sizeof (deferred_locations) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_deferred_locations(z) ((deferred_locations *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (deferred_locations) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_deferred_locations(n, z) ((deferred_locations *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (deferred_locations), n MEM_STAT_INFO))) +#define ggc_alloc_dw_loc_list_ref() ((dw_loc_list_ref *)(ggc_internal_alloc_stat (sizeof (dw_loc_list_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_loc_list_ref() ((dw_loc_list_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_loc_list_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_loc_list_ref(n) ((dw_loc_list_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_loc_list_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_loc_list_ref(n) ((dw_loc_list_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_loc_list_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_loc_list_ref(z) ((dw_loc_list_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_loc_list_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_loc_list_ref(z) ((dw_loc_list_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_loc_list_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_loc_list_ref(n, z) ((dw_loc_list_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_loc_list_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_loc_descr_ref() ((dw_loc_descr_ref *)(ggc_internal_alloc_stat (sizeof (dw_loc_descr_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_loc_descr_ref() ((dw_loc_descr_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_loc_descr_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_loc_descr_ref(n) ((dw_loc_descr_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_loc_descr_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_loc_descr_ref(n) ((dw_loc_descr_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_loc_descr_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_loc_descr_ref(z) ((dw_loc_descr_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_loc_descr_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_loc_descr_ref(z) ((dw_loc_descr_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_loc_descr_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_loc_descr_ref(n, z) ((dw_loc_descr_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_loc_descr_ref), n MEM_STAT_INFO))) +#define ggc_alloc_const_dw_die_ref() ((const_dw_die_ref *)(ggc_internal_alloc_stat (sizeof (const_dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_dw_die_ref() ((const_dw_die_ref *)(ggc_internal_cleared_alloc_stat (sizeof (const_dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_dw_die_ref(n) ((const_dw_die_ref *)(ggc_internal_vec_alloc_stat (sizeof (const_dw_die_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_dw_die_ref(n) ((const_dw_die_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_dw_die_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_dw_die_ref(z) ((const_dw_die_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (const_dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_dw_die_ref(z) ((const_dw_die_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_dw_die_ref(n, z) ((const_dw_die_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_dw_die_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_die_ref() ((dw_die_ref *)(ggc_internal_alloc_stat (sizeof (dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_die_ref() ((dw_die_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_die_ref(n) ((dw_die_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_die_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_die_ref(n) ((dw_die_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_die_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_die_ref(z) ((dw_die_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_die_ref(z) ((dw_die_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_die_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_die_ref(n, z) ((dw_die_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_die_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_val_ref() ((dw_val_ref *)(ggc_internal_alloc_stat (sizeof (dw_val_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_val_ref() ((dw_val_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_val_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_val_ref(n) ((dw_val_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_val_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_val_ref(n) ((dw_val_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_val_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_val_ref(z) ((dw_val_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_val_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_val_ref(z) ((dw_val_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_val_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_val_ref(n, z) ((dw_val_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_val_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_fde_node() ((dw_fde_node *)(ggc_internal_alloc_stat (sizeof (dw_fde_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_fde_node() ((dw_fde_node *)(ggc_internal_cleared_alloc_stat (sizeof (dw_fde_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_fde_node(n) ((dw_fde_node *)(ggc_internal_vec_alloc_stat (sizeof (dw_fde_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_fde_node(n) ((dw_fde_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_fde_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_fde_node(z) ((dw_fde_node *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_fde_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_fde_node(z) ((dw_fde_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_fde_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_fde_node(n, z) ((dw_fde_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_fde_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_cfi_node() ((dw_cfi_node *)(ggc_internal_alloc_stat (sizeof (dw_cfi_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_cfi_node() ((dw_cfi_node *)(ggc_internal_cleared_alloc_stat (sizeof (dw_cfi_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_cfi_node(n) ((dw_cfi_node *)(ggc_internal_vec_alloc_stat (sizeof (dw_cfi_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_cfi_node(n) ((dw_cfi_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_cfi_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_cfi_node(z) ((dw_cfi_node *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_cfi_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_cfi_node(z) ((dw_cfi_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_cfi_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_cfi_node(n, z) ((dw_cfi_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_cfi_node), n MEM_STAT_INFO))) +#define ggc_alloc_dw_cfi_oprnd() ((dw_cfi_oprnd *)(ggc_internal_alloc_stat (sizeof (dw_cfi_oprnd) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_cfi_oprnd() ((dw_cfi_oprnd *)(ggc_internal_cleared_alloc_stat (sizeof (dw_cfi_oprnd) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_cfi_oprnd(n) ((dw_cfi_oprnd *)(ggc_internal_vec_alloc_stat (sizeof (dw_cfi_oprnd), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_cfi_oprnd(n) ((dw_cfi_oprnd *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_cfi_oprnd), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_cfi_oprnd(z) ((dw_cfi_oprnd *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_cfi_oprnd) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_cfi_oprnd(z) ((dw_cfi_oprnd *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_cfi_oprnd) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_cfi_oprnd(n, z) ((dw_cfi_oprnd *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_cfi_oprnd), n MEM_STAT_INFO))) +#define ggc_alloc_dw_cfi_oprnd_ref() ((dw_cfi_oprnd_ref *)(ggc_internal_alloc_stat (sizeof (dw_cfi_oprnd_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_cfi_oprnd_ref() ((dw_cfi_oprnd_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_cfi_oprnd_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_cfi_oprnd_ref(n) ((dw_cfi_oprnd_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_cfi_oprnd_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_cfi_oprnd_ref(n) ((dw_cfi_oprnd_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_cfi_oprnd_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_cfi_oprnd_ref(z) ((dw_cfi_oprnd_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_cfi_oprnd_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_cfi_oprnd_ref(z) ((dw_cfi_oprnd_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_cfi_oprnd_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_cfi_oprnd_ref(n, z) ((dw_cfi_oprnd_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_cfi_oprnd_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_fde_ref() ((dw_fde_ref *)(ggc_internal_alloc_stat (sizeof (dw_fde_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_fde_ref() ((dw_fde_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_fde_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_fde_ref(n) ((dw_fde_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_fde_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_fde_ref(n) ((dw_fde_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_fde_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_fde_ref(z) ((dw_fde_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_fde_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_fde_ref(z) ((dw_fde_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_fde_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_fde_ref(n, z) ((dw_fde_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_fde_ref), n MEM_STAT_INFO))) +#define ggc_alloc_dw_cfi_ref() ((dw_cfi_ref *)(ggc_internal_alloc_stat (sizeof (dw_cfi_ref) MEM_STAT_INFO))) +#define ggc_alloc_cleared_dw_cfi_ref() ((dw_cfi_ref *)(ggc_internal_cleared_alloc_stat (sizeof (dw_cfi_ref) MEM_STAT_INFO))) +#define ggc_alloc_vec_dw_cfi_ref(n) ((dw_cfi_ref *)(ggc_internal_vec_alloc_stat (sizeof (dw_cfi_ref), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_dw_cfi_ref(n) ((dw_cfi_ref *)(ggc_internal_cleared_vec_alloc_stat (sizeof (dw_cfi_ref), n MEM_STAT_INFO))) +#define ggc_alloc_zone_dw_cfi_ref(z) ((dw_cfi_ref *)(ggc_internal_zone_alloc_stat (z, sizeof (dw_cfi_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_dw_cfi_ref(z) ((dw_cfi_ref *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (dw_cfi_ref) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_dw_cfi_ref(n, z) ((dw_cfi_ref *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (dw_cfi_ref), n MEM_STAT_INFO))) +#define ggc_alloc_alias_set_entry() ((alias_set_entry *)(ggc_internal_alloc_stat (sizeof (alias_set_entry) MEM_STAT_INFO))) +#define ggc_alloc_cleared_alias_set_entry() ((alias_set_entry *)(ggc_internal_cleared_alloc_stat (sizeof (alias_set_entry) MEM_STAT_INFO))) +#define ggc_alloc_vec_alias_set_entry(n) ((alias_set_entry *)(ggc_internal_vec_alloc_stat (sizeof (alias_set_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_alias_set_entry(n) ((alias_set_entry *)(ggc_internal_cleared_vec_alloc_stat (sizeof (alias_set_entry), n MEM_STAT_INFO))) +#define ggc_alloc_zone_alias_set_entry(z) ((alias_set_entry *)(ggc_internal_zone_alloc_stat (z, sizeof (alias_set_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_alias_set_entry(z) ((alias_set_entry *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (alias_set_entry) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_alias_set_entry(n, z) ((alias_set_entry *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (alias_set_entry), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_edge_p() ((cgraph_edge_p *)(ggc_internal_alloc_stat (sizeof (cgraph_edge_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_edge_p() ((cgraph_edge_p *)(ggc_internal_cleared_alloc_stat (sizeof (cgraph_edge_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_edge_p(n) ((cgraph_edge_p *)(ggc_internal_vec_alloc_stat (sizeof (cgraph_edge_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_edge_p(n) ((cgraph_edge_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cgraph_edge_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_edge_p(z) ((cgraph_edge_p *)(ggc_internal_zone_alloc_stat (z, sizeof (cgraph_edge_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_edge_p(z) ((cgraph_edge_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cgraph_edge_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_edge_p(n, z) ((cgraph_edge_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cgraph_edge_p), n MEM_STAT_INFO))) +#define ggc_alloc_const_varpool_node_set_element() ((const_varpool_node_set_element *)(ggc_internal_alloc_stat (sizeof (const_varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_varpool_node_set_element() ((const_varpool_node_set_element *)(ggc_internal_cleared_alloc_stat (sizeof (const_varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_varpool_node_set_element(n) ((const_varpool_node_set_element *)(ggc_internal_vec_alloc_stat (sizeof (const_varpool_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_varpool_node_set_element(n) ((const_varpool_node_set_element *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_varpool_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_varpool_node_set_element(z) ((const_varpool_node_set_element *)(ggc_internal_zone_alloc_stat (z, sizeof (const_varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_varpool_node_set_element(z) ((const_varpool_node_set_element *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_varpool_node_set_element(n, z) ((const_varpool_node_set_element *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_varpool_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_varpool_node_set_element() ((varpool_node_set_element *)(ggc_internal_alloc_stat (sizeof (varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varpool_node_set_element() ((varpool_node_set_element *)(ggc_internal_cleared_alloc_stat (sizeof (varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_vec_varpool_node_set_element(n) ((varpool_node_set_element *)(ggc_internal_vec_alloc_stat (sizeof (varpool_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varpool_node_set_element(n) ((varpool_node_set_element *)(ggc_internal_cleared_vec_alloc_stat (sizeof (varpool_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varpool_node_set_element(z) ((varpool_node_set_element *)(ggc_internal_zone_alloc_stat (z, sizeof (varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varpool_node_set_element(z) ((varpool_node_set_element *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (varpool_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varpool_node_set_element(n, z) ((varpool_node_set_element *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (varpool_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_const_cgraph_node_set_element() ((const_cgraph_node_set_element *)(ggc_internal_alloc_stat (sizeof (const_cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_cgraph_node_set_element() ((const_cgraph_node_set_element *)(ggc_internal_cleared_alloc_stat (sizeof (const_cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_cgraph_node_set_element(n) ((const_cgraph_node_set_element *)(ggc_internal_vec_alloc_stat (sizeof (const_cgraph_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_cgraph_node_set_element(n) ((const_cgraph_node_set_element *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_cgraph_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_cgraph_node_set_element(z) ((const_cgraph_node_set_element *)(ggc_internal_zone_alloc_stat (z, sizeof (const_cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_cgraph_node_set_element(z) ((const_cgraph_node_set_element *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_cgraph_node_set_element(n, z) ((const_cgraph_node_set_element *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_cgraph_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_node_set_element() ((cgraph_node_set_element *)(ggc_internal_alloc_stat (sizeof (cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_node_set_element() ((cgraph_node_set_element *)(ggc_internal_cleared_alloc_stat (sizeof (cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_node_set_element(n) ((cgraph_node_set_element *)(ggc_internal_vec_alloc_stat (sizeof (cgraph_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_node_set_element(n) ((cgraph_node_set_element *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cgraph_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_node_set_element(z) ((cgraph_node_set_element *)(ggc_internal_zone_alloc_stat (z, sizeof (cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_node_set_element(z) ((cgraph_node_set_element *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cgraph_node_set_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_node_set_element(n, z) ((cgraph_node_set_element *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cgraph_node_set_element), n MEM_STAT_INFO))) +#define ggc_alloc_varpool_node_set() ((varpool_node_set *)(ggc_internal_alloc_stat (sizeof (varpool_node_set) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varpool_node_set() ((varpool_node_set *)(ggc_internal_cleared_alloc_stat (sizeof (varpool_node_set) MEM_STAT_INFO))) +#define ggc_alloc_vec_varpool_node_set(n) ((varpool_node_set *)(ggc_internal_vec_alloc_stat (sizeof (varpool_node_set), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varpool_node_set(n) ((varpool_node_set *)(ggc_internal_cleared_vec_alloc_stat (sizeof (varpool_node_set), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varpool_node_set(z) ((varpool_node_set *)(ggc_internal_zone_alloc_stat (z, sizeof (varpool_node_set) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varpool_node_set(z) ((varpool_node_set *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (varpool_node_set) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varpool_node_set(n, z) ((varpool_node_set *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (varpool_node_set), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_node_set() ((cgraph_node_set *)(ggc_internal_alloc_stat (sizeof (cgraph_node_set) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_node_set() ((cgraph_node_set *)(ggc_internal_cleared_alloc_stat (sizeof (cgraph_node_set) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_node_set(n) ((cgraph_node_set *)(ggc_internal_vec_alloc_stat (sizeof (cgraph_node_set), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_node_set(n) ((cgraph_node_set *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cgraph_node_set), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_node_set(z) ((cgraph_node_set *)(ggc_internal_zone_alloc_stat (z, sizeof (cgraph_node_set) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_node_set(z) ((cgraph_node_set *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cgraph_node_set) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_node_set(n, z) ((cgraph_node_set *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cgraph_node_set), n MEM_STAT_INFO))) +#define ggc_alloc_varpool_node_ptr() ((varpool_node_ptr *)(ggc_internal_alloc_stat (sizeof (varpool_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_varpool_node_ptr() ((varpool_node_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (varpool_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_varpool_node_ptr(n) ((varpool_node_ptr *)(ggc_internal_vec_alloc_stat (sizeof (varpool_node_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_varpool_node_ptr(n) ((varpool_node_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (varpool_node_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_varpool_node_ptr(z) ((varpool_node_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (varpool_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_varpool_node_ptr(z) ((varpool_node_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (varpool_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_varpool_node_ptr(n, z) ((varpool_node_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (varpool_node_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cgraph_node_ptr() ((cgraph_node_ptr *)(ggc_internal_alloc_stat (sizeof (cgraph_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_cgraph_node_ptr() ((cgraph_node_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (cgraph_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_cgraph_node_ptr(n) ((cgraph_node_ptr *)(ggc_internal_vec_alloc_stat (sizeof (cgraph_node_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_cgraph_node_ptr(n) ((cgraph_node_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (cgraph_node_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_cgraph_node_ptr(z) ((cgraph_node_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (cgraph_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_cgraph_node_ptr(z) ((cgraph_node_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (cgraph_node_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_cgraph_node_ptr(n, z) ((cgraph_node_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (cgraph_node_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_replace_map_p() ((ipa_replace_map_p *)(ggc_internal_alloc_stat (sizeof (ipa_replace_map_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_replace_map_p() ((ipa_replace_map_p *)(ggc_internal_cleared_alloc_stat (sizeof (ipa_replace_map_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_replace_map_p(n) ((ipa_replace_map_p *)(ggc_internal_vec_alloc_stat (sizeof (ipa_replace_map_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_replace_map_p(n) ((ipa_replace_map_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ipa_replace_map_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_replace_map_p(z) ((ipa_replace_map_p *)(ggc_internal_zone_alloc_stat (z, sizeof (ipa_replace_map_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_replace_map_p(z) ((ipa_replace_map_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ipa_replace_map_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_replace_map_p(n, z) ((ipa_replace_map_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ipa_replace_map_p), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_ref_ptr() ((ipa_ref_ptr *)(ggc_internal_alloc_stat (sizeof (ipa_ref_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_ref_ptr() ((ipa_ref_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (ipa_ref_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_ref_ptr(n) ((ipa_ref_ptr *)(ggc_internal_vec_alloc_stat (sizeof (ipa_ref_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_ref_ptr(n) ((ipa_ref_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ipa_ref_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_ref_ptr(z) ((ipa_ref_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (ipa_ref_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_ref_ptr(z) ((ipa_ref_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ipa_ref_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_ref_ptr(n, z) ((ipa_ref_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ipa_ref_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_ipa_ref_t() ((ipa_ref_t *)(ggc_internal_alloc_stat (sizeof (ipa_ref_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ipa_ref_t() ((ipa_ref_t *)(ggc_internal_cleared_alloc_stat (sizeof (ipa_ref_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_ipa_ref_t(n) ((ipa_ref_t *)(ggc_internal_vec_alloc_stat (sizeof (ipa_ref_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ipa_ref_t(n) ((ipa_ref_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ipa_ref_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ipa_ref_t(z) ((ipa_ref_t *)(ggc_internal_zone_alloc_stat (z, sizeof (ipa_ref_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ipa_ref_t(z) ((ipa_ref_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ipa_ref_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ipa_ref_t(n, z) ((ipa_ref_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ipa_ref_t), n MEM_STAT_INFO))) +#define ggc_alloc_loop_p() ((loop_p *)(ggc_internal_alloc_stat (sizeof (loop_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_loop_p() ((loop_p *)(ggc_internal_cleared_alloc_stat (sizeof (loop_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_loop_p(n) ((loop_p *)(ggc_internal_vec_alloc_stat (sizeof (loop_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_loop_p(n) ((loop_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (loop_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_loop_p(z) ((loop_p *)(ggc_internal_zone_alloc_stat (z, sizeof (loop_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_loop_p(z) ((loop_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (loop_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_loop_p(n, z) ((loop_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (loop_p), n MEM_STAT_INFO))) +#define ggc_alloc_temp_slot_p() ((temp_slot_p *)(ggc_internal_alloc_stat (sizeof (temp_slot_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_temp_slot_p() ((temp_slot_p *)(ggc_internal_cleared_alloc_stat (sizeof (temp_slot_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_temp_slot_p(n) ((temp_slot_p *)(ggc_internal_vec_alloc_stat (sizeof (temp_slot_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_temp_slot_p(n) ((temp_slot_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (temp_slot_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_temp_slot_p(z) ((temp_slot_p *)(ggc_internal_zone_alloc_stat (z, sizeof (temp_slot_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_temp_slot_p(z) ((temp_slot_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (temp_slot_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_temp_slot_p(n, z) ((temp_slot_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (temp_slot_p), n MEM_STAT_INFO))) +#define ggc_alloc_call_site_record() ((call_site_record *)(ggc_internal_alloc_stat (sizeof (call_site_record) MEM_STAT_INFO))) +#define ggc_alloc_cleared_call_site_record() ((call_site_record *)(ggc_internal_cleared_alloc_stat (sizeof (call_site_record) MEM_STAT_INFO))) +#define ggc_alloc_vec_call_site_record(n) ((call_site_record *)(ggc_internal_vec_alloc_stat (sizeof (call_site_record), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_call_site_record(n) ((call_site_record *)(ggc_internal_cleared_vec_alloc_stat (sizeof (call_site_record), n MEM_STAT_INFO))) +#define ggc_alloc_zone_call_site_record(z) ((call_site_record *)(ggc_internal_zone_alloc_stat (z, sizeof (call_site_record) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_call_site_record(z) ((call_site_record *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (call_site_record) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_call_site_record(n, z) ((call_site_record *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (call_site_record), n MEM_STAT_INFO))) +#define ggc_alloc_hashnode() ((hashnode *)(ggc_internal_alloc_stat (sizeof (hashnode) MEM_STAT_INFO))) +#define ggc_alloc_cleared_hashnode() ((hashnode *)(ggc_internal_cleared_alloc_stat (sizeof (hashnode) MEM_STAT_INFO))) +#define ggc_alloc_vec_hashnode(n) ((hashnode *)(ggc_internal_vec_alloc_stat (sizeof (hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_hashnode(n) ((hashnode *)(ggc_internal_cleared_vec_alloc_stat (sizeof (hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_zone_hashnode(z) ((hashnode *)(ggc_internal_zone_alloc_stat (z, sizeof (hashnode) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_hashnode(z) ((hashnode *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (hashnode) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_hashnode(n, z) ((hashnode *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (hashnode), n MEM_STAT_INFO))) +#define ggc_alloc_ht_identifier_ptr() ((ht_identifier_ptr *)(ggc_internal_alloc_stat (sizeof (ht_identifier_ptr) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ht_identifier_ptr() ((ht_identifier_ptr *)(ggc_internal_cleared_alloc_stat (sizeof (ht_identifier_ptr) MEM_STAT_INFO))) +#define ggc_alloc_vec_ht_identifier_ptr(n) ((ht_identifier_ptr *)(ggc_internal_vec_alloc_stat (sizeof (ht_identifier_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ht_identifier_ptr(n) ((ht_identifier_ptr *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ht_identifier_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ht_identifier_ptr(z) ((ht_identifier_ptr *)(ggc_internal_zone_alloc_stat (z, sizeof (ht_identifier_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ht_identifier_ptr(z) ((ht_identifier_ptr *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ht_identifier_ptr) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ht_identifier_ptr(n, z) ((ht_identifier_ptr *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ht_identifier_ptr), n MEM_STAT_INFO))) +#define ggc_alloc_ssa_use_operand_t() ((ssa_use_operand_t *)(ggc_internal_alloc_stat (sizeof (ssa_use_operand_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_ssa_use_operand_t() ((ssa_use_operand_t *)(ggc_internal_cleared_alloc_stat (sizeof (ssa_use_operand_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_ssa_use_operand_t(n) ((ssa_use_operand_t *)(ggc_internal_vec_alloc_stat (sizeof (ssa_use_operand_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_ssa_use_operand_t(n) ((ssa_use_operand_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (ssa_use_operand_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_ssa_use_operand_t(z) ((ssa_use_operand_t *)(ggc_internal_zone_alloc_stat (z, sizeof (ssa_use_operand_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_ssa_use_operand_t(z) ((ssa_use_operand_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (ssa_use_operand_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_ssa_use_operand_t(n, z) ((ssa_use_operand_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (ssa_use_operand_t), n MEM_STAT_INFO))) +#define ggc_alloc_constructor_elt() ((constructor_elt *)(ggc_internal_alloc_stat (sizeof (constructor_elt) MEM_STAT_INFO))) +#define ggc_alloc_cleared_constructor_elt() ((constructor_elt *)(ggc_internal_cleared_alloc_stat (sizeof (constructor_elt) MEM_STAT_INFO))) +#define ggc_alloc_vec_constructor_elt(n) ((constructor_elt *)(ggc_internal_vec_alloc_stat (sizeof (constructor_elt), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_constructor_elt(n) ((constructor_elt *)(ggc_internal_cleared_vec_alloc_stat (sizeof (constructor_elt), n MEM_STAT_INFO))) +#define ggc_alloc_zone_constructor_elt(z) ((constructor_elt *)(ggc_internal_zone_alloc_stat (z, sizeof (constructor_elt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_constructor_elt(z) ((constructor_elt *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (constructor_elt) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_constructor_elt(n, z) ((constructor_elt *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (constructor_elt), n MEM_STAT_INFO))) +#define ggc_alloc_bitmap_head() ((bitmap_head *)(ggc_internal_alloc_stat (sizeof (bitmap_head) MEM_STAT_INFO))) +#define ggc_alloc_cleared_bitmap_head() ((bitmap_head *)(ggc_internal_cleared_alloc_stat (sizeof (bitmap_head) MEM_STAT_INFO))) +#define ggc_alloc_vec_bitmap_head(n) ((bitmap_head *)(ggc_internal_vec_alloc_stat (sizeof (bitmap_head), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_bitmap_head(n) ((bitmap_head *)(ggc_internal_cleared_vec_alloc_stat (sizeof (bitmap_head), n MEM_STAT_INFO))) +#define ggc_alloc_zone_bitmap_head(z) ((bitmap_head *)(ggc_internal_zone_alloc_stat (z, sizeof (bitmap_head) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_bitmap_head(z) ((bitmap_head *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (bitmap_head) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_bitmap_head(n, z) ((bitmap_head *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (bitmap_head), n MEM_STAT_INFO))) +#define ggc_alloc_bitmap_element() ((bitmap_element *)(ggc_internal_alloc_stat (sizeof (bitmap_element) MEM_STAT_INFO))) +#define ggc_alloc_cleared_bitmap_element() ((bitmap_element *)(ggc_internal_cleared_alloc_stat (sizeof (bitmap_element) MEM_STAT_INFO))) +#define ggc_alloc_vec_bitmap_element(n) ((bitmap_element *)(ggc_internal_vec_alloc_stat (sizeof (bitmap_element), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_bitmap_element(n) ((bitmap_element *)(ggc_internal_cleared_vec_alloc_stat (sizeof (bitmap_element), n MEM_STAT_INFO))) +#define ggc_alloc_zone_bitmap_element(z) ((bitmap_element *)(ggc_internal_zone_alloc_stat (z, sizeof (bitmap_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_bitmap_element(z) ((bitmap_element *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (bitmap_element) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_bitmap_element(n, z) ((bitmap_element *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (bitmap_element), n MEM_STAT_INFO))) +#define ggc_alloc_splay_tree() ((splay_tree *)(ggc_internal_alloc_stat (sizeof (splay_tree) MEM_STAT_INFO))) +#define ggc_alloc_cleared_splay_tree() ((splay_tree *)(ggc_internal_cleared_alloc_stat (sizeof (splay_tree) MEM_STAT_INFO))) +#define ggc_alloc_vec_splay_tree(n) ((splay_tree *)(ggc_internal_vec_alloc_stat (sizeof (splay_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_splay_tree(n) ((splay_tree *)(ggc_internal_cleared_vec_alloc_stat (sizeof (splay_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_splay_tree(z) ((splay_tree *)(ggc_internal_zone_alloc_stat (z, sizeof (splay_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_splay_tree(z) ((splay_tree *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (splay_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_splay_tree(n, z) ((splay_tree *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (splay_tree), n MEM_STAT_INFO))) +#define ggc_alloc_splay_tree_node() ((splay_tree_node *)(ggc_internal_alloc_stat (sizeof (splay_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_cleared_splay_tree_node() ((splay_tree_node *)(ggc_internal_cleared_alloc_stat (sizeof (splay_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_vec_splay_tree_node(n) ((splay_tree_node *)(ggc_internal_vec_alloc_stat (sizeof (splay_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_splay_tree_node(n) ((splay_tree_node *)(ggc_internal_cleared_vec_alloc_stat (sizeof (splay_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_zone_splay_tree_node(z) ((splay_tree_node *)(ggc_internal_zone_alloc_stat (z, sizeof (splay_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_splay_tree_node(z) ((splay_tree_node *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (splay_tree_node) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_splay_tree_node(n, z) ((splay_tree_node *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (splay_tree_node), n MEM_STAT_INFO))) +#define ggc_alloc_htab_t() ((htab_t *)(ggc_internal_alloc_stat (sizeof (htab_t) MEM_STAT_INFO))) +#define ggc_alloc_cleared_htab_t() ((htab_t *)(ggc_internal_cleared_alloc_stat (sizeof (htab_t) MEM_STAT_INFO))) +#define ggc_alloc_vec_htab_t(n) ((htab_t *)(ggc_internal_vec_alloc_stat (sizeof (htab_t), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_htab_t(n) ((htab_t *)(ggc_internal_cleared_vec_alloc_stat (sizeof (htab_t), n MEM_STAT_INFO))) +#define ggc_alloc_zone_htab_t(z) ((htab_t *)(ggc_internal_zone_alloc_stat (z, sizeof (htab_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_htab_t(z) ((htab_t *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (htab_t) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_htab_t(n, z) ((htab_t *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (htab_t), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_p() ((gimple_p *)(ggc_internal_alloc_stat (sizeof (gimple_p) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_p() ((gimple_p *)(ggc_internal_cleared_alloc_stat (sizeof (gimple_p) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_p(n) ((gimple_p *)(ggc_internal_vec_alloc_stat (sizeof (gimple_p), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_p(n) ((gimple_p *)(ggc_internal_cleared_vec_alloc_stat (sizeof (gimple_p), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_p(z) ((gimple_p *)(ggc_internal_zone_alloc_stat (z, sizeof (gimple_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_p(z) ((gimple_p *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (gimple_p) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_p(n, z) ((gimple_p *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (gimple_p), n MEM_STAT_INFO))) +#define ggc_alloc_const_basic_block() ((const_basic_block *)(ggc_internal_alloc_stat (sizeof (const_basic_block) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_basic_block() ((const_basic_block *)(ggc_internal_cleared_alloc_stat (sizeof (const_basic_block) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_basic_block(n) ((const_basic_block *)(ggc_internal_vec_alloc_stat (sizeof (const_basic_block), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_basic_block(n) ((const_basic_block *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_basic_block), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_basic_block(z) ((const_basic_block *)(ggc_internal_zone_alloc_stat (z, sizeof (const_basic_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_basic_block(z) ((const_basic_block *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_basic_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_basic_block(n, z) ((const_basic_block *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_basic_block), n MEM_STAT_INFO))) +#define ggc_alloc_basic_block() ((basic_block *)(ggc_internal_alloc_stat (sizeof (basic_block) MEM_STAT_INFO))) +#define ggc_alloc_cleared_basic_block() ((basic_block *)(ggc_internal_cleared_alloc_stat (sizeof (basic_block) MEM_STAT_INFO))) +#define ggc_alloc_vec_basic_block(n) ((basic_block *)(ggc_internal_vec_alloc_stat (sizeof (basic_block), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_basic_block(n) ((basic_block *)(ggc_internal_cleared_vec_alloc_stat (sizeof (basic_block), n MEM_STAT_INFO))) +#define ggc_alloc_zone_basic_block(z) ((basic_block *)(ggc_internal_zone_alloc_stat (z, sizeof (basic_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_basic_block(z) ((basic_block *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (basic_block) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_basic_block(n, z) ((basic_block *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (basic_block), n MEM_STAT_INFO))) +#define ggc_alloc_const_edge() ((const_edge *)(ggc_internal_alloc_stat (sizeof (const_edge) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_edge() ((const_edge *)(ggc_internal_cleared_alloc_stat (sizeof (const_edge) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_edge(n) ((const_edge *)(ggc_internal_vec_alloc_stat (sizeof (const_edge), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_edge(n) ((const_edge *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_edge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_edge(z) ((const_edge *)(ggc_internal_zone_alloc_stat (z, sizeof (const_edge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_edge(z) ((const_edge *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_edge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_edge(n, z) ((const_edge *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_edge), n MEM_STAT_INFO))) +#define ggc_alloc_edge() ((edge *)(ggc_internal_alloc_stat (sizeof (edge) MEM_STAT_INFO))) +#define ggc_alloc_cleared_edge() ((edge *)(ggc_internal_cleared_alloc_stat (sizeof (edge) MEM_STAT_INFO))) +#define ggc_alloc_vec_edge(n) ((edge *)(ggc_internal_vec_alloc_stat (sizeof (edge), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_edge(n) ((edge *)(ggc_internal_cleared_vec_alloc_stat (sizeof (edge), n MEM_STAT_INFO))) +#define ggc_alloc_zone_edge(z) ((edge *)(ggc_internal_zone_alloc_stat (z, sizeof (edge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_edge(z) ((edge *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (edge) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_edge(n, z) ((edge *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (edge), n MEM_STAT_INFO))) +#define ggc_alloc_const_gimple_seq() ((const_gimple_seq *)(ggc_internal_alloc_stat (sizeof (const_gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_gimple_seq() ((const_gimple_seq *)(ggc_internal_cleared_alloc_stat (sizeof (const_gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_gimple_seq(n) ((const_gimple_seq *)(ggc_internal_vec_alloc_stat (sizeof (const_gimple_seq), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_gimple_seq(n) ((const_gimple_seq *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_gimple_seq), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_gimple_seq(z) ((const_gimple_seq *)(ggc_internal_zone_alloc_stat (z, sizeof (const_gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_gimple_seq(z) ((const_gimple_seq *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_gimple_seq(n, z) ((const_gimple_seq *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_gimple_seq), n MEM_STAT_INFO))) +#define ggc_alloc_gimple_seq() ((gimple_seq *)(ggc_internal_alloc_stat (sizeof (gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple_seq() ((gimple_seq *)(ggc_internal_cleared_alloc_stat (sizeof (gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple_seq(n) ((gimple_seq *)(ggc_internal_vec_alloc_stat (sizeof (gimple_seq), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple_seq(n) ((gimple_seq *)(ggc_internal_cleared_vec_alloc_stat (sizeof (gimple_seq), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple_seq(z) ((gimple_seq *)(ggc_internal_zone_alloc_stat (z, sizeof (gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple_seq(z) ((gimple_seq *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (gimple_seq) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple_seq(n, z) ((gimple_seq *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (gimple_seq), n MEM_STAT_INFO))) +#define ggc_alloc_const_gimple() ((const_gimple *)(ggc_internal_alloc_stat (sizeof (const_gimple) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_gimple() ((const_gimple *)(ggc_internal_cleared_alloc_stat (sizeof (const_gimple) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_gimple(n) ((const_gimple *)(ggc_internal_vec_alloc_stat (sizeof (const_gimple), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_gimple(n) ((const_gimple *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_gimple), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_gimple(z) ((const_gimple *)(ggc_internal_zone_alloc_stat (z, sizeof (const_gimple) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_gimple(z) ((const_gimple *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_gimple) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_gimple(n, z) ((const_gimple *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_gimple), n MEM_STAT_INFO))) +#define ggc_alloc_const_tree() ((const_tree *)(ggc_internal_alloc_stat (sizeof (const_tree) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_tree() ((const_tree *)(ggc_internal_cleared_alloc_stat (sizeof (const_tree) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_tree(n) ((const_tree *)(ggc_internal_vec_alloc_stat (sizeof (const_tree), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_tree(n) ((const_tree *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_tree(z) ((const_tree *)(ggc_internal_zone_alloc_stat (z, sizeof (const_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_tree(z) ((const_tree *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_tree(n, z) ((const_tree *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_tree), n MEM_STAT_INFO))) +#define ggc_alloc_gimple() ((gimple *)(ggc_internal_alloc_stat (sizeof (gimple) MEM_STAT_INFO))) +#define ggc_alloc_cleared_gimple() ((gimple *)(ggc_internal_cleared_alloc_stat (sizeof (gimple) MEM_STAT_INFO))) +#define ggc_alloc_vec_gimple(n) ((gimple *)(ggc_internal_vec_alloc_stat (sizeof (gimple), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_gimple(n) ((gimple *)(ggc_internal_cleared_vec_alloc_stat (sizeof (gimple), n MEM_STAT_INFO))) +#define ggc_alloc_zone_gimple(z) ((gimple *)(ggc_internal_zone_alloc_stat (z, sizeof (gimple) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_gimple(z) ((gimple *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (gimple) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_gimple(n, z) ((gimple *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (gimple), n MEM_STAT_INFO))) +#define ggc_alloc_tree() ((tree *)(ggc_internal_alloc_stat (sizeof (tree) MEM_STAT_INFO))) +#define ggc_alloc_cleared_tree() ((tree *)(ggc_internal_cleared_alloc_stat (sizeof (tree) MEM_STAT_INFO))) +#define ggc_alloc_vec_tree(n) ((tree *)(ggc_internal_vec_alloc_stat (sizeof (tree), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_tree(n) ((tree *)(ggc_internal_cleared_vec_alloc_stat (sizeof (tree), n MEM_STAT_INFO))) +#define ggc_alloc_zone_tree(z) ((tree *)(ggc_internal_zone_alloc_stat (z, sizeof (tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_tree(z) ((tree *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (tree) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_tree(n, z) ((tree *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (tree), n MEM_STAT_INFO))) +#define ggc_alloc_const_rtvec() ((const_rtvec *)(ggc_internal_alloc_stat (sizeof (const_rtvec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_rtvec() ((const_rtvec *)(ggc_internal_cleared_alloc_stat (sizeof (const_rtvec) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_rtvec(n) ((const_rtvec *)(ggc_internal_vec_alloc_stat (sizeof (const_rtvec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_rtvec(n) ((const_rtvec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_rtvec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_rtvec(z) ((const_rtvec *)(ggc_internal_zone_alloc_stat (z, sizeof (const_rtvec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_rtvec(z) ((const_rtvec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_rtvec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_rtvec(n, z) ((const_rtvec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_rtvec), n MEM_STAT_INFO))) +#define ggc_alloc_rtvec() ((rtvec *)(ggc_internal_alloc_stat (sizeof (rtvec) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtvec() ((rtvec *)(ggc_internal_cleared_alloc_stat (sizeof (rtvec) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtvec(n) ((rtvec *)(ggc_internal_vec_alloc_stat (sizeof (rtvec), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtvec(n) ((rtvec *)(ggc_internal_cleared_vec_alloc_stat (sizeof (rtvec), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtvec(z) ((rtvec *)(ggc_internal_zone_alloc_stat (z, sizeof (rtvec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtvec(z) ((rtvec *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (rtvec) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtvec(n, z) ((rtvec *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (rtvec), n MEM_STAT_INFO))) +#define ggc_alloc_const_rtx() ((const_rtx *)(ggc_internal_alloc_stat (sizeof (const_rtx) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_rtx() ((const_rtx *)(ggc_internal_cleared_alloc_stat (sizeof (const_rtx) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_rtx(n) ((const_rtx *)(ggc_internal_vec_alloc_stat (sizeof (const_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_rtx(n) ((const_rtx *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_rtx(z) ((const_rtx *)(ggc_internal_zone_alloc_stat (z, sizeof (const_rtx) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_rtx(z) ((const_rtx *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_rtx) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_rtx(n, z) ((const_rtx *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_rtx), n MEM_STAT_INFO))) +#define ggc_alloc_rtx() ((rtx *)(ggc_internal_alloc_stat (sizeof (rtx) MEM_STAT_INFO))) +#define ggc_alloc_cleared_rtx() ((rtx *)(ggc_internal_cleared_alloc_stat (sizeof (rtx) MEM_STAT_INFO))) +#define ggc_alloc_vec_rtx(n) ((rtx *)(ggc_internal_vec_alloc_stat (sizeof (rtx), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_rtx(n) ((rtx *)(ggc_internal_cleared_vec_alloc_stat (sizeof (rtx), n MEM_STAT_INFO))) +#define ggc_alloc_zone_rtx(z) ((rtx *)(ggc_internal_zone_alloc_stat (z, sizeof (rtx) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_rtx(z) ((rtx *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (rtx) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_rtx(n, z) ((rtx *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (rtx), n MEM_STAT_INFO))) +#define ggc_alloc_const_bitmap() ((const_bitmap *)(ggc_internal_alloc_stat (sizeof (const_bitmap) MEM_STAT_INFO))) +#define ggc_alloc_cleared_const_bitmap() ((const_bitmap *)(ggc_internal_cleared_alloc_stat (sizeof (const_bitmap) MEM_STAT_INFO))) +#define ggc_alloc_vec_const_bitmap(n) ((const_bitmap *)(ggc_internal_vec_alloc_stat (sizeof (const_bitmap), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_const_bitmap(n) ((const_bitmap *)(ggc_internal_cleared_vec_alloc_stat (sizeof (const_bitmap), n MEM_STAT_INFO))) +#define ggc_alloc_zone_const_bitmap(z) ((const_bitmap *)(ggc_internal_zone_alloc_stat (z, sizeof (const_bitmap) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_const_bitmap(z) ((const_bitmap *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (const_bitmap) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_const_bitmap(n, z) ((const_bitmap *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (const_bitmap), n MEM_STAT_INFO))) +#define ggc_alloc_bitmap() ((bitmap *)(ggc_internal_alloc_stat (sizeof (bitmap) MEM_STAT_INFO))) +#define ggc_alloc_cleared_bitmap() ((bitmap *)(ggc_internal_cleared_alloc_stat (sizeof (bitmap) MEM_STAT_INFO))) +#define ggc_alloc_vec_bitmap(n) ((bitmap *)(ggc_internal_vec_alloc_stat (sizeof (bitmap), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_bitmap(n) ((bitmap *)(ggc_internal_cleared_vec_alloc_stat (sizeof (bitmap), n MEM_STAT_INFO))) +#define ggc_alloc_zone_bitmap(z) ((bitmap *)(ggc_internal_zone_alloc_stat (z, sizeof (bitmap) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_bitmap(z) ((bitmap *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (bitmap) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_bitmap(n, z) ((bitmap *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (bitmap), n MEM_STAT_INFO))) +#define ggc_alloc_PTR() ((PTR *)(ggc_internal_alloc_stat (sizeof (PTR) MEM_STAT_INFO))) +#define ggc_alloc_cleared_PTR() ((PTR *)(ggc_internal_cleared_alloc_stat (sizeof (PTR) MEM_STAT_INFO))) +#define ggc_alloc_vec_PTR(n) ((PTR *)(ggc_internal_vec_alloc_stat (sizeof (PTR), n MEM_STAT_INFO))) +#define ggc_alloc_cleared_vec_PTR(n) ((PTR *)(ggc_internal_cleared_vec_alloc_stat (sizeof (PTR), n MEM_STAT_INFO))) +#define ggc_alloc_zone_PTR(z) ((PTR *)(ggc_internal_zone_alloc_stat (z, sizeof (PTR) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_PTR(z) ((PTR *)(ggc_internal_zone_cleared_alloc_stat (z, sizeof (PTR) MEM_STAT_INFO))) +#define ggc_alloc_zone_cleared_vec_PTR(n, z) ((PTR *)(ggc_internal_zone_cleared_vec_alloc_stat (z, sizeof (PTR), n MEM_STAT_INFO))) + +/* GC marker procedures. */ +/* macros and declarations */ +#define gt_ggc_m_22VEC_c_saved_builtin_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_c_saved_builtin_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_c_saved_builtin_gc (void *); +#define gt_ggc_m_15c_inline_static(X) do { \ + if (X != NULL) gt_ggc_mx_c_inline_static (X);\ + } while (0) +extern void gt_ggc_mx_c_inline_static (void *); +#define gt_ggc_m_24VEC_c_goto_bindings_p_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_c_goto_bindings_p_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_c_goto_bindings_p_gc (void *); +#define gt_ggc_m_15c_goto_bindings(X) do { \ + if (X != NULL) gt_ggc_mx_c_goto_bindings (X);\ + } while (0) +extern void gt_ggc_mx_c_goto_bindings (void *); +#define gt_ggc_m_7c_scope(X) do { \ + if (X != NULL) gt_ggc_mx_c_scope (X);\ + } while (0) +extern void gt_ggc_mx_c_scope (void *); +#define gt_ggc_m_9c_binding(X) do { \ + if (X != NULL) gt_ggc_mx_c_binding (X);\ + } while (0) +extern void gt_ggc_mx_c_binding (void *); +#define gt_ggc_m_12c_label_vars(X) do { \ + if (X != NULL) gt_ggc_mx_c_label_vars (X);\ + } while (0) +extern void gt_ggc_mx_c_label_vars (void *); +#define gt_ggc_m_8c_parser(X) do { \ + if (X != NULL) gt_ggc_mx_c_parser (X);\ + } while (0) +extern void gt_ggc_mx_c_parser (void *); +#define gt_ggc_m_20VEC_ivarref_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_ivarref_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_ivarref_entry_gc (void *); +#define gt_ggc_m_22VEC_prot_list_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_prot_list_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_prot_list_entry_gc (void *); +#define gt_ggc_m_19VEC_msgref_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_msgref_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_msgref_entry_gc (void *); +#define gt_ggc_m_23VEC_ident_data_tuple_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_ident_data_tuple_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_ident_data_tuple_gc (void *); +#define gt_ggc_m_15interface_tuple(X) do { \ + if (X != NULL) gt_ggc_mx_interface_tuple (X);\ + } while (0) +extern void gt_ggc_mx_interface_tuple (void *); +#define gt_ggc_m_17string_descriptor(X) do { \ + if (X != NULL) gt_ggc_mx_string_descriptor (X);\ + } while (0) +extern void gt_ggc_mx_string_descriptor (void *); +#define gt_ggc_m_9imp_entry(X) do { \ + if (X != NULL) gt_ggc_mx_imp_entry (X);\ + } while (0) +extern void gt_ggc_mx_imp_entry (void *); +#define gt_ggc_m_16hashed_attribute(X) do { \ + if (X != NULL) gt_ggc_mx_hashed_attribute (X);\ + } while (0) +extern void gt_ggc_mx_hashed_attribute (void *); +#define gt_ggc_m_12hashed_entry(X) do { \ + if (X != NULL) gt_ggc_mx_hashed_entry (X);\ + } while (0) +extern void gt_ggc_mx_hashed_entry (void *); +#define gt_ggc_m_23VEC_ltrans_partition_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_ltrans_partition_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_ltrans_partition_gc (void *); +#define gt_ggc_m_20ltrans_partition_def(X) do { \ + if (X != NULL) gt_ggc_mx_ltrans_partition_def (X);\ + } while (0) +extern void gt_ggc_mx_ltrans_partition_def (void *); +#define gt_ggc_m_19VEC_method_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_method_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_method_entry_gc (void *); +#define gt_ggc_m_14type_assertion(X) do { \ + if (X != NULL) gt_ggc_mx_type_assertion (X);\ + } while (0) +extern void gt_ggc_mx_type_assertion (void *); +#define gt_ggc_m_18treetreehash_entry(X) do { \ + if (X != NULL) gt_ggc_mx_treetreehash_entry (X);\ + } while (0) +extern void gt_ggc_mx_treetreehash_entry (void *); +#define gt_ggc_m_5CPool(X) do { \ + if (X != NULL) gt_ggc_mx_CPool (X);\ + } while (0) +extern void gt_ggc_mx_CPool (void *); +#define gt_ggc_m_3JCF(X) do { \ + if (X != NULL) gt_ggc_mx_JCF (X);\ + } while (0) +extern void gt_ggc_mx_JCF (void *); +#define gt_ggc_m_17module_htab_entry(X) do { \ + if (X != NULL) gt_ggc_mx_module_htab_entry (X);\ + } while (0) +extern void gt_ggc_mx_module_htab_entry (void *); +#define gt_ggc_m_13binding_level(X) do { \ + if (X != NULL) gt_ggc_mx_binding_level (X);\ + } while (0) +extern void gt_ggc_mx_binding_level (void *); +#define gt_ggc_m_20VEC_saved_builtin_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_saved_builtin_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_saved_builtin_gc (void *); +#define gt_ggc_m_9opt_stack(X) do { \ + if (X != NULL) gt_ggc_mx_opt_stack (X);\ + } while (0) +extern void gt_ggc_mx_opt_stack (void *); +#define gt_ggc_m_27VEC_pending_redefinition_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_pending_redefinition_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_pending_redefinition_gc (void *); +#define gt_ggc_m_19VEC_pending_weak_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_pending_weak_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_pending_weak_gc (void *); +#define gt_ggc_m_11align_stack(X) do { \ + if (X != NULL) gt_ggc_mx_align_stack (X);\ + } while (0) +extern void gt_ggc_mx_align_stack (void *); +#define gt_ggc_m_18VEC_tree_gc_vec_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_tree_gc_vec_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_tree_gc_vec_gc (void *); +#define gt_ggc_m_19VEC_const_char_p_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_const_char_p_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_const_char_p_gc (void *); +#define gt_ggc_m_21pending_abstract_type(X) do { \ + if (X != NULL) gt_ggc_mx_pending_abstract_type (X);\ + } while (0) +extern void gt_ggc_mx_pending_abstract_type (void *); +#define gt_ggc_m_15VEC_tree_int_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_tree_int_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_tree_int_gc (void *); +#define gt_ggc_m_9cp_parser(X) do { \ + if (X != NULL) gt_ggc_mx_cp_parser (X);\ + } while (0) +extern void gt_ggc_mx_cp_parser (void *); +#define gt_ggc_m_34VEC_cp_unparsed_functions_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_cp_unparsed_functions_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_cp_unparsed_functions_entry_gc (void *); +#define gt_ggc_m_27VEC_cp_default_arg_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_cp_default_arg_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_cp_default_arg_entry_gc (void *); +#define gt_ggc_m_17cp_parser_context(X) do { \ + if (X != NULL) gt_ggc_mx_cp_parser_context (X);\ + } while (0) +extern void gt_ggc_mx_cp_parser_context (void *); +#define gt_ggc_m_8cp_lexer(X) do { \ + if (X != NULL) gt_ggc_mx_cp_lexer (X);\ + } while (0) +extern void gt_ggc_mx_cp_lexer (void *); +#define gt_ggc_m_10tree_check(X) do { \ + if (X != NULL) gt_ggc_mx_tree_check (X);\ + } while (0) +extern void gt_ggc_mx_tree_check (void *); +#define gt_ggc_m_14constexpr_call(X) do { \ + if (X != NULL) gt_ggc_mx_constexpr_call (X);\ + } while (0) +extern void gt_ggc_mx_constexpr_call (void *); +#define gt_ggc_m_16constexpr_fundef(X) do { \ + if (X != NULL) gt_ggc_mx_constexpr_fundef (X);\ + } while (0) +extern void gt_ggc_mx_constexpr_fundef (void *); +#define gt_ggc_m_22VEC_deferred_access_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_deferred_access_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_deferred_access_gc (void *); +#define gt_ggc_m_10spec_entry(X) do { \ + if (X != NULL) gt_ggc_mx_spec_entry (X);\ + } while (0) +extern void gt_ggc_mx_spec_entry (void *); +#define gt_ggc_m_26VEC_pending_attribute_p_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_pending_attribute_p_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_pending_attribute_p_gc (void *); +#define gt_ggc_m_17pending_attribute(X) do { \ + if (X != NULL) gt_ggc_mx_pending_attribute (X);\ + } while (0) +extern void gt_ggc_mx_pending_attribute (void *); +#define gt_ggc_m_16pending_template(X) do { \ + if (X != NULL) gt_ggc_mx_pending_template (X);\ + } while (0) +extern void gt_ggc_mx_pending_template (void *); +#define gt_ggc_m_21VEC_incomplete_var_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_incomplete_var_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_incomplete_var_gc (void *); +#define gt_ggc_m_21named_label_use_entry(X) do { \ + if (X != NULL) gt_ggc_mx_named_label_use_entry (X);\ + } while (0) +extern void gt_ggc_mx_named_label_use_entry (void *); +#define gt_ggc_m_28VEC_deferred_access_check_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_deferred_access_check_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_deferred_access_check_gc (void *); +#define gt_ggc_m_18sorted_fields_type(X) do { \ + if (X != NULL) gt_ggc_mx_sorted_fields_type (X);\ + } while (0) +extern void gt_ggc_mx_sorted_fields_type (void *); +#define gt_ggc_m_18VEC_tree_pair_s_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_tree_pair_s_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_tree_pair_s_gc (void *); +#define gt_ggc_m_17named_label_entry(X) do { \ + if (X != NULL) gt_ggc_mx_named_label_entry (X);\ + } while (0) +extern void gt_ggc_mx_named_label_entry (void *); +#define gt_ggc_m_32VEC_qualified_typedef_usage_t_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_qualified_typedef_usage_t_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_qualified_typedef_usage_t_gc (void *); +#define gt_ggc_m_14cp_token_cache(X) do { \ + if (X != NULL) gt_ggc_mx_cp_token_cache (X);\ + } while (0) +extern void gt_ggc_mx_cp_token_cache (void *); +#define gt_ggc_m_11saved_scope(X) do { \ + if (X != NULL) gt_ggc_mx_saved_scope (X);\ + } while (0) +extern void gt_ggc_mx_saved_scope (void *); +#define gt_ggc_m_16cxx_int_tree_map(X) do { \ + if (X != NULL) gt_ggc_mx_cxx_int_tree_map (X);\ + } while (0) +extern void gt_ggc_mx_cxx_int_tree_map (void *); +#define gt_ggc_m_23VEC_cp_label_binding_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_cp_label_binding_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_cp_label_binding_gc (void *); +#define gt_ggc_m_23VEC_cp_class_binding_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_cp_class_binding_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_cp_class_binding_gc (void *); +#define gt_ggc_m_24VEC_cxx_saved_binding_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_cxx_saved_binding_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_cxx_saved_binding_gc (void *); +#define gt_ggc_m_16cp_binding_level(X) do { \ + if (X != NULL) gt_ggc_mx_cp_binding_level (X);\ + } while (0) +extern void gt_ggc_mx_cp_binding_level (void *); +#define gt_ggc_m_11cxx_binding(X) do { \ + if (X != NULL) gt_ggc_mx_cxx_binding (X);\ + } while (0) +extern void gt_ggc_mx_cxx_binding (void *); +#define gt_ggc_m_15binding_entry_s(X) do { \ + if (X != NULL) gt_ggc_mx_binding_entry_s (X);\ + } while (0) +extern void gt_ggc_mx_binding_entry_s (void *); +#define gt_ggc_m_15binding_table_s(X) do { \ + if (X != NULL) gt_ggc_mx_binding_table_s (X);\ + } while (0) +extern void gt_ggc_mx_binding_table_s (void *); +#define gt_ggc_m_11tinst_level(X) do { \ + if (X != NULL) gt_ggc_mx_tinst_level (X);\ + } while (0) +extern void gt_ggc_mx_tinst_level (void *); +#define gt_ggc_m_14VEC_tinfo_s_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_tinfo_s_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_tinfo_s_gc (void *); +#define gt_ggc_m_18gnat_binding_level(X) do { \ + if (X != NULL) gt_ggc_mx_gnat_binding_level (X);\ + } while (0) +extern void gt_ggc_mx_gnat_binding_level (void *); +#define gt_ggc_m_9elab_info(X) do { \ + if (X != NULL) gt_ggc_mx_elab_info (X);\ + } while (0) +extern void gt_ggc_mx_elab_info (void *); +#define gt_ggc_m_10stmt_group(X) do { \ + if (X != NULL) gt_ggc_mx_stmt_group (X);\ + } while (0) +extern void gt_ggc_mx_stmt_group (void *); +#define gt_ggc_m_16VEC_parm_attr_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_parm_attr_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_parm_attr_gc (void *); +#define gt_ggc_m_11parm_attr_d(X) do { \ + if (X != NULL) gt_ggc_mx_parm_attr_d (X);\ + } while (0) +extern void gt_ggc_mx_parm_attr_d (void *); +#define gt_ggc_m_17lto_in_decl_state(X) do { \ + if (X != NULL) gt_ggc_mx_lto_in_decl_state (X);\ + } while (0) +extern void gt_ggc_mx_lto_in_decl_state (void *); +#define gt_ggc_m_22VEC_ipa_edge_args_t_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_ipa_edge_args_t_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_ipa_edge_args_t_gc (void *); +#define gt_ggc_m_20lto_symtab_entry_def(X) do { \ + if (X != NULL) gt_ggc_mx_lto_symtab_entry_def (X);\ + } while (0) +extern void gt_ggc_mx_lto_symtab_entry_def (void *); +#define gt_ggc_m_11heapvar_map(X) do { \ + if (X != NULL) gt_ggc_mx_heapvar_map (X);\ + } while (0) +extern void gt_ggc_mx_heapvar_map (void *); +#define gt_ggc_m_20ssa_operand_memory_d(X) do { \ + if (X != NULL) gt_ggc_mx_ssa_operand_memory_d (X);\ + } while (0) +extern void gt_ggc_mx_ssa_operand_memory_d (void *); +#define gt_ggc_m_13scev_info_str(X) do { \ + if (X != NULL) gt_ggc_mx_scev_info_str (X);\ + } while (0) +extern void gt_ggc_mx_scev_info_str (void *); +#define gt_ggc_m_24VEC_mem_addr_template_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_mem_addr_template_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_mem_addr_template_gc (void *); +#define gt_ggc_m_26gimple_type_leader_entry_s(X) do { \ + if (X != NULL) gt_ggc_mx_gimple_type_leader_entry_s (X);\ + } while (0) +extern void gt_ggc_mx_gimple_type_leader_entry_s (void *); +#define gt_ggc_m_17gimple_seq_node_d(X) do { \ + if (X != NULL) gt_ggc_mx_gimple_seq_node_d (X);\ + } while (0) +extern void gt_ggc_mx_gimple_seq_node_d (void *); +#define gt_ggc_m_9type_hash(X) do { \ + if (X != NULL) gt_ggc_mx_type_hash (X);\ + } while (0) +extern void gt_ggc_mx_type_hash (void *); +#define gt_ggc_m_16string_pool_data(X) do { \ + if (X != NULL) gt_ggc_mx_string_pool_data (X);\ + } while (0) +extern void gt_ggc_mx_string_pool_data (void *); +#define gt_ggc_m_23temp_slot_address_entry(X) do { \ + if (X != NULL) gt_ggc_mx_temp_slot_address_entry (X);\ + } while (0) +extern void gt_ggc_mx_temp_slot_address_entry (void *); +#define gt_ggc_m_15throw_stmt_node(X) do { \ + if (X != NULL) gt_ggc_mx_throw_stmt_node (X);\ + } while (0) +extern void gt_ggc_mx_throw_stmt_node (void *); +#define gt_ggc_m_21VEC_eh_landing_pad_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_eh_landing_pad_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_eh_landing_pad_gc (void *); +#define gt_ggc_m_16VEC_eh_region_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_eh_region_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_eh_region_gc (void *); +#define gt_ggc_m_10eh_catch_d(X) do { \ + if (X != NULL) gt_ggc_mx_eh_catch_d (X);\ + } while (0) +extern void gt_ggc_mx_eh_catch_d (void *); +#define gt_ggc_m_16eh_landing_pad_d(X) do { \ + if (X != NULL) gt_ggc_mx_eh_landing_pad_d (X);\ + } while (0) +extern void gt_ggc_mx_eh_landing_pad_d (void *); +#define gt_ggc_m_11eh_region_d(X) do { \ + if (X != NULL) gt_ggc_mx_eh_region_d (X);\ + } while (0) +extern void gt_ggc_mx_eh_region_d (void *); +#define gt_ggc_m_8type_ent(X) do { \ + if (X != NULL) gt_ggc_mx_type_ent (X);\ + } while (0) +extern void gt_ggc_mx_type_ent (void *); +#define gt_ggc_m_18saved_module_scope(X) do { \ + if (X != NULL) gt_ggc_mx_saved_module_scope (X);\ + } while (0) +extern void gt_ggc_mx_saved_module_scope (void *); +#define gt_ggc_m_10vcall_insn(X) do { \ + if (X != NULL) gt_ggc_mx_vcall_insn (X);\ + } while (0) +extern void gt_ggc_mx_vcall_insn (void *); +#define gt_ggc_m_18VEC_vcall_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_vcall_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_vcall_entry_gc (void *); +#define gt_ggc_m_18VEC_dcall_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_dcall_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_dcall_entry_gc (void *); +#define gt_ggc_m_22cached_dw_loc_list_def(X) do { \ + if (X != NULL) gt_ggc_mx_cached_dw_loc_list_def (X);\ + } while (0) +extern void gt_ggc_mx_cached_dw_loc_list_def (void *); +#define gt_ggc_m_16var_loc_list_def(X) do { \ + if (X != NULL) gt_ggc_mx_var_loc_list_def (X);\ + } while (0) +extern void gt_ggc_mx_var_loc_list_def (void *); +#define gt_ggc_m_12var_loc_node(X) do { \ + if (X != NULL) gt_ggc_mx_var_loc_node (X);\ + } while (0) +extern void gt_ggc_mx_var_loc_node (void *); +#define gt_ggc_m_20VEC_die_arg_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_die_arg_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_die_arg_entry_gc (void *); +#define gt_ggc_m_16limbo_die_struct(X) do { \ + if (X != NULL) gt_ggc_mx_limbo_die_struct (X);\ + } while (0) +extern void gt_ggc_mx_limbo_die_struct (void *); +#define gt_ggc_m_20VEC_macinfo_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_macinfo_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_macinfo_entry_gc (void *); +#define gt_ggc_m_20VEC_pubname_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_pubname_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_pubname_entry_gc (void *); +#define gt_ggc_m_19VEC_dw_attr_node_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_dw_attr_node_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_dw_attr_node_gc (void *); +#define gt_ggc_m_18comdat_type_struct(X) do { \ + if (X != NULL) gt_ggc_mx_comdat_type_struct (X);\ + } while (0) +extern void gt_ggc_mx_comdat_type_struct (void *); +#define gt_ggc_m_25dw_ranges_by_label_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_ranges_by_label_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_ranges_by_label_struct (void *); +#define gt_ggc_m_16dw_ranges_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_ranges_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_ranges_struct (void *); +#define gt_ggc_m_28dw_separate_line_info_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_separate_line_info_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_separate_line_info_struct (void *); +#define gt_ggc_m_19dw_line_info_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_line_info_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_line_info_struct (void *); +#define gt_ggc_m_25VEC_deferred_locations_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_deferred_locations_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_deferred_locations_gc (void *); +#define gt_ggc_m_18dw_loc_list_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_loc_list_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_loc_list_struct (void *); +#define gt_ggc_m_15dwarf_file_data(X) do { \ + if (X != NULL) gt_ggc_mx_dwarf_file_data (X);\ + } while (0) +extern void gt_ggc_mx_dwarf_file_data (void *); +#define gt_ggc_m_15queued_reg_save(X) do { \ + if (X != NULL) gt_ggc_mx_queued_reg_save (X);\ + } while (0) +extern void gt_ggc_mx_queued_reg_save (void *); +#define gt_ggc_m_20indirect_string_node(X) do { \ + if (X != NULL) gt_ggc_mx_indirect_string_node (X);\ + } while (0) +extern void gt_ggc_mx_indirect_string_node (void *); +#define gt_ggc_m_19dw_loc_descr_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_loc_descr_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_loc_descr_struct (void *); +#define gt_ggc_m_13dw_fde_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_fde_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_fde_struct (void *); +#define gt_ggc_m_13dw_cfi_struct(X) do { \ + if (X != NULL) gt_ggc_mx_dw_cfi_struct (X);\ + } while (0) +extern void gt_ggc_mx_dw_cfi_struct (void *); +#define gt_ggc_m_8typeinfo(X) do { \ + if (X != NULL) gt_ggc_mx_typeinfo (X);\ + } while (0) +extern void gt_ggc_mx_typeinfo (void *); +#define gt_ggc_m_22VEC_alias_set_entry_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_alias_set_entry_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_alias_set_entry_gc (void *); +#define gt_ggc_m_17alias_set_entry_d(X) do { \ + if (X != NULL) gt_ggc_mx_alias_set_entry_d (X);\ + } while (0) +extern void gt_ggc_mx_alias_set_entry_d (void *); +#define gt_ggc_m_24constant_descriptor_tree(X) do { \ + if (X != NULL) gt_ggc_mx_constant_descriptor_tree (X);\ + } while (0) +extern void gt_ggc_mx_constant_descriptor_tree (void *); +#define gt_ggc_m_10cgraph_sym(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_sym (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_sym (void *); +#define gt_ggc_m_15cgraph_mod_info(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_mod_info (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_mod_info (void *); +#define gt_ggc_m_15cgraph_asm_node(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_asm_node (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_asm_node (void *); +#define gt_ggc_m_25cgraph_indirect_call_info(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_indirect_call_info (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_indirect_call_info (void *); +#define gt_ggc_m_20varpool_node_set_def(X) do { \ + if (X != NULL) gt_ggc_mx_varpool_node_set_def (X);\ + } while (0) +extern void gt_ggc_mx_varpool_node_set_def (void *); +#define gt_ggc_m_28varpool_node_set_element_def(X) do { \ + if (X != NULL) gt_ggc_mx_varpool_node_set_element_def (X);\ + } while (0) +extern void gt_ggc_mx_varpool_node_set_element_def (void *); +#define gt_ggc_m_23VEC_varpool_node_ptr_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_varpool_node_ptr_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_varpool_node_ptr_gc (void *); +#define gt_ggc_m_19cgraph_node_set_def(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_node_set_def (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_node_set_def (void *); +#define gt_ggc_m_27cgraph_node_set_element_def(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_node_set_element_def (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_node_set_element_def (void *); +#define gt_ggc_m_22VEC_cgraph_node_ptr_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_cgraph_node_ptr_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_cgraph_node_ptr_gc (void *); +#define gt_ggc_m_11cgraph_edge(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_edge (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_edge (void *); +#define gt_ggc_m_24VEC_ipa_replace_map_p_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_ipa_replace_map_p_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_ipa_replace_map_p_gc (void *); +#define gt_ggc_m_15ipa_replace_map(X) do { \ + if (X != NULL) gt_ggc_mx_ipa_replace_map (X);\ + } while (0) +extern void gt_ggc_mx_ipa_replace_map (void *); +#define gt_ggc_m_18lto_file_decl_data(X) do { \ + if (X != NULL) gt_ggc_mx_lto_file_decl_data (X);\ + } while (0) +extern void gt_ggc_mx_lto_file_decl_data (void *); +#define gt_ggc_m_16VEC_ipa_ref_t_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_ipa_ref_t_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_ipa_ref_t_gc (void *); +#define gt_ggc_m_12varpool_node(X) do { \ + if (X != NULL) gt_ggc_mx_varpool_node (X);\ + } while (0) +extern void gt_ggc_mx_varpool_node (void *); +#define gt_ggc_m_11cgraph_node(X) do { \ + if (X != NULL) gt_ggc_mx_cgraph_node (X);\ + } while (0) +extern void gt_ggc_mx_cgraph_node (void *); +#define gt_ggc_m_18VEC_basic_block_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_basic_block_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_basic_block_gc (void *); +#define gt_ggc_m_14gimple_bb_info(X) do { \ + if (X != NULL) gt_ggc_mx_gimple_bb_info (X);\ + } while (0) +extern void gt_ggc_mx_gimple_bb_info (void *); +#define gt_ggc_m_11rtl_bb_info(X) do { \ + if (X != NULL) gt_ggc_mx_rtl_bb_info (X);\ + } while (0) +extern void gt_ggc_mx_rtl_bb_info (void *); +#define gt_ggc_m_11VEC_edge_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_edge_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_edge_gc (void *); +#define gt_ggc_m_13VEC_loop_p_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_loop_p_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_loop_p_gc (void *); +#define gt_ggc_m_4loop(X) do { \ + if (X != NULL) gt_ggc_mx_loop (X);\ + } while (0) +extern void gt_ggc_mx_loop (void *); +#define gt_ggc_m_9loop_exit(X) do { \ + if (X != NULL) gt_ggc_mx_loop_exit (X);\ + } while (0) +extern void gt_ggc_mx_loop_exit (void *); +#define gt_ggc_m_13nb_iter_bound(X) do { \ + if (X != NULL) gt_ggc_mx_nb_iter_bound (X);\ + } while (0) +extern void gt_ggc_mx_nb_iter_bound (void *); +#define gt_ggc_m_24types_used_by_vars_entry(X) do { \ + if (X != NULL) gt_ggc_mx_types_used_by_vars_entry (X);\ + } while (0) +extern void gt_ggc_mx_types_used_by_vars_entry (void *); +#define gt_ggc_m_17language_function(X) do { \ + if (X != NULL) gt_ggc_mx_language_function (X);\ + } while (0) +extern void gt_ggc_mx_language_function (void *); +#define gt_ggc_m_5loops(X) do { \ + if (X != NULL) gt_ggc_mx_loops (X);\ + } while (0) +extern void gt_ggc_mx_loops (void *); +#define gt_ggc_m_18control_flow_graph(X) do { \ + if (X != NULL) gt_ggc_mx_control_flow_graph (X);\ + } while (0) +extern void gt_ggc_mx_control_flow_graph (void *); +#define gt_ggc_m_9eh_status(X) do { \ + if (X != NULL) gt_ggc_mx_eh_status (X);\ + } while (0) +extern void gt_ggc_mx_eh_status (void *); +#define gt_ggc_m_11stack_usage(X) do { \ + if (X != NULL) gt_ggc_mx_stack_usage (X);\ + } while (0) +extern void gt_ggc_mx_stack_usage (void *); +#define gt_ggc_m_20initial_value_struct(X) do { \ + if (X != NULL) gt_ggc_mx_initial_value_struct (X);\ + } while (0) +extern void gt_ggc_mx_initial_value_struct (void *); +#define gt_ggc_m_11frame_space(X) do { \ + if (X != NULL) gt_ggc_mx_frame_space (X);\ + } while (0) +extern void gt_ggc_mx_frame_space (void *); +#define gt_ggc_m_17rtx_constant_pool(X) do { \ + if (X != NULL) gt_ggc_mx_rtx_constant_pool (X);\ + } while (0) +extern void gt_ggc_mx_rtx_constant_pool (void *); +#define gt_ggc_m_18VEC_temp_slot_p_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_temp_slot_p_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_temp_slot_p_gc (void *); +#define gt_ggc_m_9temp_slot(X) do { \ + if (X != NULL) gt_ggc_mx_temp_slot (X);\ + } while (0) +extern void gt_ggc_mx_temp_slot (void *); +#define gt_ggc_m_9gimple_df(X) do { \ + if (X != NULL) gt_ggc_mx_gimple_df (X);\ + } while (0) +extern void gt_ggc_mx_gimple_df (void *); +#define gt_ggc_m_23VEC_call_site_record_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_call_site_record_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_call_site_record_gc (void *); +#define gt_ggc_m_18call_site_record_d(X) do { \ + if (X != NULL) gt_ggc_mx_call_site_record_d (X);\ + } while (0) +extern void gt_ggc_mx_call_site_record_d (void *); +#define gt_ggc_m_14sequence_stack(X) do { \ + if (X != NULL) gt_ggc_mx_sequence_stack (X);\ + } while (0) +extern void gt_ggc_mx_sequence_stack (void *); +#define gt_ggc_m_13libfunc_entry(X) do { \ + if (X != NULL) gt_ggc_mx_libfunc_entry (X);\ + } while (0) +extern void gt_ggc_mx_libfunc_entry (void *); +#define gt_ggc_m_17tree_priority_map(X) do { \ + if (X != NULL) gt_ggc_mx_tree_priority_map (X);\ + } while (0) +extern void gt_ggc_mx_tree_priority_map (void *); +#define gt_ggc_m_12tree_int_map(X) do { \ + if (X != NULL) gt_ggc_mx_tree_int_map (X);\ + } while (0) +extern void gt_ggc_mx_tree_int_map (void *); +#define gt_ggc_m_13tree_decl_map(X) do { \ + if (X != NULL) gt_ggc_mx_tree_decl_map (X);\ + } while (0) +extern void gt_ggc_mx_tree_decl_map (void *); +#define gt_ggc_m_14lang_tree_node(X) do { \ + if (X != NULL) gt_ggc_mx_lang_tree_node (X);\ + } while (0) +extern void gt_ggc_mx_lang_tree_node (void *); +#define gt_ggc_m_24tree_statement_list_node(X) do { \ + if (X != NULL) gt_ggc_mx_tree_statement_list_node (X);\ + } while (0) +extern void gt_ggc_mx_tree_statement_list_node (void *); +#define gt_ggc_m_9var_ann_d(X) do { \ + if (X != NULL) gt_ggc_mx_var_ann_d (X);\ + } while (0) +extern void gt_ggc_mx_var_ann_d (void *); +#define gt_ggc_m_9lang_decl(X) do { \ + if (X != NULL) gt_ggc_mx_lang_decl (X);\ + } while (0) +extern void gt_ggc_mx_lang_decl (void *); +#define gt_ggc_m_9lang_type(X) do { \ + if (X != NULL) gt_ggc_mx_lang_type (X);\ + } while (0) +extern void gt_ggc_mx_lang_type (void *); +#define gt_ggc_m_10die_struct(X) do { \ + if (X != NULL) gt_ggc_mx_die_struct (X);\ + } while (0) +extern void gt_ggc_mx_die_struct (void *); +#define gt_ggc_m_12ptr_info_def(X) do { \ + if (X != NULL) gt_ggc_mx_ptr_info_def (X);\ + } while (0) +extern void gt_ggc_mx_ptr_info_def (void *); +#define gt_ggc_m_22VEC_constructor_elt_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_constructor_elt_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_constructor_elt_gc (void *); +#define gt_ggc_m_17VEC_alias_pair_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_alias_pair_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_alias_pair_gc (void *); +#define gt_ggc_m_8function(X) do { \ + if (X != NULL) gt_ggc_mx_function (X);\ + } while (0) +extern void gt_ggc_mx_function (void *); +#define gt_ggc_m_23constant_descriptor_rtx(X) do { \ + if (X != NULL) gt_ggc_mx_constant_descriptor_rtx (X);\ + } while (0) +extern void gt_ggc_mx_constant_descriptor_rtx (void *); +#define gt_ggc_m_11fixed_value(X) do { \ + if (X != NULL) gt_ggc_mx_fixed_value (X);\ + } while (0) +extern void gt_ggc_mx_fixed_value (void *); +#define gt_ggc_m_10real_value(X) do { \ + if (X != NULL) gt_ggc_mx_real_value (X);\ + } while (0) +extern void gt_ggc_mx_real_value (void *); +#define gt_ggc_m_12object_block(X) do { \ + if (X != NULL) gt_ggc_mx_object_block (X);\ + } while (0) +extern void gt_ggc_mx_object_block (void *); +#define gt_ggc_m_9reg_attrs(X) do { \ + if (X != NULL) gt_ggc_mx_reg_attrs (X);\ + } while (0) +extern void gt_ggc_mx_reg_attrs (void *); +#define gt_ggc_m_9mem_attrs(X) do { \ + if (X != NULL) gt_ggc_mx_mem_attrs (X);\ + } while (0) +extern void gt_ggc_mx_mem_attrs (void *); +#define gt_ggc_m_14bitmap_obstack(X) do { \ + if (X != NULL) gt_ggc_mx_bitmap_obstack (X);\ + } while (0) +extern void gt_ggc_mx_bitmap_obstack (void *); +#define gt_ggc_m_18bitmap_element_def(X) do { \ + if (X != NULL) gt_ggc_mx_bitmap_element_def (X);\ + } while (0) +extern void gt_ggc_mx_bitmap_element_def (void *); +#define gt_ggc_m_16machine_function(X) do { \ + if (X != NULL) gt_ggc_mx_machine_function (X);\ + } while (0) +extern void gt_ggc_mx_machine_function (void *); +#define gt_ggc_m_10VEC_rtx_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_rtx_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_rtx_gc (void *); +#define gt_ggc_m_13VEC_gimple_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_gimple_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_gimple_gc (void *); +#define gt_ggc_m_11VEC_tree_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_tree_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_tree_gc (void *); +#define gt_ggc_m_12VEC_uchar_gc(X) do { \ + if (X != NULL) gt_ggc_mx_VEC_uchar_gc (X);\ + } while (0) +extern void gt_ggc_mx_VEC_uchar_gc (void *); +#define gt_ggc_m_15basic_block_def(X) do { \ + if (X != NULL) gt_ggc_mx_basic_block_def (X);\ + } while (0) +extern void gt_ggc_mx_basic_block_def (void *); +#define gt_ggc_m_8edge_def(X) do { \ + if (X != NULL) gt_ggc_mx_edge_def (X);\ + } while (0) +extern void gt_ggc_mx_edge_def (void *); +#define gt_ggc_m_12gimple_seq_d(X) do { \ + if (X != NULL) gt_ggc_mx_gimple_seq_d (X);\ + } while (0) +extern void gt_ggc_mx_gimple_seq_d (void *); +#define gt_ggc_m_7section(X) do { \ + if (X != NULL) gt_ggc_mx_section (X);\ + } while (0) +extern void gt_ggc_mx_section (void *); +#define gt_ggc_m_18gimple_statement_d(X) do { \ + if (X != NULL) gt_ggc_mx_gimple_statement_d (X);\ + } while (0) +extern void gt_ggc_mx_gimple_statement_d (void *); +#define gt_ggc_m_9rtvec_def(X) do { \ + if (X != NULL) gt_ggc_mx_rtvec_def (X);\ + } while (0) +extern void gt_ggc_mx_rtvec_def (void *); +#define gt_ggc_m_7rtx_def(X) do { \ + if (X != NULL) gt_ggc_mx_rtx_def (X);\ + } while (0) +extern void gt_ggc_mx_rtx_def (void *); +#define gt_ggc_m_15bitmap_head_def(X) do { \ + if (X != NULL) gt_ggc_mx_bitmap_head_def (X);\ + } while (0) +extern void gt_ggc_mx_bitmap_head_def (void *); +#define gt_ggc_m_9tree_node(X) do { \ + if (X != NULL) gt_ggc_mx_tree_node (X);\ + } while (0) +#define gt_ggc_mx_tree_node gt_ggc_mx_lang_tree_node +#define gt_ggc_m_6answer(X) do { \ + if (X != NULL) gt_ggc_mx_answer (X);\ + } while (0) +extern void gt_ggc_mx_answer (void *); +#define gt_ggc_m_9cpp_macro(X) do { \ + if (X != NULL) gt_ggc_mx_cpp_macro (X);\ + } while (0) +extern void gt_ggc_mx_cpp_macro (void *); +#define gt_ggc_m_9cpp_token(X) do { \ + if (X != NULL) gt_ggc_mx_cpp_token (X);\ + } while (0) +extern void gt_ggc_mx_cpp_token (void *); +#define gt_ggc_m_9line_maps(X) do { \ + if (X != NULL) gt_ggc_mx_line_maps (X);\ + } while (0) +extern void gt_ggc_mx_line_maps (void *); +extern void gt_ggc_m_II17splay_tree_node_s (void *); +extern void gt_ggc_m_SP9tree_node17splay_tree_node_s (void *); +extern void gt_ggc_m_P9tree_nodeP9tree_node17splay_tree_node_s (void *); +extern void gt_ggc_m_P15interface_tuple4htab (void *); +extern void gt_ggc_m_P17string_descriptor4htab (void *); +extern void gt_ggc_m_P14type_assertion4htab (void *); +extern void gt_ggc_m_P18treetreehash_entry4htab (void *); +extern void gt_ggc_m_P17module_htab_entry4htab (void *); +extern void gt_ggc_m_P21pending_abstract_type4htab (void *); +extern void gt_ggc_m_P14constexpr_call4htab (void *); +extern void gt_ggc_m_P16constexpr_fundef4htab (void *); +extern void gt_ggc_m_P10spec_entry4htab (void *); +extern void gt_ggc_m_P16cxx_int_tree_map4htab (void *); +extern void gt_ggc_m_P17named_label_entry4htab (void *); +extern void gt_ggc_m_P17lto_in_decl_state4htab (void *); +extern void gt_ggc_m_P20lto_symtab_entry_def4htab (void *); +extern void gt_ggc_m_P11heapvar_map4htab (void *); +extern void gt_ggc_m_P9tree_nodeP9tree_node12splay_tree_s (void *); +extern void gt_ggc_m_P13scev_info_str4htab (void *); +extern void gt_ggc_m_P12tree_int_map4htab (void *); +extern void gt_ggc_m_P23constant_descriptor_rtx4htab (void *); +extern void gt_ggc_m_P24constant_descriptor_tree4htab (void *); +extern void gt_ggc_m_P12object_block4htab (void *); +extern void gt_ggc_m_P7section4htab (void *); +extern void gt_ggc_m_P17tree_priority_map4htab (void *); +extern void gt_ggc_m_P13tree_decl_map4htab (void *); +extern void gt_ggc_m_P9type_hash4htab (void *); +extern void gt_ggc_m_P23temp_slot_address_entry4htab (void *); +extern void gt_ggc_m_P15throw_stmt_node4htab (void *); +extern void gt_ggc_m_P9reg_attrs4htab (void *); +extern void gt_ggc_m_P9mem_attrs4htab (void *); +extern void gt_ggc_m_P7rtx_def4htab (void *); +extern void gt_ggc_m_P12varpool_node4htab (void *); +extern void gt_ggc_m_P10cgraph_sym4htab (void *); +extern void gt_ggc_m_P8type_ent4htab (void *); +extern void gt_ggc_m_P18saved_module_scope4htab (void *); +extern void gt_ggc_m_SP9tree_node12splay_tree_s (void *); +extern void gt_ggc_m_P10vcall_insn4htab (void *); +extern void gt_ggc_m_P22cached_dw_loc_list_def4htab (void *); +extern void gt_ggc_m_P16var_loc_list_def4htab (void *); +extern void gt_ggc_m_P10die_struct4htab (void *); +extern void gt_ggc_m_P15dwarf_file_data4htab (void *); +extern void gt_ggc_m_P20indirect_string_node4htab (void *); +extern void gt_ggc_m_P11cgraph_node4htab (void *); +extern void gt_ggc_m_II12splay_tree_s (void *); +extern void gt_ggc_m_P15cgraph_mod_info4htab (void *); +extern void gt_ggc_m_P28varpool_node_set_element_def4htab (void *); +extern void gt_ggc_m_P27cgraph_node_set_element_def4htab (void *); +extern void gt_ggc_m_P11cgraph_edge4htab (void *); +extern void gt_ggc_m_P9loop_exit4htab (void *); +extern void gt_ggc_m_P24types_used_by_vars_entry4htab (void *); +extern void gt_ggc_m_P9tree_node4htab (void *); +extern void gt_ggc_m_P13libfunc_entry4htab (void *); + +/* functions code */ + +/* PCH type-walking procedures. */ +/* macros and declarations */ +#define gt_pch_n_22VEC_c_saved_builtin_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_c_saved_builtin_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_c_saved_builtin_gc (void *); +#define gt_pch_n_15c_inline_static(X) do { \ + if (X != NULL) gt_pch_nx_c_inline_static (X);\ + } while (0) +extern void gt_pch_nx_c_inline_static (void *); +#define gt_pch_n_24VEC_c_goto_bindings_p_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_c_goto_bindings_p_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_c_goto_bindings_p_gc (void *); +#define gt_pch_n_15c_goto_bindings(X) do { \ + if (X != NULL) gt_pch_nx_c_goto_bindings (X);\ + } while (0) +extern void gt_pch_nx_c_goto_bindings (void *); +#define gt_pch_n_7c_scope(X) do { \ + if (X != NULL) gt_pch_nx_c_scope (X);\ + } while (0) +extern void gt_pch_nx_c_scope (void *); +#define gt_pch_n_9c_binding(X) do { \ + if (X != NULL) gt_pch_nx_c_binding (X);\ + } while (0) +extern void gt_pch_nx_c_binding (void *); +#define gt_pch_n_12c_label_vars(X) do { \ + if (X != NULL) gt_pch_nx_c_label_vars (X);\ + } while (0) +extern void gt_pch_nx_c_label_vars (void *); +#define gt_pch_n_8c_parser(X) do { \ + if (X != NULL) gt_pch_nx_c_parser (X);\ + } while (0) +extern void gt_pch_nx_c_parser (void *); +#define gt_pch_n_20VEC_ivarref_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_ivarref_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_ivarref_entry_gc (void *); +#define gt_pch_n_22VEC_prot_list_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_prot_list_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_prot_list_entry_gc (void *); +#define gt_pch_n_19VEC_msgref_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_msgref_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_msgref_entry_gc (void *); +#define gt_pch_n_23VEC_ident_data_tuple_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_ident_data_tuple_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_ident_data_tuple_gc (void *); +#define gt_pch_n_15interface_tuple(X) do { \ + if (X != NULL) gt_pch_nx_interface_tuple (X);\ + } while (0) +extern void gt_pch_nx_interface_tuple (void *); +#define gt_pch_n_17string_descriptor(X) do { \ + if (X != NULL) gt_pch_nx_string_descriptor (X);\ + } while (0) +extern void gt_pch_nx_string_descriptor (void *); +#define gt_pch_n_9imp_entry(X) do { \ + if (X != NULL) gt_pch_nx_imp_entry (X);\ + } while (0) +extern void gt_pch_nx_imp_entry (void *); +#define gt_pch_n_16hashed_attribute(X) do { \ + if (X != NULL) gt_pch_nx_hashed_attribute (X);\ + } while (0) +extern void gt_pch_nx_hashed_attribute (void *); +#define gt_pch_n_12hashed_entry(X) do { \ + if (X != NULL) gt_pch_nx_hashed_entry (X);\ + } while (0) +extern void gt_pch_nx_hashed_entry (void *); +#define gt_pch_n_23VEC_ltrans_partition_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_ltrans_partition_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_ltrans_partition_gc (void *); +#define gt_pch_n_20ltrans_partition_def(X) do { \ + if (X != NULL) gt_pch_nx_ltrans_partition_def (X);\ + } while (0) +extern void gt_pch_nx_ltrans_partition_def (void *); +#define gt_pch_n_19VEC_method_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_method_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_method_entry_gc (void *); +#define gt_pch_n_14type_assertion(X) do { \ + if (X != NULL) gt_pch_nx_type_assertion (X);\ + } while (0) +extern void gt_pch_nx_type_assertion (void *); +#define gt_pch_n_18treetreehash_entry(X) do { \ + if (X != NULL) gt_pch_nx_treetreehash_entry (X);\ + } while (0) +extern void gt_pch_nx_treetreehash_entry (void *); +#define gt_pch_n_5CPool(X) do { \ + if (X != NULL) gt_pch_nx_CPool (X);\ + } while (0) +extern void gt_pch_nx_CPool (void *); +#define gt_pch_n_3JCF(X) do { \ + if (X != NULL) gt_pch_nx_JCF (X);\ + } while (0) +extern void gt_pch_nx_JCF (void *); +#define gt_pch_n_17module_htab_entry(X) do { \ + if (X != NULL) gt_pch_nx_module_htab_entry (X);\ + } while (0) +extern void gt_pch_nx_module_htab_entry (void *); +#define gt_pch_n_13binding_level(X) do { \ + if (X != NULL) gt_pch_nx_binding_level (X);\ + } while (0) +extern void gt_pch_nx_binding_level (void *); +#define gt_pch_n_20VEC_saved_builtin_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_saved_builtin_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_saved_builtin_gc (void *); +#define gt_pch_n_9opt_stack(X) do { \ + if (X != NULL) gt_pch_nx_opt_stack (X);\ + } while (0) +extern void gt_pch_nx_opt_stack (void *); +#define gt_pch_n_27VEC_pending_redefinition_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_pending_redefinition_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_pending_redefinition_gc (void *); +#define gt_pch_n_19VEC_pending_weak_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_pending_weak_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_pending_weak_gc (void *); +#define gt_pch_n_11align_stack(X) do { \ + if (X != NULL) gt_pch_nx_align_stack (X);\ + } while (0) +extern void gt_pch_nx_align_stack (void *); +#define gt_pch_n_18VEC_tree_gc_vec_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_tree_gc_vec_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_tree_gc_vec_gc (void *); +#define gt_pch_n_19VEC_const_char_p_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_const_char_p_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_const_char_p_gc (void *); +#define gt_pch_n_21pending_abstract_type(X) do { \ + if (X != NULL) gt_pch_nx_pending_abstract_type (X);\ + } while (0) +extern void gt_pch_nx_pending_abstract_type (void *); +#define gt_pch_n_15VEC_tree_int_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_tree_int_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_tree_int_gc (void *); +#define gt_pch_n_9cp_parser(X) do { \ + if (X != NULL) gt_pch_nx_cp_parser (X);\ + } while (0) +extern void gt_pch_nx_cp_parser (void *); +#define gt_pch_n_34VEC_cp_unparsed_functions_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_cp_unparsed_functions_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_cp_unparsed_functions_entry_gc (void *); +#define gt_pch_n_27VEC_cp_default_arg_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_cp_default_arg_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_cp_default_arg_entry_gc (void *); +#define gt_pch_n_17cp_parser_context(X) do { \ + if (X != NULL) gt_pch_nx_cp_parser_context (X);\ + } while (0) +extern void gt_pch_nx_cp_parser_context (void *); +#define gt_pch_n_8cp_lexer(X) do { \ + if (X != NULL) gt_pch_nx_cp_lexer (X);\ + } while (0) +extern void gt_pch_nx_cp_lexer (void *); +#define gt_pch_n_10tree_check(X) do { \ + if (X != NULL) gt_pch_nx_tree_check (X);\ + } while (0) +extern void gt_pch_nx_tree_check (void *); +#define gt_pch_n_14constexpr_call(X) do { \ + if (X != NULL) gt_pch_nx_constexpr_call (X);\ + } while (0) +extern void gt_pch_nx_constexpr_call (void *); +#define gt_pch_n_16constexpr_fundef(X) do { \ + if (X != NULL) gt_pch_nx_constexpr_fundef (X);\ + } while (0) +extern void gt_pch_nx_constexpr_fundef (void *); +#define gt_pch_n_22VEC_deferred_access_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_deferred_access_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_deferred_access_gc (void *); +#define gt_pch_n_10spec_entry(X) do { \ + if (X != NULL) gt_pch_nx_spec_entry (X);\ + } while (0) +extern void gt_pch_nx_spec_entry (void *); +#define gt_pch_n_26VEC_pending_attribute_p_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_pending_attribute_p_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_pending_attribute_p_gc (void *); +#define gt_pch_n_17pending_attribute(X) do { \ + if (X != NULL) gt_pch_nx_pending_attribute (X);\ + } while (0) +extern void gt_pch_nx_pending_attribute (void *); +#define gt_pch_n_16pending_template(X) do { \ + if (X != NULL) gt_pch_nx_pending_template (X);\ + } while (0) +extern void gt_pch_nx_pending_template (void *); +#define gt_pch_n_21VEC_incomplete_var_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_incomplete_var_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_incomplete_var_gc (void *); +#define gt_pch_n_21named_label_use_entry(X) do { \ + if (X != NULL) gt_pch_nx_named_label_use_entry (X);\ + } while (0) +extern void gt_pch_nx_named_label_use_entry (void *); +#define gt_pch_n_28VEC_deferred_access_check_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_deferred_access_check_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_deferred_access_check_gc (void *); +#define gt_pch_n_18sorted_fields_type(X) do { \ + if (X != NULL) gt_pch_nx_sorted_fields_type (X);\ + } while (0) +extern void gt_pch_nx_sorted_fields_type (void *); +#define gt_pch_n_18VEC_tree_pair_s_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_tree_pair_s_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_tree_pair_s_gc (void *); +#define gt_pch_n_17named_label_entry(X) do { \ + if (X != NULL) gt_pch_nx_named_label_entry (X);\ + } while (0) +extern void gt_pch_nx_named_label_entry (void *); +#define gt_pch_n_32VEC_qualified_typedef_usage_t_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_qualified_typedef_usage_t_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_qualified_typedef_usage_t_gc (void *); +#define gt_pch_n_14cp_token_cache(X) do { \ + if (X != NULL) gt_pch_nx_cp_token_cache (X);\ + } while (0) +extern void gt_pch_nx_cp_token_cache (void *); +#define gt_pch_n_11saved_scope(X) do { \ + if (X != NULL) gt_pch_nx_saved_scope (X);\ + } while (0) +extern void gt_pch_nx_saved_scope (void *); +#define gt_pch_n_16cxx_int_tree_map(X) do { \ + if (X != NULL) gt_pch_nx_cxx_int_tree_map (X);\ + } while (0) +extern void gt_pch_nx_cxx_int_tree_map (void *); +#define gt_pch_n_23VEC_cp_label_binding_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_cp_label_binding_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_cp_label_binding_gc (void *); +#define gt_pch_n_23VEC_cp_class_binding_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_cp_class_binding_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_cp_class_binding_gc (void *); +#define gt_pch_n_24VEC_cxx_saved_binding_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_cxx_saved_binding_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_cxx_saved_binding_gc (void *); +#define gt_pch_n_16cp_binding_level(X) do { \ + if (X != NULL) gt_pch_nx_cp_binding_level (X);\ + } while (0) +extern void gt_pch_nx_cp_binding_level (void *); +#define gt_pch_n_11cxx_binding(X) do { \ + if (X != NULL) gt_pch_nx_cxx_binding (X);\ + } while (0) +extern void gt_pch_nx_cxx_binding (void *); +#define gt_pch_n_15binding_entry_s(X) do { \ + if (X != NULL) gt_pch_nx_binding_entry_s (X);\ + } while (0) +extern void gt_pch_nx_binding_entry_s (void *); +#define gt_pch_n_15binding_table_s(X) do { \ + if (X != NULL) gt_pch_nx_binding_table_s (X);\ + } while (0) +extern void gt_pch_nx_binding_table_s (void *); +#define gt_pch_n_11tinst_level(X) do { \ + if (X != NULL) gt_pch_nx_tinst_level (X);\ + } while (0) +extern void gt_pch_nx_tinst_level (void *); +#define gt_pch_n_14VEC_tinfo_s_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_tinfo_s_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_tinfo_s_gc (void *); +#define gt_pch_n_18gnat_binding_level(X) do { \ + if (X != NULL) gt_pch_nx_gnat_binding_level (X);\ + } while (0) +extern void gt_pch_nx_gnat_binding_level (void *); +#define gt_pch_n_9elab_info(X) do { \ + if (X != NULL) gt_pch_nx_elab_info (X);\ + } while (0) +extern void gt_pch_nx_elab_info (void *); +#define gt_pch_n_10stmt_group(X) do { \ + if (X != NULL) gt_pch_nx_stmt_group (X);\ + } while (0) +extern void gt_pch_nx_stmt_group (void *); +#define gt_pch_n_16VEC_parm_attr_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_parm_attr_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_parm_attr_gc (void *); +#define gt_pch_n_11parm_attr_d(X) do { \ + if (X != NULL) gt_pch_nx_parm_attr_d (X);\ + } while (0) +extern void gt_pch_nx_parm_attr_d (void *); +#define gt_pch_n_17lto_in_decl_state(X) do { \ + if (X != NULL) gt_pch_nx_lto_in_decl_state (X);\ + } while (0) +extern void gt_pch_nx_lto_in_decl_state (void *); +#define gt_pch_n_22VEC_ipa_edge_args_t_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_ipa_edge_args_t_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_ipa_edge_args_t_gc (void *); +#define gt_pch_n_20lto_symtab_entry_def(X) do { \ + if (X != NULL) gt_pch_nx_lto_symtab_entry_def (X);\ + } while (0) +extern void gt_pch_nx_lto_symtab_entry_def (void *); +#define gt_pch_n_11heapvar_map(X) do { \ + if (X != NULL) gt_pch_nx_heapvar_map (X);\ + } while (0) +extern void gt_pch_nx_heapvar_map (void *); +#define gt_pch_n_20ssa_operand_memory_d(X) do { \ + if (X != NULL) gt_pch_nx_ssa_operand_memory_d (X);\ + } while (0) +extern void gt_pch_nx_ssa_operand_memory_d (void *); +#define gt_pch_n_13scev_info_str(X) do { \ + if (X != NULL) gt_pch_nx_scev_info_str (X);\ + } while (0) +extern void gt_pch_nx_scev_info_str (void *); +#define gt_pch_n_24VEC_mem_addr_template_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_mem_addr_template_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_mem_addr_template_gc (void *); +#define gt_pch_n_26gimple_type_leader_entry_s(X) do { \ + if (X != NULL) gt_pch_nx_gimple_type_leader_entry_s (X);\ + } while (0) +extern void gt_pch_nx_gimple_type_leader_entry_s (void *); +#define gt_pch_n_17gimple_seq_node_d(X) do { \ + if (X != NULL) gt_pch_nx_gimple_seq_node_d (X);\ + } while (0) +extern void gt_pch_nx_gimple_seq_node_d (void *); +#define gt_pch_n_9type_hash(X) do { \ + if (X != NULL) gt_pch_nx_type_hash (X);\ + } while (0) +extern void gt_pch_nx_type_hash (void *); +#define gt_pch_n_16string_pool_data(X) do { \ + if (X != NULL) gt_pch_nx_string_pool_data (X);\ + } while (0) +extern void gt_pch_nx_string_pool_data (void *); +#define gt_pch_n_23temp_slot_address_entry(X) do { \ + if (X != NULL) gt_pch_nx_temp_slot_address_entry (X);\ + } while (0) +extern void gt_pch_nx_temp_slot_address_entry (void *); +#define gt_pch_n_15throw_stmt_node(X) do { \ + if (X != NULL) gt_pch_nx_throw_stmt_node (X);\ + } while (0) +extern void gt_pch_nx_throw_stmt_node (void *); +#define gt_pch_n_21VEC_eh_landing_pad_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_eh_landing_pad_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_eh_landing_pad_gc (void *); +#define gt_pch_n_16VEC_eh_region_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_eh_region_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_eh_region_gc (void *); +#define gt_pch_n_10eh_catch_d(X) do { \ + if (X != NULL) gt_pch_nx_eh_catch_d (X);\ + } while (0) +extern void gt_pch_nx_eh_catch_d (void *); +#define gt_pch_n_16eh_landing_pad_d(X) do { \ + if (X != NULL) gt_pch_nx_eh_landing_pad_d (X);\ + } while (0) +extern void gt_pch_nx_eh_landing_pad_d (void *); +#define gt_pch_n_11eh_region_d(X) do { \ + if (X != NULL) gt_pch_nx_eh_region_d (X);\ + } while (0) +extern void gt_pch_nx_eh_region_d (void *); +#define gt_pch_n_8type_ent(X) do { \ + if (X != NULL) gt_pch_nx_type_ent (X);\ + } while (0) +extern void gt_pch_nx_type_ent (void *); +#define gt_pch_n_18saved_module_scope(X) do { \ + if (X != NULL) gt_pch_nx_saved_module_scope (X);\ + } while (0) +extern void gt_pch_nx_saved_module_scope (void *); +#define gt_pch_n_10vcall_insn(X) do { \ + if (X != NULL) gt_pch_nx_vcall_insn (X);\ + } while (0) +extern void gt_pch_nx_vcall_insn (void *); +#define gt_pch_n_18VEC_vcall_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_vcall_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_vcall_entry_gc (void *); +#define gt_pch_n_18VEC_dcall_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_dcall_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_dcall_entry_gc (void *); +#define gt_pch_n_22cached_dw_loc_list_def(X) do { \ + if (X != NULL) gt_pch_nx_cached_dw_loc_list_def (X);\ + } while (0) +extern void gt_pch_nx_cached_dw_loc_list_def (void *); +#define gt_pch_n_16var_loc_list_def(X) do { \ + if (X != NULL) gt_pch_nx_var_loc_list_def (X);\ + } while (0) +extern void gt_pch_nx_var_loc_list_def (void *); +#define gt_pch_n_12var_loc_node(X) do { \ + if (X != NULL) gt_pch_nx_var_loc_node (X);\ + } while (0) +extern void gt_pch_nx_var_loc_node (void *); +#define gt_pch_n_20VEC_die_arg_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_die_arg_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_die_arg_entry_gc (void *); +#define gt_pch_n_16limbo_die_struct(X) do { \ + if (X != NULL) gt_pch_nx_limbo_die_struct (X);\ + } while (0) +extern void gt_pch_nx_limbo_die_struct (void *); +#define gt_pch_n_20VEC_macinfo_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_macinfo_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_macinfo_entry_gc (void *); +#define gt_pch_n_20VEC_pubname_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_pubname_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_pubname_entry_gc (void *); +#define gt_pch_n_19VEC_dw_attr_node_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_dw_attr_node_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_dw_attr_node_gc (void *); +#define gt_pch_n_18comdat_type_struct(X) do { \ + if (X != NULL) gt_pch_nx_comdat_type_struct (X);\ + } while (0) +extern void gt_pch_nx_comdat_type_struct (void *); +#define gt_pch_n_25dw_ranges_by_label_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_ranges_by_label_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_ranges_by_label_struct (void *); +#define gt_pch_n_16dw_ranges_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_ranges_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_ranges_struct (void *); +#define gt_pch_n_28dw_separate_line_info_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_separate_line_info_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_separate_line_info_struct (void *); +#define gt_pch_n_19dw_line_info_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_line_info_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_line_info_struct (void *); +#define gt_pch_n_25VEC_deferred_locations_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_deferred_locations_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_deferred_locations_gc (void *); +#define gt_pch_n_18dw_loc_list_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_loc_list_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_loc_list_struct (void *); +#define gt_pch_n_15dwarf_file_data(X) do { \ + if (X != NULL) gt_pch_nx_dwarf_file_data (X);\ + } while (0) +extern void gt_pch_nx_dwarf_file_data (void *); +#define gt_pch_n_15queued_reg_save(X) do { \ + if (X != NULL) gt_pch_nx_queued_reg_save (X);\ + } while (0) +extern void gt_pch_nx_queued_reg_save (void *); +#define gt_pch_n_20indirect_string_node(X) do { \ + if (X != NULL) gt_pch_nx_indirect_string_node (X);\ + } while (0) +extern void gt_pch_nx_indirect_string_node (void *); +#define gt_pch_n_19dw_loc_descr_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_loc_descr_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_loc_descr_struct (void *); +#define gt_pch_n_13dw_fde_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_fde_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_fde_struct (void *); +#define gt_pch_n_13dw_cfi_struct(X) do { \ + if (X != NULL) gt_pch_nx_dw_cfi_struct (X);\ + } while (0) +extern void gt_pch_nx_dw_cfi_struct (void *); +#define gt_pch_n_8typeinfo(X) do { \ + if (X != NULL) gt_pch_nx_typeinfo (X);\ + } while (0) +extern void gt_pch_nx_typeinfo (void *); +#define gt_pch_n_22VEC_alias_set_entry_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_alias_set_entry_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_alias_set_entry_gc (void *); +#define gt_pch_n_17alias_set_entry_d(X) do { \ + if (X != NULL) gt_pch_nx_alias_set_entry_d (X);\ + } while (0) +extern void gt_pch_nx_alias_set_entry_d (void *); +#define gt_pch_n_24constant_descriptor_tree(X) do { \ + if (X != NULL) gt_pch_nx_constant_descriptor_tree (X);\ + } while (0) +extern void gt_pch_nx_constant_descriptor_tree (void *); +#define gt_pch_n_10cgraph_sym(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_sym (X);\ + } while (0) +extern void gt_pch_nx_cgraph_sym (void *); +#define gt_pch_n_15cgraph_mod_info(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_mod_info (X);\ + } while (0) +extern void gt_pch_nx_cgraph_mod_info (void *); +#define gt_pch_n_15cgraph_asm_node(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_asm_node (X);\ + } while (0) +extern void gt_pch_nx_cgraph_asm_node (void *); +#define gt_pch_n_25cgraph_indirect_call_info(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_indirect_call_info (X);\ + } while (0) +extern void gt_pch_nx_cgraph_indirect_call_info (void *); +#define gt_pch_n_20varpool_node_set_def(X) do { \ + if (X != NULL) gt_pch_nx_varpool_node_set_def (X);\ + } while (0) +extern void gt_pch_nx_varpool_node_set_def (void *); +#define gt_pch_n_28varpool_node_set_element_def(X) do { \ + if (X != NULL) gt_pch_nx_varpool_node_set_element_def (X);\ + } while (0) +extern void gt_pch_nx_varpool_node_set_element_def (void *); +#define gt_pch_n_23VEC_varpool_node_ptr_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_varpool_node_ptr_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_varpool_node_ptr_gc (void *); +#define gt_pch_n_19cgraph_node_set_def(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_node_set_def (X);\ + } while (0) +extern void gt_pch_nx_cgraph_node_set_def (void *); +#define gt_pch_n_27cgraph_node_set_element_def(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_node_set_element_def (X);\ + } while (0) +extern void gt_pch_nx_cgraph_node_set_element_def (void *); +#define gt_pch_n_22VEC_cgraph_node_ptr_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_cgraph_node_ptr_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_cgraph_node_ptr_gc (void *); +#define gt_pch_n_11cgraph_edge(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_edge (X);\ + } while (0) +extern void gt_pch_nx_cgraph_edge (void *); +#define gt_pch_n_24VEC_ipa_replace_map_p_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_ipa_replace_map_p_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_ipa_replace_map_p_gc (void *); +#define gt_pch_n_15ipa_replace_map(X) do { \ + if (X != NULL) gt_pch_nx_ipa_replace_map (X);\ + } while (0) +extern void gt_pch_nx_ipa_replace_map (void *); +#define gt_pch_n_18lto_file_decl_data(X) do { \ + if (X != NULL) gt_pch_nx_lto_file_decl_data (X);\ + } while (0) +extern void gt_pch_nx_lto_file_decl_data (void *); +#define gt_pch_n_16VEC_ipa_ref_t_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_ipa_ref_t_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_ipa_ref_t_gc (void *); +#define gt_pch_n_12varpool_node(X) do { \ + if (X != NULL) gt_pch_nx_varpool_node (X);\ + } while (0) +extern void gt_pch_nx_varpool_node (void *); +#define gt_pch_n_11cgraph_node(X) do { \ + if (X != NULL) gt_pch_nx_cgraph_node (X);\ + } while (0) +extern void gt_pch_nx_cgraph_node (void *); +#define gt_pch_n_18VEC_basic_block_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_basic_block_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_basic_block_gc (void *); +#define gt_pch_n_14gimple_bb_info(X) do { \ + if (X != NULL) gt_pch_nx_gimple_bb_info (X);\ + } while (0) +extern void gt_pch_nx_gimple_bb_info (void *); +#define gt_pch_n_11rtl_bb_info(X) do { \ + if (X != NULL) gt_pch_nx_rtl_bb_info (X);\ + } while (0) +extern void gt_pch_nx_rtl_bb_info (void *); +#define gt_pch_n_11VEC_edge_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_edge_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_edge_gc (void *); +#define gt_pch_n_13VEC_loop_p_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_loop_p_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_loop_p_gc (void *); +#define gt_pch_n_4loop(X) do { \ + if (X != NULL) gt_pch_nx_loop (X);\ + } while (0) +extern void gt_pch_nx_loop (void *); +#define gt_pch_n_9loop_exit(X) do { \ + if (X != NULL) gt_pch_nx_loop_exit (X);\ + } while (0) +extern void gt_pch_nx_loop_exit (void *); +#define gt_pch_n_13nb_iter_bound(X) do { \ + if (X != NULL) gt_pch_nx_nb_iter_bound (X);\ + } while (0) +extern void gt_pch_nx_nb_iter_bound (void *); +#define gt_pch_n_24types_used_by_vars_entry(X) do { \ + if (X != NULL) gt_pch_nx_types_used_by_vars_entry (X);\ + } while (0) +extern void gt_pch_nx_types_used_by_vars_entry (void *); +#define gt_pch_n_17language_function(X) do { \ + if (X != NULL) gt_pch_nx_language_function (X);\ + } while (0) +extern void gt_pch_nx_language_function (void *); +#define gt_pch_n_5loops(X) do { \ + if (X != NULL) gt_pch_nx_loops (X);\ + } while (0) +extern void gt_pch_nx_loops (void *); +#define gt_pch_n_18control_flow_graph(X) do { \ + if (X != NULL) gt_pch_nx_control_flow_graph (X);\ + } while (0) +extern void gt_pch_nx_control_flow_graph (void *); +#define gt_pch_n_9eh_status(X) do { \ + if (X != NULL) gt_pch_nx_eh_status (X);\ + } while (0) +extern void gt_pch_nx_eh_status (void *); +#define gt_pch_n_11stack_usage(X) do { \ + if (X != NULL) gt_pch_nx_stack_usage (X);\ + } while (0) +extern void gt_pch_nx_stack_usage (void *); +#define gt_pch_n_20initial_value_struct(X) do { \ + if (X != NULL) gt_pch_nx_initial_value_struct (X);\ + } while (0) +extern void gt_pch_nx_initial_value_struct (void *); +#define gt_pch_n_11frame_space(X) do { \ + if (X != NULL) gt_pch_nx_frame_space (X);\ + } while (0) +extern void gt_pch_nx_frame_space (void *); +#define gt_pch_n_17rtx_constant_pool(X) do { \ + if (X != NULL) gt_pch_nx_rtx_constant_pool (X);\ + } while (0) +extern void gt_pch_nx_rtx_constant_pool (void *); +#define gt_pch_n_18VEC_temp_slot_p_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_temp_slot_p_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_temp_slot_p_gc (void *); +#define gt_pch_n_9temp_slot(X) do { \ + if (X != NULL) gt_pch_nx_temp_slot (X);\ + } while (0) +extern void gt_pch_nx_temp_slot (void *); +#define gt_pch_n_9gimple_df(X) do { \ + if (X != NULL) gt_pch_nx_gimple_df (X);\ + } while (0) +extern void gt_pch_nx_gimple_df (void *); +#define gt_pch_n_23VEC_call_site_record_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_call_site_record_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_call_site_record_gc (void *); +#define gt_pch_n_18call_site_record_d(X) do { \ + if (X != NULL) gt_pch_nx_call_site_record_d (X);\ + } while (0) +extern void gt_pch_nx_call_site_record_d (void *); +#define gt_pch_n_14sequence_stack(X) do { \ + if (X != NULL) gt_pch_nx_sequence_stack (X);\ + } while (0) +extern void gt_pch_nx_sequence_stack (void *); +#define gt_pch_n_13libfunc_entry(X) do { \ + if (X != NULL) gt_pch_nx_libfunc_entry (X);\ + } while (0) +extern void gt_pch_nx_libfunc_entry (void *); +#define gt_pch_n_17tree_priority_map(X) do { \ + if (X != NULL) gt_pch_nx_tree_priority_map (X);\ + } while (0) +extern void gt_pch_nx_tree_priority_map (void *); +#define gt_pch_n_12tree_int_map(X) do { \ + if (X != NULL) gt_pch_nx_tree_int_map (X);\ + } while (0) +extern void gt_pch_nx_tree_int_map (void *); +#define gt_pch_n_13tree_decl_map(X) do { \ + if (X != NULL) gt_pch_nx_tree_decl_map (X);\ + } while (0) +extern void gt_pch_nx_tree_decl_map (void *); +#define gt_pch_n_14lang_tree_node(X) do { \ + if (X != NULL) gt_pch_nx_lang_tree_node (X);\ + } while (0) +extern void gt_pch_nx_lang_tree_node (void *); +#define gt_pch_n_24tree_statement_list_node(X) do { \ + if (X != NULL) gt_pch_nx_tree_statement_list_node (X);\ + } while (0) +extern void gt_pch_nx_tree_statement_list_node (void *); +#define gt_pch_n_9var_ann_d(X) do { \ + if (X != NULL) gt_pch_nx_var_ann_d (X);\ + } while (0) +extern void gt_pch_nx_var_ann_d (void *); +#define gt_pch_n_9lang_decl(X) do { \ + if (X != NULL) gt_pch_nx_lang_decl (X);\ + } while (0) +extern void gt_pch_nx_lang_decl (void *); +#define gt_pch_n_9lang_type(X) do { \ + if (X != NULL) gt_pch_nx_lang_type (X);\ + } while (0) +extern void gt_pch_nx_lang_type (void *); +#define gt_pch_n_10die_struct(X) do { \ + if (X != NULL) gt_pch_nx_die_struct (X);\ + } while (0) +extern void gt_pch_nx_die_struct (void *); +#define gt_pch_n_12ptr_info_def(X) do { \ + if (X != NULL) gt_pch_nx_ptr_info_def (X);\ + } while (0) +extern void gt_pch_nx_ptr_info_def (void *); +#define gt_pch_n_22VEC_constructor_elt_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_constructor_elt_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_constructor_elt_gc (void *); +#define gt_pch_n_17VEC_alias_pair_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_alias_pair_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_alias_pair_gc (void *); +#define gt_pch_n_8function(X) do { \ + if (X != NULL) gt_pch_nx_function (X);\ + } while (0) +extern void gt_pch_nx_function (void *); +#define gt_pch_n_23constant_descriptor_rtx(X) do { \ + if (X != NULL) gt_pch_nx_constant_descriptor_rtx (X);\ + } while (0) +extern void gt_pch_nx_constant_descriptor_rtx (void *); +#define gt_pch_n_11fixed_value(X) do { \ + if (X != NULL) gt_pch_nx_fixed_value (X);\ + } while (0) +extern void gt_pch_nx_fixed_value (void *); +#define gt_pch_n_10real_value(X) do { \ + if (X != NULL) gt_pch_nx_real_value (X);\ + } while (0) +extern void gt_pch_nx_real_value (void *); +#define gt_pch_n_12object_block(X) do { \ + if (X != NULL) gt_pch_nx_object_block (X);\ + } while (0) +extern void gt_pch_nx_object_block (void *); +#define gt_pch_n_9reg_attrs(X) do { \ + if (X != NULL) gt_pch_nx_reg_attrs (X);\ + } while (0) +extern void gt_pch_nx_reg_attrs (void *); +#define gt_pch_n_9mem_attrs(X) do { \ + if (X != NULL) gt_pch_nx_mem_attrs (X);\ + } while (0) +extern void gt_pch_nx_mem_attrs (void *); +#define gt_pch_n_14bitmap_obstack(X) do { \ + if (X != NULL) gt_pch_nx_bitmap_obstack (X);\ + } while (0) +extern void gt_pch_nx_bitmap_obstack (void *); +#define gt_pch_n_18bitmap_element_def(X) do { \ + if (X != NULL) gt_pch_nx_bitmap_element_def (X);\ + } while (0) +extern void gt_pch_nx_bitmap_element_def (void *); +#define gt_pch_n_16machine_function(X) do { \ + if (X != NULL) gt_pch_nx_machine_function (X);\ + } while (0) +extern void gt_pch_nx_machine_function (void *); +#define gt_pch_n_10VEC_rtx_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_rtx_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_rtx_gc (void *); +#define gt_pch_n_13VEC_gimple_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_gimple_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_gimple_gc (void *); +#define gt_pch_n_11VEC_tree_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_tree_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_tree_gc (void *); +#define gt_pch_n_12VEC_uchar_gc(X) do { \ + if (X != NULL) gt_pch_nx_VEC_uchar_gc (X);\ + } while (0) +extern void gt_pch_nx_VEC_uchar_gc (void *); +#define gt_pch_n_15basic_block_def(X) do { \ + if (X != NULL) gt_pch_nx_basic_block_def (X);\ + } while (0) +extern void gt_pch_nx_basic_block_def (void *); +#define gt_pch_n_8edge_def(X) do { \ + if (X != NULL) gt_pch_nx_edge_def (X);\ + } while (0) +extern void gt_pch_nx_edge_def (void *); +#define gt_pch_n_12gimple_seq_d(X) do { \ + if (X != NULL) gt_pch_nx_gimple_seq_d (X);\ + } while (0) +extern void gt_pch_nx_gimple_seq_d (void *); +#define gt_pch_n_7section(X) do { \ + if (X != NULL) gt_pch_nx_section (X);\ + } while (0) +extern void gt_pch_nx_section (void *); +#define gt_pch_n_18gimple_statement_d(X) do { \ + if (X != NULL) gt_pch_nx_gimple_statement_d (X);\ + } while (0) +extern void gt_pch_nx_gimple_statement_d (void *); +#define gt_pch_n_9rtvec_def(X) do { \ + if (X != NULL) gt_pch_nx_rtvec_def (X);\ + } while (0) +extern void gt_pch_nx_rtvec_def (void *); +#define gt_pch_n_7rtx_def(X) do { \ + if (X != NULL) gt_pch_nx_rtx_def (X);\ + } while (0) +extern void gt_pch_nx_rtx_def (void *); +#define gt_pch_n_15bitmap_head_def(X) do { \ + if (X != NULL) gt_pch_nx_bitmap_head_def (X);\ + } while (0) +extern void gt_pch_nx_bitmap_head_def (void *); +#define gt_pch_n_9tree_node(X) do { \ + if (X != NULL) gt_pch_nx_tree_node (X);\ + } while (0) +#define gt_pch_nx_tree_node gt_pch_nx_lang_tree_node +#define gt_pch_n_6answer(X) do { \ + if (X != NULL) gt_pch_nx_answer (X);\ + } while (0) +extern void gt_pch_nx_answer (void *); +#define gt_pch_n_9cpp_macro(X) do { \ + if (X != NULL) gt_pch_nx_cpp_macro (X);\ + } while (0) +extern void gt_pch_nx_cpp_macro (void *); +#define gt_pch_n_9cpp_token(X) do { \ + if (X != NULL) gt_pch_nx_cpp_token (X);\ + } while (0) +extern void gt_pch_nx_cpp_token (void *); +#define gt_pch_n_9line_maps(X) do { \ + if (X != NULL) gt_pch_nx_line_maps (X);\ + } while (0) +extern void gt_pch_nx_line_maps (void *); +extern void gt_pch_n_II17splay_tree_node_s (void *); +extern void gt_pch_n_SP9tree_node17splay_tree_node_s (void *); +extern void gt_pch_n_P9tree_nodeP9tree_node17splay_tree_node_s (void *); +extern void gt_pch_n_P15interface_tuple4htab (void *); +extern void gt_pch_n_P17string_descriptor4htab (void *); +extern void gt_pch_n_P14type_assertion4htab (void *); +extern void gt_pch_n_P18treetreehash_entry4htab (void *); +extern void gt_pch_n_P17module_htab_entry4htab (void *); +extern void gt_pch_n_P21pending_abstract_type4htab (void *); +extern void gt_pch_n_P14constexpr_call4htab (void *); +extern void gt_pch_n_P16constexpr_fundef4htab (void *); +extern void gt_pch_n_P10spec_entry4htab (void *); +extern void gt_pch_n_P16cxx_int_tree_map4htab (void *); +extern void gt_pch_n_P17named_label_entry4htab (void *); +extern void gt_pch_n_P17lto_in_decl_state4htab (void *); +extern void gt_pch_n_P20lto_symtab_entry_def4htab (void *); +extern void gt_pch_n_P11heapvar_map4htab (void *); +extern void gt_pch_n_P9tree_nodeP9tree_node12splay_tree_s (void *); +extern void gt_pch_n_P13scev_info_str4htab (void *); +extern void gt_pch_n_P12tree_int_map4htab (void *); +extern void gt_pch_n_P23constant_descriptor_rtx4htab (void *); +extern void gt_pch_n_P24constant_descriptor_tree4htab (void *); +extern void gt_pch_n_P12object_block4htab (void *); +extern void gt_pch_n_P7section4htab (void *); +extern void gt_pch_n_P17tree_priority_map4htab (void *); +extern void gt_pch_n_P13tree_decl_map4htab (void *); +extern void gt_pch_n_P9type_hash4htab (void *); +extern void gt_pch_n_P23temp_slot_address_entry4htab (void *); +extern void gt_pch_n_P15throw_stmt_node4htab (void *); +extern void gt_pch_n_P9reg_attrs4htab (void *); +extern void gt_pch_n_P9mem_attrs4htab (void *); +extern void gt_pch_n_P7rtx_def4htab (void *); +extern void gt_pch_n_P12varpool_node4htab (void *); +extern void gt_pch_n_P10cgraph_sym4htab (void *); +extern void gt_pch_n_P8type_ent4htab (void *); +extern void gt_pch_n_P18saved_module_scope4htab (void *); +extern void gt_pch_n_SP9tree_node12splay_tree_s (void *); +extern void gt_pch_n_P10vcall_insn4htab (void *); +extern void gt_pch_n_P22cached_dw_loc_list_def4htab (void *); +extern void gt_pch_n_P16var_loc_list_def4htab (void *); +extern void gt_pch_n_P10die_struct4htab (void *); +extern void gt_pch_n_P15dwarf_file_data4htab (void *); +extern void gt_pch_n_P20indirect_string_node4htab (void *); +extern void gt_pch_n_P11cgraph_node4htab (void *); +extern void gt_pch_n_II12splay_tree_s (void *); +extern void gt_pch_n_P15cgraph_mod_info4htab (void *); +extern void gt_pch_n_P28varpool_node_set_element_def4htab (void *); +extern void gt_pch_n_P27cgraph_node_set_element_def4htab (void *); +extern void gt_pch_n_P11cgraph_edge4htab (void *); +extern void gt_pch_n_P9loop_exit4htab (void *); +extern void gt_pch_n_P24types_used_by_vars_entry4htab (void *); +extern void gt_pch_n_P9tree_node4htab (void *); +extern void gt_pch_n_P13libfunc_entry4htab (void *); + +/* functions code */ + +/* Local pointer-walking routines. */ +extern void gt_pch_p_22VEC_c_saved_builtin_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15c_inline_static + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24VEC_c_goto_bindings_p_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15c_goto_bindings + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_7c_scope + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9c_binding + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12c_label_vars + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_8c_parser + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20VEC_ivarref_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22VEC_prot_list_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19VEC_msgref_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23VEC_ident_data_tuple_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15interface_tuple + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17string_descriptor + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9imp_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16hashed_attribute + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12hashed_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23VEC_ltrans_partition_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20ltrans_partition_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19VEC_method_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14type_assertion + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18treetreehash_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_5CPool + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_3JCF + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17module_htab_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13binding_level + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20VEC_saved_builtin_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9opt_stack + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_27VEC_pending_redefinition_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19VEC_pending_weak_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11align_stack + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18VEC_tree_gc_vec_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19VEC_const_char_p_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_21pending_abstract_type + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15VEC_tree_int_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9cp_parser + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_34VEC_cp_unparsed_functions_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_27VEC_cp_default_arg_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17cp_parser_context + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_8cp_lexer + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10tree_check + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14constexpr_call + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16constexpr_fundef + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22VEC_deferred_access_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10spec_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_26VEC_pending_attribute_p_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17pending_attribute + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16pending_template + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_21VEC_incomplete_var_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_21named_label_use_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_28VEC_deferred_access_check_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18sorted_fields_type + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18VEC_tree_pair_s_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17named_label_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_32VEC_qualified_typedef_usage_t_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14cp_token_cache + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11saved_scope + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16cxx_int_tree_map + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23VEC_cp_label_binding_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23VEC_cp_class_binding_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24VEC_cxx_saved_binding_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16cp_binding_level + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11cxx_binding + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15binding_entry_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15binding_table_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11tinst_level + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14VEC_tinfo_s_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18gnat_binding_level + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9elab_info + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10stmt_group + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16VEC_parm_attr_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11parm_attr_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17lto_in_decl_state + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22VEC_ipa_edge_args_t_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20lto_symtab_entry_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11heapvar_map + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20ssa_operand_memory_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13scev_info_str + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24VEC_mem_addr_template_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_26gimple_type_leader_entry_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17gimple_seq_node_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9type_hash + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16string_pool_data + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23temp_slot_address_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15throw_stmt_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_21VEC_eh_landing_pad_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16VEC_eh_region_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10eh_catch_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16eh_landing_pad_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11eh_region_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_8type_ent + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18saved_module_scope + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10vcall_insn + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18VEC_vcall_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18VEC_dcall_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22cached_dw_loc_list_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16var_loc_list_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12var_loc_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20VEC_die_arg_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16limbo_die_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20VEC_macinfo_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20VEC_pubname_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19VEC_dw_attr_node_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18comdat_type_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_25dw_ranges_by_label_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16dw_ranges_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_28dw_separate_line_info_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19dw_line_info_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_25VEC_deferred_locations_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18dw_loc_list_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15dwarf_file_data + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15queued_reg_save + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20indirect_string_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19dw_loc_descr_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13dw_fde_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13dw_cfi_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_8typeinfo + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22VEC_alias_set_entry_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17alias_set_entry_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24constant_descriptor_tree + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10cgraph_sym + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15cgraph_mod_info + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15cgraph_asm_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_25cgraph_indirect_call_info + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20varpool_node_set_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_28varpool_node_set_element_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23VEC_varpool_node_ptr_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_19cgraph_node_set_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_27cgraph_node_set_element_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22VEC_cgraph_node_ptr_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11cgraph_edge + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24VEC_ipa_replace_map_p_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15ipa_replace_map + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18lto_file_decl_data + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16VEC_ipa_ref_t_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12varpool_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11cgraph_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18VEC_basic_block_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14gimple_bb_info + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11rtl_bb_info + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11VEC_edge_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13VEC_loop_p_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_4loop + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9loop_exit + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13nb_iter_bound + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24types_used_by_vars_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17language_function + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_5loops + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18control_flow_graph + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9eh_status + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11stack_usage + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_20initial_value_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11frame_space + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17rtx_constant_pool + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18VEC_temp_slot_p_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9temp_slot + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9gimple_df + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23VEC_call_site_record_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18call_site_record_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14sequence_stack + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13libfunc_entry + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17tree_priority_map + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12tree_int_map + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13tree_decl_map + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14lang_tree_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_24tree_statement_list_node + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9var_ann_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9lang_decl + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9lang_type + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10die_struct + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12ptr_info_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_22VEC_constructor_elt_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_17VEC_alias_pair_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_8function + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_23constant_descriptor_rtx + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11fixed_value + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10real_value + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12object_block + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9reg_attrs + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9mem_attrs + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_14bitmap_obstack + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18bitmap_element_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_16machine_function + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_10VEC_rtx_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_13VEC_gimple_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_11VEC_tree_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12VEC_uchar_gc + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15basic_block_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_8edge_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_12gimple_seq_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_7section + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_18gimple_statement_d + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9rtvec_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_7rtx_def + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_15bitmap_head_def + (void *, void *, gt_pointer_operator, void *); +#define gt_pch_p_9tree_node gt_pch_p_14lang_tree_node +extern void gt_pch_p_6answer + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9cpp_macro + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9cpp_token + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_9line_maps + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_II17splay_tree_node_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_SP9tree_node17splay_tree_node_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9tree_nodeP9tree_node17splay_tree_node_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P15interface_tuple4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P17string_descriptor4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P14type_assertion4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P18treetreehash_entry4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P17module_htab_entry4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P21pending_abstract_type4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P14constexpr_call4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P16constexpr_fundef4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P10spec_entry4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P16cxx_int_tree_map4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P17named_label_entry4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P17lto_in_decl_state4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P20lto_symtab_entry_def4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P11heapvar_map4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9tree_nodeP9tree_node12splay_tree_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P13scev_info_str4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P12tree_int_map4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P23constant_descriptor_rtx4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P24constant_descriptor_tree4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P12object_block4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P7section4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P17tree_priority_map4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P13tree_decl_map4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9type_hash4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P23temp_slot_address_entry4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P15throw_stmt_node4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9reg_attrs4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9mem_attrs4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P7rtx_def4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P12varpool_node4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P10cgraph_sym4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P8type_ent4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P18saved_module_scope4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_SP9tree_node12splay_tree_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P10vcall_insn4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P22cached_dw_loc_list_def4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P16var_loc_list_def4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P10die_struct4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P15dwarf_file_data4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P20indirect_string_node4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P11cgraph_node4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_II12splay_tree_s + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P15cgraph_mod_info4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P28varpool_node_set_element_def4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P27cgraph_node_set_element_def4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P11cgraph_edge4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9loop_exit4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P24types_used_by_vars_entry4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P9tree_node4htab + (void *, void *, gt_pointer_operator, void *); +extern void gt_pch_p_P13libfunc_entry4htab + (void *, void *, gt_pointer_operator, void *); + +/* Splay tree callback allocators. */ +extern void * ggc_alloc_splay_tree_scalar_scalar_splay_tree_node_s (int, void *); +extern void * ggc_alloc_splay_tree_str_tree_node_splay_tree_node_s (int, void *); +extern void * ggc_alloc_splay_tree_tree_node_tree_node_splay_tree_node_s (int, void *); +extern void * ggc_alloc_splay_tree_interface_tuple_htab (int, void *); +extern void * ggc_alloc_splay_tree_string_descriptor_htab (int, void *); +extern void * ggc_alloc_splay_tree_type_assertion_htab (int, void *); +extern void * ggc_alloc_splay_tree_treetreehash_entry_htab (int, void *); +extern void * ggc_alloc_splay_tree_module_htab_entry_htab (int, void *); +extern void * ggc_alloc_splay_tree_pending_abstract_type_htab (int, void *); +extern void * ggc_alloc_splay_tree_constexpr_call_htab (int, void *); +extern void * ggc_alloc_splay_tree_constexpr_fundef_htab (int, void *); +extern void * ggc_alloc_splay_tree_spec_entry_htab (int, void *); +extern void * ggc_alloc_splay_tree_cxx_int_tree_map_htab (int, void *); +extern void * ggc_alloc_splay_tree_named_label_entry_htab (int, void *); +extern void * ggc_alloc_splay_tree_lto_in_decl_state_htab (int, void *); +extern void * ggc_alloc_splay_tree_lto_symtab_entry_def_htab (int, void *); +extern void * ggc_alloc_splay_tree_heapvar_map_htab (int, void *); +extern void * ggc_alloc_splay_tree_tree_node_tree_node_splay_tree_s (int, void *); +extern void * ggc_alloc_splay_tree_scev_info_str_htab (int, void *); +extern void * ggc_alloc_splay_tree_tree_int_map_htab (int, void *); +extern void * ggc_alloc_splay_tree_constant_descriptor_rtx_htab (int, void *); +extern void * ggc_alloc_splay_tree_constant_descriptor_tree_htab (int, void *); +extern void * ggc_alloc_splay_tree_object_block_htab (int, void *); +extern void * ggc_alloc_splay_tree_section_htab (int, void *); +extern void * ggc_alloc_splay_tree_tree_priority_map_htab (int, void *); +extern void * ggc_alloc_splay_tree_tree_decl_map_htab (int, void *); +extern void * ggc_alloc_splay_tree_type_hash_htab (int, void *); +extern void * ggc_alloc_splay_tree_temp_slot_address_entry_htab (int, void *); +extern void * ggc_alloc_splay_tree_throw_stmt_node_htab (int, void *); +extern void * ggc_alloc_splay_tree_reg_attrs_htab (int, void *); +extern void * ggc_alloc_splay_tree_mem_attrs_htab (int, void *); +extern void * ggc_alloc_splay_tree_rtx_def_htab (int, void *); +extern void * ggc_alloc_splay_tree_varpool_node_htab (int, void *); +extern void * ggc_alloc_splay_tree_cgraph_sym_htab (int, void *); +extern void * ggc_alloc_splay_tree_type_ent_htab (int, void *); +extern void * ggc_alloc_splay_tree_saved_module_scope_htab (int, void *); +extern void * ggc_alloc_splay_tree_str_tree_node_splay_tree_s (int, void *); +extern void * ggc_alloc_splay_tree_vcall_insn_htab (int, void *); +extern void * ggc_alloc_splay_tree_cached_dw_loc_list_def_htab (int, void *); +extern void * ggc_alloc_splay_tree_var_loc_list_def_htab (int, void *); +extern void * ggc_alloc_splay_tree_die_struct_htab (int, void *); +extern void * ggc_alloc_splay_tree_dwarf_file_data_htab (int, void *); +extern void * ggc_alloc_splay_tree_indirect_string_node_htab (int, void *); +extern void * ggc_alloc_splay_tree_cgraph_node_htab (int, void *); +extern void * ggc_alloc_splay_tree_scalar_scalar_splay_tree_s (int, void *); +extern void * ggc_alloc_splay_tree_cgraph_mod_info_htab (int, void *); +extern void * ggc_alloc_splay_tree_varpool_node_set_element_def_htab (int, void *); +extern void * ggc_alloc_splay_tree_cgraph_node_set_element_def_htab (int, void *); +extern void * ggc_alloc_splay_tree_cgraph_edge_htab (int, void *); +extern void * ggc_alloc_splay_tree_loop_exit_htab (int, void *); +extern void * ggc_alloc_splay_tree_types_used_by_vars_entry_htab (int, void *); +extern void * ggc_alloc_splay_tree_tree_node_htab (int, void *); +extern void * ggc_alloc_splay_tree_libfunc_entry_htab (int, void *); diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hard-reg-set.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hard-reg-set.h new file mode 100644 index 0000000..9cd7c8b --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hard-reg-set.h @@ -0,0 +1,706 @@ +/* Sets (bit vectors) of hard registers, and operations on them. + Copyright (C) 1987, 1992, 1994, 2000, 2003, 2004, 2005, 2007, 2008, 2009, + 2010 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/>. */ + +#ifndef GCC_HARD_REG_SET_H +#define GCC_HARD_REG_SET_H + +/* Define the type of a set of hard registers. */ + +/* HARD_REG_ELT_TYPE is a typedef of the unsigned integral type which + will be used for hard reg sets, either alone or in an array. + + If HARD_REG_SET is a macro, its definition is HARD_REG_ELT_TYPE, + and it has enough bits to represent all the target machine's hard + registers. Otherwise, it is a typedef for a suitably sized array + of HARD_REG_ELT_TYPEs. HARD_REG_SET_LONGS is defined as how many. + + Note that lots of code assumes that the first part of a regset is + the same format as a HARD_REG_SET. To help make sure this is true, + we only try the widest fast integer mode (HOST_WIDEST_FAST_INT) + instead of all the smaller types. This approach loses only if + there are very few registers and then only in the few cases where + we have an array of HARD_REG_SETs, so it needn't be as complex as + it used to be. */ + +typedef unsigned HOST_WIDEST_FAST_INT HARD_REG_ELT_TYPE; + +#if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT + +#define HARD_REG_SET HARD_REG_ELT_TYPE + +#else + +#define HARD_REG_SET_LONGS \ + ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDEST_FAST_INT - 1) \ + / HOST_BITS_PER_WIDEST_FAST_INT) +typedef HARD_REG_ELT_TYPE HARD_REG_SET[HARD_REG_SET_LONGS]; + +#endif + +/* HARD_CONST is used to cast a constant to the appropriate type + for use with a HARD_REG_SET. */ + +#define HARD_CONST(X) ((HARD_REG_ELT_TYPE) (X)) + +/* Define macros SET_HARD_REG_BIT, CLEAR_HARD_REG_BIT and TEST_HARD_REG_BIT + to set, clear or test one bit in a hard reg set of type HARD_REG_SET. + All three take two arguments: the set and the register number. + + In the case where sets are arrays of longs, the first argument + is actually a pointer to a long. + + Define two macros for initializing a set: + CLEAR_HARD_REG_SET and SET_HARD_REG_SET. + These take just one argument. + + Also define macros for copying hard reg sets: + COPY_HARD_REG_SET and COMPL_HARD_REG_SET. + These take two arguments TO and FROM; they read from FROM + and store into TO. COMPL_HARD_REG_SET complements each bit. + + Also define macros for combining hard reg sets: + IOR_HARD_REG_SET and AND_HARD_REG_SET. + These take two arguments TO and FROM; they read from FROM + and combine bitwise into TO. Define also two variants + IOR_COMPL_HARD_REG_SET and AND_COMPL_HARD_REG_SET + which use the complement of the set FROM. + + Also define: + + hard_reg_set_subset_p (X, Y), which returns true if X is a subset of Y. + hard_reg_set_equal_p (X, Y), which returns true if X and Y are equal. + hard_reg_set_intersect_p (X, Y), which returns true if X and Y intersect. + hard_reg_set_empty_p (X), which returns true if X is empty. */ + +#define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT) + +#ifdef HARD_REG_SET + +#define SET_HARD_REG_BIT(SET, BIT) \ + ((SET) |= HARD_CONST (1) << (BIT)) +#define CLEAR_HARD_REG_BIT(SET, BIT) \ + ((SET) &= ~(HARD_CONST (1) << (BIT))) +#define TEST_HARD_REG_BIT(SET, BIT) \ + (!!((SET) & (HARD_CONST (1) << (BIT)))) + +#define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0)) +#define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0)) + +#define COPY_HARD_REG_SET(TO, FROM) ((TO) = (FROM)) +#define COMPL_HARD_REG_SET(TO, FROM) ((TO) = ~(FROM)) + +#define IOR_HARD_REG_SET(TO, FROM) ((TO) |= (FROM)) +#define IOR_COMPL_HARD_REG_SET(TO, FROM) ((TO) |= ~ (FROM)) +#define AND_HARD_REG_SET(TO, FROM) ((TO) &= (FROM)) +#define AND_COMPL_HARD_REG_SET(TO, FROM) ((TO) &= ~ (FROM)) + +static inline bool +hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return (x & ~y) == HARD_CONST (0); +} + +static inline bool +hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return x == y; +} + +static inline bool +hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return (x & y) != HARD_CONST (0); +} + +static inline bool +hard_reg_set_empty_p (const HARD_REG_SET x) +{ + return x == HARD_CONST (0); +} + +#else + +#define SET_HARD_REG_BIT(SET, BIT) \ + ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT] \ + |= HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)) + +#define CLEAR_HARD_REG_BIT(SET, BIT) \ + ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT] \ + &= ~(HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))) + +#define TEST_HARD_REG_BIT(SET, BIT) \ + (!!((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT] \ + & (HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)))) + +#if FIRST_PSEUDO_REGISTER <= 2*HOST_BITS_PER_WIDEST_FAST_INT +#define CLEAR_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + scan_tp_[0] = 0; \ + scan_tp_[1] = 0; } while (0) + +#define SET_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + scan_tp_[0] = -1; \ + scan_tp_[1] = -1; } while (0) + +#define COPY_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] = scan_fp_[0]; \ + scan_tp_[1] = scan_fp_[1]; } while (0) + +#define COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] = ~ scan_fp_[0]; \ + scan_tp_[1] = ~ scan_fp_[1]; } while (0) + +#define AND_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] &= scan_fp_[0]; \ + scan_tp_[1] &= scan_fp_[1]; } while (0) + +#define AND_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] &= ~ scan_fp_[0]; \ + scan_tp_[1] &= ~ scan_fp_[1]; } while (0) + +#define IOR_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] |= scan_fp_[0]; \ + scan_tp_[1] |= scan_fp_[1]; } while (0) + +#define IOR_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] |= ~ scan_fp_[0]; \ + scan_tp_[1] |= ~ scan_fp_[1]; } while (0) + +static inline bool +hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return (x[0] & ~y[0]) == 0 && (x[1] & ~y[1]) == 0; +} + +static inline bool +hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return x[0] == y[0] && x[1] == y[1]; +} + +static inline bool +hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return (x[0] & y[0]) != 0 || (x[1] & y[1]) != 0; +} + +static inline bool +hard_reg_set_empty_p (const HARD_REG_SET x) +{ + return x[0] == 0 && x[1] == 0; +} + +#else +#if FIRST_PSEUDO_REGISTER <= 3*HOST_BITS_PER_WIDEST_FAST_INT +#define CLEAR_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + scan_tp_[0] = 0; \ + scan_tp_[1] = 0; \ + scan_tp_[2] = 0; } while (0) + +#define SET_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + scan_tp_[0] = -1; \ + scan_tp_[1] = -1; \ + scan_tp_[2] = -1; } while (0) + +#define COPY_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] = scan_fp_[0]; \ + scan_tp_[1] = scan_fp_[1]; \ + scan_tp_[2] = scan_fp_[2]; } while (0) + +#define COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] = ~ scan_fp_[0]; \ + scan_tp_[1] = ~ scan_fp_[1]; \ + scan_tp_[2] = ~ scan_fp_[2]; } while (0) + +#define AND_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] &= scan_fp_[0]; \ + scan_tp_[1] &= scan_fp_[1]; \ + scan_tp_[2] &= scan_fp_[2]; } while (0) + +#define AND_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] &= ~ scan_fp_[0]; \ + scan_tp_[1] &= ~ scan_fp_[1]; \ + scan_tp_[2] &= ~ scan_fp_[2]; } while (0) + +#define IOR_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] |= scan_fp_[0]; \ + scan_tp_[1] |= scan_fp_[1]; \ + scan_tp_[2] |= scan_fp_[2]; } while (0) + +#define IOR_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] |= ~ scan_fp_[0]; \ + scan_tp_[1] |= ~ scan_fp_[1]; \ + scan_tp_[2] |= ~ scan_fp_[2]; } while (0) + +static inline bool +hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return ((x[0] & ~y[0]) == 0 + && (x[1] & ~y[1]) == 0 + && (x[2] & ~y[2]) == 0); +} + +static inline bool +hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return x[0] == y[0] && x[1] == y[1] && x[2] == y[2]; +} + +static inline bool +hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return ((x[0] & y[0]) != 0 + || (x[1] & y[1]) != 0 + || (x[2] & y[2]) != 0); +} + +static inline bool +hard_reg_set_empty_p (const HARD_REG_SET x) +{ + return x[0] == 0 && x[1] == 0 && x[2] == 0; +} + +#else +#if FIRST_PSEUDO_REGISTER <= 4*HOST_BITS_PER_WIDEST_FAST_INT +#define CLEAR_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + scan_tp_[0] = 0; \ + scan_tp_[1] = 0; \ + scan_tp_[2] = 0; \ + scan_tp_[3] = 0; } while (0) + +#define SET_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + scan_tp_[0] = -1; \ + scan_tp_[1] = -1; \ + scan_tp_[2] = -1; \ + scan_tp_[3] = -1; } while (0) + +#define COPY_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] = scan_fp_[0]; \ + scan_tp_[1] = scan_fp_[1]; \ + scan_tp_[2] = scan_fp_[2]; \ + scan_tp_[3] = scan_fp_[3]; } while (0) + +#define COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] = ~ scan_fp_[0]; \ + scan_tp_[1] = ~ scan_fp_[1]; \ + scan_tp_[2] = ~ scan_fp_[2]; \ + scan_tp_[3] = ~ scan_fp_[3]; } while (0) + +#define AND_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] &= scan_fp_[0]; \ + scan_tp_[1] &= scan_fp_[1]; \ + scan_tp_[2] &= scan_fp_[2]; \ + scan_tp_[3] &= scan_fp_[3]; } while (0) + +#define AND_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] &= ~ scan_fp_[0]; \ + scan_tp_[1] &= ~ scan_fp_[1]; \ + scan_tp_[2] &= ~ scan_fp_[2]; \ + scan_tp_[3] &= ~ scan_fp_[3]; } while (0) + +#define IOR_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] |= scan_fp_[0]; \ + scan_tp_[1] |= scan_fp_[1]; \ + scan_tp_[2] |= scan_fp_[2]; \ + scan_tp_[3] |= scan_fp_[3]; } while (0) + +#define IOR_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + scan_tp_[0] |= ~ scan_fp_[0]; \ + scan_tp_[1] |= ~ scan_fp_[1]; \ + scan_tp_[2] |= ~ scan_fp_[2]; \ + scan_tp_[3] |= ~ scan_fp_[3]; } while (0) + +static inline bool +hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return ((x[0] & ~y[0]) == 0 + && (x[1] & ~y[1]) == 0 + && (x[2] & ~y[2]) == 0 + && (x[3] & ~y[3]) == 0); +} + +static inline bool +hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return x[0] == y[0] && x[1] == y[1] && x[2] == y[2] && x[3] == y[3]; +} + +static inline bool +hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + return ((x[0] & y[0]) != 0 + || (x[1] & y[1]) != 0 + || (x[2] & y[2]) != 0 + || (x[3] & y[3]) != 0); +} + +static inline bool +hard_reg_set_empty_p (const HARD_REG_SET x) +{ + return x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 0; +} + +#else /* FIRST_PSEUDO_REGISTER > 4*HOST_BITS_PER_WIDEST_FAST_INT */ + +#define CLEAR_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ = 0; } while (0) + +#define SET_HARD_REG_SET(TO) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ = -1; } while (0) + +#define COPY_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ = *scan_fp_++; } while (0) + +#define COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ = ~ *scan_fp_++; } while (0) + +#define AND_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ &= *scan_fp_++; } while (0) + +#define AND_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ &= ~ *scan_fp_++; } while (0) + +#define IOR_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ |= *scan_fp_++; } while (0) + +#define IOR_COMPL_HARD_REG_SET(TO, FROM) \ +do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \ + int i; \ + for (i = 0; i < HARD_REG_SET_LONGS; i++) \ + *scan_tp_++ |= ~ *scan_fp_++; } while (0) + +static inline bool +hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + int i; + + for (i = 0; i < HARD_REG_SET_LONGS; i++) + if ((x[i] & ~y[i]) != 0) + return false; + return true; +} + +static inline bool +hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + int i; + + for (i = 0; i < HARD_REG_SET_LONGS; i++) + if (x[i] != y[i]) + return false; + return true; +} + +static inline bool +hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y) +{ + int i; + + for (i = 0; i < HARD_REG_SET_LONGS; i++) + if ((x[i] & y[i]) != 0) + return true; + return false; +} + +static inline bool +hard_reg_set_empty_p (const HARD_REG_SET x) +{ + int i; + + for (i = 0; i < HARD_REG_SET_LONGS; i++) + if (x[i] != 0) + return false; + return true; +} + +#endif +#endif +#endif +#endif + +/* Iterator for hard register sets. */ + +typedef struct +{ + /* Pointer to the current element. */ + HARD_REG_ELT_TYPE *pelt; + + /* The length of the set. */ + unsigned short length; + + /* Word within the current element. */ + unsigned short word_no; + + /* Contents of the actually processed word. When finding next bit + it is shifted right, so that the actual bit is always the least + significant bit of ACTUAL. */ + HARD_REG_ELT_TYPE bits; +} hard_reg_set_iterator; + +#define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT + +/* The implementation of the iterator functions is fully analogous to + the bitmap iterators. */ +static inline void +hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set, + unsigned min, unsigned *regno) +{ +#ifdef HARD_REG_SET_LONGS + iter->pelt = set; + iter->length = HARD_REG_SET_LONGS; +#else + iter->pelt = &set; + iter->length = 1; +#endif + iter->word_no = min / HARD_REG_ELT_BITS; + if (iter->word_no < iter->length) + { + iter->bits = iter->pelt[iter->word_no]; + iter->bits >>= min % HARD_REG_ELT_BITS; + + /* This is required for correct search of the next bit. */ + min += !iter->bits; + } + *regno = min; +} + +static inline bool +hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno) +{ + while (1) + { + /* Return false when we're advanced past the end of the set. */ + if (iter->word_no >= iter->length) + return false; + + if (iter->bits) + { + /* Find the correct bit and return it. */ + while (!(iter->bits & 1)) + { + iter->bits >>= 1; + *regno += 1; + } + return (*regno < FIRST_PSEUDO_REGISTER); + } + + /* Round to the beginning of the next word. */ + *regno = (*regno + HARD_REG_ELT_BITS - 1); + *regno -= *regno % HARD_REG_ELT_BITS; + + /* Find the next non-zero word. */ + while (++iter->word_no < iter->length) + { + iter->bits = iter->pelt[iter->word_no]; + if (iter->bits) + break; + *regno += HARD_REG_ELT_BITS; + } + } +} + +static inline void +hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno) +{ + iter->bits >>= 1; + *regno += 1; +} + +#define EXECUTE_IF_SET_IN_HARD_REG_SET(SET, MIN, REGNUM, ITER) \ + for (hard_reg_set_iter_init (&(ITER), (SET), (MIN), &(REGNUM)); \ + hard_reg_set_iter_set (&(ITER), &(REGNUM)); \ + hard_reg_set_iter_next (&(ITER), &(REGNUM))) + + +/* Define some standard sets of registers. */ + +/* Indexed by hard register number, contains 1 for registers + that are being used for global register decls. + These must be exempt from ordinary flow analysis + and are also considered fixed. */ + +extern char global_regs[FIRST_PSEUDO_REGISTER]; + +struct target_hard_regs { + /* Indexed by hard register number, contains 1 for registers + that are fixed use (stack pointer, pc, frame pointer, etc.;. + These are the registers that cannot be used to allocate + a pseudo reg whose life does not cross calls. */ + char x_fixed_regs[FIRST_PSEUDO_REGISTER]; + + /* The same info as a HARD_REG_SET. */ + HARD_REG_SET x_fixed_reg_set; + + /* Indexed by hard register number, contains 1 for registers + that are fixed use or are clobbered by function calls. + These are the registers that cannot be used to allocate + a pseudo reg whose life crosses calls. */ + char x_call_used_regs[FIRST_PSEUDO_REGISTER]; + + char x_call_really_used_regs[FIRST_PSEUDO_REGISTER]; + + /* The same info as a HARD_REG_SET. */ + HARD_REG_SET x_call_used_reg_set; + + /* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or + a function value return register or TARGET_STRUCT_VALUE_RTX or + STATIC_CHAIN_REGNUM. These are the registers that cannot hold quantities + across calls even if we are willing to save and restore them. */ + HARD_REG_SET x_call_fixed_reg_set; + + /* Contains 1 for registers that are set or clobbered by calls. */ + /* ??? Ideally, this would be just call_used_regs plus global_regs, but + for someone's bright idea to have call_used_regs strictly include + fixed_regs. Which leaves us guessing as to the set of fixed_regs + that are actually preserved. We know for sure that those associated + with the local stack frame are safe, but scant others. */ + HARD_REG_SET x_regs_invalidated_by_call; + + /* Call used hard registers which can not be saved because there is no + insn for this. */ + HARD_REG_SET x_no_caller_save_reg_set; + + /* Table of register numbers in the order in which to try to use them. */ + int x_reg_alloc_order[FIRST_PSEUDO_REGISTER]; + + /* The inverse of reg_alloc_order. */ + int x_inv_reg_alloc_order[FIRST_PSEUDO_REGISTER]; + + /* For each reg class, a HARD_REG_SET saying which registers are in it. */ + HARD_REG_SET x_reg_class_contents[N_REG_CLASSES]; + + /* For each reg class, a boolean saying whether the class contains only + fixed registers. */ + bool x_class_only_fixed_regs[N_REG_CLASSES]; + + /* For each reg class, number of regs it contains. */ + unsigned int x_reg_class_size[N_REG_CLASSES]; + + /* For each reg class, table listing all the classes contained in it. */ + enum reg_class x_reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES]; + + /* For each pair of reg classes, + a largest reg class contained in their union. */ + enum reg_class x_reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES]; + + /* For each pair of reg classes, + the smallest reg class that contains their union. */ + enum reg_class x_reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES]; + + /* Vector indexed by hardware reg giving its name. */ + const char *x_reg_names[FIRST_PSEUDO_REGISTER]; +}; + +extern struct target_hard_regs default_target_hard_regs; +#if SWITCHABLE_TARGET +extern struct target_hard_regs *this_target_hard_regs; +#else +#define this_target_hard_regs (&default_target_hard_regs) +#endif + +#define fixed_regs \ + (this_target_hard_regs->x_fixed_regs) +#define fixed_reg_set \ + (this_target_hard_regs->x_fixed_reg_set) +#define call_used_regs \ + (this_target_hard_regs->x_call_used_regs) +#define call_really_used_regs \ + (this_target_hard_regs->x_call_really_used_regs) +#define call_used_reg_set \ + (this_target_hard_regs->x_call_used_reg_set) +#define call_fixed_reg_set \ + (this_target_hard_regs->x_call_fixed_reg_set) +#define regs_invalidated_by_call \ + (this_target_hard_regs->x_regs_invalidated_by_call) +#define no_caller_save_reg_set \ + (this_target_hard_regs->x_no_caller_save_reg_set) +#define reg_alloc_order \ + (this_target_hard_regs->x_reg_alloc_order) +#define inv_reg_alloc_order \ + (this_target_hard_regs->x_inv_reg_alloc_order) +#define reg_class_contents \ + (this_target_hard_regs->x_reg_class_contents) +#define class_only_fixed_regs \ + (this_target_hard_regs->x_class_only_fixed_regs) +#define reg_class_size \ + (this_target_hard_regs->x_reg_class_size) +#define reg_class_subclasses \ + (this_target_hard_regs->x_reg_class_subclasses) +#define reg_class_subunion \ + (this_target_hard_regs->x_reg_class_subunion) +#define reg_class_superunion \ + (this_target_hard_regs->x_reg_class_superunion) +#define reg_names \ + (this_target_hard_regs->x_reg_names) + +/* Vector indexed by reg class giving its name. */ + +extern const char * reg_class_names[]; + +/* Given a hard REGN a FROM mode and a TO mode, return nonzero if + REGN cannot change modes between the specified modes. */ +#define REG_CANNOT_CHANGE_MODE_P(REGN, FROM, TO) \ + CANNOT_CHANGE_MODE_CLASS (FROM, TO, REGNO_REG_CLASS (REGN)) + +#endif /* ! GCC_HARD_REG_SET_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hashtab.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hashtab.h new file mode 100644 index 0000000..4bb65d6 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hashtab.h @@ -0,0 +1,209 @@ +/* An expandable hash tables datatype. + Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Vladimir Makarov (vmakarov@cygnus.com). + +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" + +#ifndef GTY +#define GTY(X) +#endif + +/* 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 GTY(()) 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 ** GTY ((use_param, length ("%h.size"))) 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 * GTY((skip)) 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/lib/gcc/arm-eabi/4.6.x-google/plugin/include/highlev-plugin-common.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/highlev-plugin-common.h new file mode 100644 index 0000000..7af2d0a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/highlev-plugin-common.h @@ -0,0 +1,33 @@ +/* Interface for high-level plugins in GCC - Parts common between GCC, + ICI and high-level plugins. + + Copyright (C) 2009 Free Software Foundation, Inc. + + Contributed by INRIA. + +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/>. */ + +#ifndef HIGHLEV_PLUGIN_COMMON_H +#define HIGHLEV_PLUGIN_COMMON_H + +/* Return codes for invoke_plugin_callbacks / call_plugin_event . */ +#define PLUGEVT_SUCCESS 0 +#define PLUGEVT_NO_EVENTS 1 +#define PLUGEVT_NO_SUCH_EVENT 2 +#define PLUGEVT_NO_CALLBACK 3 + +#endif /* HIGHLEV_PLUGIN_COMMON_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hwint.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hwint.h new file mode 100644 index 0000000..1eadd45 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/hwint.h @@ -0,0 +1,260 @@ +/* HOST_WIDE_INT definitions for the GNU compiler. + Copyright (C) 1998, 2002, 2004, 2008, 2009, 2010 + Free Software Foundation, Inc. + + This file is part of GCC. + + Provide definitions for macros which depend on HOST_BITS_PER_INT + and HOST_BITS_PER_LONG. */ + +#ifndef GCC_HWINT_H +#define GCC_HWINT_H + +/* This describes the machine the compiler is hosted on. */ +#define HOST_BITS_PER_CHAR CHAR_BIT +#define HOST_BITS_PER_SHORT (CHAR_BIT * SIZEOF_SHORT) +#define HOST_BITS_PER_INT (CHAR_BIT * SIZEOF_INT) +#define HOST_BITS_PER_LONG (CHAR_BIT * SIZEOF_LONG) + +/* The string that should be inserted into a printf style format to + indicate a "long" operand. */ +#ifndef HOST_LONG_FORMAT +#define HOST_LONG_FORMAT "l" +#endif + +/* The string that should be inserted into a printf style format to + indicate a "long long" operand. */ +#ifndef HOST_LONG_LONG_FORMAT +#define HOST_LONG_LONG_FORMAT "ll" +#endif + +/* If HAVE_LONG_LONG and SIZEOF_LONG_LONG aren't defined, but + GCC_VERSION >= 3000, assume this is the second or later stage of a + bootstrap, we do have long long, and it's 64 bits. (This is + required by C99; we do have some ports that violate that assumption + but they're all cross-compile-only.) Just in case, force a + constraint violation if that assumption is incorrect. */ +#if !defined HAVE_LONG_LONG +# if GCC_VERSION >= 3000 +# define HAVE_LONG_LONG 1 +# define SIZEOF_LONG_LONG 8 +extern char sizeof_long_long_must_be_8[sizeof(long long) == 8 ? 1 : -1]; +# endif +#endif + +#ifdef HAVE_LONG_LONG +# define HOST_BITS_PER_LONGLONG (CHAR_BIT * SIZEOF_LONG_LONG) +#endif +#ifdef HAVE___INT64 +# define HOST_BITS_PER___INT64 (CHAR_BIT * SIZEOF___INT64) +#endif + +/* Set HOST_WIDE_INT. This should be the widest efficient host + integer type. It can be 32 or 64 bits, except that if we are + targeting a machine with 64-bit size_t then it has to be 64 bits. + + With a sane ABI, 'long' is the largest efficient host integer type. + Thus, we use that unless we have to use 'long long' or '__int64' + because we're targeting a 64-bit machine from a 32-bit host. */ + +#if HOST_BITS_PER_LONG >= 64 || !defined NEED_64BIT_HOST_WIDE_INT +# define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG +# define HOST_WIDE_INT long +#else +# if HOST_BITS_PER_LONGLONG >= 64 +# define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONGLONG +# define HOST_WIDE_INT long long +# else +# if HOST_BITS_PER___INT64 >= 64 +# define HOST_BITS_PER_WIDE_INT HOST_BITS_PER___INT64 +# define HOST_WIDE_INT __int64 +# else + #error "Unable to find a suitable type for HOST_WIDE_INT" +# endif +# endif +#endif + +/* Various printf format strings for HOST_WIDE_INT. */ + +#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG +# define HOST_WIDE_INT_PRINT HOST_LONG_FORMAT +# define HOST_WIDE_INT_PRINT_C "L" + /* 'long' might be 32 or 64 bits, and the number of leading zeroes + must be tweaked accordingly. */ +# if HOST_BITS_PER_WIDE_INT == 64 +# define HOST_WIDE_INT_PRINT_DOUBLE_HEX \ + "0x%" HOST_LONG_FORMAT "x%016" HOST_LONG_FORMAT "x" +# else +# define HOST_WIDE_INT_PRINT_DOUBLE_HEX \ + "0x%" HOST_LONG_FORMAT "x%08" HOST_LONG_FORMAT "x" +# endif +#else +# define HOST_WIDE_INT_PRINT HOST_LONG_LONG_FORMAT +# define HOST_WIDE_INT_PRINT_C "LL" + /* We can assume that 'long long' is at least 64 bits. */ +# define HOST_WIDE_INT_PRINT_DOUBLE_HEX \ + "0x%" HOST_LONG_LONG_FORMAT "x%016" HOST_LONG_LONG_FORMAT "x" +#endif /* HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG */ + +#define HOST_WIDE_INT_PRINT_DEC "%" HOST_WIDE_INT_PRINT "d" +#define HOST_WIDE_INT_PRINT_DEC_C HOST_WIDE_INT_PRINT_DEC HOST_WIDE_INT_PRINT_C +#define HOST_WIDE_INT_PRINT_UNSIGNED "%" HOST_WIDE_INT_PRINT "u" +#define HOST_WIDE_INT_PRINT_HEX "%#" HOST_WIDE_INT_PRINT "x" + +/* Set HOST_WIDEST_INT. This is a 64-bit type unless the compiler + in use has no 64-bit type at all; in that case it's 32 bits. */ + +#if HOST_BITS_PER_WIDE_INT >= 64 \ + || (HOST_BITS_PER_LONGLONG < 64 && HOST_BITS_PER___INT64 < 64) +# define HOST_WIDEST_INT HOST_WIDE_INT +# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_WIDE_INT +# define HOST_WIDEST_INT_PRINT HOST_WIDE_INT_PRINT +# define HOST_WIDEST_INT_PRINT_DEC HOST_WIDE_INT_PRINT_DEC +# define HOST_WIDEST_INT_PRINT_DEC_C HOST_WIDE_INT_PRINT_DEC_C +# define HOST_WIDEST_INT_PRINT_UNSIGNED HOST_WIDE_INT_PRINT_UNSIGNED +# define HOST_WIDEST_INT_PRINT_HEX HOST_WIDE_INT_PRINT_HEX +# define HOST_WIDEST_INT_PRINT_DOUBLE_HEX HOST_WIDE_INT_PRINT_DOUBLE_HEX +#else +# if HOST_BITS_PER_LONGLONG >= 64 +# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONGLONG +# define HOST_WIDEST_INT long long +# else +# if HOST_BITS_PER___INT64 >= 64 +# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER___INT64 +# define HOST_WIDEST_INT __int64 +# else + #error "This line should be impossible to reach" +# endif +# endif +# define HOST_WIDEST_INT_PRINT HOST_LONG_LONG_FORMAT +# define HOST_WIDEST_INT_PRINT_DEC "%" HOST_LONG_LONG_FORMAT "d" +# define HOST_WIDEST_INT_PRINT_DEC_C "%" HOST_LONG_LONG_FORMAT "dLL" +# define HOST_WIDEST_INT_PRINT_UNSIGNED "%" HOST_LONG_LONG_FORMAT "u" +# define HOST_WIDEST_INT_PRINT_HEX "%#" HOST_LONG_LONG_FORMAT "x" +# define HOST_WIDEST_INT_PRINT_DOUBLE_HEX \ + "0x%" HOST_LONG_LONG_FORMAT "x%016" HOST_LONG_LONG_FORMAT "x" +#endif + +/* Define HOST_WIDEST_FAST_INT to the widest integer type supported + efficiently in hardware. (That is, the widest integer type that fits + in a hardware register.) Normally this is "long" but on some hosts it + should be "long long" or "__int64". This is no convenient way to + autodetect this, so such systems must set a flag in config.host; see there + for details. */ + +#ifdef USE_LONG_LONG_FOR_WIDEST_FAST_INT +# ifdef HAVE_LONG_LONG +# define HOST_WIDEST_FAST_INT long long +# define HOST_BITS_PER_WIDEST_FAST_INT HOST_BITS_PER_LONGLONG +# elif defined (HAVE___INT64) +# define HOST_WIDEST_FAST_INT __int64 +# define HOST_BITS_PER_WIDEST_FAST_INT HOST_BITS_PER___INT64 +# else +# error "Your host said it wanted to use long long or __int64 but neither" +# error "exist" +# endif +#else +# define HOST_WIDEST_FAST_INT long +# define HOST_BITS_PER_WIDEST_FAST_INT HOST_BITS_PER_LONG +#endif + +/* Inline functions operating on HOST_WIDE_INT. */ +#if GCC_VERSION < 3004 + +extern int clz_hwi (unsigned HOST_WIDE_INT x); +extern int ctz_hwi (unsigned HOST_WIDE_INT x); +extern int ffs_hwi (unsigned HOST_WIDE_INT x); + +/* Return log2, or -1 if not exact. */ +extern int exact_log2 (unsigned HOST_WIDE_INT); + +/* Return floor of log2, with -1 for zero. */ +extern int floor_log2 (unsigned HOST_WIDE_INT); + +#else /* GCC_VERSION >= 3004 */ + +/* For convenience, define 0 -> word_size. */ +static inline int +clz_hwi (unsigned HOST_WIDE_INT x) +{ + if (x == 0) + return HOST_BITS_PER_WIDE_INT; +# if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG + return __builtin_clzl (x); +# elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG + return __builtin_clzll (x); +# else + return __builtin_clz (x); +# endif +} + +static inline int +ctz_hwi (unsigned HOST_WIDE_INT x) +{ + if (x == 0) + return HOST_BITS_PER_WIDE_INT; +# if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG + return __builtin_ctzl (x); +# elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG + return __builtin_ctzll (x); +# else + return __builtin_ctz (x); +# endif +} + +static inline int +ffs_hwi (unsigned HOST_WIDE_INT x) +{ +# if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG + return __builtin_ffsl (x); +# elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG + return __builtin_ffsll (x); +# else + return __builtin_ffs (x); +# endif +} + +static inline int +floor_log2 (unsigned HOST_WIDE_INT x) +{ + return HOST_BITS_PER_WIDE_INT - 1 - clz_hwi (x); +} + +static inline int +exact_log2 (unsigned HOST_WIDE_INT x) +{ + return x == (x & -x) && x ? ctz_hwi (x) : -1; +} + +#endif /* GCC_VERSION >= 3004 */ + +/* Compute the greatest common divisor of two numbers using + Euclid's algorithm. */ + +static inline int +gcd (int a, int b) +{ + int x, y, z; + + x = abs (a); + y = abs (b); + + while (x > 0) + { + z = y % x; + y = x; + x = z; + } + + return y; +} + +/* Compute the least common multiple of two numbers A and B . */ + +static inline int +least_common_multiple (int a, int b) +{ + return (abs (a) * abs (b) / gcd (a, b)); +} + +#endif /* ! GCC_HWINT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/incpath.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/incpath.h new file mode 100644 index 0000000..065f552 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/incpath.h @@ -0,0 +1,36 @@ +/* Set up combined include path for the preprocessor. + Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 + Free Software Foundation, Inc. + + 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 3, 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; see the file COPYING3. If not see + <http://www.gnu.org/licenses/>. */ + +extern void split_quote_chain (void); +extern void add_path (char *, int, int, bool); +extern void register_include_chains (cpp_reader *, const char *, + const char *, const char *, + int, int, int); +extern void add_cpp_dir_path (struct cpp_dir *, int); +extern void get_include_chains (cpp_dir **quotes, cpp_dir **brackets); +extern void clear_include_chains (void); + +struct target_c_incpath_s { + /* Do extra includes processing. STDINC is false iff -nostdinc was given. */ + void (*extra_pre_includes) (const char *, const char *, int); + void (*extra_includes) (const char *, const char *, int); +}; + +extern struct target_c_incpath_s target_c_incpath; + +enum { QUOTE = 0, BRACKET, SYSTEM, AFTER }; diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/input.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/input.h new file mode 100644 index 0000000..6b79871 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/input.h @@ -0,0 +1,75 @@ +/* Declarations for variables relating to reading the source file. + Used by parsers, lexical analyzers, and error message routines. + Copyright (C) 1993, 1997, 1998, 2000, 2003, 2004, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_INPUT_H +#define GCC_INPUT_H + +#include "line-map.h" + +extern GTY(()) struct line_maps *line_table; + +/* A value which will never be used to represent a real location. */ +#define UNKNOWN_LOCATION ((source_location) 0) + +/* The location for declarations in "<built-in>" */ +#define BUILTINS_LOCATION ((source_location) 1) + +/* line-map.c reserves RESERVED_LOCATION_COUNT to the user. Ensure + both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that. */ +extern char builtins_location_check[(BUILTINS_LOCATION + < RESERVED_LOCATION_COUNT) ? 1 : -1]; + +typedef struct +{ + /* The name of the source file involved. */ + const char *file; + + /* The line-location in the source file. */ + int line; + + int column; + + /* In a system header?. */ + bool sysp; +} expanded_location; + +extern expanded_location expand_location (source_location); + +/* Historically GCC used location_t, while cpp used source_location. + This could be removed but it hardly seems worth the effort. */ +typedef source_location location_t; + +extern location_t input_location; + +extern location_t location_with_discriminator (location_t, int); +extern bool has_discriminator (location_t); +extern location_t map_discriminator_location (location_t); +extern int get_discriminator_from_locus (location_t); + +#define LOCATION_FILE(LOC) ((expand_location (LOC)).file) +#define LOCATION_LINE(LOC) ((expand_location (LOC)).line) + +#define input_line LOCATION_LINE (input_location) +#define input_filename LOCATION_FILE (input_location) +#define in_system_header_at(LOC) ((expand_location (LOC)).sysp != 0) +#define in_system_header (in_system_header_at (input_location)) + +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-constants.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-constants.h new file mode 100644 index 0000000..aedbc69 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-constants.h @@ -0,0 +1,196 @@ +/* Generated automatically by the program `genconstants' + from the machine description file `md'. */ + +#ifndef GCC_INSN_CONSTANTS_H +#define GCC_INSN_CONSTANTS_H + +#define UNSPEC_VSUB 192 +#define UNSPEC_VST4B 189 +#define UNSPEC_VHADD 97 +#define UNSPEC_VPUMAX 142 +#define UNSPEC_GOT_PREL_SYM 29 +#define UNSPEC_VMLS 121 +#define UNSPEC_GOTSYM_OFF 24 +#define VUNSPEC_ALIGN8 11 +#define UNSPEC_VPADAL 135 +#define UNSPEC_VSHR_N 174 +#define UNSPEC_VPADDL 137 +#define UNSPEC_VQDMULH_LANE 151 +#define UNSPEC_PIC_OFFSET 23 +#define UNSPEC_VST3_LANE 186 +#define UNSPEC_VREV32 166 +#define UNSPEC_VPADD 136 +#define VUNSPEC_SYNC_NEW_OP 24 +#define UNSPEC_VRECPE 163 +#define UNSPEC_VLD4B 112 +#define UNSPEC_VTST 200 +#define VUNSPEC_SYNC_OP 23 +#define DOM_CC_X_OR_Y 2 +#define R0_REGNUM 0 +#define UNSPEC_VABDL 70 +#define UNSPEC_VMAX 115 +#define VUNSPEC_POOL_16 8 +#define UNSPEC_VCLE 206 +#define UNSPEC_VST3 183 +#define UNSPEC_VBSL 78 +#define UNSPEC_VLD3A 106 +#define VUNSPEC_WCMP_GTU 13 +#define DOM_CC_X_AND_Y 0 +#define UNSPEC_VEXT 93 +#define UNSPEC_VQSHL_N 158 +#define UNSPEC_VSHLL_N 172 +#define UNSPEC_VQSUB 162 +#define UNSPEC_VCLS 84 +#define UNSPEC_VST3A 184 +#define VUNSPEC_EPILOGUE 1 +#define UNSPEC_VST3B 185 +#define UNSPEC_PIC_LABEL 21 +#define UNSPEC_WACC 9 +#define VUNSPEC_BLOCKAGE 0 +#define UNSPEC_VADD 72 +#define UNSPEC_VMULL 128 +#define UNSPEC_VPMIN 139 +#define UNSPEC_VMLSL 122 +#define UNSPEC_VQDMLSL_LANE 149 +#define VUNSPEC_SYNC_LOCK 22 +#define UNSPEC_VMLS_LANE 123 +#define UNSPEC_VLD2_DUP 103 +#define VUNSPEC_WCMP_EQ 12 +#define UNSPEC_MEMORY_BARRIER 28 +#define UNSPEC_VCAGE 79 +#define UNSPEC_VLD4_DUP 113 +#define UNSPEC_VLD3_LANE 109 +#define UNSPEC_WSADZ 12 +#define VUNSPEC_EH_RETURN 20 +#define UNSPEC_VLD4_LANE 114 +#define UNSPEC_VCVT_N 89 +#define UNSPEC_VLD1_LANE 101 +#define UNSPEC_VMLSL_LANE 124 +#define UNSPEC_VUZP1 201 +#define UNSPEC_SIN 0 +#define UNSPEC_VQADD 145 +#define UNSPEC_VCEQ 81 +#define UNSPEC_VQSHRUN_N 161 +#define UNSPEC_VST4 187 +#define UNSPEC_VMLA 117 +#define UNSPEC_VQSHL 157 +#define UNSPEC_VQSHLU_N 159 +#define UNSPEC_PIC_SYM 3 +#define UNSPEC_VSUBL 194 +#define UNSPEC_VSTRUCTDUMMY 191 +#define UNSPEC_VMLA_LANE 119 +#define UNSPEC_VQMOVUN 155 +#define VUNSPEC_POOL_END 3 +#define VUNSPEC_ALIGN 2 +#define UNSPEC_VMUL 127 +#define FPA_F7_REGNUM 23 +#define UNSPEC_SYMBOL_OFFSET 27 +#define UNSPEC_VQDMULL 152 +#define UNSPEC_VQMOVN 154 +#define FPA_F0_REGNUM 16 +#define UNSPEC_CLRDI 17 +#define UNSPEC_MISALIGNED_ACCESS 205 +#define UNSPEC_WMACS 13 +#define UNSPEC_VZIP2 204 +#define UNSPEC_WMACU 14 +#define UNSPEC_VHSUB 98 +#define UNSPEC_RBIT 26 +#define UNSPEC_VTBX 197 +#define UNSPEC_VLD1_DUP 100 +#define VUNSPEC_POOL_1 4 +#define VUNSPEC_POOL_2 5 +#define UNSPEC_VSRA_N 177 +#define VUNSPEC_POOL_4 6 +#define UNSPEC_VST1 179 +#define UNPSEC_COS 1 +#define VUNSPEC_POOL_8 7 +#define UNSPEC_THUMB1_CASESI 25 +#define UNSPEC_VMOVL 125 +#define UNSPEC_WMADDS 18 +#define UNSPEC_VMOVN 126 +#define UNSPEC_WMADDU 19 +#define UNSPEC_VPUMIN 143 +#define UNSPEC_VQABS 144 +#define UNSPEC_VLD3B 107 +#define PC_REGNUM 15 +#define UNSPEC_VLD3_DUP 108 +#define UNSPEC_VSUBW 195 +#define UNSPEC_VCAGT 80 +#define LR_REGNUM 14 +#define VFPCC_REGNUM 127 +#define UNSPEC_VTBL 196 +#define UNSPEC_VSUBHN 193 +#define UNSPEC_WSAD 11 +#define UNSPEC_VST4A 188 +#define UNSPEC_PROLOGUE_USE 6 +#define UNSPEC_PIC_BASE 4 +#define UNSPEC_VSLI 176 +#define VUNSPEC_TMRC 9 +#define UNSPEC_PUSH_MULT 2 +#define UNSPEC_VQDMLAL 146 +#define UNSPEC_VADDHN 73 +#define UNSPEC_TMOVMSK 10 +#define UNSPEC_WMACSZ 15 +#define UNSPEC_VRSQRTS 169 +#define UNSPEC_VMUL_LANE 129 +#define VUNSPEC_TMCR 10 +#define VUNSPEC_SYNC_OLD_OP 25 +#define UNSPEC_VMLAL_LANE 120 +#define CC_REGNUM 24 +#define UNSPEC_VQDMULH 150 +#define UNSPEC_ASHIFT_UNSIGNED 66 +#define UNSPEC_VST2 181 +#define UNSPEC_VSHRN_N 175 +#define UNSPEC_PRLG_STK 5 +#define UNSPEC_VTRN1 198 +#define UNSPEC_TLS 20 +#define UNSPEC_VLD4A 111 +#define UNSPEC_VUZP2 202 +#define UNSPEC_VPSMIN 141 +#define UNSPEC_VLD2 102 +#define UNSPEC_VMULL_LANE 130 +#define UNSPEC_VREV64 167 +#define UNSPEC_VSHL 171 +#define UNSPEC_VRSQRTE 168 +#define IP_REGNUM 12 +#define UNSPEC_VCGE 82 +#define UNSPEC_VLD2_LANE 104 +#define UNSPEC_VABD 69 +#define UNSPEC_WMACUZ 16 +#define VUNSPEC_WCMP_GT 14 +#define UNSPEC_VQSHRN_N 160 +#define UNSPEC_VTRN2 199 +#define UNSPEC_VRECPS 164 +#define UNSPEC_VREV16 165 +#define UNSPEC_VQDMULL_LANE 153 +#define UNSPEC_VSRI 178 +#define UNSPEC_CHECK_ARCH 7 +#define UNSPEC_VST1_LANE 180 +#define UNSPEC_VCGT 83 +#define UNSPEC_VCVT 88 +#define UNSPEC_STACK_ALIGN 22 +#define UNSPEC_VST4_LANE 190 +#define UNSPEC_VZIP1 203 +#define UNSPEC_VLD1 99 +#define UNSPEC_VADDL 74 +#define UNSPEC_VLD3 105 +#define UNSPEC_VLD4 110 +#define UNSPEC_VSHL_N 173 +#define UNSPEC_VQNEG 156 +#define UNSPEC_VMLAL 118 +#define VUNSPEC_SYNC_COMPARE_AND_SWAP 21 +#define LAST_ARM_REGNUM 15 +#define UNSPEC_VPSMAX 140 +#define UNSPEC_ASHIFT_SIGNED 65 +#define DOM_CC_NX_OR_Y 1 +#define UNSPEC_VST2_LANE 182 +#define UNSPEC_VCLT 207 +#define UNSPEC_VMIN 116 +#define UNSPEC_VADDW 75 +#define UNSPEC_WSHUFH 8 +#define UNSPEC_VPMAX 138 +#define UNSPEC_VQDMLAL_LANE 147 +#define SP_REGNUM 13 +#define UNSPEC_VQDMLSL 148 + +#endif /* GCC_INSN_CONSTANTS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-flags.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-flags.h new file mode 100644 index 0000000..e014fa3 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-flags.h @@ -0,0 +1,3921 @@ +/* Generated automatically by the program `genflags' + from the machine description file `md'. */ + +#ifndef GCC_INSN_FLAGS_H +#define GCC_INSN_FLAGS_H + +#define HAVE_thumb1_subsi3_insn (TARGET_THUMB1) +#define HAVE_mulhisi3 (TARGET_DSP_MULTIPLY) +#define HAVE_maddhisi4 (TARGET_DSP_MULTIPLY) +#define HAVE_insv_zero (arm_arch_thumb2) +#define HAVE_insv_t2 (arm_arch_thumb2) +#define HAVE_andsi_notsi_si (TARGET_32BIT) +#define HAVE_thumb1_bicsi3 (TARGET_THUMB1) +#define HAVE_andsi_not_shiftsi_si (TARGET_ARM) +#define HAVE_arm_ashldi3_1bit (TARGET_32BIT) +#define HAVE_arm_ashrdi3_1bit (TARGET_32BIT) +#define HAVE_arm_lshrdi3_1bit (TARGET_32BIT) +#define HAVE_extv (arm_arch_thumb2) +#define HAVE_extzv_t2 (arm_arch_thumb2) +#define HAVE_one_cmpldi2 (TARGET_32BIT) +#define HAVE_zero_extendqidi2 (TARGET_32BIT ) +#define HAVE_zero_extendhidi2 (TARGET_32BIT && arm_arch6) +#define HAVE_zero_extendsidi2 (TARGET_32BIT ) +#define HAVE_extendqidi2 (TARGET_32BIT && arm_arch6) +#define HAVE_extendhidi2 (TARGET_32BIT && arm_arch6) +#define HAVE_extendsidi2 (TARGET_32BIT ) +#define HAVE_thumb1_extendhisi2 (TARGET_THUMB1) +#define HAVE_thumb1_extendqisi2 (TARGET_THUMB1) +#define HAVE_pic_load_addr_32bit (TARGET_32BIT && flag_pic) +#define HAVE_pic_load_addr_thumb1 (TARGET_THUMB1 && flag_pic) +#define HAVE_pic_add_dot_plus_four (TARGET_THUMB) +#define HAVE_pic_add_dot_plus_eight (TARGET_ARM) +#define HAVE_tls_load_dot_plus_eight (TARGET_ARM) +#define HAVE_movmem12b (TARGET_THUMB1) +#define HAVE_movmem8b (TARGET_THUMB1) +#define HAVE_cbranchsi4_insn (TARGET_THUMB1) +#define HAVE_cbranchsi4_scratch (TARGET_THUMB1) +#define HAVE_cstoresi_nltu_thumb1 (TARGET_THUMB1) +#define HAVE_cstoresi_ltu_thumb1 (TARGET_THUMB1) +#define HAVE_thumb1_addsi3_addgeu (TARGET_THUMB1) +#define HAVE_blockage 1 +#define HAVE_arm_casesi_internal (TARGET_ARM) +#define HAVE_thumb1_casesi_dispatch (TARGET_THUMB1) +#define HAVE_nop 1 +#define HAVE_movcond (TARGET_ARM) +#define HAVE_sibcall_epilogue (TARGET_32BIT) +#define HAVE_stack_tie 1 +#define HAVE_align_4 1 +#define HAVE_align_8 1 +#define HAVE_consttable_end 1 +#define HAVE_consttable_1 (TARGET_THUMB1) +#define HAVE_consttable_2 (TARGET_THUMB1) +#define HAVE_consttable_4 1 +#define HAVE_consttable_8 1 +#define HAVE_consttable_16 1 +#define HAVE_clzsi2 (TARGET_32BIT && arm_arch5) +#define HAVE_rbitsi2 (TARGET_32BIT && arm_arch_thumb2) +#define HAVE_prefetch (TARGET_32BIT && arm_arch5e) +#define HAVE_prologue_use 1 +#define HAVE_arm_eh_return (TARGET_ARM) +#define HAVE_thumb_eh_return (TARGET_THUMB1) +#define HAVE_load_tp_hard (TARGET_HARD_TP) +#define HAVE_load_tp_soft (TARGET_SOFT_TP) +#define HAVE_cirrus_adddi3 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_subdi3 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_muldi3 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_ashldi3_cirrus (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_ashldi_const (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_ashiftrtdi_const (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_floatsisf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_floatsidf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_floatdisf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_floatdidf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_truncsfsi2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_cirrus_truncdfsi2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_MAVERICK) +#define HAVE_iwmmxt_iordi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_xordi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_anddi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_nanddi3 (TARGET_REALLY_IWMMXT) +#define HAVE_movv2si_internal (TARGET_REALLY_IWMMXT) +#define HAVE_movv4hi_internal (TARGET_REALLY_IWMMXT) +#define HAVE_movv8qi_internal (TARGET_REALLY_IWMMXT) +#define HAVE_ssaddv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_ssaddv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_ssaddv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_usaddv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_usaddv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_usaddv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_sssubv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_sssubv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_sssubv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_ussubv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_ussubv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_ussubv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_smulv4hi3_highpart (TARGET_REALLY_IWMMXT) +#define HAVE_umulv4hi3_highpart (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wmacs (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wmacsz (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wmacu (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wmacuz (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_clrdi (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_uavgrndv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_uavgrndv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_uavgv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_uavgv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_psadbw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tinsrb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tinsrh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tinsrw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_textrmub (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_textrmsb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_textrmuh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_textrmsh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_textrmw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wshufh (TARGET_REALLY_IWMMXT) +#define HAVE_eqv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_eqv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_eqv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_gtuv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_gtuv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_gtuv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_gtv8qi3 (TARGET_REALLY_IWMMXT) +#define HAVE_gtv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_gtv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wpackhss (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wpackwss (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wpackdss (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wpackhus (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wpackwus (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wpackdus (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckihb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckihh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckihw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckilb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckilh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckilw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckehub (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckehuh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckehuw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckehsb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckehsh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckehsw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckelub (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckeluh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckeluw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckelsb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckelsh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wunpckelsw (TARGET_REALLY_IWMMXT) +#define HAVE_rorv4hi3 (TARGET_REALLY_IWMMXT) +#define HAVE_rorv2si3 (TARGET_REALLY_IWMMXT) +#define HAVE_rordi3 (TARGET_REALLY_IWMMXT) +#define HAVE_ashrv4hi3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_ashrv2si3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_ashrdi3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_lshrv4hi3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_lshrv2si3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_lshrdi3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_ashlv4hi3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_ashlv2si3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_ashldi3_iwmmxt (TARGET_REALLY_IWMMXT) +#define HAVE_rorv4hi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_rorv2si3_di (TARGET_REALLY_IWMMXT) +#define HAVE_rordi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_ashrv4hi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_ashrv2si3_di (TARGET_REALLY_IWMMXT) +#define HAVE_ashrdi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_lshrv4hi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_lshrv2si3_di (TARGET_REALLY_IWMMXT) +#define HAVE_lshrdi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_ashlv4hi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_ashlv2si3_di (TARGET_REALLY_IWMMXT) +#define HAVE_ashldi3_di (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wmadds (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wmaddu (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmia (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmiaph (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmiabb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmiatb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmiabt (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmiatt (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tbcstqi (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tbcsthi (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tbcstsi (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmovmskb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmovmskh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmovmskw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_waccb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wacch (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_waccw (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_walign (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmrc (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_tmcr (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wsadb (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wsadh (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wsadbz (TARGET_REALLY_IWMMXT) +#define HAVE_iwmmxt_wsadhz (TARGET_REALLY_IWMMXT) +#define HAVE_extendhfsf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FP16) +#define HAVE_truncsfhf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FP16) +#define HAVE_fixuns_truncsfsi2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_VFP) +#define HAVE_fixuns_truncdfsi2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_VFP_DOUBLE) +#define HAVE_floatunssisf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_VFP) +#define HAVE_floatunssidf2 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_VFP_DOUBLE) +#define HAVE_tls_load_dot_plus_four (TARGET_THUMB2) +#define HAVE_thumb2_zero_extendqisi2_v6 (TARGET_THUMB2 && arm_arch6) +#define HAVE_thumb2_casesi_internal (TARGET_THUMB2 && !flag_pic) +#define HAVE_thumb2_casesi_internal_pic (TARGET_THUMB2 && flag_pic) +#define HAVE_thumb2_eh_return (TARGET_THUMB2) +#define HAVE_divsi3 (TARGET_THUMB2 && arm_arch_hwdiv) +#define HAVE_udivsi3 (TARGET_THUMB2 && arm_arch_hwdiv) +#define HAVE_vec_setv8qi_internal (TARGET_NEON) +#define HAVE_vec_setv4hi_internal (TARGET_NEON) +#define HAVE_vec_setv2si_internal (TARGET_NEON) +#define HAVE_vec_setv2sf_internal (TARGET_NEON) +#define HAVE_vec_setv16qi_internal (TARGET_NEON) +#define HAVE_vec_setv8hi_internal (TARGET_NEON) +#define HAVE_vec_setv4si_internal (TARGET_NEON) +#define HAVE_vec_setv4sf_internal (TARGET_NEON) +#define HAVE_vec_setv2di_internal (TARGET_NEON) +#define HAVE_vec_extractv8qi (TARGET_NEON) +#define HAVE_vec_extractv4hi (TARGET_NEON) +#define HAVE_vec_extractv2si (TARGET_NEON) +#define HAVE_vec_extractv2sf (TARGET_NEON) +#define HAVE_vec_extractv16qi (TARGET_NEON) +#define HAVE_vec_extractv8hi (TARGET_NEON) +#define HAVE_vec_extractv4si (TARGET_NEON) +#define HAVE_vec_extractv4sf (TARGET_NEON) +#define HAVE_vec_extractv2di (TARGET_NEON) +#define HAVE_adddi3_neon (TARGET_NEON) +#define HAVE_subdi3_neon (TARGET_NEON) +#define HAVE_mulv8qi3addv8qi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv16qi3addv16qi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv4hi3addv4hi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv8hi3addv8hi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv2si3addv2si_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv4si3addv4si_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv2sf3addv2sf_neon (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_mulv4sf3addv4sf_neon (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_mulv2di3addv2di_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv8qi3negv8qiaddv8qi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv16qi3negv16qiaddv16qi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv4hi3negv4hiaddv4hi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv8hi3negv8hiaddv8hi_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv2si3negv2siaddv2si_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv4si3negv4siaddv4si_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_mulv2sf3negv2sfaddv2sf_neon (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_mulv4sf3negv4sfaddv4sf_neon (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_mulv2di3negv2diaddv2di_neon (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_iorv8qi3 (TARGET_NEON) +#define HAVE_iorv16qi3 (TARGET_NEON) +#define HAVE_iorv4hi3 (TARGET_NEON) +#define HAVE_iorv8hi3 (TARGET_NEON) +#define HAVE_iorv2si3 (TARGET_NEON) +#define HAVE_iorv4si3 (TARGET_NEON) +#define HAVE_iorv2sf3 (TARGET_NEON) +#define HAVE_iorv4sf3 (TARGET_NEON) +#define HAVE_iorv2di3 (TARGET_NEON) +#define HAVE_iordi3_neon (TARGET_NEON) +#define HAVE_andv8qi3 (TARGET_NEON) +#define HAVE_andv16qi3 (TARGET_NEON) +#define HAVE_andv4hi3 (TARGET_NEON) +#define HAVE_andv8hi3 (TARGET_NEON) +#define HAVE_andv2si3 (TARGET_NEON) +#define HAVE_andv4si3 (TARGET_NEON) +#define HAVE_andv2sf3 (TARGET_NEON) +#define HAVE_andv4sf3 (TARGET_NEON) +#define HAVE_andv2di3 (TARGET_NEON) +#define HAVE_anddi3_neon (TARGET_NEON) +#define HAVE_ornv8qi3_neon (TARGET_NEON) +#define HAVE_ornv16qi3_neon (TARGET_NEON) +#define HAVE_ornv4hi3_neon (TARGET_NEON) +#define HAVE_ornv8hi3_neon (TARGET_NEON) +#define HAVE_ornv2si3_neon (TARGET_NEON) +#define HAVE_ornv4si3_neon (TARGET_NEON) +#define HAVE_ornv2sf3_neon (TARGET_NEON) +#define HAVE_ornv4sf3_neon (TARGET_NEON) +#define HAVE_ornv2di3_neon (TARGET_NEON) +#define HAVE_orndi3_neon (TARGET_NEON) +#define HAVE_bicv8qi3_neon (TARGET_NEON) +#define HAVE_bicv16qi3_neon (TARGET_NEON) +#define HAVE_bicv4hi3_neon (TARGET_NEON) +#define HAVE_bicv8hi3_neon (TARGET_NEON) +#define HAVE_bicv2si3_neon (TARGET_NEON) +#define HAVE_bicv4si3_neon (TARGET_NEON) +#define HAVE_bicv2sf3_neon (TARGET_NEON) +#define HAVE_bicv4sf3_neon (TARGET_NEON) +#define HAVE_bicv2di3_neon (TARGET_NEON) +#define HAVE_bicdi3_neon (TARGET_NEON) +#define HAVE_xorv8qi3 (TARGET_NEON) +#define HAVE_xorv16qi3 (TARGET_NEON) +#define HAVE_xorv4hi3 (TARGET_NEON) +#define HAVE_xorv8hi3 (TARGET_NEON) +#define HAVE_xorv2si3 (TARGET_NEON) +#define HAVE_xorv4si3 (TARGET_NEON) +#define HAVE_xorv2sf3 (TARGET_NEON) +#define HAVE_xorv4sf3 (TARGET_NEON) +#define HAVE_xorv2di3 (TARGET_NEON) +#define HAVE_xordi3_neon (TARGET_NEON) +#define HAVE_one_cmplv8qi2 (TARGET_NEON) +#define HAVE_one_cmplv16qi2 (TARGET_NEON) +#define HAVE_one_cmplv4hi2 (TARGET_NEON) +#define HAVE_one_cmplv8hi2 (TARGET_NEON) +#define HAVE_one_cmplv2si2 (TARGET_NEON) +#define HAVE_one_cmplv4si2 (TARGET_NEON) +#define HAVE_one_cmplv2sf2 (TARGET_NEON) +#define HAVE_one_cmplv4sf2 (TARGET_NEON) +#define HAVE_one_cmplv2di2 (TARGET_NEON) +#define HAVE_absv8qi2 (TARGET_NEON) +#define HAVE_absv16qi2 (TARGET_NEON) +#define HAVE_absv4hi2 (TARGET_NEON) +#define HAVE_absv8hi2 (TARGET_NEON) +#define HAVE_absv2si2 (TARGET_NEON) +#define HAVE_absv4si2 (TARGET_NEON) +#define HAVE_absv2sf2 (TARGET_NEON) +#define HAVE_absv4sf2 (TARGET_NEON) +#define HAVE_negv8qi2 (TARGET_NEON) +#define HAVE_negv16qi2 (TARGET_NEON) +#define HAVE_negv4hi2 (TARGET_NEON) +#define HAVE_negv8hi2 (TARGET_NEON) +#define HAVE_negv2si2 (TARGET_NEON) +#define HAVE_negv4si2 (TARGET_NEON) +#define HAVE_negv2sf2 (TARGET_NEON) +#define HAVE_negv4sf2 (TARGET_NEON) +#define HAVE_vashlv8qi3 (TARGET_NEON) +#define HAVE_vashlv16qi3 (TARGET_NEON) +#define HAVE_vashlv4hi3 (TARGET_NEON) +#define HAVE_vashlv8hi3 (TARGET_NEON) +#define HAVE_vashlv2si3 (TARGET_NEON) +#define HAVE_vashlv4si3 (TARGET_NEON) +#define HAVE_ashlv8qi3_signed (TARGET_NEON) +#define HAVE_ashlv16qi3_signed (TARGET_NEON) +#define HAVE_ashlv4hi3_signed (TARGET_NEON) +#define HAVE_ashlv8hi3_signed (TARGET_NEON) +#define HAVE_ashlv2si3_signed (TARGET_NEON) +#define HAVE_ashlv4si3_signed (TARGET_NEON) +#define HAVE_ashlv2di3_signed (TARGET_NEON) +#define HAVE_ashlv8qi3_unsigned (TARGET_NEON) +#define HAVE_ashlv16qi3_unsigned (TARGET_NEON) +#define HAVE_ashlv4hi3_unsigned (TARGET_NEON) +#define HAVE_ashlv8hi3_unsigned (TARGET_NEON) +#define HAVE_ashlv2si3_unsigned (TARGET_NEON) +#define HAVE_ashlv4si3_unsigned (TARGET_NEON) +#define HAVE_ashlv2di3_unsigned (TARGET_NEON) +#define HAVE_widen_ssumv8qi3 (TARGET_NEON) +#define HAVE_widen_ssumv4hi3 (TARGET_NEON) +#define HAVE_widen_ssumv2si3 (TARGET_NEON) +#define HAVE_widen_usumv8qi3 (TARGET_NEON) +#define HAVE_widen_usumv4hi3 (TARGET_NEON) +#define HAVE_widen_usumv2si3 (TARGET_NEON) +#define HAVE_quad_halves_plusv4si (TARGET_NEON) +#define HAVE_quad_halves_sminv4si (TARGET_NEON) +#define HAVE_quad_halves_smaxv4si (TARGET_NEON) +#define HAVE_quad_halves_uminv4si (TARGET_NEON) +#define HAVE_quad_halves_umaxv4si (TARGET_NEON) +#define HAVE_quad_halves_plusv4sf (TARGET_NEON && flag_unsafe_math_optimizations) +#define HAVE_quad_halves_sminv4sf (TARGET_NEON && flag_unsafe_math_optimizations) +#define HAVE_quad_halves_smaxv4sf (TARGET_NEON && flag_unsafe_math_optimizations) +#define HAVE_quad_halves_plusv8hi (TARGET_NEON) +#define HAVE_quad_halves_sminv8hi (TARGET_NEON) +#define HAVE_quad_halves_smaxv8hi (TARGET_NEON) +#define HAVE_quad_halves_uminv8hi (TARGET_NEON) +#define HAVE_quad_halves_umaxv8hi (TARGET_NEON) +#define HAVE_quad_halves_plusv16qi (TARGET_NEON) +#define HAVE_quad_halves_sminv16qi (TARGET_NEON) +#define HAVE_quad_halves_smaxv16qi (TARGET_NEON) +#define HAVE_quad_halves_uminv16qi (TARGET_NEON) +#define HAVE_quad_halves_umaxv16qi (TARGET_NEON) +#define HAVE_neon_move_lo_quad_v2di (TARGET_NEON) +#define HAVE_neon_move_lo_quad_v2df (TARGET_NEON) +#define HAVE_neon_move_lo_quad_v16qi (TARGET_NEON) +#define HAVE_neon_move_lo_quad_v8hi (TARGET_NEON) +#define HAVE_neon_move_lo_quad_v4si (TARGET_NEON) +#define HAVE_neon_move_lo_quad_v4sf (TARGET_NEON) +#define HAVE_neon_move_hi_quad_v2di (TARGET_NEON) +#define HAVE_neon_move_hi_quad_v2df (TARGET_NEON) +#define HAVE_neon_move_hi_quad_v16qi (TARGET_NEON) +#define HAVE_neon_move_hi_quad_v8hi (TARGET_NEON) +#define HAVE_neon_move_hi_quad_v4si (TARGET_NEON) +#define HAVE_neon_move_hi_quad_v4sf (TARGET_NEON) +#define HAVE_reduc_splus_v2di (TARGET_NEON) +#define HAVE_neon_vpadd_internalv8qi (TARGET_NEON) +#define HAVE_neon_vpadd_internalv4hi (TARGET_NEON) +#define HAVE_neon_vpadd_internalv2si (TARGET_NEON) +#define HAVE_neon_vpadd_internalv2sf (TARGET_NEON) +#define HAVE_neon_vpsminv8qi (TARGET_NEON) +#define HAVE_neon_vpsminv4hi (TARGET_NEON) +#define HAVE_neon_vpsminv2si (TARGET_NEON) +#define HAVE_neon_vpsminv2sf (TARGET_NEON) +#define HAVE_neon_vpsmaxv8qi (TARGET_NEON) +#define HAVE_neon_vpsmaxv4hi (TARGET_NEON) +#define HAVE_neon_vpsmaxv2si (TARGET_NEON) +#define HAVE_neon_vpsmaxv2sf (TARGET_NEON) +#define HAVE_neon_vpuminv8qi (TARGET_NEON) +#define HAVE_neon_vpuminv4hi (TARGET_NEON) +#define HAVE_neon_vpuminv2si (TARGET_NEON) +#define HAVE_neon_vpumaxv8qi (TARGET_NEON) +#define HAVE_neon_vpumaxv4hi (TARGET_NEON) +#define HAVE_neon_vpumaxv2si (TARGET_NEON) +#define HAVE_neon_vaddv8qi_unspec (TARGET_NEON) +#define HAVE_neon_vaddv16qi_unspec (TARGET_NEON) +#define HAVE_neon_vaddv4hi_unspec (TARGET_NEON) +#define HAVE_neon_vaddv8hi_unspec (TARGET_NEON) +#define HAVE_neon_vaddv2si_unspec (TARGET_NEON) +#define HAVE_neon_vaddv4si_unspec (TARGET_NEON) +#define HAVE_neon_vaddv2sf_unspec (TARGET_NEON) +#define HAVE_neon_vaddv4sf_unspec (TARGET_NEON) +#define HAVE_neon_vadddi_unspec (TARGET_NEON) +#define HAVE_neon_vaddv2di_unspec (TARGET_NEON) +#define HAVE_neon_vaddlv8qi (TARGET_NEON) +#define HAVE_neon_vaddlv4hi (TARGET_NEON) +#define HAVE_neon_vaddlv2si (TARGET_NEON) +#define HAVE_neon_vaddwv8qi (TARGET_NEON) +#define HAVE_neon_vaddwv4hi (TARGET_NEON) +#define HAVE_neon_vaddwv2si (TARGET_NEON) +#define HAVE_neon_vhaddv8qi (TARGET_NEON) +#define HAVE_neon_vhaddv16qi (TARGET_NEON) +#define HAVE_neon_vhaddv4hi (TARGET_NEON) +#define HAVE_neon_vhaddv8hi (TARGET_NEON) +#define HAVE_neon_vhaddv2si (TARGET_NEON) +#define HAVE_neon_vhaddv4si (TARGET_NEON) +#define HAVE_neon_vqaddv8qi (TARGET_NEON) +#define HAVE_neon_vqaddv16qi (TARGET_NEON) +#define HAVE_neon_vqaddv4hi (TARGET_NEON) +#define HAVE_neon_vqaddv8hi (TARGET_NEON) +#define HAVE_neon_vqaddv2si (TARGET_NEON) +#define HAVE_neon_vqaddv4si (TARGET_NEON) +#define HAVE_neon_vqadddi (TARGET_NEON) +#define HAVE_neon_vqaddv2di (TARGET_NEON) +#define HAVE_neon_vaddhnv8hi (TARGET_NEON) +#define HAVE_neon_vaddhnv4si (TARGET_NEON) +#define HAVE_neon_vaddhnv2di (TARGET_NEON) +#define HAVE_neon_vmulv8qi (TARGET_NEON) +#define HAVE_neon_vmulv16qi (TARGET_NEON) +#define HAVE_neon_vmulv4hi (TARGET_NEON) +#define HAVE_neon_vmulv8hi (TARGET_NEON) +#define HAVE_neon_vmulv2si (TARGET_NEON) +#define HAVE_neon_vmulv4si (TARGET_NEON) +#define HAVE_neon_vmulv2sf (TARGET_NEON) +#define HAVE_neon_vmulv4sf (TARGET_NEON) +#define HAVE_neon_vmlav8qi_unspec (TARGET_NEON) +#define HAVE_neon_vmlav16qi_unspec (TARGET_NEON) +#define HAVE_neon_vmlav4hi_unspec (TARGET_NEON) +#define HAVE_neon_vmlav8hi_unspec (TARGET_NEON) +#define HAVE_neon_vmlav2si_unspec (TARGET_NEON) +#define HAVE_neon_vmlav4si_unspec (TARGET_NEON) +#define HAVE_neon_vmlav2sf_unspec (TARGET_NEON) +#define HAVE_neon_vmlav4sf_unspec (TARGET_NEON) +#define HAVE_neon_vmlav2di_unspec (TARGET_NEON) +#define HAVE_neon_vmlalv8qi (TARGET_NEON) +#define HAVE_neon_vmlalv4hi (TARGET_NEON) +#define HAVE_neon_vmlalv2si (TARGET_NEON) +#define HAVE_neon_vmlsv8qi_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv16qi_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv4hi_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv8hi_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv2si_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv4si_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv2sf_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv4sf_unspec (TARGET_NEON) +#define HAVE_neon_vmlsv2di_unspec (TARGET_NEON) +#define HAVE_neon_vmlslv8qi (TARGET_NEON) +#define HAVE_neon_vmlslv4hi (TARGET_NEON) +#define HAVE_neon_vmlslv2si (TARGET_NEON) +#define HAVE_neon_vqdmulhv4hi (TARGET_NEON) +#define HAVE_neon_vqdmulhv2si (TARGET_NEON) +#define HAVE_neon_vqdmulhv8hi (TARGET_NEON) +#define HAVE_neon_vqdmulhv4si (TARGET_NEON) +#define HAVE_neon_vqdmlalv4hi (TARGET_NEON) +#define HAVE_neon_vqdmlalv2si (TARGET_NEON) +#define HAVE_neon_vqdmlslv4hi (TARGET_NEON) +#define HAVE_neon_vqdmlslv2si (TARGET_NEON) +#define HAVE_neon_vmullv8qi (TARGET_NEON) +#define HAVE_neon_vmullv4hi (TARGET_NEON) +#define HAVE_neon_vmullv2si (TARGET_NEON) +#define HAVE_neon_vqdmullv4hi (TARGET_NEON) +#define HAVE_neon_vqdmullv2si (TARGET_NEON) +#define HAVE_neon_vsubv8qi_unspec (TARGET_NEON) +#define HAVE_neon_vsubv16qi_unspec (TARGET_NEON) +#define HAVE_neon_vsubv4hi_unspec (TARGET_NEON) +#define HAVE_neon_vsubv8hi_unspec (TARGET_NEON) +#define HAVE_neon_vsubv2si_unspec (TARGET_NEON) +#define HAVE_neon_vsubv4si_unspec (TARGET_NEON) +#define HAVE_neon_vsubv2sf_unspec (TARGET_NEON) +#define HAVE_neon_vsubv4sf_unspec (TARGET_NEON) +#define HAVE_neon_vsubdi_unspec (TARGET_NEON) +#define HAVE_neon_vsubv2di_unspec (TARGET_NEON) +#define HAVE_neon_vsublv8qi (TARGET_NEON) +#define HAVE_neon_vsublv4hi (TARGET_NEON) +#define HAVE_neon_vsublv2si (TARGET_NEON) +#define HAVE_neon_vsubwv8qi (TARGET_NEON) +#define HAVE_neon_vsubwv4hi (TARGET_NEON) +#define HAVE_neon_vsubwv2si (TARGET_NEON) +#define HAVE_neon_vqsubv8qi (TARGET_NEON) +#define HAVE_neon_vqsubv16qi (TARGET_NEON) +#define HAVE_neon_vqsubv4hi (TARGET_NEON) +#define HAVE_neon_vqsubv8hi (TARGET_NEON) +#define HAVE_neon_vqsubv2si (TARGET_NEON) +#define HAVE_neon_vqsubv4si (TARGET_NEON) +#define HAVE_neon_vqsubdi (TARGET_NEON) +#define HAVE_neon_vqsubv2di (TARGET_NEON) +#define HAVE_neon_vhsubv8qi (TARGET_NEON) +#define HAVE_neon_vhsubv16qi (TARGET_NEON) +#define HAVE_neon_vhsubv4hi (TARGET_NEON) +#define HAVE_neon_vhsubv8hi (TARGET_NEON) +#define HAVE_neon_vhsubv2si (TARGET_NEON) +#define HAVE_neon_vhsubv4si (TARGET_NEON) +#define HAVE_neon_vsubhnv8hi (TARGET_NEON) +#define HAVE_neon_vsubhnv4si (TARGET_NEON) +#define HAVE_neon_vsubhnv2di (TARGET_NEON) +#define HAVE_neon_vceqv8qi (TARGET_NEON) +#define HAVE_neon_vceqv16qi (TARGET_NEON) +#define HAVE_neon_vceqv4hi (TARGET_NEON) +#define HAVE_neon_vceqv8hi (TARGET_NEON) +#define HAVE_neon_vceqv2si (TARGET_NEON) +#define HAVE_neon_vceqv4si (TARGET_NEON) +#define HAVE_neon_vceqv2sf (TARGET_NEON) +#define HAVE_neon_vceqv4sf (TARGET_NEON) +#define HAVE_neon_vcgev8qi (TARGET_NEON) +#define HAVE_neon_vcgev16qi (TARGET_NEON) +#define HAVE_neon_vcgev4hi (TARGET_NEON) +#define HAVE_neon_vcgev8hi (TARGET_NEON) +#define HAVE_neon_vcgev2si (TARGET_NEON) +#define HAVE_neon_vcgev4si (TARGET_NEON) +#define HAVE_neon_vcgev2sf (TARGET_NEON) +#define HAVE_neon_vcgev4sf (TARGET_NEON) +#define HAVE_neon_vcgtv8qi (TARGET_NEON) +#define HAVE_neon_vcgtv16qi (TARGET_NEON) +#define HAVE_neon_vcgtv4hi (TARGET_NEON) +#define HAVE_neon_vcgtv8hi (TARGET_NEON) +#define HAVE_neon_vcgtv2si (TARGET_NEON) +#define HAVE_neon_vcgtv4si (TARGET_NEON) +#define HAVE_neon_vcgtv2sf (TARGET_NEON) +#define HAVE_neon_vcgtv4sf (TARGET_NEON) +#define HAVE_neon_vclev8qi (TARGET_NEON) +#define HAVE_neon_vclev16qi (TARGET_NEON) +#define HAVE_neon_vclev4hi (TARGET_NEON) +#define HAVE_neon_vclev8hi (TARGET_NEON) +#define HAVE_neon_vclev2si (TARGET_NEON) +#define HAVE_neon_vclev4si (TARGET_NEON) +#define HAVE_neon_vclev2sf (TARGET_NEON) +#define HAVE_neon_vclev4sf (TARGET_NEON) +#define HAVE_neon_vcltv8qi (TARGET_NEON) +#define HAVE_neon_vcltv16qi (TARGET_NEON) +#define HAVE_neon_vcltv4hi (TARGET_NEON) +#define HAVE_neon_vcltv8hi (TARGET_NEON) +#define HAVE_neon_vcltv2si (TARGET_NEON) +#define HAVE_neon_vcltv4si (TARGET_NEON) +#define HAVE_neon_vcltv2sf (TARGET_NEON) +#define HAVE_neon_vcltv4sf (TARGET_NEON) +#define HAVE_neon_vcagev2sf (TARGET_NEON) +#define HAVE_neon_vcagev4sf (TARGET_NEON) +#define HAVE_neon_vcagtv2sf (TARGET_NEON) +#define HAVE_neon_vcagtv4sf (TARGET_NEON) +#define HAVE_neon_vtstv8qi (TARGET_NEON) +#define HAVE_neon_vtstv16qi (TARGET_NEON) +#define HAVE_neon_vtstv4hi (TARGET_NEON) +#define HAVE_neon_vtstv8hi (TARGET_NEON) +#define HAVE_neon_vtstv2si (TARGET_NEON) +#define HAVE_neon_vtstv4si (TARGET_NEON) +#define HAVE_neon_vabdv8qi (TARGET_NEON) +#define HAVE_neon_vabdv16qi (TARGET_NEON) +#define HAVE_neon_vabdv4hi (TARGET_NEON) +#define HAVE_neon_vabdv8hi (TARGET_NEON) +#define HAVE_neon_vabdv2si (TARGET_NEON) +#define HAVE_neon_vabdv4si (TARGET_NEON) +#define HAVE_neon_vabdv2sf (TARGET_NEON) +#define HAVE_neon_vabdv4sf (TARGET_NEON) +#define HAVE_neon_vabdlv8qi (TARGET_NEON) +#define HAVE_neon_vabdlv4hi (TARGET_NEON) +#define HAVE_neon_vabdlv2si (TARGET_NEON) +#define HAVE_neon_vabav8qi (TARGET_NEON) +#define HAVE_neon_vabav16qi (TARGET_NEON) +#define HAVE_neon_vabav4hi (TARGET_NEON) +#define HAVE_neon_vabav8hi (TARGET_NEON) +#define HAVE_neon_vabav2si (TARGET_NEON) +#define HAVE_neon_vabav4si (TARGET_NEON) +#define HAVE_neon_vabalv8qi (TARGET_NEON) +#define HAVE_neon_vabalv4hi (TARGET_NEON) +#define HAVE_neon_vabalv2si (TARGET_NEON) +#define HAVE_neon_vmaxv8qi (TARGET_NEON) +#define HAVE_neon_vmaxv16qi (TARGET_NEON) +#define HAVE_neon_vmaxv4hi (TARGET_NEON) +#define HAVE_neon_vmaxv8hi (TARGET_NEON) +#define HAVE_neon_vmaxv2si (TARGET_NEON) +#define HAVE_neon_vmaxv4si (TARGET_NEON) +#define HAVE_neon_vmaxv2sf (TARGET_NEON) +#define HAVE_neon_vmaxv4sf (TARGET_NEON) +#define HAVE_neon_vminv8qi (TARGET_NEON) +#define HAVE_neon_vminv16qi (TARGET_NEON) +#define HAVE_neon_vminv4hi (TARGET_NEON) +#define HAVE_neon_vminv8hi (TARGET_NEON) +#define HAVE_neon_vminv2si (TARGET_NEON) +#define HAVE_neon_vminv4si (TARGET_NEON) +#define HAVE_neon_vminv2sf (TARGET_NEON) +#define HAVE_neon_vminv4sf (TARGET_NEON) +#define HAVE_neon_vpaddlv8qi (TARGET_NEON) +#define HAVE_neon_vpaddlv16qi (TARGET_NEON) +#define HAVE_neon_vpaddlv4hi (TARGET_NEON) +#define HAVE_neon_vpaddlv8hi (TARGET_NEON) +#define HAVE_neon_vpaddlv2si (TARGET_NEON) +#define HAVE_neon_vpaddlv4si (TARGET_NEON) +#define HAVE_neon_vpadalv8qi (TARGET_NEON) +#define HAVE_neon_vpadalv16qi (TARGET_NEON) +#define HAVE_neon_vpadalv4hi (TARGET_NEON) +#define HAVE_neon_vpadalv8hi (TARGET_NEON) +#define HAVE_neon_vpadalv2si (TARGET_NEON) +#define HAVE_neon_vpadalv4si (TARGET_NEON) +#define HAVE_neon_vpmaxv8qi (TARGET_NEON) +#define HAVE_neon_vpmaxv4hi (TARGET_NEON) +#define HAVE_neon_vpmaxv2si (TARGET_NEON) +#define HAVE_neon_vpmaxv2sf (TARGET_NEON) +#define HAVE_neon_vpminv8qi (TARGET_NEON) +#define HAVE_neon_vpminv4hi (TARGET_NEON) +#define HAVE_neon_vpminv2si (TARGET_NEON) +#define HAVE_neon_vpminv2sf (TARGET_NEON) +#define HAVE_neon_vrecpsv2sf (TARGET_NEON) +#define HAVE_neon_vrecpsv4sf (TARGET_NEON) +#define HAVE_neon_vrsqrtsv2sf (TARGET_NEON) +#define HAVE_neon_vrsqrtsv4sf (TARGET_NEON) +#define HAVE_neon_vqabsv8qi (TARGET_NEON) +#define HAVE_neon_vqabsv16qi (TARGET_NEON) +#define HAVE_neon_vqabsv4hi (TARGET_NEON) +#define HAVE_neon_vqabsv8hi (TARGET_NEON) +#define HAVE_neon_vqabsv2si (TARGET_NEON) +#define HAVE_neon_vqabsv4si (TARGET_NEON) +#define HAVE_neon_vqnegv8qi (TARGET_NEON) +#define HAVE_neon_vqnegv16qi (TARGET_NEON) +#define HAVE_neon_vqnegv4hi (TARGET_NEON) +#define HAVE_neon_vqnegv8hi (TARGET_NEON) +#define HAVE_neon_vqnegv2si (TARGET_NEON) +#define HAVE_neon_vqnegv4si (TARGET_NEON) +#define HAVE_neon_vclsv8qi (TARGET_NEON) +#define HAVE_neon_vclsv16qi (TARGET_NEON) +#define HAVE_neon_vclsv4hi (TARGET_NEON) +#define HAVE_neon_vclsv8hi (TARGET_NEON) +#define HAVE_neon_vclsv2si (TARGET_NEON) +#define HAVE_neon_vclsv4si (TARGET_NEON) +#define HAVE_clzv8qi2 (TARGET_NEON) +#define HAVE_clzv16qi2 (TARGET_NEON) +#define HAVE_clzv4hi2 (TARGET_NEON) +#define HAVE_clzv8hi2 (TARGET_NEON) +#define HAVE_clzv2si2 (TARGET_NEON) +#define HAVE_clzv4si2 (TARGET_NEON) +#define HAVE_popcountv8qi2 (TARGET_NEON) +#define HAVE_popcountv16qi2 (TARGET_NEON) +#define HAVE_neon_vrecpev2si (TARGET_NEON) +#define HAVE_neon_vrecpev2sf (TARGET_NEON) +#define HAVE_neon_vrecpev4si (TARGET_NEON) +#define HAVE_neon_vrecpev4sf (TARGET_NEON) +#define HAVE_neon_vrsqrtev2si (TARGET_NEON) +#define HAVE_neon_vrsqrtev2sf (TARGET_NEON) +#define HAVE_neon_vrsqrtev4si (TARGET_NEON) +#define HAVE_neon_vrsqrtev4sf (TARGET_NEON) +#define HAVE_neon_vget_lanev8qi_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev4hi_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev2si_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev2sf_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev8qi_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev4hi_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev2si_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev2sf_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev16qi_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev8hi_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev4si_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev4sf_sext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev16qi_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev8hi_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev4si_zext_internal (TARGET_NEON) +#define HAVE_neon_vget_lanev4sf_zext_internal (TARGET_NEON) +#define HAVE_neon_vdup_nv8qi (TARGET_NEON) +#define HAVE_neon_vdup_nv4hi (TARGET_NEON) +#define HAVE_neon_vdup_nv16qi (TARGET_NEON) +#define HAVE_neon_vdup_nv8hi (TARGET_NEON) +#define HAVE_neon_vdup_nv2si (TARGET_NEON) +#define HAVE_neon_vdup_nv2sf (TARGET_NEON) +#define HAVE_neon_vdup_nv4si (TARGET_NEON) +#define HAVE_neon_vdup_nv4sf (TARGET_NEON) +#define HAVE_neon_vdup_nv2di (TARGET_NEON) +#define HAVE_neon_vdup_lanev8qi_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev16qi_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev4hi_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev8hi_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev2si_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev4si_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev2sf_internal (TARGET_NEON) +#define HAVE_neon_vdup_lanev4sf_internal (TARGET_NEON) +#define HAVE_neon_vcombinev8qi (TARGET_NEON) +#define HAVE_neon_vcombinev4hi (TARGET_NEON) +#define HAVE_neon_vcombinev2si (TARGET_NEON) +#define HAVE_neon_vcombinev2sf (TARGET_NEON) +#define HAVE_neon_vcombinedi (TARGET_NEON) +#define HAVE_neon_vget_highv16qi (TARGET_NEON) +#define HAVE_neon_vget_highv8hi (TARGET_NEON) +#define HAVE_neon_vget_highv4si (TARGET_NEON) +#define HAVE_neon_vget_highv4sf (TARGET_NEON) +#define HAVE_neon_vget_highv2di (TARGET_NEON) +#define HAVE_neon_vget_lowv16qi (TARGET_NEON) +#define HAVE_neon_vget_lowv8hi (TARGET_NEON) +#define HAVE_neon_vget_lowv4si (TARGET_NEON) +#define HAVE_neon_vget_lowv4sf (TARGET_NEON) +#define HAVE_neon_vget_lowv2di (TARGET_NEON) +#define HAVE_neon_vcvtv2sf (TARGET_NEON) +#define HAVE_neon_vcvtv4sf (TARGET_NEON) +#define HAVE_neon_vcvtv2si (TARGET_NEON) +#define HAVE_neon_vcvtv4si (TARGET_NEON) +#define HAVE_neon_vcvt_nv2sf (TARGET_NEON) +#define HAVE_neon_vcvt_nv4sf (TARGET_NEON) +#define HAVE_neon_vcvt_nv2si (TARGET_NEON) +#define HAVE_neon_vcvt_nv4si (TARGET_NEON) +#define HAVE_neon_vmovnv8hi (TARGET_NEON) +#define HAVE_neon_vmovnv4si (TARGET_NEON) +#define HAVE_neon_vmovnv2di (TARGET_NEON) +#define HAVE_neon_vqmovnv8hi (TARGET_NEON) +#define HAVE_neon_vqmovnv4si (TARGET_NEON) +#define HAVE_neon_vqmovnv2di (TARGET_NEON) +#define HAVE_neon_vqmovunv8hi (TARGET_NEON) +#define HAVE_neon_vqmovunv4si (TARGET_NEON) +#define HAVE_neon_vqmovunv2di (TARGET_NEON) +#define HAVE_neon_vmovlv8qi (TARGET_NEON) +#define HAVE_neon_vmovlv4hi (TARGET_NEON) +#define HAVE_neon_vmovlv2si (TARGET_NEON) +#define HAVE_neon_vmul_lanev4hi (TARGET_NEON) +#define HAVE_neon_vmul_lanev2si (TARGET_NEON) +#define HAVE_neon_vmul_lanev2sf (TARGET_NEON) +#define HAVE_neon_vmul_lanev8hi (TARGET_NEON) +#define HAVE_neon_vmul_lanev4si (TARGET_NEON) +#define HAVE_neon_vmul_lanev4sf (TARGET_NEON) +#define HAVE_neon_vmull_lanev4hi (TARGET_NEON) +#define HAVE_neon_vmull_lanev2si (TARGET_NEON) +#define HAVE_neon_vqdmull_lanev4hi (TARGET_NEON) +#define HAVE_neon_vqdmull_lanev2si (TARGET_NEON) +#define HAVE_neon_vqdmulh_lanev8hi (TARGET_NEON) +#define HAVE_neon_vqdmulh_lanev4si (TARGET_NEON) +#define HAVE_neon_vqdmulh_lanev4hi (TARGET_NEON) +#define HAVE_neon_vqdmulh_lanev2si (TARGET_NEON) +#define HAVE_neon_vmla_lanev4hi (TARGET_NEON) +#define HAVE_neon_vmla_lanev2si (TARGET_NEON) +#define HAVE_neon_vmla_lanev2sf (TARGET_NEON) +#define HAVE_neon_vmla_lanev8hi (TARGET_NEON) +#define HAVE_neon_vmla_lanev4si (TARGET_NEON) +#define HAVE_neon_vmla_lanev4sf (TARGET_NEON) +#define HAVE_neon_vmlal_lanev4hi (TARGET_NEON) +#define HAVE_neon_vmlal_lanev2si (TARGET_NEON) +#define HAVE_neon_vqdmlal_lanev4hi (TARGET_NEON) +#define HAVE_neon_vqdmlal_lanev2si (TARGET_NEON) +#define HAVE_neon_vmls_lanev4hi (TARGET_NEON) +#define HAVE_neon_vmls_lanev2si (TARGET_NEON) +#define HAVE_neon_vmls_lanev2sf (TARGET_NEON) +#define HAVE_neon_vmls_lanev8hi (TARGET_NEON) +#define HAVE_neon_vmls_lanev4si (TARGET_NEON) +#define HAVE_neon_vmls_lanev4sf (TARGET_NEON) +#define HAVE_neon_vmlsl_lanev4hi (TARGET_NEON) +#define HAVE_neon_vmlsl_lanev2si (TARGET_NEON) +#define HAVE_neon_vqdmlsl_lanev4hi (TARGET_NEON) +#define HAVE_neon_vqdmlsl_lanev2si (TARGET_NEON) +#define HAVE_neon_vextv8qi (TARGET_NEON) +#define HAVE_neon_vextv16qi (TARGET_NEON) +#define HAVE_neon_vextv4hi (TARGET_NEON) +#define HAVE_neon_vextv8hi (TARGET_NEON) +#define HAVE_neon_vextv2si (TARGET_NEON) +#define HAVE_neon_vextv4si (TARGET_NEON) +#define HAVE_neon_vextv2sf (TARGET_NEON) +#define HAVE_neon_vextv4sf (TARGET_NEON) +#define HAVE_neon_vextdi (TARGET_NEON) +#define HAVE_neon_vextv2di (TARGET_NEON) +#define HAVE_neon_vrev64v8qi (TARGET_NEON) +#define HAVE_neon_vrev64v16qi (TARGET_NEON) +#define HAVE_neon_vrev64v4hi (TARGET_NEON) +#define HAVE_neon_vrev64v8hi (TARGET_NEON) +#define HAVE_neon_vrev64v2si (TARGET_NEON) +#define HAVE_neon_vrev64v4si (TARGET_NEON) +#define HAVE_neon_vrev64v2sf (TARGET_NEON) +#define HAVE_neon_vrev64v4sf (TARGET_NEON) +#define HAVE_neon_vrev64v2di (TARGET_NEON) +#define HAVE_neon_vrev32v8qi (TARGET_NEON) +#define HAVE_neon_vrev32v4hi (TARGET_NEON) +#define HAVE_neon_vrev32v16qi (TARGET_NEON) +#define HAVE_neon_vrev32v8hi (TARGET_NEON) +#define HAVE_neon_vrev16v8qi (TARGET_NEON) +#define HAVE_neon_vrev16v16qi (TARGET_NEON) +#define HAVE_neon_vbslv8qi_internal (TARGET_NEON) +#define HAVE_neon_vbslv16qi_internal (TARGET_NEON) +#define HAVE_neon_vbslv4hi_internal (TARGET_NEON) +#define HAVE_neon_vbslv8hi_internal (TARGET_NEON) +#define HAVE_neon_vbslv2si_internal (TARGET_NEON) +#define HAVE_neon_vbslv4si_internal (TARGET_NEON) +#define HAVE_neon_vbslv2sf_internal (TARGET_NEON) +#define HAVE_neon_vbslv4sf_internal (TARGET_NEON) +#define HAVE_neon_vbsldi_internal (TARGET_NEON) +#define HAVE_neon_vbslv2di_internal (TARGET_NEON) +#define HAVE_neon_vshlv8qi (TARGET_NEON) +#define HAVE_neon_vshlv16qi (TARGET_NEON) +#define HAVE_neon_vshlv4hi (TARGET_NEON) +#define HAVE_neon_vshlv8hi (TARGET_NEON) +#define HAVE_neon_vshlv2si (TARGET_NEON) +#define HAVE_neon_vshlv4si (TARGET_NEON) +#define HAVE_neon_vshldi (TARGET_NEON) +#define HAVE_neon_vshlv2di (TARGET_NEON) +#define HAVE_neon_vqshlv8qi (TARGET_NEON) +#define HAVE_neon_vqshlv16qi (TARGET_NEON) +#define HAVE_neon_vqshlv4hi (TARGET_NEON) +#define HAVE_neon_vqshlv8hi (TARGET_NEON) +#define HAVE_neon_vqshlv2si (TARGET_NEON) +#define HAVE_neon_vqshlv4si (TARGET_NEON) +#define HAVE_neon_vqshldi (TARGET_NEON) +#define HAVE_neon_vqshlv2di (TARGET_NEON) +#define HAVE_neon_vshr_nv8qi (TARGET_NEON) +#define HAVE_neon_vshr_nv16qi (TARGET_NEON) +#define HAVE_neon_vshr_nv4hi (TARGET_NEON) +#define HAVE_neon_vshr_nv8hi (TARGET_NEON) +#define HAVE_neon_vshr_nv2si (TARGET_NEON) +#define HAVE_neon_vshr_nv4si (TARGET_NEON) +#define HAVE_neon_vshr_ndi (TARGET_NEON) +#define HAVE_neon_vshr_nv2di (TARGET_NEON) +#define HAVE_neon_vshrn_nv8hi (TARGET_NEON) +#define HAVE_neon_vshrn_nv4si (TARGET_NEON) +#define HAVE_neon_vshrn_nv2di (TARGET_NEON) +#define HAVE_neon_vqshrn_nv8hi (TARGET_NEON) +#define HAVE_neon_vqshrn_nv4si (TARGET_NEON) +#define HAVE_neon_vqshrn_nv2di (TARGET_NEON) +#define HAVE_neon_vqshrun_nv8hi (TARGET_NEON) +#define HAVE_neon_vqshrun_nv4si (TARGET_NEON) +#define HAVE_neon_vqshrun_nv2di (TARGET_NEON) +#define HAVE_neon_vshl_nv8qi (TARGET_NEON) +#define HAVE_neon_vshl_nv16qi (TARGET_NEON) +#define HAVE_neon_vshl_nv4hi (TARGET_NEON) +#define HAVE_neon_vshl_nv8hi (TARGET_NEON) +#define HAVE_neon_vshl_nv2si (TARGET_NEON) +#define HAVE_neon_vshl_nv4si (TARGET_NEON) +#define HAVE_neon_vshl_ndi (TARGET_NEON) +#define HAVE_neon_vshl_nv2di (TARGET_NEON) +#define HAVE_neon_vqshl_nv8qi (TARGET_NEON) +#define HAVE_neon_vqshl_nv16qi (TARGET_NEON) +#define HAVE_neon_vqshl_nv4hi (TARGET_NEON) +#define HAVE_neon_vqshl_nv8hi (TARGET_NEON) +#define HAVE_neon_vqshl_nv2si (TARGET_NEON) +#define HAVE_neon_vqshl_nv4si (TARGET_NEON) +#define HAVE_neon_vqshl_ndi (TARGET_NEON) +#define HAVE_neon_vqshl_nv2di (TARGET_NEON) +#define HAVE_neon_vqshlu_nv8qi (TARGET_NEON) +#define HAVE_neon_vqshlu_nv16qi (TARGET_NEON) +#define HAVE_neon_vqshlu_nv4hi (TARGET_NEON) +#define HAVE_neon_vqshlu_nv8hi (TARGET_NEON) +#define HAVE_neon_vqshlu_nv2si (TARGET_NEON) +#define HAVE_neon_vqshlu_nv4si (TARGET_NEON) +#define HAVE_neon_vqshlu_ndi (TARGET_NEON) +#define HAVE_neon_vqshlu_nv2di (TARGET_NEON) +#define HAVE_neon_vshll_nv8qi (TARGET_NEON) +#define HAVE_neon_vshll_nv4hi (TARGET_NEON) +#define HAVE_neon_vshll_nv2si (TARGET_NEON) +#define HAVE_neon_vsra_nv8qi (TARGET_NEON) +#define HAVE_neon_vsra_nv16qi (TARGET_NEON) +#define HAVE_neon_vsra_nv4hi (TARGET_NEON) +#define HAVE_neon_vsra_nv8hi (TARGET_NEON) +#define HAVE_neon_vsra_nv2si (TARGET_NEON) +#define HAVE_neon_vsra_nv4si (TARGET_NEON) +#define HAVE_neon_vsra_ndi (TARGET_NEON) +#define HAVE_neon_vsra_nv2di (TARGET_NEON) +#define HAVE_neon_vsri_nv8qi (TARGET_NEON) +#define HAVE_neon_vsri_nv16qi (TARGET_NEON) +#define HAVE_neon_vsri_nv4hi (TARGET_NEON) +#define HAVE_neon_vsri_nv8hi (TARGET_NEON) +#define HAVE_neon_vsri_nv2si (TARGET_NEON) +#define HAVE_neon_vsri_nv4si (TARGET_NEON) +#define HAVE_neon_vsri_ndi (TARGET_NEON) +#define HAVE_neon_vsri_nv2di (TARGET_NEON) +#define HAVE_neon_vsli_nv8qi (TARGET_NEON) +#define HAVE_neon_vsli_nv16qi (TARGET_NEON) +#define HAVE_neon_vsli_nv4hi (TARGET_NEON) +#define HAVE_neon_vsli_nv8hi (TARGET_NEON) +#define HAVE_neon_vsli_nv2si (TARGET_NEON) +#define HAVE_neon_vsli_nv4si (TARGET_NEON) +#define HAVE_neon_vsli_ndi (TARGET_NEON) +#define HAVE_neon_vsli_nv2di (TARGET_NEON) +#define HAVE_neon_vtbl1v8qi (TARGET_NEON) +#define HAVE_neon_vtbl2v8qi (TARGET_NEON) +#define HAVE_neon_vtbl3v8qi (TARGET_NEON) +#define HAVE_neon_vtbl4v8qi (TARGET_NEON) +#define HAVE_neon_vtbx1v8qi (TARGET_NEON) +#define HAVE_neon_vtbx2v8qi (TARGET_NEON) +#define HAVE_neon_vtbx3v8qi (TARGET_NEON) +#define HAVE_neon_vtbx4v8qi (TARGET_NEON) +#define HAVE_neon_vtrnv8qi_internal (TARGET_NEON) +#define HAVE_neon_vtrnv16qi_internal (TARGET_NEON) +#define HAVE_neon_vtrnv4hi_internal (TARGET_NEON) +#define HAVE_neon_vtrnv8hi_internal (TARGET_NEON) +#define HAVE_neon_vtrnv2si_internal (TARGET_NEON) +#define HAVE_neon_vtrnv4si_internal (TARGET_NEON) +#define HAVE_neon_vtrnv2sf_internal (TARGET_NEON) +#define HAVE_neon_vtrnv4sf_internal (TARGET_NEON) +#define HAVE_neon_vzipv8qi_internal (TARGET_NEON) +#define HAVE_neon_vzipv16qi_internal (TARGET_NEON) +#define HAVE_neon_vzipv4hi_internal (TARGET_NEON) +#define HAVE_neon_vzipv8hi_internal (TARGET_NEON) +#define HAVE_neon_vzipv2si_internal (TARGET_NEON) +#define HAVE_neon_vzipv4si_internal (TARGET_NEON) +#define HAVE_neon_vzipv2sf_internal (TARGET_NEON) +#define HAVE_neon_vzipv4sf_internal (TARGET_NEON) +#define HAVE_neon_vuzpv8qi_internal (TARGET_NEON) +#define HAVE_neon_vuzpv16qi_internal (TARGET_NEON) +#define HAVE_neon_vuzpv4hi_internal (TARGET_NEON) +#define HAVE_neon_vuzpv8hi_internal (TARGET_NEON) +#define HAVE_neon_vuzpv2si_internal (TARGET_NEON) +#define HAVE_neon_vuzpv4si_internal (TARGET_NEON) +#define HAVE_neon_vuzpv2sf_internal (TARGET_NEON) +#define HAVE_neon_vuzpv4sf_internal (TARGET_NEON) +#define HAVE_neon_vld1v8qi (TARGET_NEON) +#define HAVE_neon_vld1v16qi (TARGET_NEON) +#define HAVE_neon_vld1v4hi (TARGET_NEON) +#define HAVE_neon_vld1v8hi (TARGET_NEON) +#define HAVE_neon_vld1v2si (TARGET_NEON) +#define HAVE_neon_vld1v4si (TARGET_NEON) +#define HAVE_neon_vld1v2sf (TARGET_NEON) +#define HAVE_neon_vld1v4sf (TARGET_NEON) +#define HAVE_neon_vld1di (TARGET_NEON) +#define HAVE_neon_vld1v2di (TARGET_NEON) +#define HAVE_neon_vld1_lanev8qi (TARGET_NEON) +#define HAVE_neon_vld1_lanev4hi (TARGET_NEON) +#define HAVE_neon_vld1_lanev2si (TARGET_NEON) +#define HAVE_neon_vld1_lanev2sf (TARGET_NEON) +#define HAVE_neon_vld1_lanedi (TARGET_NEON) +#define HAVE_neon_vld1_lanev16qi (TARGET_NEON) +#define HAVE_neon_vld1_lanev8hi (TARGET_NEON) +#define HAVE_neon_vld1_lanev4si (TARGET_NEON) +#define HAVE_neon_vld1_lanev4sf (TARGET_NEON) +#define HAVE_neon_vld1_lanev2di (TARGET_NEON) +#define HAVE_neon_vld1_dupv8qi (TARGET_NEON) +#define HAVE_neon_vld1_dupv4hi (TARGET_NEON) +#define HAVE_neon_vld1_dupv2si (TARGET_NEON) +#define HAVE_neon_vld1_dupv2sf (TARGET_NEON) +#define HAVE_neon_vld1_dupdi (TARGET_NEON) +#define HAVE_neon_vld1_dupv16qi (TARGET_NEON) +#define HAVE_neon_vld1_dupv8hi (TARGET_NEON) +#define HAVE_neon_vld1_dupv4si (TARGET_NEON) +#define HAVE_neon_vld1_dupv4sf (TARGET_NEON) +#define HAVE_neon_vld1_dupv2di (TARGET_NEON) +#define HAVE_neon_vst1v8qi (TARGET_NEON) +#define HAVE_neon_vst1v16qi (TARGET_NEON) +#define HAVE_neon_vst1v4hi (TARGET_NEON) +#define HAVE_neon_vst1v8hi (TARGET_NEON) +#define HAVE_neon_vst1v2si (TARGET_NEON) +#define HAVE_neon_vst1v4si (TARGET_NEON) +#define HAVE_neon_vst1v2sf (TARGET_NEON) +#define HAVE_neon_vst1v4sf (TARGET_NEON) +#define HAVE_neon_vst1di (TARGET_NEON) +#define HAVE_neon_vst1v2di (TARGET_NEON) +#define HAVE_neon_vst1_lanev8qi (TARGET_NEON) +#define HAVE_neon_vst1_lanev4hi (TARGET_NEON) +#define HAVE_neon_vst1_lanev2si (TARGET_NEON) +#define HAVE_neon_vst1_lanev2sf (TARGET_NEON) +#define HAVE_neon_vst1_lanedi (TARGET_NEON) +#define HAVE_neon_vst1_lanev16qi (TARGET_NEON) +#define HAVE_neon_vst1_lanev8hi (TARGET_NEON) +#define HAVE_neon_vst1_lanev4si (TARGET_NEON) +#define HAVE_neon_vst1_lanev4sf (TARGET_NEON) +#define HAVE_neon_vst1_lanev2di (TARGET_NEON) +#define HAVE_neon_vld2v8qi (TARGET_NEON) +#define HAVE_neon_vld2v4hi (TARGET_NEON) +#define HAVE_neon_vld2v2si (TARGET_NEON) +#define HAVE_neon_vld2v2sf (TARGET_NEON) +#define HAVE_neon_vld2di (TARGET_NEON) +#define HAVE_neon_vld2v16qi (TARGET_NEON) +#define HAVE_neon_vld2v8hi (TARGET_NEON) +#define HAVE_neon_vld2v4si (TARGET_NEON) +#define HAVE_neon_vld2v4sf (TARGET_NEON) +#define HAVE_neon_vld2_lanev8qi (TARGET_NEON) +#define HAVE_neon_vld2_lanev4hi (TARGET_NEON) +#define HAVE_neon_vld2_lanev2si (TARGET_NEON) +#define HAVE_neon_vld2_lanev2sf (TARGET_NEON) +#define HAVE_neon_vld2_lanev8hi (TARGET_NEON) +#define HAVE_neon_vld2_lanev4si (TARGET_NEON) +#define HAVE_neon_vld2_lanev4sf (TARGET_NEON) +#define HAVE_neon_vld2_dupv8qi (TARGET_NEON) +#define HAVE_neon_vld2_dupv4hi (TARGET_NEON) +#define HAVE_neon_vld2_dupv2si (TARGET_NEON) +#define HAVE_neon_vld2_dupv2sf (TARGET_NEON) +#define HAVE_neon_vld2_dupdi (TARGET_NEON) +#define HAVE_neon_vst2v8qi (TARGET_NEON) +#define HAVE_neon_vst2v4hi (TARGET_NEON) +#define HAVE_neon_vst2v2si (TARGET_NEON) +#define HAVE_neon_vst2v2sf (TARGET_NEON) +#define HAVE_neon_vst2di (TARGET_NEON) +#define HAVE_neon_vst2v16qi (TARGET_NEON) +#define HAVE_neon_vst2v8hi (TARGET_NEON) +#define HAVE_neon_vst2v4si (TARGET_NEON) +#define HAVE_neon_vst2v4sf (TARGET_NEON) +#define HAVE_neon_vst2_lanev8qi (TARGET_NEON) +#define HAVE_neon_vst2_lanev4hi (TARGET_NEON) +#define HAVE_neon_vst2_lanev2si (TARGET_NEON) +#define HAVE_neon_vst2_lanev2sf (TARGET_NEON) +#define HAVE_neon_vst2_lanev8hi (TARGET_NEON) +#define HAVE_neon_vst2_lanev4si (TARGET_NEON) +#define HAVE_neon_vst2_lanev4sf (TARGET_NEON) +#define HAVE_neon_vld3v8qi (TARGET_NEON) +#define HAVE_neon_vld3v4hi (TARGET_NEON) +#define HAVE_neon_vld3v2si (TARGET_NEON) +#define HAVE_neon_vld3v2sf (TARGET_NEON) +#define HAVE_neon_vld3di (TARGET_NEON) +#define HAVE_neon_vld3qav16qi (TARGET_NEON) +#define HAVE_neon_vld3qav8hi (TARGET_NEON) +#define HAVE_neon_vld3qav4si (TARGET_NEON) +#define HAVE_neon_vld3qav4sf (TARGET_NEON) +#define HAVE_neon_vld3qbv16qi (TARGET_NEON) +#define HAVE_neon_vld3qbv8hi (TARGET_NEON) +#define HAVE_neon_vld3qbv4si (TARGET_NEON) +#define HAVE_neon_vld3qbv4sf (TARGET_NEON) +#define HAVE_neon_vld3_lanev8qi (TARGET_NEON) +#define HAVE_neon_vld3_lanev4hi (TARGET_NEON) +#define HAVE_neon_vld3_lanev2si (TARGET_NEON) +#define HAVE_neon_vld3_lanev2sf (TARGET_NEON) +#define HAVE_neon_vld3_lanev8hi (TARGET_NEON) +#define HAVE_neon_vld3_lanev4si (TARGET_NEON) +#define HAVE_neon_vld3_lanev4sf (TARGET_NEON) +#define HAVE_neon_vld3_dupv8qi (TARGET_NEON) +#define HAVE_neon_vld3_dupv4hi (TARGET_NEON) +#define HAVE_neon_vld3_dupv2si (TARGET_NEON) +#define HAVE_neon_vld3_dupv2sf (TARGET_NEON) +#define HAVE_neon_vld3_dupdi (TARGET_NEON) +#define HAVE_neon_vst3v8qi (TARGET_NEON) +#define HAVE_neon_vst3v4hi (TARGET_NEON) +#define HAVE_neon_vst3v2si (TARGET_NEON) +#define HAVE_neon_vst3v2sf (TARGET_NEON) +#define HAVE_neon_vst3di (TARGET_NEON) +#define HAVE_neon_vst3qav16qi (TARGET_NEON) +#define HAVE_neon_vst3qav8hi (TARGET_NEON) +#define HAVE_neon_vst3qav4si (TARGET_NEON) +#define HAVE_neon_vst3qav4sf (TARGET_NEON) +#define HAVE_neon_vst3qbv16qi (TARGET_NEON) +#define HAVE_neon_vst3qbv8hi (TARGET_NEON) +#define HAVE_neon_vst3qbv4si (TARGET_NEON) +#define HAVE_neon_vst3qbv4sf (TARGET_NEON) +#define HAVE_neon_vst3_lanev8qi (TARGET_NEON) +#define HAVE_neon_vst3_lanev4hi (TARGET_NEON) +#define HAVE_neon_vst3_lanev2si (TARGET_NEON) +#define HAVE_neon_vst3_lanev2sf (TARGET_NEON) +#define HAVE_neon_vst3_lanev8hi (TARGET_NEON) +#define HAVE_neon_vst3_lanev4si (TARGET_NEON) +#define HAVE_neon_vst3_lanev4sf (TARGET_NEON) +#define HAVE_neon_vld4v8qi (TARGET_NEON) +#define HAVE_neon_vld4v4hi (TARGET_NEON) +#define HAVE_neon_vld4v2si (TARGET_NEON) +#define HAVE_neon_vld4v2sf (TARGET_NEON) +#define HAVE_neon_vld4di (TARGET_NEON) +#define HAVE_neon_vld4qav16qi (TARGET_NEON) +#define HAVE_neon_vld4qav8hi (TARGET_NEON) +#define HAVE_neon_vld4qav4si (TARGET_NEON) +#define HAVE_neon_vld4qav4sf (TARGET_NEON) +#define HAVE_neon_vld4qbv16qi (TARGET_NEON) +#define HAVE_neon_vld4qbv8hi (TARGET_NEON) +#define HAVE_neon_vld4qbv4si (TARGET_NEON) +#define HAVE_neon_vld4qbv4sf (TARGET_NEON) +#define HAVE_neon_vld4_lanev8qi (TARGET_NEON) +#define HAVE_neon_vld4_lanev4hi (TARGET_NEON) +#define HAVE_neon_vld4_lanev2si (TARGET_NEON) +#define HAVE_neon_vld4_lanev2sf (TARGET_NEON) +#define HAVE_neon_vld4_lanev8hi (TARGET_NEON) +#define HAVE_neon_vld4_lanev4si (TARGET_NEON) +#define HAVE_neon_vld4_lanev4sf (TARGET_NEON) +#define HAVE_neon_vld4_dupv8qi (TARGET_NEON) +#define HAVE_neon_vld4_dupv4hi (TARGET_NEON) +#define HAVE_neon_vld4_dupv2si (TARGET_NEON) +#define HAVE_neon_vld4_dupv2sf (TARGET_NEON) +#define HAVE_neon_vld4_dupdi (TARGET_NEON) +#define HAVE_neon_vst4v8qi (TARGET_NEON) +#define HAVE_neon_vst4v4hi (TARGET_NEON) +#define HAVE_neon_vst4v2si (TARGET_NEON) +#define HAVE_neon_vst4v2sf (TARGET_NEON) +#define HAVE_neon_vst4di (TARGET_NEON) +#define HAVE_neon_vst4qav16qi (TARGET_NEON) +#define HAVE_neon_vst4qav8hi (TARGET_NEON) +#define HAVE_neon_vst4qav4si (TARGET_NEON) +#define HAVE_neon_vst4qav4sf (TARGET_NEON) +#define HAVE_neon_vst4qbv16qi (TARGET_NEON) +#define HAVE_neon_vst4qbv8hi (TARGET_NEON) +#define HAVE_neon_vst4qbv4si (TARGET_NEON) +#define HAVE_neon_vst4qbv4sf (TARGET_NEON) +#define HAVE_neon_vst4_lanev8qi (TARGET_NEON) +#define HAVE_neon_vst4_lanev4hi (TARGET_NEON) +#define HAVE_neon_vst4_lanev2si (TARGET_NEON) +#define HAVE_neon_vst4_lanev2sf (TARGET_NEON) +#define HAVE_neon_vst4_lanev8hi (TARGET_NEON) +#define HAVE_neon_vst4_lanev4si (TARGET_NEON) +#define HAVE_neon_vst4_lanev4sf (TARGET_NEON) +#define HAVE_neon_vec_unpacks_lo_v16qi (TARGET_NEON) +#define HAVE_neon_vec_unpacku_lo_v16qi (TARGET_NEON) +#define HAVE_neon_vec_unpacks_lo_v8hi (TARGET_NEON) +#define HAVE_neon_vec_unpacku_lo_v8hi (TARGET_NEON) +#define HAVE_neon_vec_unpacks_lo_v4si (TARGET_NEON) +#define HAVE_neon_vec_unpacku_lo_v4si (TARGET_NEON) +#define HAVE_neon_vec_unpacks_hi_v16qi (TARGET_NEON) +#define HAVE_neon_vec_unpacku_hi_v16qi (TARGET_NEON) +#define HAVE_neon_vec_unpacks_hi_v8hi (TARGET_NEON) +#define HAVE_neon_vec_unpacku_hi_v8hi (TARGET_NEON) +#define HAVE_neon_vec_unpacks_hi_v4si (TARGET_NEON) +#define HAVE_neon_vec_unpacku_hi_v4si (TARGET_NEON) +#define HAVE_neon_vec_smult_lo_v16qi (TARGET_NEON) +#define HAVE_neon_vec_umult_lo_v16qi (TARGET_NEON) +#define HAVE_neon_vec_smult_lo_v8hi (TARGET_NEON) +#define HAVE_neon_vec_umult_lo_v8hi (TARGET_NEON) +#define HAVE_neon_vec_smult_lo_v4si (TARGET_NEON) +#define HAVE_neon_vec_umult_lo_v4si (TARGET_NEON) +#define HAVE_neon_vec_smult_hi_v16qi (TARGET_NEON) +#define HAVE_neon_vec_umult_hi_v16qi (TARGET_NEON) +#define HAVE_neon_vec_smult_hi_v8hi (TARGET_NEON) +#define HAVE_neon_vec_umult_hi_v8hi (TARGET_NEON) +#define HAVE_neon_vec_smult_hi_v4si (TARGET_NEON) +#define HAVE_neon_vec_umult_hi_v4si (TARGET_NEON) +#define HAVE_neon_unpacks_v8qi (TARGET_NEON) +#define HAVE_neon_unpacku_v8qi (TARGET_NEON) +#define HAVE_neon_unpacks_v4hi (TARGET_NEON) +#define HAVE_neon_unpacku_v4hi (TARGET_NEON) +#define HAVE_neon_unpacks_v2si (TARGET_NEON) +#define HAVE_neon_unpacku_v2si (TARGET_NEON) +#define HAVE_neon_vec_smult_v8qi (TARGET_NEON) +#define HAVE_neon_vec_umult_v8qi (TARGET_NEON) +#define HAVE_neon_vec_smult_v4hi (TARGET_NEON) +#define HAVE_neon_vec_umult_v4hi (TARGET_NEON) +#define HAVE_neon_vec_smult_v2si (TARGET_NEON) +#define HAVE_neon_vec_umult_v2si (TARGET_NEON) +#define HAVE_vec_pack_trunc_v8hi (TARGET_NEON) +#define HAVE_vec_pack_trunc_v4si (TARGET_NEON) +#define HAVE_vec_pack_trunc_v2di (TARGET_NEON) +#define HAVE_neon_vec_pack_trunc_v8hi (TARGET_NEON) +#define HAVE_neon_vec_pack_trunc_v4si (TARGET_NEON) +#define HAVE_neon_vec_pack_trunc_v2di (TARGET_NEON) +#define HAVE_arm_sync_compare_and_swapsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_compare_and_swapqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_compare_and_swaphi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_lock_test_and_setsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_lock_test_and_setqi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_lock_test_and_sethi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_addsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_subsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_iorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_xorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_andsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_nandsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_addqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_subqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_iorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_xorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_andqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_addhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_subhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_iorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_xorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_andhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_nandqi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_new_nandhi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_addsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_subsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_iorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_xorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_andsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_nandsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_addqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_subqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_iorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_xorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_andqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_addhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_subhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_iorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_xorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_andhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_nandqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_arm_sync_old_nandhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_adddi3 1 +#define HAVE_addsi3 1 +#define HAVE_incscc (TARGET_32BIT) +#define HAVE_addsf3 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_adddf3 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_subdi3 1 +#define HAVE_subsi3 1 +#define HAVE_decscc (TARGET_32BIT) +#define HAVE_subsf3 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_subdf3 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_mulsi3 1 +#define HAVE_maddsidi4 (TARGET_32BIT && arm_arch3m) +#define HAVE_mulsidi3 (TARGET_32BIT && arm_arch3m) +#define HAVE_umulsidi3 (TARGET_32BIT && arm_arch3m) +#define HAVE_umaddsidi4 (TARGET_32BIT && arm_arch3m) +#define HAVE_smulsi3_highpart (TARGET_32BIT && arm_arch3m) +#define HAVE_umulsi3_highpart (TARGET_32BIT && arm_arch3m) +#define HAVE_mulsf3 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_muldf3 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_divsf3 (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP)) +#define HAVE_divdf3 (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP_DOUBLE)) +#define HAVE_modsf3 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA) +#define HAVE_moddf3 (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA) +#define HAVE_anddi3 (TARGET_32BIT) +#define HAVE_andsi3 1 +#define HAVE_insv (TARGET_ARM || arm_arch_thumb2) +#define HAVE_iordi3 (TARGET_32BIT) +#define HAVE_iorsi3 1 +#define HAVE_xordi3 (TARGET_32BIT) +#define HAVE_xorsi3 1 +#define HAVE_smaxsi3 (TARGET_32BIT) +#define HAVE_sminsi3 (TARGET_32BIT) +#define HAVE_umaxsi3 (TARGET_32BIT) +#define HAVE_uminsi3 (TARGET_32BIT) +#define HAVE_ashldi3 (TARGET_32BIT) +#define HAVE_ashlsi3 1 +#define HAVE_ashrdi3 (TARGET_32BIT) +#define HAVE_ashrsi3 1 +#define HAVE_lshrdi3 (TARGET_32BIT) +#define HAVE_lshrsi3 1 +#define HAVE_rotlsi3 (TARGET_32BIT) +#define HAVE_rotrsi3 1 +#define HAVE_extzv (TARGET_THUMB1 || arm_arch_thumb2) +#define HAVE_negdi2 1 +#define HAVE_negsi2 1 +#define HAVE_negsf2 (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP)) +#define HAVE_negdf2 (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP_DOUBLE)) +#define HAVE_abssi2 1 +#define HAVE_abssf2 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_absdf2 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_sqrtsf2 (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP)) +#define HAVE_sqrtdf2 (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP_DOUBLE)) +#define HAVE_one_cmplsi2 1 +#define HAVE_floatsihf2 1 +#define HAVE_floatdihf2 1 +#define HAVE_floatsisf2 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_floatsidf2 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_fix_trunchfsi2 1 +#define HAVE_fix_trunchfdi2 1 +#define HAVE_fix_truncsfsi2 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_fix_truncdfsi2 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_truncdfsf2 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_truncdfhf2 1 +#define HAVE_zero_extendhisi2 1 +#define HAVE_zero_extendqisi2 1 +#define HAVE_extendhisi2 1 +#define HAVE_extendhisi2_mem (TARGET_ARM) +#define HAVE_extendqihi2 (TARGET_ARM) +#define HAVE_extendqisi2 1 +#define HAVE_extendsfdf2 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_extendhfdf2 1 +#define HAVE_movdi 1 +#define HAVE_movsi 1 +#define HAVE_calculate_pic_address (flag_pic) +#define HAVE_builtin_setjmp_receiver (flag_pic) +#define HAVE_storehi (TARGET_ARM) +#define HAVE_storehi_bigend (TARGET_ARM) +#define HAVE_storeinthi (TARGET_ARM) +#define HAVE_storehi_single_op (TARGET_32BIT && arm_arch4) +#define HAVE_movhi 1 +#define HAVE_movhi_bytes (TARGET_ARM) +#define HAVE_movhi_bigend (TARGET_ARM) +#define HAVE_thumb_movhi_clobber (TARGET_THUMB1) +#define HAVE_reload_outhi 1 +#define HAVE_reload_inhi 1 +#define HAVE_movqi 1 +#define HAVE_movhf 1 +#define HAVE_movsf 1 +#define HAVE_movdf 1 +#define HAVE_reload_outdf (TARGET_32BIT) +#define HAVE_movxf (TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA) +#define HAVE_load_multiple (TARGET_32BIT) +#define HAVE_store_multiple (TARGET_32BIT) +#define HAVE_movmemqi 1 +#define HAVE_cbranchsi4 (TARGET_THUMB1 || TARGET_32BIT) +#define HAVE_cbranchqi4 (TARGET_THUMB1) +#define HAVE_cbranchsf4 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_cbranchdf4 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_cbranchdi4 (TARGET_32BIT) +#define HAVE_cbranch_cc (TARGET_32BIT) +#define HAVE_cstore_cc (TARGET_32BIT) +#define HAVE_cstoresi4 (TARGET_32BIT || TARGET_THUMB1) +#define HAVE_cstoresf4 (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_cstoredf4 (TARGET_32BIT && TARGET_HARD_FLOAT && !TARGET_VFP_SINGLE) +#define HAVE_cstoredi4 (TARGET_32BIT) +#define HAVE_cstoresi_eq0_thumb1 (TARGET_THUMB1) +#define HAVE_cstoresi_ne0_thumb1 (TARGET_THUMB1) +#define HAVE_movsicc (TARGET_32BIT) +#define HAVE_movsfcc (TARGET_32BIT && TARGET_HARD_FLOAT) +#define HAVE_movdfcc (TARGET_32BIT && TARGET_HARD_FLOAT && (TARGET_FPA || TARGET_VFP_DOUBLE)) +#define HAVE_jump 1 +#define HAVE_call 1 +#define HAVE_call_internal 1 +#define HAVE_call_value 1 +#define HAVE_call_value_internal 1 +#define HAVE_sibcall (TARGET_32BIT) +#define HAVE_sibcall_value (TARGET_32BIT) +#define HAVE_return (TARGET_32BIT && USE_RETURN_INSN (FALSE)) +#define HAVE_return_addr_mask (TARGET_ARM) +#define HAVE_untyped_call 1 +#define HAVE_untyped_return 1 +#define HAVE_casesi (TARGET_32BIT || optimize_size || flag_pic) +#define HAVE_thumb1_casesi_internal_pic (TARGET_THUMB1) +#define HAVE_indirect_jump 1 +#define HAVE_prologue 1 +#define HAVE_epilogue 1 +#define HAVE_eh_epilogue 1 +#define HAVE_tablejump (TARGET_THUMB1) +#define HAVE_ctzsi2 (TARGET_32BIT && arm_arch_thumb2) +#define HAVE_eh_return 1 +#define HAVE_arm_legacy_rev (TARGET_32BIT) +#define HAVE_thumb_legacy_rev (TARGET_THUMB) +#define HAVE_bswapsi2 (TARGET_EITHER && (arm_arch6 || !optimize_size)) +#define HAVE_movv2di (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2DImode))) +#define HAVE_movv2si (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_movv4hi (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_movv8qi (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_movv2sf (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SFmode))) +#define HAVE_movv4si (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_movv8hi (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_movv16qi (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_movv4sf (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SFmode))) +#define HAVE_addv2di3 ((TARGET_NEON && ((V2DImode != V2SFmode && V2DImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2DImode))) +#define HAVE_addv2si3 ((TARGET_NEON && ((V2SImode != V2SFmode && V2SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_addv4hi3 ((TARGET_NEON && ((V4HImode != V2SFmode && V4HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_addv8qi3 ((TARGET_NEON && ((V8QImode != V2SFmode && V8QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_addv2sf3 ((TARGET_NEON && ((V2SFmode != V2SFmode && V2SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SFmode))) +#define HAVE_addv4si3 ((TARGET_NEON && ((V4SImode != V2SFmode && V4SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_addv8hi3 ((TARGET_NEON && ((V8HImode != V2SFmode && V8HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_addv16qi3 ((TARGET_NEON && ((V16QImode != V2SFmode && V16QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_addv4sf3 ((TARGET_NEON && ((V4SFmode != V2SFmode && V4SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SFmode))) +#define HAVE_subv2di3 ((TARGET_NEON && ((V2DImode != V2SFmode && V2DImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2DImode))) +#define HAVE_subv2si3 ((TARGET_NEON && ((V2SImode != V2SFmode && V2SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_subv4hi3 ((TARGET_NEON && ((V4HImode != V2SFmode && V4HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_subv8qi3 ((TARGET_NEON && ((V8QImode != V2SFmode && V8QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_subv2sf3 ((TARGET_NEON && ((V2SFmode != V2SFmode && V2SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SFmode))) +#define HAVE_subv4si3 ((TARGET_NEON && ((V4SImode != V2SFmode && V4SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_subv8hi3 ((TARGET_NEON && ((V8HImode != V2SFmode && V8HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_subv16qi3 ((TARGET_NEON && ((V16QImode != V2SFmode && V16QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_subv4sf3 ((TARGET_NEON && ((V4SFmode != V2SFmode && V4SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SFmode))) +#define HAVE_mulv2si3 ((TARGET_NEON && ((V2SImode != V2SFmode && V2SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V2SImode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv4hi3 ((TARGET_NEON && ((V4HImode != V2SFmode && V4HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V4HImode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv8qi3 ((TARGET_NEON && ((V8QImode != V2SFmode && V8QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V8QImode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv2sf3 ((TARGET_NEON && ((V2SFmode != V2SFmode && V2SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V2SFmode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv4si3 ((TARGET_NEON && ((V4SImode != V2SFmode && V4SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V4SImode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv8hi3 ((TARGET_NEON && ((V8HImode != V2SFmode && V8HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V8HImode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv16qi3 ((TARGET_NEON && ((V16QImode != V2SFmode && V16QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V16QImode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_mulv4sf3 ((TARGET_NEON && ((V4SFmode != V2SFmode && V4SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (V4SFmode == V4HImode && TARGET_REALLY_IWMMXT)) +#define HAVE_sminv2si3 ((TARGET_NEON && ((V2SImode != V2SFmode && V2SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_sminv4hi3 ((TARGET_NEON && ((V4HImode != V2SFmode && V4HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_sminv8qi3 ((TARGET_NEON && ((V8QImode != V2SFmode && V8QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_sminv2sf3 ((TARGET_NEON && ((V2SFmode != V2SFmode && V2SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SFmode))) +#define HAVE_sminv4si3 ((TARGET_NEON && ((V4SImode != V2SFmode && V4SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_sminv8hi3 ((TARGET_NEON && ((V8HImode != V2SFmode && V8HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_sminv16qi3 ((TARGET_NEON && ((V16QImode != V2SFmode && V16QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_sminv4sf3 ((TARGET_NEON && ((V4SFmode != V2SFmode && V4SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SFmode))) +#define HAVE_uminv2si3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_uminv4hi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_uminv8qi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_uminv4si3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_uminv8hi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_uminv16qi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_smaxv2si3 ((TARGET_NEON && ((V2SImode != V2SFmode && V2SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_smaxv4hi3 ((TARGET_NEON && ((V4HImode != V2SFmode && V4HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_smaxv8qi3 ((TARGET_NEON && ((V8QImode != V2SFmode && V8QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_smaxv2sf3 ((TARGET_NEON && ((V2SFmode != V2SFmode && V2SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SFmode))) +#define HAVE_smaxv4si3 ((TARGET_NEON && ((V4SImode != V2SFmode && V4SImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_smaxv8hi3 ((TARGET_NEON && ((V8HImode != V2SFmode && V8HImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_smaxv16qi3 ((TARGET_NEON && ((V16QImode != V2SFmode && V16QImode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_smaxv4sf3 ((TARGET_NEON && ((V4SFmode != V2SFmode && V4SFmode != V4SFmode) \ + || flag_unsafe_math_optimizations)) \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SFmode))) +#define HAVE_umaxv2si3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V2SImode))) +#define HAVE_umaxv4hi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4HImode))) +#define HAVE_umaxv8qi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8QImode))) +#define HAVE_umaxv4si3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V4SImode))) +#define HAVE_umaxv8hi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V8HImode))) +#define HAVE_umaxv16qi3 (TARGET_NEON \ + || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (V16QImode))) +#define HAVE_movti (TARGET_NEON) +#define HAVE_movei (TARGET_NEON) +#define HAVE_movoi (TARGET_NEON) +#define HAVE_movci (TARGET_NEON) +#define HAVE_movxi (TARGET_NEON) +#define HAVE_movmisalignv8qi (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv16qi (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv4hi (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv8hi (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv2si (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv4si (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv2sf (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv4sf (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisaligndi (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_movmisalignv2di (TARGET_NEON && !BYTES_BIG_ENDIAN) +#define HAVE_vec_setv8qi (TARGET_NEON) +#define HAVE_vec_setv16qi (TARGET_NEON) +#define HAVE_vec_setv4hi (TARGET_NEON) +#define HAVE_vec_setv8hi (TARGET_NEON) +#define HAVE_vec_setv2si (TARGET_NEON) +#define HAVE_vec_setv4si (TARGET_NEON) +#define HAVE_vec_setv2sf (TARGET_NEON) +#define HAVE_vec_setv4sf (TARGET_NEON) +#define HAVE_vec_setv2di (TARGET_NEON) +#define HAVE_vec_initv8qi (TARGET_NEON) +#define HAVE_vec_initv16qi (TARGET_NEON) +#define HAVE_vec_initv4hi (TARGET_NEON) +#define HAVE_vec_initv8hi (TARGET_NEON) +#define HAVE_vec_initv2si (TARGET_NEON) +#define HAVE_vec_initv4si (TARGET_NEON) +#define HAVE_vec_initv2sf (TARGET_NEON) +#define HAVE_vec_initv4sf (TARGET_NEON) +#define HAVE_vec_initv2di (TARGET_NEON) +#define HAVE_vashrv8qi3 (TARGET_NEON) +#define HAVE_vashrv16qi3 (TARGET_NEON) +#define HAVE_vashrv4hi3 (TARGET_NEON) +#define HAVE_vashrv8hi3 (TARGET_NEON) +#define HAVE_vashrv2si3 (TARGET_NEON) +#define HAVE_vashrv4si3 (TARGET_NEON) +#define HAVE_vlshrv8qi3 (TARGET_NEON) +#define HAVE_vlshrv16qi3 (TARGET_NEON) +#define HAVE_vlshrv4hi3 (TARGET_NEON) +#define HAVE_vlshrv8hi3 (TARGET_NEON) +#define HAVE_vlshrv2si3 (TARGET_NEON) +#define HAVE_vlshrv4si3 (TARGET_NEON) +#define HAVE_vec_shr_v8qi (TARGET_NEON) +#define HAVE_vec_shr_v16qi (TARGET_NEON) +#define HAVE_vec_shr_v4hi (TARGET_NEON) +#define HAVE_vec_shr_v8hi (TARGET_NEON) +#define HAVE_vec_shr_v2si (TARGET_NEON) +#define HAVE_vec_shr_v4si (TARGET_NEON) +#define HAVE_vec_shr_v2sf (TARGET_NEON) +#define HAVE_vec_shr_v4sf (TARGET_NEON) +#define HAVE_vec_shr_v2di (TARGET_NEON) +#define HAVE_vec_shl_v8qi (TARGET_NEON) +#define HAVE_vec_shl_v16qi (TARGET_NEON) +#define HAVE_vec_shl_v4hi (TARGET_NEON) +#define HAVE_vec_shl_v8hi (TARGET_NEON) +#define HAVE_vec_shl_v2si (TARGET_NEON) +#define HAVE_vec_shl_v4si (TARGET_NEON) +#define HAVE_vec_shl_v2sf (TARGET_NEON) +#define HAVE_vec_shl_v4sf (TARGET_NEON) +#define HAVE_vec_shl_v2di (TARGET_NEON) +#define HAVE_move_hi_quad_v2di (TARGET_NEON) +#define HAVE_move_hi_quad_v2df (TARGET_NEON) +#define HAVE_move_hi_quad_v16qi (TARGET_NEON) +#define HAVE_move_hi_quad_v8hi (TARGET_NEON) +#define HAVE_move_hi_quad_v4si (TARGET_NEON) +#define HAVE_move_hi_quad_v4sf (TARGET_NEON) +#define HAVE_move_lo_quad_v2di (TARGET_NEON) +#define HAVE_move_lo_quad_v2df (TARGET_NEON) +#define HAVE_move_lo_quad_v16qi (TARGET_NEON) +#define HAVE_move_lo_quad_v8hi (TARGET_NEON) +#define HAVE_move_lo_quad_v4si (TARGET_NEON) +#define HAVE_move_lo_quad_v4sf (TARGET_NEON) +#define HAVE_reduc_splus_v8qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v4hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v2si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v2sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v16qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v8hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v4si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_splus_v4sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_reduc_uplus_v8qi (TARGET_NEON) +#define HAVE_reduc_uplus_v16qi (TARGET_NEON) +#define HAVE_reduc_uplus_v4hi (TARGET_NEON) +#define HAVE_reduc_uplus_v8hi (TARGET_NEON) +#define HAVE_reduc_uplus_v2si (TARGET_NEON) +#define HAVE_reduc_uplus_v4si (TARGET_NEON) +#define HAVE_reduc_uplus_v2di (TARGET_NEON) +#define HAVE_reduc_smin_v8qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v4hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v2si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v2sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v16qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v8hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v4si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smin_v4sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v8qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v4hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v2si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v2sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v16qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v8hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v4si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_reduc_smax_v4sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_reduc_umin_v8qi (TARGET_NEON) +#define HAVE_reduc_umin_v4hi (TARGET_NEON) +#define HAVE_reduc_umin_v2si (TARGET_NEON) +#define HAVE_reduc_umin_v16qi (TARGET_NEON) +#define HAVE_reduc_umin_v8hi (TARGET_NEON) +#define HAVE_reduc_umin_v4si (TARGET_NEON) +#define HAVE_reduc_umax_v8qi (TARGET_NEON) +#define HAVE_reduc_umax_v4hi (TARGET_NEON) +#define HAVE_reduc_umax_v2si (TARGET_NEON) +#define HAVE_reduc_umax_v16qi (TARGET_NEON) +#define HAVE_reduc_umax_v8hi (TARGET_NEON) +#define HAVE_reduc_umax_v4si (TARGET_NEON) +#define HAVE_vcondv8qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_vcondv16qi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_vcondv4hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_vcondv8hi (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_vcondv2si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_vcondv4si (TARGET_NEON && (!false || flag_unsafe_math_optimizations)) +#define HAVE_vcondv2sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_vcondv4sf (TARGET_NEON && (!true || flag_unsafe_math_optimizations)) +#define HAVE_vconduv8qi (TARGET_NEON) +#define HAVE_vconduv16qi (TARGET_NEON) +#define HAVE_vconduv4hi (TARGET_NEON) +#define HAVE_vconduv8hi (TARGET_NEON) +#define HAVE_vconduv2si (TARGET_NEON) +#define HAVE_vconduv4si (TARGET_NEON) +#define HAVE_neon_vaddv8qi (TARGET_NEON) +#define HAVE_neon_vaddv16qi (TARGET_NEON) +#define HAVE_neon_vaddv4hi (TARGET_NEON) +#define HAVE_neon_vaddv8hi (TARGET_NEON) +#define HAVE_neon_vaddv2si (TARGET_NEON) +#define HAVE_neon_vaddv4si (TARGET_NEON) +#define HAVE_neon_vaddv2sf (TARGET_NEON) +#define HAVE_neon_vaddv4sf (TARGET_NEON) +#define HAVE_neon_vadddi (TARGET_NEON) +#define HAVE_neon_vaddv2di (TARGET_NEON) +#define HAVE_neon_vmlav8qi (TARGET_NEON) +#define HAVE_neon_vmlav16qi (TARGET_NEON) +#define HAVE_neon_vmlav4hi (TARGET_NEON) +#define HAVE_neon_vmlav8hi (TARGET_NEON) +#define HAVE_neon_vmlav2si (TARGET_NEON) +#define HAVE_neon_vmlav4si (TARGET_NEON) +#define HAVE_neon_vmlav2sf (TARGET_NEON) +#define HAVE_neon_vmlav4sf (TARGET_NEON) +#define HAVE_neon_vmlsv8qi (TARGET_NEON) +#define HAVE_neon_vmlsv16qi (TARGET_NEON) +#define HAVE_neon_vmlsv4hi (TARGET_NEON) +#define HAVE_neon_vmlsv8hi (TARGET_NEON) +#define HAVE_neon_vmlsv2si (TARGET_NEON) +#define HAVE_neon_vmlsv4si (TARGET_NEON) +#define HAVE_neon_vmlsv2sf (TARGET_NEON) +#define HAVE_neon_vmlsv4sf (TARGET_NEON) +#define HAVE_neon_vsubv8qi (TARGET_NEON) +#define HAVE_neon_vsubv16qi (TARGET_NEON) +#define HAVE_neon_vsubv4hi (TARGET_NEON) +#define HAVE_neon_vsubv8hi (TARGET_NEON) +#define HAVE_neon_vsubv2si (TARGET_NEON) +#define HAVE_neon_vsubv4si (TARGET_NEON) +#define HAVE_neon_vsubv2sf (TARGET_NEON) +#define HAVE_neon_vsubv4sf (TARGET_NEON) +#define HAVE_neon_vsubdi (TARGET_NEON) +#define HAVE_neon_vsubv2di (TARGET_NEON) +#define HAVE_neon_vpaddv8qi (TARGET_NEON) +#define HAVE_neon_vpaddv4hi (TARGET_NEON) +#define HAVE_neon_vpaddv2si (TARGET_NEON) +#define HAVE_neon_vpaddv2sf (TARGET_NEON) +#define HAVE_neon_vabsv8qi (TARGET_NEON) +#define HAVE_neon_vabsv16qi (TARGET_NEON) +#define HAVE_neon_vabsv4hi (TARGET_NEON) +#define HAVE_neon_vabsv8hi (TARGET_NEON) +#define HAVE_neon_vabsv2si (TARGET_NEON) +#define HAVE_neon_vabsv4si (TARGET_NEON) +#define HAVE_neon_vabsv2sf (TARGET_NEON) +#define HAVE_neon_vabsv4sf (TARGET_NEON) +#define HAVE_neon_vnegv8qi (TARGET_NEON) +#define HAVE_neon_vnegv16qi (TARGET_NEON) +#define HAVE_neon_vnegv4hi (TARGET_NEON) +#define HAVE_neon_vnegv8hi (TARGET_NEON) +#define HAVE_neon_vnegv2si (TARGET_NEON) +#define HAVE_neon_vnegv4si (TARGET_NEON) +#define HAVE_neon_vnegv2sf (TARGET_NEON) +#define HAVE_neon_vnegv4sf (TARGET_NEON) +#define HAVE_neon_vclzv8qi (TARGET_NEON) +#define HAVE_neon_vclzv16qi (TARGET_NEON) +#define HAVE_neon_vclzv4hi (TARGET_NEON) +#define HAVE_neon_vclzv8hi (TARGET_NEON) +#define HAVE_neon_vclzv2si (TARGET_NEON) +#define HAVE_neon_vclzv4si (TARGET_NEON) +#define HAVE_neon_vcntv8qi (TARGET_NEON) +#define HAVE_neon_vcntv16qi (TARGET_NEON) +#define HAVE_neon_vmvnv8qi (TARGET_NEON) +#define HAVE_neon_vmvnv16qi (TARGET_NEON) +#define HAVE_neon_vmvnv4hi (TARGET_NEON) +#define HAVE_neon_vmvnv8hi (TARGET_NEON) +#define HAVE_neon_vmvnv2si (TARGET_NEON) +#define HAVE_neon_vmvnv4si (TARGET_NEON) +#define HAVE_neon_vget_lanev8qi (TARGET_NEON) +#define HAVE_neon_vget_lanev16qi (TARGET_NEON) +#define HAVE_neon_vget_lanev4hi (TARGET_NEON) +#define HAVE_neon_vget_lanev8hi (TARGET_NEON) +#define HAVE_neon_vget_lanev2si (TARGET_NEON) +#define HAVE_neon_vget_lanev4si (TARGET_NEON) +#define HAVE_neon_vget_lanev2sf (TARGET_NEON) +#define HAVE_neon_vget_lanev4sf (TARGET_NEON) +#define HAVE_neon_vget_lanedi (TARGET_NEON) +#define HAVE_neon_vget_lanev2di (TARGET_NEON) +#define HAVE_neon_vset_lanev8qi (TARGET_NEON) +#define HAVE_neon_vset_lanev16qi (TARGET_NEON) +#define HAVE_neon_vset_lanev4hi (TARGET_NEON) +#define HAVE_neon_vset_lanev8hi (TARGET_NEON) +#define HAVE_neon_vset_lanev2si (TARGET_NEON) +#define HAVE_neon_vset_lanev4si (TARGET_NEON) +#define HAVE_neon_vset_lanev2sf (TARGET_NEON) +#define HAVE_neon_vset_lanev4sf (TARGET_NEON) +#define HAVE_neon_vset_lanev2di (TARGET_NEON) +#define HAVE_neon_vset_lanedi (TARGET_NEON) +#define HAVE_neon_vcreatev8qi (TARGET_NEON) +#define HAVE_neon_vcreatev4hi (TARGET_NEON) +#define HAVE_neon_vcreatev2si (TARGET_NEON) +#define HAVE_neon_vcreatev2sf (TARGET_NEON) +#define HAVE_neon_vcreatedi (TARGET_NEON) +#define HAVE_neon_vdup_ndi (TARGET_NEON) +#define HAVE_neon_vdup_lanev8qi (TARGET_NEON) +#define HAVE_neon_vdup_lanev16qi (TARGET_NEON) +#define HAVE_neon_vdup_lanev4hi (TARGET_NEON) +#define HAVE_neon_vdup_lanev8hi (TARGET_NEON) +#define HAVE_neon_vdup_lanev2si (TARGET_NEON) +#define HAVE_neon_vdup_lanev4si (TARGET_NEON) +#define HAVE_neon_vdup_lanev2sf (TARGET_NEON) +#define HAVE_neon_vdup_lanev4sf (TARGET_NEON) +#define HAVE_neon_vdup_lanedi (TARGET_NEON) +#define HAVE_neon_vdup_lanev2di (TARGET_NEON) +#define HAVE_neon_vmul_nv4hi (TARGET_NEON) +#define HAVE_neon_vmul_nv2si (TARGET_NEON) +#define HAVE_neon_vmul_nv2sf (TARGET_NEON) +#define HAVE_neon_vmul_nv8hi (TARGET_NEON) +#define HAVE_neon_vmul_nv4si (TARGET_NEON) +#define HAVE_neon_vmul_nv4sf (TARGET_NEON) +#define HAVE_neon_vmull_nv4hi (TARGET_NEON) +#define HAVE_neon_vmull_nv2si (TARGET_NEON) +#define HAVE_neon_vqdmull_nv4hi (TARGET_NEON) +#define HAVE_neon_vqdmull_nv2si (TARGET_NEON) +#define HAVE_neon_vqdmulh_nv4hi (TARGET_NEON) +#define HAVE_neon_vqdmulh_nv2si (TARGET_NEON) +#define HAVE_neon_vqdmulh_nv8hi (TARGET_NEON) +#define HAVE_neon_vqdmulh_nv4si (TARGET_NEON) +#define HAVE_neon_vmla_nv4hi (TARGET_NEON) +#define HAVE_neon_vmla_nv2si (TARGET_NEON) +#define HAVE_neon_vmla_nv2sf (TARGET_NEON) +#define HAVE_neon_vmla_nv8hi (TARGET_NEON) +#define HAVE_neon_vmla_nv4si (TARGET_NEON) +#define HAVE_neon_vmla_nv4sf (TARGET_NEON) +#define HAVE_neon_vmlal_nv4hi (TARGET_NEON) +#define HAVE_neon_vmlal_nv2si (TARGET_NEON) +#define HAVE_neon_vqdmlal_nv4hi (TARGET_NEON) +#define HAVE_neon_vqdmlal_nv2si (TARGET_NEON) +#define HAVE_neon_vmls_nv4hi (TARGET_NEON) +#define HAVE_neon_vmls_nv2si (TARGET_NEON) +#define HAVE_neon_vmls_nv2sf (TARGET_NEON) +#define HAVE_neon_vmls_nv8hi (TARGET_NEON) +#define HAVE_neon_vmls_nv4si (TARGET_NEON) +#define HAVE_neon_vmls_nv4sf (TARGET_NEON) +#define HAVE_neon_vmlsl_nv4hi (TARGET_NEON) +#define HAVE_neon_vmlsl_nv2si (TARGET_NEON) +#define HAVE_neon_vqdmlsl_nv4hi (TARGET_NEON) +#define HAVE_neon_vqdmlsl_nv2si (TARGET_NEON) +#define HAVE_neon_vbslv8qi (TARGET_NEON) +#define HAVE_neon_vbslv16qi (TARGET_NEON) +#define HAVE_neon_vbslv4hi (TARGET_NEON) +#define HAVE_neon_vbslv8hi (TARGET_NEON) +#define HAVE_neon_vbslv2si (TARGET_NEON) +#define HAVE_neon_vbslv4si (TARGET_NEON) +#define HAVE_neon_vbslv2sf (TARGET_NEON) +#define HAVE_neon_vbslv4sf (TARGET_NEON) +#define HAVE_neon_vbsldi (TARGET_NEON) +#define HAVE_neon_vbslv2di (TARGET_NEON) +#define HAVE_neon_vtrnv8qi (TARGET_NEON) +#define HAVE_neon_vtrnv16qi (TARGET_NEON) +#define HAVE_neon_vtrnv4hi (TARGET_NEON) +#define HAVE_neon_vtrnv8hi (TARGET_NEON) +#define HAVE_neon_vtrnv2si (TARGET_NEON) +#define HAVE_neon_vtrnv4si (TARGET_NEON) +#define HAVE_neon_vtrnv2sf (TARGET_NEON) +#define HAVE_neon_vtrnv4sf (TARGET_NEON) +#define HAVE_neon_vzipv8qi (TARGET_NEON) +#define HAVE_neon_vzipv16qi (TARGET_NEON) +#define HAVE_neon_vzipv4hi (TARGET_NEON) +#define HAVE_neon_vzipv8hi (TARGET_NEON) +#define HAVE_neon_vzipv2si (TARGET_NEON) +#define HAVE_neon_vzipv4si (TARGET_NEON) +#define HAVE_neon_vzipv2sf (TARGET_NEON) +#define HAVE_neon_vzipv4sf (TARGET_NEON) +#define HAVE_neon_vuzpv8qi (TARGET_NEON) +#define HAVE_neon_vuzpv16qi (TARGET_NEON) +#define HAVE_neon_vuzpv4hi (TARGET_NEON) +#define HAVE_neon_vuzpv8hi (TARGET_NEON) +#define HAVE_neon_vuzpv2si (TARGET_NEON) +#define HAVE_neon_vuzpv4si (TARGET_NEON) +#define HAVE_neon_vuzpv2sf (TARGET_NEON) +#define HAVE_neon_vuzpv4sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv8qiv8qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv8qiv4hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv8qiv2si (TARGET_NEON) +#define HAVE_neon_vreinterpretv8qiv2sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv8qidi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4hiv8qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4hiv4hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4hiv2si (TARGET_NEON) +#define HAVE_neon_vreinterpretv4hiv2sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv4hidi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2siv8qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2siv4hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2siv2si (TARGET_NEON) +#define HAVE_neon_vreinterpretv2siv2sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv2sidi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2sfv8qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2sfv4hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2sfv2si (TARGET_NEON) +#define HAVE_neon_vreinterpretv2sfv2sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv2sfdi (TARGET_NEON) +#define HAVE_neon_vreinterpretdiv8qi (TARGET_NEON) +#define HAVE_neon_vreinterpretdiv4hi (TARGET_NEON) +#define HAVE_neon_vreinterpretdiv2si (TARGET_NEON) +#define HAVE_neon_vreinterpretdiv2sf (TARGET_NEON) +#define HAVE_neon_vreinterpretdidi (TARGET_NEON) +#define HAVE_neon_vreinterpretv16qiv16qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv16qiv8hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv16qiv4si (TARGET_NEON) +#define HAVE_neon_vreinterpretv16qiv4sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv16qiv2di (TARGET_NEON) +#define HAVE_neon_vreinterpretv8hiv16qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv8hiv8hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv8hiv4si (TARGET_NEON) +#define HAVE_neon_vreinterpretv8hiv4sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv8hiv2di (TARGET_NEON) +#define HAVE_neon_vreinterpretv4siv16qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4siv8hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4siv4si (TARGET_NEON) +#define HAVE_neon_vreinterpretv4siv4sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv4siv2di (TARGET_NEON) +#define HAVE_neon_vreinterpretv4sfv16qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4sfv8hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv4sfv4si (TARGET_NEON) +#define HAVE_neon_vreinterpretv4sfv4sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv4sfv2di (TARGET_NEON) +#define HAVE_neon_vreinterpretv2div16qi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2div8hi (TARGET_NEON) +#define HAVE_neon_vreinterpretv2div4si (TARGET_NEON) +#define HAVE_neon_vreinterpretv2div4sf (TARGET_NEON) +#define HAVE_neon_vreinterpretv2div2di (TARGET_NEON) +#define HAVE_neon_vld3v16qi (TARGET_NEON) +#define HAVE_neon_vld3v8hi (TARGET_NEON) +#define HAVE_neon_vld3v4si (TARGET_NEON) +#define HAVE_neon_vld3v4sf (TARGET_NEON) +#define HAVE_neon_vst3v16qi (TARGET_NEON) +#define HAVE_neon_vst3v8hi (TARGET_NEON) +#define HAVE_neon_vst3v4si (TARGET_NEON) +#define HAVE_neon_vst3v4sf (TARGET_NEON) +#define HAVE_neon_vld4v16qi (TARGET_NEON) +#define HAVE_neon_vld4v8hi (TARGET_NEON) +#define HAVE_neon_vld4v4si (TARGET_NEON) +#define HAVE_neon_vld4v4sf (TARGET_NEON) +#define HAVE_neon_vst4v16qi (TARGET_NEON) +#define HAVE_neon_vst4v8hi (TARGET_NEON) +#define HAVE_neon_vst4v4si (TARGET_NEON) +#define HAVE_neon_vst4v4sf (TARGET_NEON) +#define HAVE_neon_vandv8qi (TARGET_NEON) +#define HAVE_neon_vandv16qi (TARGET_NEON) +#define HAVE_neon_vandv4hi (TARGET_NEON) +#define HAVE_neon_vandv8hi (TARGET_NEON) +#define HAVE_neon_vandv2si (TARGET_NEON) +#define HAVE_neon_vandv4si (TARGET_NEON) +#define HAVE_neon_vandv2sf (TARGET_NEON) +#define HAVE_neon_vandv4sf (TARGET_NEON) +#define HAVE_neon_vanddi (TARGET_NEON) +#define HAVE_neon_vandv2di (TARGET_NEON) +#define HAVE_neon_vorrv8qi (TARGET_NEON) +#define HAVE_neon_vorrv16qi (TARGET_NEON) +#define HAVE_neon_vorrv4hi (TARGET_NEON) +#define HAVE_neon_vorrv8hi (TARGET_NEON) +#define HAVE_neon_vorrv2si (TARGET_NEON) +#define HAVE_neon_vorrv4si (TARGET_NEON) +#define HAVE_neon_vorrv2sf (TARGET_NEON) +#define HAVE_neon_vorrv4sf (TARGET_NEON) +#define HAVE_neon_vorrdi (TARGET_NEON) +#define HAVE_neon_vorrv2di (TARGET_NEON) +#define HAVE_neon_veorv8qi (TARGET_NEON) +#define HAVE_neon_veorv16qi (TARGET_NEON) +#define HAVE_neon_veorv4hi (TARGET_NEON) +#define HAVE_neon_veorv8hi (TARGET_NEON) +#define HAVE_neon_veorv2si (TARGET_NEON) +#define HAVE_neon_veorv4si (TARGET_NEON) +#define HAVE_neon_veorv2sf (TARGET_NEON) +#define HAVE_neon_veorv4sf (TARGET_NEON) +#define HAVE_neon_veordi (TARGET_NEON) +#define HAVE_neon_veorv2di (TARGET_NEON) +#define HAVE_neon_vbicv8qi (TARGET_NEON) +#define HAVE_neon_vbicv16qi (TARGET_NEON) +#define HAVE_neon_vbicv4hi (TARGET_NEON) +#define HAVE_neon_vbicv8hi (TARGET_NEON) +#define HAVE_neon_vbicv2si (TARGET_NEON) +#define HAVE_neon_vbicv4si (TARGET_NEON) +#define HAVE_neon_vbicv2sf (TARGET_NEON) +#define HAVE_neon_vbicv4sf (TARGET_NEON) +#define HAVE_neon_vbicdi (TARGET_NEON) +#define HAVE_neon_vbicv2di (TARGET_NEON) +#define HAVE_neon_vornv8qi (TARGET_NEON) +#define HAVE_neon_vornv16qi (TARGET_NEON) +#define HAVE_neon_vornv4hi (TARGET_NEON) +#define HAVE_neon_vornv8hi (TARGET_NEON) +#define HAVE_neon_vornv2si (TARGET_NEON) +#define HAVE_neon_vornv4si (TARGET_NEON) +#define HAVE_neon_vornv2sf (TARGET_NEON) +#define HAVE_neon_vornv4sf (TARGET_NEON) +#define HAVE_neon_vorndi (TARGET_NEON) +#define HAVE_neon_vornv2di (TARGET_NEON) +#define HAVE_vec_unpacks_hi_v16qi (TARGET_NEON) +#define HAVE_vec_unpacku_hi_v16qi (TARGET_NEON) +#define HAVE_vec_unpacks_hi_v8hi (TARGET_NEON) +#define HAVE_vec_unpacku_hi_v8hi (TARGET_NEON) +#define HAVE_vec_unpacks_hi_v4si (TARGET_NEON) +#define HAVE_vec_unpacku_hi_v4si (TARGET_NEON) +#define HAVE_vec_unpacks_lo_v16qi (TARGET_NEON) +#define HAVE_vec_unpacku_lo_v16qi (TARGET_NEON) +#define HAVE_vec_unpacks_lo_v8hi (TARGET_NEON) +#define HAVE_vec_unpacku_lo_v8hi (TARGET_NEON) +#define HAVE_vec_unpacks_lo_v4si (TARGET_NEON) +#define HAVE_vec_unpacku_lo_v4si (TARGET_NEON) +#define HAVE_vec_widen_smult_lo_v16qi (TARGET_NEON) +#define HAVE_vec_widen_umult_lo_v16qi (TARGET_NEON) +#define HAVE_vec_widen_smult_lo_v8hi (TARGET_NEON) +#define HAVE_vec_widen_umult_lo_v8hi (TARGET_NEON) +#define HAVE_vec_widen_smult_lo_v4si (TARGET_NEON) +#define HAVE_vec_widen_umult_lo_v4si (TARGET_NEON) +#define HAVE_vec_widen_smult_hi_v16qi (TARGET_NEON) +#define HAVE_vec_widen_umult_hi_v16qi (TARGET_NEON) +#define HAVE_vec_widen_smult_hi_v8hi (TARGET_NEON) +#define HAVE_vec_widen_umult_hi_v8hi (TARGET_NEON) +#define HAVE_vec_widen_smult_hi_v4si (TARGET_NEON) +#define HAVE_vec_widen_umult_hi_v4si (TARGET_NEON) +#define HAVE_vec_unpacks_lo_v8qi (TARGET_NEON) +#define HAVE_vec_unpacku_lo_v8qi (TARGET_NEON) +#define HAVE_vec_unpacks_lo_v4hi (TARGET_NEON) +#define HAVE_vec_unpacku_lo_v4hi (TARGET_NEON) +#define HAVE_vec_unpacks_lo_v2si (TARGET_NEON) +#define HAVE_vec_unpacku_lo_v2si (TARGET_NEON) +#define HAVE_vec_unpacks_hi_v8qi (TARGET_NEON) +#define HAVE_vec_unpacku_hi_v8qi (TARGET_NEON) +#define HAVE_vec_unpacks_hi_v4hi (TARGET_NEON) +#define HAVE_vec_unpacku_hi_v4hi (TARGET_NEON) +#define HAVE_vec_unpacks_hi_v2si (TARGET_NEON) +#define HAVE_vec_unpacku_hi_v2si (TARGET_NEON) +#define HAVE_vec_widen_smult_hi_v8qi (TARGET_NEON) +#define HAVE_vec_widen_umult_hi_v8qi (TARGET_NEON) +#define HAVE_vec_widen_smult_hi_v4hi (TARGET_NEON) +#define HAVE_vec_widen_umult_hi_v4hi (TARGET_NEON) +#define HAVE_vec_widen_smult_hi_v2si (TARGET_NEON) +#define HAVE_vec_widen_umult_hi_v2si (TARGET_NEON) +#define HAVE_vec_widen_smult_lo_v8qi (TARGET_NEON) +#define HAVE_vec_widen_umult_lo_v8qi (TARGET_NEON) +#define HAVE_vec_widen_smult_lo_v4hi (TARGET_NEON) +#define HAVE_vec_widen_umult_lo_v4hi (TARGET_NEON) +#define HAVE_vec_widen_smult_lo_v2si (TARGET_NEON) +#define HAVE_vec_widen_umult_lo_v2si (TARGET_NEON) +#define HAVE_vec_pack_trunc_v4hi (TARGET_NEON) +#define HAVE_vec_pack_trunc_v2si (TARGET_NEON) +#define HAVE_vec_pack_trunc_di (TARGET_NEON) +#define HAVE_memory_barrier (TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_compare_and_swapsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_compare_and_swapqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_compare_and_swaphi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_lock_test_and_setsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_lock_test_and_setqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_lock_test_and_sethi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_addsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_subsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_iorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_xorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_andsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_nandsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_addqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_subqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_iorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_xorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_andqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_addhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_subhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_iorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_xorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_andhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_nandqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_nandhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_addsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_subsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_iorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_xorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_andsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_nandsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_addqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_subqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_iorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_xorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_andqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_addhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_subhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_iorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_xorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_andhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_nandqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_new_nandhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_addsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_subsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_iorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_xorsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_andsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_nandsi (TARGET_HAVE_LDREX && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_addqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_subqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_iorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_xorqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_andqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_addhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_subhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_iorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_xorhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_andhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_nandqi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +#define HAVE_sync_old_nandhi (TARGET_HAVE_LDREXBHD && TARGET_HAVE_MEMORY_BARRIER) +extern rtx gen_thumb1_subsi3_insn (rtx, rtx, rtx); +extern rtx gen_mulhisi3 (rtx, rtx, rtx); +extern rtx gen_maddhisi4 (rtx, rtx, rtx, rtx); +extern rtx gen_insv_zero (rtx, rtx, rtx); +extern rtx gen_insv_t2 (rtx, rtx, rtx, rtx); +extern rtx gen_andsi_notsi_si (rtx, rtx, rtx); +extern rtx gen_thumb1_bicsi3 (rtx, rtx, rtx); +extern rtx gen_andsi_not_shiftsi_si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_arm_ashldi3_1bit (rtx, rtx); +extern rtx gen_arm_ashrdi3_1bit (rtx, rtx); +extern rtx gen_arm_lshrdi3_1bit (rtx, rtx); +extern rtx gen_extv (rtx, rtx, rtx, rtx); +extern rtx gen_extzv_t2 (rtx, rtx, rtx, rtx); +extern rtx gen_one_cmpldi2 (rtx, rtx); +extern rtx gen_zero_extendqidi2 (rtx, rtx); +extern rtx gen_zero_extendhidi2 (rtx, rtx); +extern rtx gen_zero_extendsidi2 (rtx, rtx); +extern rtx gen_extendqidi2 (rtx, rtx); +extern rtx gen_extendhidi2 (rtx, rtx); +extern rtx gen_extendsidi2 (rtx, rtx); +extern rtx gen_thumb1_extendhisi2 (rtx, rtx); +extern rtx gen_thumb1_extendqisi2 (rtx, rtx); +extern rtx gen_pic_load_addr_32bit (rtx, rtx); +extern rtx gen_pic_load_addr_thumb1 (rtx, rtx); +extern rtx gen_pic_add_dot_plus_four (rtx, rtx, rtx); +extern rtx gen_pic_add_dot_plus_eight (rtx, rtx, rtx); +extern rtx gen_tls_load_dot_plus_eight (rtx, rtx, rtx); +static inline rtx gen_pic_offset_arm (rtx, rtx, rtx); +static inline rtx +gen_pic_offset_arm(rtx ARG_UNUSED (a), rtx ARG_UNUSED (b), rtx ARG_UNUSED (c)) +{ + return 0; +} +extern rtx gen_movmem12b (rtx, rtx, rtx, rtx); +extern rtx gen_movmem8b (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchsi4_insn (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchsi4_scratch (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_cstoresi_nltu_thumb1 (rtx, rtx, rtx); +extern rtx gen_cstoresi_ltu_thumb1 (rtx, rtx, rtx); +extern rtx gen_thumb1_addsi3_addgeu (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_blockage (void); +extern rtx gen_arm_casesi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_thumb1_casesi_dispatch (rtx); +extern rtx gen_nop (void); +extern rtx gen_movcond (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_sibcall_epilogue (void); +extern rtx gen_stack_tie (rtx, rtx); +extern rtx gen_align_4 (void); +extern rtx gen_align_8 (void); +extern rtx gen_consttable_end (void); +extern rtx gen_consttable_1 (rtx); +extern rtx gen_consttable_2 (rtx); +extern rtx gen_consttable_4 (rtx); +extern rtx gen_consttable_8 (rtx); +extern rtx gen_consttable_16 (rtx); +extern rtx gen_clzsi2 (rtx, rtx); +extern rtx gen_rbitsi2 (rtx, rtx); +extern rtx gen_prefetch (rtx, rtx, rtx); +extern rtx gen_prologue_use (rtx); +extern rtx gen_arm_eh_return (rtx); +extern rtx gen_thumb_eh_return (rtx); +extern rtx gen_load_tp_hard (rtx); +extern rtx gen_load_tp_soft (void); +extern rtx gen_cirrus_adddi3 (rtx, rtx, rtx); +extern rtx gen_cirrus_subdi3 (rtx, rtx, rtx); +extern rtx gen_muldi3 (rtx, rtx, rtx); +static inline rtx gen_cirrus_ashl_const (rtx, rtx, rtx); +static inline rtx +gen_cirrus_ashl_const(rtx ARG_UNUSED (a), rtx ARG_UNUSED (b), rtx ARG_UNUSED (c)) +{ + return 0; +} +static inline rtx gen_cirrus_ashiftrt_const (rtx, rtx, rtx); +static inline rtx +gen_cirrus_ashiftrt_const(rtx ARG_UNUSED (a), rtx ARG_UNUSED (b), rtx ARG_UNUSED (c)) +{ + return 0; +} +static inline rtx gen_cirrus_ashlsi3 (rtx, rtx, rtx); +static inline rtx +gen_cirrus_ashlsi3(rtx ARG_UNUSED (a), rtx ARG_UNUSED (b), rtx ARG_UNUSED (c)) +{ + return 0; +} +extern rtx gen_ashldi3_cirrus (rtx, rtx, rtx); +extern rtx gen_cirrus_ashldi_const (rtx, rtx, rtx); +extern rtx gen_cirrus_ashiftrtdi_const (rtx, rtx, rtx); +extern rtx gen_cirrus_floatsisf2 (rtx, rtx); +extern rtx gen_cirrus_floatsidf2 (rtx, rtx); +extern rtx gen_floatdisf2 (rtx, rtx); +extern rtx gen_floatdidf2 (rtx, rtx); +extern rtx gen_cirrus_truncsfsi2 (rtx, rtx); +extern rtx gen_cirrus_truncdfsi2 (rtx, rtx); +extern rtx gen_iwmmxt_iordi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_xordi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_anddi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_nanddi3 (rtx, rtx, rtx); +extern rtx gen_movv2si_internal (rtx, rtx); +extern rtx gen_movv4hi_internal (rtx, rtx); +extern rtx gen_movv8qi_internal (rtx, rtx); +extern rtx gen_ssaddv8qi3 (rtx, rtx, rtx); +extern rtx gen_ssaddv4hi3 (rtx, rtx, rtx); +extern rtx gen_ssaddv2si3 (rtx, rtx, rtx); +extern rtx gen_usaddv8qi3 (rtx, rtx, rtx); +extern rtx gen_usaddv4hi3 (rtx, rtx, rtx); +extern rtx gen_usaddv2si3 (rtx, rtx, rtx); +extern rtx gen_sssubv8qi3 (rtx, rtx, rtx); +extern rtx gen_sssubv4hi3 (rtx, rtx, rtx); +extern rtx gen_sssubv2si3 (rtx, rtx, rtx); +extern rtx gen_ussubv8qi3 (rtx, rtx, rtx); +extern rtx gen_ussubv4hi3 (rtx, rtx, rtx); +extern rtx gen_ussubv2si3 (rtx, rtx, rtx); +extern rtx gen_smulv4hi3_highpart (rtx, rtx, rtx); +extern rtx gen_umulv4hi3_highpart (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wmacs (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_wmacsz (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wmacu (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_wmacuz (rtx, rtx, rtx); +extern rtx gen_iwmmxt_clrdi (rtx); +extern rtx gen_iwmmxt_uavgrndv8qi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_uavgrndv4hi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_uavgv8qi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_uavgv4hi3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_psadbw (rtx, rtx, rtx); +extern rtx gen_iwmmxt_tinsrb (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tinsrh (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tinsrw (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_textrmub (rtx, rtx, rtx); +extern rtx gen_iwmmxt_textrmsb (rtx, rtx, rtx); +extern rtx gen_iwmmxt_textrmuh (rtx, rtx, rtx); +extern rtx gen_iwmmxt_textrmsh (rtx, rtx, rtx); +extern rtx gen_iwmmxt_textrmw (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wshufh (rtx, rtx, rtx); +extern rtx gen_eqv8qi3 (rtx, rtx, rtx); +extern rtx gen_eqv4hi3 (rtx, rtx, rtx); +extern rtx gen_eqv2si3 (rtx, rtx, rtx); +extern rtx gen_gtuv8qi3 (rtx, rtx, rtx); +extern rtx gen_gtuv4hi3 (rtx, rtx, rtx); +extern rtx gen_gtuv2si3 (rtx, rtx, rtx); +extern rtx gen_gtv8qi3 (rtx, rtx, rtx); +extern rtx gen_gtv4hi3 (rtx, rtx, rtx); +extern rtx gen_gtv2si3 (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wpackhss (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wpackwss (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wpackdss (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wpackhus (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wpackwus (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wpackdus (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckihb (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckihh (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckihw (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckilb (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckilh (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckilw (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wunpckehub (rtx, rtx); +extern rtx gen_iwmmxt_wunpckehuh (rtx, rtx); +extern rtx gen_iwmmxt_wunpckehuw (rtx, rtx); +extern rtx gen_iwmmxt_wunpckehsb (rtx, rtx); +extern rtx gen_iwmmxt_wunpckehsh (rtx, rtx); +extern rtx gen_iwmmxt_wunpckehsw (rtx, rtx); +extern rtx gen_iwmmxt_wunpckelub (rtx, rtx); +extern rtx gen_iwmmxt_wunpckeluh (rtx, rtx); +extern rtx gen_iwmmxt_wunpckeluw (rtx, rtx); +extern rtx gen_iwmmxt_wunpckelsb (rtx, rtx); +extern rtx gen_iwmmxt_wunpckelsh (rtx, rtx); +extern rtx gen_iwmmxt_wunpckelsw (rtx, rtx); +extern rtx gen_rorv4hi3 (rtx, rtx, rtx); +extern rtx gen_rorv2si3 (rtx, rtx, rtx); +extern rtx gen_rordi3 (rtx, rtx, rtx); +extern rtx gen_ashrv4hi3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_ashrv2si3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_ashrdi3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_lshrv4hi3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_lshrv2si3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_lshrdi3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_ashlv4hi3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_ashlv2si3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_ashldi3_iwmmxt (rtx, rtx, rtx); +extern rtx gen_rorv4hi3_di (rtx, rtx, rtx); +extern rtx gen_rorv2si3_di (rtx, rtx, rtx); +extern rtx gen_rordi3_di (rtx, rtx, rtx); +extern rtx gen_ashrv4hi3_di (rtx, rtx, rtx); +extern rtx gen_ashrv2si3_di (rtx, rtx, rtx); +extern rtx gen_ashrdi3_di (rtx, rtx, rtx); +extern rtx gen_lshrv4hi3_di (rtx, rtx, rtx); +extern rtx gen_lshrv2si3_di (rtx, rtx, rtx); +extern rtx gen_lshrdi3_di (rtx, rtx, rtx); +extern rtx gen_ashlv4hi3_di (rtx, rtx, rtx); +extern rtx gen_ashlv2si3_di (rtx, rtx, rtx); +extern rtx gen_ashldi3_di (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wmadds (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wmaddu (rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmia (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmiaph (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmiabb (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmiatb (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmiabt (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmiatt (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tbcstqi (rtx, rtx); +extern rtx gen_iwmmxt_tbcsthi (rtx, rtx); +extern rtx gen_iwmmxt_tbcstsi (rtx, rtx); +extern rtx gen_iwmmxt_tmovmskb (rtx, rtx); +extern rtx gen_iwmmxt_tmovmskh (rtx, rtx); +extern rtx gen_iwmmxt_tmovmskw (rtx, rtx); +extern rtx gen_iwmmxt_waccb (rtx, rtx); +extern rtx gen_iwmmxt_wacch (rtx, rtx); +extern rtx gen_iwmmxt_waccw (rtx, rtx); +extern rtx gen_iwmmxt_walign (rtx, rtx, rtx, rtx); +extern rtx gen_iwmmxt_tmrc (rtx, rtx); +extern rtx gen_iwmmxt_tmcr (rtx, rtx); +extern rtx gen_iwmmxt_wsadb (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wsadh (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wsadbz (rtx, rtx, rtx); +extern rtx gen_iwmmxt_wsadhz (rtx, rtx, rtx); +extern rtx gen_extendhfsf2 (rtx, rtx); +extern rtx gen_truncsfhf2 (rtx, rtx); +extern rtx gen_fixuns_truncsfsi2 (rtx, rtx); +extern rtx gen_fixuns_truncdfsi2 (rtx, rtx); +extern rtx gen_floatunssisf2 (rtx, rtx); +extern rtx gen_floatunssidf2 (rtx, rtx); +extern rtx gen_tls_load_dot_plus_four (rtx, rtx, rtx, rtx); +extern rtx gen_thumb2_zero_extendqisi2_v6 (rtx, rtx); +extern rtx gen_thumb2_casesi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_thumb2_casesi_internal_pic (rtx, rtx, rtx, rtx); +extern rtx gen_thumb2_eh_return (rtx); +extern rtx gen_divsi3 (rtx, rtx, rtx); +extern rtx gen_udivsi3 (rtx, rtx, rtx); +extern rtx gen_vec_setv8qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv4hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv2si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv2sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv16qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv8hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv4si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv4sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_setv2di_internal (rtx, rtx, rtx, rtx); +extern rtx gen_vec_extractv8qi (rtx, rtx, rtx); +extern rtx gen_vec_extractv4hi (rtx, rtx, rtx); +extern rtx gen_vec_extractv2si (rtx, rtx, rtx); +extern rtx gen_vec_extractv2sf (rtx, rtx, rtx); +extern rtx gen_vec_extractv16qi (rtx, rtx, rtx); +extern rtx gen_vec_extractv8hi (rtx, rtx, rtx); +extern rtx gen_vec_extractv4si (rtx, rtx, rtx); +extern rtx gen_vec_extractv4sf (rtx, rtx, rtx); +extern rtx gen_vec_extractv2di (rtx, rtx, rtx); +extern rtx gen_adddi3_neon (rtx, rtx, rtx); +extern rtx gen_subdi3_neon (rtx, rtx, rtx); +extern rtx gen_mulv8qi3addv8qi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv16qi3addv16qi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv4hi3addv4hi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv8hi3addv8hi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv2si3addv2si_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv4si3addv4si_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv2sf3addv2sf_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv4sf3addv4sf_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv2di3addv2di_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv8qi3negv8qiaddv8qi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv16qi3negv16qiaddv16qi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv4hi3negv4hiaddv4hi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv8hi3negv8hiaddv8hi_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv2si3negv2siaddv2si_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv4si3negv4siaddv4si_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv2sf3negv2sfaddv2sf_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv4sf3negv4sfaddv4sf_neon (rtx, rtx, rtx, rtx); +extern rtx gen_mulv2di3negv2diaddv2di_neon (rtx, rtx, rtx, rtx); +extern rtx gen_iorv8qi3 (rtx, rtx, rtx); +extern rtx gen_iorv16qi3 (rtx, rtx, rtx); +extern rtx gen_iorv4hi3 (rtx, rtx, rtx); +extern rtx gen_iorv8hi3 (rtx, rtx, rtx); +extern rtx gen_iorv2si3 (rtx, rtx, rtx); +extern rtx gen_iorv4si3 (rtx, rtx, rtx); +extern rtx gen_iorv2sf3 (rtx, rtx, rtx); +extern rtx gen_iorv4sf3 (rtx, rtx, rtx); +extern rtx gen_iorv2di3 (rtx, rtx, rtx); +extern rtx gen_iordi3_neon (rtx, rtx, rtx); +extern rtx gen_andv8qi3 (rtx, rtx, rtx); +extern rtx gen_andv16qi3 (rtx, rtx, rtx); +extern rtx gen_andv4hi3 (rtx, rtx, rtx); +extern rtx gen_andv8hi3 (rtx, rtx, rtx); +extern rtx gen_andv2si3 (rtx, rtx, rtx); +extern rtx gen_andv4si3 (rtx, rtx, rtx); +extern rtx gen_andv2sf3 (rtx, rtx, rtx); +extern rtx gen_andv4sf3 (rtx, rtx, rtx); +extern rtx gen_andv2di3 (rtx, rtx, rtx); +extern rtx gen_anddi3_neon (rtx, rtx, rtx); +extern rtx gen_ornv8qi3_neon (rtx, rtx, rtx); +extern rtx gen_ornv16qi3_neon (rtx, rtx, rtx); +extern rtx gen_ornv4hi3_neon (rtx, rtx, rtx); +extern rtx gen_ornv8hi3_neon (rtx, rtx, rtx); +extern rtx gen_ornv2si3_neon (rtx, rtx, rtx); +extern rtx gen_ornv4si3_neon (rtx, rtx, rtx); +extern rtx gen_ornv2sf3_neon (rtx, rtx, rtx); +extern rtx gen_ornv4sf3_neon (rtx, rtx, rtx); +extern rtx gen_ornv2di3_neon (rtx, rtx, rtx); +extern rtx gen_orndi3_neon (rtx, rtx, rtx); +extern rtx gen_bicv8qi3_neon (rtx, rtx, rtx); +extern rtx gen_bicv16qi3_neon (rtx, rtx, rtx); +extern rtx gen_bicv4hi3_neon (rtx, rtx, rtx); +extern rtx gen_bicv8hi3_neon (rtx, rtx, rtx); +extern rtx gen_bicv2si3_neon (rtx, rtx, rtx); +extern rtx gen_bicv4si3_neon (rtx, rtx, rtx); +extern rtx gen_bicv2sf3_neon (rtx, rtx, rtx); +extern rtx gen_bicv4sf3_neon (rtx, rtx, rtx); +extern rtx gen_bicv2di3_neon (rtx, rtx, rtx); +extern rtx gen_bicdi3_neon (rtx, rtx, rtx); +extern rtx gen_xorv8qi3 (rtx, rtx, rtx); +extern rtx gen_xorv16qi3 (rtx, rtx, rtx); +extern rtx gen_xorv4hi3 (rtx, rtx, rtx); +extern rtx gen_xorv8hi3 (rtx, rtx, rtx); +extern rtx gen_xorv2si3 (rtx, rtx, rtx); +extern rtx gen_xorv4si3 (rtx, rtx, rtx); +extern rtx gen_xorv2sf3 (rtx, rtx, rtx); +extern rtx gen_xorv4sf3 (rtx, rtx, rtx); +extern rtx gen_xorv2di3 (rtx, rtx, rtx); +extern rtx gen_xordi3_neon (rtx, rtx, rtx); +extern rtx gen_one_cmplv8qi2 (rtx, rtx); +extern rtx gen_one_cmplv16qi2 (rtx, rtx); +extern rtx gen_one_cmplv4hi2 (rtx, rtx); +extern rtx gen_one_cmplv8hi2 (rtx, rtx); +extern rtx gen_one_cmplv2si2 (rtx, rtx); +extern rtx gen_one_cmplv4si2 (rtx, rtx); +extern rtx gen_one_cmplv2sf2 (rtx, rtx); +extern rtx gen_one_cmplv4sf2 (rtx, rtx); +extern rtx gen_one_cmplv2di2 (rtx, rtx); +extern rtx gen_absv8qi2 (rtx, rtx); +extern rtx gen_absv16qi2 (rtx, rtx); +extern rtx gen_absv4hi2 (rtx, rtx); +extern rtx gen_absv8hi2 (rtx, rtx); +extern rtx gen_absv2si2 (rtx, rtx); +extern rtx gen_absv4si2 (rtx, rtx); +extern rtx gen_absv2sf2 (rtx, rtx); +extern rtx gen_absv4sf2 (rtx, rtx); +extern rtx gen_negv8qi2 (rtx, rtx); +extern rtx gen_negv16qi2 (rtx, rtx); +extern rtx gen_negv4hi2 (rtx, rtx); +extern rtx gen_negv8hi2 (rtx, rtx); +extern rtx gen_negv2si2 (rtx, rtx); +extern rtx gen_negv4si2 (rtx, rtx); +extern rtx gen_negv2sf2 (rtx, rtx); +extern rtx gen_negv4sf2 (rtx, rtx); +extern rtx gen_vashlv8qi3 (rtx, rtx, rtx); +extern rtx gen_vashlv16qi3 (rtx, rtx, rtx); +extern rtx gen_vashlv4hi3 (rtx, rtx, rtx); +extern rtx gen_vashlv8hi3 (rtx, rtx, rtx); +extern rtx gen_vashlv2si3 (rtx, rtx, rtx); +extern rtx gen_vashlv4si3 (rtx, rtx, rtx); +extern rtx gen_ashlv8qi3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv16qi3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv4hi3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv8hi3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv2si3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv4si3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv2di3_signed (rtx, rtx, rtx); +extern rtx gen_ashlv8qi3_unsigned (rtx, rtx, rtx); +extern rtx gen_ashlv16qi3_unsigned (rtx, rtx, rtx); +extern rtx gen_ashlv4hi3_unsigned (rtx, rtx, rtx); +extern rtx gen_ashlv8hi3_unsigned (rtx, rtx, rtx); +extern rtx gen_ashlv2si3_unsigned (rtx, rtx, rtx); +extern rtx gen_ashlv4si3_unsigned (rtx, rtx, rtx); +extern rtx gen_ashlv2di3_unsigned (rtx, rtx, rtx); +extern rtx gen_widen_ssumv8qi3 (rtx, rtx, rtx); +extern rtx gen_widen_ssumv4hi3 (rtx, rtx, rtx); +extern rtx gen_widen_ssumv2si3 (rtx, rtx, rtx); +extern rtx gen_widen_usumv8qi3 (rtx, rtx, rtx); +extern rtx gen_widen_usumv4hi3 (rtx, rtx, rtx); +extern rtx gen_widen_usumv2si3 (rtx, rtx, rtx); +extern rtx gen_quad_halves_plusv4si (rtx, rtx); +extern rtx gen_quad_halves_sminv4si (rtx, rtx); +extern rtx gen_quad_halves_smaxv4si (rtx, rtx); +extern rtx gen_quad_halves_uminv4si (rtx, rtx); +extern rtx gen_quad_halves_umaxv4si (rtx, rtx); +extern rtx gen_quad_halves_plusv4sf (rtx, rtx); +extern rtx gen_quad_halves_sminv4sf (rtx, rtx); +extern rtx gen_quad_halves_smaxv4sf (rtx, rtx); +extern rtx gen_quad_halves_plusv8hi (rtx, rtx); +extern rtx gen_quad_halves_sminv8hi (rtx, rtx); +extern rtx gen_quad_halves_smaxv8hi (rtx, rtx); +extern rtx gen_quad_halves_uminv8hi (rtx, rtx); +extern rtx gen_quad_halves_umaxv8hi (rtx, rtx); +extern rtx gen_quad_halves_plusv16qi (rtx, rtx); +extern rtx gen_quad_halves_sminv16qi (rtx, rtx); +extern rtx gen_quad_halves_smaxv16qi (rtx, rtx); +extern rtx gen_quad_halves_uminv16qi (rtx, rtx); +extern rtx gen_quad_halves_umaxv16qi (rtx, rtx); +extern rtx gen_neon_move_lo_quad_v2di (rtx, rtx, rtx); +extern rtx gen_neon_move_lo_quad_v2df (rtx, rtx, rtx); +extern rtx gen_neon_move_lo_quad_v16qi (rtx, rtx, rtx); +extern rtx gen_neon_move_lo_quad_v8hi (rtx, rtx, rtx); +extern rtx gen_neon_move_lo_quad_v4si (rtx, rtx, rtx); +extern rtx gen_neon_move_lo_quad_v4sf (rtx, rtx, rtx); +extern rtx gen_neon_move_hi_quad_v2di (rtx, rtx, rtx); +extern rtx gen_neon_move_hi_quad_v2df (rtx, rtx, rtx); +extern rtx gen_neon_move_hi_quad_v16qi (rtx, rtx, rtx); +extern rtx gen_neon_move_hi_quad_v8hi (rtx, rtx, rtx); +extern rtx gen_neon_move_hi_quad_v4si (rtx, rtx, rtx); +extern rtx gen_neon_move_hi_quad_v4sf (rtx, rtx, rtx); +extern rtx gen_reduc_splus_v2di (rtx, rtx); +extern rtx gen_neon_vpadd_internalv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vpadd_internalv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vpadd_internalv2si (rtx, rtx, rtx); +extern rtx gen_neon_vpadd_internalv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vpsminv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vpsminv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vpsminv2si (rtx, rtx, rtx); +extern rtx gen_neon_vpsminv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vpsmaxv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vpsmaxv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vpsmaxv2si (rtx, rtx, rtx); +extern rtx gen_neon_vpsmaxv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vpuminv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vpuminv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vpuminv2si (rtx, rtx, rtx); +extern rtx gen_neon_vpumaxv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vpumaxv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vpumaxv2si (rtx, rtx, rtx); +extern rtx gen_neon_vaddv8qi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv16qi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv4hi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv8hi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv2si_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv4si_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv2sf_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv4sf_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vadddi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddv2di_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vaddlv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddlv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddlv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddwv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddwv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddwv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhaddv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhaddv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhaddv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhaddv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhaddv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhaddv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqadddi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqaddv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddhnv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddhnv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddhnv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmulv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav8qi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav16qi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav4hi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav8hi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav2si_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav4si_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav2sf_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav4sf_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav2di_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlalv8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlalv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlalv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv8qi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv16qi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv4hi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv8hi_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv2si_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv4si_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv2sf_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv4sf_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv2di_unspec (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlslv8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlslv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlslv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulhv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulhv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulhv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulhv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlalv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlalv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlslv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlslv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmullv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmullv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmullv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmullv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmullv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv8qi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv16qi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv4hi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv8hi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv2si_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv4si_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv2sf_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv4sf_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubdi_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsubv2di_unspec (rtx, rtx, rtx); +extern rtx gen_neon_vsublv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsublv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsublv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubwv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubwv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubwv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubdi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqsubv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhsubv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhsubv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhsubv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhsubv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhsubv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vhsubv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubhnv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubhnv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubhnv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vceqv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcgtv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vclev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcltv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcagev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcagev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcagtv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcagtv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtstv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtstv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtstv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtstv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtstv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtstv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdlv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdlv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabdlv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabav8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabav16qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabav4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabav8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabav2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabav4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabalv8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabalv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabalv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmaxv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vminv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpaddlv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vpaddlv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vpaddlv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vpaddlv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vpaddlv2si (rtx, rtx, rtx); +extern rtx gen_neon_vpaddlv4si (rtx, rtx, rtx); +extern rtx gen_neon_vpadalv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpadalv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpadalv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpadalv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpadalv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpadalv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpmaxv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpmaxv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpmaxv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpmaxv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpminv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpminv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpminv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpminv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vrecpsv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vrecpsv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vrsqrtsv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vrsqrtsv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqabsv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vqabsv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vqabsv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vqabsv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vqabsv2si (rtx, rtx, rtx); +extern rtx gen_neon_vqabsv4si (rtx, rtx, rtx); +extern rtx gen_neon_vqnegv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vqnegv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vqnegv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vqnegv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vqnegv2si (rtx, rtx, rtx); +extern rtx gen_neon_vqnegv4si (rtx, rtx, rtx); +extern rtx gen_neon_vclsv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vclsv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vclsv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vclsv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vclsv2si (rtx, rtx, rtx); +extern rtx gen_neon_vclsv4si (rtx, rtx, rtx); +extern rtx gen_clzv8qi2 (rtx, rtx); +extern rtx gen_clzv16qi2 (rtx, rtx); +extern rtx gen_clzv4hi2 (rtx, rtx); +extern rtx gen_clzv8hi2 (rtx, rtx); +extern rtx gen_clzv2si2 (rtx, rtx); +extern rtx gen_clzv4si2 (rtx, rtx); +extern rtx gen_popcountv8qi2 (rtx, rtx); +extern rtx gen_popcountv16qi2 (rtx, rtx); +extern rtx gen_neon_vrecpev2si (rtx, rtx, rtx); +extern rtx gen_neon_vrecpev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vrecpev4si (rtx, rtx, rtx); +extern rtx gen_neon_vrecpev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vrsqrtev2si (rtx, rtx, rtx); +extern rtx gen_neon_vrsqrtev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vrsqrtev4si (rtx, rtx, rtx); +extern rtx gen_neon_vrsqrtev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev8qi_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4hi_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2si_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2sf_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev8qi_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4hi_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2si_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2sf_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev16qi_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev8hi_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4si_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4sf_sext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev16qi_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev8hi_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4si_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4sf_zext_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_nv8qi (rtx, rtx); +extern rtx gen_neon_vdup_nv4hi (rtx, rtx); +extern rtx gen_neon_vdup_nv16qi (rtx, rtx); +extern rtx gen_neon_vdup_nv8hi (rtx, rtx); +extern rtx gen_neon_vdup_nv2si (rtx, rtx); +extern rtx gen_neon_vdup_nv2sf (rtx, rtx); +extern rtx gen_neon_vdup_nv4si (rtx, rtx); +extern rtx gen_neon_vdup_nv4sf (rtx, rtx); +extern rtx gen_neon_vdup_nv2di (rtx, rtx); +extern rtx gen_neon_vdup_lanev8qi_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev16qi_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev4hi_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev8hi_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev2si_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev4si_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev2sf_internal (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev4sf_internal (rtx, rtx, rtx); +extern rtx gen_neon_vcombinev8qi (rtx, rtx, rtx); +extern rtx gen_neon_vcombinev4hi (rtx, rtx, rtx); +extern rtx gen_neon_vcombinev2si (rtx, rtx, rtx); +extern rtx gen_neon_vcombinev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vcombinedi (rtx, rtx, rtx); +extern rtx gen_neon_vget_highv16qi (rtx, rtx); +extern rtx gen_neon_vget_highv8hi (rtx, rtx); +extern rtx gen_neon_vget_highv4si (rtx, rtx); +extern rtx gen_neon_vget_highv4sf (rtx, rtx); +extern rtx gen_neon_vget_highv2di (rtx, rtx); +extern rtx gen_neon_vget_lowv16qi (rtx, rtx); +extern rtx gen_neon_vget_lowv8hi (rtx, rtx); +extern rtx gen_neon_vget_lowv4si (rtx, rtx); +extern rtx gen_neon_vget_lowv4sf (rtx, rtx); +extern rtx gen_neon_vget_lowv2di (rtx, rtx); +extern rtx gen_neon_vcvtv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vcvtv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vcvtv2si (rtx, rtx, rtx); +extern rtx gen_neon_vcvtv4si (rtx, rtx, rtx); +extern rtx gen_neon_vcvt_nv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcvt_nv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcvt_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcvt_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmovnv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vmovnv4si (rtx, rtx, rtx); +extern rtx gen_neon_vmovnv2di (rtx, rtx, rtx); +extern rtx gen_neon_vqmovnv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vqmovnv4si (rtx, rtx, rtx); +extern rtx gen_neon_vqmovnv2di (rtx, rtx, rtx); +extern rtx gen_neon_vqmovunv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vqmovunv4si (rtx, rtx, rtx); +extern rtx gen_neon_vqmovunv2di (rtx, rtx, rtx); +extern rtx gen_neon_vmovlv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vmovlv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vmovlv2si (rtx, rtx, rtx); +extern rtx gen_neon_vmul_lanev4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_lanev2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_lanev2sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_lanev8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_lanev4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_lanev4sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmull_lanev4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmull_lanev2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmull_lanev4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmull_lanev2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_lanev8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_lanev4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_lanev4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_lanev2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_lanev4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_lanev2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_lanev2sf (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_lanev8hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_lanev4si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_lanev4sf (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlal_lanev4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlal_lanev2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlal_lanev4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlal_lanev2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_lanev4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_lanev2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_lanev2sf (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_lanev8hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_lanev4si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_lanev4sf (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsl_lanev4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsl_lanev2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlsl_lanev4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlsl_lanev2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextdi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vextv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vrev64v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v4hi (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v8hi (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v2si (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v4si (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v2sf (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v4sf (rtx, rtx, rtx); +extern rtx gen_neon_vrev64v2di (rtx, rtx, rtx); +extern rtx gen_neon_vrev32v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vrev32v4hi (rtx, rtx, rtx); +extern rtx gen_neon_vrev32v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vrev32v8hi (rtx, rtx, rtx); +extern rtx gen_neon_vrev16v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vrev16v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vbslv8qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv16qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv4hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv8hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv2si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv4si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv2sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv4sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbsldi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv2di_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshldi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshlv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshldi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_ndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshr_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshrn_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshrn_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshrn_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshrn_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshrn_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshrn_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshrun_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshrun_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshrun_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_ndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshl_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_ndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshl_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_ndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqshlu_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshll_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshll_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vshll_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv16qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_ndi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsra_nv2di (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_ndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsri_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_ndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsli_nv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtbl1v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vtbl2v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vtbl3v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vtbl4v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vtbx1v8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtbx2v8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtbx3v8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtbx4v8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv8qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv16qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv4hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv8hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv2si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv4si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv2sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv4sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv8qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv16qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv4hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv8hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv2si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv4si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv2sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vzipv4sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv8qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv16qi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv4hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv8hi_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv2si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv4si_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv2sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vuzpv4sf_internal (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1v8qi (rtx, rtx); +extern rtx gen_neon_vld1v16qi (rtx, rtx); +extern rtx gen_neon_vld1v4hi (rtx, rtx); +extern rtx gen_neon_vld1v8hi (rtx, rtx); +extern rtx gen_neon_vld1v2si (rtx, rtx); +extern rtx gen_neon_vld1v4si (rtx, rtx); +extern rtx gen_neon_vld1v2sf (rtx, rtx); +extern rtx gen_neon_vld1v4sf (rtx, rtx); +extern rtx gen_neon_vld1di (rtx, rtx); +extern rtx gen_neon_vld1v2di (rtx, rtx); +extern rtx gen_neon_vld1_lanev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanedi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_lanev2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld1_dupv8qi (rtx, rtx); +extern rtx gen_neon_vld1_dupv4hi (rtx, rtx); +extern rtx gen_neon_vld1_dupv2si (rtx, rtx); +extern rtx gen_neon_vld1_dupv2sf (rtx, rtx); +extern rtx gen_neon_vld1_dupdi (rtx, rtx); +extern rtx gen_neon_vld1_dupv16qi (rtx, rtx); +extern rtx gen_neon_vld1_dupv8hi (rtx, rtx); +extern rtx gen_neon_vld1_dupv4si (rtx, rtx); +extern rtx gen_neon_vld1_dupv4sf (rtx, rtx); +extern rtx gen_neon_vld1_dupv2di (rtx, rtx); +extern rtx gen_neon_vst1v8qi (rtx, rtx); +extern rtx gen_neon_vst1v16qi (rtx, rtx); +extern rtx gen_neon_vst1v4hi (rtx, rtx); +extern rtx gen_neon_vst1v8hi (rtx, rtx); +extern rtx gen_neon_vst1v2si (rtx, rtx); +extern rtx gen_neon_vst1v4si (rtx, rtx); +extern rtx gen_neon_vst1v2sf (rtx, rtx); +extern rtx gen_neon_vst1v4sf (rtx, rtx); +extern rtx gen_neon_vst1di (rtx, rtx); +extern rtx gen_neon_vst1v2di (rtx, rtx); +extern rtx gen_neon_vst1_lanev8qi (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev4hi (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev2si (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanedi (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev16qi (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev4si (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vst1_lanev2di (rtx, rtx, rtx); +extern rtx gen_neon_vld2v8qi (rtx, rtx); +extern rtx gen_neon_vld2v4hi (rtx, rtx); +extern rtx gen_neon_vld2v2si (rtx, rtx); +extern rtx gen_neon_vld2v2sf (rtx, rtx); +extern rtx gen_neon_vld2di (rtx, rtx); +extern rtx gen_neon_vld2v16qi (rtx, rtx); +extern rtx gen_neon_vld2v8hi (rtx, rtx); +extern rtx gen_neon_vld2v4si (rtx, rtx); +extern rtx gen_neon_vld2v4sf (rtx, rtx); +extern rtx gen_neon_vld2_lanev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_lanev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_lanev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_lanev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_lanev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_lanev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_lanev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld2_dupv8qi (rtx, rtx); +extern rtx gen_neon_vld2_dupv4hi (rtx, rtx); +extern rtx gen_neon_vld2_dupv2si (rtx, rtx); +extern rtx gen_neon_vld2_dupv2sf (rtx, rtx); +extern rtx gen_neon_vld2_dupdi (rtx, rtx); +extern rtx gen_neon_vst2v8qi (rtx, rtx); +extern rtx gen_neon_vst2v4hi (rtx, rtx); +extern rtx gen_neon_vst2v2si (rtx, rtx); +extern rtx gen_neon_vst2v2sf (rtx, rtx); +extern rtx gen_neon_vst2di (rtx, rtx); +extern rtx gen_neon_vst2v16qi (rtx, rtx); +extern rtx gen_neon_vst2v8hi (rtx, rtx); +extern rtx gen_neon_vst2v4si (rtx, rtx); +extern rtx gen_neon_vst2v4sf (rtx, rtx); +extern rtx gen_neon_vst2_lanev8qi (rtx, rtx, rtx); +extern rtx gen_neon_vst2_lanev4hi (rtx, rtx, rtx); +extern rtx gen_neon_vst2_lanev2si (rtx, rtx, rtx); +extern rtx gen_neon_vst2_lanev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vst2_lanev8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst2_lanev4si (rtx, rtx, rtx); +extern rtx gen_neon_vst2_lanev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vld3v8qi (rtx, rtx); +extern rtx gen_neon_vld3v4hi (rtx, rtx); +extern rtx gen_neon_vld3v2si (rtx, rtx); +extern rtx gen_neon_vld3v2sf (rtx, rtx); +extern rtx gen_neon_vld3di (rtx, rtx); +extern rtx gen_neon_vld3qav16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qav8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qav4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qav4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qbv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qbv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qbv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3qbv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_lanev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld3_dupv8qi (rtx, rtx); +extern rtx gen_neon_vld3_dupv4hi (rtx, rtx); +extern rtx gen_neon_vld3_dupv2si (rtx, rtx); +extern rtx gen_neon_vld3_dupv2sf (rtx, rtx); +extern rtx gen_neon_vld3_dupdi (rtx, rtx); +extern rtx gen_neon_vst3v8qi (rtx, rtx); +extern rtx gen_neon_vst3v4hi (rtx, rtx); +extern rtx gen_neon_vst3v2si (rtx, rtx); +extern rtx gen_neon_vst3v2sf (rtx, rtx); +extern rtx gen_neon_vst3di (rtx, rtx); +extern rtx gen_neon_vst3qav16qi (rtx, rtx, rtx); +extern rtx gen_neon_vst3qav8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst3qav4si (rtx, rtx, rtx); +extern rtx gen_neon_vst3qav4sf (rtx, rtx, rtx); +extern rtx gen_neon_vst3qbv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vst3qbv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst3qbv4si (rtx, rtx, rtx); +extern rtx gen_neon_vst3qbv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev8qi (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev4hi (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev2si (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev4si (rtx, rtx, rtx); +extern rtx gen_neon_vst3_lanev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vld4v8qi (rtx, rtx); +extern rtx gen_neon_vld4v4hi (rtx, rtx); +extern rtx gen_neon_vld4v2si (rtx, rtx); +extern rtx gen_neon_vld4v2sf (rtx, rtx); +extern rtx gen_neon_vld4di (rtx, rtx); +extern rtx gen_neon_vld4qav16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qav8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qav4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qav4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qbv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qbv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qbv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4qbv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_lanev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vld4_dupv8qi (rtx, rtx); +extern rtx gen_neon_vld4_dupv4hi (rtx, rtx); +extern rtx gen_neon_vld4_dupv2si (rtx, rtx); +extern rtx gen_neon_vld4_dupv2sf (rtx, rtx); +extern rtx gen_neon_vld4_dupdi (rtx, rtx); +extern rtx gen_neon_vst4v8qi (rtx, rtx); +extern rtx gen_neon_vst4v4hi (rtx, rtx); +extern rtx gen_neon_vst4v2si (rtx, rtx); +extern rtx gen_neon_vst4v2sf (rtx, rtx); +extern rtx gen_neon_vst4di (rtx, rtx); +extern rtx gen_neon_vst4qav16qi (rtx, rtx, rtx); +extern rtx gen_neon_vst4qav8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst4qav4si (rtx, rtx, rtx); +extern rtx gen_neon_vst4qav4sf (rtx, rtx, rtx); +extern rtx gen_neon_vst4qbv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vst4qbv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst4qbv4si (rtx, rtx, rtx); +extern rtx gen_neon_vst4qbv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev8qi (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev4hi (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev2si (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev8hi (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev4si (rtx, rtx, rtx); +extern rtx gen_neon_vst4_lanev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacks_lo_v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacku_lo_v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacks_lo_v8hi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacku_lo_v8hi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacks_lo_v4si (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacku_lo_v4si (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacks_hi_v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacku_hi_v16qi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacks_hi_v8hi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacku_hi_v8hi (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacks_hi_v4si (rtx, rtx, rtx); +extern rtx gen_neon_vec_unpacku_hi_v4si (rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_lo_v16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_lo_v16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_lo_v8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_lo_v8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_lo_v4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_lo_v4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_hi_v16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_hi_v16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_hi_v8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_hi_v8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_hi_v4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_hi_v4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_unpacks_v8qi (rtx, rtx); +extern rtx gen_neon_unpacku_v8qi (rtx, rtx); +extern rtx gen_neon_unpacks_v4hi (rtx, rtx); +extern rtx gen_neon_unpacku_v4hi (rtx, rtx); +extern rtx gen_neon_unpacks_v2si (rtx, rtx); +extern rtx gen_neon_unpacku_v2si (rtx, rtx); +extern rtx gen_neon_vec_smult_v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_v8qi (rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_v4hi (rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_v4hi (rtx, rtx, rtx); +extern rtx gen_neon_vec_smult_v2si (rtx, rtx, rtx); +extern rtx gen_neon_vec_umult_v2si (rtx, rtx, rtx); +extern rtx gen_vec_pack_trunc_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_pack_trunc_v4si (rtx, rtx, rtx); +extern rtx gen_vec_pack_trunc_v2di (rtx, rtx, rtx); +extern rtx gen_neon_vec_pack_trunc_v8hi (rtx, rtx); +extern rtx gen_neon_vec_pack_trunc_v4si (rtx, rtx); +extern rtx gen_neon_vec_pack_trunc_v2di (rtx, rtx); +extern rtx gen_arm_sync_compare_and_swapsi (rtx, rtx, rtx, rtx); +extern rtx gen_arm_sync_compare_and_swapqi (rtx, rtx, rtx, rtx); +extern rtx gen_arm_sync_compare_and_swaphi (rtx, rtx, rtx, rtx); +extern rtx gen_arm_sync_lock_test_and_setsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_lock_test_and_setqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_lock_test_and_sethi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_addsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_subsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_iorsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_xorsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_andsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_nandsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_addqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_subqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_iorqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_xorqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_andqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_addhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_subhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_iorhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_xorhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_andhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_nandqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_new_nandhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_addsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_subsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_iorsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_xorsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_andsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_nandsi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_addqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_subqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_iorqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_xorqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_andqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_addhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_subhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_iorhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_xorhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_andhi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_nandqi (rtx, rtx, rtx); +extern rtx gen_arm_sync_old_nandhi (rtx, rtx, rtx); +extern rtx gen_adddi3 (rtx, rtx, rtx); +extern rtx gen_addsi3 (rtx, rtx, rtx); +extern rtx gen_incscc (rtx, rtx, rtx, rtx); +extern rtx gen_addsf3 (rtx, rtx, rtx); +extern rtx gen_adddf3 (rtx, rtx, rtx); +extern rtx gen_subdi3 (rtx, rtx, rtx); +extern rtx gen_subsi3 (rtx, rtx, rtx); +extern rtx gen_decscc (rtx, rtx, rtx, rtx); +extern rtx gen_subsf3 (rtx, rtx, rtx); +extern rtx gen_subdf3 (rtx, rtx, rtx); +extern rtx gen_mulsi3 (rtx, rtx, rtx); +extern rtx gen_maddsidi4 (rtx, rtx, rtx, rtx); +extern rtx gen_mulsidi3 (rtx, rtx, rtx); +extern rtx gen_umulsidi3 (rtx, rtx, rtx); +extern rtx gen_umaddsidi4 (rtx, rtx, rtx, rtx); +extern rtx gen_smulsi3_highpart (rtx, rtx, rtx); +extern rtx gen_umulsi3_highpart (rtx, rtx, rtx); +extern rtx gen_mulsf3 (rtx, rtx, rtx); +extern rtx gen_muldf3 (rtx, rtx, rtx); +extern rtx gen_divsf3 (rtx, rtx, rtx); +extern rtx gen_divdf3 (rtx, rtx, rtx); +extern rtx gen_modsf3 (rtx, rtx, rtx); +extern rtx gen_moddf3 (rtx, rtx, rtx); +extern rtx gen_anddi3 (rtx, rtx, rtx); +extern rtx gen_andsi3 (rtx, rtx, rtx); +extern rtx gen_insv (rtx, rtx, rtx, rtx); +extern rtx gen_iordi3 (rtx, rtx, rtx); +extern rtx gen_iorsi3 (rtx, rtx, rtx); +extern rtx gen_xordi3 (rtx, rtx, rtx); +extern rtx gen_xorsi3 (rtx, rtx, rtx); +extern rtx gen_smaxsi3 (rtx, rtx, rtx); +extern rtx gen_sminsi3 (rtx, rtx, rtx); +extern rtx gen_umaxsi3 (rtx, rtx, rtx); +extern rtx gen_uminsi3 (rtx, rtx, rtx); +extern rtx gen_ashldi3 (rtx, rtx, rtx); +extern rtx gen_ashlsi3 (rtx, rtx, rtx); +extern rtx gen_ashrdi3 (rtx, rtx, rtx); +extern rtx gen_ashrsi3 (rtx, rtx, rtx); +extern rtx gen_lshrdi3 (rtx, rtx, rtx); +extern rtx gen_lshrsi3 (rtx, rtx, rtx); +extern rtx gen_rotlsi3 (rtx, rtx, rtx); +extern rtx gen_rotrsi3 (rtx, rtx, rtx); +extern rtx gen_extzv (rtx, rtx, rtx, rtx); +extern rtx gen_negdi2 (rtx, rtx); +extern rtx gen_negsi2 (rtx, rtx); +extern rtx gen_negsf2 (rtx, rtx); +extern rtx gen_negdf2 (rtx, rtx); +extern rtx gen_abssi2 (rtx, rtx); +extern rtx gen_abssf2 (rtx, rtx); +extern rtx gen_absdf2 (rtx, rtx); +extern rtx gen_sqrtsf2 (rtx, rtx); +extern rtx gen_sqrtdf2 (rtx, rtx); +extern rtx gen_one_cmplsi2 (rtx, rtx); +extern rtx gen_floatsihf2 (rtx, rtx); +extern rtx gen_floatdihf2 (rtx, rtx); +extern rtx gen_floatsisf2 (rtx, rtx); +extern rtx gen_floatsidf2 (rtx, rtx); +extern rtx gen_fix_trunchfsi2 (rtx, rtx); +extern rtx gen_fix_trunchfdi2 (rtx, rtx); +extern rtx gen_fix_truncsfsi2 (rtx, rtx); +extern rtx gen_fix_truncdfsi2 (rtx, rtx); +extern rtx gen_truncdfsf2 (rtx, rtx); +extern rtx gen_truncdfhf2 (rtx, rtx); +extern rtx gen_zero_extendhisi2 (rtx, rtx); +extern rtx gen_zero_extendqisi2 (rtx, rtx); +extern rtx gen_extendhisi2 (rtx, rtx); +extern rtx gen_extendhisi2_mem (rtx, rtx); +extern rtx gen_extendqihi2 (rtx, rtx); +extern rtx gen_extendqisi2 (rtx, rtx); +extern rtx gen_extendsfdf2 (rtx, rtx); +extern rtx gen_extendhfdf2 (rtx, rtx); +extern rtx gen_movdi (rtx, rtx); +extern rtx gen_movsi (rtx, rtx); +extern rtx gen_calculate_pic_address (rtx, rtx, rtx); +extern rtx gen_builtin_setjmp_receiver (rtx); +extern rtx gen_storehi (rtx, rtx); +extern rtx gen_storehi_bigend (rtx, rtx); +extern rtx gen_storeinthi (rtx, rtx); +extern rtx gen_storehi_single_op (rtx, rtx); +extern rtx gen_movhi (rtx, rtx); +extern rtx gen_movhi_bytes (rtx, rtx); +extern rtx gen_movhi_bigend (rtx, rtx); +extern rtx gen_thumb_movhi_clobber (rtx, rtx, rtx); +extern rtx gen_reload_outhi (rtx, rtx, rtx); +extern rtx gen_reload_inhi (rtx, rtx, rtx); +extern rtx gen_movqi (rtx, rtx); +extern rtx gen_movhf (rtx, rtx); +extern rtx gen_movsf (rtx, rtx); +extern rtx gen_movdf (rtx, rtx); +extern rtx gen_reload_outdf (rtx, rtx, rtx); +extern rtx gen_movxf (rtx, rtx); +extern rtx gen_load_multiple (rtx, rtx, rtx); +extern rtx gen_store_multiple (rtx, rtx, rtx); +extern rtx gen_movmemqi (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchsi4 (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchqi4 (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchsf4 (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchdf4 (rtx, rtx, rtx, rtx); +extern rtx gen_cbranchdi4 (rtx, rtx, rtx, rtx); +extern rtx gen_cbranch_cc (rtx, rtx, rtx, rtx); +extern rtx gen_cstore_cc (rtx, rtx, rtx, rtx); +extern rtx gen_cstoresi4 (rtx, rtx, rtx, rtx); +extern rtx gen_cstoresf4 (rtx, rtx, rtx, rtx); +extern rtx gen_cstoredf4 (rtx, rtx, rtx, rtx); +extern rtx gen_cstoredi4 (rtx, rtx, rtx, rtx); +extern rtx gen_cstoresi_eq0_thumb1 (rtx, rtx); +extern rtx gen_cstoresi_ne0_thumb1 (rtx, rtx); +extern rtx gen_movsicc (rtx, rtx, rtx, rtx); +extern rtx gen_movsfcc (rtx, rtx, rtx, rtx); +extern rtx gen_movdfcc (rtx, rtx, rtx, rtx); +extern rtx gen_jump (rtx); +#define GEN_CALL(A, B, C, D) gen_call ((A), (B), (C)) +extern rtx gen_call (rtx, rtx, rtx); +extern rtx gen_call_internal (rtx, rtx, rtx); +#define GEN_CALL_VALUE(A, B, C, D, E) gen_call_value ((A), (B), (C), (D)) +extern rtx gen_call_value (rtx, rtx, rtx, rtx); +extern rtx gen_call_value_internal (rtx, rtx, rtx, rtx); +#define GEN_SIBCALL(A, B, C, D) gen_sibcall ((A), (B), (C)) +extern rtx gen_sibcall (rtx, rtx, rtx); +#define GEN_SIBCALL_VALUE(A, B, C, D, E) gen_sibcall_value ((A), (B), (C), (D)) +extern rtx gen_sibcall_value (rtx, rtx, rtx, rtx); +extern rtx gen_return (void); +extern rtx gen_return_addr_mask (rtx); +extern rtx gen_untyped_call (rtx, rtx, rtx); +extern rtx gen_untyped_return (rtx, rtx); +extern rtx gen_casesi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_thumb1_casesi_internal_pic (rtx, rtx, rtx, rtx); +extern rtx gen_indirect_jump (rtx); +extern rtx gen_prologue (void); +extern rtx gen_epilogue (void); +extern rtx gen_eh_epilogue (rtx, rtx, rtx); +extern rtx gen_tablejump (rtx, rtx); +extern rtx gen_ctzsi2 (rtx, rtx); +extern rtx gen_eh_return (rtx); +extern rtx gen_arm_legacy_rev (rtx, rtx, rtx, rtx); +extern rtx gen_thumb_legacy_rev (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_bswapsi2 (rtx, rtx); +extern rtx gen_movv2di (rtx, rtx); +extern rtx gen_movv2si (rtx, rtx); +extern rtx gen_movv4hi (rtx, rtx); +extern rtx gen_movv8qi (rtx, rtx); +extern rtx gen_movv2sf (rtx, rtx); +extern rtx gen_movv4si (rtx, rtx); +extern rtx gen_movv8hi (rtx, rtx); +extern rtx gen_movv16qi (rtx, rtx); +extern rtx gen_movv4sf (rtx, rtx); +extern rtx gen_addv2di3 (rtx, rtx, rtx); +extern rtx gen_addv2si3 (rtx, rtx, rtx); +extern rtx gen_addv4hi3 (rtx, rtx, rtx); +extern rtx gen_addv8qi3 (rtx, rtx, rtx); +extern rtx gen_addv2sf3 (rtx, rtx, rtx); +extern rtx gen_addv4si3 (rtx, rtx, rtx); +extern rtx gen_addv8hi3 (rtx, rtx, rtx); +extern rtx gen_addv16qi3 (rtx, rtx, rtx); +extern rtx gen_addv4sf3 (rtx, rtx, rtx); +extern rtx gen_subv2di3 (rtx, rtx, rtx); +extern rtx gen_subv2si3 (rtx, rtx, rtx); +extern rtx gen_subv4hi3 (rtx, rtx, rtx); +extern rtx gen_subv8qi3 (rtx, rtx, rtx); +extern rtx gen_subv2sf3 (rtx, rtx, rtx); +extern rtx gen_subv4si3 (rtx, rtx, rtx); +extern rtx gen_subv8hi3 (rtx, rtx, rtx); +extern rtx gen_subv16qi3 (rtx, rtx, rtx); +extern rtx gen_subv4sf3 (rtx, rtx, rtx); +extern rtx gen_mulv2si3 (rtx, rtx, rtx); +extern rtx gen_mulv4hi3 (rtx, rtx, rtx); +extern rtx gen_mulv8qi3 (rtx, rtx, rtx); +extern rtx gen_mulv2sf3 (rtx, rtx, rtx); +extern rtx gen_mulv4si3 (rtx, rtx, rtx); +extern rtx gen_mulv8hi3 (rtx, rtx, rtx); +extern rtx gen_mulv16qi3 (rtx, rtx, rtx); +extern rtx gen_mulv4sf3 (rtx, rtx, rtx); +extern rtx gen_sminv2si3 (rtx, rtx, rtx); +extern rtx gen_sminv4hi3 (rtx, rtx, rtx); +extern rtx gen_sminv8qi3 (rtx, rtx, rtx); +extern rtx gen_sminv2sf3 (rtx, rtx, rtx); +extern rtx gen_sminv4si3 (rtx, rtx, rtx); +extern rtx gen_sminv8hi3 (rtx, rtx, rtx); +extern rtx gen_sminv16qi3 (rtx, rtx, rtx); +extern rtx gen_sminv4sf3 (rtx, rtx, rtx); +extern rtx gen_uminv2si3 (rtx, rtx, rtx); +extern rtx gen_uminv4hi3 (rtx, rtx, rtx); +extern rtx gen_uminv8qi3 (rtx, rtx, rtx); +extern rtx gen_uminv4si3 (rtx, rtx, rtx); +extern rtx gen_uminv8hi3 (rtx, rtx, rtx); +extern rtx gen_uminv16qi3 (rtx, rtx, rtx); +extern rtx gen_smaxv2si3 (rtx, rtx, rtx); +extern rtx gen_smaxv4hi3 (rtx, rtx, rtx); +extern rtx gen_smaxv8qi3 (rtx, rtx, rtx); +extern rtx gen_smaxv2sf3 (rtx, rtx, rtx); +extern rtx gen_smaxv4si3 (rtx, rtx, rtx); +extern rtx gen_smaxv8hi3 (rtx, rtx, rtx); +extern rtx gen_smaxv16qi3 (rtx, rtx, rtx); +extern rtx gen_smaxv4sf3 (rtx, rtx, rtx); +extern rtx gen_umaxv2si3 (rtx, rtx, rtx); +extern rtx gen_umaxv4hi3 (rtx, rtx, rtx); +extern rtx gen_umaxv8qi3 (rtx, rtx, rtx); +extern rtx gen_umaxv4si3 (rtx, rtx, rtx); +extern rtx gen_umaxv8hi3 (rtx, rtx, rtx); +extern rtx gen_umaxv16qi3 (rtx, rtx, rtx); +extern rtx gen_movti (rtx, rtx); +extern rtx gen_movei (rtx, rtx); +extern rtx gen_movoi (rtx, rtx); +extern rtx gen_movci (rtx, rtx); +extern rtx gen_movxi (rtx, rtx); +extern rtx gen_movmisalignv8qi (rtx, rtx); +extern rtx gen_movmisalignv16qi (rtx, rtx); +extern rtx gen_movmisalignv4hi (rtx, rtx); +extern rtx gen_movmisalignv8hi (rtx, rtx); +extern rtx gen_movmisalignv2si (rtx, rtx); +extern rtx gen_movmisalignv4si (rtx, rtx); +extern rtx gen_movmisalignv2sf (rtx, rtx); +extern rtx gen_movmisalignv4sf (rtx, rtx); +extern rtx gen_movmisaligndi (rtx, rtx); +extern rtx gen_movmisalignv2di (rtx, rtx); +extern rtx gen_vec_setv8qi (rtx, rtx, rtx); +extern rtx gen_vec_setv16qi (rtx, rtx, rtx); +extern rtx gen_vec_setv4hi (rtx, rtx, rtx); +extern rtx gen_vec_setv8hi (rtx, rtx, rtx); +extern rtx gen_vec_setv2si (rtx, rtx, rtx); +extern rtx gen_vec_setv4si (rtx, rtx, rtx); +extern rtx gen_vec_setv2sf (rtx, rtx, rtx); +extern rtx gen_vec_setv4sf (rtx, rtx, rtx); +extern rtx gen_vec_setv2di (rtx, rtx, rtx); +extern rtx gen_vec_initv8qi (rtx, rtx); +extern rtx gen_vec_initv16qi (rtx, rtx); +extern rtx gen_vec_initv4hi (rtx, rtx); +extern rtx gen_vec_initv8hi (rtx, rtx); +extern rtx gen_vec_initv2si (rtx, rtx); +extern rtx gen_vec_initv4si (rtx, rtx); +extern rtx gen_vec_initv2sf (rtx, rtx); +extern rtx gen_vec_initv4sf (rtx, rtx); +extern rtx gen_vec_initv2di (rtx, rtx); +extern rtx gen_vashrv8qi3 (rtx, rtx, rtx); +extern rtx gen_vashrv16qi3 (rtx, rtx, rtx); +extern rtx gen_vashrv4hi3 (rtx, rtx, rtx); +extern rtx gen_vashrv8hi3 (rtx, rtx, rtx); +extern rtx gen_vashrv2si3 (rtx, rtx, rtx); +extern rtx gen_vashrv4si3 (rtx, rtx, rtx); +extern rtx gen_vlshrv8qi3 (rtx, rtx, rtx); +extern rtx gen_vlshrv16qi3 (rtx, rtx, rtx); +extern rtx gen_vlshrv4hi3 (rtx, rtx, rtx); +extern rtx gen_vlshrv8hi3 (rtx, rtx, rtx); +extern rtx gen_vlshrv2si3 (rtx, rtx, rtx); +extern rtx gen_vlshrv4si3 (rtx, rtx, rtx); +extern rtx gen_vec_shr_v8qi (rtx, rtx, rtx); +extern rtx gen_vec_shr_v16qi (rtx, rtx, rtx); +extern rtx gen_vec_shr_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_shr_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_shr_v2si (rtx, rtx, rtx); +extern rtx gen_vec_shr_v4si (rtx, rtx, rtx); +extern rtx gen_vec_shr_v2sf (rtx, rtx, rtx); +extern rtx gen_vec_shr_v4sf (rtx, rtx, rtx); +extern rtx gen_vec_shr_v2di (rtx, rtx, rtx); +extern rtx gen_vec_shl_v8qi (rtx, rtx, rtx); +extern rtx gen_vec_shl_v16qi (rtx, rtx, rtx); +extern rtx gen_vec_shl_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_shl_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_shl_v2si (rtx, rtx, rtx); +extern rtx gen_vec_shl_v4si (rtx, rtx, rtx); +extern rtx gen_vec_shl_v2sf (rtx, rtx, rtx); +extern rtx gen_vec_shl_v4sf (rtx, rtx, rtx); +extern rtx gen_vec_shl_v2di (rtx, rtx, rtx); +extern rtx gen_move_hi_quad_v2di (rtx, rtx); +extern rtx gen_move_hi_quad_v2df (rtx, rtx); +extern rtx gen_move_hi_quad_v16qi (rtx, rtx); +extern rtx gen_move_hi_quad_v8hi (rtx, rtx); +extern rtx gen_move_hi_quad_v4si (rtx, rtx); +extern rtx gen_move_hi_quad_v4sf (rtx, rtx); +extern rtx gen_move_lo_quad_v2di (rtx, rtx); +extern rtx gen_move_lo_quad_v2df (rtx, rtx); +extern rtx gen_move_lo_quad_v16qi (rtx, rtx); +extern rtx gen_move_lo_quad_v8hi (rtx, rtx); +extern rtx gen_move_lo_quad_v4si (rtx, rtx); +extern rtx gen_move_lo_quad_v4sf (rtx, rtx); +extern rtx gen_reduc_splus_v8qi (rtx, rtx); +extern rtx gen_reduc_splus_v4hi (rtx, rtx); +extern rtx gen_reduc_splus_v2si (rtx, rtx); +extern rtx gen_reduc_splus_v2sf (rtx, rtx); +extern rtx gen_reduc_splus_v16qi (rtx, rtx); +extern rtx gen_reduc_splus_v8hi (rtx, rtx); +extern rtx gen_reduc_splus_v4si (rtx, rtx); +extern rtx gen_reduc_splus_v4sf (rtx, rtx); +extern rtx gen_reduc_uplus_v8qi (rtx, rtx); +extern rtx gen_reduc_uplus_v16qi (rtx, rtx); +extern rtx gen_reduc_uplus_v4hi (rtx, rtx); +extern rtx gen_reduc_uplus_v8hi (rtx, rtx); +extern rtx gen_reduc_uplus_v2si (rtx, rtx); +extern rtx gen_reduc_uplus_v4si (rtx, rtx); +extern rtx gen_reduc_uplus_v2di (rtx, rtx); +extern rtx gen_reduc_smin_v8qi (rtx, rtx); +extern rtx gen_reduc_smin_v4hi (rtx, rtx); +extern rtx gen_reduc_smin_v2si (rtx, rtx); +extern rtx gen_reduc_smin_v2sf (rtx, rtx); +extern rtx gen_reduc_smin_v16qi (rtx, rtx); +extern rtx gen_reduc_smin_v8hi (rtx, rtx); +extern rtx gen_reduc_smin_v4si (rtx, rtx); +extern rtx gen_reduc_smin_v4sf (rtx, rtx); +extern rtx gen_reduc_smax_v8qi (rtx, rtx); +extern rtx gen_reduc_smax_v4hi (rtx, rtx); +extern rtx gen_reduc_smax_v2si (rtx, rtx); +extern rtx gen_reduc_smax_v2sf (rtx, rtx); +extern rtx gen_reduc_smax_v16qi (rtx, rtx); +extern rtx gen_reduc_smax_v8hi (rtx, rtx); +extern rtx gen_reduc_smax_v4si (rtx, rtx); +extern rtx gen_reduc_smax_v4sf (rtx, rtx); +extern rtx gen_reduc_umin_v8qi (rtx, rtx); +extern rtx gen_reduc_umin_v4hi (rtx, rtx); +extern rtx gen_reduc_umin_v2si (rtx, rtx); +extern rtx gen_reduc_umin_v16qi (rtx, rtx); +extern rtx gen_reduc_umin_v8hi (rtx, rtx); +extern rtx gen_reduc_umin_v4si (rtx, rtx); +extern rtx gen_reduc_umax_v8qi (rtx, rtx); +extern rtx gen_reduc_umax_v4hi (rtx, rtx); +extern rtx gen_reduc_umax_v2si (rtx, rtx); +extern rtx gen_reduc_umax_v16qi (rtx, rtx); +extern rtx gen_reduc_umax_v8hi (rtx, rtx); +extern rtx gen_reduc_umax_v4si (rtx, rtx); +extern rtx gen_vcondv8qi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv16qi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv8hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv4si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv2sf (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vcondv4sf (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vconduv8qi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vconduv16qi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vconduv4hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vconduv8hi (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vconduv2si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_vconduv4si (rtx, rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vadddi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vaddv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav16qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav2sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlav4sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv8qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv16qi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv2sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsv4sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubdi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vsubv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpaddv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpaddv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpaddv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vpaddv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vabsv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vabsv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vabsv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vabsv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vabsv2si (rtx, rtx, rtx); +extern rtx gen_neon_vabsv4si (rtx, rtx, rtx); +extern rtx gen_neon_vabsv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vabsv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vnegv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vnegv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vnegv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vnegv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vnegv2si (rtx, rtx, rtx); +extern rtx gen_neon_vnegv4si (rtx, rtx, rtx); +extern rtx gen_neon_vnegv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vnegv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vclzv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vclzv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vclzv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vclzv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vclzv2si (rtx, rtx, rtx); +extern rtx gen_neon_vclzv4si (rtx, rtx, rtx); +extern rtx gen_neon_vcntv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vcntv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vmvnv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vmvnv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vmvnv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vmvnv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vmvnv2si (rtx, rtx, rtx); +extern rtx gen_neon_vmvnv4si (rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanedi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vget_lanev2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanev2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vset_lanedi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vcreatev8qi (rtx, rtx); +extern rtx gen_neon_vcreatev4hi (rtx, rtx); +extern rtx gen_neon_vcreatev2si (rtx, rtx); +extern rtx gen_neon_vcreatev2sf (rtx, rtx); +extern rtx gen_neon_vcreatedi (rtx, rtx); +extern rtx gen_neon_vdup_ndi (rtx, rtx); +extern rtx gen_neon_vdup_lanev8qi (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev16qi (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev4hi (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev8hi (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev2si (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev4si (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev2sf (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev4sf (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanedi (rtx, rtx, rtx); +extern rtx gen_neon_vdup_lanev2di (rtx, rtx, rtx); +extern rtx gen_neon_vmul_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_nv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmul_nv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmull_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmull_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmull_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmull_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_nv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_nv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_nv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmulh_nv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_nv2sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_nv8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_nv4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmla_nv4sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlal_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlal_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlal_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlal_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_nv2sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_nv8hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_nv4si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmls_nv4sf (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsl_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vmlsl_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlsl_nv4hi (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vqdmlsl_nv2si (rtx, rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbsldi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbslv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vtrnv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv2si (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv4si (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vtrnv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vzipv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vzipv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vzipv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vzipv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vzipv2si (rtx, rtx, rtx); +extern rtx gen_neon_vzipv4si (rtx, rtx, rtx); +extern rtx gen_neon_vzipv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vzipv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv8qi (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv16qi (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv4hi (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv8hi (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv2si (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv4si (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv2sf (rtx, rtx, rtx); +extern rtx gen_neon_vuzpv4sf (rtx, rtx, rtx); +extern rtx gen_neon_vreinterpretv8qiv8qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv8qiv4hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv8qiv2si (rtx, rtx); +extern rtx gen_neon_vreinterpretv8qiv2sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv8qidi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4hiv8qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4hiv4hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4hiv2si (rtx, rtx); +extern rtx gen_neon_vreinterpretv4hiv2sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv4hidi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2siv8qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2siv4hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2siv2si (rtx, rtx); +extern rtx gen_neon_vreinterpretv2siv2sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv2sidi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2sfv8qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2sfv4hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2sfv2si (rtx, rtx); +extern rtx gen_neon_vreinterpretv2sfv2sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv2sfdi (rtx, rtx); +extern rtx gen_neon_vreinterpretdiv8qi (rtx, rtx); +extern rtx gen_neon_vreinterpretdiv4hi (rtx, rtx); +extern rtx gen_neon_vreinterpretdiv2si (rtx, rtx); +extern rtx gen_neon_vreinterpretdiv2sf (rtx, rtx); +extern rtx gen_neon_vreinterpretdidi (rtx, rtx); +extern rtx gen_neon_vreinterpretv16qiv16qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv16qiv8hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv16qiv4si (rtx, rtx); +extern rtx gen_neon_vreinterpretv16qiv4sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv16qiv2di (rtx, rtx); +extern rtx gen_neon_vreinterpretv8hiv16qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv8hiv8hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv8hiv4si (rtx, rtx); +extern rtx gen_neon_vreinterpretv8hiv4sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv8hiv2di (rtx, rtx); +extern rtx gen_neon_vreinterpretv4siv16qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4siv8hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4siv4si (rtx, rtx); +extern rtx gen_neon_vreinterpretv4siv4sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv4siv2di (rtx, rtx); +extern rtx gen_neon_vreinterpretv4sfv16qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4sfv8hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv4sfv4si (rtx, rtx); +extern rtx gen_neon_vreinterpretv4sfv4sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv4sfv2di (rtx, rtx); +extern rtx gen_neon_vreinterpretv2div16qi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2div8hi (rtx, rtx); +extern rtx gen_neon_vreinterpretv2div4si (rtx, rtx); +extern rtx gen_neon_vreinterpretv2div4sf (rtx, rtx); +extern rtx gen_neon_vreinterpretv2div2di (rtx, rtx); +extern rtx gen_neon_vld3v16qi (rtx, rtx); +extern rtx gen_neon_vld3v8hi (rtx, rtx); +extern rtx gen_neon_vld3v4si (rtx, rtx); +extern rtx gen_neon_vld3v4sf (rtx, rtx); +extern rtx gen_neon_vst3v16qi (rtx, rtx); +extern rtx gen_neon_vst3v8hi (rtx, rtx); +extern rtx gen_neon_vst3v4si (rtx, rtx); +extern rtx gen_neon_vst3v4sf (rtx, rtx); +extern rtx gen_neon_vld4v16qi (rtx, rtx); +extern rtx gen_neon_vld4v8hi (rtx, rtx); +extern rtx gen_neon_vld4v4si (rtx, rtx); +extern rtx gen_neon_vld4v4sf (rtx, rtx); +extern rtx gen_neon_vst4v16qi (rtx, rtx); +extern rtx gen_neon_vst4v8hi (rtx, rtx); +extern rtx gen_neon_vst4v4si (rtx, rtx); +extern rtx gen_neon_vst4v4sf (rtx, rtx); +extern rtx gen_neon_vandv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vanddi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vandv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrdi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorrv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veordi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_veorv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicdi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vbicv2di (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv8qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv16qi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv4hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv8hi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv2si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv4si (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv2sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv4sf (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vorndi (rtx, rtx, rtx, rtx); +extern rtx gen_neon_vornv2di (rtx, rtx, rtx, rtx); +extern rtx gen_vec_unpacks_hi_v16qi (rtx, rtx); +extern rtx gen_vec_unpacku_hi_v16qi (rtx, rtx); +extern rtx gen_vec_unpacks_hi_v8hi (rtx, rtx); +extern rtx gen_vec_unpacku_hi_v8hi (rtx, rtx); +extern rtx gen_vec_unpacks_hi_v4si (rtx, rtx); +extern rtx gen_vec_unpacku_hi_v4si (rtx, rtx); +extern rtx gen_vec_unpacks_lo_v16qi (rtx, rtx); +extern rtx gen_vec_unpacku_lo_v16qi (rtx, rtx); +extern rtx gen_vec_unpacks_lo_v8hi (rtx, rtx); +extern rtx gen_vec_unpacku_lo_v8hi (rtx, rtx); +extern rtx gen_vec_unpacks_lo_v4si (rtx, rtx); +extern rtx gen_vec_unpacku_lo_v4si (rtx, rtx); +extern rtx gen_vec_widen_smult_lo_v16qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_lo_v16qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_lo_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_lo_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_lo_v4si (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_lo_v4si (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_hi_v16qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_hi_v16qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_hi_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_hi_v8hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_hi_v4si (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_hi_v4si (rtx, rtx, rtx); +extern rtx gen_vec_unpacks_lo_v8qi (rtx, rtx); +extern rtx gen_vec_unpacku_lo_v8qi (rtx, rtx); +extern rtx gen_vec_unpacks_lo_v4hi (rtx, rtx); +extern rtx gen_vec_unpacku_lo_v4hi (rtx, rtx); +extern rtx gen_vec_unpacks_lo_v2si (rtx, rtx); +extern rtx gen_vec_unpacku_lo_v2si (rtx, rtx); +extern rtx gen_vec_unpacks_hi_v8qi (rtx, rtx); +extern rtx gen_vec_unpacku_hi_v8qi (rtx, rtx); +extern rtx gen_vec_unpacks_hi_v4hi (rtx, rtx); +extern rtx gen_vec_unpacku_hi_v4hi (rtx, rtx); +extern rtx gen_vec_unpacks_hi_v2si (rtx, rtx); +extern rtx gen_vec_unpacku_hi_v2si (rtx, rtx); +extern rtx gen_vec_widen_smult_hi_v8qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_hi_v8qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_hi_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_hi_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_hi_v2si (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_hi_v2si (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_lo_v8qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_lo_v8qi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_lo_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_lo_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_widen_smult_lo_v2si (rtx, rtx, rtx); +extern rtx gen_vec_widen_umult_lo_v2si (rtx, rtx, rtx); +extern rtx gen_vec_pack_trunc_v4hi (rtx, rtx, rtx); +extern rtx gen_vec_pack_trunc_v2si (rtx, rtx, rtx); +extern rtx gen_vec_pack_trunc_di (rtx, rtx, rtx); +extern rtx gen_memory_barrier (void); +extern rtx gen_sync_compare_and_swapsi (rtx, rtx, rtx, rtx); +extern rtx gen_sync_compare_and_swapqi (rtx, rtx, rtx, rtx); +extern rtx gen_sync_compare_and_swaphi (rtx, rtx, rtx, rtx); +extern rtx gen_sync_lock_test_and_setsi (rtx, rtx, rtx); +extern rtx gen_sync_lock_test_and_setqi (rtx, rtx, rtx); +extern rtx gen_sync_lock_test_and_sethi (rtx, rtx, rtx); +extern rtx gen_sync_addsi (rtx, rtx); +extern rtx gen_sync_subsi (rtx, rtx); +extern rtx gen_sync_iorsi (rtx, rtx); +extern rtx gen_sync_xorsi (rtx, rtx); +extern rtx gen_sync_andsi (rtx, rtx); +extern rtx gen_sync_nandsi (rtx, rtx); +extern rtx gen_sync_addqi (rtx, rtx); +extern rtx gen_sync_subqi (rtx, rtx); +extern rtx gen_sync_iorqi (rtx, rtx); +extern rtx gen_sync_xorqi (rtx, rtx); +extern rtx gen_sync_andqi (rtx, rtx); +extern rtx gen_sync_addhi (rtx, rtx); +extern rtx gen_sync_subhi (rtx, rtx); +extern rtx gen_sync_iorhi (rtx, rtx); +extern rtx gen_sync_xorhi (rtx, rtx); +extern rtx gen_sync_andhi (rtx, rtx); +extern rtx gen_sync_nandqi (rtx, rtx); +extern rtx gen_sync_nandhi (rtx, rtx); +extern rtx gen_sync_new_addsi (rtx, rtx, rtx); +extern rtx gen_sync_new_subsi (rtx, rtx, rtx); +extern rtx gen_sync_new_iorsi (rtx, rtx, rtx); +extern rtx gen_sync_new_xorsi (rtx, rtx, rtx); +extern rtx gen_sync_new_andsi (rtx, rtx, rtx); +extern rtx gen_sync_new_nandsi (rtx, rtx, rtx); +extern rtx gen_sync_new_addqi (rtx, rtx, rtx); +extern rtx gen_sync_new_subqi (rtx, rtx, rtx); +extern rtx gen_sync_new_iorqi (rtx, rtx, rtx); +extern rtx gen_sync_new_xorqi (rtx, rtx, rtx); +extern rtx gen_sync_new_andqi (rtx, rtx, rtx); +extern rtx gen_sync_new_addhi (rtx, rtx, rtx); +extern rtx gen_sync_new_subhi (rtx, rtx, rtx); +extern rtx gen_sync_new_iorhi (rtx, rtx, rtx); +extern rtx gen_sync_new_xorhi (rtx, rtx, rtx); +extern rtx gen_sync_new_andhi (rtx, rtx, rtx); +extern rtx gen_sync_new_nandqi (rtx, rtx, rtx); +extern rtx gen_sync_new_nandhi (rtx, rtx, rtx); +extern rtx gen_sync_old_addsi (rtx, rtx, rtx); +extern rtx gen_sync_old_subsi (rtx, rtx, rtx); +extern rtx gen_sync_old_iorsi (rtx, rtx, rtx); +extern rtx gen_sync_old_xorsi (rtx, rtx, rtx); +extern rtx gen_sync_old_andsi (rtx, rtx, rtx); +extern rtx gen_sync_old_nandsi (rtx, rtx, rtx); +extern rtx gen_sync_old_addqi (rtx, rtx, rtx); +extern rtx gen_sync_old_subqi (rtx, rtx, rtx); +extern rtx gen_sync_old_iorqi (rtx, rtx, rtx); +extern rtx gen_sync_old_xorqi (rtx, rtx, rtx); +extern rtx gen_sync_old_andqi (rtx, rtx, rtx); +extern rtx gen_sync_old_addhi (rtx, rtx, rtx); +extern rtx gen_sync_old_subhi (rtx, rtx, rtx); +extern rtx gen_sync_old_iorhi (rtx, rtx, rtx); +extern rtx gen_sync_old_xorhi (rtx, rtx, rtx); +extern rtx gen_sync_old_andhi (rtx, rtx, rtx); +extern rtx gen_sync_old_nandqi (rtx, rtx, rtx); +extern rtx gen_sync_old_nandhi (rtx, rtx, rtx); + +#endif /* GCC_INSN_FLAGS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-modes.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-modes.h new file mode 100644 index 0000000..d056c28 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-modes.h @@ -0,0 +1,157 @@ +/* Generated automatically from machmode.def and config/arm/arm-modes.def + by genmodes. */ + +#ifndef GCC_INSN_MODES_H +#define GCC_INSN_MODES_H + +enum machine_mode +{ + VOIDmode, /* machmode.def:173 */ + BLKmode, /* machmode.def:177 */ + CCmode, /* machmode.def:205 */ + CC_NOOVmode, /* config/arm/arm-modes.def:46 */ + CC_Zmode, /* config/arm/arm-modes.def:47 */ + CC_CZmode, /* config/arm/arm-modes.def:48 */ + CC_NCVmode, /* config/arm/arm-modes.def:49 */ + CC_SWPmode, /* config/arm/arm-modes.def:50 */ + CCFPmode, /* config/arm/arm-modes.def:51 */ + CCFPEmode, /* config/arm/arm-modes.def:52 */ + CC_DNEmode, /* config/arm/arm-modes.def:53 */ + CC_DEQmode, /* config/arm/arm-modes.def:54 */ + CC_DLEmode, /* config/arm/arm-modes.def:55 */ + CC_DLTmode, /* config/arm/arm-modes.def:56 */ + CC_DGEmode, /* config/arm/arm-modes.def:57 */ + CC_DGTmode, /* config/arm/arm-modes.def:58 */ + CC_DLEUmode, /* config/arm/arm-modes.def:59 */ + CC_DLTUmode, /* config/arm/arm-modes.def:60 */ + CC_DGEUmode, /* config/arm/arm-modes.def:61 */ + CC_DGTUmode, /* config/arm/arm-modes.def:62 */ + CC_Cmode, /* config/arm/arm-modes.def:63 */ + CC_Nmode, /* config/arm/arm-modes.def:64 */ + BImode, /* machmode.def:180 */ + QImode, /* machmode.def:185 */ + HImode, /* machmode.def:186 */ + SImode, /* machmode.def:187 */ + DImode, /* machmode.def:188 */ + TImode, /* machmode.def:189 */ + EImode, /* config/arm/arm-modes.def:75 */ + OImode, /* config/arm/arm-modes.def:76 */ + CImode, /* config/arm/arm-modes.def:77 */ + XImode, /* config/arm/arm-modes.def:78 */ + QQmode, /* machmode.def:208 */ + HQmode, /* machmode.def:209 */ + SQmode, /* machmode.def:210 */ + DQmode, /* machmode.def:211 */ + TQmode, /* machmode.def:212 */ + UQQmode, /* machmode.def:214 */ + UHQmode, /* machmode.def:215 */ + USQmode, /* machmode.def:216 */ + UDQmode, /* machmode.def:217 */ + UTQmode, /* machmode.def:218 */ + HAmode, /* machmode.def:220 */ + SAmode, /* machmode.def:221 */ + DAmode, /* machmode.def:222 */ + TAmode, /* machmode.def:223 */ + UHAmode, /* machmode.def:225 */ + USAmode, /* machmode.def:226 */ + UDAmode, /* machmode.def:227 */ + UTAmode, /* machmode.def:228 */ + HFmode, /* config/arm/arm-modes.def:29 */ + SFmode, /* machmode.def:200 */ + DFmode, /* machmode.def:201 */ + XFmode, /* config/arm/arm-modes.def:26 */ + SDmode, /* machmode.def:240 */ + DDmode, /* machmode.def:241 */ + TDmode, /* machmode.def:242 */ + CQImode, /* machmode.def:236 */ + CHImode, /* machmode.def:236 */ + CSImode, /* machmode.def:236 */ + CDImode, /* machmode.def:236 */ + CTImode, /* machmode.def:236 */ + CEImode, /* machmode.def:236 */ + COImode, /* machmode.def:236 */ + CCImode, /* machmode.def:236 */ + CXImode, /* machmode.def:236 */ + HCmode, /* machmode.def:237 */ + SCmode, /* machmode.def:237 */ + DCmode, /* machmode.def:237 */ + XCmode, /* machmode.def:237 */ + V4QImode, /* config/arm/arm-modes.def:67 */ + V2HImode, /* config/arm/arm-modes.def:67 */ + V8QImode, /* config/arm/arm-modes.def:68 */ + V4HImode, /* config/arm/arm-modes.def:68 */ + V2SImode, /* config/arm/arm-modes.def:68 */ + V16QImode, /* config/arm/arm-modes.def:69 */ + V8HImode, /* config/arm/arm-modes.def:69 */ + V4SImode, /* config/arm/arm-modes.def:69 */ + V2DImode, /* config/arm/arm-modes.def:69 */ + V4HFmode, /* config/arm/arm-modes.def:70 */ + V2SFmode, /* config/arm/arm-modes.def:70 */ + V8HFmode, /* config/arm/arm-modes.def:71 */ + V4SFmode, /* config/arm/arm-modes.def:71 */ + V2DFmode, /* config/arm/arm-modes.def:71 */ + MAX_MACHINE_MODE, + + MIN_MODE_RANDOM = VOIDmode, + MAX_MODE_RANDOM = BLKmode, + + MIN_MODE_CC = CCmode, + MAX_MODE_CC = CC_Nmode, + + MIN_MODE_INT = QImode, + MAX_MODE_INT = XImode, + + MIN_MODE_PARTIAL_INT = VOIDmode, + MAX_MODE_PARTIAL_INT = VOIDmode, + + MIN_MODE_FRACT = QQmode, + MAX_MODE_FRACT = TQmode, + + MIN_MODE_UFRACT = UQQmode, + MAX_MODE_UFRACT = UTQmode, + + MIN_MODE_ACCUM = HAmode, + MAX_MODE_ACCUM = TAmode, + + MIN_MODE_UACCUM = UHAmode, + MAX_MODE_UACCUM = UTAmode, + + MIN_MODE_FLOAT = HFmode, + MAX_MODE_FLOAT = XFmode, + + MIN_MODE_DECIMAL_FLOAT = SDmode, + MAX_MODE_DECIMAL_FLOAT = TDmode, + + MIN_MODE_COMPLEX_INT = CQImode, + MAX_MODE_COMPLEX_INT = CXImode, + + MIN_MODE_COMPLEX_FLOAT = HCmode, + MAX_MODE_COMPLEX_FLOAT = XCmode, + + MIN_MODE_VECTOR_INT = V4QImode, + MAX_MODE_VECTOR_INT = V2DImode, + + MIN_MODE_VECTOR_FRACT = VOIDmode, + MAX_MODE_VECTOR_FRACT = VOIDmode, + + MIN_MODE_VECTOR_UFRACT = VOIDmode, + MAX_MODE_VECTOR_UFRACT = VOIDmode, + + MIN_MODE_VECTOR_ACCUM = VOIDmode, + MAX_MODE_VECTOR_ACCUM = VOIDmode, + + MIN_MODE_VECTOR_UACCUM = VOIDmode, + MAX_MODE_VECTOR_UACCUM = VOIDmode, + + MIN_MODE_VECTOR_FLOAT = V4HFmode, + MAX_MODE_VECTOR_FLOAT = V2DFmode, + + NUM_MACHINE_MODES = MAX_MACHINE_MODE +}; + +#define CONST_MODE_SIZE const +#define CONST_MODE_BASE_ALIGN const +#define CONST_MODE_IBIT const +#define CONST_MODE_FBIT const + +#endif /* insn-modes.h */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-notes.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-notes.def new file mode 100644 index 0000000..83161ec --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/insn-notes.def @@ -0,0 +1,77 @@ +/* Insn note definitions. + Copyright (C) 2004, 2005, 2007 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/>. */ + +/* This file defines all the codes that may appear in the + NOTE_LINE_NUMBER field of a NOTE insn for kinds of notes that are + not line numbers. Source files define DEF_INSN_NOTE appropriately + before including this file. + + We are slowly removing the concept of insn-chain notes from the + compiler. Adding new codes to this file is STRONGLY DISCOURAGED. + If you think you need one, look for other ways to express what you + mean, such as register notes or bits in the basic-block structure. */ + +/* Shorthand. */ +#define INSN_NOTE(NAME) DEF_INSN_NOTE (NOTE_INSN_##NAME) + +/* This note is used to get rid of an insn when it isn't safe to patch + the insn out of the chain. */ +INSN_NOTE (DELETED) + +/* Generated in place of user-declared labels when they are deleted. */ +INSN_NOTE (DELETED_LABEL) + +/* These are used to mark the beginning and end of a lexical block. + See NOTE_BLOCK and reorder_blocks. */ +INSN_NOTE (BLOCK_BEG) +INSN_NOTE (BLOCK_END) + +/* This note indicates the start of the real body of the function, + i.e. the point just after all of the parms have been moved into + their homes, etc. */ +INSN_NOTE (FUNCTION_BEG) + +/* This marks the point immediately after the last prologue insn. */ +INSN_NOTE (PROLOGUE_END) + +/* This marks the point immediately prior to the first epilogue insn. */ +INSN_NOTE (EPILOGUE_BEG) + +/* These note where exception handling regions begin and end. + Uses NOTE_EH_HANDLER to identify the region in question. */ +INSN_NOTE (EH_REGION_BEG) +INSN_NOTE (EH_REGION_END) + +/* The location of a variable. */ +INSN_NOTE (VAR_LOCATION) + +/* Record the struct for the following basic block. Uses + NOTE_BASIC_BLOCK. FIXME: Redundant with the basic block pointer + now included in every insn. */ +INSN_NOTE (BASIC_BLOCK) + +/* Mark the inflection point in the instruction stream where we switch + between hot and cold text sections. */ +INSN_NOTE (SWITCH_TEXT_SECTIONS) + +/* Mark the restore point after an epilogue changed CFI data. Used only + when an epilogue appears in the middle of a function. */ +INSN_NOTE (CFA_RESTORE_STATE) + +#undef INSN_NOTE diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/intl.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/intl.h new file mode 100644 index 0000000..c4db354 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/intl.h @@ -0,0 +1,70 @@ +/* intl.h - internationalization + Copyright 1998, 2001, 2003, 2004, 2007, 2009, 2010 + 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. + + 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/>. */ + +#ifndef GCC_INTL_H +#define GCC_INTL_H + +#ifdef HAVE_LOCALE_H +# include <locale.h> +#endif + +#ifndef HAVE_SETLOCALE +# define setlocale(category, locale) (locale) +#endif + +#ifdef ENABLE_NLS +#include <libintl.h> +extern void gcc_init_libintl (void); +extern size_t gcc_gettext_width (const char *); +#else +/* Stubs. */ +# undef textdomain +# define textdomain(domain) (domain) +# undef bindtextdomain +# define bindtextdomain(domain, directory) (domain) +# undef gettext +# define gettext(msgid) (msgid) +# define ngettext(singular,plural,n) fake_ngettext(singular,plural,n) +# define gcc_init_libintl() /* nothing */ +# define gcc_gettext_width(s) strlen(s) + +extern const char *fake_ngettext(const char *singular,const char *plural, + unsigned long int n); + +#endif + +#ifndef _ +# define _(msgid) gettext (msgid) +#endif + +#ifndef N_ +# define N_(msgid) msgid +#endif + +#ifndef G_ +# define G_(gmsgid) gmsgid +#endif + +extern char *get_spaces (const char *); + +extern const char *open_quote; +extern const char *close_quote; +extern const char *locale_encoding; +extern bool locale_utf8; + +#endif /* intl.h */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-prop.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-prop.h new file mode 100644 index 0000000..9244d5a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-prop.h @@ -0,0 +1,523 @@ +/* Interprocedural analyses. + Copyright (C) 2005, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef IPA_PROP_H +#define IPA_PROP_H + +#include "tree.h" +#include "vec.h" +#include "cgraph.h" +#include "gimple.h" + +/* The following definitions and interfaces are used by + interprocedural analyses or parameters. */ + +/* ipa-prop.c stuff (ipa-cp, indirect inlining): */ + +/* A jump function for a callsite represents the values passed as actual + arguments of the callsite. There are three main types of values : + + Pass-through - the caller's formal parameter is passed as an actual + argument, possibly one simple operation performed on it. + Constant - a constant (is_gimple_ip_invariant)is passed as an actual + argument. + Unknown - neither of the above. + + IPA_JF_CONST_MEMBER_PTR stands for C++ member pointers, it is a special + constant in this regard. Other constants are represented with IPA_JF_CONST. + + IPA_JF_ANCESTOR is a special pass-through jump function, which means that + the result is an address of a part of the object pointed to by the formal + parameter to which the function refers. It is mainly intended to represent + getting addresses of of ancestor fields in C++ + (e.g. &this_1(D)->D.1766.D.1756). Note that if the original pointer is + NULL, ancestor jump function must behave like a simple pass-through. + + Other pass-through functions can either simply pass on an unchanged formal + parameter or can apply one simple binary operation to it (such jump + functions are called polynomial). + + IPA_JF_KNOWN_TYPE is a special type of an "unknown" function that applies + only to pointer parameters. It means that even though we cannot prove that + the passed value is an interprocedural constant, we still know the exact + type of the containing object which may be valuable for devirtualization. + + Jump functions are computed in ipa-prop.c by function + update_call_notes_after_inlining. Some information can be lost and jump + functions degraded accordingly when inlining, see + update_call_notes_after_inlining in the same file. */ + +enum jump_func_type +{ + IPA_JF_UNKNOWN = 0, /* newly allocated and zeroed jump functions default */ + IPA_JF_KNOWN_TYPE, /* represented by field base_binfo */ + IPA_JF_CONST, /* represented by field costant */ + IPA_JF_CONST_MEMBER_PTR, /* represented by field member_cst */ + IPA_JF_PASS_THROUGH, /* represented by field pass_through */ + IPA_JF_ANCESTOR /* represented by field ancestor */ +}; + +/* Structure holding data required to describe a pass-through jump function. */ + +struct GTY(()) ipa_pass_through_data +{ + /* If an operation is to be performed on the original parameter, this is the + second (constant) operand. */ + tree operand; + /* Number of the caller's formal parameter being passed. */ + int formal_id; + /* Operation that is performed on the argument before it is passed on. + NOP_EXPR means no operation. Otherwise oper must be a simple binary + arithmetic operation where the caller's parameter is the first operand and + operand field from this structure is the second one. */ + enum tree_code operation; +}; + +/* Structure holding data required to describe an ancestor pass-through + jump function. */ + +struct GTY(()) ipa_ancestor_jf_data +{ + /* Offset of the field representing the ancestor. */ + HOST_WIDE_INT offset; + /* TYpe of the result. */ + tree type; + /* Number of the caller's formal parameter being passed. */ + int formal_id; +}; + +/* Structure holding a C++ member pointer constant. Holds a pointer to the + method and delta offset. */ +struct GTY(()) ipa_member_ptr_cst +{ + tree pfn; + tree delta; +}; + +/* A jump function for a callsite represents the values passed as actual + arguments of the callsite. See enum jump_func_type for the various + types of jump functions supported. */ +struct GTY (()) ipa_jump_func +{ + enum jump_func_type type; + /* Represents a value of a jump function. pass_through is used only in jump + function context. constant represents the actual constant in constant jump + functions and member_cst holds constant c++ member functions. */ + union jump_func_value + { + tree GTY ((tag ("IPA_JF_KNOWN_TYPE"))) base_binfo; + tree GTY ((tag ("IPA_JF_CONST"))) constant; + struct ipa_member_ptr_cst GTY ((tag ("IPA_JF_CONST_MEMBER_PTR"))) member_cst; + struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through; + struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor; + } GTY ((desc ("%1.type"))) value; +}; + +/* All formal parameters in the program have a lattice associated with it + computed by the interprocedural stage of IPCP. + There are three main values of the lattice: + IPA_TOP - unknown, + IPA_BOTTOM - variable, + IPA_CONST_VALUE - simple scalar constant, + + We also use this type to propagate types accross the call graph for the + purpose of devirtualization. In that case, IPA_CONST_VALUE denotes a known + type, rather than a constant. */ +enum ipa_lattice_type +{ + IPA_BOTTOM, + IPA_CONST_VALUE, + IPA_TOP +}; + +/* All formal parameters in the program have a cval computed by + the interprocedural stage of IPCP. See enum ipa_lattice_type for + the various types of lattices supported */ +struct ipcp_lattice +{ + enum ipa_lattice_type type; + tree constant; +}; + +/* Structure describing a single formal parameter. */ +struct ipa_param_descriptor +{ + /* IPA-CP lattice. */ + struct ipcp_lattice ipcp_lattice; + /* PARAM_DECL of this parameter. */ + tree decl; + /* Vector of BINFOs of types that this argument might encounter. NULL + basically means a top value, bottom is marked by the cannot_devirtualize + flag below.*/ + VEC (tree, heap) *types; + /* The parameter is used. */ + unsigned used : 1; + /* Set when parameter type cannot be used for devirtualization. */ + unsigned cannot_devirtualize : 1; +}; + +/* ipa_node_params stores information related to formal parameters of functions + and some other information for interprocedural passes that operate on + parameters (such as ipa-cp). */ +struct ipa_node_params +{ + /* Number of formal parameters of this function. When set to 0, this + function's parameters would not be analyzed by IPA CP. */ + int param_count; + /* Whether this function is called with variable number of actual + arguments. */ + unsigned called_with_var_arguments : 1; + /* Whether the param uses analysis has already been performed. */ + unsigned uses_analysis_done : 1; + /* Whether the function is enqueued in an ipa_func_list. */ + unsigned node_enqueued : 1; + /* Pointer to an array of structures describing individual formal + parameters. */ + struct ipa_param_descriptor *params; + /* Only for versioned nodes this field would not be NULL, + it points to the node that IPA cp cloned from. */ + struct cgraph_node *ipcp_orig_node; + /* Meaningful only for original functions. Expresses the + ratio between the direct calls and sum of all invocations of + this function (given by profiling info). It is used to calculate + the profiling information of the original function and the versioned + one. */ + gcov_type count_scale; +}; + +/* ipa_node_params access functions. Please use these to access fields that + are or will be shared among various passes. */ + +/* Set the number of formal parameters. */ + +static inline void +ipa_set_param_count (struct ipa_node_params *info, int count) +{ + info->param_count = count; +} + +/* Return the number of formal parameters. */ + +static inline int +ipa_get_param_count (struct ipa_node_params *info) +{ + return info->param_count; +} + +/* Return the declaration of Ith formal parameter of the function corresponding + to INFO. Note there is no setter function as this array is built just once + using ipa_initialize_node_params. */ + +static inline tree +ipa_get_param (struct ipa_node_params *info, int i) +{ + return info->params[i].decl; +} + +/* Return the used flag corresponding to the Ith formal parameter of + the function associated with INFO. */ + +static inline bool +ipa_is_param_used (struct ipa_node_params *info, int i) +{ + return info->params[i].used; +} + +/* Return the cannot_devirtualize flag corresponding to the Ith formal + parameter of the function associated with INFO. The corresponding function + to set the flag is ipa_set_param_cannot_devirtualize. */ + +static inline bool +ipa_param_cannot_devirtualize_p (struct ipa_node_params *info, int i) +{ + return info->params[i].cannot_devirtualize; +} + +/* Return true iff the vector of possible types of the Ith formal parameter of + the function associated with INFO is empty. */ + +static inline bool +ipa_param_types_vec_empty (struct ipa_node_params *info, int i) +{ + return info->params[i].types == NULL; +} + +/* Flag this node as having callers with variable number of arguments. */ + +static inline void +ipa_set_called_with_variable_arg (struct ipa_node_params *info) +{ + info->called_with_var_arguments = 1; +} + +/* Have we detected this node was called with variable number of arguments? */ + +static inline bool +ipa_is_called_with_var_arguments (struct ipa_node_params *info) +{ + return info->called_with_var_arguments; +} + + + +/* ipa_edge_args stores information related to a callsite and particularly its + arguments. It can be accessed by the IPA_EDGE_REF macro. */ +typedef struct GTY(()) ipa_edge_args +{ + /* Number of actual arguments in this callsite. When set to 0, + this callsite's parameters would not be analyzed by the different + stages of IPA CP. */ + int argument_count; + /* Array of the callsite's jump function of each parameter. */ + struct ipa_jump_func GTY ((length ("%h.argument_count"))) *jump_functions; +} ipa_edge_args_t; + +/* ipa_edge_args access functions. Please use these to access fields that + are or will be shared among various passes. */ + +/* Set the number of actual arguments. */ + +static inline void +ipa_set_cs_argument_count (struct ipa_edge_args *args, int count) +{ + args->argument_count = count; +} + +/* Return the number of actual arguments. */ + +static inline int +ipa_get_cs_argument_count (struct ipa_edge_args *args) +{ + return args->argument_count; +} + +/* Returns a pointer to the jump function for the ith argument. Please note + there is no setter function as jump functions are all set up in + ipa_compute_jump_functions. */ + +static inline struct ipa_jump_func * +ipa_get_ith_jump_func (struct ipa_edge_args *args, int i) +{ + return &args->jump_functions[i]; +} + +/* Vectors need to have typedefs of structures. */ +typedef struct ipa_node_params ipa_node_params_t; + +/* Types of vectors holding the infos. */ +DEF_VEC_O (ipa_node_params_t); +DEF_VEC_ALLOC_O (ipa_node_params_t, heap); +DEF_VEC_O (ipa_edge_args_t); +DEF_VEC_ALLOC_O (ipa_edge_args_t, gc); + +/* Vector where the parameter infos are actually stored. */ +extern VEC (ipa_node_params_t, heap) *ipa_node_params_vector; +/* Vector where the parameter infos are actually stored. */ +extern GTY(()) VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector; + +/* Return the associated parameter/argument info corresponding to the given + node/edge. */ +#define IPA_NODE_REF(NODE) (VEC_index (ipa_node_params_t, \ + ipa_node_params_vector, (NODE)->uid)) +#define IPA_EDGE_REF(EDGE) (VEC_index (ipa_edge_args_t, \ + ipa_edge_args_vector, (EDGE)->uid)) +/* This macro checks validity of index returned by + ipa_get_param_decl_index function. */ +#define IS_VALID_JUMP_FUNC_INDEX(I) ((I) != -1) + +/* Creating and freeing ipa_node_params and ipa_edge_args. */ +void ipa_create_all_node_params (void); +void ipa_create_all_edge_args (void); +void ipa_free_edge_args_substructures (struct ipa_edge_args *); +void ipa_free_node_params_substructures (struct ipa_node_params *); +void ipa_free_all_node_params (void); +void ipa_free_all_edge_args (void); +void ipa_create_all_structures_for_iinln (void); +void ipa_free_all_structures_after_ipa_cp (void); +void ipa_free_all_structures_after_iinln (void); +void ipa_register_cgraph_hooks (void); + +/* This function ensures the array of node param infos is big enough to + accommodate a structure for all nodes and reallocates it if not. */ + +static inline void +ipa_check_create_node_params (void) +{ + if (!ipa_node_params_vector) + ipa_node_params_vector = VEC_alloc (ipa_node_params_t, heap, + cgraph_max_uid); + + if (VEC_length (ipa_node_params_t, ipa_node_params_vector) + <= (unsigned) cgraph_max_uid) + VEC_safe_grow_cleared (ipa_node_params_t, heap, + ipa_node_params_vector, cgraph_max_uid + 1); +} + +/* This function ensures the array of edge arguments infos is big enough to + accommodate a structure for all edges and reallocates it if not. */ + +static inline void +ipa_check_create_edge_args (void) +{ + if (!ipa_edge_args_vector) + ipa_edge_args_vector = VEC_alloc (ipa_edge_args_t, gc, + cgraph_edge_max_uid); + + if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector) + <= (unsigned) cgraph_edge_max_uid) + VEC_safe_grow_cleared (ipa_edge_args_t, gc, ipa_edge_args_vector, + cgraph_edge_max_uid + 1); +} + +/* Returns true if the array of edge infos is large enough to accommodate an + info for EDGE. The main purpose of this function is that debug dumping + function can check info availability without causing reallocations. */ + +static inline bool +ipa_edge_args_info_available_for_edge_p (struct cgraph_edge *edge) +{ + return ((unsigned) edge->uid < VEC_length (ipa_edge_args_t, + ipa_edge_args_vector)); +} + +/* A function list element. It is used to create a temporary worklist used in + the propagation stage of IPCP. (can be used for more IPA optimizations) */ +struct ipa_func_list +{ + struct cgraph_node *node; + struct ipa_func_list *next; +}; + +/* ipa_func_list interface. */ +struct ipa_func_list *ipa_init_func_list (void); +void ipa_push_func_to_list_1 (struct ipa_func_list **, struct cgraph_node *, + struct ipa_node_params *); +struct cgraph_node *ipa_pop_func_from_list (struct ipa_func_list **); + +/* Add cgraph NODE to the worklist WL if it is not already in one. */ + +static inline void +ipa_push_func_to_list (struct ipa_func_list **wl, struct cgraph_node *node) +{ + struct ipa_node_params *info = IPA_NODE_REF (node); + + if (!info->node_enqueued) + ipa_push_func_to_list_1 (wl, node, info); +} + +void ipa_analyze_node (struct cgraph_node *); + +/* Function formal parameters related computations. */ +void ipa_initialize_node_params (struct cgraph_node *node); +bool ipa_propagate_indirect_call_infos (struct cgraph_edge *cs, + VEC (cgraph_edge_p, heap) **new_edges); + +/* Indirect edge and binfo processing. */ +struct cgraph_edge *ipa_make_edge_direct_to_target (struct cgraph_edge *, tree, + tree); + + +/* Debugging interface. */ +void ipa_print_node_params (FILE *, struct cgraph_node *node); +void ipa_print_all_params (FILE *); +void ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node); +void ipa_print_all_jump_functions (FILE * f); + +/* Structure to describe transformations of formal parameters and actual + arguments. Each instance describes one new parameter and they are meant to + be stored in a vector. Additionally, most users will probably want to store + adjustments about parameters that are being removed altogether so that SSA + names belonging to them can be replaced by SSA names of an artificial + variable. */ +struct ipa_parm_adjustment +{ + /* The original PARM_DECL itself, helpful for processing of the body of the + function itself. Intended for traversing function bodies. + ipa_modify_formal_parameters, ipa_modify_call_arguments and + ipa_combine_adjustments ignore this and use base_index. + ipa_modify_formal_parameters actually sets this. */ + tree base; + + /* Type of the new parameter. However, if by_ref is true, the real type will + be a pointer to this type. */ + tree type; + + /* Alias refrerence type to be used in MEM_REFs when adjusting caller + arguments. */ + tree alias_ptr_type; + + /* The new declaration when creating/replacing a parameter. Created by + ipa_modify_formal_parameters, useful for functions modifying the body + accordingly. */ + tree reduction; + + /* New declaration of a substitute variable that we may use to replace all + non-default-def ssa names when a parm decl is going away. */ + tree new_ssa_base; + + /* If non-NULL and the original parameter is to be removed (copy_param below + is NULL), this is going to be its nonlocalized vars value. */ + tree nonlocal_value; + + /* Offset into the original parameter (for the cases when the new parameter + is a component of an original one). */ + HOST_WIDE_INT offset; + + /* Zero based index of the original parameter this one is based on. (ATM + there is no way to insert a new parameter out of the blue because there is + no need but if it arises the code can be easily exteded to do so.) */ + int base_index; + + /* This new parameter is an unmodified parameter at index base_index. */ + unsigned copy_param : 1; + + /* This adjustment describes a parameter that is about to be removed + completely. Most users will probably need to book keep those so that they + don't leave behinfd any non default def ssa names belonging to them. */ + unsigned remove_param : 1; + + /* The parameter is to be passed by reference. */ + unsigned by_ref : 1; +}; + +typedef struct ipa_parm_adjustment ipa_parm_adjustment_t; +DEF_VEC_O (ipa_parm_adjustment_t); +DEF_VEC_ALLOC_O (ipa_parm_adjustment_t, heap); + +typedef VEC (ipa_parm_adjustment_t, heap) *ipa_parm_adjustment_vec; + +VEC(tree, heap) *ipa_get_vector_of_formal_parms (tree fndecl); +void ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec, + const char *); +void ipa_modify_call_arguments (struct cgraph_edge *, gimple, + ipa_parm_adjustment_vec); +ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec, + ipa_parm_adjustment_vec); +void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree); + +void ipa_prop_write_jump_functions (cgraph_node_set set); +void ipa_prop_read_jump_functions (void); +void ipa_update_after_lto_read (void); + +/* From tree-sra.c: */ +tree build_ref_for_offset (location_t, tree, HOST_WIDE_INT, tree, + gimple_stmt_iterator *, bool); + +#endif /* IPA_PROP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-ref-inline.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-ref-inline.h new file mode 100644 index 0000000..6ca9ba0 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-ref-inline.h @@ -0,0 +1,119 @@ +/* IPA reference lists. + Copyright (C) 2010 + Free Software Foundation, Inc. + Contributed by Jan Hubicka + +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/>. */ + +/* Return callgraph node REF is refering. */ +static inline struct cgraph_node * +ipa_ref_node (struct ipa_ref *ref) +{ + gcc_assert (ref->refered_type == IPA_REF_CGRAPH); + return ref->refered.cgraph_node; +} + +/* Return varpool node REF is refering. */ + +static inline struct varpool_node * +ipa_ref_varpool_node (struct ipa_ref *ref) +{ + gcc_assert (ref->refered_type == IPA_REF_VARPOOL); + return ref->refered.varpool_node; +} + +/* Return cgraph node REF is in. */ + +static inline struct cgraph_node * +ipa_ref_refering_node (struct ipa_ref *ref) +{ + gcc_assert (ref->refering_type == IPA_REF_CGRAPH); + return ref->refering.cgraph_node; +} + +/* Return varpool node REF is in. */ + +static inline struct varpool_node * +ipa_ref_refering_varpool_node (struct ipa_ref *ref) +{ + gcc_assert (ref->refering_type == IPA_REF_VARPOOL); + return ref->refering.varpool_node; +} + +/* Return reference list REF is in. */ + +static inline struct ipa_ref_list * +ipa_ref_refering_ref_list (struct ipa_ref *ref) +{ + if (ref->refering_type == IPA_REF_CGRAPH) + return &ipa_ref_refering_node (ref)->ref_list; + else + return &ipa_ref_refering_varpool_node (ref)->ref_list; +} + +/* Return reference list REF is in. */ + +static inline struct ipa_ref_list * +ipa_ref_refered_ref_list (struct ipa_ref *ref) +{ + if (ref->refered_type == IPA_REF_CGRAPH) + return &ipa_ref_node (ref)->ref_list; + else + return &ipa_ref_varpool_node (ref)->ref_list; +} + +/* Return first reference in LIST or NULL if empty. */ + +static inline struct ipa_ref * +ipa_ref_list_first_reference (struct ipa_ref_list *list) +{ + if (!VEC_length (ipa_ref_t, list->references)) + return NULL; + return VEC_index (ipa_ref_t, list->references, 0); +} + +/* Return first refering ref in LIST or NULL if empty. */ + +static inline struct ipa_ref * +ipa_ref_list_first_refering (struct ipa_ref_list *list) +{ + if (!VEC_length (ipa_ref_ptr, list->refering)) + return NULL; + return VEC_index (ipa_ref_ptr, list->refering, 0); +} + +/* Clear reference list. */ + +static inline void +ipa_empty_ref_list (struct ipa_ref_list *list) +{ + list->refering = NULL; + list->references = NULL; +} + +/* Clear reference list. */ + +static inline unsigned int +ipa_ref_list_nreferences (struct ipa_ref_list *list) +{ + return VEC_length (ipa_ref_t, list->references); +} + +#define ipa_ref_list_reference_iterate(L,I,P) \ + VEC_iterate(ipa_ref_t, (L)->references, (I), (P)) +#define ipa_ref_list_refering_iterate(L,I,P) \ + VEC_iterate(ipa_ref_ptr, (L)->refering, (I), (P)) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-ref.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-ref.h new file mode 100644 index 0000000..2be7353 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-ref.h @@ -0,0 +1,92 @@ +/* IPA reference lists. + Copyright (C) 2010 + Free Software Foundation, Inc. + Contributed by Jan Hubicka + +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/>. */ + +struct cgraph_node; +struct varpool_node; + +/* How the reference is done. */ +enum GTY(()) ipa_ref_use +{ + IPA_REF_LOAD, + IPA_REF_STORE, + IPA_REF_ADDR +}; + +/* Type of refering or refered type. */ +enum GTY(()) ipa_ref_type +{ + IPA_REF_CGRAPH, + IPA_REF_VARPOOL +}; + +/* We can have references spanning both callgraph and varpool, + so all pointers needs to be of both types. */ +union GTY(()) ipa_ref_ptr_u +{ + struct cgraph_node * GTY((tag ("IPA_REF_CGRAPH"))) cgraph_node; + struct varpool_node * GTY((tag ("IPA_REF_VARPOOL"))) varpool_node; +}; + +/* Record of reference in callgraph or varpool. */ +struct GTY(()) ipa_ref +{ + union ipa_ref_ptr_u GTY ((desc ("%1.refering_type"))) refering; + union ipa_ref_ptr_u GTY ((desc ("%1.refered_type"))) refered; + gimple stmt; + unsigned int refered_index; + ENUM_BITFIELD (ipa_ref_type) refering_type:1; + ENUM_BITFIELD (ipa_ref_type) refered_type:1; + ENUM_BITFIELD (ipa_ref_use) use:2; +}; + +typedef struct ipa_ref ipa_ref_t; +typedef struct ipa_ref *ipa_ref_ptr; + +DEF_VEC_O(ipa_ref_t); +DEF_VEC_ALLOC_O(ipa_ref_t,gc); +DEF_VEC_P(ipa_ref_ptr); +DEF_VEC_ALLOC_P(ipa_ref_ptr,heap); + +/* List of references. This is stored in both callgraph and varpool nodes. */ +struct GTY(()) ipa_ref_list +{ + /* Store actual references in references vector. */ + VEC(ipa_ref_t,gc) *references; + /* Refering is vector of pointers to references. It must not live in GGC space + or GGC will try to mark middle of references vectors. */ + VEC(ipa_ref_ptr,heap) * GTY((skip)) refering; +}; + +struct ipa_ref * ipa_record_reference (struct cgraph_node *, + struct varpool_node *, + struct cgraph_node *, + struct varpool_node *, + enum ipa_ref_use, gimple); + +void ipa_remove_reference (struct ipa_ref *); +void ipa_remove_all_references (struct ipa_ref_list *); +void ipa_remove_all_refering (struct ipa_ref_list *); +void ipa_dump_references (FILE *, struct ipa_ref_list *); +void ipa_dump_refering (FILE *, struct ipa_ref_list *); +void ipa_clone_references (struct cgraph_node *, struct varpool_node *, struct ipa_ref_list *); +void ipa_clone_refering (struct cgraph_node *, struct varpool_node *, struct ipa_ref_list *); +bool ipa_ref_cannot_lead_to_return (struct ipa_ref *); + diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-reference.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-reference.h new file mode 100644 index 0000000..48ed983 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-reference.h @@ -0,0 +1,32 @@ +/* IPA handling of references. + Copyright (C) 2004, 2005, 2007, 2008, 2010 + Free Software Foundation, Inc. + Contributed by Kenneth Zadeck <zadeck@naturalbridge.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_IPA_REFERENCE_H +#define GCC_IPA_REFERENCE_H +#include "bitmap.h" +#include "tree.h" + +/* In ipa-reference.c */ +bitmap ipa_reference_get_not_read_global (struct cgraph_node *fn); +bitmap ipa_reference_get_not_written_global (struct cgraph_node *fn); + +#endif /* GCC_IPA_REFERENCE_H */ + diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-utils.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-utils.h new file mode 100644 index 0000000..5c797fa --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/ipa-utils.h @@ -0,0 +1,48 @@ +/* Utilities for ipa analysis. + Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc. + Contributed by Kenneth Zadeck <zadeck@naturalbridge.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_IPA_UTILS_H +#define GCC_IPA_UTILS_H +#include "tree.h" +#include "cgraph.h" + +/* Used for parsing attributes of asm code. */ +extern tree memory_identifier_string; +extern tree get_memory_identifier_string (void); + +struct ipa_dfs_info { + int dfn_number; + int low_link; + bool new_node; + bool on_stack; + struct cgraph_node* next_cycle; + PTR aux; +}; + + + +/* In ipa-utils.c */ +void ipa_utils_print_order (FILE*, const char *, struct cgraph_node**, int); +int ipa_utils_reduced_inorder (struct cgraph_node **, bool, bool, + bool (*ignore_edge) (struct cgraph_edge *)); +tree get_base_var (tree); + + +#endif /* GCC_IPA_UTILS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/java/java-tree.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/java/java-tree.def new file mode 100644 index 0000000..e565499 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/java/java-tree.def @@ -0,0 +1,38 @@ +/* This file contains the definitions and documentation for the + extra tree codes used by gcj. + Copyright (C) 1996, 2007 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/>. */ + + +/* Shift right, logical. */ +DEFTREECODE (URSHIFT_EXPR, "urshift_expr", tcc_binary, 2) + +/* Return -1, 0, 1 depending on whether the first argument is + less, equal, or greater to the second argument. */ +DEFTREECODE (COMPARE_EXPR, "compare_expr", tcc_binary, 2) + +/* Same as COMPARE_EXPR, but if either value is NaN, the result is -1. */ +DEFTREECODE (COMPARE_L_EXPR, "compare_l_expr", tcc_binary, 2) +/* Same as COMPARE_EXPR, but if either value is NaN, the result is 1. */ +DEFTREECODE (COMPARE_G_EXPR, "compare_g_expr", tcc_binary, 2) + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/l-ipo.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/l-ipo.h new file mode 100644 index 0000000..d1c3dbf --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/l-ipo.h @@ -0,0 +1,61 @@ +/* Copyright (C) 2009. Free Software Foundation, Inc. + Contributed by Xinliang David Li (davidxl@google.com) and + Raksit Ashok (raksit@google.com) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_L_IPO_H +#define GCC_L_IPO_H + +/* Primary module's id (non-zero). If no module-info was read in, this will + be zero. */ +extern unsigned primary_module_id; + +/* The macro to test if the compilation is in light weight IPO mode. + In this mode, the source module being compiled will be compiled + together with 0 or more auxiliary modules. */ +#define L_IPO_COMP_MODE (primary_module_id != 0) + +/* The macro to test if the current module being parsed is the + primary source module. */ +#define L_IPO_IS_PRIMARY_MODULE (current_module_id == primary_module_id) + +/* The macro to test if the current module being parsed is an + auxiliary source module. */ +#define L_IPO_IS_AUXILIARY_MODULE (L_IPO_COMP_MODE && current_module_id \ + && current_module_id != primary_module_id) + +/* Current module id. */ +extern unsigned current_module_id; +extern struct gcov_module_info **module_infos; +extern int is_last_module (unsigned mod_id); + +extern unsigned num_in_fnames; +extern int at_eof; +extern bool parser_parsing_start; + +void push_module_scope (void); +void pop_module_scope (void); +tree lipo_save_decl (tree src); +void lipo_restore_decl (tree, tree); +void add_decl_to_current_module_scope (tree decl, void *b); +int lipo_cmp_type (tree t1, tree t2); +tree get_type_or_decl_name (tree); +int equivalent_struct_types_for_tbaa (const_tree t1, const_tree t2); +extern void copy_defined_module_set (tree, tree); + +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/langhooks.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/langhooks.h new file mode 100644 index 0000000..0f0957c --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/langhooks.h @@ -0,0 +1,567 @@ +/* The lang_hooks data structure. + Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_LANG_HOOKS_H +#define GCC_LANG_HOOKS_H + +/* This file should be #include-d after tree.h. */ + +struct diagnostic_info; + +struct gimplify_omp_ctx; + +struct array_descr_info; + +/* A print hook for print_tree (). */ +typedef void (*lang_print_tree_hook) (FILE *, tree, int indent); + +enum classify_record + { RECORD_IS_STRUCT, RECORD_IS_CLASS, RECORD_IS_INTERFACE }; + +/* The following hooks are documented in langhooks.c. Must not be + NULL. */ + +struct lang_hooks_for_tree_inlining +{ + bool (*var_mod_type_p) (tree, tree); +}; + +struct lang_hooks_for_callgraph +{ + /* The node passed is a language-specific tree node. If its contents + are relevant to use of other declarations, mark them. */ + tree (*analyze_expr) (tree *, int *); +}; + +/* The following hooks are used by tree-dump.c. */ + +struct lang_hooks_for_tree_dump +{ + /* Dump language-specific parts of tree nodes. Returns nonzero if it + does not want the usual dumping of the second argument. */ + bool (*dump_tree) (void *, tree); + + /* Determine type qualifiers in a language-specific way. */ + int (*type_quals) (const_tree); +}; + +/* Hooks related to types. */ + +struct lang_hooks_for_types +{ + /* Return a new type (with the indicated CODE), doing whatever + language-specific processing is required. */ + tree (*make_type) (enum tree_code); + + /* Return what kind of RECORD_TYPE this is, mainly for purposes of + debug information. If not defined, record types are assumed to + be structures. */ + enum classify_record (*classify_record) (tree); + + /* Given MODE and UNSIGNEDP, return a suitable type-tree with that + mode. */ + tree (*type_for_mode) (enum machine_mode, int); + + /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an + integer type with at least that precision. */ + tree (*type_for_size) (unsigned, int); + + /* True if the type is an instantiation of a generic type, + e.g. C++ template implicit specializations. */ + bool (*generic_p) (const_tree); + + /* Returns the TREE_VEC of elements of a given generic argument pack. */ + tree (*get_argument_pack_elems) (const_tree); + + /* Given a type, apply default promotions to unnamed function + arguments and return the new type. Return the same type if no + change. Required by any language that supports variadic + arguments. The default hook dies. */ + tree (*type_promotes_to) (tree); + + /* Register TYPE as a builtin type with the indicated NAME. The + TYPE is placed in the outermost lexical scope. The semantics + should be analogous to: + + typedef TYPE NAME; + + in C. The default hook ignores the declaration. */ + void (*register_builtin_type) (tree, const char *); + + /* This routine is called in tree.c to print an error message for + invalid use of an incomplete type. VALUE is the expression that + was used (or 0 if that isn't known) and TYPE is the type that was + invalid. */ + void (*incomplete_type_error) (const_tree value, const_tree type); + + /* Called from assign_temp to return the maximum size, if there is one, + for a type. */ + tree (*max_size) (const_tree); + + /* Register language specific type size variables as potentially OpenMP + firstprivate variables. */ + void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree); + + /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes. + Called only after doing all language independent checks. + At present, this function is only called when both TYPE1 and TYPE2 are + FUNCTION_TYPEs. */ + bool (*type_hash_eq) (const_tree, const_tree); + + /* Return TRUE if TYPE uses a hidden descriptor and fills in information + for the debugger about the array bounds, strides, etc. */ + bool (*get_array_descr_info) (const_tree, struct array_descr_info *); + + /* Fill in information for the debugger about the bounds of TYPE. */ + void (*get_subrange_bounds) (const_tree, tree *, tree *); + + /* If we requested a pointer to a vector, build up the pointers that + we stripped off while looking for the inner type. Similarly for + return values from functions. The argument TYPE is the top of the + chain, and BOTTOM is the new type which we will point to. */ + tree (*reconstruct_complex_type) (tree, tree); +}; + +/* Language hooks related to decls and the symbol table. */ + +struct lang_hooks_for_decls +{ + /* Returns nonzero if we are in the global binding level. Ada + returns -1 for an undocumented reason used in stor-layout.c. */ + int (*global_bindings_p) (void); + + /* Function to add a decl to the current scope level. Takes one + argument, a decl to add. Returns that decl, or, if the same + symbol is already declared, may return a different decl for that + name. */ + tree (*pushdecl) (tree); + + /* Returns the chain of decls so far in the current scope level. */ + tree (*getdecls) (void); + + /* Returns true if DECL is explicit member function. */ + bool (*function_decl_explicit_p) (tree); + + /* Returns True if the parameter is a generic parameter decl + of a generic type, e.g a template template parameter for the C++ FE. */ + bool (*generic_generic_parameter_decl_p) (const_tree); + + /* Determine if a function parameter got expanded from a + function parameter pack. */ + bool (*function_parm_expanded_from_pack_p) (tree, tree); + + /* Returns the generic declaration of a generic function instantiations. */ + tree (*get_generic_function_decl) (const_tree); + + /* Returns true when we should warn for an unused global DECL. + We will already have checked that it has static binding. */ + bool (*warn_unused_global) (const_tree); + + /* Obtain a list of globals and do final output on them at end + of compilation */ + void (*final_write_globals) (void); + + /* True if this decl may be called via a sibcall. */ + bool (*ok_for_sibcall) (const_tree); + + /* True if OpenMP should privatize what this DECL points to rather + than the DECL itself. */ + bool (*omp_privatize_by_reference) (const_tree); + + /* Return sharing kind if OpenMP sharing attribute of DECL is + predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ + enum omp_clause_default_kind (*omp_predetermined_sharing) (tree); + + /* Return decl that should be reported for DEFAULT(NONE) failure + diagnostics. Usually the DECL passed in. */ + tree (*omp_report_decl) (tree); + + /* Return true if DECL's DECL_VALUE_EXPR (if any) should be + disregarded in OpenMP construct, because it is going to be + remapped during OpenMP lowering. SHARED is true if DECL + is going to be shared, false if it is going to be privatized. */ + bool (*omp_disregard_value_expr) (tree, bool); + + /* Return true if DECL that is shared iff SHARED is true should + be put into OMP_CLAUSE_PRIVATE_DEBUG. */ + bool (*omp_private_debug_clause) (tree, bool); + + /* Return true if DECL in private clause needs + OMP_CLAUSE_PRIVATE_OUTER_REF on the private clause. */ + bool (*omp_private_outer_ref) (tree); + + /* Build and return code for a default constructor for DECL in + response to CLAUSE. OUTER is corresponding outer region's + variable if needed. Return NULL if nothing to be done. */ + tree (*omp_clause_default_ctor) (tree clause, tree decl, tree outer); + + /* Build and return code for a copy constructor from SRC to DST. */ + tree (*omp_clause_copy_ctor) (tree clause, tree dst, tree src); + + /* Similarly, except use an assignment operator instead. */ + tree (*omp_clause_assign_op) (tree clause, tree dst, tree src); + + /* Build and return code destructing DECL. Return NULL if nothing + to be done. */ + tree (*omp_clause_dtor) (tree clause, tree decl); + + /* Do language specific checking on an implicitly determined clause. */ + void (*omp_finish_clause) (tree clause); +}; + +/* Lang hooks for LIPO. */ + +struct lang_hooks_for_lipo +{ + /* Add DECL to the list of predefined builtins. */ + void (*add_built_in_decl) (tree decl); + + /* Save the tree (by making a copy) and binding values + for builtins before parsing start. */ + void (*save_built_in_decl_pre_parsing) (void); + + /* Restore builtins and their bindings to their values + before parsing. */ + void (*restore_built_in_decl_pre_parsing) (void); + + /* Save the tree (by making a copy) and binding values for + builtins after parsing of a file. */ + void (*save_built_in_decl_post_module_parsing) (void); + + /* Restore builtins and their bindings to their post + parsing values. */ + void (*restore_built_in_decl_post_module_parsing) (void); + + /* Clear symbol binding for name ID. */ + void (*clear_global_name_bindings) (tree id); + + /* Return true if DECL in SCOPE is scoped in global/namespace scope, + otherwise return false. */ + bool (*has_global_name) (tree decl, void *scope); + + /* Return the actual size of the lang_decl struct for + decl T. */ + int (*get_lang_decl_size) (tree t); + + /* Duplicate language specific type information from SRC + to DEST. */ + void (*dup_lang_type) (tree src, tree dest); + + /* Copy DEST into SRC. */ + void (*copy_lang_type) (tree src, tree dest); + + /* Process decls after parsing of a source module. */ + void (*process_pending_decls) (unsigned); + + /* Clear the list of deferred functions. */ + void (*clear_deferred_fns) (void); + + /* Return true if T is compiler generated. */ + bool (*is_compiler_generated_type) (tree t); + + /* Compare language specific types T1 and T2. + Return 1 if they are compatible. */ + int (*cmp_lang_type) (tree t1, tree t2); +}; + +/* Language hooks related to LTO serialization. */ + +struct lang_hooks_for_lto +{ + /* Begin a new LTO section named NAME. */ + void (*begin_section) (const char *name); + + /* Write DATA of length LEN to the currently open LTO section. BLOCK is a + pointer to the dynamically allocated memory containing DATA. The + append_data function is responsible for freeing it when it is no longer + needed. */ + void (*append_data) (const void *data, size_t len, void *block); + + /* End the previously begun LTO section. */ + void (*end_section) (void); +}; + +/* Language-specific hooks. See langhooks-def.h for defaults. */ + +struct lang_hooks +{ + /* String identifying the front end. e.g. "GNU C++". */ + const char *name; + + /* sizeof (struct lang_identifier), so make_node () creates + identifier nodes long enough for the language-specific slots. */ + size_t identifier_size; + + /* Remove any parts of the tree that are used only by the FE. */ + void (*free_lang_data) (tree); + + /* Determines the size of any language-specific tcc_constant or + tcc_exceptional nodes. Since it is called from make_node, the + only information available is the tree code. Expected to die + on unrecognized codes. */ + size_t (*tree_size) (enum tree_code); + + /* Return the language mask used for converting argv into a sequence + of options. */ + unsigned int (*option_lang_mask) (void); + + /* Initialize variables in an options structure. */ + void (*init_options_struct) (struct gcc_options *opts); + + /* After the initialize_diagnostics hook is called, do any simple + initialization needed before any calls to handle_option, other + than that done by the init_options_struct hook. */ + void (*init_options) (unsigned int decoded_options_count, + struct cl_decoded_option *decoded_options); + + /* Callback used to perform language-specific initialization for the + global diagnostic context structure. */ + void (*initialize_diagnostics) (diagnostic_context *); + + /* Return true if a warning should be given about option OPTION, + which is for the wrong language, false if it should be quietly + ignored. */ + bool (*complain_wrong_lang_p) (const struct cl_option *option); + + /* Handle the switch CODE, which has real type enum opt_code from + options.h. If the switch takes an argument, it is passed in ARG + which points to permanent storage. The handler is responsible for + checking whether ARG is NULL, which indicates that no argument + was in fact supplied. For -f and -W switches, VALUE is 1 or 0 + for the positive and negative forms respectively. HANDLERS should + be passed to any recursive handle_option calls. LOC is the + location of the option. + + Return true if the switch is valid, false if invalid. */ + bool (*handle_option) (size_t code, const char *arg, int value, int kind, + location_t loc, + const struct cl_option_handlers *handlers); + + /* Called when all command line options have been parsed to allow + further processing and initialization + + Should return true to indicate that a compiler back-end is + not required, such as with the -E option. + + If errorcount is nonzero after this call the compiler exits + immediately and the finish hook is not called. */ + bool (*post_options) (const char **); + + /* Called after post_options to initialize the front end. Return + false to indicate that no further compilation be performed, in + which case the finish hook is called immediately. */ + bool (*init) (void); + + /* Called at the end of compilation, as a finalizer. */ + void (*finish) (void); + + /* Parses the entire file. */ + void (*parse_file) (void); + + /* Determines if it's ok for a function to have no noreturn attribute. */ + bool (*missing_noreturn_ok_p) (tree); + + /* Called to obtain the alias set to be used for an expression or type. + Returns -1 if the language does nothing special for it. */ + alias_set_type (*get_alias_set) (tree); + + /* Function to finish handling an incomplete decl at the end of + compilation. Default hook is does nothing. */ + void (*finish_incomplete_decl) (tree); + + /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the + DECL_NODE with a newly GC-allocated copy. */ + void (*dup_lang_specific_decl) (tree); + + /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of + thing that the assembler should talk about, set + DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE. + Otherwise, set it to the ERROR_MARK_NODE to ensure that the + assembler does not talk about it. */ + void (*set_decl_assembler_name) (tree); + + /* The front end can add its own statistics to -fmem-report with + this hook. It should output to stderr. */ + void (*print_statistics) (void); + + /* Called by print_tree when there is a tree of class tcc_exceptional + that it doesn't know how to display. */ + lang_print_tree_hook print_xnode; + + /* Called to print language-dependent parts of tcc_decl, tcc_type, + and IDENTIFIER_NODE nodes. */ + lang_print_tree_hook print_decl; + lang_print_tree_hook print_type; + lang_print_tree_hook print_identifier; + + /* Computes the name to use to print a declaration. DECL is the + non-NULL declaration in question. VERBOSITY determines what + information will be printed: 0: DECL_NAME, demangled as + necessary. 1: and scope information. 2: and any other + information that might be interesting, such as function parameter + types in C++. The name is in the internal character set and + needs to be converted to the locale character set of diagnostics, + or to the execution character set for strings such as + __PRETTY_FUNCTION__. */ + const char *(*decl_printable_name) (tree decl, int verbosity); + + /* Computes the dwarf-2/3 name for a tree. VERBOSITY determines what + information will be printed: 0: DECL_NAME, demangled as + necessary. 1: and scope information. */ + const char *(*dwarf_name) (tree, int verbosity); + + /* This compares two types for equivalence ("compatible" in C-based languages). + This routine should only return 1 if it is sure. It should not be used + in contexts where erroneously returning 0 causes problems. */ + int (*types_compatible_p) (tree x, tree y); + + /* Called by report_error_function to print out function name. */ + void (*print_error_function) (diagnostic_context *, const char *, + struct diagnostic_info *); + + /* Convert a character from the host's to the target's character + set. The character should be in what C calls the "basic source + character set" (roughly, the set of characters defined by plain + old ASCII). The default is to return the character unchanged, + which is correct in most circumstances. Note that both argument + and result should be sign-extended under -fsigned-char, + zero-extended under -fno-signed-char. */ + HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT); + + /* Pointers to machine-independent attribute tables, for front ends + using attribs.c. If one is NULL, it is ignored. Respectively, a + table of attributes specific to the language, a table of + attributes common to two or more languages (to allow easy + sharing), and a table of attributes for checking formats. */ + const struct attribute_spec *attribute_table; + const struct attribute_spec *common_attribute_table; + const struct attribute_spec *format_attribute_table; + + struct lang_hooks_for_tree_inlining tree_inlining; + + struct lang_hooks_for_callgraph callgraph; + + struct lang_hooks_for_tree_dump tree_dump; + + struct lang_hooks_for_decls decls; + + struct lang_hooks_for_types types; + + struct lang_hooks_for_lipo l_ipo; + + struct lang_hooks_for_lto lto; + + /* Returns the generic parameters of an instantiation of + a generic type or decl, e.g. C++ template instantiation. */ + tree (*get_innermost_generic_parms) (const_tree); + + /* Returns the TREE_VEC of arguments of an instantiation + of a generic type of decl, e.g. C++ template instantiation. */ + tree (*get_innermost_generic_args) (const_tree); + + /* Determine if a tree is a function parameter pack. */ + bool (*function_parameter_pack_p) (const_tree); + + /* Perform language-specific gimplification on the argument. Returns an + enum gimplify_status, though we can't see that type here. */ + int (*gimplify_expr) (tree *, gimple_seq *, gimple_seq *); + + /* Return the virtual function decl for the given OBJ_TYPE_REF expression. */ + tree (*get_virtual_function_decl) (tree, tree); + + /* Determine whether the given DECL is a compiler-generated base field + in a derived class. */ + bool (*decl_is_base_field) (tree); + + /* Return true if DECL is a constructor. */ + bool (*decl_is_constructor) (tree); + + /* Return true if DECL is a destructor. */ + bool (*decl_is_destructor) (tree); + + /* Return + 1 if decl is a const member function, + 2 if decl is not a const member function but has a const overload that + has identical parameter list, + 0 otherwise. */ + int (*decl_is_const_member_func) (tree); + + /* Do language specific processing in the builtin function DECL */ + tree (*builtin_function) (tree decl); + + /* Like builtin_function, but make sure the scope is the external scope. + This is used to delay putting in back end builtin functions until the ISA + that defines the builtin is declared via function specific target options, + which can save memory for machines like the x86_64 that have multiple + ISAs. If this points to the same function as builtin_function, the + backend must add all of the builtins at program initialization time. */ + tree (*builtin_function_ext_scope) (tree decl); + + /* Returns true if DECL is a user defined conversion operator (C++) */ + bool (*user_conv_function_p) (tree decl); + + /* Used to set up the tree_contains_structure array for a frontend. */ + void (*init_ts) (void); + + /* Called by recompute_tree_invariant_for_addr_expr to go from EXPR + to a contained expression or DECL, possibly updating *TC or *SE + if in the process TREE_CONSTANT or TREE_SIDE_EFFECTS need updating. */ + tree (*expr_to_decl) (tree expr, bool *tc, bool *se); + + /* The EH personality function decl. */ + tree (*eh_personality) (void); + + /* Map a type to a runtime object to match type. */ + tree (*eh_runtime_type) (tree); + + /* If non-NULL, this is a function that returns a function decl to be + executed if an unhandled exception is propagated out of a cleanup + region. For example, in C++, an exception thrown by a destructor + during stack unwinding is required to result in a call to + `std::terminate', so the C++ version of this function returns a + FUNCTION_DECL for `std::terminate'. */ + tree (*eh_protect_cleanup_actions) (void); + + /* True if this language uses __cxa_end_cleanup when the ARM EABI + is enabled. */ + bool eh_use_cxa_end_cleanup; + + /* True if this language requires deep unsharing of tree nodes prior to + gimplification. */ + bool deep_unsharing; + + /* Whenever you add entries here, make sure you adjust langhooks-def.h + and langhooks.c accordingly. */ +}; + +/* Each front end provides its own. */ +extern struct lang_hooks lang_hooks; +extern tree add_builtin_function (const char *name, tree type, + int function_code, enum built_in_class cl, + const char *library_name, + tree attrs); + +extern tree add_builtin_function_ext_scope (const char *name, tree type, + int function_code, + enum built_in_class cl, + const char *library_name, + tree attrs); + +#endif /* GCC_LANG_HOOKS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/libiberty.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/libiberty.h new file mode 100644 index 0000000..1cc7250 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/libiberty.h @@ -0,0 +1,679 @@ +/* Function declarations for libiberty. + + Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + + Note - certain prototypes declared in this header file are for + functions whoes implementation copyright does not belong to the + FSF. Those prototypes are present in this file for reference + purposes only and their presence in this file should not construed + as an indication of ownership by the FSF of the implementation of + those functions in any way or form whatsoever. + + 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, 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. + + Written by Cygnus Support, 1994. + + The libiberty library provides a number of functions which are + missing on some operating systems. We do not declare those here, + to avoid conflicts with the system header files on operating + systems that do support those functions. In this file we only + declare those functions which are specific to libiberty. */ + +#ifndef LIBIBERTY_H +#define LIBIBERTY_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "ansidecl.h" + +/* Get a definition for size_t. */ +#include <stddef.h> +/* Get a definition for va_list. */ +#include <stdarg.h> + +#include <stdio.h> + +/* If the OS supports it, ensure that the supplied stream is setup to + avoid any multi-threaded locking. Otherwise leave the FILE pointer + unchanged. If the stream is NULL do nothing. */ + +extern void unlock_stream (FILE *); + +/* If the OS supports it, ensure that the standard I/O streams, stdin, + stdout and stderr are setup to avoid any multi-threaded locking. + Otherwise do nothing. */ + +extern void unlock_std_streams (void); + +/* Open and return a FILE pointer. If the OS supports it, ensure that + the stream is setup to avoid any multi-threaded locking. Otherwise + return the FILE pointer unchanged. */ + +extern FILE *fopen_unlocked (const char *, const char *); +extern FILE *fdopen_unlocked (int, const char *); +extern FILE *freopen_unlocked (const char *, const char *, FILE *); + +/* Build an argument vector from a string. Allocates memory using + malloc. Use freeargv to free the vector. */ + +extern char **buildargv (const char *) ATTRIBUTE_MALLOC; + +/* Free a vector returned by buildargv. */ + +extern void freeargv (char **); + +/* Duplicate an argument vector. Allocates memory using malloc. Use + freeargv to free the vector. */ + +extern char **dupargv (char **) ATTRIBUTE_MALLOC; + +/* Expand "@file" arguments in argv. */ + +extern void expandargv PARAMS ((int *, char ***)); + +/* Write argv to an @-file, inserting necessary quoting. */ + +extern int writeargv PARAMS ((char **, FILE *)); + +/* Return the last component of a path name. Note that we can't use a + prototype here because the parameter is declared inconsistently + across different systems, sometimes as "char *" and sometimes as + "const char *" */ + +/* HAVE_DECL_* is a three-state macro: undefined, 0 or 1. If it is + undefined, we haven't run the autoconf check so provide the + declaration without arguments. If it is 0, we checked and failed + to find the declaration so provide a fully prototyped one. If it + is 1, we found it so don't provide any declaration at all. */ +#if !HAVE_DECL_BASENAME +#if defined (__GNU_LIBRARY__ ) || defined (__linux__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined(__NetBSD__) || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) || defined (HAVE_DECL_BASENAME) +extern char *basename (const char *); +#else +/* Do not allow basename to be used if there is no prototype seen. We + either need to use the above prototype or have one from + autoconf which would result in HAVE_DECL_BASENAME being set. */ +#define basename basename_cannot_be_used_without_a_prototype +#endif +#endif + +/* A well-defined basename () that is always compiled in. */ + +extern const char *lbasename (const char *); + +/* Same, but assumes DOS semantics (drive name, backslash is also a + dir separator) regardless of host. */ + +extern const char *dos_lbasename (const char *); + +/* Same, but assumes Unix semantics (absolute paths always start with + a slash, only forward slash is accepted as dir separator) + regardless of host. */ + +extern const char *unix_lbasename (const char *); + +/* A well-defined realpath () that is always compiled in. */ + +extern char *lrealpath (const char *); + +/* Concatenate an arbitrary number of strings. You must pass NULL as + the last argument of this function, to terminate the list of + strings. Allocates memory using xmalloc. */ + +extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL; + +/* Concatenate an arbitrary number of strings. You must pass NULL as + the last argument of this function, to terminate the list of + strings. Allocates memory using xmalloc. The first argument is + not one of the strings to be concatenated, but if not NULL is a + pointer to be freed after the new string is created, similar to the + way xrealloc works. */ + +extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL; + +/* Determine the length of concatenating an arbitrary number of + strings. You must pass NULL as the last argument of this function, + to terminate the list of strings. */ + +extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL; + +/* Concatenate an arbitrary number of strings into a SUPPLIED area of + memory. You must pass NULL as the last argument of this function, + to terminate the list of strings. The supplied memory is assumed + to be large enough. */ + +extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL; + +/* Concatenate an arbitrary number of strings into a GLOBAL area of + memory. You must pass NULL as the last argument of this function, + to terminate the list of strings. The supplied memory is assumed + to be large enough. */ + +extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL; + +/* This is the global area used by concat_copy2. */ + +extern char *libiberty_concat_ptr; + +/* Concatenate an arbitrary number of strings. You must pass NULL as + the last argument of this function, to terminate the list of + strings. Allocates memory using alloca. The arguments are + evaluated twice! */ +#define ACONCAT(ACONCAT_PARAMS) \ + (libiberty_concat_ptr = (char *) alloca (concat_length ACONCAT_PARAMS + 1), \ + concat_copy2 ACONCAT_PARAMS) + +/* Check whether two file descriptors refer to the same file. */ + +extern int fdmatch (int fd1, int fd2); + +/* Return the position of the first bit set in the argument. */ +/* Prototypes vary from system to system, so we only provide a + prototype on systems where we know that we need it. */ +#if defined (HAVE_DECL_FFS) && !HAVE_DECL_FFS +extern int ffs(int); +#endif + +/* Get the working directory. The result is cached, so don't call + chdir() between calls to getpwd(). */ + +extern char * getpwd (void); + +/* Get the current time. */ +/* Prototypes vary from system to system, so we only provide a + prototype on systems where we know that we need it. */ +#ifdef __MINGW32__ +/* Forward declaration to avoid #include <sys/time.h>. */ +struct timeval; +extern int gettimeofday (struct timeval *, void *); +#endif + +/* Get the amount of time the process has run, in microseconds. */ + +extern long get_run_time (void); + +/* Generate a relocated path to some installation directory. Allocates + return value using malloc. */ + +extern char *make_relative_prefix (const char *, const char *, + const char *) ATTRIBUTE_MALLOC; + +/* Generate a relocated path to some installation directory without + attempting to follow any soft links. Allocates + return value using malloc. */ + +extern char *make_relative_prefix_ignore_links (const char *, const char *, + const char *) ATTRIBUTE_MALLOC; + +/* Choose a temporary directory to use for scratch files. */ + +extern char *choose_temp_base (void) ATTRIBUTE_MALLOC; + +/* Return a temporary file name or NULL if unable to create one. */ + +extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC; + +/* Remove a link to a file unless it is special. */ + +extern int unlink_if_ordinary (const char *); + +/* Allocate memory filled with spaces. Allocates using malloc. */ + +extern const char *spaces (int count); + +/* Return the maximum error number for which strerror will return a + string. */ + +extern int errno_max (void); + +/* Return the name of an errno value (e.g., strerrno (EINVAL) returns + "EINVAL"). */ + +extern const char *strerrno (int); + +/* Given the name of an errno value, return the value. */ + +extern int strtoerrno (const char *); + +/* ANSI's strerror(), but more robust. */ + +extern char *xstrerror (int); + +/* Return the maximum signal number for which strsignal will return a + string. */ + +extern int signo_max (void); + +/* Return a signal message string for a signal number + (e.g., strsignal (SIGHUP) returns something like "Hangup"). */ +/* This is commented out as it can conflict with one in system headers. + We still document its existence though. */ + +/*extern const char *strsignal (int);*/ + +/* Return the name of a signal number (e.g., strsigno (SIGHUP) returns + "SIGHUP"). */ + +extern const char *strsigno (int); + +/* Given the name of a signal, return its number. */ + +extern int strtosigno (const char *); + +/* Register a function to be run by xexit. Returns 0 on success. */ + +extern int xatexit (void (*fn) (void)); + +/* Exit, calling all the functions registered with xatexit. */ + +extern void xexit (int status) ATTRIBUTE_NORETURN; + +/* Set the program name used by xmalloc. */ + +extern void xmalloc_set_program_name (const char *); + +/* Report an allocation failure. */ +extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN; + +/* Allocate memory without fail. If malloc fails, this will print a + message to stderr (using the name set by xmalloc_set_program_name, + if any) and then call xexit. */ + +extern void *xmalloc (size_t) ATTRIBUTE_MALLOC; + +/* Reallocate memory without fail. This works like xmalloc. Note, + realloc type functions are not suitable for attribute malloc since + they may return the same address across multiple calls. */ + +extern void *xrealloc (void *, size_t); + +/* Allocate memory without fail and set it to zero. This works like + xmalloc. */ + +extern void *xcalloc (size_t, size_t) ATTRIBUTE_MALLOC; + +/* Copy a string into a memory buffer without fail. */ + +extern char *xstrdup (const char *) ATTRIBUTE_MALLOC; + +/* Copy at most N characters from string into a buffer without fail. */ + +extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC; + +/* Copy an existing memory buffer to a new memory buffer without fail. */ + +extern void *xmemdup (const void *, size_t, size_t) ATTRIBUTE_MALLOC; + +/* Physical memory routines. Return values are in BYTES. */ +extern double physmem_total (void); +extern double physmem_available (void); + +/* Compute the 32-bit CRC of a block of memory. */ +extern unsigned int xcrc32 (const unsigned char *, int, unsigned int); + +/* These macros provide a K&R/C89/C++-friendly way of allocating structures + with nice encapsulation. The XDELETE*() macros are technically + superfluous, but provided here for symmetry. Using them consistently + makes it easier to update client code to use different allocators such + as new/delete and new[]/delete[]. */ + +/* Scalar allocators. */ + +#define XALLOCA(T) ((T *) alloca (sizeof (T))) +#define XNEW(T) ((T *) xmalloc (sizeof (T))) +#define XCNEW(T) ((T *) xcalloc (1, sizeof (T))) +#define XDUP(T, P) ((T *) xmemdup ((P), sizeof (T), sizeof (T))) +#define XDELETE(P) free ((void*) (P)) + +/* Array allocators. */ + +#define XALLOCAVEC(T, N) ((T *) alloca (sizeof (T) * (N))) +#define XNEWVEC(T, N) ((T *) xmalloc (sizeof (T) * (N))) +#define XCNEWVEC(T, N) ((T *) xcalloc ((N), sizeof (T))) +#define XDUPVEC(T, P, N) ((T *) xmemdup ((P), sizeof (T) * (N), sizeof (T) * (N))) +#define XRESIZEVEC(T, P, N) ((T *) xrealloc ((void *) (P), sizeof (T) * (N))) +#define XDELETEVEC(P) free ((void*) (P)) + +/* Allocators for variable-sized structures and raw buffers. */ + +#define XALLOCAVAR(T, S) ((T *) alloca ((S))) +#define XNEWVAR(T, S) ((T *) xmalloc ((S))) +#define XCNEWVAR(T, S) ((T *) xcalloc (1, (S))) +#define XDUPVAR(T, P, S1, S2) ((T *) xmemdup ((P), (S1), (S2))) +#define XRESIZEVAR(T, P, S) ((T *) xrealloc ((P), (S))) + +/* Type-safe obstack allocator. */ + +#define XOBNEW(O, T) ((T *) obstack_alloc ((O), sizeof (T))) +#define XOBNEWVEC(O, T, N) ((T *) obstack_alloc ((O), sizeof (T) * (N))) +#define XOBNEWVAR(O, T, S) ((T *) obstack_alloc ((O), (S))) +#define XOBFINISH(O, T) ((T) obstack_finish ((O))) + +/* hex character manipulation routines */ + +#define _hex_array_size 256 +#define _hex_bad 99 +extern const unsigned char _hex_value[_hex_array_size]; +extern void hex_init (void); +#define hex_p(c) (hex_value (c) != _hex_bad) +/* If you change this, note well: Some code relies on side effects in + the argument being performed exactly once. */ +#define hex_value(c) ((unsigned int) _hex_value[(unsigned char) (c)]) + +/* Flags for pex_init. These are bits to be or'ed together. */ + +/* Record subprocess times, if possible. */ +#define PEX_RECORD_TIMES 0x1 + +/* Use pipes for communication between processes, if possible. */ +#define PEX_USE_PIPES 0x2 + +/* Save files used for communication between processes. */ +#define PEX_SAVE_TEMPS 0x4 + +/* Prepare to execute one or more programs, with standard output of + each program fed to standard input of the next. + FLAGS As above. + PNAME The name of the program to report in error messages. + TEMPBASE A base name to use for temporary files; may be NULL to + use a random name. + Returns NULL on error. */ + +extern struct pex_obj *pex_init (int flags, const char *pname, + const char *tempbase); + +/* Flags for pex_run. These are bits to be or'ed together. */ + +/* Last program in pipeline. Standard output of program goes to + OUTNAME, or, if OUTNAME is NULL, to standard output of caller. Do + not set this if you want to call pex_read_output. After this is + set, pex_run may no longer be called with the same struct + pex_obj. */ +#define PEX_LAST 0x1 + +/* Search for program in executable search path. */ +#define PEX_SEARCH 0x2 + +/* OUTNAME is a suffix. */ +#define PEX_SUFFIX 0x4 + +/* Send program's standard error to standard output. */ +#define PEX_STDERR_TO_STDOUT 0x8 + +/* Input file should be opened in binary mode. This flag is ignored + on Unix. */ +#define PEX_BINARY_INPUT 0x10 + +/* Output file should be opened in binary mode. This flag is ignored + on Unix. For proper behaviour PEX_BINARY_INPUT and + PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using + PEX_BINARY_OUTPUT should be followed by a call using + PEX_BINARY_INPUT. */ +#define PEX_BINARY_OUTPUT 0x20 + +/* Capture stderr to a pipe. The output can be read by + calling pex_read_err and reading from the returned + FILE object. This flag may be specified only for + the last program in a pipeline. + + This flag is supported only on Unix and Windows. */ +#define PEX_STDERR_TO_PIPE 0x40 + +/* Capture stderr in binary mode. This flag is ignored + on Unix. */ +#define PEX_BINARY_ERROR 0x80 + + +/* Execute one program. Returns NULL on success. On error returns an + error string (typically just the name of a system call); the error + string is statically allocated. + + OBJ Returned by pex_init. + + FLAGS As above. + + EXECUTABLE The program to execute. + + ARGV NULL terminated array of arguments to pass to the program. + + OUTNAME Sets the output file name as follows: + + PEX_SUFFIX set (OUTNAME may not be NULL): + TEMPBASE parameter to pex_init not NULL: + Output file name is the concatenation of TEMPBASE + and OUTNAME. + TEMPBASE is NULL: + Output file name is a random file name ending in + OUTNAME. + PEX_SUFFIX not set: + OUTNAME not NULL: + Output file name is OUTNAME. + OUTNAME NULL, TEMPBASE not NULL: + Output file name is randomly chosen using + TEMPBASE. + OUTNAME NULL, TEMPBASE NULL: + Output file name is randomly chosen. + + If PEX_LAST is not set, the output file name is the + name to use for a temporary file holding stdout, if + any (there will not be a file if PEX_USE_PIPES is set + and the system supports pipes). If a file is used, it + will be removed when no longer needed unless + PEX_SAVE_TEMPS is set. + + If PEX_LAST is set, and OUTNAME is not NULL, standard + output is written to the output file name. The file + will not be removed. If PEX_LAST and PEX_SUFFIX are + both set, TEMPBASE may not be NULL. + + ERRNAME If not NULL, this is the name of a file to which + standard error is written. If NULL, standard error of + the program is standard error of the caller. + + ERR On an error return, *ERR is set to an errno value, or + to 0 if there is no relevant errno. +*/ + +extern const char *pex_run (struct pex_obj *obj, int flags, + const char *executable, char * const *argv, + const char *outname, const char *errname, + int *err); + +/* As for pex_run (), but takes an extra parameter to enable the + environment for the child process to be specified. + + ENV The environment for the child process, specified as + an array of character pointers. Each element of the + array should point to a string of the form VAR=VALUE, + with the exception of the last element which must be + a null pointer. +*/ + +extern const char *pex_run_in_environment (struct pex_obj *obj, int flags, + const char *executable, + char * const *argv, + char * const *env, + const char *outname, + const char *errname, int *err); + +/* Return a stream for a temporary file to pass to the first program + in the pipeline as input. The file name is chosen as for pex_run. + pex_run closes the file automatically; don't close it yourself. */ + +extern FILE *pex_input_file (struct pex_obj *obj, int flags, + const char *in_name); + +/* Return a stream for a pipe connected to the standard input of the + first program in the pipeline. You must have passed + `PEX_USE_PIPES' to `pex_init'. Close the returned stream + yourself. */ + +extern FILE *pex_input_pipe (struct pex_obj *obj, int binary); + +/* Read the standard output of the last program to be executed. + pex_run can not be called after this. BINARY should be non-zero if + the file should be opened in binary mode; this is ignored on Unix. + Returns NULL on error. Don't call fclose on the returned FILE; it + will be closed by pex_free. */ + +extern FILE *pex_read_output (struct pex_obj *, int binary); + +/* Read the standard error of the last program to be executed. + pex_run can not be called after this. BINARY should be non-zero if + the file should be opened in binary mode; this is ignored on Unix. + Returns NULL on error. Don't call fclose on the returned FILE; it + will be closed by pex_free. */ + +extern FILE *pex_read_err (struct pex_obj *, int binary); + +/* Return exit status of all programs in VECTOR. COUNT indicates the + size of VECTOR. The status codes in the vector are in the order of + the calls to pex_run. Returns 0 on error, 1 on success. */ + +extern int pex_get_status (struct pex_obj *, int count, int *vector); + +/* Return times of all programs in VECTOR. COUNT indicates the size + of VECTOR. struct pex_time is really just struct timeval, but that + is not portable to all systems. Returns 0 on error, 1 on + success. */ + +struct pex_time +{ + unsigned long user_seconds; + unsigned long user_microseconds; + unsigned long system_seconds; + unsigned long system_microseconds; +}; + +extern int pex_get_times (struct pex_obj *, int count, + struct pex_time *vector); + +/* Clean up a pex_obj. If you have not called pex_get_times or + pex_get_status, this will try to kill the subprocesses. */ + +extern void pex_free (struct pex_obj *); + +/* Just execute one program. Return value is as for pex_run. + FLAGS Combination of PEX_SEARCH and PEX_STDERR_TO_STDOUT. + EXECUTABLE As for pex_run. + ARGV As for pex_run. + PNAME As for pex_init. + OUTNAME As for pex_run when PEX_LAST is set. + ERRNAME As for pex_run. + STATUS Set to exit status on success. + ERR As for pex_run. +*/ + +extern const char *pex_one (int flags, const char *executable, + char * const *argv, const char *pname, + const char *outname, const char *errname, + int *status, int *err); + +/* pexecute and pwait are the old pexecute interface, still here for + backward compatibility. Don't use these for new code. Instead, + use pex_init/pex_run/pex_get_status/pex_free, or pex_one. */ + +/* Definitions used by the pexecute routine. */ + +#define PEXECUTE_FIRST 1 +#define PEXECUTE_LAST 2 +#define PEXECUTE_ONE (PEXECUTE_FIRST + PEXECUTE_LAST) +#define PEXECUTE_SEARCH 4 +#define PEXECUTE_VERBOSE 8 + +/* Execute a program. */ + +extern int pexecute (const char *, char * const *, const char *, + const char *, char **, char **, int); + +/* Wait for pexecute to finish. */ + +extern int pwait (int, int *, int); + +#if !HAVE_DECL_ASPRINTF +/* Like sprintf but provides a pointer to malloc'd storage, which must + be freed by the caller. */ + +extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2; +#endif + +#if !HAVE_DECL_VASPRINTF +/* Like vsprintf but provides a pointer to malloc'd storage, which + must be freed by the caller. */ + +extern int vasprintf (char **, const char *, va_list) ATTRIBUTE_PRINTF(2,0); +#endif + +#if defined(HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF +/* Like sprintf but prints at most N characters. */ +extern int snprintf (char *, size_t, const char *, ...) ATTRIBUTE_PRINTF_3; +#endif + +#if defined(HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF +/* Like vsprintf but prints at most N characters. */ +extern int vsnprintf (char *, size_t, const char *, va_list) ATTRIBUTE_PRINTF(3,0); +#endif + +#if defined(HAVE_DECL_STRVERSCMP) && !HAVE_DECL_STRVERSCMP +/* Compare version strings. */ +extern int strverscmp (const char *, const char *); +#endif + +/* Set the title of a process */ +extern void setproctitle (const char *name, ...); + +#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) + +/* Drastically simplified alloca configurator. If we're using GCC, + we use __builtin_alloca; otherwise we use the C alloca. The C + alloca is always available. You can override GCC by defining + USE_C_ALLOCA yourself. The canonical autoconf macro C_ALLOCA is + also set/unset as it is often used to indicate whether code needs + to call alloca(0). */ +extern void *C_alloca (size_t) ATTRIBUTE_MALLOC; +#undef alloca +#if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA +# define alloca(x) __builtin_alloca(x) +# undef C_ALLOCA +# define ASTRDUP(X) \ + (__extension__ ({ const char *const libiberty_optr = (X); \ + const unsigned long libiberty_len = strlen (libiberty_optr) + 1; \ + char *const libiberty_nptr = (char *const) alloca (libiberty_len); \ + (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len); })) +#else +# define alloca(x) C_alloca(x) +# undef USE_C_ALLOCA +# define USE_C_ALLOCA 1 +# undef C_ALLOCA +# define C_ALLOCA 1 +extern const char *libiberty_optr; +extern char *libiberty_nptr; +extern unsigned long libiberty_len; +# define ASTRDUP(X) \ + (libiberty_optr = (X), \ + libiberty_len = strlen (libiberty_optr) + 1, \ + libiberty_nptr = (char *) alloca (libiberty_len), \ + (char *) memcpy (libiberty_nptr, libiberty_optr, libiberty_len)) +#endif + +#ifdef __cplusplus +} +#endif + + +#endif /* ! defined (LIBIBERTY_H) */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/line-map.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/line-map.h new file mode 100644 index 0000000..3234423 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/line-map.h @@ -0,0 +1,193 @@ +/* Map logical line numbers to (source file, line number) pairs. + Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + +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 3, 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; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ + +#ifndef LIBCPP_LINE_MAP_H +#define LIBCPP_LINE_MAP_H + +#ifndef GTY +#define GTY(x) /* nothing */ +#endif + +/* Reason for adding a line change with add_line_map (). LC_ENTER is + when including a new file, e.g. a #include directive in C. + LC_LEAVE is when reaching a file's end. LC_RENAME is when a file + name or line number changes for neither of the above reasons + (e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME + but a filename of "" is not specially interpreted as standard input. */ +enum lc_reason {LC_ENTER = 0, LC_LEAVE, LC_RENAME, LC_RENAME_VERBATIM}; + +/* The type of line numbers. */ +typedef unsigned int linenum_type; + +/* A logical line/column number, i.e. an "index" into a line_map. */ +typedef unsigned int source_location; + +/* Memory allocation function typedef. Works like xrealloc. */ +typedef void *(*line_map_realloc) (void *, size_t); + +/* Physical source file TO_FILE at line TO_LINE at column 0 is represented + by the logical START_LOCATION. TO_LINE+L at column C is represented by + START_LOCATION+(L*(1<<column_bits))+C, as long as C<(1<<column_bits), + and the result_location is less than the next line_map's start_location. + (The top line is line 1 and the leftmost column is column 1; line/column 0 + means "entire file/line" or "unknown line/column" or "not applicable".) + INCLUDED_FROM is an index into the set that gives the line mapping + at whose end the current one was included. File(s) at the bottom + of the include stack have this set to -1. REASON is the reason for + creation of this line map, SYSP is one for a system header, two for + a C system header file that therefore needs to be extern "C" + protected in C++, and zero otherwise. */ +struct GTY(()) line_map { + const char *to_file; + linenum_type to_line; + source_location start_location; + int included_from; + ENUM_BITFIELD (lc_reason) reason : CHAR_BIT; + /* The sysp field isn't really needed now that it's in cpp_buffer. */ + unsigned char sysp; + /* Number of the low-order source_location bits used for a column number. */ + unsigned int column_bits : 8; +}; + +/* A set of chronological line_map structures. */ +struct GTY(()) line_maps { + struct line_map * GTY ((length ("%h.used"))) maps; + unsigned int allocated; + unsigned int used; + + unsigned int cache; + + /* The most recently listed include stack, if any, starts with + LAST_LISTED as the topmost including file. -1 indicates nothing + has been listed yet. */ + int last_listed; + + /* Depth of the include stack, including the current file. */ + unsigned int depth; + + /* If true, prints an include trace a la -H. */ + bool trace_includes; + + /* Highest source_location "given out". */ + source_location highest_location; + + /* Start of line of highest source_location "given out". */ + source_location highest_line; + + /* The maximum column number we can quickly allocate. Higher numbers + may require allocating a new line_map. */ + unsigned int max_column_hint; + + /* If non-null, the allocator to use when resizing 'maps'. If null, + xrealloc is used. */ + line_map_realloc reallocator; +}; + +/* Initialize a line map set. */ +extern void linemap_init (struct line_maps *); + +/* Free a line map set. */ +extern void linemap_free (struct line_maps *); + +/* Check for and warn about line_maps entered but not exited. */ + +extern void linemap_check_files_exited (struct line_maps *); + +/* Return a source_location for the start (i.e. column==0) of + (physical) line TO_LINE in the current source file (as in the + most recent linemap_add). MAX_COLUMN_HINT is the highest column + number we expect to use in this line (but it does not change + the highest_location). */ + +extern source_location linemap_line_start +(struct line_maps *set, linenum_type to_line, unsigned int max_column_hint); + +/* Add a mapping of logical source line to physical source file and + line number. + + The text pointed to by TO_FILE must have a lifetime + at least as long as the final call to lookup_line (). An empty + TO_FILE means standard input. If reason is LC_LEAVE, and + TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their + natural values considering the file we are returning to. + + A call to this function can relocate the previous set of + maps, so any stored line_map pointers should not be used. */ +extern const struct line_map *linemap_add + (struct line_maps *, enum lc_reason, unsigned int sysp, + const char *to_file, linenum_type to_line); + +/* Given a logical line, returns the map from which the corresponding + (source file, line) pair can be deduced. */ +extern const struct line_map *linemap_lookup + (struct line_maps *, source_location); + +/* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will + be reserved for libcpp user as special values, no token from libcpp + will contain any of those locations. */ +#define RESERVED_LOCATION_COUNT 2 + +/* Converts a map and a source_location to source line. */ +#define SOURCE_LINE(MAP, LOC) \ + ((((LOC) - (MAP)->start_location) >> (MAP)->column_bits) + (MAP)->to_line) + +#define SOURCE_COLUMN(MAP, LOC) \ + (((LOC) - (MAP)->start_location) & ((1 << (MAP)->column_bits) - 1)) + +/* Returns the last source line within a map. This is the (last) line + of the #include, or other directive, that caused a map change. */ +#define LAST_SOURCE_LINE(MAP) \ + SOURCE_LINE (MAP, LAST_SOURCE_LINE_LOCATION (MAP)) +#define LAST_SOURCE_COLUMN(MAP) \ + SOURCE_COLUMN (MAP, LAST_SOURCE_LINE_LOCATION (MAP)) +#define LAST_SOURCE_LINE_LOCATION(MAP) \ + ((((MAP)[1].start_location - 1 - (MAP)->start_location) \ + & ~((1 << (MAP)->column_bits) - 1)) \ + + (MAP)->start_location) + +/* Returns the map a given map was included from. */ +#define INCLUDED_FROM(SET, MAP) (&(SET)->maps[(MAP)->included_from]) + +/* Nonzero if the map is at the bottom of the include stack. */ +#define MAIN_FILE_P(MAP) ((MAP)->included_from < 0) + +/* Set LOC to a source position that is the same line as the most recent + linemap_line_start, but with the specified TO_COLUMN column number. */ + +#define LINEMAP_POSITION_FOR_COLUMN(LOC, SET, TO_COLUMN) do { \ + unsigned int to_column = (TO_COLUMN); \ + struct line_maps *set = (SET); \ + if (__builtin_expect (to_column >= set->max_column_hint, 0)) \ + (LOC) = linemap_position_for_column (set, to_column); \ + else { \ + source_location r = set->highest_line; \ + r = r + to_column; \ + if (r >= set->highest_location) \ + set->highest_location = r; \ + (LOC) = r; \ + }} while (0) + + +extern source_location +linemap_position_for_column (struct line_maps *set, unsigned int to_column); + +#endif /* !LIBCPP_LINE_MAP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/machmode.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/machmode.h new file mode 100644 index 0000000..bdcd02d --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/machmode.h @@ -0,0 +1,278 @@ +/* Machine mode definitions for GCC; included by rtl.h and tree.h. + Copyright (C) 1991, 1993, 1994, 1996, 1998, 1999, 2000, 2001, 2003, + 2007, 2008, 2009, 2010 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/>. */ + +#ifndef HAVE_MACHINE_MODES +#define HAVE_MACHINE_MODES + +/* Make an enum class that gives all the machine modes. */ +#include "insn-modes.h" + +/* Get the name of mode MODE as a string. */ + +extern const char * const mode_name[NUM_MACHINE_MODES]; +#define GET_MODE_NAME(MODE) mode_name[MODE] + +/* Mode classes. */ + +#include "mode-classes.def" +#define DEF_MODE_CLASS(M) M +enum mode_class { MODE_CLASSES, MAX_MODE_CLASS }; +#undef DEF_MODE_CLASS +#undef MODE_CLASSES + +/* Get the general kind of object that mode MODE represents + (integer, floating, complex, etc.) */ + +extern const unsigned char mode_class[NUM_MACHINE_MODES]; +#define GET_MODE_CLASS(MODE) ((enum mode_class) mode_class[MODE]) + +/* Nonzero if MODE is an integral mode. */ +#define INTEGRAL_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_INT \ + || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \ + || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT) + +/* Nonzero if MODE is a floating-point mode. */ +#define FLOAT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_FLOAT \ + || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \ + || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT) + +/* Nonzero if MODE is a complex mode. */ +#define COMPLEX_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \ + || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) + +/* Nonzero if MODE is a vector mode. */ +#define VECTOR_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM) + +/* Nonzero if MODE is a scalar integral mode. */ +#define SCALAR_INT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_INT \ + || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT) + +/* Nonzero if MODE is a scalar floating point mode. */ +#define SCALAR_FLOAT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_FLOAT \ + || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT) + +/* Nonzero if MODE is a decimal floating point mode. */ +#define DECIMAL_FLOAT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT) + +/* Nonzero if MODE is a scalar fract mode. */ +#define SCALAR_FRACT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_FRACT) + +/* Nonzero if MODE is a scalar ufract mode. */ +#define SCALAR_UFRACT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_UFRACT) + +/* Nonzero if MODE is a scalar fract or ufract mode. */ +#define ALL_SCALAR_FRACT_MODE_P(MODE) \ + (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar accum mode. */ +#define SCALAR_ACCUM_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_ACCUM) + +/* Nonzero if MODE is a scalar uaccum mode. */ +#define SCALAR_UACCUM_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_UACCUM) + +/* Nonzero if MODE is a scalar accum or uaccum mode. */ +#define ALL_SCALAR_ACCUM_MODE_P(MODE) \ + (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar fract or accum mode. */ +#define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE) \ + (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar ufract or uaccum mode. */ +#define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE) \ + (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode. */ +#define ALL_SCALAR_FIXED_POINT_MODE_P(MODE) \ + (SIGNED_SCALAR_FIXED_POINT_MODE_P (MODE) \ + || UNSIGNED_SCALAR_FIXED_POINT_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar/vector fract mode. */ +#define FRACT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_FRACT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT) + +/* Nonzero if MODE is a scalar/vector ufract mode. */ +#define UFRACT_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_UFRACT \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT) + +/* Nonzero if MODE is a scalar/vector fract or ufract mode. */ +#define ALL_FRACT_MODE_P(MODE) \ + (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar/vector accum mode. */ +#define ACCUM_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_ACCUM \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM) + +/* Nonzero if MODE is a scalar/vector uaccum mode. */ +#define UACCUM_MODE_P(MODE) \ + (GET_MODE_CLASS (MODE) == MODE_UACCUM \ + || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM) + +/* Nonzero if MODE is a scalar/vector accum or uaccum mode. */ +#define ALL_ACCUM_MODE_P(MODE) \ + (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar/vector fract or accum mode. */ +#define SIGNED_FIXED_POINT_MODE_P(MODE) \ + (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar/vector ufract or uaccum mode. */ +#define UNSIGNED_FIXED_POINT_MODE_P(MODE) \ + (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE)) + +/* Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode. */ +#define ALL_FIXED_POINT_MODE_P(MODE) \ + (SIGNED_FIXED_POINT_MODE_P (MODE) \ + || UNSIGNED_FIXED_POINT_MODE_P (MODE)) + +/* Nonzero if CLASS modes can be widened. */ +#define CLASS_HAS_WIDER_MODES_P(CLASS) \ + (CLASS == MODE_INT \ + || CLASS == MODE_FLOAT \ + || CLASS == MODE_DECIMAL_FLOAT \ + || CLASS == MODE_COMPLEX_FLOAT \ + || CLASS == MODE_FRACT \ + || CLASS == MODE_UFRACT \ + || CLASS == MODE_ACCUM \ + || CLASS == MODE_UACCUM) + +/* Get the size in bytes and bits of an object of mode MODE. */ + +extern CONST_MODE_SIZE unsigned char mode_size[NUM_MACHINE_MODES]; +#define GET_MODE_SIZE(MODE) ((unsigned short) mode_size[MODE]) +#define GET_MODE_BITSIZE(MODE) ((unsigned short) (GET_MODE_SIZE (MODE) * BITS_PER_UNIT)) + +/* Get the number of value bits of an object of mode MODE. */ +extern const unsigned short mode_precision[NUM_MACHINE_MODES]; +#define GET_MODE_PRECISION(MODE) mode_precision[MODE] + +/* Get the number of integral bits of an object of mode MODE. */ +extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES]; +#define GET_MODE_IBIT(MODE) mode_ibit[MODE] + +/* Get the number of fractional bits of an object of mode MODE. */ +extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES]; +#define GET_MODE_FBIT(MODE) mode_fbit[MODE] + +/* Get a bitmask containing 1 for all bits in a word + that fit within mode MODE. */ + +extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES]; + +#define GET_MODE_MASK(MODE) mode_mask_array[MODE] + +/* Return the mode of the inner elements in a vector. */ + +extern const unsigned char mode_inner[NUM_MACHINE_MODES]; +#define GET_MODE_INNER(MODE) ((enum machine_mode) mode_inner[MODE]) + +/* Get the size in bytes of the basic parts of an object of mode MODE. */ + +#define GET_MODE_UNIT_SIZE(MODE) \ + (GET_MODE_INNER (MODE) == VOIDmode \ + ? GET_MODE_SIZE (MODE) \ + : GET_MODE_SIZE (GET_MODE_INNER (MODE))) + +/* Get the number of units in the object. */ + +extern const unsigned char mode_nunits[NUM_MACHINE_MODES]; +#define GET_MODE_NUNITS(MODE) mode_nunits[MODE] + +/* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */ + +extern const unsigned char mode_wider[NUM_MACHINE_MODES]; +#define GET_MODE_WIDER_MODE(MODE) ((enum machine_mode) mode_wider[MODE]) + +extern const unsigned char mode_2xwider[NUM_MACHINE_MODES]; +#define GET_MODE_2XWIDER_MODE(MODE) ((enum machine_mode) mode_2xwider[MODE]) + +/* Return the mode for data of a given size SIZE and mode class CLASS. + If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE. + The value is BLKmode if no other mode is found. */ + +extern enum machine_mode mode_for_size (unsigned int, enum mode_class, int); + +/* Similar, but find the smallest mode for a given width. */ + +extern enum machine_mode smallest_mode_for_size (unsigned int, + enum mode_class); + + +/* Return an integer mode of the exact same size as the input mode, + or BLKmode on failure. */ + +extern enum machine_mode int_mode_for_mode (enum machine_mode); + +/* Return a mode that is suitable for representing a vector, + or BLKmode on failure. */ + +extern enum machine_mode mode_for_vector (enum machine_mode, unsigned); + +/* Find the best mode to use to access a bit field. */ + +extern enum machine_mode get_best_mode (int, int, unsigned int, + enum machine_mode, int); + +/* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */ + +extern CONST_MODE_BASE_ALIGN unsigned char mode_base_align[NUM_MACHINE_MODES]; + +extern unsigned get_mode_alignment (enum machine_mode); + +#define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE) + +/* For each class, get the narrowest mode in that class. */ + +extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS]; +#define GET_CLASS_NARROWEST_MODE(CLASS) \ + ((enum machine_mode) class_narrowest_mode[CLASS]) + +/* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD + and the mode whose class is Pmode and whose size is POINTER_SIZE. */ + +extern enum machine_mode byte_mode; +extern enum machine_mode word_mode; +extern enum machine_mode ptr_mode; + +/* Target-dependent machine mode initialization - in insn-modes.c. */ +extern void init_adjust_machine_modes (void); + +#endif /* not HAVE_MACHINE_MODES */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/md5.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/md5.h new file mode 100644 index 0000000..b3ff4e1 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/md5.h @@ -0,0 +1,149 @@ +/* md5.h - Declaration of functions and data types used for MD5 sum + computing library functions. + Copyright 1995, 1996, 2000 Free Software Foundation, Inc. + NOTE: The canonical source of this file is maintained with the GNU C + Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. + + 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, 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 _MD5_H +#define _MD5_H 1 + +#include <stdio.h> + +#if defined HAVE_LIMITS_H || _LIBC +# include <limits.h> +#endif + +#include "ansidecl.h" + +/* The following contortions are an attempt to use the C preprocessor + to determine an unsigned integral type that is 32 bits wide. An + alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but + doing that would require that the configure script compile and *run* + the resulting executable. Locally running cross-compiled executables + is usually not possible. */ + +#ifdef _LIBC +# include <sys/types.h> +typedef u_int32_t md5_uint32; +typedef uintptr_t md5_uintptr; +#else +# define INT_MAX_32_BITS 2147483647 + +/* If UINT_MAX isn't defined, assume it's a 32-bit type. + This should be valid for all systems GNU cares about because + that doesn't include 16-bit systems, and only modern systems + (that certainly have <limits.h>) have 64+-bit integral types. */ + +# ifndef INT_MAX +# define INT_MAX INT_MAX_32_BITS +# endif + +# if INT_MAX == INT_MAX_32_BITS + typedef unsigned int md5_uint32; +# else +# if SHRT_MAX == INT_MAX_32_BITS + typedef unsigned short md5_uint32; +# else +# if LONG_MAX == INT_MAX_32_BITS + typedef unsigned long md5_uint32; +# else + /* The following line is intended to evoke an error. + Using #error is not portable enough. */ + "Cannot determine unsigned 32-bit data type." +# endif +# endif +# endif +/* We have to make a guess about the integer type equivalent in size + to pointers which should always be correct. */ +typedef unsigned long int md5_uintptr; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* Structure to save state of computation between the single steps. */ +struct md5_ctx +{ + md5_uint32 A; + md5_uint32 B; + md5_uint32 C; + md5_uint32 D; + + md5_uint32 total[2]; + md5_uint32 buflen; + char buffer[128] ATTRIBUTE_ALIGNED_ALIGNOF(md5_uint32); +}; + +/* + * The following three functions are build up the low level used in + * the functions `md5_stream' and `md5_buffer'. + */ + +/* Initialize structure containing state of computation. + (RFC 1321, 3.3: Step 3) */ +extern void md5_init_ctx (struct md5_ctx *ctx); + +/* Starting with the result of former calls of this function (or the + initialization function update the context for the next LEN bytes + starting at BUFFER. + It is necessary that LEN is a multiple of 64!!! */ +extern void md5_process_block (const void *buffer, size_t len, + struct md5_ctx *ctx); + +/* Starting with the result of former calls of this function (or the + initialization function update the context for the next LEN bytes + starting at BUFFER. + It is NOT required that LEN is a multiple of 64. */ +extern void md5_process_bytes (const void *buffer, size_t len, + struct md5_ctx *ctx); + +/* Process the remaining bytes in the buffer and put result from CTX + in first 16 bytes following RESBUF. The result is always in little + endian byte order, so that a byte-wise output yields to the wanted + ASCII representation of the message digest. + + IMPORTANT: On some systems it is required that RESBUF is correctly + aligned for a 32 bits value. */ +extern void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf); + + +/* Put result from CTX in first 16 bytes following RESBUF. The result is + always in little endian byte order, so that a byte-wise output yields + to the wanted ASCII representation of the message digest. + + IMPORTANT: On some systems it is required that RESBUF is correctly + aligned for a 32 bits value. */ +extern void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf); + + +/* Compute MD5 message digest for bytes read from STREAM. The + resulting message digest number will be written into the 16 bytes + beginning at RESBLOCK. */ +extern int md5_stream (FILE *stream, void *resblock); + +/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The + result is always in little endian byte order, so that a byte-wise + output yields to the wanted ASCII representation of the message + digest. */ +extern void *md5_buffer (const char *buffer, size_t len, void *resblock); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/mode-classes.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/mode-classes.def new file mode 100644 index 0000000..83017ec --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/mode-classes.def @@ -0,0 +1,39 @@ +/* Machine mode class definitions for GCC. + Copyright (C) 2003, 2007 + 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/>. */ + +#define MODE_CLASSES \ + DEF_MODE_CLASS (MODE_RANDOM), /* other */ \ + DEF_MODE_CLASS (MODE_CC), /* condition code in a register */ \ + DEF_MODE_CLASS (MODE_INT), /* integer */ \ + DEF_MODE_CLASS (MODE_PARTIAL_INT), /* integer with padding bits */ \ + DEF_MODE_CLASS (MODE_FRACT), /* signed fractional number */ \ + DEF_MODE_CLASS (MODE_UFRACT), /* unsigned fractional number */ \ + DEF_MODE_CLASS (MODE_ACCUM), /* signed accumulator */ \ + DEF_MODE_CLASS (MODE_UACCUM), /* unsigned accumulator */ \ + DEF_MODE_CLASS (MODE_FLOAT), /* floating point */ \ + DEF_MODE_CLASS (MODE_DECIMAL_FLOAT), /* decimal floating point */ \ + DEF_MODE_CLASS (MODE_COMPLEX_INT), /* complex numbers */ \ + DEF_MODE_CLASS (MODE_COMPLEX_FLOAT), \ + DEF_MODE_CLASS (MODE_VECTOR_INT), /* SIMD vectors */ \ + DEF_MODE_CLASS (MODE_VECTOR_FRACT), /* SIMD vectors */ \ + DEF_MODE_CLASS (MODE_VECTOR_UFRACT), /* SIMD vectors */ \ + DEF_MODE_CLASS (MODE_VECTOR_ACCUM), /* SIMD vectors */ \ + DEF_MODE_CLASS (MODE_VECTOR_UACCUM), /* SIMD vectors */ \ + DEF_MODE_CLASS (MODE_VECTOR_FLOAT) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/objc/objc-tree.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/objc/objc-tree.def new file mode 100644 index 0000000..5833e6a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/objc/objc-tree.def @@ -0,0 +1,77 @@ +/* This file contains the definitions and documentation for the + additional tree codes used in the Objective C front end (see tree.def + for the standard codes). + Copyright (C) 1990, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2007, 2010 + 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/>. */ + + +/* Objective-C types. */ +DEFTREECODE (CLASS_INTERFACE_TYPE, "class_interface_type", tcc_type, 0) +DEFTREECODE (CLASS_IMPLEMENTATION_TYPE, "class_implementation_type", + tcc_type, 0) +DEFTREECODE (CATEGORY_INTERFACE_TYPE, "category_interface_type", tcc_type, 0) +DEFTREECODE (CATEGORY_IMPLEMENTATION_TYPE,"category_implementation_type", + tcc_type, 0) +DEFTREECODE (PROTOCOL_INTERFACE_TYPE, "protocol_interface_type", tcc_type, 0) + +/* Objective-C decls. */ +DEFTREECODE (KEYWORD_DECL, "keyword_decl", tcc_declaration, 0) +DEFTREECODE (INSTANCE_METHOD_DECL, "instance_method_decl", tcc_declaration, 0) +DEFTREECODE (CLASS_METHOD_DECL, "class_method_decl", tcc_declaration, 0) +DEFTREECODE (PROPERTY_DECL, "property_decl", tcc_declaration, 0) + +/* Objective-C expressions. */ +DEFTREECODE (MESSAGE_SEND_EXPR, "message_send_expr", tcc_expression, 3) +DEFTREECODE (CLASS_REFERENCE_EXPR, "class_reference_expr", tcc_expression, 1) + +/* This tree is used to represent the expression 'object.property', + where 'object' is an Objective-C object and 'property' is an + Objective-C property. Operand 0 is the object (the tree + representing the expression), and Operand 1 is the property (the + PROPERTY_DECL). Operand 2 is the 'getter' call, ready to be used; + we pregenerate it because it is hard to generate it properly later + on. Operand 3 records whether using the 'getter' call should + generate a deprecation warning or not. + + A PROPERTY_REF tree needs to be transformed into 'setter' and + 'getter' calls at some point; at the moment this happens in two + places: + + * if we detect that a modify expression is being applied to a + PROPERTY_REF, then we transform that into a 'getter' call (this + happens in build_modify_expr() or cp_build_modify_expr()). + + * else, it will remain as a PROPERTY_REF until we get to + gimplification; at that point, we convert each PROPERTY_REF into + a 'getter' call during ObjC/ObjC++ gimplify. At that point, it + is quite hard to build a 'getter' call, but we have already built + it and we just need to swap Operand 2 in, and emit the deprecation + warnings from Operand 3 if needed. + + Please note that when the Objective-C 2.0 "dot-syntax" 'object.component' + is encountered, where 'component' is not a property but there are valid + setter/getter methods for it, an artificial PROPERTY_DECL is generated + and used in the PROPERTY_REF. */ +DEFTREECODE (PROPERTY_REF, "property_ref", tcc_expression, 4) + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/obstack.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/obstack.h new file mode 100644 index 0000000..4aec3a4 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/obstack.h @@ -0,0 +1,545 @@ +/* obstack.h - object stack macros + Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008 + Free Software Foundation, Inc. + + + NOTE: The canonical source of this file is maintained with the GNU C Library. + Bugs can be reported to bug-glibc@gnu.org. + + 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, 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. */ + +/* Summary: + +All the apparent functions defined here are macros. The idea +is that you would use these pre-tested macros to solve a +very specific set of problems, and they would run fast. +Caution: no side-effects in arguments please!! They may be +evaluated MANY times!! + +These macros operate a stack of objects. Each object starts life +small, and may grow to maturity. (Consider building a word syllable +by syllable.) An object can move while it is growing. Once it has +been "finished" it never changes address again. So the "top of the +stack" is typically an immature growing object, while the rest of the +stack is of mature, fixed size and fixed address objects. + +These routines grab large chunks of memory, using a function you +supply, called `obstack_chunk_alloc'. On occasion, they free chunks, +by calling `obstack_chunk_free'. You must define them and declare +them before using any obstack macros. + +Each independent stack is represented by a `struct obstack'. +Each of the obstack macros expects a pointer to such a structure +as the first argument. + +One motivation for this package is the problem of growing char strings +in symbol tables. Unless you are "fascist pig with a read-only mind" +--Gosper's immortal quote from HAKMEM item 154, out of context--you +would not like to put any arbitrary upper limit on the length of your +symbols. + +In practice this often means you will build many short symbols and a +few long symbols. At the time you are reading a symbol you don't know +how long it is. One traditional method is to read a symbol into a +buffer, realloc()ating the buffer every time you try to read a symbol +that is longer than the buffer. This is beaut, but you still will +want to copy the symbol from the buffer to a more permanent +symbol-table entry say about half the time. + +With obstacks, you can work differently. Use one obstack for all symbol +names. As you read a symbol, grow the name in the obstack gradually. +When the name is complete, finalize it. Then, if the symbol exists already, +free the newly read name. + +The way we do this is to take a large chunk, allocating memory from +low addresses. When you want to build a symbol in the chunk you just +add chars above the current "high water mark" in the chunk. When you +have finished adding chars, because you got to the end of the symbol, +you know how long the chars are, and you can create a new object. +Mostly the chars will not burst over the highest address of the chunk, +because you would typically expect a chunk to be (say) 100 times as +long as an average object. + +In case that isn't clear, when we have enough chars to make up +the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) +so we just point to it where it lies. No moving of chars is +needed and this is the second win: potentially long strings need +never be explicitly shuffled. Once an object is formed, it does not +change its address during its lifetime. + +When the chars burst over a chunk boundary, we allocate a larger +chunk, and then copy the partly formed object from the end of the old +chunk to the beginning of the new larger chunk. We then carry on +accreting characters to the end of the object as we normally would. + +A special macro is provided to add a single char at a time to a +growing object. This allows the use of register variables, which +break the ordinary 'growth' macro. + +Summary: + We allocate large chunks. + We carve out one object at a time from the current chunk. + Once carved, an object never moves. + We are free to append data of any size to the currently + growing object. + Exactly one object is growing in an obstack at any one time. + You can run one obstack per control block. + You may have as many control blocks as you dare. + Because of the way we do it, you can `unwind' an obstack + back to a previous state. (You may remove objects much + as you would with a stack.) +*/ + + +/* Don't do the contents of this file more than once. */ + +#ifndef _OBSTACK_H +#define _OBSTACK_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* We use subtraction of (char *) 0 instead of casting to int + because on word-addressable machines a simple cast to int + may ignore the byte-within-word field of the pointer. */ + +#ifndef __PTR_TO_INT +# define __PTR_TO_INT(P) ((P) - (char *) 0) +#endif + +#ifndef __INT_TO_PTR +# define __INT_TO_PTR(P) ((P) + (char *) 0) +#endif + +/* We need the type of the resulting object. If __PTRDIFF_TYPE__ is + defined, as with GNU C, use that; that way we don't pollute the + namespace with <stddef.h>'s symbols. Otherwise, if <stddef.h> is + available, include it and use ptrdiff_t. In traditional C, long is + the best that we can do. */ + +#ifdef __PTRDIFF_TYPE__ +# define PTR_INT_TYPE __PTRDIFF_TYPE__ +#else +# ifdef HAVE_STDDEF_H +# include <stddef.h> +# define PTR_INT_TYPE ptrdiff_t +# else +# define PTR_INT_TYPE long +# endif +#endif + +#if defined _LIBC || defined HAVE_STRING_H +# include <string.h> +# define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N)) +#else +# ifdef memcpy +# define _obstack_memcpy(To, From, N) memcpy ((To), (char *)(From), (N)) +# else +# define _obstack_memcpy(To, From, N) bcopy ((char *)(From), (To), (N)) +# endif +#endif + +struct _obstack_chunk /* Lives at front of each chunk. */ +{ + char *limit; /* 1 past end of this chunk */ + struct _obstack_chunk *prev; /* address of prior chunk or NULL */ + char contents[4]; /* objects begin here */ +}; + +struct obstack /* control current object in current chunk */ +{ + long chunk_size; /* preferred size to allocate chunks in */ + struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */ + char *object_base; /* address of object we are building */ + char *next_free; /* where to add next char to current object */ + char *chunk_limit; /* address of char after current chunk */ + PTR_INT_TYPE temp; /* Temporary for some macros. */ + int alignment_mask; /* Mask of alignment for each object. */ + /* These prototypes vary based on `use_extra_arg', and we use + casts to the prototypeless function type in all assignments, + but having prototypes here quiets -Wstrict-prototypes. */ + struct _obstack_chunk *(*chunkfun) (void *, long); + void (*freefun) (void *, struct _obstack_chunk *); + void *extra_arg; /* first arg for chunk alloc/dealloc funcs */ + unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */ + unsigned maybe_empty_object:1;/* There is a possibility that the current + chunk contains a zero-length object. This + prevents freeing the chunk if we allocate + a bigger chunk to replace it. */ + unsigned alloc_failed:1; /* No longer used, as we now call the failed + handler on error, but retained for binary + compatibility. */ +}; + +/* Declare the external functions we use; they are in obstack.c. */ + +extern void _obstack_newchunk (struct obstack *, int); +extern void _obstack_free (struct obstack *, void *); +extern int _obstack_begin (struct obstack *, int, int, + void *(*) (long), void (*) (void *)); +extern int _obstack_begin_1 (struct obstack *, int, int, + void *(*) (void *, long), + void (*) (void *, void *), void *); +extern int _obstack_memory_used (struct obstack *); + +/* Do the function-declarations after the structs + but before defining the macros. */ + +void obstack_init (struct obstack *obstack); + +void * obstack_alloc (struct obstack *obstack, int size); + +void * obstack_copy (struct obstack *obstack, void *address, int size); +void * obstack_copy0 (struct obstack *obstack, void *address, int size); + +void obstack_free (struct obstack *obstack, void *block); + +void obstack_blank (struct obstack *obstack, int size); + +void obstack_grow (struct obstack *obstack, void *data, int size); +void obstack_grow0 (struct obstack *obstack, void *data, int size); + +void obstack_1grow (struct obstack *obstack, int data_char); +void obstack_ptr_grow (struct obstack *obstack, void *data); +void obstack_int_grow (struct obstack *obstack, int data); + +void * obstack_finish (struct obstack *obstack); + +int obstack_object_size (struct obstack *obstack); + +int obstack_room (struct obstack *obstack); +void obstack_make_room (struct obstack *obstack, int size); +void obstack_1grow_fast (struct obstack *obstack, int data_char); +void obstack_ptr_grow_fast (struct obstack *obstack, void *data); +void obstack_int_grow_fast (struct obstack *obstack, int data); +void obstack_blank_fast (struct obstack *obstack, int size); + +void * obstack_base (struct obstack *obstack); +void * obstack_next_free (struct obstack *obstack); +int obstack_alignment_mask (struct obstack *obstack); +int obstack_chunk_size (struct obstack *obstack); +int obstack_memory_used (struct obstack *obstack); + +/* Error handler called when `obstack_chunk_alloc' failed to allocate + more memory. This can be set to a user defined function. The + default action is to print a message and abort. */ +extern void (*obstack_alloc_failed_handler) (void); + +/* Exit value used when `print_and_abort' is used. */ +extern int obstack_exit_failure; + +/* Pointer to beginning of object being allocated or to be allocated next. + Note that this might not be the final address of the object + because a new chunk might be needed to hold the final size. */ + +#define obstack_base(h) ((h)->object_base) + +/* Size for allocating ordinary chunks. */ + +#define obstack_chunk_size(h) ((h)->chunk_size) + +/* Pointer to next byte not yet allocated in current chunk. */ + +#define obstack_next_free(h) ((h)->next_free) + +/* Mask specifying low bits that should be clear in address of an object. */ + +#define obstack_alignment_mask(h) ((h)->alignment_mask) + +/* To prevent prototype warnings provide complete argument list in + standard C version. */ +# define obstack_init(h) \ + _obstack_begin ((h), 0, 0, \ + (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free) + +# define obstack_begin(h, size) \ + _obstack_begin ((h), (size), 0, \ + (void *(*) (long)) obstack_chunk_alloc, (void (*) (void *)) obstack_chunk_free) + +# define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ + _obstack_begin ((h), (size), (alignment), \ + (void *(*) (long)) (chunkfun), (void (*) (void *)) (freefun)) + +# define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ + _obstack_begin_1 ((h), (size), (alignment), \ + (void *(*) (void *, long)) (chunkfun), \ + (void (*) (void *, void *)) (freefun), (arg)) + +# define obstack_chunkfun(h, newchunkfun) \ + ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun)) + +# define obstack_freefun(h, newfreefun) \ + ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun)) + +#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = (achar)) + +#define obstack_blank_fast(h,n) ((h)->next_free += (n)) + +#define obstack_memory_used(h) _obstack_memory_used (h) + +#if defined __GNUC__ && defined __STDC__ && __STDC__ +/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and + does not implement __extension__. But that compiler doesn't define + __GNUC_MINOR__. */ +# if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__) +# define __extension__ +# endif + +/* For GNU C, if not -traditional, + we can define these macros to compute all args only once + without using a global variable. + Also, we can avoid using the `temp' slot, to make faster code. */ + +# define obstack_object_size(OBSTACK) \ + __extension__ \ + ({ struct obstack *__o = (OBSTACK); \ + (unsigned) (__o->next_free - __o->object_base); }) + +# define obstack_room(OBSTACK) \ + __extension__ \ + ({ struct obstack *__o = (OBSTACK); \ + (unsigned) (__o->chunk_limit - __o->next_free); }) + +# define obstack_make_room(OBSTACK,length) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + if (__o->chunk_limit - __o->next_free < __len) \ + _obstack_newchunk (__o, __len); \ + (void) 0; }) + +# define obstack_empty_p(OBSTACK) \ + __extension__ \ + ({ struct obstack *__o = (OBSTACK); \ + (__o->chunk->prev == 0 && __o->next_free - __o->chunk->contents == 0); }) + +# define obstack_grow(OBSTACK,where,length) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + if (__o->next_free + __len > __o->chunk_limit) \ + _obstack_newchunk (__o, __len); \ + _obstack_memcpy (__o->next_free, (where), __len); \ + __o->next_free += __len; \ + (void) 0; }) + +# define obstack_grow0(OBSTACK,where,length) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + if (__o->next_free + __len + 1 > __o->chunk_limit) \ + _obstack_newchunk (__o, __len + 1); \ + _obstack_memcpy (__o->next_free, (where), __len); \ + __o->next_free += __len; \ + *(__o->next_free)++ = 0; \ + (void) 0; }) + +# define obstack_1grow(OBSTACK,datum) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + if (__o->next_free + 1 > __o->chunk_limit) \ + _obstack_newchunk (__o, 1); \ + obstack_1grow_fast (__o, datum); \ + (void) 0; }) + +/* These assume that the obstack alignment is good enough for pointers or ints, + and that the data added so far to the current object + shares that much alignment. */ + +# define obstack_ptr_grow(OBSTACK,datum) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + if (__o->next_free + sizeof (void *) > __o->chunk_limit) \ + _obstack_newchunk (__o, sizeof (void *)); \ + obstack_ptr_grow_fast (__o, datum); }) + +# define obstack_int_grow(OBSTACK,datum) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + if (__o->next_free + sizeof (int) > __o->chunk_limit) \ + _obstack_newchunk (__o, sizeof (int)); \ + obstack_int_grow_fast (__o, datum); }) + +# define obstack_ptr_grow_fast(OBSTACK,aptr) \ +__extension__ \ +({ struct obstack *__o1 = (OBSTACK); \ + *(const void **) __o1->next_free = (aptr); \ + __o1->next_free += sizeof (const void *); \ + (void) 0; }) + +# define obstack_int_grow_fast(OBSTACK,aint) \ +__extension__ \ +({ struct obstack *__o1 = (OBSTACK); \ + *(int *) __o1->next_free = (aint); \ + __o1->next_free += sizeof (int); \ + (void) 0; }) + +# define obstack_blank(OBSTACK,length) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + if (__o->chunk_limit - __o->next_free < __len) \ + _obstack_newchunk (__o, __len); \ + obstack_blank_fast (__o, __len); \ + (void) 0; }) + +# define obstack_alloc(OBSTACK,length) \ +__extension__ \ +({ struct obstack *__h = (OBSTACK); \ + obstack_blank (__h, (length)); \ + obstack_finish (__h); }) + +# define obstack_copy(OBSTACK,where,length) \ +__extension__ \ +({ struct obstack *__h = (OBSTACK); \ + obstack_grow (__h, (where), (length)); \ + obstack_finish (__h); }) + +# define obstack_copy0(OBSTACK,where,length) \ +__extension__ \ +({ struct obstack *__h = (OBSTACK); \ + obstack_grow0 (__h, (where), (length)); \ + obstack_finish (__h); }) + +/* The local variable is named __o1 to avoid a name conflict + when obstack_blank is called. */ +# define obstack_finish(OBSTACK) \ +__extension__ \ +({ struct obstack *__o1 = (OBSTACK); \ + void *value; \ + value = (void *) __o1->object_base; \ + if (__o1->next_free == value) \ + __o1->maybe_empty_object = 1; \ + __o1->next_free \ + = __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\ + & ~ (__o1->alignment_mask)); \ + if (__o1->next_free - (char *)__o1->chunk \ + > __o1->chunk_limit - (char *)__o1->chunk) \ + __o1->next_free = __o1->chunk_limit; \ + __o1->object_base = __o1->next_free; \ + value; }) + +# define obstack_free(OBSTACK, OBJ) \ +__extension__ \ +({ struct obstack *__o = (OBSTACK); \ + void *__obj = (void *) (OBJ); \ + if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ + __o->next_free = __o->object_base = (char *) __obj; \ + else (obstack_free) (__o, __obj); }) + +#else /* not __GNUC__ or not __STDC__ */ + +# define obstack_object_size(h) \ + (unsigned) ((h)->next_free - (h)->object_base) + +# define obstack_room(h) \ + (unsigned) ((h)->chunk_limit - (h)->next_free) + +# define obstack_empty_p(h) \ + ((h)->chunk->prev == 0 && (h)->next_free - (h)->chunk->contents == 0) + +/* Note that the call to _obstack_newchunk is enclosed in (..., 0) + so that we can avoid having void expressions + in the arms of the conditional expression. + Casting the third operand to void was tried before, + but some compilers won't accept it. */ + +# define obstack_make_room(h,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp > (h)->chunk_limit) \ + ? (_obstack_newchunk ((h), (h)->temp), 0) : 0)) + +# define obstack_grow(h,where,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp > (h)->chunk_limit) \ + ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ + _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ + (h)->next_free += (h)->temp) + +# define obstack_grow0(h,where,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ + ? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \ + _obstack_memcpy ((h)->next_free, (where), (h)->temp), \ + (h)->next_free += (h)->temp, \ + *((h)->next_free)++ = 0) + +# define obstack_1grow(h,datum) \ +( (((h)->next_free + 1 > (h)->chunk_limit) \ + ? (_obstack_newchunk ((h), 1), 0) : 0), \ + obstack_1grow_fast (h, datum)) + +# define obstack_ptr_grow(h,datum) \ +( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ + ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \ + obstack_ptr_grow_fast (h, datum)) + +# define obstack_int_grow(h,datum) \ +( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ + ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ + obstack_int_grow_fast (h, datum)) + +# define obstack_ptr_grow_fast(h,aptr) \ + (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr)) + +# define obstack_int_grow_fast(h,aint) \ + (((int *) ((h)->next_free += sizeof (int)))[-1] = (aptr)) + +# define obstack_blank(h,length) \ +( (h)->temp = (length), \ + (((h)->chunk_limit - (h)->next_free < (h)->temp) \ + ? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \ + obstack_blank_fast (h, (h)->temp)) + +# define obstack_alloc(h,length) \ + (obstack_blank ((h), (length)), obstack_finish ((h))) + +# define obstack_copy(h,where,length) \ + (obstack_grow ((h), (where), (length)), obstack_finish ((h))) + +# define obstack_copy0(h,where,length) \ + (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) + +# define obstack_finish(h) \ +( ((h)->next_free == (h)->object_base \ + ? (((h)->maybe_empty_object = 1), 0) \ + : 0), \ + (h)->temp = __PTR_TO_INT ((h)->object_base), \ + (h)->next_free \ + = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ + & ~ ((h)->alignment_mask)), \ + (((h)->next_free - (char *) (h)->chunk \ + > (h)->chunk_limit - (char *) (h)->chunk) \ + ? ((h)->next_free = (h)->chunk_limit) : 0), \ + (h)->object_base = (h)->next_free, \ + (void *) __INT_TO_PTR ((h)->temp)) + +# define obstack_free(h,obj) \ +( (h)->temp = (char *) (obj) - (char *) (h)->chunk, \ + (((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ + ? (int) ((h)->next_free = (h)->object_base \ + = (h)->temp + (char *) (h)->chunk) \ + : (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0))) + +#endif /* not __GNUC__ or not __STDC__ */ + +#ifdef __cplusplus +} /* C++ */ +#endif + +#endif /* obstack.h */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/omp-builtins.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/omp-builtins.def new file mode 100644 index 0000000..125b76c --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/omp-builtins.def @@ -0,0 +1,208 @@ +/* This file contains the definitions and documentation for the + OpenMP builtins used in the GNU compiler. + Copyright (C) 2005, 2007, 2008, 2010 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, you should define a macro: + + DEF_GOMP_BUILTIN (ENUM, NAME, TYPE, ATTRS) + + See builtins.def for details. */ + +DEF_GOMP_BUILTIN (BUILT_IN_OMP_GET_THREAD_NUM, "omp_get_thread_num", + BT_FN_INT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_OMP_GET_NUM_THREADS, "omp_get_num_threads", + BT_FN_INT, ATTR_CONST_NOTHROW_LEAF_LIST) + +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_ATOMIC_START, "GOMP_atomic_start", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_ATOMIC_END, "GOMP_atomic_end", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_BARRIER, "GOMP_barrier", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_TASKWAIT, "GOMP_taskwait", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_CRITICAL_START, "GOMP_critical_start", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_CRITICAL_END, "GOMP_critical_end", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_CRITICAL_NAME_START, + "GOMP_critical_name_start", + BT_FN_VOID_PTRPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_CRITICAL_NAME_END, + "GOMP_critical_name_end", + BT_FN_VOID_PTRPTR, ATTR_NOTHROW_LEAF_LIST) +/* NOTE: Do not change the order of BUILT_IN_GOMP_LOOP_*_START. They + are used in index arithmetic with enum omp_clause_schedule_kind + in omp-low.c. */ +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_STATIC_START, + "GOMP_loop_static_start", + BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_DYNAMIC_START, + "GOMP_loop_dynamic_start", + BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_GUIDED_START, + "GOMP_loop_guided_start", + BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_RUNTIME_START, + "GOMP_loop_runtime_start", + BT_FN_BOOL_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_STATIC_START, + "GOMP_loop_ordered_static_start", + BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_START, + "GOMP_loop_ordered_dynamic_start", + BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_START, + "GOMP_loop_ordered_guided_start", + BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_START, + "GOMP_loop_ordered_runtime_start", + BT_FN_BOOL_LONG_LONG_LONG_LONGPTR_LONGPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_STATIC_NEXT, "GOMP_loop_static_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_DYNAMIC_NEXT, "GOMP_loop_dynamic_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_GUIDED_NEXT, "GOMP_loop_guided_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_RUNTIME_NEXT, "GOMP_loop_runtime_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_STATIC_NEXT, + "GOMP_loop_ordered_static_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_DYNAMIC_NEXT, + "GOMP_loop_ordered_dynamic_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_GUIDED_NEXT, + "GOMP_loop_ordered_guided_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ORDERED_RUNTIME_NEXT, + "GOMP_loop_ordered_runtime_next", + BT_FN_BOOL_LONGPTR_LONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_STATIC_START, + "GOMP_loop_ull_static_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_START, + "GOMP_loop_ull_dynamic_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_GUIDED_START, + "GOMP_loop_ull_guided_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_RUNTIME_START, + "GOMP_loop_ull_runtime_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_START, + "GOMP_loop_ull_ordered_static_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START, + "GOMP_loop_ull_ordered_dynamic_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_START, + "GOMP_loop_ull_ordered_guided_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_START, + "GOMP_loop_ull_ordered_runtime_start", + BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULLPTR_ULLPTR, + ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_STATIC_NEXT, "GOMP_loop_ull_static_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_DYNAMIC_NEXT, "GOMP_loop_ull_dynamic_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_GUIDED_NEXT, "GOMP_loop_ull_guided_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_RUNTIME_NEXT, "GOMP_loop_ull_runtime_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT, + "GOMP_loop_ull_ordered_static_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT, + "GOMP_loop_ull_ordered_dynamic_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT, + "GOMP_loop_ull_ordered_guided_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT, + "GOMP_loop_ull_ordered_runtime_next", + BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) +/* NOTE: Do not change the order of BUILT_IN_GOMP_PARALLEL_LOOP_*_START. + They are used in index arithmetic with enum omp_clause_schedule_kind + in omp-low.c. */ +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_LOOP_STATIC_START, + "GOMP_parallel_loop_static_start", + BT_FN_VOID_OMPFN_PTR_UINT_LONG_LONG_LONG_LONG, + ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_LOOP_DYNAMIC_START, + "GOMP_parallel_loop_dynamic_start", + BT_FN_VOID_OMPFN_PTR_UINT_LONG_LONG_LONG_LONG, + ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_LOOP_GUIDED_START, + "GOMP_parallel_loop_guided_start", + BT_FN_VOID_OMPFN_PTR_UINT_LONG_LONG_LONG_LONG, + ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_LOOP_RUNTIME_START, + "GOMP_parallel_loop_runtime_start", + BT_FN_VOID_OMPFN_PTR_UINT_LONG_LONG_LONG, + ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_END, "GOMP_loop_end", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_END_NOWAIT, "GOMP_loop_end_nowait", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_ORDERED_START, "GOMP_ordered_start", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_ORDERED_END, "GOMP_ordered_end", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_START, "GOMP_parallel_start", + BT_FN_VOID_OMPFN_PTR_UINT, ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_END, "GOMP_parallel_end", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_TASK, "GOMP_task", + BT_FN_VOID_OMPFN_PTR_OMPCPYFN_LONG_LONG_BOOL_UINT, + ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SECTIONS_START, "GOMP_sections_start", + BT_FN_UINT_UINT, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SECTIONS_NEXT, "GOMP_sections_next", + BT_FN_UINT, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_SECTIONS_START, + "GOMP_parallel_sections_start", + BT_FN_VOID_OMPFN_PTR_UINT_UINT, ATTR_NOTHROW_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SECTIONS_END, "GOMP_sections_end", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SECTIONS_END_NOWAIT, + "GOMP_sections_end_nowait", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SINGLE_START, "GOMP_single_start", + BT_FN_BOOL, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SINGLE_COPY_START, "GOMP_single_copy_start", + BT_FN_PTR, ATTR_NOTHROW_LEAF_LIST) +DEF_GOMP_BUILTIN (BUILT_IN_GOMP_SINGLE_COPY_END, "GOMP_single_copy_end", + BT_FN_VOID_PTR, ATTR_NOTHROW_LEAF_LIST) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/options.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/options.h new file mode 100644 index 0000000..4318647 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/options.h @@ -0,0 +1,4834 @@ +/* This file is auto-generated by opth-gen.awk. */ + +#ifndef OPTIONS_H +#define OPTIONS_H + +#include "flag-types.h" + +#if !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) && !defined(IN_RTS) +#ifndef GENERATOR_FILE +#if !defined(GCC_DRIVER) && !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) +struct GTY(()) gcc_options +#else +struct gcc_options +#endif +{ +#endif +#ifdef GENERATOR_FILE +extern HOST_WIDE_INT frame_larger_than_size; +#else + HOST_WIDE_INT x_frame_larger_than_size; +#define frame_larger_than_size global_options.x_frame_larger_than_size +#endif +#ifdef GENERATOR_FILE +extern HOST_WIDE_INT larger_than_size; +#else + HOST_WIDE_INT x_larger_than_size; +#define larger_than_size global_options.x_larger_than_size +#endif +#ifdef GENERATOR_FILE +extern bool exit_after_options; +#else + bool x_exit_after_options; +#define exit_after_options global_options.x_exit_after_options +#endif +#ifdef GENERATOR_FILE +extern bool flag_dump_all_passed; +#else + bool x_flag_dump_all_passed; +#define flag_dump_all_passed global_options.x_flag_dump_all_passed +#endif +#ifdef GENERATOR_FILE +extern bool flag_opts_finished; +#else + bool x_flag_opts_finished; +#define flag_opts_finished global_options.x_flag_opts_finished +#endif +#ifdef GENERATOR_FILE +extern bool flag_warn_unused_result; +#else + bool x_flag_warn_unused_result; +#define flag_warn_unused_result global_options.x_flag_warn_unused_result +#endif +#ifdef GENERATOR_FILE +extern bool generate_debug_line_table; +#else + bool x_generate_debug_line_table; +#define generate_debug_line_table global_options.x_generate_debug_line_table +#endif +#ifdef GENERATOR_FILE +extern bool use_gnu_debug_info_extensions; +#else + bool x_use_gnu_debug_info_extensions; +#define use_gnu_debug_info_extensions global_options.x_use_gnu_debug_info_extensions +#endif +#ifdef GENERATOR_FILE +extern bool warn_frame_larger_than; +#else + bool x_warn_frame_larger_than; +#define warn_frame_larger_than global_options.x_warn_frame_larger_than +#endif +#ifdef GENERATOR_FILE +extern bool warn_larger_than; +#else + bool x_warn_larger_than; +#define warn_larger_than global_options.x_warn_larger_than +#endif +#ifdef GENERATOR_FILE +extern char *help_enum_printed; +#else + char * x_help_enum_printed; +#define help_enum_printed global_options.x_help_enum_printed +#endif +#ifdef GENERATOR_FILE +extern char *help_printed; +#else + char * x_help_printed; +#define help_printed global_options.x_help_printed +#endif +#ifdef GENERATOR_FILE +extern const char *main_input_basename; +#else + const char * x_main_input_basename; +#define main_input_basename global_options.x_main_input_basename +#endif +#ifdef GENERATOR_FILE +extern const char *main_input_filename; +#else + const char * x_main_input_filename; +#define main_input_filename global_options.x_main_input_filename +#endif +#ifdef GENERATOR_FILE +extern enum debug_info_levels debug_info_level; +#else + enum debug_info_levels x_debug_info_level; +#define debug_info_level global_options.x_debug_info_level +#endif +#ifdef GENERATOR_FILE +extern enum debug_info_type write_symbols; +#else + enum debug_info_type x_write_symbols; +#define write_symbols global_options.x_write_symbols +#endif +#ifdef GENERATOR_FILE +extern enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]; +#else + enum debug_struct_file x_debug_struct_generic[DINFO_USAGE_NUM_ENUMS]; +#define debug_struct_generic global_options.x_debug_struct_generic +#endif +#ifdef GENERATOR_FILE +extern enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]; +#else + enum debug_struct_file x_debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]; +#define debug_struct_ordinary global_options.x_debug_struct_ordinary +#endif +#ifdef GENERATOR_FILE +extern enum graph_dump_types graph_dump_format; +#else + enum graph_dump_types x_graph_dump_format; +#define graph_dump_format global_options.x_graph_dump_format +#endif +#ifdef GENERATOR_FILE +extern enum stack_check_type flag_stack_check; +#else + enum stack_check_type x_flag_stack_check; +#define flag_stack_check global_options.x_flag_stack_check +#endif +#ifdef GENERATOR_FILE +extern enum vect_verbosity_levels user_vect_verbosity_level; +#else + enum vect_verbosity_levels x_user_vect_verbosity_level; +#define user_vect_verbosity_level global_options.x_user_vect_verbosity_level +#endif +#ifdef GENERATOR_FILE +extern int *param_values; +#else + int * x_param_values; +#define param_values global_options.x_param_values +#endif +#ifdef GENERATOR_FILE +extern int flag_complex_method; +#else + int x_flag_complex_method; +#define flag_complex_method global_options.x_flag_complex_method +#endif +#ifdef GENERATOR_FILE +extern int flag_debug_asm; +#else + int x_flag_debug_asm; +#define flag_debug_asm global_options.x_flag_debug_asm +#endif +#ifdef GENERATOR_FILE +extern int flag_dump_rtl_in_asm; +#else + int x_flag_dump_rtl_in_asm; +#define flag_dump_rtl_in_asm global_options.x_flag_dump_rtl_in_asm +#endif +#ifdef GENERATOR_FILE +extern int flag_evaluation_order; +#else + int x_flag_evaluation_order; +#define flag_evaluation_order global_options.x_flag_evaluation_order +#endif +#ifdef GENERATOR_FILE +extern int flag_gen_aux_info; +#else + int x_flag_gen_aux_info; +#define flag_gen_aux_info global_options.x_flag_gen_aux_info +#endif +#ifdef GENERATOR_FILE +extern int flag_generate_lto; +#else + int x_flag_generate_lto; +#define flag_generate_lto global_options.x_flag_generate_lto +#endif +#ifdef GENERATOR_FILE +extern int flag_print_asm_name; +#else + int x_flag_print_asm_name; +#define flag_print_asm_name global_options.x_flag_print_asm_name +#endif +#ifdef GENERATOR_FILE +extern int flag_shlib; +#else + int x_flag_shlib; +#define flag_shlib global_options.x_flag_shlib +#endif +#ifdef GENERATOR_FILE +extern int main_input_baselength; +#else + int x_main_input_baselength; +#define main_input_baselength global_options.x_main_input_baselength +#endif +#ifdef GENERATOR_FILE +extern int optimize; +#else + int x_optimize; +#define optimize global_options.x_optimize +#endif +#ifdef GENERATOR_FILE +extern int optimize_fast; +#else + int x_optimize_fast; +#define optimize_fast global_options.x_optimize_fast +#endif +#ifdef GENERATOR_FILE +extern int optimize_size; +#else + int x_optimize_size; +#define optimize_size global_options.x_optimize_size +#endif +#ifdef GENERATOR_FILE +extern int rtl_dump_and_exit; +#else + int x_rtl_dump_and_exit; +#define rtl_dump_and_exit global_options.x_rtl_dump_and_exit +#endif +#ifdef GENERATOR_FILE +extern int target_flags; +#else + int x_target_flags; +#define target_flags global_options.x_target_flags +#endif +#ifdef GENERATOR_FILE +extern unsigned int help_columns; +#else + unsigned int x_help_columns; +#define help_columns global_options.x_help_columns +#endif +#ifdef GENERATOR_FILE +extern unsigned int initial_max_fld_align; +#else + unsigned int x_initial_max_fld_align; +#define initial_max_fld_align global_options.x_initial_max_fld_align +#endif +#ifdef GENERATOR_FILE +extern void *flag_instrument_functions_exclude_files; +#else + void * x_flag_instrument_functions_exclude_files; +#define flag_instrument_functions_exclude_files global_options.x_flag_instrument_functions_exclude_files +#endif +#ifdef GENERATOR_FILE +extern void *flag_instrument_functions_exclude_functions; +#else + void * x_flag_instrument_functions_exclude_functions; +#define flag_instrument_functions_exclude_functions global_options.x_flag_instrument_functions_exclude_functions +#endif +#ifdef GENERATOR_FILE +extern int help_flag; +#else + int x_help_flag; +#define help_flag global_options.x_help_flag +#endif +#ifdef GENERATOR_FILE +extern int flag_preprocess_only; +#else + int x_flag_preprocess_only; +#define flag_preprocess_only global_options.x_flag_preprocess_only +#endif +#ifdef GENERATOR_FILE +extern int warn_abi; +#else + int x_warn_abi; +#define warn_abi global_options.x_warn_abi +#endif +#ifdef GENERATOR_FILE +extern int warn_address; +#else + int x_warn_address; +#define warn_address global_options.x_warn_address +#endif +#ifdef GENERATOR_FILE +extern int warn_aggregate_return; +#else + int x_warn_aggregate_return; +#define warn_aggregate_return global_options.x_warn_aggregate_return +#endif +#ifdef GENERATOR_FILE +extern int warn_array_bounds; +#else + int x_warn_array_bounds; +#define warn_array_bounds global_options.x_warn_array_bounds +#endif +#ifdef GENERATOR_FILE +extern int warn_assign_intercept; +#else + int x_warn_assign_intercept; +#define warn_assign_intercept global_options.x_warn_assign_intercept +#endif +#ifdef GENERATOR_FILE +extern int warn_attributes; +#else + int x_warn_attributes; +#define warn_attributes global_options.x_warn_attributes +#endif +#ifdef GENERATOR_FILE +extern int warn_bad_function_cast; +#else + int x_warn_bad_function_cast; +#define warn_bad_function_cast global_options.x_warn_bad_function_cast +#endif +#ifdef GENERATOR_FILE +extern int warn_cxx_compat; +#else + int x_warn_cxx_compat; +#define warn_cxx_compat global_options.x_warn_cxx_compat +#endif +#ifdef GENERATOR_FILE +extern int warn_cxx0x_compat; +#else + int x_warn_cxx0x_compat; +#define warn_cxx0x_compat global_options.x_warn_cxx0x_compat +#endif +#ifdef GENERATOR_FILE +extern int warn_cast_align; +#else + int x_warn_cast_align; +#define warn_cast_align global_options.x_warn_cast_align +#endif +#ifdef GENERATOR_FILE +extern int warn_cast_qual; +#else + int x_warn_cast_qual; +#define warn_cast_qual global_options.x_warn_cast_qual +#endif +#ifdef GENERATOR_FILE +extern int warn_char_subscripts; +#else + int x_warn_char_subscripts; +#define warn_char_subscripts global_options.x_warn_char_subscripts +#endif +#ifdef GENERATOR_FILE +extern int warn_clobbered; +#else + int x_warn_clobbered; +#define warn_clobbered global_options.x_warn_clobbered +#endif +#ifdef GENERATOR_FILE +extern int warn_conversion; +#else + int x_warn_conversion; +#define warn_conversion global_options.x_warn_conversion +#endif +#ifdef GENERATOR_FILE +extern int warn_conversion_null; +#else + int x_warn_conversion_null; +#define warn_conversion_null global_options.x_warn_conversion_null +#endif +#ifdef GENERATOR_FILE +extern int warn_coverage_mismatch; +#else + int x_warn_coverage_mismatch; +#define warn_coverage_mismatch global_options.x_warn_coverage_mismatch +#endif +#ifdef GENERATOR_FILE +extern int warn_cpp; +#else + int x_warn_cpp; +#define warn_cpp global_options.x_warn_cpp +#endif +#ifdef GENERATOR_FILE +extern int warn_ctor_dtor_privacy; +#else + int x_warn_ctor_dtor_privacy; +#define warn_ctor_dtor_privacy global_options.x_warn_ctor_dtor_privacy +#endif +#ifdef GENERATOR_FILE +extern int warn_declaration_after_statement; +#else + int x_warn_declaration_after_statement; +#define warn_declaration_after_statement global_options.x_warn_declaration_after_statement +#endif +#ifdef GENERATOR_FILE +extern int warn_deprecated; +#else + int x_warn_deprecated; +#define warn_deprecated global_options.x_warn_deprecated +#endif +#ifdef GENERATOR_FILE +extern int warn_deprecated_decl; +#else + int x_warn_deprecated_decl; +#define warn_deprecated_decl global_options.x_warn_deprecated_decl +#endif +#ifdef GENERATOR_FILE +extern int warn_disabled_optimization; +#else + int x_warn_disabled_optimization; +#define warn_disabled_optimization global_options.x_warn_disabled_optimization +#endif +#ifdef GENERATOR_FILE +extern int warn_div_by_zero; +#else + int x_warn_div_by_zero; +#define warn_div_by_zero global_options.x_warn_div_by_zero +#endif +#ifdef GENERATOR_FILE +extern int warn_double_promotion; +#else + int x_warn_double_promotion; +#define warn_double_promotion global_options.x_warn_double_promotion +#endif +#ifdef GENERATOR_FILE +extern int warn_ecpp; +#else + int x_warn_ecpp; +#define warn_ecpp global_options.x_warn_ecpp +#endif +#ifdef GENERATOR_FILE +extern int warn_empty_body; +#else + int x_warn_empty_body; +#define warn_empty_body global_options.x_warn_empty_body +#endif +#ifdef GENERATOR_FILE +extern int warn_enum_compare; +#else + int x_warn_enum_compare; +#define warn_enum_compare global_options.x_warn_enum_compare +#endif +#ifdef GENERATOR_FILE +extern int warnings_are_errors; +#else + int x_warnings_are_errors; +#define warnings_are_errors global_options.x_warnings_are_errors +#endif +#ifdef GENERATOR_FILE +extern int extra_warnings; +#else + int x_extra_warnings; +#define extra_warnings global_options.x_extra_warnings +#endif +#ifdef GENERATOR_FILE +extern int flag_extraneous_semicolon; +#else + int x_flag_extraneous_semicolon; +#define flag_extraneous_semicolon global_options.x_flag_extraneous_semicolon +#endif +#ifdef GENERATOR_FILE +extern int flag_fatal_errors; +#else + int x_flag_fatal_errors; +#define flag_fatal_errors global_options.x_flag_fatal_errors +#endif +#ifdef GENERATOR_FILE +extern int warn_float_equal; +#else + int x_warn_float_equal; +#define warn_float_equal global_options.x_warn_float_equal +#endif +#ifdef GENERATOR_FILE +extern int warn_format_contains_nul; +#else + int x_warn_format_contains_nul; +#define warn_format_contains_nul global_options.x_warn_format_contains_nul +#endif +#ifdef GENERATOR_FILE +extern int warn_format_extra_args; +#else + int x_warn_format_extra_args; +#define warn_format_extra_args global_options.x_warn_format_extra_args +#endif +#ifdef GENERATOR_FILE +extern int warn_format_nonliteral; +#else + int x_warn_format_nonliteral; +#define warn_format_nonliteral global_options.x_warn_format_nonliteral +#endif +#ifdef GENERATOR_FILE +extern int warn_format_security; +#else + int x_warn_format_security; +#define warn_format_security global_options.x_warn_format_security +#endif +#ifdef GENERATOR_FILE +extern int warn_format_y2k; +#else + int x_warn_format_y2k; +#define warn_format_y2k global_options.x_warn_format_y2k +#endif +#ifdef GENERATOR_FILE +extern int warn_format_zero_length; +#else + int x_warn_format_zero_length; +#define warn_format_zero_length global_options.x_warn_format_zero_length +#endif +#ifdef GENERATOR_FILE +extern int warn_ignored_qualifiers; +#else + int x_warn_ignored_qualifiers; +#define warn_ignored_qualifiers global_options.x_warn_ignored_qualifiers +#endif +#ifdef GENERATOR_FILE +extern int warn_implicit; +#else + int x_warn_implicit; +#define warn_implicit global_options.x_warn_implicit +#endif +#ifdef GENERATOR_FILE +extern int warn_implicit_function_declaration; +#else + int x_warn_implicit_function_declaration; +#define warn_implicit_function_declaration global_options.x_warn_implicit_function_declaration +#endif +#ifdef GENERATOR_FILE +extern int warn_implicit_int; +#else + int x_warn_implicit_int; +#define warn_implicit_int global_options.x_warn_implicit_int +#endif +#ifdef GENERATOR_FILE +extern int warn_init_self; +#else + int x_warn_init_self; +#define warn_init_self global_options.x_warn_init_self +#endif +#ifdef GENERATOR_FILE +extern int warn_inline; +#else + int x_warn_inline; +#define warn_inline global_options.x_warn_inline +#endif +#ifdef GENERATOR_FILE +extern int warn_int_to_pointer_cast; +#else + int x_warn_int_to_pointer_cast; +#define warn_int_to_pointer_cast global_options.x_warn_int_to_pointer_cast +#endif +#ifdef GENERATOR_FILE +extern int warn_invalid_offsetof; +#else + int x_warn_invalid_offsetof; +#define warn_invalid_offsetof global_options.x_warn_invalid_offsetof +#endif +#ifdef GENERATOR_FILE +extern int warn_jump_misses_init; +#else + int x_warn_jump_misses_init; +#define warn_jump_misses_init global_options.x_warn_jump_misses_init +#endif +#ifdef GENERATOR_FILE +extern int warn_logical_op; +#else + int x_warn_logical_op; +#define warn_logical_op global_options.x_warn_logical_op +#endif +#ifdef GENERATOR_FILE +extern int warn_long_long; +#else + int x_warn_long_long; +#define warn_long_long global_options.x_warn_long_long +#endif +#ifdef GENERATOR_FILE +extern int warn_main; +#else + int x_warn_main; +#define warn_main global_options.x_warn_main +#endif +#ifdef GENERATOR_FILE +extern int warn_maybe_uninitialized; +#else + int x_warn_maybe_uninitialized; +#define warn_maybe_uninitialized global_options.x_warn_maybe_uninitialized +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_braces; +#else + int x_warn_missing_braces; +#define warn_missing_braces global_options.x_warn_missing_braces +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_declarations; +#else + int x_warn_missing_declarations; +#define warn_missing_declarations global_options.x_warn_missing_declarations +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_field_initializers; +#else + int x_warn_missing_field_initializers; +#define warn_missing_field_initializers global_options.x_warn_missing_field_initializers +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_format_attribute; +#else + int x_warn_missing_format_attribute; +#define warn_missing_format_attribute global_options.x_warn_missing_format_attribute +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_noreturn; +#else + int x_warn_missing_noreturn; +#define warn_missing_noreturn global_options.x_warn_missing_noreturn +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_parameter_type; +#else + int x_warn_missing_parameter_type; +#define warn_missing_parameter_type global_options.x_warn_missing_parameter_type +#endif +#ifdef GENERATOR_FILE +extern int warn_missing_prototypes; +#else + int x_warn_missing_prototypes; +#define warn_missing_prototypes global_options.x_warn_missing_prototypes +#endif +#ifdef GENERATOR_FILE +extern int warn_mudflap; +#else + int x_warn_mudflap; +#define warn_mudflap global_options.x_warn_mudflap +#endif +#ifdef GENERATOR_FILE +extern int warn_narrowing; +#else + int x_warn_narrowing; +#define warn_narrowing global_options.x_warn_narrowing +#endif +#ifdef GENERATOR_FILE +extern int warn_nested_externs; +#else + int x_warn_nested_externs; +#define warn_nested_externs global_options.x_warn_nested_externs +#endif +#ifdef GENERATOR_FILE +extern int warn_noexcept; +#else + int x_warn_noexcept; +#define warn_noexcept global_options.x_warn_noexcept +#endif +#ifdef GENERATOR_FILE +extern int warn_nontemplate_friend; +#else + int x_warn_nontemplate_friend; +#define warn_nontemplate_friend global_options.x_warn_nontemplate_friend +#endif +#ifdef GENERATOR_FILE +extern int warn_nonvdtor; +#else + int x_warn_nonvdtor; +#define warn_nonvdtor global_options.x_warn_nonvdtor +#endif +#ifdef GENERATOR_FILE +extern int warn_nonnull; +#else + int x_warn_nonnull; +#define warn_nonnull global_options.x_warn_nonnull +#endif +#ifdef GENERATOR_FILE +extern int warn_old_style_cast; +#else + int x_warn_old_style_cast; +#define warn_old_style_cast global_options.x_warn_old_style_cast +#endif +#ifdef GENERATOR_FILE +extern int warn_old_style_declaration; +#else + int x_warn_old_style_declaration; +#define warn_old_style_declaration global_options.x_warn_old_style_declaration +#endif +#ifdef GENERATOR_FILE +extern int warn_old_style_definition; +#else + int x_warn_old_style_definition; +#define warn_old_style_definition global_options.x_warn_old_style_definition +#endif +#ifdef GENERATOR_FILE +extern int flag_newer; +#else + int x_flag_newer; +#define flag_newer global_options.x_flag_newer +#endif +#ifdef GENERATOR_FILE +extern int warn_overflow; +#else + int x_warn_overflow; +#define warn_overflow global_options.x_warn_overflow +#endif +#ifdef GENERATOR_FILE +extern int warn_overlength_strings; +#else + int x_warn_overlength_strings; +#define warn_overlength_strings global_options.x_warn_overlength_strings +#endif +#ifdef GENERATOR_FILE +extern int warn_overloaded_virtual; +#else + int x_warn_overloaded_virtual; +#define warn_overloaded_virtual global_options.x_warn_overloaded_virtual +#endif +#ifdef GENERATOR_FILE +extern int warn_override_init; +#else + int x_warn_override_init; +#define warn_override_init global_options.x_warn_override_init +#endif +#ifdef GENERATOR_FILE +extern int warn_packed; +#else + int x_warn_packed; +#define warn_packed global_options.x_warn_packed +#endif +#ifdef GENERATOR_FILE +extern int warn_packed_bitfield_compat; +#else + int x_warn_packed_bitfield_compat; +#define warn_packed_bitfield_compat global_options.x_warn_packed_bitfield_compat +#endif +#ifdef GENERATOR_FILE +extern int warn_padded; +#else + int x_warn_padded; +#define warn_padded global_options.x_warn_padded +#endif +#ifdef GENERATOR_FILE +extern int warn_parentheses; +#else + int x_warn_parentheses; +#define warn_parentheses global_options.x_warn_parentheses +#endif +#ifdef GENERATOR_FILE +extern int warn_pmf2ptr; +#else + int x_warn_pmf2ptr; +#define warn_pmf2ptr global_options.x_warn_pmf2ptr +#endif +#ifdef GENERATOR_FILE +extern int warn_pointer_arith; +#else + int x_warn_pointer_arith; +#define warn_pointer_arith global_options.x_warn_pointer_arith +#endif +#ifdef GENERATOR_FILE +extern int warn_pointer_sign; +#else + int x_warn_pointer_sign; +#define warn_pointer_sign global_options.x_warn_pointer_sign +#endif +#ifdef GENERATOR_FILE +extern int warn_pointer_to_int_cast; +#else + int x_warn_pointer_to_int_cast; +#define warn_pointer_to_int_cast global_options.x_warn_pointer_to_int_cast +#endif +#ifdef GENERATOR_FILE +extern int warn_pragmas; +#else + int x_warn_pragmas; +#define warn_pragmas global_options.x_warn_pragmas +#endif +#ifdef GENERATOR_FILE +extern int warn_property_assign_default; +#else + int x_warn_property_assign_default; +#define warn_property_assign_default global_options.x_warn_property_assign_default +#endif +#ifdef GENERATOR_FILE +extern int warn_protocol; +#else + int x_warn_protocol; +#define warn_protocol global_options.x_warn_protocol +#endif +#ifdef GENERATOR_FILE +extern int warn_psabi; +#else + int x_warn_psabi; +#define warn_psabi global_options.x_warn_psabi +#endif +#ifdef GENERATOR_FILE +extern int warn_real_conversion; +#else + int x_warn_real_conversion; +#define warn_real_conversion global_options.x_warn_real_conversion +#endif +#ifdef GENERATOR_FILE +extern int warn_redundant_decls; +#else + int x_warn_redundant_decls; +#define warn_redundant_decls global_options.x_warn_redundant_decls +#endif +#ifdef GENERATOR_FILE +extern int flag_redundant; +#else + int x_flag_redundant; +#define flag_redundant global_options.x_flag_redundant +#endif +#ifdef GENERATOR_FILE +extern int warn_reorder; +#else + int x_warn_reorder; +#define warn_reorder global_options.x_warn_reorder +#endif +#ifdef GENERATOR_FILE +extern int warn_return_type; +#else + int x_warn_return_type; +#define warn_return_type global_options.x_warn_return_type +#endif +#ifdef GENERATOR_FILE +extern int warn_ripa_opt_mismatch; +#else + int x_warn_ripa_opt_mismatch; +#define warn_ripa_opt_mismatch global_options.x_warn_ripa_opt_mismatch +#endif +#ifdef GENERATOR_FILE +extern int warn_selector; +#else + int x_warn_selector; +#define warn_selector global_options.x_warn_selector +#endif +#ifdef GENERATOR_FILE +extern int warn_self_assign; +#else + int x_warn_self_assign; +#define warn_self_assign global_options.x_warn_self_assign +#endif +#ifdef GENERATOR_FILE +extern int warn_self_assign_non_pod; +#else + int x_warn_self_assign_non_pod; +#define warn_self_assign_non_pod global_options.x_warn_self_assign_non_pod +#endif +#ifdef GENERATOR_FILE +extern int warn_sequence_point; +#else + int x_warn_sequence_point; +#define warn_sequence_point global_options.x_warn_sequence_point +#endif +#ifdef GENERATOR_FILE +extern int warn_shadow; +#else + int x_warn_shadow; +#define warn_shadow global_options.x_warn_shadow +#endif +#ifdef GENERATOR_FILE +extern int warn_shadow_compatible_local; +#else + int x_warn_shadow_compatible_local; +#define warn_shadow_compatible_local global_options.x_warn_shadow_compatible_local +#endif +#ifdef GENERATOR_FILE +extern int warn_shadow_local; +#else + int x_warn_shadow_local; +#define warn_shadow_local global_options.x_warn_shadow_local +#endif +#ifdef GENERATOR_FILE +extern int warn_sign_compare; +#else + int x_warn_sign_compare; +#define warn_sign_compare global_options.x_warn_sign_compare +#endif +#ifdef GENERATOR_FILE +extern int warn_sign_conversion; +#else + int x_warn_sign_conversion; +#define warn_sign_conversion global_options.x_warn_sign_conversion +#endif +#ifdef GENERATOR_FILE +extern int warn_sign_promo; +#else + int x_warn_sign_promo; +#define warn_sign_promo global_options.x_warn_sign_promo +#endif +#ifdef GENERATOR_FILE +extern int warn_stack_protect; +#else + int x_warn_stack_protect; +#define warn_stack_protect global_options.x_warn_stack_protect +#endif +#ifdef GENERATOR_FILE +extern int warn_strict_aliasing; +#else + int x_warn_strict_aliasing; +#define warn_strict_aliasing global_options.x_warn_strict_aliasing +#endif +#ifdef GENERATOR_FILE +extern int warn_strict_null_sentinel; +#else + int x_warn_strict_null_sentinel; +#define warn_strict_null_sentinel global_options.x_warn_strict_null_sentinel +#endif +#ifdef GENERATOR_FILE +extern int warn_strict_overflow; +#else + int x_warn_strict_overflow; +#define warn_strict_overflow global_options.x_warn_strict_overflow +#endif +#ifdef GENERATOR_FILE +extern int warn_strict_prototypes; +#else + int x_warn_strict_prototypes; +#define warn_strict_prototypes global_options.x_warn_strict_prototypes +#endif +#ifdef GENERATOR_FILE +extern int warn_strict_selector_match; +#else + int x_warn_strict_selector_match; +#define warn_strict_selector_match global_options.x_warn_strict_selector_match +#endif +#ifdef GENERATOR_FILE +extern int warn_suggest_attribute_const; +#else + int x_warn_suggest_attribute_const; +#define warn_suggest_attribute_const global_options.x_warn_suggest_attribute_const +#endif +#ifdef GENERATOR_FILE +extern int warn_suggest_attribute_noreturn; +#else + int x_warn_suggest_attribute_noreturn; +#define warn_suggest_attribute_noreturn global_options.x_warn_suggest_attribute_noreturn +#endif +#ifdef GENERATOR_FILE +extern int warn_suggest_attribute_pure; +#else + int x_warn_suggest_attribute_pure; +#define warn_suggest_attribute_pure global_options.x_warn_suggest_attribute_pure +#endif +#ifdef GENERATOR_FILE +extern int warn_switch; +#else + int x_warn_switch; +#define warn_switch global_options.x_warn_switch +#endif +#ifdef GENERATOR_FILE +extern int warn_switch_default; +#else + int x_warn_switch_default; +#define warn_switch_default global_options.x_warn_switch_default +#endif +#ifdef GENERATOR_FILE +extern int warn_switch_enum; +#else + int x_warn_switch_enum; +#define warn_switch_enum global_options.x_warn_switch_enum +#endif +#ifdef GENERATOR_FILE +extern int warn_sync_nand; +#else + int x_warn_sync_nand; +#define warn_sync_nand global_options.x_warn_sync_nand +#endif +#ifdef GENERATOR_FILE +extern int warn_synth; +#else + int x_warn_synth; +#define warn_synth global_options.x_warn_synth +#endif +#ifdef GENERATOR_FILE +extern int warn_system_headers; +#else + int x_warn_system_headers; +#define warn_system_headers global_options.x_warn_system_headers +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_attr_bind_param; +#else + int x_warn_thread_attr_bind_param; +#define warn_thread_attr_bind_param global_options.x_warn_thread_attr_bind_param +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_mismatched_lock_acq_rel; +#else + int x_warn_thread_mismatched_lock_acq_rel; +#define warn_thread_mismatched_lock_acq_rel global_options.x_warn_thread_mismatched_lock_acq_rel +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_mismatched_lock_order; +#else + int x_warn_thread_mismatched_lock_order; +#define warn_thread_mismatched_lock_order global_options.x_warn_thread_mismatched_lock_order +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_reentrant_lock; +#else + int x_warn_thread_reentrant_lock; +#define warn_thread_reentrant_lock global_options.x_warn_thread_reentrant_lock +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_safety; +#else + int x_warn_thread_safety; +#define warn_thread_safety global_options.x_warn_thread_safety +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_unguarded_func; +#else + int x_warn_thread_unguarded_func; +#define warn_thread_unguarded_func global_options.x_warn_thread_unguarded_func +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_unguarded_var; +#else + int x_warn_thread_unguarded_var; +#define warn_thread_unguarded_var global_options.x_warn_thread_unguarded_var +#endif +#ifdef GENERATOR_FILE +extern int warn_unsupported_lock_name; +#else + int x_warn_unsupported_lock_name; +#define warn_unsupported_lock_name global_options.x_warn_unsupported_lock_name +#endif +#ifdef GENERATOR_FILE +extern int warn_thread_optimization; +#else + int x_warn_thread_optimization; +#define warn_thread_optimization global_options.x_warn_thread_optimization +#endif +#ifdef GENERATOR_FILE +extern int warn_traditional; +#else + int x_warn_traditional; +#define warn_traditional global_options.x_warn_traditional +#endif +#ifdef GENERATOR_FILE +extern int warn_traditional_conversion; +#else + int x_warn_traditional_conversion; +#define warn_traditional_conversion global_options.x_warn_traditional_conversion +#endif +#ifdef GENERATOR_FILE +extern int warn_trampolines; +#else + int x_warn_trampolines; +#define warn_trampolines global_options.x_warn_trampolines +#endif +#ifdef GENERATOR_FILE +extern int warn_type_limits; +#else + int x_warn_type_limits; +#define warn_type_limits global_options.x_warn_type_limits +#endif +#ifdef GENERATOR_FILE +extern int warn_undeclared_selector; +#else + int x_warn_undeclared_selector; +#define warn_undeclared_selector global_options.x_warn_undeclared_selector +#endif +#ifdef GENERATOR_FILE +extern int warn_uninitialized; +#else + int x_warn_uninitialized; +#define warn_uninitialized global_options.x_warn_uninitialized +#endif +#ifdef GENERATOR_FILE +extern int warn_unsafe_loop_optimizations; +#else + int x_warn_unsafe_loop_optimizations; +#define warn_unsafe_loop_optimizations global_options.x_warn_unsafe_loop_optimizations +#endif +#ifdef GENERATOR_FILE +extern int warn_unsuffixed_float_constants; +#else + int x_warn_unsuffixed_float_constants; +#define warn_unsuffixed_float_constants global_options.x_warn_unsuffixed_float_constants +#endif +#ifdef GENERATOR_FILE +extern int warn_unused; +#else + int x_warn_unused; +#define warn_unused global_options.x_warn_unused +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_but_set_parameter; +#else + int x_warn_unused_but_set_parameter; +#define warn_unused_but_set_parameter global_options.x_warn_unused_but_set_parameter +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_but_set_variable; +#else + int x_warn_unused_but_set_variable; +#define warn_unused_but_set_variable global_options.x_warn_unused_but_set_variable +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_function; +#else + int x_warn_unused_function; +#define warn_unused_function global_options.x_warn_unused_function +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_label; +#else + int x_warn_unused_label; +#define warn_unused_label global_options.x_warn_unused_label +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_parameter; +#else + int x_warn_unused_parameter; +#define warn_unused_parameter global_options.x_warn_unused_parameter +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_result; +#else + int x_warn_unused_result; +#define warn_unused_result global_options.x_warn_unused_result +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_value; +#else + int x_warn_unused_value; +#define warn_unused_value global_options.x_warn_unused_value +#endif +#ifdef GENERATOR_FILE +extern int warn_unused_variable; +#else + int x_warn_unused_variable; +#define warn_unused_variable global_options.x_warn_unused_variable +#endif +#ifdef GENERATOR_FILE +extern int warn_vla; +#else + int x_warn_vla; +#define warn_vla global_options.x_warn_vla +#endif +#ifdef GENERATOR_FILE +extern int warn_volatile_register_var; +#else + int x_warn_volatile_register_var; +#define warn_volatile_register_var global_options.x_warn_volatile_register_var +#endif +#ifdef GENERATOR_FILE +extern int warn_write_strings; +#else + int x_warn_write_strings; +#define warn_write_strings global_options.x_warn_write_strings +#endif +#ifdef GENERATOR_FILE +extern const char *aux_info_file_name; +#else + const char *x_aux_info_file_name; +#define aux_info_file_name global_options.x_aux_info_file_name +#endif +#ifdef GENERATOR_FILE +extern const char *aux_base_name; +#else + const char *x_aux_base_name; +#define aux_base_name global_options.x_aux_base_name +#endif +#ifdef GENERATOR_FILE +extern const char *dump_base_name; +#else + const char *x_dump_base_name; +#define dump_base_name global_options.x_dump_base_name +#endif +#ifdef GENERATOR_FILE +extern const char *dump_dir_name; +#else + const char *x_dump_dir_name; +#define dump_dir_name global_options.x_dump_dir_name +#endif +#ifdef GENERATOR_FILE +extern int flag_pic; +#else + int x_flag_pic; +#define flag_pic global_options.x_flag_pic +#endif +#ifdef GENERATOR_FILE +extern int flag_pie; +#else + int x_flag_pie; +#define flag_pie global_options.x_flag_pie +#endif +#ifdef GENERATOR_FILE +extern int flag_abi_version; +#else + int x_flag_abi_version; +#define flag_abi_version global_options.x_flag_abi_version +#endif +#ifdef GENERATOR_FILE +extern int flag_access_control; +#else + int x_flag_access_control; +#define flag_access_control global_options.x_flag_access_control +#endif +#ifdef GENERATOR_FILE +extern int align_functions; +#else + int x_align_functions; +#define align_functions global_options.x_align_functions +#endif +#ifdef GENERATOR_FILE +extern int align_jumps; +#else + int x_align_jumps; +#define align_jumps global_options.x_align_jumps +#endif +#ifdef GENERATOR_FILE +extern int align_labels; +#else + int x_align_labels; +#define align_labels global_options.x_align_labels +#endif +#ifdef GENERATOR_FILE +extern int align_loops; +#else + int x_align_loops; +#define align_loops global_options.x_align_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_no_asm; +#else + int x_flag_no_asm; +#define flag_no_asm global_options.x_flag_no_asm +#endif +#ifdef GENERATOR_FILE +extern int flag_assert; +#else + int x_flag_assert; +#define flag_assert global_options.x_flag_assert +#endif +#ifdef GENERATOR_FILE +extern int flag_associative_math; +#else + int x_flag_associative_math; +#define flag_associative_math global_options.x_flag_associative_math +#endif +#ifdef GENERATOR_FILE +extern int flag_asynchronous_unwind_tables; +#else + int x_flag_asynchronous_unwind_tables; +#define flag_asynchronous_unwind_tables global_options.x_flag_asynchronous_unwind_tables +#endif +#ifdef GENERATOR_FILE +extern int flag_auto_inc_dec; +#else + int x_flag_auto_inc_dec; +#define flag_auto_inc_dec global_options.x_flag_auto_inc_dec +#endif +#ifdef GENERATOR_FILE +extern int flag_bootstrap_classes; +#else + int x_flag_bootstrap_classes; +#define flag_bootstrap_classes global_options.x_flag_bootstrap_classes +#endif +#ifdef GENERATOR_FILE +extern int flag_bounds_check; +#else + int x_flag_bounds_check; +#define flag_bounds_check global_options.x_flag_bounds_check +#endif +#ifdef GENERATOR_FILE +extern int flag_branch_on_count_reg; +#else + int x_flag_branch_on_count_reg; +#define flag_branch_on_count_reg global_options.x_flag_branch_on_count_reg +#endif +#ifdef GENERATOR_FILE +extern int flag_branch_probabilities; +#else + int x_flag_branch_probabilities; +#define flag_branch_probabilities global_options.x_flag_branch_probabilities +#endif +#ifdef GENERATOR_FILE +extern int flag_branch_target_load_optimize; +#else + int x_flag_branch_target_load_optimize; +#define flag_branch_target_load_optimize global_options.x_flag_branch_target_load_optimize +#endif +#ifdef GENERATOR_FILE +extern int flag_branch_target_load_optimize2; +#else + int x_flag_branch_target_load_optimize2; +#define flag_branch_target_load_optimize2 global_options.x_flag_branch_target_load_optimize2 +#endif +#ifdef GENERATOR_FILE +extern int flag_btr_bb_exclusive; +#else + int x_flag_btr_bb_exclusive; +#define flag_btr_bb_exclusive global_options.x_flag_btr_bb_exclusive +#endif +#ifdef GENERATOR_FILE +extern int flag_no_builtin; +#else + int x_flag_no_builtin; +#define flag_no_builtin global_options.x_flag_no_builtin +#endif +#ifdef GENERATOR_FILE +extern void *common_deferred_options; +#else + void *x_common_deferred_options; +#define common_deferred_options global_options.x_common_deferred_options +#endif +#ifdef GENERATOR_FILE +extern int flag_caller_saves; +#else + int x_flag_caller_saves; +#define flag_caller_saves global_options.x_flag_caller_saves +#endif +#ifdef GENERATOR_FILE +extern int flag_callgraph_profiles_sections; +#else + int x_flag_callgraph_profiles_sections; +#define flag_callgraph_profiles_sections global_options.x_flag_callgraph_profiles_sections +#endif +#ifdef GENERATOR_FILE +extern int flag_check_data_deps; +#else + int x_flag_check_data_deps; +#define flag_check_data_deps global_options.x_flag_check_data_deps +#endif +#ifdef GENERATOR_FILE +extern int flag_check_new; +#else + int x_flag_check_new; +#define flag_check_new global_options.x_flag_check_new +#endif +#ifdef GENERATOR_FILE +extern int flag_check_references; +#else + int x_flag_check_references; +#define flag_check_references global_options.x_flag_check_references +#endif +#ifdef GENERATOR_FILE +extern int flag_clone_hot_version_paths; +#else + int x_flag_clone_hot_version_paths; +#define flag_clone_hot_version_paths global_options.x_flag_clone_hot_version_paths +#endif +#ifdef GENERATOR_FILE +extern int flag_combine_stack_adjustments; +#else + int x_flag_combine_stack_adjustments; +#define flag_combine_stack_adjustments global_options.x_flag_combine_stack_adjustments +#endif +#ifdef GENERATOR_FILE +extern int flag_no_common; +#else + int x_flag_no_common; +#define flag_no_common global_options.x_flag_no_common +#endif +#ifdef GENERATOR_FILE +extern int flag_compare_debug; +#else + int x_flag_compare_debug; +#define flag_compare_debug global_options.x_flag_compare_debug +#endif +#ifdef GENERATOR_FILE +extern const char *flag_compare_debug_opt; +#else + const char *x_flag_compare_debug_opt; +#define flag_compare_debug_opt global_options.x_flag_compare_debug_opt +#endif +#ifdef GENERATOR_FILE +extern int flag_compare_elim_after_reload; +#else + int x_flag_compare_elim_after_reload; +#define flag_compare_elim_after_reload global_options.x_flag_compare_elim_after_reload +#endif +#ifdef GENERATOR_FILE +extern int flag_conserve_space; +#else + int x_flag_conserve_space; +#define flag_conserve_space global_options.x_flag_conserve_space +#endif +#ifdef GENERATOR_FILE +extern int flag_conserve_stack; +#else + int x_flag_conserve_stack; +#define flag_conserve_stack global_options.x_flag_conserve_stack +#endif +#ifdef GENERATOR_FILE +extern int max_constexpr_depth; +#else + int x_max_constexpr_depth; +#define max_constexpr_depth global_options.x_max_constexpr_depth +#endif +#ifdef GENERATOR_FILE +extern int flag_cprop_registers; +#else + int x_flag_cprop_registers; +#define flag_cprop_registers global_options.x_flag_cprop_registers +#endif +#ifdef GENERATOR_FILE +extern int flag_crossjumping; +#else + int x_flag_crossjumping; +#define flag_crossjumping global_options.x_flag_crossjumping +#endif +#ifdef GENERATOR_FILE +extern int flag_cse_follow_jumps; +#else + int x_flag_cse_follow_jumps; +#define flag_cse_follow_jumps global_options.x_flag_cse_follow_jumps +#endif +#ifdef GENERATOR_FILE +extern int flag_cx_fortran_rules; +#else + int x_flag_cx_fortran_rules; +#define flag_cx_fortran_rules global_options.x_flag_cx_fortran_rules +#endif +#ifdef GENERATOR_FILE +extern int flag_cx_limited_range; +#else + int x_flag_cx_limited_range; +#define flag_cx_limited_range global_options.x_flag_cx_limited_range +#endif +#ifdef GENERATOR_FILE +extern int flag_data_sections; +#else + int x_flag_data_sections; +#define flag_data_sections global_options.x_flag_data_sections +#endif +#ifdef GENERATOR_FILE +extern int flag_dce; +#else + int x_flag_dce; +#define flag_dce global_options.x_flag_dce +#endif +#ifdef GENERATOR_FILE +extern int flag_deduce_init_list; +#else + int x_flag_deduce_init_list; +#define flag_deduce_init_list global_options.x_flag_deduce_init_list +#endif +#ifdef GENERATOR_FILE +extern int flag_defer_pop; +#else + int x_flag_defer_pop; +#define flag_defer_pop global_options.x_flag_defer_pop +#endif +#ifdef GENERATOR_FILE +extern int flag_delayed_branch; +#else + int x_flag_delayed_branch; +#define flag_delayed_branch global_options.x_flag_delayed_branch +#endif +#ifdef GENERATOR_FILE +extern int flag_delete_null_pointer_checks; +#else + int x_flag_delete_null_pointer_checks; +#define flag_delete_null_pointer_checks global_options.x_flag_delete_null_pointer_checks +#endif +#ifdef GENERATOR_FILE +extern int flag_devirtualize; +#else + int x_flag_devirtualize; +#define flag_devirtualize global_options.x_flag_devirtualize +#endif +#ifdef GENERATOR_FILE +extern int flag_diagnostics_show_option; +#else + int x_flag_diagnostics_show_option; +#define flag_diagnostics_show_option global_options.x_flag_diagnostics_show_option +#endif +#ifdef GENERATOR_FILE +extern int flag_dse; +#else + int x_flag_dse; +#define flag_dse global_options.x_flag_dse +#endif +#ifdef GENERATOR_FILE +extern const char *flag_dump_final_insns; +#else + const char *x_flag_dump_final_insns; +#define flag_dump_final_insns global_options.x_flag_dump_final_insns +#endif +#ifdef GENERATOR_FILE +extern const char *flag_dump_go_spec; +#else + const char *x_flag_dump_go_spec; +#define flag_dump_go_spec global_options.x_flag_dump_go_spec +#endif +#ifdef GENERATOR_FILE +extern int flag_dump_noaddr; +#else + int x_flag_dump_noaddr; +#define flag_dump_noaddr global_options.x_flag_dump_noaddr +#endif +#ifdef GENERATOR_FILE +extern int flag_dump_passes; +#else + int x_flag_dump_passes; +#define flag_dump_passes global_options.x_flag_dump_passes +#endif +#ifdef GENERATOR_FILE +extern int flag_dump_unnumbered; +#else + int x_flag_dump_unnumbered; +#define flag_dump_unnumbered global_options.x_flag_dump_unnumbered +#endif +#ifdef GENERATOR_FILE +extern int flag_dump_unnumbered_links; +#else + int x_flag_dump_unnumbered_links; +#define flag_dump_unnumbered_links global_options.x_flag_dump_unnumbered_links +#endif +#ifdef GENERATOR_FILE +extern int flag_dwarf2_cfi_asm; +#else + int x_flag_dwarf2_cfi_asm; +#define flag_dwarf2_cfi_asm global_options.x_flag_dwarf2_cfi_asm +#endif +#ifdef GENERATOR_FILE +extern int flag_early_inlining; +#else + int x_flag_early_inlining; +#define flag_early_inlining global_options.x_flag_early_inlining +#endif +#ifdef GENERATOR_FILE +extern int flag_elide_constructors; +#else + int x_flag_elide_constructors; +#define flag_elide_constructors global_options.x_flag_elide_constructors +#endif +#ifdef GENERATOR_FILE +extern int flag_eliminate_dwarf2_dups; +#else + int x_flag_eliminate_dwarf2_dups; +#define flag_eliminate_dwarf2_dups global_options.x_flag_eliminate_dwarf2_dups +#endif +#ifdef GENERATOR_FILE +extern int flag_debug_only_used_symbols; +#else + int x_flag_debug_only_used_symbols; +#define flag_debug_only_used_symbols global_options.x_flag_debug_only_used_symbols +#endif +#ifdef GENERATOR_FILE +extern int flag_eliminate_unused_debug_types; +#else + int x_flag_eliminate_unused_debug_types; +#define flag_eliminate_unused_debug_types global_options.x_flag_eliminate_unused_debug_types +#endif +#ifdef GENERATOR_FILE +extern int flag_emit_class_debug_always; +#else + int x_flag_emit_class_debug_always; +#define flag_emit_class_debug_always global_options.x_flag_emit_class_debug_always +#endif +#ifdef GENERATOR_FILE +extern int flag_emit_class_files; +#else + int x_flag_emit_class_files; +#define flag_emit_class_files global_options.x_flag_emit_class_files +#endif +#ifdef GENERATOR_FILE +extern int flag_enable_icf_debug; +#else + int x_flag_enable_icf_debug; +#define flag_enable_icf_debug global_options.x_flag_enable_icf_debug +#endif +#ifdef GENERATOR_FILE +extern int flag_enforce_eh_specs; +#else + int x_flag_enforce_eh_specs; +#define flag_enforce_eh_specs global_options.x_flag_enforce_eh_specs +#endif +#ifdef GENERATOR_FILE +extern int flag_exceptions; +#else + int x_flag_exceptions; +#define flag_exceptions global_options.x_flag_exceptions +#endif +#ifdef GENERATOR_FILE +extern enum excess_precision flag_excess_precision_cmdline; +#else + enum excess_precision x_flag_excess_precision_cmdline; +#define flag_excess_precision_cmdline global_options.x_flag_excess_precision_cmdline +#endif +#ifdef GENERATOR_FILE +extern int flag_expensive_optimizations; +#else + int x_flag_expensive_optimizations; +#define flag_expensive_optimizations global_options.x_flag_expensive_optimizations +#endif +#ifdef GENERATOR_FILE +extern int flag_filelist_file; +#else + int x_flag_filelist_file; +#define flag_filelist_file global_options.x_flag_filelist_file +#endif +#ifdef GENERATOR_FILE +extern int flag_finite_math_only; +#else + int x_flag_finite_math_only; +#define flag_finite_math_only global_options.x_flag_finite_math_only +#endif +#ifdef GENERATOR_FILE +extern int flag_float_store; +#else + int x_flag_float_store; +#define flag_float_store global_options.x_flag_float_store +#endif +#ifdef GENERATOR_FILE +extern int flag_new_for_scope; +#else + int x_flag_new_for_scope; +#define flag_new_for_scope global_options.x_flag_new_for_scope +#endif +#ifdef GENERATOR_FILE +extern int flag_force_classes_archive_check; +#else + int x_flag_force_classes_archive_check; +#define flag_force_classes_archive_check global_options.x_flag_force_classes_archive_check +#endif +#ifdef GENERATOR_FILE +extern int flag_forward_propagate; +#else + int x_flag_forward_propagate; +#define flag_forward_propagate global_options.x_flag_forward_propagate +#endif +#ifdef GENERATOR_FILE +extern enum fp_contract_mode flag_fp_contract_mode; +#else + enum fp_contract_mode x_flag_fp_contract_mode; +#define flag_fp_contract_mode global_options.x_flag_fp_contract_mode +#endif +#ifdef GENERATOR_FILE +extern int flag_friend_injection; +#else + int x_flag_friend_injection; +#define flag_friend_injection global_options.x_flag_friend_injection +#endif +#ifdef GENERATOR_FILE +extern int flag_no_function_cse; +#else + int x_flag_no_function_cse; +#define flag_no_function_cse global_options.x_flag_no_function_cse +#endif +#ifdef GENERATOR_FILE +extern int flag_function_sections; +#else + int x_flag_function_sections; +#define flag_function_sections global_options.x_flag_function_sections +#endif +#ifdef GENERATOR_FILE +extern int flag_gcse; +#else + int x_flag_gcse; +#define flag_gcse global_options.x_flag_gcse +#endif +#ifdef GENERATOR_FILE +extern int flag_gcse_after_reload; +#else + int x_flag_gcse_after_reload; +#define flag_gcse_after_reload global_options.x_flag_gcse_after_reload +#endif +#ifdef GENERATOR_FILE +extern int flag_gcse_las; +#else + int x_flag_gcse_las; +#define flag_gcse_las global_options.x_flag_gcse_las +#endif +#ifdef GENERATOR_FILE +extern int flag_gcse_lm; +#else + int x_flag_gcse_lm; +#define flag_gcse_lm global_options.x_flag_gcse_lm +#endif +#ifdef GENERATOR_FILE +extern int flag_gcse_sm; +#else + int x_flag_gcse_sm; +#define flag_gcse_sm global_options.x_flag_gcse_sm +#endif +#ifdef GENERATOR_FILE +extern int flag_no_gnu_keywords; +#else + int x_flag_no_gnu_keywords; +#define flag_no_gnu_keywords global_options.x_flag_no_gnu_keywords +#endif +#ifdef GENERATOR_FILE +extern int flag_gnu89_inline; +#else + int x_flag_gnu89_inline; +#define flag_gnu89_inline global_options.x_flag_gnu89_inline +#endif +#ifdef GENERATOR_FILE +extern int flag_graphite; +#else + int x_flag_graphite; +#define flag_graphite global_options.x_flag_graphite +#endif +#ifdef GENERATOR_FILE +extern int flag_graphite_identity; +#else + int x_flag_graphite_identity; +#define flag_graphite_identity global_options.x_flag_graphite_identity +#endif +#ifdef GENERATOR_FILE +extern int flag_guess_branch_prob; +#else + int x_flag_guess_branch_prob; +#define flag_guess_branch_prob global_options.x_flag_guess_branch_prob +#endif +#ifdef GENERATOR_FILE +extern int flag_hash_synchronization; +#else + int x_flag_hash_synchronization; +#define flag_hash_synchronization global_options.x_flag_hash_synchronization +#endif +#ifdef GENERATOR_FILE +extern int flag_no_ident; +#else + int x_flag_no_ident; +#define flag_no_ident global_options.x_flag_no_ident +#endif +#ifdef GENERATOR_FILE +extern int flag_if_conversion; +#else + int x_flag_if_conversion; +#define flag_if_conversion global_options.x_flag_if_conversion +#endif +#ifdef GENERATOR_FILE +extern int flag_if_conversion2; +#else + int x_flag_if_conversion2; +#define flag_if_conversion2 global_options.x_flag_if_conversion2 +#endif +#ifdef GENERATOR_FILE +extern int flag_implement_inlines; +#else + int x_flag_implement_inlines; +#define flag_implement_inlines global_options.x_flag_implement_inlines +#endif +#ifdef GENERATOR_FILE +extern int flag_implicit_inline_templates; +#else + int x_flag_implicit_inline_templates; +#define flag_implicit_inline_templates global_options.x_flag_implicit_inline_templates +#endif +#ifdef GENERATOR_FILE +extern int flag_implicit_templates; +#else + int x_flag_implicit_templates; +#define flag_implicit_templates global_options.x_flag_implicit_templates +#endif +#ifdef GENERATOR_FILE +extern int flag_indirect_classes; +#else + int x_flag_indirect_classes; +#define flag_indirect_classes global_options.x_flag_indirect_classes +#endif +#ifdef GENERATOR_FILE +extern int flag_indirect_dispatch; +#else + int x_flag_indirect_dispatch; +#define flag_indirect_dispatch global_options.x_flag_indirect_dispatch +#endif +#ifdef GENERATOR_FILE +extern int flag_indirect_inlining; +#else + int x_flag_indirect_inlining; +#define flag_indirect_inlining global_options.x_flag_indirect_inlining +#endif +#ifdef GENERATOR_FILE +extern int flag_inhibit_size_directive; +#else + int x_flag_inhibit_size_directive; +#define flag_inhibit_size_directive global_options.x_flag_inhibit_size_directive +#endif +#ifdef GENERATOR_FILE +extern int flag_no_inline; +#else + int x_flag_no_inline; +#define flag_no_inline global_options.x_flag_no_inline +#endif +#ifdef GENERATOR_FILE +extern int flag_inline_functions; +#else + int x_flag_inline_functions; +#define flag_inline_functions global_options.x_flag_inline_functions +#endif +#ifdef GENERATOR_FILE +extern int flag_inline_functions_called_once; +#else + int x_flag_inline_functions_called_once; +#define flag_inline_functions_called_once global_options.x_flag_inline_functions_called_once +#endif +#ifdef GENERATOR_FILE +extern int flag_inline_hot_caller; +#else + int x_flag_inline_hot_caller; +#define flag_inline_hot_caller global_options.x_flag_inline_hot_caller +#endif +#ifdef GENERATOR_FILE +extern int flag_inline_small_functions; +#else + int x_flag_inline_small_functions; +#define flag_inline_small_functions global_options.x_flag_inline_small_functions +#endif +#ifdef GENERATOR_FILE +extern int flag_instrument_function_entry_exit; +#else + int x_flag_instrument_function_entry_exit; +#define flag_instrument_function_entry_exit global_options.x_flag_instrument_function_entry_exit +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_cp; +#else + int x_flag_ipa_cp; +#define flag_ipa_cp global_options.x_flag_ipa_cp +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_cp_clone; +#else + int x_flag_ipa_cp_clone; +#define flag_ipa_cp_clone global_options.x_flag_ipa_cp_clone +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_matrix_reorg; +#else + int x_flag_ipa_matrix_reorg; +#define flag_ipa_matrix_reorg global_options.x_flag_ipa_matrix_reorg +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_profile; +#else + int x_flag_ipa_profile; +#define flag_ipa_profile global_options.x_flag_ipa_profile +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_pta; +#else + int x_flag_ipa_pta; +#define flag_ipa_pta global_options.x_flag_ipa_pta +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_pure_const; +#else + int x_flag_ipa_pure_const; +#define flag_ipa_pure_const global_options.x_flag_ipa_pure_const +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_reference; +#else + int x_flag_ipa_reference; +#define flag_ipa_reference global_options.x_flag_ipa_reference +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_sra; +#else + int x_flag_ipa_sra; +#define flag_ipa_sra global_options.x_flag_ipa_sra +#endif +#ifdef GENERATOR_FILE +extern int flag_ipa_struct_reorg; +#else + int x_flag_ipa_struct_reorg; +#define flag_ipa_struct_reorg global_options.x_flag_ipa_struct_reorg +#endif +#ifdef GENERATOR_FILE +extern enum ira_algorithm flag_ira_algorithm; +#else + enum ira_algorithm x_flag_ira_algorithm; +#define flag_ira_algorithm global_options.x_flag_ira_algorithm +#endif +#ifdef GENERATOR_FILE +extern int flag_ira_loop_pressure; +#else + int x_flag_ira_loop_pressure; +#define flag_ira_loop_pressure global_options.x_flag_ira_loop_pressure +#endif +#ifdef GENERATOR_FILE +extern enum ira_region flag_ira_region; +#else + enum ira_region x_flag_ira_region; +#define flag_ira_region global_options.x_flag_ira_region +#endif +#ifdef GENERATOR_FILE +extern int flag_ira_share_save_slots; +#else + int x_flag_ira_share_save_slots; +#define flag_ira_share_save_slots global_options.x_flag_ira_share_save_slots +#endif +#ifdef GENERATOR_FILE +extern int flag_ira_share_spill_slots; +#else + int x_flag_ira_share_spill_slots; +#define flag_ira_share_spill_slots global_options.x_flag_ira_share_spill_slots +#endif +#ifdef GENERATOR_FILE +extern int flag_ira_verbose; +#else + int x_flag_ira_verbose; +#define flag_ira_verbose global_options.x_flag_ira_verbose +#endif +#ifdef GENERATOR_FILE +extern int flag_ivopts; +#else + int x_flag_ivopts; +#define flag_ivopts global_options.x_flag_ivopts +#endif +#ifdef GENERATOR_FILE +extern int flag_jni; +#else + int x_flag_jni; +#define flag_jni global_options.x_flag_jni +#endif +#ifdef GENERATOR_FILE +extern int flag_jump_tables; +#else + int x_flag_jump_tables; +#define flag_jump_tables global_options.x_flag_jump_tables +#endif +#ifdef GENERATOR_FILE +extern int flag_keep_inline_dllexport; +#else + int x_flag_keep_inline_dllexport; +#define flag_keep_inline_dllexport global_options.x_flag_keep_inline_dllexport +#endif +#ifdef GENERATOR_FILE +extern int flag_keep_inline_functions; +#else + int x_flag_keep_inline_functions; +#define flag_keep_inline_functions global_options.x_flag_keep_inline_functions +#endif +#ifdef GENERATOR_FILE +extern int flag_keep_static_consts; +#else + int x_flag_keep_static_consts; +#define flag_keep_static_consts global_options.x_flag_keep_static_consts +#endif +#ifdef GENERATOR_FILE +extern int flag_lax_vector_conversions; +#else + int x_flag_lax_vector_conversions; +#define flag_lax_vector_conversions global_options.x_flag_lax_vector_conversions +#endif +#ifdef GENERATOR_FILE +extern int flag_leading_underscore; +#else + int x_flag_leading_underscore; +#define flag_leading_underscore global_options.x_flag_leading_underscore +#endif +#ifdef GENERATOR_FILE +extern int flag_loop_block; +#else + int x_flag_loop_block; +#define flag_loop_block global_options.x_flag_loop_block +#endif +#ifdef GENERATOR_FILE +extern int flag_loop_flatten; +#else + int x_flag_loop_flatten; +#define flag_loop_flatten global_options.x_flag_loop_flatten +#endif +#ifdef GENERATOR_FILE +extern int flag_loop_interchange; +#else + int x_flag_loop_interchange; +#define flag_loop_interchange global_options.x_flag_loop_interchange +#endif +#ifdef GENERATOR_FILE +extern int flag_loop_parallelize_all; +#else + int x_flag_loop_parallelize_all; +#define flag_loop_parallelize_all global_options.x_flag_loop_parallelize_all +#endif +#ifdef GENERATOR_FILE +extern int flag_loop_strip_mine; +#else + int x_flag_loop_strip_mine; +#define flag_loop_strip_mine global_options.x_flag_loop_strip_mine +#endif +#ifdef GENERATOR_FILE +extern int flag_lto_compression_level; +#else + int x_flag_lto_compression_level; +#define flag_lto_compression_level global_options.x_flag_lto_compression_level +#endif +#ifdef GENERATOR_FILE +extern int flag_lto_partition_1to1; +#else + int x_flag_lto_partition_1to1; +#define flag_lto_partition_1to1 global_options.x_flag_lto_partition_1to1 +#endif +#ifdef GENERATOR_FILE +extern int flag_lto_partition_balanced; +#else + int x_flag_lto_partition_balanced; +#define flag_lto_partition_balanced global_options.x_flag_lto_partition_balanced +#endif +#ifdef GENERATOR_FILE +extern int flag_lto_partition_none; +#else + int x_flag_lto_partition_none; +#define flag_lto_partition_none global_options.x_flag_lto_partition_none +#endif +#ifdef GENERATOR_FILE +extern int flag_lto_report; +#else + int x_flag_lto_report; +#define flag_lto_report global_options.x_flag_lto_report +#endif +#ifdef GENERATOR_FILE +extern const char *flag_lto; +#else + const char *x_flag_lto; +#define flag_lto global_options.x_flag_lto +#endif +#ifdef GENERATOR_FILE +extern int flag_ltrans; +#else + int x_flag_ltrans; +#define flag_ltrans global_options.x_flag_ltrans +#endif +#ifdef GENERATOR_FILE +extern const char *ltrans_output_list; +#else + const char *x_ltrans_output_list; +#define ltrans_output_list global_options.x_ltrans_output_list +#endif +#ifdef GENERATOR_FILE +extern int flag_errno_math; +#else + int x_flag_errno_math; +#define flag_errno_math global_options.x_flag_errno_math +#endif +#ifdef GENERATOR_FILE +extern int flag_max_errors; +#else + int x_flag_max_errors; +#define flag_max_errors global_options.x_flag_max_errors +#endif +#ifdef GENERATOR_FILE +extern int mem_report; +#else + int x_mem_report; +#define mem_report global_options.x_mem_report +#endif +#ifdef GENERATOR_FILE +extern int flag_merge_constants; +#else + int x_flag_merge_constants; +#define flag_merge_constants global_options.x_flag_merge_constants +#endif +#ifdef GENERATOR_FILE +extern int flag_merge_debug_strings; +#else + int x_flag_merge_debug_strings; +#define flag_merge_debug_strings global_options.x_flag_merge_debug_strings +#endif +#ifdef GENERATOR_FILE +extern int flag_modulo_sched; +#else + int x_flag_modulo_sched; +#define flag_modulo_sched global_options.x_flag_modulo_sched +#endif +#ifdef GENERATOR_FILE +extern int flag_modulo_sched_allow_regmoves; +#else + int x_flag_modulo_sched_allow_regmoves; +#define flag_modulo_sched_allow_regmoves global_options.x_flag_modulo_sched_allow_regmoves +#endif +#ifdef GENERATOR_FILE +extern int flag_move_loop_invariants; +#else + int x_flag_move_loop_invariants; +#define flag_move_loop_invariants global_options.x_flag_move_loop_invariants +#endif +#ifdef GENERATOR_FILE +extern int flag_ms_extensions; +#else + int x_flag_ms_extensions; +#define flag_ms_extensions global_options.x_flag_ms_extensions +#endif +#ifdef GENERATOR_FILE +extern int flag_mudflap; +#else + int x_flag_mudflap; +#define flag_mudflap global_options.x_flag_mudflap +#endif +#ifdef GENERATOR_FILE +extern int flag_mudflap_ignore_reads; +#else + int x_flag_mudflap_ignore_reads; +#define flag_mudflap_ignore_reads global_options.x_flag_mudflap_ignore_reads +#endif +#ifdef GENERATOR_FILE +extern int flag_nil_receivers; +#else + int x_flag_nil_receivers; +#define flag_nil_receivers global_options.x_flag_nil_receivers +#endif +#ifdef GENERATOR_FILE +extern int flag_non_call_exceptions; +#else + int x_flag_non_call_exceptions; +#define flag_non_call_exceptions global_options.x_flag_non_call_exceptions +#endif +#ifdef GENERATOR_FILE +extern int flag_no_nonansi_builtin; +#else + int x_flag_no_nonansi_builtin; +#define flag_no_nonansi_builtin global_options.x_flag_no_nonansi_builtin +#endif +#ifdef GENERATOR_FILE +extern int flag_nothrow_opt; +#else + int x_flag_nothrow_opt; +#define flag_nothrow_opt global_options.x_flag_nothrow_opt +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_abi; +#else + int x_flag_objc_abi; +#define flag_objc_abi global_options.x_flag_objc_abi +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_call_cxx_cdtors; +#else + int x_flag_objc_call_cxx_cdtors; +#define flag_objc_call_cxx_cdtors global_options.x_flag_objc_call_cxx_cdtors +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_direct_dispatch; +#else + int x_flag_objc_direct_dispatch; +#define flag_objc_direct_dispatch global_options.x_flag_objc_direct_dispatch +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_exceptions; +#else + int x_flag_objc_exceptions; +#define flag_objc_exceptions global_options.x_flag_objc_exceptions +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_gc; +#else + int x_flag_objc_gc; +#define flag_objc_gc global_options.x_flag_objc_gc +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_nilcheck; +#else + int x_flag_objc_nilcheck; +#define flag_objc_nilcheck global_options.x_flag_objc_nilcheck +#endif +#ifdef GENERATOR_FILE +extern int flag_objc_sjlj_exceptions; +#else + int x_flag_objc_sjlj_exceptions; +#define flag_objc_sjlj_exceptions global_options.x_flag_objc_sjlj_exceptions +#endif +#ifdef GENERATOR_FILE +extern int flag_objc1_only; +#else + int x_flag_objc1_only; +#define flag_objc1_only global_options.x_flag_objc1_only +#endif +#ifdef GENERATOR_FILE +extern int flag_omit_frame_pointer; +#else + int x_flag_omit_frame_pointer; +#define flag_omit_frame_pointer global_options.x_flag_omit_frame_pointer +#endif +#ifdef GENERATOR_FILE +extern int flag_openmp; +#else + int x_flag_openmp; +#define flag_openmp global_options.x_flag_openmp +#endif +#ifdef GENERATOR_FILE +extern int flag_opt_info; +#else + int x_flag_opt_info; +#define flag_opt_info global_options.x_flag_opt_info +#endif +#ifdef GENERATOR_FILE +extern int flag_optimize_locality; +#else + int x_flag_optimize_locality; +#define flag_optimize_locality global_options.x_flag_optimize_locality +#endif +#ifdef GENERATOR_FILE +extern int flag_regmove; +#else + int x_flag_regmove; +#define flag_regmove global_options.x_flag_regmove +#endif +#ifdef GENERATOR_FILE +extern int flag_optimize_sibling_calls; +#else + int x_flag_optimize_sibling_calls; +#define flag_optimize_sibling_calls global_options.x_flag_optimize_sibling_calls +#endif +#ifdef GENERATOR_FILE +extern int flag_optimize_sci; +#else + int x_flag_optimize_sci; +#define flag_optimize_sci global_options.x_flag_optimize_sci +#endif +#ifdef GENERATOR_FILE +extern int flag_pack_struct; +#else + int x_flag_pack_struct; +#define flag_pack_struct global_options.x_flag_pack_struct +#endif +#ifdef GENERATOR_FILE +extern int flag_partial_inlining; +#else + int x_flag_partial_inlining; +#define flag_partial_inlining global_options.x_flag_partial_inlining +#endif +#ifdef GENERATOR_FILE +extern int flag_pcc_struct_return; +#else + int x_flag_pcc_struct_return; +#define flag_pcc_struct_return global_options.x_flag_pcc_struct_return +#endif +#ifdef GENERATOR_FILE +extern int flag_peel_loops; +#else + int x_flag_peel_loops; +#define flag_peel_loops global_options.x_flag_peel_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_no_peephole; +#else + int x_flag_no_peephole; +#define flag_no_peephole global_options.x_flag_no_peephole +#endif +#ifdef GENERATOR_FILE +extern int flag_peephole2; +#else + int x_flag_peephole2; +#define flag_peephole2 global_options.x_flag_peephole2 +#endif +#ifdef GENERATOR_FILE +extern int flag_plan9_extensions; +#else + int x_flag_plan9_extensions; +#define flag_plan9_extensions global_options.x_flag_plan9_extensions +#endif +#ifdef GENERATOR_FILE +extern const char *flag_pmu_profile_generate; +#else + const char *x_flag_pmu_profile_generate; +#define flag_pmu_profile_generate global_options.x_flag_pmu_profile_generate +#endif +#ifdef GENERATOR_FILE +extern const char *flag_pmu_profile_use; +#else + const char *x_flag_pmu_profile_use; +#define flag_pmu_profile_use global_options.x_flag_pmu_profile_use +#endif +#ifdef GENERATOR_FILE +extern int post_ipa_mem_report; +#else + int x_post_ipa_mem_report; +#define post_ipa_mem_report global_options.x_post_ipa_mem_report +#endif +#ifdef GENERATOR_FILE +extern int pre_ipa_mem_report; +#else + int x_pre_ipa_mem_report; +#define pre_ipa_mem_report global_options.x_pre_ipa_mem_report +#endif +#ifdef GENERATOR_FILE +extern int flag_predictive_commoning; +#else + int x_flag_predictive_commoning; +#define flag_predictive_commoning global_options.x_flag_predictive_commoning +#endif +#ifdef GENERATOR_FILE +extern int flag_prefetch_loop_arrays; +#else + int x_flag_prefetch_loop_arrays; +#define flag_prefetch_loop_arrays global_options.x_flag_prefetch_loop_arrays +#endif +#ifdef GENERATOR_FILE +extern int flag_pretty_templates; +#else + int x_flag_pretty_templates; +#define flag_pretty_templates global_options.x_flag_pretty_templates +#endif +#ifdef GENERATOR_FILE +extern int profile_flag; +#else + int x_profile_flag; +#define profile_flag global_options.x_profile_flag +#endif +#ifdef GENERATOR_FILE +extern int profile_arc_flag; +#else + int x_profile_arc_flag; +#define profile_arc_flag global_options.x_profile_arc_flag +#endif +#ifdef GENERATOR_FILE +extern int flag_profile_correction; +#else + int x_flag_profile_correction; +#define flag_profile_correction global_options.x_flag_profile_correction +#endif +#ifdef GENERATOR_FILE +extern const char *profile_data_prefix; +#else + const char *x_profile_data_prefix; +#define profile_data_prefix global_options.x_profile_data_prefix +#endif +#ifdef GENERATOR_FILE +extern int flag_profile_dump; +#else + int x_flag_profile_dump; +#define flag_profile_dump global_options.x_flag_profile_dump +#endif +#ifdef GENERATOR_FILE +extern int flag_profile_generate_sampling; +#else + int x_flag_profile_generate_sampling; +#define flag_profile_generate_sampling global_options.x_flag_profile_generate_sampling +#endif +#ifdef GENERATOR_FILE +extern int flag_profile_reusedist; +#else + int x_flag_profile_reusedist; +#define flag_profile_reusedist global_options.x_flag_profile_reusedist +#endif +#ifdef GENERATOR_FILE +extern int flag_profile_use; +#else + int x_flag_profile_use; +#define flag_profile_use global_options.x_flag_profile_use +#endif +#ifdef GENERATOR_FILE +extern int flag_profile_values; +#else + int x_flag_profile_values; +#define flag_profile_values global_options.x_flag_profile_values +#endif +#ifdef GENERATOR_FILE +extern int flag_reciprocal_math; +#else + int x_flag_reciprocal_math; +#define flag_reciprocal_math global_options.x_flag_reciprocal_math +#endif +#ifdef GENERATOR_FILE +extern int flag_record_gcc_switches; +#else + int x_flag_record_gcc_switches; +#define flag_record_gcc_switches global_options.x_flag_record_gcc_switches +#endif +#ifdef GENERATOR_FILE +extern int flag_record_gcc_switches_in_elf; +#else + int x_flag_record_gcc_switches_in_elf; +#define flag_record_gcc_switches_in_elf global_options.x_flag_record_gcc_switches_in_elf +#endif +#ifdef GENERATOR_FILE +extern int flag_reduced_reflection; +#else + int x_flag_reduced_reflection; +#define flag_reduced_reflection global_options.x_flag_reduced_reflection +#endif +#ifdef GENERATOR_FILE +extern int flag_rename_registers; +#else + int x_flag_rename_registers; +#define flag_rename_registers global_options.x_flag_rename_registers +#endif +#ifdef GENERATOR_FILE +extern int flag_reorder_blocks; +#else + int x_flag_reorder_blocks; +#define flag_reorder_blocks global_options.x_flag_reorder_blocks +#endif +#ifdef GENERATOR_FILE +extern int flag_reorder_blocks_and_partition; +#else + int x_flag_reorder_blocks_and_partition; +#define flag_reorder_blocks_and_partition global_options.x_flag_reorder_blocks_and_partition +#endif +#ifdef GENERATOR_FILE +extern int flag_reorder_functions; +#else + int x_flag_reorder_functions; +#define flag_reorder_functions global_options.x_flag_reorder_functions +#endif +#ifdef GENERATOR_FILE +extern int flag_replace_objc_classes; +#else + int x_flag_replace_objc_classes; +#define flag_replace_objc_classes global_options.x_flag_replace_objc_classes +#endif +#ifdef GENERATOR_FILE +extern int go_require_return_statement; +#else + int x_go_require_return_statement; +#define go_require_return_statement global_options.x_go_require_return_statement +#endif +#ifdef GENERATOR_FILE +extern int flag_rerun_cse_after_loop; +#else + int x_flag_rerun_cse_after_loop; +#define flag_rerun_cse_after_loop global_options.x_flag_rerun_cse_after_loop +#endif +#ifdef GENERATOR_FILE +extern int flag_resched_modulo_sched; +#else + int x_flag_resched_modulo_sched; +#define flag_resched_modulo_sched global_options.x_flag_resched_modulo_sched +#endif +#ifdef GENERATOR_FILE +extern int flag_dyn_ipa; +#else + int x_flag_dyn_ipa; +#define flag_dyn_ipa global_options.x_flag_dyn_ipa +#endif +#ifdef GENERATOR_FILE +extern int flag_ripa_disallow_asm_modules; +#else + int x_flag_ripa_disallow_asm_modules; +#define flag_ripa_disallow_asm_modules global_options.x_flag_ripa_disallow_asm_modules +#endif +#ifdef GENERATOR_FILE +extern int flag_ripa_disallow_opt_mismatch; +#else + int x_flag_ripa_disallow_opt_mismatch; +#define flag_ripa_disallow_opt_mismatch global_options.x_flag_ripa_disallow_opt_mismatch +#endif +#ifdef GENERATOR_FILE +extern int flag_ripa_no_promote_always_inline; +#else + int x_flag_ripa_no_promote_always_inline; +#define flag_ripa_no_promote_always_inline global_options.x_flag_ripa_no_promote_always_inline +#endif +#ifdef GENERATOR_FILE +extern int flag_ripa_peel_size_limit; +#else + int x_flag_ripa_peel_size_limit; +#define flag_ripa_peel_size_limit global_options.x_flag_ripa_peel_size_limit +#endif +#ifdef GENERATOR_FILE +extern int flag_ripa_unroll_size_limit; +#else + int x_flag_ripa_unroll_size_limit; +#define flag_ripa_unroll_size_limit global_options.x_flag_ripa_unroll_size_limit +#endif +#ifdef GENERATOR_FILE +extern int flag_rounding_math; +#else + int x_flag_rounding_math; +#define flag_rounding_math global_options.x_flag_rounding_math +#endif +#ifdef GENERATOR_FILE +extern int flag_rtti; +#else + int x_flag_rtti; +#define flag_rtti global_options.x_flag_rtti +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_critical_path_heuristic; +#else + int x_flag_sched_critical_path_heuristic; +#define flag_sched_critical_path_heuristic global_options.x_flag_sched_critical_path_heuristic +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_dep_count_heuristic; +#else + int x_flag_sched_dep_count_heuristic; +#define flag_sched_dep_count_heuristic global_options.x_flag_sched_dep_count_heuristic +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_group_heuristic; +#else + int x_flag_sched_group_heuristic; +#define flag_sched_group_heuristic global_options.x_flag_sched_group_heuristic +#endif +#ifdef GENERATOR_FILE +extern int flag_schedule_interblock; +#else + int x_flag_schedule_interblock; +#define flag_schedule_interblock global_options.x_flag_schedule_interblock +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_last_insn_heuristic; +#else + int x_flag_sched_last_insn_heuristic; +#define flag_sched_last_insn_heuristic global_options.x_flag_sched_last_insn_heuristic +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_pressure; +#else + int x_flag_sched_pressure; +#define flag_sched_pressure global_options.x_flag_sched_pressure +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_rank_heuristic; +#else + int x_flag_sched_rank_heuristic; +#define flag_sched_rank_heuristic global_options.x_flag_sched_rank_heuristic +#endif +#ifdef GENERATOR_FILE +extern int flag_schedule_speculative; +#else + int x_flag_schedule_speculative; +#define flag_schedule_speculative global_options.x_flag_schedule_speculative +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_spec_insn_heuristic; +#else + int x_flag_sched_spec_insn_heuristic; +#define flag_sched_spec_insn_heuristic global_options.x_flag_sched_spec_insn_heuristic +#endif +#ifdef GENERATOR_FILE +extern int flag_schedule_speculative_load; +#else + int x_flag_schedule_speculative_load; +#define flag_schedule_speculative_load global_options.x_flag_schedule_speculative_load +#endif +#ifdef GENERATOR_FILE +extern int flag_schedule_speculative_load_dangerous; +#else + int x_flag_schedule_speculative_load_dangerous; +#define flag_schedule_speculative_load_dangerous global_options.x_flag_schedule_speculative_load_dangerous +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_stalled_insns; +#else + int x_flag_sched_stalled_insns; +#define flag_sched_stalled_insns global_options.x_flag_sched_stalled_insns +#endif +#ifdef GENERATOR_FILE +extern int flag_sched_stalled_insns_dep; +#else + int x_flag_sched_stalled_insns_dep; +#define flag_sched_stalled_insns_dep global_options.x_flag_sched_stalled_insns_dep +#endif +#ifdef GENERATOR_FILE +extern int sched_verbose_param; +#else + int x_sched_verbose_param; +#define sched_verbose_param global_options.x_sched_verbose_param +#endif +#ifdef GENERATOR_FILE +extern int flag_sched2_use_superblocks; +#else + int x_flag_sched2_use_superblocks; +#define flag_sched2_use_superblocks global_options.x_flag_sched2_use_superblocks +#endif +#ifdef GENERATOR_FILE +extern int flag_schedule_insns; +#else + int x_flag_schedule_insns; +#define flag_schedule_insns global_options.x_flag_schedule_insns +#endif +#ifdef GENERATOR_FILE +extern int flag_schedule_insns_after_reload; +#else + int x_flag_schedule_insns_after_reload; +#define flag_schedule_insns_after_reload global_options.x_flag_schedule_insns_after_reload +#endif +#ifdef GENERATOR_FILE +extern int flag_section_anchors; +#else + int x_flag_section_anchors; +#define flag_section_anchors global_options.x_flag_section_anchors +#endif +#ifdef GENERATOR_FILE +extern int flag_sel_sched_pipelining; +#else + int x_flag_sel_sched_pipelining; +#define flag_sel_sched_pipelining global_options.x_flag_sel_sched_pipelining +#endif +#ifdef GENERATOR_FILE +extern int flag_sel_sched_pipelining_outer_loops; +#else + int x_flag_sel_sched_pipelining_outer_loops; +#define flag_sel_sched_pipelining_outer_loops global_options.x_flag_sel_sched_pipelining_outer_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_sel_sched_reschedule_pipelined; +#else + int x_flag_sel_sched_reschedule_pipelined; +#define flag_sel_sched_reschedule_pipelined global_options.x_flag_sel_sched_reschedule_pipelined +#endif +#ifdef GENERATOR_FILE +extern int flag_selective_scheduling; +#else + int x_flag_selective_scheduling; +#define flag_selective_scheduling global_options.x_flag_selective_scheduling +#endif +#ifdef GENERATOR_FILE +extern int flag_selective_scheduling2; +#else + int x_flag_selective_scheduling2; +#define flag_selective_scheduling2 global_options.x_flag_selective_scheduling2 +#endif +#ifdef GENERATOR_FILE +extern int flag_short_double; +#else + int x_flag_short_double; +#define flag_short_double global_options.x_flag_short_double +#endif +#ifdef GENERATOR_FILE +extern int flag_short_enums; +#else + int x_flag_short_enums; +#define flag_short_enums global_options.x_flag_short_enums +#endif +#ifdef GENERATOR_FILE +extern int flag_short_wchar; +#else + int x_flag_short_wchar; +#define flag_short_wchar global_options.x_flag_short_wchar +#endif +#ifdef GENERATOR_FILE +extern int flag_show_column; +#else + int x_flag_show_column; +#define flag_show_column global_options.x_flag_show_column +#endif +#ifdef GENERATOR_FILE +extern int flag_signaling_nans; +#else + int x_flag_signaling_nans; +#define flag_signaling_nans global_options.x_flag_signaling_nans +#endif +#ifdef GENERATOR_FILE +extern int flag_signed_bitfields; +#else + int x_flag_signed_bitfields; +#define flag_signed_bitfields global_options.x_flag_signed_bitfields +#endif +#ifdef GENERATOR_FILE +extern int flag_signed_char; +#else + int x_flag_signed_char; +#define flag_signed_char global_options.x_flag_signed_char +#endif +#ifdef GENERATOR_FILE +extern int flag_signed_zeros; +#else + int x_flag_signed_zeros; +#define flag_signed_zeros global_options.x_flag_signed_zeros +#endif +#ifdef GENERATOR_FILE +extern int flag_single_precision_constant; +#else + int x_flag_single_precision_constant; +#define flag_single_precision_constant global_options.x_flag_single_precision_constant +#endif +#ifdef GENERATOR_FILE +extern int flag_sized_delete; +#else + int x_flag_sized_delete; +#define flag_sized_delete global_options.x_flag_sized_delete +#endif +#ifdef GENERATOR_FILE +extern int flag_split_ivs_in_unroller; +#else + int x_flag_split_ivs_in_unroller; +#define flag_split_ivs_in_unroller global_options.x_flag_split_ivs_in_unroller +#endif +#ifdef GENERATOR_FILE +extern int flag_split_stack; +#else + int x_flag_split_stack; +#define flag_split_stack global_options.x_flag_split_stack +#endif +#ifdef GENERATOR_FILE +extern int flag_split_wide_types; +#else + int x_flag_split_wide_types; +#define flag_split_wide_types global_options.x_flag_split_wide_types +#endif +#ifdef GENERATOR_FILE +extern int flag_stack_protect; +#else + int x_flag_stack_protect; +#define flag_stack_protect global_options.x_flag_stack_protect +#endif +#ifdef GENERATOR_FILE +extern int flag_stack_usage; +#else + int x_flag_stack_usage; +#define flag_stack_usage global_options.x_flag_stack_usage +#endif +#ifdef GENERATOR_FILE +extern int flag_detailed_statistics; +#else + int x_flag_detailed_statistics; +#define flag_detailed_statistics global_options.x_flag_detailed_statistics +#endif +#ifdef GENERATOR_FILE +extern int flag_store_check; +#else + int x_flag_store_check; +#define flag_store_check global_options.x_flag_store_check +#endif +#ifdef GENERATOR_FILE +extern int flag_strict_aliasing; +#else + int x_flag_strict_aliasing; +#define flag_strict_aliasing global_options.x_flag_strict_aliasing +#endif +#ifdef GENERATOR_FILE +extern int flag_strict_enum_precision; +#else + int x_flag_strict_enum_precision; +#define flag_strict_enum_precision global_options.x_flag_strict_enum_precision +#endif +#ifdef GENERATOR_FILE +extern int flag_strict_enums; +#else + int x_flag_strict_enums; +#define flag_strict_enums global_options.x_flag_strict_enums +#endif +#ifdef GENERATOR_FILE +extern int flag_strict_overflow; +#else + int x_flag_strict_overflow; +#define flag_strict_overflow global_options.x_flag_strict_overflow +#endif +#ifdef GENERATOR_FILE +extern int flag_strict_volatile_bitfields; +#else + int x_flag_strict_volatile_bitfields; +#define flag_strict_volatile_bitfields global_options.x_flag_strict_volatile_bitfields +#endif +#ifdef GENERATOR_FILE +extern int flag_syntax_only; +#else + int x_flag_syntax_only; +#define flag_syntax_only global_options.x_flag_syntax_only +#endif +#ifdef GENERATOR_FILE +extern int flag_test_coverage; +#else + int x_flag_test_coverage; +#define flag_test_coverage global_options.x_flag_test_coverage +#endif +#ifdef GENERATOR_FILE +extern int flag_thread_jumps; +#else + int x_flag_thread_jumps; +#define flag_thread_jumps global_options.x_flag_thread_jumps +#endif +#ifdef GENERATOR_FILE +extern int flag_threadsafe_statics; +#else + int x_flag_threadsafe_statics; +#define flag_threadsafe_statics global_options.x_flag_threadsafe_statics +#endif +#ifdef GENERATOR_FILE +extern int time_report; +#else + int x_time_report; +#define time_report global_options.x_time_report +#endif +#ifdef GENERATOR_FILE +extern enum tls_model flag_tls_default; +#else + enum tls_model x_flag_tls_default; +#define flag_tls_default global_options.x_flag_tls_default +#endif +#ifdef GENERATOR_FILE +extern int flag_toplevel_reorder; +#else + int x_flag_toplevel_reorder; +#define flag_toplevel_reorder global_options.x_flag_toplevel_reorder +#endif +#ifdef GENERATOR_FILE +extern int flag_tracer; +#else + int x_flag_tracer; +#define flag_tracer global_options.x_flag_tracer +#endif +#ifdef GENERATOR_FILE +extern int flag_trapping_math; +#else + int x_flag_trapping_math; +#define flag_trapping_math global_options.x_flag_trapping_math +#endif +#ifdef GENERATOR_FILE +extern int flag_trapv; +#else + int x_flag_trapv; +#define flag_trapv global_options.x_flag_trapv +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_bit_ccp; +#else + int x_flag_tree_bit_ccp; +#define flag_tree_bit_ccp global_options.x_flag_tree_bit_ccp +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_builtin_call_dce; +#else + int x_flag_tree_builtin_call_dce; +#define flag_tree_builtin_call_dce global_options.x_flag_tree_builtin_call_dce +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_ccp; +#else + int x_flag_tree_ccp; +#define flag_tree_ccp global_options.x_flag_tree_ccp +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_ch; +#else + int x_flag_tree_ch; +#define flag_tree_ch global_options.x_flag_tree_ch +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_copy_prop; +#else + int x_flag_tree_copy_prop; +#define flag_tree_copy_prop global_options.x_flag_tree_copy_prop +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_copyrename; +#else + int x_flag_tree_copyrename; +#define flag_tree_copyrename global_options.x_flag_tree_copyrename +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_cselim; +#else + int x_flag_tree_cselim; +#define flag_tree_cselim global_options.x_flag_tree_cselim +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_dce; +#else + int x_flag_tree_dce; +#define flag_tree_dce global_options.x_flag_tree_dce +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_dom; +#else + int x_flag_tree_dom; +#define flag_tree_dom global_options.x_flag_tree_dom +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_dse; +#else + int x_flag_tree_dse; +#define flag_tree_dse global_options.x_flag_tree_dse +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_forwprop; +#else + int x_flag_tree_forwprop; +#define flag_tree_forwprop global_options.x_flag_tree_forwprop +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_fre; +#else + int x_flag_tree_fre; +#define flag_tree_fre global_options.x_flag_tree_fre +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_distribute_patterns; +#else + int x_flag_tree_loop_distribute_patterns; +#define flag_tree_loop_distribute_patterns global_options.x_flag_tree_loop_distribute_patterns +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_distribution; +#else + int x_flag_tree_loop_distribution; +#define flag_tree_loop_distribution global_options.x_flag_tree_loop_distribution +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_if_convert; +#else + int x_flag_tree_loop_if_convert; +#define flag_tree_loop_if_convert global_options.x_flag_tree_loop_if_convert +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_if_convert_stores; +#else + int x_flag_tree_loop_if_convert_stores; +#define flag_tree_loop_if_convert_stores global_options.x_flag_tree_loop_if_convert_stores +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_im; +#else + int x_flag_tree_loop_im; +#define flag_tree_loop_im global_options.x_flag_tree_loop_im +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_ivcanon; +#else + int x_flag_tree_loop_ivcanon; +#define flag_tree_loop_ivcanon global_options.x_flag_tree_loop_ivcanon +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_loop_optimize; +#else + int x_flag_tree_loop_optimize; +#define flag_tree_loop_optimize global_options.x_flag_tree_loop_optimize +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_live_range_split; +#else + int x_flag_tree_live_range_split; +#define flag_tree_live_range_split global_options.x_flag_tree_live_range_split +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_parallelize_loops; +#else + int x_flag_tree_parallelize_loops; +#define flag_tree_parallelize_loops global_options.x_flag_tree_parallelize_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_phiprop; +#else + int x_flag_tree_phiprop; +#define flag_tree_phiprop global_options.x_flag_tree_phiprop +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_pre; +#else + int x_flag_tree_pre; +#define flag_tree_pre global_options.x_flag_tree_pre +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_pta; +#else + int x_flag_tree_pta; +#define flag_tree_pta global_options.x_flag_tree_pta +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_reassoc; +#else + int x_flag_tree_reassoc; +#define flag_tree_reassoc global_options.x_flag_tree_reassoc +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_scev_cprop; +#else + int x_flag_tree_scev_cprop; +#define flag_tree_scev_cprop global_options.x_flag_tree_scev_cprop +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_sink; +#else + int x_flag_tree_sink; +#define flag_tree_sink global_options.x_flag_tree_sink +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_slp_vectorize; +#else + int x_flag_tree_slp_vectorize; +#define flag_tree_slp_vectorize global_options.x_flag_tree_slp_vectorize +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_sra; +#else + int x_flag_tree_sra; +#define flag_tree_sra global_options.x_flag_tree_sra +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_switch_conversion; +#else + int x_flag_tree_switch_conversion; +#define flag_tree_switch_conversion global_options.x_flag_tree_switch_conversion +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_ter; +#else + int x_flag_tree_ter; +#define flag_tree_ter global_options.x_flag_tree_ter +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_vect_loop_version; +#else + int x_flag_tree_vect_loop_version; +#define flag_tree_vect_loop_version global_options.x_flag_tree_vect_loop_version +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_vectorize; +#else + int x_flag_tree_vectorize; +#define flag_tree_vectorize global_options.x_flag_tree_vectorize +#endif +#ifdef GENERATOR_FILE +extern int flag_tree_vrp; +#else + int x_flag_tree_vrp; +#define flag_tree_vrp global_options.x_flag_tree_vrp +#endif +#ifdef GENERATOR_FILE +extern int flag_unit_at_a_time; +#else + int x_flag_unit_at_a_time; +#define flag_unit_at_a_time global_options.x_flag_unit_at_a_time +#endif +#ifdef GENERATOR_FILE +extern int flag_unroll_all_loops; +#else + int x_flag_unroll_all_loops; +#define flag_unroll_all_loops global_options.x_flag_unroll_all_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_unroll_loops; +#else + int x_flag_unroll_loops; +#define flag_unroll_loops global_options.x_flag_unroll_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_unsafe_loop_optimizations; +#else + int x_flag_unsafe_loop_optimizations; +#define flag_unsafe_loop_optimizations global_options.x_flag_unsafe_loop_optimizations +#endif +#ifdef GENERATOR_FILE +extern int flag_unsafe_math_optimizations; +#else + int x_flag_unsafe_math_optimizations; +#define flag_unsafe_math_optimizations global_options.x_flag_unsafe_math_optimizations +#endif +#ifdef GENERATOR_FILE +extern int flag_unswitch_loops; +#else + int x_flag_unswitch_loops; +#define flag_unswitch_loops global_options.x_flag_unswitch_loops +#endif +#ifdef GENERATOR_FILE +extern int flag_unwind_tables; +#else + int x_flag_unwind_tables; +#define flag_unwind_tables global_options.x_flag_unwind_tables +#endif +#ifdef GENERATOR_FILE +extern int flag_use_atomic_builtins; +#else + int x_flag_use_atomic_builtins; +#define flag_use_atomic_builtins global_options.x_flag_use_atomic_builtins +#endif +#ifdef GENERATOR_FILE +extern int flag_use_boehm_gc; +#else + int x_flag_use_boehm_gc; +#define flag_use_boehm_gc global_options.x_flag_use_boehm_gc +#endif +#ifdef GENERATOR_FILE +extern int flag_use_cxa_atexit; +#else + int x_flag_use_cxa_atexit; +#define flag_use_cxa_atexit global_options.x_flag_use_cxa_atexit +#endif +#ifdef GENERATOR_FILE +extern int flag_use_cxa_get_exception_ptr; +#else + int x_flag_use_cxa_get_exception_ptr; +#define flag_use_cxa_get_exception_ptr global_options.x_flag_use_cxa_get_exception_ptr +#endif +#ifdef GENERATOR_FILE +extern int flag_use_divide_subroutine; +#else + int x_flag_use_divide_subroutine; +#define flag_use_divide_subroutine global_options.x_flag_use_divide_subroutine +#endif +#ifdef GENERATOR_FILE +extern int flag_var_tracking; +#else + int x_flag_var_tracking; +#define flag_var_tracking global_options.x_flag_var_tracking +#endif +#ifdef GENERATOR_FILE +extern int flag_var_tracking_assignments; +#else + int x_flag_var_tracking_assignments; +#define flag_var_tracking_assignments global_options.x_flag_var_tracking_assignments +#endif +#ifdef GENERATOR_FILE +extern int flag_var_tracking_assignments_toggle; +#else + int x_flag_var_tracking_assignments_toggle; +#define flag_var_tracking_assignments_toggle global_options.x_flag_var_tracking_assignments_toggle +#endif +#ifdef GENERATOR_FILE +extern int flag_var_tracking_uninit; +#else + int x_flag_var_tracking_uninit; +#define flag_var_tracking_uninit global_options.x_flag_var_tracking_uninit +#endif +#ifdef GENERATOR_FILE +extern int flag_variable_expansion_in_unroller; +#else + int x_flag_variable_expansion_in_unroller; +#define flag_variable_expansion_in_unroller global_options.x_flag_variable_expansion_in_unroller +#endif +#ifdef GENERATOR_FILE +extern int flag_vect_cost_model; +#else + int x_flag_vect_cost_model; +#define flag_vect_cost_model global_options.x_flag_vect_cost_model +#endif +#ifdef GENERATOR_FILE +extern int flag_verbose_asm; +#else + int x_flag_verbose_asm; +#define flag_verbose_asm global_options.x_flag_verbose_asm +#endif +#ifdef GENERATOR_FILE +extern int flag_visibility_ms_compat; +#else + int x_flag_visibility_ms_compat; +#define flag_visibility_ms_compat global_options.x_flag_visibility_ms_compat +#endif +#ifdef GENERATOR_FILE +extern enum symbol_visibility default_visibility; +#else + enum symbol_visibility x_default_visibility; +#define default_visibility global_options.x_default_visibility +#endif +#ifdef GENERATOR_FILE +extern int flag_value_profile_transformations; +#else + int x_flag_value_profile_transformations; +#define flag_value_profile_transformations global_options.x_flag_value_profile_transformations +#endif +#ifdef GENERATOR_FILE +extern int flag_weak; +#else + int x_flag_weak; +#define flag_weak global_options.x_flag_weak +#endif +#ifdef GENERATOR_FILE +extern int flag_web; +#else + int x_flag_web; +#define flag_web global_options.x_flag_web +#endif +#ifdef GENERATOR_FILE +extern int flag_whole_program; +#else + int x_flag_whole_program; +#define flag_whole_program global_options.x_flag_whole_program +#endif +#ifdef GENERATOR_FILE +extern int flag_working_directory; +#else + int x_flag_working_directory; +#define flag_working_directory global_options.x_flag_working_directory +#endif +#ifdef GENERATOR_FILE +extern int flag_wpa; +#else + int x_flag_wpa; +#define flag_wpa global_options.x_flag_wpa +#endif +#ifdef GENERATOR_FILE +extern int flag_wrapv; +#else + int x_flag_wrapv; +#define flag_wrapv global_options.x_flag_wrapv +#endif +#ifdef GENERATOR_FILE +extern int flag_zee; +#else + int x_flag_zee; +#define flag_zee global_options.x_flag_zee +#endif +#ifdef GENERATOR_FILE +extern int flag_zero_initialized_in_bss; +#else + int x_flag_zero_initialized_in_bss; +#define flag_zero_initialized_in_bss global_options.x_flag_zero_initialized_in_bss +#endif +#ifdef GENERATOR_FILE +extern int flag_zero_link; +#else + int x_flag_zero_link; +#define flag_zero_link global_options.x_flag_zero_link +#endif +#ifdef GENERATOR_FILE +extern int dwarf_version; +#else + int x_dwarf_version; +#define dwarf_version global_options.x_dwarf_version +#endif +#ifdef GENERATOR_FILE +extern int flag_gen_declaration; +#else + int x_flag_gen_declaration; +#define flag_gen_declaration global_options.x_flag_gen_declaration +#endif +#ifdef GENERATOR_FILE +extern int dwarf_strict; +#else + int x_dwarf_strict; +#define dwarf_strict global_options.x_dwarf_strict +#endif +#ifdef GENERATOR_FILE +extern int flag_gtoggle; +#else + int x_flag_gtoggle; +#define flag_gtoggle global_options.x_flag_gtoggle +#endif +#ifdef GENERATOR_FILE +extern const char *plugindir_string; +#else + const char *x_plugindir_string; +#define plugindir_string global_options.x_plugindir_string +#endif +#ifdef GENERATOR_FILE +extern const char *target_abi_name; +#else + const char *x_target_abi_name; +#define target_abi_name global_options.x_target_abi_name +#endif +#ifdef GENERATOR_FILE +extern int fix_cm3_ldrd; +#else + int x_fix_cm3_ldrd; +#define fix_cm3_ldrd global_options.x_fix_cm3_ldrd +#endif +#ifdef GENERATOR_FILE +extern const char *target_float_abi_name; +#else + const char *x_target_float_abi_name; +#define target_float_abi_name global_options.x_target_float_abi_name +#endif +#ifdef GENERATOR_FILE +extern const char *target_fp16_format_name; +#else + const char *x_target_fp16_format_name; +#define target_fp16_format_name global_options.x_target_fp16_format_name +#endif +#ifdef GENERATOR_FILE +extern const char *target_fpe_name; +#else + const char *x_target_fpe_name; +#define target_fpe_name global_options.x_target_fpe_name +#endif +#ifdef GENERATOR_FILE +extern const char *target_fpu_name; +#else + const char *x_target_fpu_name; +#define target_fpu_name global_options.x_target_fpu_name +#endif +#ifdef GENERATOR_FILE +extern const char *arm_pic_register_string; +#else + const char *x_arm_pic_register_string; +#define arm_pic_register_string global_options.x_arm_pic_register_string +#endif +#ifdef GENERATOR_FILE +extern const char *structure_size_string; +#else + const char *x_structure_size_string; +#define structure_size_string global_options.x_structure_size_string +#endif +#ifdef GENERATOR_FILE +extern const char *target_thread_switch; +#else + const char *x_target_thread_switch; +#define target_thread_switch global_options.x_target_thread_switch +#endif +#ifdef GENERATOR_FILE +extern int target_word_relocations; +#else + int x_target_word_relocations; +#define target_word_relocations global_options.x_target_word_relocations +#endif +#ifdef GENERATOR_FILE +extern const char *asm_file_name; +#else + const char *x_asm_file_name; +#define asm_file_name global_options.x_asm_file_name +#endif +#ifdef GENERATOR_FILE +extern int pass_exit_codes; +#else + int x_pass_exit_codes; +#define pass_exit_codes global_options.x_pass_exit_codes +#endif +#ifdef GENERATOR_FILE +extern int pedantic; +#else + int x_pedantic; +#define pedantic global_options.x_pedantic +#endif +#ifdef GENERATOR_FILE +extern int flag_pedantic_errors; +#else + int x_flag_pedantic_errors; +#define flag_pedantic_errors global_options.x_flag_pedantic_errors +#endif +#ifdef GENERATOR_FILE +extern int use_pipes; +#else + int x_use_pipes; +#define use_pipes global_options.x_use_pipes +#endif +#ifdef GENERATOR_FILE +extern const char *print_file_name; +#else + const char *x_print_file_name; +#define print_file_name global_options.x_print_file_name +#endif +#ifdef GENERATOR_FILE +extern int print_multi_directory; +#else + int x_print_multi_directory; +#define print_multi_directory global_options.x_print_multi_directory +#endif +#ifdef GENERATOR_FILE +extern int print_multi_lib; +#else + int x_print_multi_lib; +#define print_multi_lib global_options.x_print_multi_lib +#endif +#ifdef GENERATOR_FILE +extern int print_multi_os_directory; +#else + int x_print_multi_os_directory; +#define print_multi_os_directory global_options.x_print_multi_os_directory +#endif +#ifdef GENERATOR_FILE +extern const char *print_prog_name; +#else + const char *x_print_prog_name; +#define print_prog_name global_options.x_print_prog_name +#endif +#ifdef GENERATOR_FILE +extern int print_search_dirs; +#else + int x_print_search_dirs; +#define print_search_dirs global_options.x_print_search_dirs +#endif +#ifdef GENERATOR_FILE +extern int print_sysroot; +#else + int x_print_sysroot; +#define print_sysroot global_options.x_print_sysroot +#endif +#ifdef GENERATOR_FILE +extern int print_sysroot_headers_suffix; +#else + int x_print_sysroot_headers_suffix; +#define print_sysroot_headers_suffix global_options.x_print_sysroot_headers_suffix +#endif +#ifdef GENERATOR_FILE +extern int quiet_flag; +#else + int x_quiet_flag; +#define quiet_flag global_options.x_quiet_flag +#endif +#ifdef GENERATOR_FILE +extern int report_times; +#else + int x_report_times; +#define report_times global_options.x_report_times +#endif +#ifdef GENERATOR_FILE +extern int flag_undef; +#else + int x_flag_undef; +#define flag_undef global_options.x_flag_undef +#endif +#ifdef GENERATOR_FILE +extern int verbose_flag; +#else + int x_verbose_flag; +#define verbose_flag global_options.x_verbose_flag +#endif +#ifdef GENERATOR_FILE +extern int version_flag; +#else + int x_version_flag; +#define version_flag global_options.x_version_flag +#endif +#ifdef GENERATOR_FILE +extern int inhibit_warnings; +#else + int x_inhibit_warnings; +#define inhibit_warnings global_options.x_inhibit_warnings +#endif +#ifdef GENERATOR_FILE +extern const char *wrapper_string; +#else + const char *x_wrapper_string; +#define wrapper_string global_options.x_wrapper_string +#endif +#ifndef GENERATOR_FILE + const char *x_VAR_march_; +#define x_VAR_march_ do_not_use +#endif +#ifndef GENERATOR_FILE + const char *x_VAR_mcpu_; +#define x_VAR_mcpu_ do_not_use +#endif +#ifndef GENERATOR_FILE + int x_VAR_mhard_float; +#define x_VAR_mhard_float do_not_use +#endif +#ifndef GENERATOR_FILE + int x_VAR_msoft_float; +#define x_VAR_msoft_float do_not_use +#endif +#ifndef GENERATOR_FILE + const char *x_VAR_mtune_; +#define x_VAR_mtune_ do_not_use +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_associative_math; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_cx_limited_range; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_finite_math_only; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_errno_math; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_reciprocal_math; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_rounding_math; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_signaling_nans; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_signed_zeros; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_trapping_math; +#endif +#ifndef GENERATOR_FILE + bool frontend_set_flag_unsafe_math_optimizations; +#endif +#ifndef GENERATOR_FILE +}; +extern struct gcc_options global_options; +extern const struct gcc_options global_options_init; +extern struct gcc_options global_options_set; +#define target_flags_explicit global_options_set.x_target_flags +#endif +#endif + +#if !defined(GCC_DRIVER) && !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) + +/* Structure to save/restore optimization and target specific options. */ +struct GTY(()) cl_optimization +{ + int x_align_functions; + int x_align_jumps; + int x_align_labels; + int x_align_loops; + int x_flag_sched_stalled_insns; + int x_flag_sched_stalled_insns_dep; + enum fp_contract_mode x_flag_fp_contract_mode; + unsigned char x_optimize; + unsigned char x_optimize_size; + signed char x_flag_asynchronous_unwind_tables; + signed char x_flag_branch_on_count_reg; + signed char x_flag_branch_probabilities; + signed char x_flag_branch_target_load_optimize; + signed char x_flag_branch_target_load_optimize2; + signed char x_flag_btr_bb_exclusive; + signed char x_flag_caller_saves; + signed char x_flag_combine_stack_adjustments; + signed char x_flag_no_common; + signed char x_flag_compare_elim_after_reload; + signed char x_flag_conserve_stack; + signed char x_flag_cprop_registers; + signed char x_flag_crossjumping; + signed char x_flag_cse_follow_jumps; + signed char x_flag_cx_fortran_rules; + signed char x_flag_cx_limited_range; + signed char x_flag_data_sections; + signed char x_flag_dce; + signed char x_flag_defer_pop; + signed char x_flag_delayed_branch; + signed char x_flag_delete_null_pointer_checks; + signed char x_flag_devirtualize; + signed char x_flag_dse; + signed char x_flag_early_inlining; + signed char x_flag_exceptions; + signed char x_flag_expensive_optimizations; + signed char x_flag_finite_math_only; + signed char x_flag_float_store; + signed char x_flag_forward_propagate; + signed char x_flag_gcse; + signed char x_flag_gcse_after_reload; + signed char x_flag_gcse_las; + signed char x_flag_gcse_lm; + signed char x_flag_gcse_sm; + signed char x_flag_graphite_identity; + signed char x_flag_guess_branch_prob; + signed char x_flag_if_conversion; + signed char x_flag_if_conversion2; + signed char x_flag_inline_functions; + signed char x_flag_inline_functions_called_once; + signed char x_flag_inline_hot_caller; + signed char x_flag_inline_small_functions; + signed char x_flag_ipa_cp; + signed char x_flag_ipa_cp_clone; + signed char x_flag_ipa_matrix_reorg; + signed char x_flag_ipa_profile; + signed char x_flag_ipa_pta; + signed char x_flag_ipa_pure_const; + signed char x_flag_ipa_reference; + signed char x_flag_ipa_sra; + signed char x_flag_ivopts; + signed char x_flag_jump_tables; + signed char x_flag_loop_block; + signed char x_flag_loop_flatten; + signed char x_flag_loop_interchange; + signed char x_flag_loop_parallelize_all; + signed char x_flag_loop_strip_mine; + signed char x_flag_lto_report; + signed char x_flag_ltrans; + signed char x_flag_errno_math; + signed char x_flag_merge_constants; + signed char x_flag_modulo_sched; + signed char x_flag_move_loop_invariants; + signed char x_flag_non_call_exceptions; + signed char x_flag_nothrow_opt; + signed char x_flag_omit_frame_pointer; + signed char x_flag_opt_info; + signed char x_flag_regmove; + signed char x_flag_optimize_sibling_calls; + signed char x_flag_pack_struct; + signed char x_flag_peel_loops; + signed char x_flag_no_peephole; + signed char x_flag_peephole2; + signed char x_flag_predictive_commoning; + signed char x_flag_prefetch_loop_arrays; + signed char x_flag_profile_dump; + signed char x_flag_pcc_struct_return; + signed char x_flag_rename_registers; + signed char x_flag_reorder_blocks; + signed char x_flag_reorder_blocks_and_partition; + signed char x_flag_reorder_functions; + signed char x_flag_rerun_cse_after_loop; + signed char x_flag_resched_modulo_sched; + signed char x_flag_ripa_peel_size_limit; + signed char x_flag_ripa_unroll_size_limit; + signed char x_flag_rounding_math; + signed char x_flag_rtti; + signed char x_flag_sched_critical_path_heuristic; + signed char x_flag_sched_dep_count_heuristic; + signed char x_flag_sched_group_heuristic; + signed char x_flag_schedule_interblock; + signed char x_flag_sched_last_insn_heuristic; + signed char x_flag_sched_pressure; + signed char x_flag_sched_rank_heuristic; + signed char x_flag_schedule_speculative; + signed char x_flag_sched_spec_insn_heuristic; + signed char x_flag_schedule_speculative_load; + signed char x_flag_schedule_speculative_load_dangerous; + signed char x_flag_sched2_use_superblocks; + signed char x_flag_schedule_insns; + signed char x_flag_schedule_insns_after_reload; + signed char x_flag_section_anchors; + signed char x_flag_sel_sched_pipelining; + signed char x_flag_sel_sched_pipelining_outer_loops; + signed char x_flag_sel_sched_reschedule_pipelined; + signed char x_flag_selective_scheduling; + signed char x_flag_selective_scheduling2; + signed char x_flag_short_double; + signed char x_flag_short_enums; + signed char x_flag_short_wchar; + signed char x_flag_signaling_nans; + signed char x_flag_signed_zeros; + signed char x_flag_single_precision_constant; + signed char x_flag_sized_delete; + signed char x_flag_split_ivs_in_unroller; + signed char x_flag_split_wide_types; + signed char x_flag_strict_aliasing; + signed char x_flag_strict_enum_precision; + signed char x_flag_strict_enums; + signed char x_flag_thread_jumps; + signed char x_flag_threadsafe_statics; + signed char x_flag_toplevel_reorder; + signed char x_flag_trapping_math; + signed char x_flag_trapv; + signed char x_flag_tree_bit_ccp; + signed char x_flag_tree_builtin_call_dce; + signed char x_flag_tree_ccp; + signed char x_flag_tree_ch; + signed char x_flag_tree_copy_prop; + signed char x_flag_tree_copyrename; + signed char x_flag_tree_cselim; + signed char x_flag_tree_dce; + signed char x_flag_tree_dom; + signed char x_flag_tree_dse; + signed char x_flag_tree_forwprop; + signed char x_flag_tree_fre; + signed char x_flag_tree_loop_distribute_patterns; + signed char x_flag_tree_loop_distribution; + signed char x_flag_tree_loop_if_convert; + signed char x_flag_tree_loop_if_convert_stores; + signed char x_flag_tree_loop_im; + signed char x_flag_tree_loop_ivcanon; + signed char x_flag_tree_loop_optimize; + signed char x_flag_tree_live_range_split; + signed char x_flag_tree_phiprop; + signed char x_flag_tree_pre; + signed char x_flag_tree_pta; + signed char x_flag_tree_reassoc; + signed char x_flag_tree_scev_cprop; + signed char x_flag_tree_sink; + signed char x_flag_tree_slp_vectorize; + signed char x_flag_tree_sra; + signed char x_flag_tree_switch_conversion; + signed char x_flag_tree_ter; + signed char x_flag_tree_vect_loop_version; + signed char x_flag_tree_vectorize; + signed char x_flag_tree_vrp; + signed char x_flag_unit_at_a_time; + signed char x_flag_unroll_all_loops; + signed char x_flag_unroll_loops; + signed char x_flag_unsafe_loop_optimizations; + signed char x_flag_unsafe_math_optimizations; + signed char x_flag_unswitch_loops; + signed char x_flag_unwind_tables; + signed char x_flag_var_tracking; + signed char x_flag_var_tracking_assignments; + signed char x_flag_var_tracking_assignments_toggle; + signed char x_flag_var_tracking_uninit; + signed char x_flag_variable_expansion_in_unroller; + signed char x_flag_vect_cost_model; + signed char x_flag_value_profile_transformations; + signed char x_flag_web; + signed char x_flag_whole_program; + signed char x_flag_wpa; + signed char x_flag_wrapv; +}; + +/* Structure to save/restore selected target specific options. */ +struct GTY(()) cl_target_option +{ + int x_target_flags; +}; + + +/* Save optimization variables into a structure. */ +extern void cl_optimization_save (struct cl_optimization *, struct gcc_options *); + +/* Restore optimization variables from a structure. */ +extern void cl_optimization_restore (struct gcc_options *, struct cl_optimization *); + +/* Print optimization variables from a structure. */ +extern void cl_optimization_print (FILE *, int, struct cl_optimization *); + +/* Save selected option variables into a structure. */ +extern void cl_target_option_save (struct cl_target_option *, struct gcc_options *); + +/* Restore selected option variables from a structure. */ +extern void cl_target_option_restore (struct gcc_options *, struct cl_target_option *); + +/* Print target option variables from a structure. */ +extern void cl_target_option_print (FILE *, int, struct cl_target_option *); +#endif + +#define MASK_ABORT_NORETURN (1 << 0) +#define MASK_APCS_FLOAT (1 << 1) +#define MASK_APCS_FRAME (1 << 2) +#define MASK_APCS_REENT (1 << 3) +#define MASK_APCS_STACK (1 << 4) +#define MASK_BIG_END (1 << 5) +#define MASK_CALLEE_INTERWORKING (1 << 6) +#define MASK_CALLER_INTERWORKING (1 << 7) +#define MASK_CIRRUS_FIX_INVALID_INSNS (1 << 8) +#define MASK_FPE (1 << 9) +#define MASK_LONG_CALLS (1 << 10) +#define MASK_POKE_FUNCTION_NAME (1 << 11) +#define MASK_SCHED_PROLOG (1 << 12) +#define MASK_SINGLE_PIC_BASE (1 << 13) +#define MASK_THUMB (1 << 14) +#define MASK_INTERWORK (1 << 15) +#define MASK_TPCS_FRAME (1 << 16) +#define MASK_TPCS_LEAF_FRAME (1 << 17) +#define MASK_NEON_VECTORIZE_QUAD (1 << 18) +#define MASK_LITTLE_WORDS (1 << 19) + +#define TARGET_ABORT_NORETURN ((target_flags & MASK_ABORT_NORETURN) != 0) +#define TARGET_APCS_FLOAT ((target_flags & MASK_APCS_FLOAT) != 0) +#define TARGET_APCS_FRAME ((target_flags & MASK_APCS_FRAME) != 0) +#define TARGET_APCS_REENT ((target_flags & MASK_APCS_REENT) != 0) +#define TARGET_APCS_STACK ((target_flags & MASK_APCS_STACK) != 0) +#define TARGET_BIG_END ((target_flags & MASK_BIG_END) != 0) +#define TARGET_CALLEE_INTERWORKING ((target_flags & MASK_CALLEE_INTERWORKING) != 0) +#define TARGET_CALLER_INTERWORKING ((target_flags & MASK_CALLER_INTERWORKING) != 0) +#define TARGET_CIRRUS_FIX_INVALID_INSNS ((target_flags & MASK_CIRRUS_FIX_INVALID_INSNS) != 0) +#define TARGET_FPE ((target_flags & MASK_FPE) != 0) +#define TARGET_LONG_CALLS ((target_flags & MASK_LONG_CALLS) != 0) +#define TARGET_POKE_FUNCTION_NAME ((target_flags & MASK_POKE_FUNCTION_NAME) != 0) +#define TARGET_SCHED_PROLOG ((target_flags & MASK_SCHED_PROLOG) != 0) +#define TARGET_SINGLE_PIC_BASE ((target_flags & MASK_SINGLE_PIC_BASE) != 0) +#define TARGET_THUMB ((target_flags & MASK_THUMB) != 0) +#define TARGET_INTERWORK ((target_flags & MASK_INTERWORK) != 0) +#define TARGET_TPCS_FRAME ((target_flags & MASK_TPCS_FRAME) != 0) +#define TARGET_TPCS_LEAF_FRAME ((target_flags & MASK_TPCS_LEAF_FRAME) != 0) +#define TARGET_NEON_VECTORIZE_QUAD ((target_flags & MASK_NEON_VECTORIZE_QUAD) != 0) +#define TARGET_LITTLE_WORDS ((target_flags & MASK_LITTLE_WORDS) != 0) + + +#define CL_Ada (1 << 0) +#define CL_C (1 << 1) +#define CL_CXX (1 << 2) +#define CL_Fortran (1 << 3) +#define CL_Go (1 << 4) +#define CL_Java (1 << 5) +#define CL_LTO (1 << 6) +#define CL_ObjC (1 << 7) +#define CL_ObjCXX (1 << 8) +#define CL_LANG_ALL ((1 << 9) - 1) + +enum opt_code +{ + OPT____ = 0, /* -### */ + /* OPT__CLASSPATH = 1, */ /* --CLASSPATH */ + /* OPT__all_warnings = 2, */ /* --all-warnings */ + /* OPT__ansi = 3, */ /* --ansi */ + /* OPT__assemble = 4, */ /* --assemble */ + /* OPT__assert = 5, */ /* --assert */ + /* OPT__assert_ = 6, */ /* --assert= */ + /* OPT__bootclasspath = 7, */ /* --bootclasspath */ + /* OPT__canonical_prefixes = 8, */ /* --canonical-prefixes */ + /* OPT__classpath = 9, */ /* --classpath */ + /* OPT__comments = 10, */ /* --comments */ + /* OPT__comments_in_macros = 11, */ /* --comments-in-macros */ + /* OPT__compile = 12, */ /* --compile */ + /* OPT__coverage = 13, */ /* --coverage */ + /* OPT__debug = 14, */ /* --debug */ + /* OPT__define_macro = 15, */ /* --define-macro */ + /* OPT__define_macro_ = 16, */ /* --define-macro= */ + /* OPT__dependencies = 17, */ /* --dependencies */ + /* OPT__dump = 18, */ /* --dump */ + /* OPT__dump_ = 19, */ /* --dump= */ + /* OPT__dumpbase = 20, */ /* --dumpbase */ + /* OPT__dumpdir = 21, */ /* --dumpdir */ + /* OPT__encoding = 22, */ /* --encoding */ + /* OPT__entry = 23, */ /* --entry */ + /* OPT__entry_ = 24, */ /* --entry= */ + /* OPT__extdirs = 25, */ /* --extdirs */ + /* OPT__extra_warnings = 26, */ /* --extra-warnings */ + /* OPT__for_assembler = 27, */ /* --for-assembler */ + /* OPT__for_assembler_ = 28, */ /* --for-assembler= */ + /* OPT__for_linker = 29, */ /* --for-linker */ + /* OPT__for_linker_ = 30, */ /* --for-linker= */ + /* OPT__force_link = 31, */ /* --force-link */ + /* OPT__force_link_ = 32, */ /* --force-link= */ + OPT__help = 33, /* --help */ + OPT__help_ = 34, /* --help= */ + /* OPT__imacros = 35, */ /* --imacros */ + /* OPT__imacros_ = 36, */ /* --imacros= */ + /* OPT__include = 37, */ /* --include */ + /* OPT__include_barrier = 38, */ /* --include-barrier */ + /* OPT__include_directory = 39, */ /* --include-directory */ + /* OPT__include_directory_after = 40, */ /* --include-directory-after */ + /* OPT__include_directory_after_ = 41, */ /* --include-directory-after= */ + /* OPT__include_directory_ = 42, */ /* --include-directory= */ + /* OPT__include_prefix = 43, */ /* --include-prefix */ + /* OPT__include_prefix_ = 44, */ /* --include-prefix= */ + /* OPT__include_with_prefix = 45, */ /* --include-with-prefix */ + /* OPT__include_with_prefix_after = 46, */ /* --include-with-prefix-after */ + /* OPT__include_with_prefix_after_ = 47, *//* --include-with-prefix-after= */ + /* OPT__include_with_prefix_before = 48, *//* --include-with-prefix-before */ + /* OPT__include_with_prefix_before_ = 49, *//* --include-with-prefix-before= */ + /* OPT__include_with_prefix_ = 50, */ /* --include-with-prefix= */ + /* OPT__include_ = 51, */ /* --include= */ + /* OPT__language = 52, */ /* --language */ + /* OPT__language_ = 53, */ /* --language= */ + /* OPT__library_directory = 54, */ /* --library-directory */ + /* OPT__library_directory_ = 55, */ /* --library-directory= */ + /* OPT__no_canonical_prefixes = 56, */ /* --no-canonical-prefixes */ + /* OPT__no_integrated_cpp = 57, */ /* --no-integrated-cpp */ + /* OPT__no_line_commands = 58, */ /* --no-line-commands */ + /* OPT__no_standard_includes = 59, */ /* --no-standard-includes */ + /* OPT__no_standard_libraries = 60, */ /* --no-standard-libraries */ + /* OPT__no_warnings = 61, */ /* --no-warnings */ + /* OPT__optimize = 62, */ /* --optimize */ + /* OPT__output = 63, */ /* --output */ + /* OPT__output_class_directory = 64, */ /* --output-class-directory */ + /* OPT__output_class_directory_ = 65, */ /* --output-class-directory= */ + OPT__output_pch_ = 66, /* --output-pch= */ + /* OPT__output_ = 67, */ /* --output= */ + OPT__param = 68, /* --param */ + /* OPT__param_ = 69, */ /* --param= */ + /* OPT__pass_exit_codes = 70, */ /* --pass-exit-codes */ + /* OPT__pedantic = 71, */ /* --pedantic */ + /* OPT__pedantic_errors = 72, */ /* --pedantic-errors */ + /* OPT__pie = 73, */ /* --pie */ + /* OPT__pipe = 74, */ /* --pipe */ + /* OPT__prefix = 75, */ /* --prefix */ + /* OPT__prefix_ = 76, */ /* --prefix= */ + /* OPT__preprocess = 77, */ /* --preprocess */ + /* OPT__print_file_name = 78, */ /* --print-file-name */ + /* OPT__print_file_name_ = 79, */ /* --print-file-name= */ + /* OPT__print_libgcc_file_name = 80, */ /* --print-libgcc-file-name */ + /* OPT__print_missing_file_dependencies = 81, *//* --print-missing-file-dependencies */ + /* OPT__print_multi_directory = 82, */ /* --print-multi-directory */ + /* OPT__print_multi_lib = 83, */ /* --print-multi-lib */ + /* OPT__print_multi_os_directory = 84, */ /* --print-multi-os-directory */ + /* OPT__print_prog_name = 85, */ /* --print-prog-name */ + /* OPT__print_prog_name_ = 86, */ /* --print-prog-name= */ + /* OPT__print_search_dirs = 87, */ /* --print-search-dirs */ + /* OPT__print_sysroot = 88, */ /* --print-sysroot */ + /* OPT__print_sysroot_headers_suffix = 89, *//* --print-sysroot-headers-suffix */ + /* OPT__profile = 90, */ /* --profile */ + /* OPT__resource = 91, */ /* --resource */ + /* OPT__resource_ = 92, */ /* --resource= */ + /* OPT__save_temps = 93, */ /* --save-temps */ + /* OPT__shared = 94, */ /* --shared */ + /* OPT__specs = 95, */ /* --specs */ + /* OPT__specs_ = 96, */ /* --specs= */ + /* OPT__static = 97, */ /* --static */ + /* OPT__symbolic = 98, */ /* --symbolic */ + /* OPT__sysroot = 99, */ /* --sysroot */ + OPT__sysroot_ = 100, /* --sysroot= */ + OPT__target_help = 101, /* --target-help */ + /* OPT__time = 102, */ /* --time */ + /* OPT__trace_includes = 103, */ /* --trace-includes */ + /* OPT__traditional = 104, */ /* --traditional */ + /* OPT__traditional_cpp = 105, */ /* --traditional-cpp */ + /* OPT__trigraphs = 106, */ /* --trigraphs */ + /* OPT__undefine_macro = 107, */ /* --undefine-macro */ + /* OPT__undefine_macro_ = 108, */ /* --undefine-macro= */ + /* OPT__user_dependencies = 109, */ /* --user-dependencies */ + /* OPT__verbose = 110, */ /* --verbose */ + OPT__version = 111, /* --version */ + /* OPT__write_dependencies = 112, */ /* --write-dependencies */ + /* OPT__write_user_dependencies = 113, */ /* --write-user-dependencies */ + OPT_A = 114, /* -A */ + OPT_B = 115, /* -B */ + OPT_C = 116, /* -C */ + OPT_CC = 117, /* -CC */ + /* OPT_CLASSPATH = 118, */ /* -CLASSPATH */ + OPT_D = 119, /* -D */ + OPT_E = 120, /* -E */ + OPT_F = 121, /* -F */ + OPT_H = 122, /* -H */ + OPT_I = 123, /* -I */ + OPT_J = 124, /* -J */ + OPT_L = 125, /* -L */ + OPT_M = 126, /* -M */ + OPT_MD = 127, /* -MD */ + OPT_MD_ = 128, /* -MD_ */ + OPT_MF = 129, /* -MF */ + OPT_MG = 130, /* -MG */ + OPT_MM = 131, /* -MM */ + OPT_MMD = 132, /* -MMD */ + OPT_MMD_ = 133, /* -MMD_ */ + OPT_MP = 134, /* -MP */ + OPT_MQ = 135, /* -MQ */ + OPT_MT = 136, /* -MT */ + OPT_N = 137, /* -N */ + OPT_O = 138, /* -O */ + OPT_Ofast = 139, /* -Ofast */ + OPT_Os = 140, /* -Os */ + OPT_P = 141, /* -P */ + OPT_Q = 142, /* -Q */ + OPT_Qn = 143, /* -Qn */ + OPT_Qy = 144, /* -Qy */ + OPT_R = 145, /* -R */ + OPT_S = 146, /* -S */ + OPT_T = 147, /* -T */ + OPT_Tbss = 148, /* -Tbss */ + OPT_Tbss_ = 149, /* -Tbss= */ + OPT_Tdata = 150, /* -Tdata */ + OPT_Tdata_ = 151, /* -Tdata= */ + OPT_Ttext = 152, /* -Ttext */ + OPT_Ttext_ = 153, /* -Ttext= */ + OPT_U = 154, /* -U */ + /* OPT_W = 155, */ /* -W */ + OPT_Wa_ = 156, /* -Wa, */ + OPT_Wabi = 157, /* -Wabi */ + OPT_Waddress = 158, /* -Waddress */ + OPT_Waggregate_return = 159, /* -Waggregate-return */ + OPT_Waliasing = 160, /* -Waliasing */ + OPT_Walign_commons = 161, /* -Walign-commons */ + OPT_Wall = 162, /* -Wall */ + OPT_Wall_deprecation = 163, /* -Wall-deprecation */ + OPT_Wall_javadoc = 164, /* -Wall-javadoc */ + OPT_Wampersand = 165, /* -Wampersand */ + OPT_Warray_bounds = 166, /* -Warray-bounds */ + OPT_Warray_temporaries = 167, /* -Warray-temporaries */ + OPT_Wassert_identifier = 168, /* -Wassert-identifier */ + OPT_Wassign_intercept = 169, /* -Wassign-intercept */ + OPT_Wattributes = 170, /* -Wattributes */ + OPT_Wbad_function_cast = 171, /* -Wbad-function-cast */ + OPT_Wboxing = 172, /* -Wboxing */ + OPT_Wbuiltin_macro_redefined = 173, /* -Wbuiltin-macro-redefined */ + OPT_Wc___compat = 174, /* -Wc++-compat */ + OPT_Wc__0x_compat = 175, /* -Wc++0x-compat */ + /* OPT_Wc__11_compat = 176, */ /* -Wc++11-compat */ + OPT_Wcast_align = 177, /* -Wcast-align */ + OPT_Wcast_qual = 178, /* -Wcast-qual */ + OPT_Wchar_concat = 179, /* -Wchar-concat */ + OPT_Wchar_subscripts = 180, /* -Wchar-subscripts */ + OPT_Wcharacter_truncation = 181, /* -Wcharacter-truncation */ + OPT_Wclobbered = 182, /* -Wclobbered */ + OPT_Wcomment = 183, /* -Wcomment */ + /* OPT_Wcomments = 184, */ /* -Wcomments */ + OPT_Wcondition_assign = 185, /* -Wcondition-assign */ + OPT_Wconstructor_name = 186, /* -Wconstructor-name */ + OPT_Wconversion = 187, /* -Wconversion */ + OPT_Wconversion_extra = 188, /* -Wconversion-extra */ + OPT_Wconversion_null = 189, /* -Wconversion-null */ + OPT_Wcoverage_mismatch = 190, /* -Wcoverage-mismatch */ + OPT_Wcpp = 191, /* -Wcpp */ + OPT_Wctor_dtor_privacy = 192, /* -Wctor-dtor-privacy */ + OPT_Wdeclaration_after_statement = 193, /* -Wdeclaration-after-statement */ + OPT_Wdep_ann = 194, /* -Wdep-ann */ + OPT_Wdeprecated = 195, /* -Wdeprecated */ + OPT_Wdeprecated_declarations = 196, /* -Wdeprecated-declarations */ + OPT_Wdisabled_optimization = 197, /* -Wdisabled-optimization */ + OPT_Wdiscouraged = 198, /* -Wdiscouraged */ + OPT_Wdiv_by_zero = 199, /* -Wdiv-by-zero */ + OPT_Wdouble_promotion = 200, /* -Wdouble-promotion */ + OPT_Weffc__ = 201, /* -Weffc++ */ + OPT_Wempty_block = 202, /* -Wempty-block */ + OPT_Wempty_body = 203, /* -Wempty-body */ + OPT_Wendif_labels = 204, /* -Wendif-labels */ + OPT_Wenum_compare = 205, /* -Wenum-compare */ + OPT_Wenum_identifier = 206, /* -Wenum-identifier */ + OPT_Wenum_switch = 207, /* -Wenum-switch */ + OPT_Werror = 208, /* -Werror */ + /* OPT_Werror_implicit_function_declaration = 209, *//* -Werror-implicit-function-declaration */ + OPT_Werror_ = 210, /* -Werror= */ + OPT_Wextra = 211, /* -Wextra */ + OPT_Wextraneous_semicolon = 212, /* -Wextraneous-semicolon */ + OPT_Wfallthrough = 213, /* -Wfallthrough */ + OPT_Wfatal_errors = 214, /* -Wfatal-errors */ + OPT_Wfield_hiding = 215, /* -Wfield-hiding */ + OPT_Wfinal_bound = 216, /* -Wfinal-bound */ + OPT_Wfinally = 217, /* -Wfinally */ + OPT_Wfloat_equal = 218, /* -Wfloat-equal */ + OPT_Wforbidden = 219, /* -Wforbidden */ + OPT_Wformat = 220, /* -Wformat */ + OPT_Wformat_contains_nul = 221, /* -Wformat-contains-nul */ + OPT_Wformat_extra_args = 222, /* -Wformat-extra-args */ + OPT_Wformat_nonliteral = 223, /* -Wformat-nonliteral */ + OPT_Wformat_security = 224, /* -Wformat-security */ + OPT_Wformat_y2k = 225, /* -Wformat-y2k */ + OPT_Wformat_zero_length = 226, /* -Wformat-zero-length */ + OPT_Wformat_ = 227, /* -Wformat= */ + OPT_Wframe_larger_than_ = 228, /* -Wframe-larger-than= */ + OPT_Whiding = 229, /* -Whiding */ + OPT_Wignored_qualifiers = 230, /* -Wignored-qualifiers */ + OPT_Wimplicit = 231, /* -Wimplicit */ + OPT_Wimplicit_function_declaration = 232, /* -Wimplicit-function-declaration */ + OPT_Wimplicit_int = 233, /* -Wimplicit-int */ + OPT_Wimplicit_interface = 234, /* -Wimplicit-interface */ + OPT_Wimplicit_procedure = 235, /* -Wimplicit-procedure */ + /* OPT_Wimport = 236, */ /* -Wimport */ + OPT_Windirect_static = 237, /* -Windirect-static */ + OPT_Winit_self = 238, /* -Winit-self */ + OPT_Winline = 239, /* -Winline */ + OPT_Wint_to_pointer_cast = 240, /* -Wint-to-pointer-cast */ + OPT_Wintf_annotation = 241, /* -Wintf-annotation */ + OPT_Wintf_non_inherited = 242, /* -Wintf-non-inherited */ + OPT_Wintrinsic_shadow = 243, /* -Wintrinsic-shadow */ + OPT_Wintrinsics_std = 244, /* -Wintrinsics-std */ + OPT_Winvalid_offsetof = 245, /* -Winvalid-offsetof */ + OPT_Winvalid_pch = 246, /* -Winvalid-pch */ + OPT_Wjavadoc = 247, /* -Wjavadoc */ + OPT_Wjump_misses_init = 248, /* -Wjump-misses-init */ + OPT_Wl_ = 249, /* -Wl, */ + /* OPT_Wlarger_than_ = 250, */ /* -Wlarger-than- */ + OPT_Wlarger_than_ = 251, /* -Wlarger-than= */ + OPT_Wline_truncation = 252, /* -Wline-truncation */ + OPT_Wlocal_hiding = 253, /* -Wlocal-hiding */ + OPT_Wlogical_op = 254, /* -Wlogical-op */ + OPT_Wlong_long = 255, /* -Wlong-long */ + OPT_Wmain = 256, /* -Wmain */ + OPT_Wmasked_catch_block = 257, /* -Wmasked-catch-block */ + OPT_Wmaybe_uninitialized = 258, /* -Wmaybe-uninitialized */ + OPT_Wmissing_braces = 259, /* -Wmissing-braces */ + OPT_Wmissing_declarations = 260, /* -Wmissing-declarations */ + OPT_Wmissing_field_initializers = 261, /* -Wmissing-field-initializers */ + OPT_Wmissing_format_attribute = 262, /* -Wmissing-format-attribute */ + OPT_Wmissing_include_dirs = 263, /* -Wmissing-include-dirs */ + OPT_Wmissing_noreturn = 264, /* -Wmissing-noreturn */ + OPT_Wmissing_parameter_type = 265, /* -Wmissing-parameter-type */ + OPT_Wmissing_prototypes = 266, /* -Wmissing-prototypes */ + OPT_Wmudflap = 267, /* -Wmudflap */ + OPT_Wmultichar = 268, /* -Wmultichar */ + OPT_Wnarrowing = 269, /* -Wnarrowing */ + OPT_Wnested_externs = 270, /* -Wnested-externs */ + OPT_Wnls = 271, /* -Wnls */ + OPT_Wno_effect_assign = 272, /* -Wno-effect-assign */ + OPT_Wnoexcept = 273, /* -Wnoexcept */ + OPT_Wnon_template_friend = 274, /* -Wnon-template-friend */ + OPT_Wnon_virtual_dtor = 275, /* -Wnon-virtual-dtor */ + OPT_Wnonnull = 276, /* -Wnonnull */ + OPT_Wnormalized_ = 277, /* -Wnormalized= */ + OPT_Wnull = 278, /* -Wnull */ + OPT_Wold_style_cast = 279, /* -Wold-style-cast */ + OPT_Wold_style_declaration = 280, /* -Wold-style-declaration */ + OPT_Wold_style_definition = 281, /* -Wold-style-definition */ + OPT_Wout_of_date = 282, /* -Wout-of-date */ + OPT_Wover_ann = 283, /* -Wover-ann */ + OPT_Woverflow = 284, /* -Woverflow */ + OPT_Woverlength_strings = 285, /* -Woverlength-strings */ + OPT_Woverloaded_virtual = 286, /* -Woverloaded-virtual */ + OPT_Woverride_init = 287, /* -Woverride-init */ + OPT_Wp_ = 288, /* -Wp, */ + OPT_Wpacked = 289, /* -Wpacked */ + OPT_Wpacked_bitfield_compat = 290, /* -Wpacked-bitfield-compat */ + OPT_Wpadded = 291, /* -Wpadded */ + OPT_Wparam_assign = 292, /* -Wparam-assign */ + OPT_Wparentheses = 293, /* -Wparentheses */ + OPT_Wpkg_default_method = 294, /* -Wpkg-default-method */ + OPT_Wpmf_conversions = 295, /* -Wpmf-conversions */ + OPT_Wpointer_arith = 296, /* -Wpointer-arith */ + OPT_Wpointer_sign = 297, /* -Wpointer-sign */ + OPT_Wpointer_to_int_cast = 298, /* -Wpointer-to-int-cast */ + OPT_Wpragmas = 299, /* -Wpragmas */ + OPT_Wproperty_assign_default = 300, /* -Wproperty-assign-default */ + OPT_Wprotocol = 301, /* -Wprotocol */ + OPT_Wpsabi = 302, /* -Wpsabi */ + OPT_Wraw = 303, /* -Wraw */ + OPT_Wreal_conversion = 304, /* -Wreal-conversion */ + OPT_Wreal_q_constant = 305, /* -Wreal-q-constant */ + OPT_Wredundant_decls = 306, /* -Wredundant-decls */ + OPT_Wredundant_modifiers = 307, /* -Wredundant-modifiers */ + OPT_Wreorder = 308, /* -Wreorder */ + OPT_Wreturn_type = 309, /* -Wreturn-type */ + OPT_Wripa_opt_mismatch = 310, /* -Wripa-opt-mismatch */ + OPT_Wselector = 311, /* -Wselector */ + OPT_Wself_assign = 312, /* -Wself-assign */ + OPT_Wself_assign_non_pod = 313, /* -Wself-assign-non-pod */ + OPT_Wsequence_point = 314, /* -Wsequence-point */ + OPT_Wserial = 315, /* -Wserial */ + OPT_Wshadow = 316, /* -Wshadow */ + OPT_Wshadow_compatible_local = 317, /* -Wshadow-compatible-local */ + OPT_Wshadow_local = 318, /* -Wshadow-local */ + OPT_Wsign_compare = 319, /* -Wsign-compare */ + OPT_Wsign_conversion = 320, /* -Wsign-conversion */ + OPT_Wsign_promo = 321, /* -Wsign-promo */ + OPT_Wspecial_param_hiding = 322, /* -Wspecial-param-hiding */ + OPT_Wstack_protector = 323, /* -Wstack-protector */ + OPT_Wstatic_access = 324, /* -Wstatic-access */ + OPT_Wstatic_receiver = 325, /* -Wstatic-receiver */ + OPT_Wstrict_aliasing = 326, /* -Wstrict-aliasing */ + OPT_Wstrict_aliasing_ = 327, /* -Wstrict-aliasing= */ + OPT_Wstrict_null_sentinel = 328, /* -Wstrict-null-sentinel */ + OPT_Wstrict_overflow = 329, /* -Wstrict-overflow */ + OPT_Wstrict_overflow_ = 330, /* -Wstrict-overflow= */ + OPT_Wstrict_prototypes = 331, /* -Wstrict-prototypes */ + OPT_Wstrict_selector_match = 332, /* -Wstrict-selector-match */ + OPT_Wsuggest_attribute_const = 333, /* -Wsuggest-attribute=const */ + OPT_Wsuggest_attribute_noreturn = 334, /* -Wsuggest-attribute=noreturn */ + OPT_Wsuggest_attribute_pure = 335, /* -Wsuggest-attribute=pure */ + OPT_Wsuppress = 336, /* -Wsuppress */ + OPT_Wsurprising = 337, /* -Wsurprising */ + OPT_Wswitch = 338, /* -Wswitch */ + OPT_Wswitch_default = 339, /* -Wswitch-default */ + OPT_Wswitch_enum = 340, /* -Wswitch-enum */ + OPT_Wsync_nand = 341, /* -Wsync-nand */ + OPT_Wsynth = 342, /* -Wsynth */ + OPT_Wsynthetic_access = 343, /* -Wsynthetic-access */ + OPT_Wsystem_headers = 344, /* -Wsystem-headers */ + OPT_Wtabs = 345, /* -Wtabs */ + OPT_Wtasks = 346, /* -Wtasks */ + OPT_Wthread_attr_bind_param = 347, /* -Wthread-attr-bind-param */ + OPT_Wthread_mismatched_lock_acq_rel = 348, /* -Wthread-mismatched-lock-acq-rel */ + OPT_Wthread_mismatched_lock_order = 349, /* -Wthread-mismatched-lock-order */ + OPT_Wthread_reentrant_lock = 350, /* -Wthread-reentrant-lock */ + OPT_Wthread_safety = 351, /* -Wthread-safety */ + OPT_Wthread_unguarded_func = 352, /* -Wthread-unguarded-func */ + OPT_Wthread_unguarded_var = 353, /* -Wthread-unguarded-var */ + OPT_Wthread_unsupported_lock_name = 354, /* -Wthread-unsupported-lock-name */ + OPT_Wthread_warn_optimization = 355, /* -Wthread-warn-optimization */ + OPT_Wtraditional = 356, /* -Wtraditional */ + OPT_Wtraditional_conversion = 357, /* -Wtraditional-conversion */ + OPT_Wtrampolines = 358, /* -Wtrampolines */ + OPT_Wtrigraphs = 359, /* -Wtrigraphs */ + OPT_Wtype_hiding = 360, /* -Wtype-hiding */ + OPT_Wtype_limits = 361, /* -Wtype-limits */ + OPT_Wuncheck = 362, /* -Wuncheck */ + OPT_Wundeclared_selector = 363, /* -Wundeclared-selector */ + OPT_Wundef = 364, /* -Wundef */ + OPT_Wunderflow = 365, /* -Wunderflow */ + OPT_Wuninitialized = 366, /* -Wuninitialized */ + OPT_Wunknown_pragmas = 367, /* -Wunknown-pragmas */ + OPT_Wunnecessary_else = 368, /* -Wunnecessary-else */ + OPT_Wunqualified_field = 369, /* -Wunqualified-field */ + /* OPT_Wunreachable_code = 370, */ /* -Wunreachable-code */ + OPT_Wunsafe_loop_optimizations = 371, /* -Wunsafe-loop-optimizations */ + OPT_Wunsuffixed_float_constants = 372, /* -Wunsuffixed-float-constants */ + OPT_Wunused = 373, /* -Wunused */ + OPT_Wunused_argument = 374, /* -Wunused-argument */ + OPT_Wunused_but_set_parameter = 375, /* -Wunused-but-set-parameter */ + OPT_Wunused_but_set_variable = 376, /* -Wunused-but-set-variable */ + OPT_Wunused_dummy_argument = 377, /* -Wunused-dummy-argument */ + OPT_Wunused_function = 378, /* -Wunused-function */ + OPT_Wunused_import = 379, /* -Wunused-import */ + OPT_Wunused_label = 380, /* -Wunused-label */ + OPT_Wunused_local = 381, /* -Wunused-local */ + OPT_Wunused_macros = 382, /* -Wunused-macros */ + OPT_Wunused_parameter = 383, /* -Wunused-parameter */ + OPT_Wunused_private = 384, /* -Wunused-private */ + OPT_Wunused_result = 385, /* -Wunused-result */ + OPT_Wunused_thrown = 386, /* -Wunused-thrown */ + OPT_Wunused_value = 387, /* -Wunused-value */ + OPT_Wunused_variable = 388, /* -Wunused-variable */ + OPT_Wuseless_type_check = 389, /* -Wuseless-type-check */ + OPT_Wvarargs_cast = 390, /* -Wvarargs-cast */ + OPT_Wvariadic_macros = 391, /* -Wvariadic-macros */ + OPT_Wvla = 392, /* -Wvla */ + OPT_Wvolatile_register_var = 393, /* -Wvolatile-register-var */ + OPT_Wwarning_token = 394, /* -Wwarning-token */ + OPT_Wwrite_strings = 395, /* -Wwrite-strings */ + OPT_Xassembler = 396, /* -Xassembler */ + OPT_Xlinker = 397, /* -Xlinker */ + OPT_Xpreprocessor = 398, /* -Xpreprocessor */ + OPT_Z = 399, /* -Z */ + OPT_ansi = 400, /* -ansi */ + OPT_aux_info = 401, /* -aux-info */ + /* OPT_aux_info_ = 402, */ /* -aux-info= */ + OPT_auxbase = 403, /* -auxbase */ + OPT_auxbase_strip = 404, /* -auxbase-strip */ + /* OPT_bootclasspath = 405, */ /* -bootclasspath */ + OPT_c = 406, /* -c */ + OPT_canonical_prefixes = 407, /* -canonical-prefixes */ + /* OPT_classpath = 408, */ /* -classpath */ + OPT_coverage = 409, /* -coverage */ + OPT_cpp = 410, /* -cpp */ + OPT_cpp_ = 411, /* -cpp= */ + OPT_d = 412, /* -d */ + OPT_dumpbase = 413, /* -dumpbase */ + OPT_dumpdir = 414, /* -dumpdir */ + OPT_dumpmachine = 415, /* -dumpmachine */ + OPT_dumpspecs = 416, /* -dumpspecs */ + OPT_dumpversion = 417, /* -dumpversion */ + OPT_e = 418, /* -e */ + /* OPT_encoding = 419, */ /* -encoding */ + OPT_export_dynamic = 420, /* -export-dynamic */ + OPT_extdirs = 421, /* -extdirs */ + /* OPT_fCLASSPATH_ = 422, */ /* -fCLASSPATH= */ + OPT_fPIC = 423, /* -fPIC */ + OPT_fPIE = 424, /* -fPIE */ + OPT_fRTS_ = 425, /* -fRTS= */ + OPT_fabi_version_ = 426, /* -fabi-version= */ + OPT_faccess_control = 427, /* -faccess-control */ + OPT_falign_commons = 428, /* -falign-commons */ + OPT_falign_functions = 429, /* -falign-functions */ + OPT_falign_functions_ = 430, /* -falign-functions= */ + OPT_falign_jumps = 431, /* -falign-jumps */ + OPT_falign_jumps_ = 432, /* -falign-jumps= */ + OPT_falign_labels = 433, /* -falign-labels */ + OPT_falign_labels_ = 434, /* -falign-labels= */ + OPT_falign_loops = 435, /* -falign-loops */ + OPT_falign_loops_ = 436, /* -falign-loops= */ + OPT_fall_intrinsics = 437, /* -fall-intrinsics */ + /* OPT_fall_virtual = 438, */ /* -fall-virtual */ + OPT_fallow_leading_underscore = 439, /* -fallow-leading-underscore */ + /* OPT_falt_external_templates = 440, */ /* -falt-external-templates */ + /* OPT_fargument_alias = 441, */ /* -fargument-alias */ + /* OPT_fargument_noalias = 442, */ /* -fargument-noalias */ + /* OPT_fargument_noalias_anything = 443, *//* -fargument-noalias-anything */ + /* OPT_fargument_noalias_global = 444, */ /* -fargument-noalias-global */ + OPT_fasm = 445, /* -fasm */ + OPT_fassert = 446, /* -fassert */ + OPT_fassociative_math = 447, /* -fassociative-math */ + OPT_fassume_compiled = 448, /* -fassume-compiled */ + OPT_fassume_compiled_ = 449, /* -fassume-compiled= */ + OPT_fasynchronous_unwind_tables = 450, /* -fasynchronous-unwind-tables */ + OPT_fauto_inc_dec = 451, /* -fauto-inc-dec */ + OPT_fautomatic = 452, /* -fautomatic */ + OPT_faux_classpath = 453, /* -faux-classpath */ + OPT_fbackslash = 454, /* -fbackslash */ + OPT_fbacktrace = 455, /* -fbacktrace */ + OPT_fblas_matmul_limit_ = 456, /* -fblas-matmul-limit= */ + OPT_fbootclasspath_ = 457, /* -fbootclasspath= */ + OPT_fbootstrap_classes = 458, /* -fbootstrap-classes */ + OPT_fbounds_check = 459, /* -fbounds-check */ + OPT_fbranch_count_reg = 460, /* -fbranch-count-reg */ + OPT_fbranch_probabilities = 461, /* -fbranch-probabilities */ + OPT_fbranch_target_load_optimize = 462, /* -fbranch-target-load-optimize */ + OPT_fbranch_target_load_optimize2 = 463, /* -fbranch-target-load-optimize2 */ + OPT_fbtr_bb_exclusive = 464, /* -fbtr-bb-exclusive */ + OPT_fbuiltin = 465, /* -fbuiltin */ + OPT_fbuiltin_ = 466, /* -fbuiltin- */ + OPT_fcall_saved_ = 467, /* -fcall-saved- */ + OPT_fcall_used_ = 468, /* -fcall-used- */ + OPT_fcaller_saves = 469, /* -fcaller-saves */ + OPT_fcallgraph_profiles_sections = 470, /* -fcallgraph-profiles-sections */ + OPT_fcheck_array_temporaries = 471, /* -fcheck-array-temporaries */ + OPT_fcheck_data_deps = 472, /* -fcheck-data-deps */ + OPT_fcheck_new = 473, /* -fcheck-new */ + OPT_fcheck_references = 474, /* -fcheck-references */ + OPT_fcheck_ = 475, /* -fcheck= */ + OPT_fclasspath_ = 476, /* -fclasspath= */ + OPT_fclone_hot_version_paths = 477, /* -fclone-hot-version-paths */ + OPT_fcoarray_ = 478, /* -fcoarray= */ + OPT_fcombine_stack_adjustments = 479, /* -fcombine-stack-adjustments */ + OPT_fcommon = 480, /* -fcommon */ + OPT_fcompare_debug = 481, /* -fcompare-debug */ + OPT_fcompare_debug_second = 482, /* -fcompare-debug-second */ + OPT_fcompare_debug_ = 483, /* -fcompare-debug= */ + OPT_fcompare_elim = 484, /* -fcompare-elim */ + OPT_fcompile_resource_ = 485, /* -fcompile-resource= */ + OPT_fcond_mismatch = 486, /* -fcond-mismatch */ + OPT_fconserve_space = 487, /* -fconserve-space */ + OPT_fconserve_stack = 488, /* -fconserve-stack */ + OPT_fconstant_string_class_ = 489, /* -fconstant-string-class= */ + OPT_fconstexpr_depth_ = 490, /* -fconstexpr-depth= */ + OPT_fconvert_big_endian = 491, /* -fconvert=big-endian */ + OPT_fconvert_little_endian = 492, /* -fconvert=little-endian */ + OPT_fconvert_native = 493, /* -fconvert=native */ + OPT_fconvert_swap = 494, /* -fconvert=swap */ + OPT_fcprop_registers = 495, /* -fcprop-registers */ + OPT_fcray_pointer = 496, /* -fcray-pointer */ + OPT_fcrossjumping = 497, /* -fcrossjumping */ + OPT_fcse_follow_jumps = 498, /* -fcse-follow-jumps */ + /* OPT_fcse_skip_blocks = 499, */ /* -fcse-skip-blocks */ + OPT_fcx_fortran_rules = 500, /* -fcx-fortran-rules */ + OPT_fcx_limited_range = 501, /* -fcx-limited-range */ + OPT_fd_lines_as_code = 502, /* -fd-lines-as-code */ + OPT_fd_lines_as_comments = 503, /* -fd-lines-as-comments */ + OPT_fdata_sections = 504, /* -fdata-sections */ + OPT_fdbg_cnt_list = 505, /* -fdbg-cnt-list */ + OPT_fdbg_cnt_ = 506, /* -fdbg-cnt= */ + OPT_fdce = 507, /* -fdce */ + OPT_fdebug_prefix_map_ = 508, /* -fdebug-prefix-map= */ + OPT_fdeduce_init_list = 509, /* -fdeduce-init-list */ + OPT_fdefault_double_8 = 510, /* -fdefault-double-8 */ + /* OPT_fdefault_inline = 511, */ /* -fdefault-inline */ + OPT_fdefault_integer_8 = 512, /* -fdefault-integer-8 */ + OPT_fdefault_real_8 = 513, /* -fdefault-real-8 */ + OPT_fdefer_pop = 514, /* -fdefer-pop */ + OPT_fdelayed_branch = 515, /* -fdelayed-branch */ + OPT_fdelete_null_pointer_checks = 516, /* -fdelete-null-pointer-checks */ + OPT_fdevirtualize = 517, /* -fdevirtualize */ + OPT_fdiagnostics_show_location_ = 518, /* -fdiagnostics-show-location= */ + OPT_fdiagnostics_show_option = 519, /* -fdiagnostics-show-option */ + OPT_fdirectives_only = 520, /* -fdirectives-only */ + OPT_fdisable_ = 521, /* -fdisable- */ + OPT_fdisable_assertions = 522, /* -fdisable-assertions */ + OPT_fdisable_assertions_ = 523, /* -fdisable-assertions= */ + OPT_fdollar_ok = 524, /* -fdollar-ok */ + OPT_fdollars_in_identifiers = 525, /* -fdollars-in-identifiers */ + OPT_fdse = 526, /* -fdse */ + OPT_fdump_ = 527, /* -fdump- */ + OPT_fdump_core = 528, /* -fdump-core */ + OPT_fdump_final_insns = 529, /* -fdump-final-insns */ + OPT_fdump_final_insns_ = 530, /* -fdump-final-insns= */ + OPT_fdump_fortran_optimized = 531, /* -fdump-fortran-optimized */ + OPT_fdump_fortran_original = 532, /* -fdump-fortran-original */ + OPT_fdump_go_spec_ = 533, /* -fdump-go-spec= */ + OPT_fdump_noaddr = 534, /* -fdump-noaddr */ + OPT_fdump_parse_tree = 535, /* -fdump-parse-tree */ + OPT_fdump_passes = 536, /* -fdump-passes */ + OPT_fdump_unnumbered = 537, /* -fdump-unnumbered */ + OPT_fdump_unnumbered_links = 538, /* -fdump-unnumbered-links */ + OPT_fdwarf2_cfi_asm = 539, /* -fdwarf2-cfi-asm */ + OPT_fearly_inlining = 540, /* -fearly-inlining */ + OPT_felide_constructors = 541, /* -felide-constructors */ + OPT_feliminate_dwarf2_dups = 542, /* -feliminate-dwarf2-dups */ + OPT_feliminate_unused_debug_symbols = 543, /* -feliminate-unused-debug-symbols */ + OPT_feliminate_unused_debug_types = 544, /* -feliminate-unused-debug-types */ + OPT_femit_class_debug_always = 545, /* -femit-class-debug-always */ + OPT_femit_class_file = 546, /* -femit-class-file */ + OPT_femit_class_files = 547, /* -femit-class-files */ + OPT_femit_struct_debug_baseonly = 548, /* -femit-struct-debug-baseonly */ + OPT_femit_struct_debug_detailed_ = 549, /* -femit-struct-debug-detailed= */ + OPT_femit_struct_debug_reduced = 550, /* -femit-struct-debug-reduced */ + OPT_fenable_ = 551, /* -fenable- */ + OPT_fenable_assertions = 552, /* -fenable-assertions */ + OPT_fenable_assertions_ = 553, /* -fenable-assertions= */ + OPT_fenable_icf_debug = 554, /* -fenable-icf-debug */ + OPT_fencoding_ = 555, /* -fencoding= */ + OPT_fenforce_eh_specs = 556, /* -fenforce-eh-specs */ + /* OPT_fenum_int_equiv = 557, */ /* -fenum-int-equiv */ + OPT_fexceptions = 558, /* -fexceptions */ + OPT_fexcess_precision_ = 559, /* -fexcess-precision= */ + OPT_fexec_charset_ = 560, /* -fexec-charset= */ + OPT_fexpensive_optimizations = 561, /* -fexpensive-optimizations */ + OPT_fextdirs_ = 562, /* -fextdirs= */ + OPT_fextended_identifiers = 563, /* -fextended-identifiers */ + OPT_fexternal_blas = 564, /* -fexternal-blas */ + /* OPT_fexternal_templates = 565, */ /* -fexternal-templates */ + OPT_ff2c = 566, /* -ff2c */ + OPT_ffast_math = 567, /* -ffast-math */ + OPT_ffilelist_file = 568, /* -ffilelist-file */ + OPT_ffinite_math_only = 569, /* -ffinite-math-only */ + OPT_ffixed_ = 570, /* -ffixed- */ + OPT_ffixed_form = 571, /* -ffixed-form */ + OPT_ffixed_line_length_ = 572, /* -ffixed-line-length- */ + OPT_ffixed_line_length_none = 573, /* -ffixed-line-length-none */ + OPT_ffloat_store = 574, /* -ffloat-store */ + OPT_ffor_scope = 575, /* -ffor-scope */ + /* OPT_fforce_addr = 576, */ /* -fforce-addr */ + OPT_fforce_classes_archive_check = 577, /* -fforce-classes-archive-check */ + OPT_fforward_propagate = 578, /* -fforward-propagate */ + OPT_ffp_contract_ = 579, /* -ffp-contract= */ + OPT_ffpe_trap_ = 580, /* -ffpe-trap= */ + OPT_ffree_form = 581, /* -ffree-form */ + OPT_ffree_line_length_ = 582, /* -ffree-line-length- */ + OPT_ffree_line_length_none = 583, /* -ffree-line-length-none */ + OPT_ffreestanding = 584, /* -ffreestanding */ + OPT_ffriend_injection = 585, /* -ffriend-injection */ + OPT_ffunction_cse = 586, /* -ffunction-cse */ + OPT_ffunction_sections = 587, /* -ffunction-sections */ + OPT_fgcse = 588, /* -fgcse */ + OPT_fgcse_after_reload = 589, /* -fgcse-after-reload */ + OPT_fgcse_las = 590, /* -fgcse-las */ + OPT_fgcse_lm = 591, /* -fgcse-lm */ + OPT_fgcse_sm = 592, /* -fgcse-sm */ + OPT_fgnu_keywords = 593, /* -fgnu-keywords */ + OPT_fgnu_runtime = 594, /* -fgnu-runtime */ + OPT_fgnu89_inline = 595, /* -fgnu89-inline */ + OPT_fgo_dump_ = 596, /* -fgo-dump- */ + OPT_fgo_prefix_ = 597, /* -fgo-prefix= */ + OPT_fgraphite = 598, /* -fgraphite */ + OPT_fgraphite_identity = 599, /* -fgraphite-identity */ + OPT_fguess_branch_probability = 600, /* -fguess-branch-probability */ + /* OPT_fguiding_decls = 601, */ /* -fguiding-decls */ + /* OPT_fhandle_exceptions = 602, */ /* -fhandle-exceptions */ + OPT_fhash_synchronization = 603, /* -fhash-synchronization */ + /* OPT_fhelp = 604, */ /* -fhelp */ + /* OPT_fhelp_ = 605, */ /* -fhelp= */ + /* OPT_fhonor_std = 606, */ /* -fhonor-std */ + OPT_fhosted = 607, /* -fhosted */ + /* OPT_fhuge_objects = 608, */ /* -fhuge-objects */ + OPT_fident = 609, /* -fident */ + OPT_fif_conversion = 610, /* -fif-conversion */ + OPT_fif_conversion2 = 611, /* -fif-conversion2 */ + OPT_fimplement_inlines = 612, /* -fimplement-inlines */ + OPT_fimplicit_inline_templates = 613, /* -fimplicit-inline-templates */ + OPT_fimplicit_none = 614, /* -fimplicit-none */ + OPT_fimplicit_templates = 615, /* -fimplicit-templates */ + OPT_findirect_classes = 616, /* -findirect-classes */ + OPT_findirect_dispatch = 617, /* -findirect-dispatch */ + OPT_findirect_inlining = 618, /* -findirect-inlining */ + OPT_finhibit_size_directive = 619, /* -finhibit-size-directive */ + OPT_finit_character_ = 620, /* -finit-character= */ + OPT_finit_integer_ = 621, /* -finit-integer= */ + OPT_finit_local_zero = 622, /* -finit-local-zero */ + OPT_finit_logical_ = 623, /* -finit-logical= */ + OPT_finit_real_ = 624, /* -finit-real= */ + OPT_finline = 625, /* -finline */ + OPT_finline_functions = 626, /* -finline-functions */ + OPT_finline_functions_called_once = 627, /* -finline-functions-called-once */ + OPT_finline_hot_caller = 628, /* -finline-hot-caller */ + /* OPT_finline_limit_ = 629, */ /* -finline-limit- */ + OPT_finline_limit_ = 630, /* -finline-limit= */ + OPT_finline_small_functions = 631, /* -finline-small-functions */ + OPT_finput_charset_ = 632, /* -finput-charset= */ + OPT_finstrument_functions = 633, /* -finstrument-functions */ + OPT_finstrument_functions_exclude_file_list_ = 634,/* -finstrument-functions-exclude-file-list= */ + OPT_finstrument_functions_exclude_function_list_ = 635,/* -finstrument-functions-exclude-function-list= */ + OPT_fintrinsic_modules_path = 636, /* -fintrinsic-modules-path */ + OPT_fipa_cp = 637, /* -fipa-cp */ + OPT_fipa_cp_clone = 638, /* -fipa-cp-clone */ + OPT_fipa_matrix_reorg = 639, /* -fipa-matrix-reorg */ + OPT_fipa_profile = 640, /* -fipa-profile */ + OPT_fipa_pta = 641, /* -fipa-pta */ + OPT_fipa_pure_const = 642, /* -fipa-pure-const */ + OPT_fipa_reference = 643, /* -fipa-reference */ + OPT_fipa_sra = 644, /* -fipa-sra */ + OPT_fipa_struct_reorg = 645, /* -fipa-struct-reorg */ + OPT_fira_algorithm_ = 646, /* -fira-algorithm= */ + OPT_fira_loop_pressure = 647, /* -fira-loop-pressure */ + OPT_fira_region_ = 648, /* -fira-region= */ + OPT_fira_share_save_slots = 649, /* -fira-share-save-slots */ + OPT_fira_share_spill_slots = 650, /* -fira-share-spill-slots */ + OPT_fira_verbose_ = 651, /* -fira-verbose= */ + OPT_fivopts = 652, /* -fivopts */ + OPT_fjni = 653, /* -fjni */ + OPT_fjump_tables = 654, /* -fjump-tables */ + OPT_fkeep_inline_dllexport = 655, /* -fkeep-inline-dllexport */ + OPT_fkeep_inline_functions = 656, /* -fkeep-inline-functions */ + OPT_fkeep_static_consts = 657, /* -fkeep-static-consts */ + /* OPT_flabels_ok = 658, */ /* -flabels-ok */ + OPT_flax_vector_conversions = 659, /* -flax-vector-conversions */ + OPT_fleading_underscore = 660, /* -fleading-underscore */ + OPT_floop_block = 661, /* -floop-block */ + OPT_floop_flatten = 662, /* -floop-flatten */ + OPT_floop_interchange = 663, /* -floop-interchange */ + /* OPT_floop_optimize = 664, */ /* -floop-optimize */ + OPT_floop_parallelize_all = 665, /* -floop-parallelize-all */ + OPT_floop_strip_mine = 666, /* -floop-strip-mine */ + OPT_flto = 667, /* -flto */ + OPT_flto_compression_level_ = 668, /* -flto-compression-level= */ + OPT_flto_partition_1to1 = 669, /* -flto-partition=1to1 */ + OPT_flto_partition_balanced = 670, /* -flto-partition=balanced */ + OPT_flto_partition_none = 671, /* -flto-partition=none */ + OPT_flto_report = 672, /* -flto-report */ + OPT_flto_ = 673, /* -flto= */ + OPT_fltrans = 674, /* -fltrans */ + OPT_fltrans_output_list_ = 675, /* -fltrans-output-list= */ + OPT_fmain_ = 676, /* -fmain= */ + OPT_fmath_errno = 677, /* -fmath-errno */ + OPT_fmax_array_constructor_ = 678, /* -fmax-array-constructor= */ + OPT_fmax_errors_ = 679, /* -fmax-errors= */ + OPT_fmax_identifier_length_ = 680, /* -fmax-identifier-length= */ + OPT_fmax_stack_var_size_ = 681, /* -fmax-stack-var-size= */ + OPT_fmax_subrecord_length_ = 682, /* -fmax-subrecord-length= */ + OPT_fmem_report = 683, /* -fmem-report */ + OPT_fmerge_all_constants = 684, /* -fmerge-all-constants */ + OPT_fmerge_constants = 685, /* -fmerge-constants */ + OPT_fmerge_debug_strings = 686, /* -fmerge-debug-strings */ + OPT_fmessage_length_ = 687, /* -fmessage-length= */ + OPT_fmodule_private = 688, /* -fmodule-private */ + OPT_fmodulo_sched = 689, /* -fmodulo-sched */ + OPT_fmodulo_sched_allow_regmoves = 690, /* -fmodulo-sched-allow-regmoves */ + OPT_fmove_loop_invariants = 691, /* -fmove-loop-invariants */ + OPT_fms_extensions = 692, /* -fms-extensions */ + OPT_fmudflap = 693, /* -fmudflap */ + OPT_fmudflapir = 694, /* -fmudflapir */ + OPT_fmudflapth = 695, /* -fmudflapth */ + /* OPT_fname_mangling_version_ = 696, */ /* -fname-mangling-version- */ + /* OPT_fnew_abi = 697, */ /* -fnew-abi */ + OPT_fnext_runtime = 698, /* -fnext-runtime */ + OPT_fnil_receivers = 699, /* -fnil-receivers */ + OPT_fnon_call_exceptions = 700, /* -fnon-call-exceptions */ + OPT_fnonansi_builtins = 701, /* -fnonansi-builtins */ + /* OPT_fnonnull_objects = 702, */ /* -fnonnull-objects */ + OPT_fnothrow_opt = 703, /* -fnothrow-opt */ + OPT_fobjc_abi_version_ = 704, /* -fobjc-abi-version= */ + OPT_fobjc_call_cxx_cdtors = 705, /* -fobjc-call-cxx-cdtors */ + OPT_fobjc_direct_dispatch = 706, /* -fobjc-direct-dispatch */ + OPT_fobjc_exceptions = 707, /* -fobjc-exceptions */ + OPT_fobjc_gc = 708, /* -fobjc-gc */ + OPT_fobjc_nilcheck = 709, /* -fobjc-nilcheck */ + OPT_fobjc_sjlj_exceptions = 710, /* -fobjc-sjlj-exceptions */ + OPT_fobjc_std_objc1 = 711, /* -fobjc-std=objc1 */ + OPT_fomit_frame_pointer = 712, /* -fomit-frame-pointer */ + OPT_fopenmp = 713, /* -fopenmp */ + OPT_foperator_names = 714, /* -foperator-names */ + OPT_fopt_info = 715, /* -fopt-info */ + OPT_fopt_info_ = 716, /* -fopt-info= */ + OPT_foptimize_locality = 717, /* -foptimize-locality */ + OPT_foptimize_register_move = 718, /* -foptimize-register-move */ + OPT_foptimize_sibling_calls = 719, /* -foptimize-sibling-calls */ + OPT_foptimize_static_class_initialization = 720,/* -foptimize-static-class-initialization */ + /* OPT_foptional_diags = 721, */ /* -foptional-diags */ + OPT_foutput_class_dir_ = 722, /* -foutput-class-dir= */ + OPT_fpack_derived = 723, /* -fpack-derived */ + OPT_fpack_struct = 724, /* -fpack-struct */ + OPT_fpack_struct_ = 725, /* -fpack-struct= */ + OPT_fpartial_inlining = 726, /* -fpartial-inlining */ + OPT_fpcc_struct_return = 727, /* -fpcc-struct-return */ + OPT_fpch_deps = 728, /* -fpch-deps */ + OPT_fpch_preprocess = 729, /* -fpch-preprocess */ + OPT_fpeel_loops = 730, /* -fpeel-loops */ + OPT_fpeephole = 731, /* -fpeephole */ + OPT_fpeephole2 = 732, /* -fpeephole2 */ + OPT_fpermissive = 733, /* -fpermissive */ + OPT_fpic = 734, /* -fpic */ + OPT_fpie = 735, /* -fpie */ + OPT_fplan9_extensions = 736, /* -fplan9-extensions */ + OPT_fplugin_arg_ = 737, /* -fplugin-arg- */ + OPT_fplugin_ = 738, /* -fplugin= */ + OPT_fpmu_profile_generate_ = 739, /* -fpmu-profile-generate= */ + OPT_fpmu_profile_use_ = 740, /* -fpmu-profile-use= */ + OPT_fpost_ipa_mem_report = 741, /* -fpost-ipa-mem-report */ + OPT_fpre_ipa_mem_report = 742, /* -fpre-ipa-mem-report */ + OPT_fpredictive_commoning = 743, /* -fpredictive-commoning */ + OPT_fprefetch_loop_arrays = 744, /* -fprefetch-loop-arrays */ + OPT_fpreprocessed = 745, /* -fpreprocessed */ + OPT_fpretty_templates = 746, /* -fpretty-templates */ + OPT_fprofile = 747, /* -fprofile */ + OPT_fprofile_arcs = 748, /* -fprofile-arcs */ + OPT_fprofile_correction = 749, /* -fprofile-correction */ + OPT_fprofile_dir_ = 750, /* -fprofile-dir= */ + OPT_fprofile_dump = 751, /* -fprofile-dump */ + OPT_fprofile_generate = 752, /* -fprofile-generate */ + OPT_fprofile_generate_sampling = 753, /* -fprofile-generate-sampling */ + OPT_fprofile_generate_ = 754, /* -fprofile-generate= */ + OPT_fprofile_reusedist = 755, /* -fprofile-reusedist */ + OPT_fprofile_use = 756, /* -fprofile-use */ + OPT_fprofile_use_ = 757, /* -fprofile-use= */ + OPT_fprofile_values = 758, /* -fprofile-values */ + OPT_fprotect_parens = 759, /* -fprotect-parens */ + OPT_frandom_seed = 760, /* -frandom-seed */ + OPT_frandom_seed_ = 761, /* -frandom-seed= */ + OPT_frange_check = 762, /* -frange-check */ + OPT_frealloc_lhs = 763, /* -frealloc-lhs */ + OPT_freciprocal_math = 764, /* -freciprocal-math */ + OPT_frecord_gcc_switches = 765, /* -frecord-gcc-switches */ + OPT_frecord_gcc_switches_in_elf = 766, /* -frecord-gcc-switches-in-elf */ + OPT_frecord_marker_4 = 767, /* -frecord-marker=4 */ + OPT_frecord_marker_8 = 768, /* -frecord-marker=8 */ + OPT_frecursive = 769, /* -frecursive */ + OPT_freduced_reflection = 770, /* -freduced-reflection */ + OPT_freg_struct_return = 771, /* -freg-struct-return */ + OPT_fregmove = 772, /* -fregmove */ + OPT_frename_registers = 773, /* -frename-registers */ + OPT_freorder_blocks = 774, /* -freorder-blocks */ + OPT_freorder_blocks_and_partition = 775, /* -freorder-blocks-and-partition */ + OPT_freorder_functions = 776, /* -freorder-functions */ + OPT_frepack_arrays = 777, /* -frepack-arrays */ + OPT_freplace_objc_classes = 778, /* -freplace-objc-classes */ + OPT_frepo = 779, /* -frepo */ + OPT_frequire_return_statement = 780, /* -frequire-return-statement */ + OPT_frerun_cse_after_loop = 781, /* -frerun-cse-after-loop */ + /* OPT_frerun_loop_opt = 782, */ /* -frerun-loop-opt */ + OPT_freschedule_modulo_scheduled_loops = 783,/* -freschedule-modulo-scheduled-loops */ + OPT_fresolution_ = 784, /* -fresolution= */ + OPT_fripa = 785, /* -fripa */ + OPT_fripa_disallow_asm_modules = 786, /* -fripa-disallow-asm-modules */ + OPT_fripa_disallow_opt_mismatch = 787, /* -fripa-disallow-opt-mismatch */ + OPT_fripa_no_promote_always_inline_func = 788,/* -fripa-no-promote-always-inline-func */ + OPT_fripa_peel_size_limit = 789, /* -fripa-peel-size-limit */ + OPT_fripa_unroll_size_limit = 790, /* -fripa-unroll-size-limit */ + OPT_frounding_math = 791, /* -frounding-math */ + OPT_frtti = 792, /* -frtti */ + OPT_fsaw_java_file = 793, /* -fsaw-java-file */ + OPT_fsched_critical_path_heuristic = 794, /* -fsched-critical-path-heuristic */ + OPT_fsched_dep_count_heuristic = 795, /* -fsched-dep-count-heuristic */ + OPT_fsched_group_heuristic = 796, /* -fsched-group-heuristic */ + OPT_fsched_interblock = 797, /* -fsched-interblock */ + OPT_fsched_last_insn_heuristic = 798, /* -fsched-last-insn-heuristic */ + OPT_fsched_pressure = 799, /* -fsched-pressure */ + OPT_fsched_rank_heuristic = 800, /* -fsched-rank-heuristic */ + OPT_fsched_spec = 801, /* -fsched-spec */ + OPT_fsched_spec_insn_heuristic = 802, /* -fsched-spec-insn-heuristic */ + OPT_fsched_spec_load = 803, /* -fsched-spec-load */ + OPT_fsched_spec_load_dangerous = 804, /* -fsched-spec-load-dangerous */ + OPT_fsched_stalled_insns = 805, /* -fsched-stalled-insns */ + OPT_fsched_stalled_insns_dep = 806, /* -fsched-stalled-insns-dep */ + OPT_fsched_stalled_insns_dep_ = 807, /* -fsched-stalled-insns-dep= */ + OPT_fsched_stalled_insns_ = 808, /* -fsched-stalled-insns= */ + OPT_fsched_verbose_ = 809, /* -fsched-verbose= */ + OPT_fsched2_use_superblocks = 810, /* -fsched2-use-superblocks */ + /* OPT_fsched2_use_traces = 811, */ /* -fsched2-use-traces */ + OPT_fschedule_insns = 812, /* -fschedule-insns */ + OPT_fschedule_insns2 = 813, /* -fschedule-insns2 */ + OPT_fsecond_underscore = 814, /* -fsecond-underscore */ + OPT_fsection_anchors = 815, /* -fsection-anchors */ + /* OPT_fsee = 816, */ /* -fsee */ + OPT_fsel_sched_pipelining = 817, /* -fsel-sched-pipelining */ + OPT_fsel_sched_pipelining_outer_loops = 818,/* -fsel-sched-pipelining-outer-loops */ + OPT_fsel_sched_reschedule_pipelined = 819, /* -fsel-sched-reschedule-pipelined */ + OPT_fselective_scheduling = 820, /* -fselective-scheduling */ + OPT_fselective_scheduling2 = 821, /* -fselective-scheduling2 */ + OPT_fshort_double = 822, /* -fshort-double */ + OPT_fshort_enums = 823, /* -fshort-enums */ + OPT_fshort_wchar = 824, /* -fshort-wchar */ + OPT_fshow_column = 825, /* -fshow-column */ + OPT_fsign_zero = 826, /* -fsign-zero */ + OPT_fsignaling_nans = 827, /* -fsignaling-nans */ + OPT_fsigned_bitfields = 828, /* -fsigned-bitfields */ + OPT_fsigned_char = 829, /* -fsigned-char */ + OPT_fsigned_zeros = 830, /* -fsigned-zeros */ + OPT_fsingle_precision_constant = 831, /* -fsingle-precision-constant */ + OPT_fsized_delete = 832, /* -fsized-delete */ + OPT_fsource_filename_ = 833, /* -fsource-filename= */ + OPT_fsource_ = 834, /* -fsource= */ + OPT_fsplit_ivs_in_unroller = 835, /* -fsplit-ivs-in-unroller */ + OPT_fsplit_stack = 836, /* -fsplit-stack */ + OPT_fsplit_wide_types = 837, /* -fsplit-wide-types */ + /* OPT_fsquangle = 838, */ /* -fsquangle */ + /* OPT_fstack_check = 839, */ /* -fstack-check */ + OPT_fstack_check_ = 840, /* -fstack-check= */ + OPT_fstack_limit = 841, /* -fstack-limit */ + OPT_fstack_limit_register_ = 842, /* -fstack-limit-register= */ + OPT_fstack_limit_symbol_ = 843, /* -fstack-limit-symbol= */ + OPT_fstack_protector = 844, /* -fstack-protector */ + OPT_fstack_protector_all = 845, /* -fstack-protector-all */ + OPT_fstack_protector_strong = 846, /* -fstack-protector-strong */ + OPT_fstack_usage = 847, /* -fstack-usage */ + OPT_fstats = 848, /* -fstats */ + OPT_fstore_check = 849, /* -fstore-check */ + /* OPT_fstrength_reduce = 850, */ /* -fstrength-reduce */ + OPT_fstrict_aliasing = 851, /* -fstrict-aliasing */ + OPT_fstrict_enum_precision = 852, /* -fstrict-enum-precision */ + OPT_fstrict_enums = 853, /* -fstrict-enums */ + OPT_fstrict_overflow = 854, /* -fstrict-overflow */ + /* OPT_fstrict_prototype = 855, */ /* -fstrict-prototype */ + OPT_fstrict_volatile_bitfields = 856, /* -fstrict-volatile-bitfields */ + OPT_fsyntax_only = 857, /* -fsyntax-only */ + OPT_ftabstop_ = 858, /* -ftabstop= */ + /* OPT_ftarget_help = 859, */ /* -ftarget-help */ + OPT_ftarget_ = 860, /* -ftarget= */ + /* OPT_ftemplate_depth_ = 861, */ /* -ftemplate-depth- */ + OPT_ftemplate_depth_ = 862, /* -ftemplate-depth= */ + OPT_ftest_coverage = 863, /* -ftest-coverage */ + /* OPT_fthis_is_variable = 864, */ /* -fthis-is-variable */ + OPT_fthread_jumps = 865, /* -fthread-jumps */ + OPT_fthreadsafe_statics = 866, /* -fthreadsafe-statics */ + OPT_ftime_report = 867, /* -ftime-report */ + OPT_ftls_model_ = 868, /* -ftls-model= */ + OPT_ftoplevel_reorder = 869, /* -ftoplevel-reorder */ + OPT_ftracer = 870, /* -ftracer */ + OPT_ftrapping_math = 871, /* -ftrapping-math */ + OPT_ftrapv = 872, /* -ftrapv */ + OPT_ftree_bit_ccp = 873, /* -ftree-bit-ccp */ + OPT_ftree_builtin_call_dce = 874, /* -ftree-builtin-call-dce */ + OPT_ftree_ccp = 875, /* -ftree-ccp */ + OPT_ftree_ch = 876, /* -ftree-ch */ + OPT_ftree_copy_prop = 877, /* -ftree-copy-prop */ + OPT_ftree_copyrename = 878, /* -ftree-copyrename */ + OPT_ftree_cselim = 879, /* -ftree-cselim */ + OPT_ftree_dce = 880, /* -ftree-dce */ + OPT_ftree_dominator_opts = 881, /* -ftree-dominator-opts */ + OPT_ftree_dse = 882, /* -ftree-dse */ + OPT_ftree_forwprop = 883, /* -ftree-forwprop */ + OPT_ftree_fre = 884, /* -ftree-fre */ + OPT_ftree_loop_distribute_patterns = 885, /* -ftree-loop-distribute-patterns */ + OPT_ftree_loop_distribution = 886, /* -ftree-loop-distribution */ + OPT_ftree_loop_if_convert = 887, /* -ftree-loop-if-convert */ + OPT_ftree_loop_if_convert_stores = 888, /* -ftree-loop-if-convert-stores */ + OPT_ftree_loop_im = 889, /* -ftree-loop-im */ + OPT_ftree_loop_ivcanon = 890, /* -ftree-loop-ivcanon */ + /* OPT_ftree_loop_linear = 891, */ /* -ftree-loop-linear */ + OPT_ftree_loop_optimize = 892, /* -ftree-loop-optimize */ + OPT_ftree_lrs = 893, /* -ftree-lrs */ + OPT_ftree_parallelize_loops_ = 894, /* -ftree-parallelize-loops= */ + OPT_ftree_phiprop = 895, /* -ftree-phiprop */ + OPT_ftree_pre = 896, /* -ftree-pre */ + OPT_ftree_pta = 897, /* -ftree-pta */ + OPT_ftree_reassoc = 898, /* -ftree-reassoc */ + /* OPT_ftree_salias = 899, */ /* -ftree-salias */ + OPT_ftree_scev_cprop = 900, /* -ftree-scev-cprop */ + OPT_ftree_sink = 901, /* -ftree-sink */ + OPT_ftree_slp_vectorize = 902, /* -ftree-slp-vectorize */ + OPT_ftree_sra = 903, /* -ftree-sra */ + /* OPT_ftree_store_ccp = 904, */ /* -ftree-store-ccp */ + /* OPT_ftree_store_copy_prop = 905, */ /* -ftree-store-copy-prop */ + OPT_ftree_switch_conversion = 906, /* -ftree-switch-conversion */ + OPT_ftree_ter = 907, /* -ftree-ter */ + OPT_ftree_vect_loop_version = 908, /* -ftree-vect-loop-version */ + OPT_ftree_vectorize = 909, /* -ftree-vectorize */ + OPT_ftree_vectorizer_verbose_ = 910, /* -ftree-vectorizer-verbose= */ + OPT_ftree_vrp = 911, /* -ftree-vrp */ + OPT_funderscoring = 912, /* -funderscoring */ + OPT_funit_at_a_time = 913, /* -funit-at-a-time */ + OPT_funroll_all_loops = 914, /* -funroll-all-loops */ + OPT_funroll_loops = 915, /* -funroll-loops */ + OPT_funsafe_loop_optimizations = 916, /* -funsafe-loop-optimizations */ + OPT_funsafe_math_optimizations = 917, /* -funsafe-math-optimizations */ + OPT_funsigned_bitfields = 918, /* -funsigned-bitfields */ + OPT_funsigned_char = 919, /* -funsigned-char */ + OPT_funswitch_loops = 920, /* -funswitch-loops */ + OPT_funwind_tables = 921, /* -funwind-tables */ + OPT_fuse_atomic_builtins = 922, /* -fuse-atomic-builtins */ + OPT_fuse_boehm_gc = 923, /* -fuse-boehm-gc */ + OPT_fuse_cxa_atexit = 924, /* -fuse-cxa-atexit */ + OPT_fuse_cxa_get_exception_ptr = 925, /* -fuse-cxa-get-exception-ptr */ + OPT_fuse_divide_subroutine = 926, /* -fuse-divide-subroutine */ + OPT_fuse_ld_ = 927, /* -fuse-ld= */ + OPT_fuse_linker_plugin = 928, /* -fuse-linker-plugin */ + OPT_fvar_tracking = 929, /* -fvar-tracking */ + OPT_fvar_tracking_assignments = 930, /* -fvar-tracking-assignments */ + OPT_fvar_tracking_assignments_toggle = 931,/* -fvar-tracking-assignments-toggle */ + OPT_fvar_tracking_uninit = 932, /* -fvar-tracking-uninit */ + OPT_fvariable_expansion_in_unroller = 933, /* -fvariable-expansion-in-unroller */ + OPT_fvect_cost_model = 934, /* -fvect-cost-model */ + OPT_fverbose_asm = 935, /* -fverbose-asm */ + /* OPT_fversion = 936, */ /* -fversion */ + OPT_fvisibility_inlines_hidden = 937, /* -fvisibility-inlines-hidden */ + OPT_fvisibility_ms_compat = 938, /* -fvisibility-ms-compat */ + OPT_fvisibility_ = 939, /* -fvisibility= */ + OPT_fvpt = 940, /* -fvpt */ + /* OPT_fvtable_gc = 941, */ /* -fvtable-gc */ + /* OPT_fvtable_thunks = 942, */ /* -fvtable-thunks */ + OPT_fweak = 943, /* -fweak */ + OPT_fweb = 944, /* -fweb */ + OPT_fwhole_file = 945, /* -fwhole-file */ + OPT_fwhole_program = 946, /* -fwhole-program */ + OPT_fwide_exec_charset_ = 947, /* -fwide-exec-charset= */ + OPT_fworking_directory = 948, /* -fworking-directory */ + OPT_fwpa = 949, /* -fwpa */ + OPT_fwrapv = 950, /* -fwrapv */ + /* OPT_fxref = 951, */ /* -fxref */ + OPT_fzee = 952, /* -fzee */ + OPT_fzero_initialized_in_bss = 953, /* -fzero-initialized-in-bss */ + OPT_fzero_link = 954, /* -fzero-link */ + OPT_g = 955, /* -g */ + OPT_gant = 956, /* -gant */ + OPT_gcoff = 957, /* -gcoff */ + OPT_gdwarf_ = 958, /* -gdwarf- */ + OPT_gen_decls = 959, /* -gen-decls */ + OPT_ggdb = 960, /* -ggdb */ + OPT_gmlt = 961, /* -gmlt */ + OPT_gnat = 962, /* -gnat */ + OPT_gnatO = 963, /* -gnatO */ + OPT_gno_strict_dwarf = 964, /* -gno-strict-dwarf */ + OPT_gstabs = 965, /* -gstabs */ + OPT_gstabs_ = 966, /* -gstabs+ */ + OPT_gstrict_dwarf = 967, /* -gstrict-dwarf */ + OPT_gtoggle = 968, /* -gtoggle */ + OPT_gvms = 969, /* -gvms */ + OPT_gxcoff = 970, /* -gxcoff */ + OPT_gxcoff_ = 971, /* -gxcoff+ */ + OPT_h = 972, /* -h */ + OPT_idirafter = 973, /* -idirafter */ + OPT_imacros = 974, /* -imacros */ + OPT_imultilib = 975, /* -imultilib */ + OPT_include = 976, /* -include */ + OPT_iplugindir_ = 977, /* -iplugindir= */ + OPT_iprefix = 978, /* -iprefix */ + OPT_iquote = 979, /* -iquote */ + OPT_isysroot = 980, /* -isysroot */ + OPT_isystem = 981, /* -isystem */ + OPT_iwithprefix = 982, /* -iwithprefix */ + OPT_iwithprefixbefore = 983, /* -iwithprefixbefore */ + OPT_k8 = 984, /* -k8 */ + OPT_l = 985, /* -l */ + OPT_lang_asm = 986, /* -lang-asm */ + OPT_mabi_ = 987, /* -mabi= */ + OPT_mabort_on_noreturn = 988, /* -mabort-on-noreturn */ + OPT_mapcs = 989, /* -mapcs */ + OPT_mapcs_float = 990, /* -mapcs-float */ + OPT_mapcs_frame = 991, /* -mapcs-frame */ + OPT_mapcs_reentrant = 992, /* -mapcs-reentrant */ + OPT_mapcs_stack_check = 993, /* -mapcs-stack-check */ + OPT_march_ = 994, /* -march= */ + OPT_marm = 995, /* -marm */ + OPT_mbig_endian = 996, /* -mbig-endian */ + OPT_mcallee_super_interworking = 997, /* -mcallee-super-interworking */ + OPT_mcaller_super_interworking = 998, /* -mcaller-super-interworking */ + OPT_mcirrus_fix_invalid_insns = 999, /* -mcirrus-fix-invalid-insns */ + OPT_mcpu_ = 1000, /* -mcpu= */ + OPT_mfix_cortex_m3_ldrd = 1001, /* -mfix-cortex-m3-ldrd */ + OPT_mfloat_abi_ = 1002, /* -mfloat-abi= */ + OPT_mfp16_format_ = 1003, /* -mfp16-format= */ + OPT_mfp_ = 1004, /* -mfp= */ + OPT_mfpe = 1005, /* -mfpe */ + OPT_mfpe_ = 1006, /* -mfpe= */ + OPT_mfpu_ = 1007, /* -mfpu= */ + OPT_mhard_float = 1008, /* -mhard-float */ + OPT_mlittle_endian = 1009, /* -mlittle-endian */ + OPT_mlong_calls = 1010, /* -mlong-calls */ + OPT_mpic_register_ = 1011, /* -mpic-register= */ + OPT_mpoke_function_name = 1012, /* -mpoke-function-name */ + OPT_msched_prolog = 1013, /* -msched-prolog */ + OPT_msingle_pic_base = 1014, /* -msingle-pic-base */ + OPT_msoft_float = 1015, /* -msoft-float */ + OPT_mstructure_size_boundary_ = 1016, /* -mstructure-size-boundary= */ + OPT_mthumb = 1017, /* -mthumb */ + OPT_mthumb_interwork = 1018, /* -mthumb-interwork */ + OPT_mtp_ = 1019, /* -mtp= */ + OPT_mtpcs_frame = 1020, /* -mtpcs-frame */ + OPT_mtpcs_leaf_frame = 1021, /* -mtpcs-leaf-frame */ + OPT_mtune_ = 1022, /* -mtune= */ + OPT_mvectorize_with_neon_quad = 1023, /* -mvectorize-with-neon-quad */ + OPT_mword_relocations = 1024, /* -mword-relocations */ + OPT_mwords_little_endian = 1025, /* -mwords-little-endian */ + OPT_n = 1026, /* -n */ + OPT_no_canonical_prefixes = 1027, /* -no-canonical-prefixes */ + OPT_no_integrated_cpp = 1028, /* -no-integrated-cpp */ + OPT_nocpp = 1029, /* -nocpp */ + OPT_nodefaultlibs = 1030, /* -nodefaultlibs */ + OPT_nostartfiles = 1031, /* -nostartfiles */ + OPT_nostdinc = 1032, /* -nostdinc */ + OPT_nostdinc__ = 1033, /* -nostdinc++ */ + OPT_nostdlib = 1034, /* -nostdlib */ + OPT_o = 1035, /* -o */ + OPT_p = 1036, /* -p */ + OPT_pass_exit_codes = 1037, /* -pass-exit-codes */ + OPT_pedantic = 1038, /* -pedantic */ + OPT_pedantic_errors = 1039, /* -pedantic-errors */ + OPT_pg = 1040, /* -pg */ + OPT_pie = 1041, /* -pie */ + OPT_pipe = 1042, /* -pipe */ + OPT_print_file_name_ = 1043, /* -print-file-name= */ + OPT_print_libgcc_file_name = 1044, /* -print-libgcc-file-name */ + OPT_print_multi_directory = 1045, /* -print-multi-directory */ + OPT_print_multi_lib = 1046, /* -print-multi-lib */ + OPT_print_multi_os_directory = 1047, /* -print-multi-os-directory */ + OPT_print_objc_runtime_info = 1048, /* -print-objc-runtime-info */ + OPT_print_prog_name_ = 1049, /* -print-prog-name= */ + OPT_print_search_dirs = 1050, /* -print-search-dirs */ + OPT_print_sysroot = 1051, /* -print-sysroot */ + OPT_print_sysroot_headers_suffix = 1052, /* -print-sysroot-headers-suffix */ + OPT_quiet = 1053, /* -quiet */ + OPT_r = 1054, /* -r */ + OPT_remap = 1055, /* -remap */ + OPT_s = 1056, /* -s */ + OPT_s_bc_abi = 1057, /* -s-bc-abi */ + OPT_save_temps = 1058, /* -save-temps */ + OPT_save_temps_ = 1059, /* -save-temps= */ + OPT_shared = 1060, /* -shared */ + OPT_shared_libgcc = 1061, /* -shared-libgcc */ + /* OPT_specs = 1062, */ /* -specs */ + OPT_specs_ = 1063, /* -specs= */ + OPT_static = 1064, /* -static */ + OPT_static_libgcc = 1065, /* -static-libgcc */ + OPT_static_libgcj = 1066, /* -static-libgcj */ + OPT_static_libgfortran = 1067, /* -static-libgfortran */ + OPT_static_libgo = 1068, /* -static-libgo */ + OPT_static_libstdc__ = 1069, /* -static-libstdc++ */ + /* OPT_std_c__03 = 1070, */ /* -std=c++03 */ + /* OPT_std_c__0x = 1071, */ /* -std=c++0x */ + OPT_std_c__11 = 1072, /* -std=c++11 */ + OPT_std_c__98 = 1073, /* -std=c++98 */ + OPT_std_c1x = 1074, /* -std=c1x */ + /* OPT_std_c89 = 1075, */ /* -std=c89 */ + OPT_std_c90 = 1076, /* -std=c90 */ + OPT_std_c99 = 1077, /* -std=c99 */ + /* OPT_std_c9x = 1078, */ /* -std=c9x */ + OPT_std_f2003 = 1079, /* -std=f2003 */ + OPT_std_f2008 = 1080, /* -std=f2008 */ + OPT_std_f95 = 1081, /* -std=f95 */ + OPT_std_gnu = 1082, /* -std=gnu */ + /* OPT_std_gnu__03 = 1083, */ /* -std=gnu++03 */ + /* OPT_std_gnu__0x = 1084, */ /* -std=gnu++0x */ + OPT_std_gnu__11 = 1085, /* -std=gnu++11 */ + OPT_std_gnu__98 = 1086, /* -std=gnu++98 */ + OPT_std_gnu1x = 1087, /* -std=gnu1x */ + /* OPT_std_gnu89 = 1088, */ /* -std=gnu89 */ + OPT_std_gnu90 = 1089, /* -std=gnu90 */ + OPT_std_gnu99 = 1090, /* -std=gnu99 */ + /* OPT_std_gnu9x = 1091, */ /* -std=gnu9x */ + /* OPT_std_iso9899_1990 = 1092, */ /* -std=iso9899:1990 */ + OPT_std_iso9899_199409 = 1093, /* -std=iso9899:199409 */ + /* OPT_std_iso9899_1999 = 1094, */ /* -std=iso9899:1999 */ + /* OPT_std_iso9899_199x = 1095, */ /* -std=iso9899:199x */ + OPT_std_legacy = 1096, /* -std=legacy */ + OPT_symbolic = 1097, /* -symbolic */ + OPT_t = 1098, /* -t */ + OPT_time = 1099, /* -time */ + OPT_time_ = 1100, /* -time= */ + OPT_traditional = 1101, /* -traditional */ + OPT_traditional_cpp = 1102, /* -traditional-cpp */ + OPT_trigraphs = 1103, /* -trigraphs */ + OPT_u = 1104, /* -u */ + OPT_undef = 1105, /* -undef */ + OPT_v = 1106, /* -v */ + OPT_version = 1107, /* -version */ + OPT_w = 1108, /* -w */ + OPT_wrapper = 1109, /* -wrapper */ + OPT_x = 1110, /* -x */ + OPT_z = 1111, /* -z */ + N_OPTS, + OPT_SPECIAL_unknown, + OPT_SPECIAL_ignore, + OPT_SPECIAL_program_name, + OPT_SPECIAL_input_file +}; + +#endif /* OPTIONS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/opts.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/opts.h new file mode 100644 index 0000000..379ae2d --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/opts.h @@ -0,0 +1,385 @@ +/* Command line option handling. + Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_OPTS_H +#define GCC_OPTS_H + +#include "input.h" +#include "vec.h" + +/* Specifies how a switch's VAR_VALUE relates to its FLAG_VAR. */ +enum cl_var_type { + /* The switch is enabled when FLAG_VAR is nonzero. */ + CLVC_BOOLEAN, + + /* The switch is enabled when FLAG_VAR == VAR_VALUE. */ + CLVC_EQUAL, + + /* The switch is enabled when VAR_VALUE is not set in FLAG_VAR. */ + CLVC_BIT_CLEAR, + + /* The switch is enabled when VAR_VALUE is set in FLAG_VAR. */ + CLVC_BIT_SET, + + /* The switch takes a string argument and FLAG_VAR points to that + argument. */ + CLVC_STRING, + + /* The switch takes an enumerated argument (VAR_ENUM says what + enumeration) and FLAG_VAR points to that argument. */ + CLVC_ENUM, + + /* The switch should be stored in the VEC pointed to by FLAG_VAR for + later processing. */ + CLVC_DEFER +}; + +struct cl_option +{ + const char *opt_text; + const char *help; + const char *missing_argument_error; + const char *warn_message; + const char *alias_arg; + const char *neg_alias_arg; + unsigned short alias_target; + unsigned short back_chain; + unsigned char opt_len; + int neg_index; + unsigned int flags; + unsigned short flag_var_offset; + unsigned short var_enum; + enum cl_var_type var_type; + int var_value; +}; + +/* Records that the state of an option consists of SIZE bytes starting + at DATA. DATA might point to CH in some cases. */ +struct cl_option_state { + const void *data; + size_t size; + char ch; +}; + +extern const struct cl_option cl_options[]; +extern const unsigned int cl_options_count; +extern const char *const lang_names[]; +extern const unsigned int cl_lang_count; + +#define CL_PARAMS (1 << 11) /* Fake entry. Used to display --param info with --help. */ +#define CL_WARNING (1 << 12) /* Enables an (optional) warning message. */ +#define CL_OPTIMIZATION (1 << 13) /* Enables an (optional) optimization. */ +#define CL_DRIVER (1 << 14) /* Driver option. */ +#define CL_TARGET (1 << 15) /* Target-specific option. */ +#define CL_COMMON (1 << 16) /* Language-independent. */ + +#define CL_MIN_OPTION_CLASS CL_PARAMS +#define CL_MAX_OPTION_CLASS CL_COMMON + +/* From here on the bits describe attributes of the options. + Before this point the bits have described the class of the option. + This distinction is important because --help will not list options + which only have these higher bits set. */ + +/* Options marked with CL_SEPARATE take a number of separate arguments + (1 to 4) that is one more than the number in this bit-field. */ +#define CL_SEPARATE_NARGS_SHIFT 17 +#define CL_SEPARATE_NARGS_MASK (3 << CL_SEPARATE_NARGS_SHIFT) + +#define CL_SEPARATE_ALIAS (1 << 19) /* Option is an alias when used with separate argument. */ +#define CL_NO_DRIVER_ARG (1 << 20) /* Option takes no argument in the driver. */ +#define CL_REJECT_DRIVER (1 << 21) /* Reject this option in the driver. */ +#define CL_SAVE (1 << 22) /* Target-specific option for attribute. */ +#define CL_DISABLED (1 << 23) /* Disabled in this configuration. */ +#define CL_REPORT (1 << 24) /* Report argument with -fverbose-asm */ +#define CL_JOINED (1 << 25) /* If takes joined argument. */ +#define CL_SEPARATE (1 << 26) /* If takes a separate argument. */ +#define CL_REJECT_NEGATIVE (1 << 27) /* Reject no- form. */ +#define CL_MISSING_OK (1 << 28) /* Missing argument OK (joined). */ +#define CL_UINTEGER (1 << 29) /* Argument is an integer >=0. */ +#define CL_UNDOCUMENTED (1 << 30) /* Do not output with --help. */ + +/* Flags for an enumerated option argument. */ +#define CL_ENUM_CANONICAL (1 << 0) /* Canonical for this value. */ +#define CL_ENUM_DRIVER_ONLY (1 << 1) /* Only accepted in the driver. */ + +/* Structure describing an enumerated option argument. */ + +struct cl_enum_arg +{ + /* The argument text, or NULL at the end of the array. */ + const char *arg; + + /* The corresponding integer value. */ + int value; + + /* Flags associated with this argument. */ + unsigned int flags; +}; + +/* Structure describing an enumerated set of option arguments. */ + +struct cl_enum +{ + /* Help text, or NULL if the values should not be listed in --help + output. */ + const char *help; + + /* Error message for unknown arguments, or NULL to use a generic + error. */ + const char *unknown_error; + + /* Array of possible values. */ + const struct cl_enum_arg *values; + + /* The size of the type used to store a value. */ + size_t var_size; + + /* Function to set a variable of this type. */ + void (*set) (void *var, int value); + + /* Function to get the value of a variable of this type. */ + int (*get) (const void *var); +}; + +extern const struct cl_enum cl_enums[]; +extern const unsigned int cl_enums_count; + +/* Possible ways in which a command-line option may be erroneous. + These do not include not being known at all; an option index of + OPT_SPECIAL_unknown is used for that. */ + +#define CL_ERR_DISABLED (1 << 0) /* Disabled in this configuration. */ +#define CL_ERR_MISSING_ARG (1 << 1) /* Argument required but missing. */ +#define CL_ERR_WRONG_LANG (1 << 2) /* Option for wrong language. */ +#define CL_ERR_UINT_ARG (1 << 3) /* Bad unsigned integer argument. */ +#define CL_ERR_ENUM_ARG (1 << 4) /* Bad enumerated argument. */ +#define CL_ERR_NEGATIVE (1 << 5) /* Negative form of option + not permitted (together + with OPT_SPECIAL_unknown). */ + +/* Structure describing the result of decoding an option. */ + +struct cl_decoded_option +{ + /* The index of this option, or an OPT_SPECIAL_* value for + non-options and unknown options. */ + size_t opt_index; + + /* Any warning to give for use of this option, or NULL if none. */ + const char *warn_message; + + /* The string argument, or NULL if none. For OPT_SPECIAL_* cases, + the option or non-option command-line argument. */ + const char *arg; + + /* The original text of option plus arguments, with separate argv + elements concatenated into one string with spaces separating + them. This is for such uses as diagnostics and + -frecord-gcc-switches. */ + const char *orig_option_with_args_text; + + /* The canonical form of the option and its argument, for when it is + necessary to reconstruct argv elements (in particular, for + processing specs and passing options to subprocesses from the + driver). */ + const char *canonical_option[4]; + + /* The number of elements in the canonical form of the option and + arguments; always at least 1. */ + size_t canonical_option_num_elements; + + /* For a boolean option, 1 for the true case and 0 for the "no-" + case. For an unsigned integer option, the value of the + argument. 1 in all other cases. */ + int value; + + /* Any flags describing errors detected in this option. */ + int errors; +}; + +/* Structure describing an option deferred for handling after the main + option handlers. */ + +typedef struct +{ + /* Elements from struct cl_decoded_option used for deferred + options. */ + size_t opt_index; + const char *arg; + int value; +} cl_deferred_option; +DEF_VEC_O(cl_deferred_option); +DEF_VEC_ALLOC_O(cl_deferred_option,heap); + +/* Structure describing a single option-handling callback. */ + +struct cl_option_handler_func +{ + /* The function called to handle the option. */ + bool (*handler) (struct gcc_options *opts, + struct gcc_options *opts_set, + const struct cl_decoded_option *decoded, + unsigned int lang_mask, int kind, location_t loc, + const struct cl_option_handlers *handlers, + diagnostic_context *dc); + + /* The mask that must have some bit in common with the flags for the + option for this particular handler to be used. */ + unsigned int mask; +}; + +/* Structure describing the callbacks used in handling options. */ + +struct cl_option_handlers +{ + /* Callback for an unknown option to determine whether to give an + error for it, and possibly store information to diagnose the + option at a later point. Return true if an error should be + given, false otherwise. */ + bool (*unknown_option_callback) (const struct cl_decoded_option *decoded); + + /* Callback to handle, and possibly diagnose, an option for another + language. */ + void (*wrong_lang_callback) (const struct cl_decoded_option *decoded, + unsigned int lang_mask); + + /* Callback to call after the successful handling of any option. */ + void (*post_handling_callback) (const struct cl_decoded_option *decoded, + unsigned int mask); + + /* The number of individual handlers. */ + size_t num_handlers; + + /* The handlers themselves. */ + struct cl_option_handler_func handlers[3]; +}; + +/* Input file names. */ + +extern const char **in_fnames; + +/* The count of input filenames. */ + +extern unsigned num_in_fnames; + +/* GCC command-line arguments used during profile-gen, that are saved to the + profile data file. During profile-use, these can be compared to make sure + only those auxiliary modules are actually imported that use a compatible + set of GCC flags as the primary module. */ +extern const char **lipo_cl_args; + +/* The size of the above mentioned mentioned array. */ +extern unsigned num_lipo_cl_args; + +size_t find_opt (const char *input, int lang_mask); +extern int integral_argument (const char *arg); +extern bool enum_value_to_arg (const struct cl_enum_arg *enum_args, + const char **argp, int value, + unsigned int lang_mask); +extern void decode_cmdline_options_to_array (unsigned int argc, + const char **argv, + unsigned int lang_mask, + struct cl_decoded_option **decoded_options, + unsigned int *decoded_options_count); +extern void init_options_once (void); +extern void init_options_struct (struct gcc_options *opts, + struct gcc_options *opts_set); +extern void decode_cmdline_options_to_array_default_mask (unsigned int argc, + const char **argv, + struct cl_decoded_option **decoded_options, + unsigned int *decoded_options_count); +extern void set_default_handlers (struct cl_option_handlers *handlers); +extern void decode_options (struct gcc_options *opts, + struct gcc_options *opts_set, + struct cl_decoded_option *decoded_options, + unsigned int decoded_options_count, + location_t loc, + diagnostic_context *dc); +extern int option_enabled (int opt_idx, void *opts); +extern bool get_option_state (struct gcc_options *, int, + struct cl_option_state *); +extern void set_option (struct gcc_options *opts, + struct gcc_options *opts_set, + int opt_index, int value, const char *arg, int kind, + location_t loc, diagnostic_context *dc); +extern void *option_flag_var (int opt_index, struct gcc_options *opts); +bool handle_generated_option (struct gcc_options *opts, + struct gcc_options *opts_set, + size_t opt_index, const char *arg, int value, + unsigned int lang_mask, int kind, location_t loc, + const struct cl_option_handlers *handlers, + diagnostic_context *dc); +void generate_option (size_t opt_index, const char *arg, int value, + unsigned int lang_mask, + struct cl_decoded_option *decoded); +void generate_option_input_file (const char *file, + struct cl_decoded_option *decoded); +extern void read_cmdline_option (struct gcc_options *opts, + struct gcc_options *opts_set, + struct cl_decoded_option *decoded, + location_t loc, + unsigned int lang_mask, + const struct cl_option_handlers *handlers, + diagnostic_context *dc); +extern void control_warning_option (unsigned int opt_index, int kind, + bool imply, location_t loc, + unsigned int lang_mask, + const struct cl_option_handlers *handlers, + struct gcc_options *opts, + struct gcc_options *opts_set, + diagnostic_context *dc); +extern void print_ignored_options (void); +extern void add_input_filename (const char *filename); +extern void add_module_info (unsigned mod_id, bool is_primary, int index); +extern void set_lipo_c_parsing_context (struct cpp_reader *parse_in, int i, bool verbose); +extern void coverage_note_define (const char *cpp_def, bool is_def); +extern void coverage_note_include (const char *filename); +extern void handle_common_deferred_options (void); +extern bool common_handle_option (struct gcc_options *opts, + struct gcc_options *opts_set, + const struct cl_decoded_option *decoded, + unsigned int lang_mask, int kind, + location_t loc, + const struct cl_option_handlers *handlers, + diagnostic_context *dc); +extern bool target_handle_option (struct gcc_options *opts, + struct gcc_options *opts_set, + const struct cl_decoded_option *decoded, + unsigned int lang_mask, int kind, + location_t loc, + const struct cl_option_handlers *handlers, + diagnostic_context *dc); +extern void finish_options (struct gcc_options *opts, + struct gcc_options *opts_set, + location_t loc); +extern void default_options_optimization (struct gcc_options *opts, + struct gcc_options *opts_set, + struct cl_decoded_option *decoded_options, + unsigned int decoded_options_count, + location_t loc, + unsigned int lang_mask, + const struct cl_option_handlers *handlers, + diagnostic_context *dc); +extern void set_struct_debug_option (struct gcc_options *opts, + location_t loc, + const char *value); +extern void write_opts_to_asm (void); +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/output.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/output.h new file mode 100644 index 0000000..661b623 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/output.h @@ -0,0 +1,687 @@ +/* Declarations for insn-output.c. These functions are defined in recog.c, + final.c, and varasm.c. + Copyright (C) 1987, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002, + 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + 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/>. */ + +#ifndef GCC_OUTPUT_H +#define GCC_OUTPUT_H + +/* Initialize data in final at the beginning of a compilation. */ +extern void init_final (const char *); + +/* Enable APP processing of subsequent output. + Used before the output from an `asm' statement. */ +extern void app_enable (void); + +/* Disable APP processing of subsequent output. + Called from varasm.c before most kinds of output. */ +extern void app_disable (void); + +/* Return the number of slots filled in the current + delayed branch sequence (we don't count the insn needing the + delay slot). Zero if not in a delayed branch sequence. */ +extern int dbr_sequence_length (void); + +/* Indicate that branch shortening hasn't yet been done. */ +extern void init_insn_lengths (void); + +/* Obtain the current length of an insn. If branch shortening has been done, + get its actual length. Otherwise, get its maximum length. */ +extern int get_attr_length (rtx); + +/* Obtain the current length of an insn. If branch shortening has been done, + get its actual length. Otherwise, get its minimum length. */ +extern int get_attr_min_length (rtx); + +/* Make a pass over all insns and compute their actual lengths by shortening + any branches of variable length if possible. */ +extern void shorten_branches (rtx); + +/* Output assembler code for the start of a function, + and initialize some of the variables in this file + for the new function. The label for the function and associated + assembler pseudo-ops have already been output in + `assemble_start_function'. */ +extern void final_start_function (rtx, FILE *, int); + +/* Output assembler code for the end of a function. + For clarity, args are same as those of `final_start_function' + even though not all of them are needed. */ +extern void final_end_function (void); + +/* Output assembler code for some insns: all or part of a function. */ +extern void final (rtx, FILE *, int); + +/* The final scan for one insn, INSN. Args are same as in `final', except + that INSN is the insn being scanned. Value returned is the next insn to + be scanned. */ +extern rtx final_scan_insn (rtx, FILE *, int, int, int *); + +/* Replace a SUBREG with a REG or a MEM, based on the thing it is a + subreg of. */ +extern rtx alter_subreg (rtx *); + +/* Print an operand using machine-dependent assembler syntax. */ +extern void output_operand (rtx, int); + +/* Report inconsistency between the assembler template and the operands. + In an `asm', it's the user's fault; otherwise, the compiler's fault. */ +extern void output_operand_lossage (const char *, ...) ATTRIBUTE_PRINTF_1; + +/* Output a string of assembler code, substituting insn operands. + Defined in final.c. */ +extern void output_asm_insn (const char *, rtx *); + +/* Compute a worst-case reference address of a branch so that it + can be safely used in the presence of aligned labels. + Defined in final.c. */ +extern int insn_current_reference_address (rtx); + +/* Find the alignment associated with a CODE_LABEL. + Defined in final.c. */ +extern int label_to_alignment (rtx); + +/* Find the alignment maximum skip associated with a CODE_LABEL. + Defined in final.c. */ +extern int label_to_max_skip (rtx); + +/* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */ +extern void output_asm_label (rtx); + +/* Marks SYMBOL_REFs in x as referenced through use of assemble_external. */ +extern void mark_symbol_refs_as_used (rtx); + +/* Print a memory reference operand for address X + using machine-dependent assembler syntax. */ +extern void output_address (rtx); + +/* Print an integer constant expression in assembler syntax. + Addition and subtraction are the only arithmetic + that may appear in these expressions. */ +extern void output_addr_const (FILE *, rtx); + +/* Output a string of assembler code, substituting numbers, strings + and fixed syntactic prefixes. */ +#if GCC_VERSION >= 3004 +#define ATTRIBUTE_ASM_FPRINTF(m, n) __attribute__ ((__format__ (__asm_fprintf__, m, n))) ATTRIBUTE_NONNULL(m) +/* This is a magic identifier which allows GCC to figure out the type + of HOST_WIDE_INT for %wd specifier checks. You must issue this + typedef before using the __asm_fprintf__ format attribute. */ +typedef HOST_WIDE_INT __gcc_host_wide_int__; +#else +#define ATTRIBUTE_ASM_FPRINTF(m, n) ATTRIBUTE_NONNULL(m) +#endif + +extern void asm_fprintf (FILE *file, const char *p, ...) + ATTRIBUTE_ASM_FPRINTF(2, 3); + +/* Split up a CONST_DOUBLE or integer constant rtx into two rtx's for single + words. */ +extern void split_double (rtx, rtx *, rtx *); + +/* Return nonzero if this function has no function calls. */ +extern int leaf_function_p (void); + +/* Return 1 if branch is a forward branch. + Uses insn_shuid array, so it works only in the final pass. May be used by + output templates to add branch prediction hints, for example. */ +extern int final_forward_branch_p (rtx); + +/* Return 1 if this function uses only the registers that can be + safely renumbered. */ +extern int only_leaf_regs_used (void); + +/* Scan IN_RTX and its subexpressions, and renumber all regs into those + available in leaf functions. */ +extern void leaf_renumber_regs_insn (rtx); + +/* Locate the proper template for the given insn-code. */ +extern const char *get_insn_template (int, rtx); + +/* Functions in varasm.c. */ + +/* Declare DECL to be a weak symbol. */ +extern void declare_weak (tree); +/* Merge weak status. */ +extern void merge_weak (tree, tree); + +/* Emit any pending weak declarations. */ +extern void weak_finish (void); + +/* Return the default TLS model for a given variable. */ +extern enum tls_model decl_default_tls_model (const_tree); + +/* Decode an `asm' spec for a declaration as a register name. + Return the register number, or -1 if nothing specified, + or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized, + or -3 if ASMSPEC is `cc' and is not recognized, + or -4 if ASMSPEC is `memory' and is not recognized. + Accept an exact spelling or a decimal number. + Prefixes such as % are optional. */ +extern int decode_reg_name (const char *); + +/* Similar to decode_reg_name, but takes an extra parameter that is a + pointer to the number of (internal) registers described by the + external name. */ +extern int decode_reg_name_and_count (const char *, int *); + +extern void assemble_alias (tree, tree); + +extern void default_assemble_visibility (tree, int); + +/* Output a string of literal assembler code + for an `asm' keyword used between functions. */ +extern void assemble_asm (tree); + +/* Output assembler code for the constant pool of a function and associated + with defining the name of the function. DECL describes the function. + NAME is the function's name. For the constant pool, we use the current + constant pool data. */ +extern void assemble_start_function (tree, const char *); + +/* Output assembler code associated with defining the size of the + function. DECL describes the function. NAME is the function's name. */ +extern void assemble_end_function (tree, const char *); + +/* Assemble everything that is needed for a variable or function declaration. + Not used for automatic variables, and not used for function definitions. + Should not be called for variables of incomplete structure type. + + TOP_LEVEL is nonzero if this variable has file scope. + AT_END is nonzero if this is the special handling, at end of compilation, + to define things that have had only tentative definitions. + DONT_OUTPUT_DATA if nonzero means don't actually output the + initial value (that will be done by the caller). */ +extern void assemble_variable (tree, int, int, int); + +/* Compute the alignment of variable specified by DECL. + DONT_OUTPUT_DATA is from assemble_variable. */ +extern void align_variable (tree decl, bool dont_output_data); + +/* Queue for outputting something to declare an external symbol to the + assembler. (Most assemblers don't need this, so we normally output + nothing.) Do nothing if DECL is not external. */ +extern void assemble_external (tree); + +/* Assemble code to leave SIZE bytes of zeros. */ +extern void assemble_zeros (unsigned HOST_WIDE_INT); + +/* Assemble an alignment pseudo op for an ALIGN-bit boundary. */ +extern void assemble_align (int); + +/* Assemble a string constant with the specified C string as contents. */ +extern void assemble_string (const char *, int); + +/* Similar, for calling a library function FUN. */ +extern void assemble_external_libcall (rtx); + +/* Assemble a label named NAME. */ +extern void assemble_label (FILE *, const char *); + +/* Output to FILE (an assembly file) a reference to NAME. If NAME + starts with a *, the rest of NAME is output verbatim. Otherwise + NAME is transformed in a target-specific way (usually by the + addition of an underscore). */ +extern void assemble_name_raw (FILE *, const char *); + +/* Like assemble_name_raw, but should be used when NAME might refer to + an entity that is also represented as a tree (like a function or + variable). If NAME does refer to such an entity, that entity will + be marked as referenced. */ +extern void assemble_name (FILE *, const char *); + +/* Return the assembler directive for creating a given kind of integer + object. SIZE is the number of bytes in the object and ALIGNED_P + indicates whether it is known to be aligned. Return NULL if the + assembly dialect has no such directive. + + The returned string should be printed at the start of a new line and + be followed immediately by the object's initial value. */ +extern const char *integer_asm_op (int, int); + +/* Use directive OP to assemble an integer object X. Print OP at the + start of the line, followed immediately by the value of X. */ +extern void assemble_integer_with_op (const char *, rtx); + +/* The default implementation of the asm_out.integer target hook. */ +extern bool default_assemble_integer (rtx, unsigned int, int); + +/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is + the alignment of the integer in bits. Return 1 if we were able to output + the constant, otherwise 0. If FORCE is nonzero the constant must + be outputable. */ +extern bool assemble_integer (rtx, unsigned, unsigned, int); + +/* Return section for TEXT_SECITON_NAME if DECL or DECL_SECTION_NAME (DECL) + is NULL. */ +extern section *get_named_text_section (tree, const char *, const char *); + +/* An interface to assemble_integer for the common case in which a value is + fully aligned and must be printed. VALUE is the value of the integer + object and SIZE is the number of bytes it contains. */ +#define assemble_aligned_integer(SIZE, VALUE) \ + assemble_integer (VALUE, SIZE, (SIZE) * BITS_PER_UNIT, 1) + +#ifdef REAL_VALUE_TYPE_SIZE +/* Assemble the floating-point constant D into an object of size MODE. */ +extern void assemble_real (REAL_VALUE_TYPE, enum machine_mode, unsigned); +#endif + +/* Write the address of the entity given by SYMBOL to SEC. */ +extern void assemble_addr_to_section (rtx, section *); + +/* Return the size of the constant pool. */ +extern int get_pool_size (void); + +#ifdef HAVE_peephole +extern rtx peephole (rtx); +#endif + +extern void output_shared_constant_pool (void); + +extern void output_object_blocks (void); + +extern void output_quoted_string (FILE *, const char *); + +/* Whether a constructor CTOR is a valid static constant initializer if all + its elements are. This used to be internal to initializer_constant_valid_p + and has been exposed to let other functions like categorize_ctor_elements + evaluate the property while walking a constructor for other purposes. */ + +extern bool constructor_static_from_elts_p (const_tree); + +/* Return nonzero if VALUE is a valid constant-valued expression + for use in initializing a static variable; one that can be an + element of a "constant" initializer. + + Return null_pointer_node if the value is absolute; + if it is relocatable, return the variable that determines the relocation. + We assume that VALUE has been folded as much as possible; + therefore, we do not need to check for such things as + arithmetic-combinations of integers. */ +extern tree initializer_constant_valid_p (tree, tree); + +/* Return true if VALUE is a valid constant-valued expression + for use in initializing a static bit-field; one that can be + an element of a "constant" initializer. */ +extern bool initializer_constant_valid_for_bitfield_p (tree); + +/* Output assembler code for constant EXP to FILE, with no label. + This includes the pseudo-op such as ".int" or ".byte", and a newline. + Assumes output_addressed_constants has been done on EXP already. + + Generate exactly SIZE bytes of assembler data, padding at the end + with zeros if necessary. SIZE must always be specified. + + ALIGN is the alignment in bits that may be assumed for the data. */ +extern void output_constant (tree, unsigned HOST_WIDE_INT, unsigned int); + +/* When outputting delayed branch sequences, this rtx holds the + sequence being output. It is null when no delayed branch + sequence is being output, so it can be used as a test in the + insn output code. + + This variable is defined in final.c. */ +extern rtx final_sequence; + +/* The line number of the beginning of the current function. Various + md code needs this so that it can output relative linenumbers. */ + +#ifdef SDB_DEBUGGING_INFO /* Avoid undef sym in certain broken linkers. */ +extern int sdb_begin_function_line; +#endif + +/* File in which assembler code is being written. */ + +#ifdef BUFSIZ +extern FILE *asm_out_file; +#endif + +/* The first global object in the file. */ +extern const char *first_global_object_name; + +/* The first weak object in the file. */ +extern const char *weak_global_object_name; + +/* Nonzero if function being compiled doesn't contain any calls + (ignoring the prologue and epilogue). This is set prior to + local register allocation and is valid for the remaining + compiler passes. */ + +extern int current_function_is_leaf; + +/* Nonzero if function being compiled doesn't modify the stack pointer + (ignoring the prologue and epilogue). This is only valid after + pass_stack_ptr_mod has run. */ + +extern int current_function_sp_is_unchanging; + +/* Nonzero if the function being compiled is a leaf function which only + uses leaf registers. This is valid after reload (specifically after + sched2) and is useful only if the port defines LEAF_REGISTERS. */ + +extern int current_function_uses_only_leaf_regs; + +/* Default file in which to dump debug output. */ + +#ifdef BUFSIZ +extern FILE *dump_file; +#endif + +/* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */ +extern rtx current_insn_predicate; + +/* Last insn processed by final_scan_insn. */ +extern rtx current_output_insn; + +/* Nonzero while outputting an `asm' with operands. + This means that inconsistencies are the user's fault, so don't die. + The precise value is the insn being output, to pass to error_for_asm. */ +extern rtx this_is_asm_operands; + +/* Carry information from ASM_DECLARE_OBJECT_NAME + to ASM_FINISH_DECLARE_OBJECT. */ +extern int size_directive_output; +extern tree last_assemble_variable_decl; + +extern bool first_function_block_is_cold; + +/* Decide whether DECL needs to be in a writable section. + RELOC is the same as for SELECT_SECTION. */ +extern bool decl_readonly_section (const_tree, int); + +/* This can be used to compute RELOC for the function above, when + given a constant expression. */ +extern int compute_reloc_for_constant (tree); + +/* User label prefix in effect for this compilation. */ +extern const char *user_label_prefix; + +/* Default target function prologue and epilogue assembler output. */ +extern void default_function_pro_epilogue (FILE *, HOST_WIDE_INT); + +/* Default target function switched text sections. */ +extern void default_function_switched_text_sections (FILE *, tree, bool); + +/* Default target hook that outputs nothing to a stream. */ +extern void no_asm_to_stream (FILE *); + +/* Flags controlling properties of a section. */ +#define SECTION_ENTSIZE 0x000ff /* entity size in section */ +#define SECTION_CODE 0x00100 /* contains code */ +#define SECTION_WRITE 0x00200 /* data is writable */ +#define SECTION_DEBUG 0x00400 /* contains debug data */ +#define SECTION_LINKONCE 0x00800 /* is linkonce */ +#define SECTION_SMALL 0x01000 /* contains "small data" */ +#define SECTION_BSS 0x02000 /* contains zeros only */ +#define SECTION_FORGET 0x04000 /* forget that we've entered the section */ +#define SECTION_MERGE 0x08000 /* contains mergeable data */ +#define SECTION_STRINGS 0x10000 /* contains zero terminated strings without + embedded zeros */ +#define SECTION_OVERRIDE 0x20000 /* allow override of default flags */ +#define SECTION_TLS 0x40000 /* contains thread-local storage */ +#define SECTION_NOTYPE 0x80000 /* don't output @progbits */ +#define SECTION_DECLARED 0x100000 /* section has been used */ +#define SECTION_STYLE_MASK 0x600000 /* bits used for SECTION_STYLE */ +#define SECTION_COMMON 0x800000 /* contains common data */ +#define SECTION_RELRO 0x1000000 /* data is readonly after relocation processing */ +#define SECTION_MACH_DEP 0x2000000 /* subsequent bits reserved for target */ +#define SECTION_EXCLUDE 0x4000000 /* discarded by the linker */ + +/* This SECTION_STYLE is used for unnamed sections that we can switch + to using a special assembler directive. */ +#define SECTION_UNNAMED 0x000000 + +/* This SECTION_STYLE is used for named sections that we can switch + to using a general section directive. */ +#define SECTION_NAMED 0x200000 + +/* This SECTION_STYLE is used for sections that we cannot switch to at + all. The choice of section is implied by the directive that we use + to declare the object. */ +#define SECTION_NOSWITCH 0x400000 + +/* A helper function for default_elf_select_section and + default_elf_unique_section. Categorizes the DECL. */ + +enum section_category +{ + SECCAT_TEXT, + + SECCAT_RODATA, + SECCAT_RODATA_MERGE_STR, + SECCAT_RODATA_MERGE_STR_INIT, + SECCAT_RODATA_MERGE_CONST, + SECCAT_SRODATA, + + SECCAT_DATA, + + /* To optimize loading of shared programs, define following subsections + of data section: + _REL Contains data that has relocations, so they get grouped + together and dynamic linker will visit fewer pages in memory. + _RO Contains data that is otherwise read-only. This is useful + with prelinking as most relocations won't be dynamically + linked and thus stay read only. + _LOCAL Marks data containing relocations only to local objects. + These relocations will get fully resolved by prelinking. */ + SECCAT_DATA_REL, + SECCAT_DATA_REL_LOCAL, + SECCAT_DATA_REL_RO, + SECCAT_DATA_REL_RO_LOCAL, + + SECCAT_SDATA, + SECCAT_TDATA, + + SECCAT_BSS, + SECCAT_SBSS, + SECCAT_TBSS +}; + +/* Information that is provided by all instances of the section type. */ +struct GTY(()) section_common { + /* The set of SECTION_* flags that apply to this section. */ + unsigned int flags; +}; + +/* Information about a SECTION_NAMED section. */ +struct GTY(()) named_section { + struct section_common common; + + /* The name of the section. */ + const char *name; + + /* If nonnull, the VAR_DECL or FUNCTION_DECL with which the + section is associated. */ + tree decl; +}; + +/* A callback that writes the assembly code for switching to an unnamed + section. The argument provides callback-specific data. */ +typedef void (*unnamed_section_callback) (const void *); + +/* Information about a SECTION_UNNAMED section. */ +struct GTY(()) unnamed_section { + struct section_common common; + + /* The callback used to switch to the section, and the data that + should be passed to the callback. */ + unnamed_section_callback GTY ((skip)) callback; + const void *GTY ((skip)) data; + + /* The next entry in the chain of unnamed sections. */ + section *next; +}; + +/* A callback that writes the assembly code for a decl in a + SECTION_NOSWITCH section. DECL is the decl that should be assembled + and NAME is the name of its SYMBOL_REF. SIZE is the size of the decl + in bytes and ROUNDED is that size rounded up to the next + BIGGEST_ALIGNMENT / BITS_PER_UNIT boundary. + + Return true if the callback used DECL_ALIGN to set the object's + alignment. A false return value implies that we are relying + on the rounded size to align the decl. */ +typedef bool (*noswitch_section_callback) (tree decl, const char *name, + unsigned HOST_WIDE_INT size, + unsigned HOST_WIDE_INT rounded); + +/* Information about a SECTION_NOSWITCH section. */ +struct GTY(()) noswitch_section { + struct section_common common; + + /* The callback used to assemble decls in this section. */ + noswitch_section_callback GTY ((skip)) callback; +}; + +/* Information about a section, which may be named or unnamed. */ +union GTY ((desc ("SECTION_STYLE (&(%h))"))) section { + struct section_common GTY ((skip)) common; + struct named_section GTY ((tag ("SECTION_NAMED"))) named; + struct unnamed_section GTY ((tag ("SECTION_UNNAMED"))) unnamed; + struct noswitch_section GTY ((tag ("SECTION_NOSWITCH"))) noswitch; +}; + +/* Return the style of section SECT. */ +#define SECTION_STYLE(SECT) ((SECT)->common.flags & SECTION_STYLE_MASK) + +struct object_block; + +/* Special well-known sections. */ +extern GTY(()) section *text_section; +extern GTY(()) section *data_section; +extern GTY(()) section *readonly_data_section; +extern GTY(()) section *sdata_section; +extern GTY(()) section *ctors_section; +extern GTY(()) section *dtors_section; +extern GTY(()) section *bss_section; +extern GTY(()) section *sbss_section; +extern GTY(()) section *exception_section; +extern GTY(()) section *eh_frame_section; +extern GTY(()) section *tls_comm_section; +extern GTY(()) section *comm_section; +extern GTY(()) section *lcomm_section; +extern GTY(()) section *bss_noswitch_section; + +extern GTY(()) section *in_section; +extern GTY(()) bool in_cold_section_p; + +extern section *get_unnamed_section (unsigned int, void (*) (const void *), + const void *); +extern section *get_section (const char *, unsigned int, tree); +extern section *get_named_section (tree, const char *, int); +extern section *get_variable_section (tree, bool); +extern void place_block_symbol (rtx); +extern rtx get_section_anchor (struct object_block *, HOST_WIDE_INT, + enum tls_model); +extern section *mergeable_constant_section (enum machine_mode, + unsigned HOST_WIDE_INT, + unsigned int); +extern section *function_section (tree); +extern section *unlikely_text_section (void); +extern section *current_function_section (void); + +/* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if + not) section for PRIORITY. */ +extern section *get_cdtor_priority_section (int, bool); + +extern bool unlikely_text_section_p (section *); +extern void switch_to_section (section *); +extern void output_section_asm_op (const void *); + +extern void default_asm_output_source_filename (FILE *, const char *); +extern void output_file_directive (FILE *, const char *); + +extern unsigned int default_section_type_flags (tree, const char *, int); + +extern bool have_global_bss_p (void); +extern void default_no_named_section (const char *, unsigned int, tree); +extern void default_elf_asm_named_section (const char *, unsigned int, tree); +extern enum section_category categorize_decl_for_section (const_tree, int); +extern void default_coff_asm_named_section (const char *, unsigned int, tree); +extern void default_pe_asm_named_section (const char *, unsigned int, tree); + +extern void default_stabs_asm_out_destructor (rtx, int); +extern void default_named_section_asm_out_destructor (rtx, int); +extern void default_dtor_section_asm_out_destructor (rtx, int); +extern void default_stabs_asm_out_constructor (rtx, int); +extern void default_named_section_asm_out_constructor (rtx, int); +extern void default_ctor_section_asm_out_constructor (rtx, int); + +extern section *default_select_section (tree, int, unsigned HOST_WIDE_INT); +extern section *default_elf_select_section (tree, int, unsigned HOST_WIDE_INT); +extern void default_unique_section (tree, int); +extern section *default_function_rodata_section (tree); +extern section *default_no_function_rodata_section (tree); +extern section *default_select_rtx_section (enum machine_mode, rtx, + unsigned HOST_WIDE_INT); +extern section *default_elf_select_rtx_section (enum machine_mode, rtx, + unsigned HOST_WIDE_INT); +extern void default_encode_section_info (tree, rtx, int); +extern const char *default_strip_name_encoding (const char *); +extern void default_asm_output_anchor (rtx); +extern bool default_use_anchors_for_symbol_p (const_rtx); +extern bool default_binds_local_p (const_tree); +extern bool default_binds_local_p_1 (const_tree, int); +extern void default_globalize_label (FILE *, const char *); +extern void default_globalize_decl_name (FILE *, tree); +extern void default_emit_unwind_label (FILE *, tree, int, int); +extern void default_emit_except_table_label (FILE *); +extern void default_generate_internal_label (char *, const char *, + unsigned long); +extern void default_internal_label (FILE *, const char *, unsigned long); +extern void default_asm_declare_constant_name (FILE *, const char *, + const_tree, HOST_WIDE_INT); +extern void default_file_start (void); +extern void file_end_indicate_exec_stack (void); +extern void file_end_indicate_split_stack (void); + +extern void default_elf_asm_output_external (FILE *file, tree, + const char *); +extern void default_elf_init_array_asm_out_constructor (rtx, int); +extern void default_elf_fini_array_asm_out_destructor (rtx, int); +extern int maybe_assemble_visibility (tree); + +extern int default_address_cost (rtx, bool); + +/* Output stack usage information. */ +extern void output_stack_usage (void); + +/* dbxout helper functions */ +#if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO + +extern void dbxout_int (int); +extern void dbxout_stabd (int, int); +extern void dbxout_begin_stabn (int); +extern void dbxout_begin_stabn_sline (int); +extern void dbxout_begin_empty_stabs (int); +extern void dbxout_begin_simple_stabs (const char *, int); +extern void dbxout_begin_simple_stabs_desc (const char *, int, int); + +extern void dbxout_stab_value_zero (void); +extern void dbxout_stab_value_label (const char *); +extern void dbxout_stab_value_label_diff (const char *, const char *); +extern void dbxout_stab_value_internal_label (const char *, int *); +extern void dbxout_stab_value_internal_label_diff (const char *, int *, + const char *); + +#endif + +#endif /* ! GCC_OUTPUT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/params.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/params.def new file mode 100644 index 0000000..168fb5f --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/params.def @@ -0,0 +1,1049 @@ +/* params.def - Run-time parameters. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, + 2011 + Free Software Foundation, Inc. + Written by Mark Mitchell <mark@codesourcery.com>. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* This file contains definitions for language-independent + parameters. The DEFPARAM macro takes 6 arguments: + + - The enumeral corresponding to this parameter. + + - The name that can be used to set this parameter using the + command-line option `--param <name>=<value>'. + + - A help string explaining how the parameter is used. + + - A default value for the parameter. + + - The minimum acceptable value for the parameter. + + - The maximum acceptable value for the parameter (if greater than + the minimum). + + Be sure to add an entry to invoke.texi summarizing the parameter. */ + +/* The threshold ratio between current and hottest structure counts. + We say that if the ratio of the current structure count, + calculated by profiling, to the hottest structure count + in the program is less than this parameter, then structure + reorganization is not applied. The default is 10%. */ +DEFPARAM (PARAM_STRUCT_REORG_COLD_STRUCT_RATIO, + "struct-reorg-cold-struct-ratio", + "The threshold ratio between current and hottest structure counts", + 10, 0, 100) + +/* When branch is predicted to be taken with probability lower than this + threshold (in percent), then it is considered well predictable. */ +DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME, + "predictable-branch-outcome", + "Maximal estimated outcome of branch considered predictable", + 2, 0, 50) + +/* The single function inlining limit. This is the maximum size + of a function counted in internal gcc instructions (not in + real machine instructions) that is eligible for inlining + by the tree inliner. + The default value is 450. + Only functions marked inline (or methods defined in the class + definition for C++) are affected by this. + There are more restrictions to inlining: If inlined functions + call other functions, the already inlined instructions are + counted and once the recursive inline limit (see + "max-inline-insns" parameter) is exceeded, the acceptable size + gets decreased. */ +DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE, + "max-inline-insns-single", + "The maximum number of instructions in a single function eligible for inlining", + 400, 0, 0) + +/* The single function inlining limit for functions that are + inlined by virtue of -finline-functions (-O3). + This limit should be chosen to be below or equal to the limit + that is applied to functions marked inlined (or defined in the + class declaration in C++) given by the "max-inline-insns-single" + parameter. + The default value is 40. */ +DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, + "max-inline-insns-auto", + "The maximum number of instructions when automatically inlining", + 40, 0, 0) + +DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, + "max-inline-insns-recursive", + "The maximum number of instructions inline function can grow to via recursive inlining", + 450, 0, 0) + +DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO, + "max-inline-insns-recursive-auto", + "The maximum number of instructions non-inline function can grow to via recursive inlining", + 450, 0, 0) + +DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH, + "max-inline-recursive-depth", + "The maximum depth of recursive inlining for inline functions", + 8, 0, 0) + +DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO, + "max-inline-recursive-depth-auto", + "The maximum depth of recursive inlining for non-inline functions", + 8, 0, 0) + +DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY, + "min-inline-recursive-probability", + "Inline recursively only when the probability of call being executed exceeds the parameter", + 10, 0, 0) + +DEFPARAM (PARAM_INLINE_FUNCTION_OVERHEAD_SIZE, + "inline-function-overhead-size", + "Size estimate of function overhead (prologue/epilogue) for inlining purposes", + 7, 0, 0) + +/* Limit of iterations of early inliner. This basically bounds number of + nested indirect calls early inliner can resolve. Deeper chains are still + handled by late inlining. */ +DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS, + "max-early-inliner-iterations", + "The maximum number of nested indirect inlining performed by early inliner", + 10, 0, 0) + +/* Limit on probability of entry BB. */ +DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY, + "comdat-sharing-probability", + "Probability that COMDAT function will be shared with different compilatoin unit", + 20, 0, 0) + +/* Limit on probability of entry BB. */ +DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY, + "partial-inlining-entry-probability", + "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen", + 70, 0, 0) + +/* Limit the number of expansions created by the variable expansion + optimization to avoid register pressure. */ +DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS, + "max-variable-expansions-in-unroller", + "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling", + 1, 0, 0) + +/* Limit loop autovectorization to loops with large enough iteration count. */ +DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND, + "min-vect-loop-bound", + "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization", + 1, 1, 0) + +/* The maximum number of instructions to consider when looking for an + instruction to fill a delay slot. If more than this arbitrary + number of instructions is searched, the time savings from filling + the delay slot will be minimal so stop searching. Increasing + values mean more aggressive optimization, making the compile time + increase with probably small improvement in executable run time. */ +DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH, + "max-delay-slot-insn-search", + "The maximum number of instructions to consider to fill a delay slot", + 100, 0, 0) + +/* When trying to fill delay slots, the maximum number of instructions + to consider when searching for a block with valid live register + information. Increasing this arbitrarily chosen value means more + aggressive optimization, increasing the compile time. This + parameter should be removed when the delay slot code is rewritten + to maintain the control-flow graph. */ +DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH, + "max-delay-slot-live-search", + "The maximum number of instructions to consider to find accurate live register information", + 333, 0, 0) + +/* This parameter limits the number of branch elements that the + scheduler will track anti-dependencies through without resetting + the tracking mechanism. Large functions with few calls or barriers + can generate lists containing many 1000's of dependencies. Generally + the compiler either uses all available memory, or runs for far too long. */ +DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH, + "max-pending-list-length", + "The maximum length of scheduling's pending operations list", + 32, 0, 0) + +DEFPARAM(PARAM_LARGE_FUNCTION_INSNS, + "large-function-insns", + "The size of function body to be considered large", + 2700, 0, 0) +DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH, + "large-function-growth", + "Maximal growth due to inlining of large function (in percent)", + 100, 0, 0) +DEFPARAM(PARAM_LARGE_UNIT_INSNS, + "large-unit-insns", + "The size of translation unit to be considered large", + 10000, 0, 0) +DEFPARAM(PARAM_INLINE_UNIT_GROWTH, + "inline-unit-growth", + "How much can given compilation unit grow because of the inlining (in percent)", + 30, 0, 0) +DEFPARAM(PARAM_IPCP_UNIT_GROWTH, + "ipcp-unit-growth", + "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)", + 10, 0, 0) +DEFPARAM(PARAM_EARLY_INLINING_INSNS, + "early-inlining-insns", + "Maximal estimated growth of function body caused by early inlining of single call", + 10, 0, 0) +DEFPARAM(PARAM_LARGE_STACK_FRAME, + "large-stack-frame", + "The size of stack frame to be considered large", + 256, 0, 0) +DEFPARAM(PARAM_STACK_FRAME_GROWTH, + "large-stack-frame-growth", + "Maximal stack frame growth due to inlining (in percent)", + 1000, 0, 0) + +/* The GCSE optimization will be disabled if it would require + significantly more memory than this value. */ +DEFPARAM(PARAM_MAX_GCSE_MEMORY, + "max-gcse-memory", + "The maximum amount of memory to be allocated by GCSE", + 50 * 1024 * 1024, 0, 0) + +/* The GCSE optimization of an expression will avoided if the ratio of + insertions to deletions is greater than this value. */ +DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO, + "max-gcse-insertion-ratio", + "The maximum ratio of insertions to deletions of expressions in GCSE", + 20, 0, 0) + +/* This is the threshold ratio when to perform partial redundancy + elimination after reload. We perform partial redundancy elimination + when the following holds: + (Redundant load execution count) + ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION + (Added loads execution count) */ +DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION, + "gcse-after-reload-partial-fraction", + "The threshold ratio for performing partial redundancy elimination after reload", + 3, 0, 0) +/* This is the threshold ratio of the critical edges execution count compared to + the redundant loads execution count that permits performing the load + redundancy elimination in gcse after reload. */ +DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION, + "gcse-after-reload-critical-fraction", + "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload", + 10, 0, 0) + +/* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor + to calculate maximum distance for which an expression is allowed to move + from its rtx_cost. */ +DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO, + "gcse-cost-distance-ratio", + "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations", + 10, 0, 0) +/* GCSE won't restrict distance for which an expression with rtx_cost greater + than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move. */ +DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST, + "gcse-unrestricted-cost", + "Cost at which GCSE optimizations will not constraint the distance an expression can travel", + 3, 0, 0) + +/* How deep from a given basic block the dominator tree should be searched + for expressions to hoist to the block. The value of 0 will avoid limiting + the search. */ +DEFPARAM(PARAM_MAX_HOIST_DEPTH, + "max-hoist-depth", + "Maximum depth of search in the dominator tree for expressions to hoist", + 30, 0, 0) + +/* This parameter limits the number of insns in a loop that will be unrolled, + and by how much the loop is unrolled. + + This limit should be at most half of the peeling limits: loop unroller + decides to not unroll loops that iterate fewer than 2*number of allowed + unrollings and thus we would have loops that are neither peeled or unrolled + otherwise. */ +DEFPARAM(PARAM_MAX_UNROLLED_INSNS, + "max-unrolled-insns", + "The maximum number of instructions to consider to unroll in a loop", + 200, 0, 0) +/* This parameter limits how many times the loop is unrolled depending + on number of insns really executed in each iteration. */ +DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS, + "max-average-unrolled-insns", + "The maximum number of instructions to consider to unroll in a loop on average", + 80, 0, 0) +/* The maximum number of unrollings of a single loop. */ +DEFPARAM(PARAM_MAX_UNROLL_TIMES, + "max-unroll-times", + "The maximum number of unrollings of a single loop", + 8, 0, 0) +/* The maximum number of insns of a peeled loop. */ +DEFPARAM(PARAM_MAX_PEELED_INSNS, + "max-peeled-insns", + "The maximum number of insns of a peeled loop", + 400, 0, 0) +/* The maximum number of peelings of a single loop. */ +DEFPARAM(PARAM_MAX_PEEL_TIMES, + "max-peel-times", + "The maximum number of peelings of a single loop", + 16, 0, 0) +/* The maximum number of insns of a peeled loop. */ +DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS, + "max-completely-peeled-insns", + "The maximum number of insns of a completely peeled loop", + 400, 0, 0) +/* The maximum number of insns of a peeled loop, when feedback + information is available. */ +DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS_FEEDBACK, + "max-completely-peeled-insns-feedback", + "The maximum number of insns of a completely peeled loop when profile " + "feedback is available", + 600, 0, 0) +/* The maximum number of peelings of a single loop that is peeled completely. */ +DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES, + "max-completely-peel-times", + "The maximum number of peelings of a single loop that is peeled completely", + 8, 0, 0) +/* The maximum number of peelings of a single loop that is peeled + completely, when feedback information is available. */ +DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES_FEEDBACK, + "max-completely-peel-times-feedback", + "The maximum number of peelings of a single loop that is peeled " + "completely, when profile feedback is available", + 16, 0, 0) +/* The maximum number of insns of a peeled loop that rolls only once. */ +DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS, + "max-once-peeled-insns", + "The maximum number of insns of a peeled loop that rolls only once", + 400, 0, 0) +/* The maximum number of insns of a peeled loop that rolls only once, + when feedback information is available. */ +DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS_FEEDBACK, + "max-once-peeled-insns-feedback", + "The maximum number of insns of a peeled loop that rolls only once, " + "when profile feedback is available", + 600, 0, 0) +/* The maximum depth of a loop nest we completely peel. */ +DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS, + "max-completely-peel-loop-nest-depth", + "The maximum depth of a loop nest we completely peel", + 8, 0, 0) +/* The minimum profile count of basic blocks to look at when estimating + * the code size footprint of the call graph in a dynamic IPA compile. */ +DEFPARAM(PARAM_CODESIZE_HOTNESS_THRESHOLD, + "codesize-hotness-threshold", + "Minimum profile count of basic blocks counted towards dynamic IPA " + "code size footprint estimate", + 10000, 0, 0) +/* The maximum code size estimate under which loop unrolling and peeling + * is allowed in a dynamic IPA compile. This currently applies to loops with + * non-constant iteration counts and no floating point computations. */ +DEFPARAM(PARAM_UNROLLPEEL_CODESIZE_THRESHOLD, + "unrollpeel-codesize-threshold", + "Maximum dynamic IPA code size footprint estimate for loop unrolling " + "and peeling", + 10000, 0, 0) + +/* The maximum number of insns of an unswitched loop. */ +DEFPARAM(PARAM_MAX_UNSWITCH_INSNS, + "max-unswitch-insns", + "The maximum number of insns of an unswitched loop", + 50, 0, 0) +/* The maximum level of recursion in unswitch_single_loop. */ +DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL, + "max-unswitch-level", + "The maximum number of unswitchings in a single loop", + 3, 0, 0) + +/* The maximum number of iterations of a loop the brute force algorithm + for analysis of # of iterations of the loop tries to evaluate. */ +DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK, + "max-iterations-to-track", + "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates", + 1000, 0, 0) +/* A cutoff to avoid costly computations of the number of iterations in + the doloop transformation. */ +DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST, + "max-iterations-computation-cost", + "Bound on the cost of an expression to compute the number of iterations", + 10, 0, 0) + +/* This parameter is used to tune SMS MAX II calculations. */ +DEFPARAM(PARAM_SMS_MAX_II_FACTOR, + "sms-max-ii-factor", + "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop", + 100, 0, 0) +DEFPARAM(PARAM_SMS_DFA_HISTORY, + "sms-dfa-history", + "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA", + 0, 0, 0) +DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD, + "sms-loop-average-count-threshold", + "A threshold on the average loop count considered by the swing modulo scheduler", + 0, 0, 0) + +DEFPARAM(HOT_BB_COUNT_FRACTION, + "hot-bb-count-fraction", + "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot", + 40000, 0, 0) +DEFPARAM(HOT_BB_FREQUENCY_FRACTION, + "hot-bb-frequency-fraction", + "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot", + 1000, 0, 0) + +DEFPARAM (PARAM_ALIGN_THRESHOLD, + "align-threshold", + "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment", + 100, 0, 0) + +DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS, + "align-loop-iterations", + "Loops iterating at least selected number of iterations will get loop alignement.", + 4, 0, 0) + +/* For guessed profiles, the loops having unknown number of iterations + are predicted to iterate relatively few (10) times at average. + For functions containing one loop with large known number of iterations + and other loops having unbounded loops we would end up predicting all + the other loops cold that is not usually the case. So we need to artificially + flatten the profile. + + We need to cut the maximal predicted iterations to large enough iterations + so the loop appears important, but safely within HOT_BB_COUNT_FRACTION + range. */ + +DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS, + "max-predicted-iterations", + "The maximum number of loop iterations we predict statically", + 100, 0, 0) +DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK, + "tracer-dynamic-coverage-feedback", + "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available", + 95, 0, 100) +DEFPARAM(TRACER_DYNAMIC_COVERAGE, + "tracer-dynamic-coverage", + "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available", + 75, 0, 100) +DEFPARAM(TRACER_MAX_CODE_GROWTH, + "tracer-max-code-growth", + "Maximal code growth caused by tail duplication (in percent)", + 100, 0, 0) +DEFPARAM(TRACER_MIN_BRANCH_RATIO, + "tracer-min-branch-ratio", + "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)", + 10, 0, 100) +DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK, + "tracer-min-branch-probability-feedback", + "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available", + 80, 0, 100) +DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY, + "tracer-min-branch-probability", + "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available", + 50, 0, 100) + +/* The maximum number of incoming edges to consider for crossjumping. */ +DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES, + "max-crossjump-edges", + "The maximum number of incoming edges to consider for crossjumping", + 100, 0, 0) + +/* The minimum number of matching instructions to consider for crossjumping. */ +DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS, + "min-crossjump-insns", + "The minimum number of matching instructions to consider for crossjumping", + 5, 0, 0) + +/* The maximum number expansion factor when copying basic blocks. */ +DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS, + "max-grow-copy-bb-insns", + "The maximum expansion factor when copying basic blocks", + 8, 0, 0) + +/* The maximum number of insns to duplicate when unfactoring computed gotos. */ +DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS, + "max-goto-duplication-insns", + "The maximum number of insns to duplicate when unfactoring computed gotos", + 8, 0, 0) + +/* The maximum length of path considered in cse. */ +DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH, + "max-cse-path-length", + "The maximum length of path considered in cse", + 10, 0, 0) +DEFPARAM(PARAM_MAX_CSE_INSNS, + "max-cse-insns", + "The maximum instructions CSE process before flushing", + 1000, 0, 0) + +/* The cost of expression in loop invariant motion that is considered + expensive. */ +DEFPARAM(PARAM_LIM_EXPENSIVE, + "lim-expensive", + "The minimum cost of an expensive expression in the loop invariant motion", + 20, 0, 0) + +/* Bound on number of candidates for induction variables below that + all candidates are considered for each use in induction variable + optimizations. */ + +DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND, + "iv-consider-all-candidates-bound", + "Bound on number of candidates below that all candidates are considered in iv optimizations", + 30, 0, 0) + +/* The induction variable optimizations give up on loops that contain more + induction variable uses. */ + +DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES, + "iv-max-considered-uses", + "Bound on number of iv uses in loop optimized in iv optimizations", + 250, 0, 0) + +/* If there are at most this number of ivs in the set, try removing unnecessary + ivs from the set always. */ + +DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND, + "iv-always-prune-cand-set-bound", + "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization", + 10, 0, 0) + +DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, + "scev-max-expr-size", + "Bound on size of expressions used in the scalar evolutions analyzer", + 100, 0, 0) + +DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY, + "scev-max-expr-complexity", + "Bound on the complexity of the expressions in the scalar evolutions analyzer", + 10, 0, 0) + +DEFPARAM(PARAM_OMEGA_MAX_VARS, + "omega-max-vars", + "Bound on the number of variables in Omega constraint systems", + 128, 0, 0) + +DEFPARAM(PARAM_OMEGA_MAX_GEQS, + "omega-max-geqs", + "Bound on the number of inequalities in Omega constraint systems", + 256, 0, 0) + +DEFPARAM(PARAM_OMEGA_MAX_EQS, + "omega-max-eqs", + "Bound on the number of equalities in Omega constraint systems", + 128, 0, 0) + +DEFPARAM(PARAM_OMEGA_MAX_WILD_CARDS, + "omega-max-wild-cards", + "Bound on the number of wild cards in Omega constraint systems", + 18, 0, 0) + +DEFPARAM(PARAM_OMEGA_HASH_TABLE_SIZE, + "omega-hash-table-size", + "Bound on the size of the hash table in Omega constraint systems", + 550, 0, 0) + +DEFPARAM(PARAM_OMEGA_MAX_KEYS, + "omega-max-keys", + "Bound on the number of keys in Omega constraint systems", + 500, 0, 0) + +DEFPARAM(PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS, + "omega-eliminate-redundant-constraints", + "When set to 1, use expensive methods to eliminate all redundant constraints", + 0, 0, 1) + +DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS, + "vect-max-version-for-alignment-checks", + "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check", + 6, 0, 0) + +DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS, + "vect-max-version-for-alias-checks", + "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check", + 10, 0, 0) + +DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS, + "max-cselib-memory-locations", + "The maximum memory locations recorded by cselib", + 500, 0, 0) + +#ifdef ENABLE_GC_ALWAYS_COLLECT +# define GGC_MIN_EXPAND_DEFAULT 0 +# define GGC_MIN_HEAPSIZE_DEFAULT 0 +#else +# define GGC_MIN_EXPAND_DEFAULT 30 +# define GGC_MIN_HEAPSIZE_DEFAULT 4096 +#endif + +DEFPARAM(GGC_MIN_EXPAND, + "ggc-min-expand", + "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap", + GGC_MIN_EXPAND_DEFAULT, 0, 0) + +DEFPARAM(GGC_MIN_HEAPSIZE, + "ggc-min-heapsize", + "Minimum heap size before we start collecting garbage, in kilobytes", + GGC_MIN_HEAPSIZE_DEFAULT, 0, 0) + +#undef GGC_MIN_EXPAND_DEFAULT +#undef GGC_MIN_HEAPSIZE_DEFAULT + +DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS, + "max-reload-search-insns", + "The maximum number of instructions to search backward when looking for equivalent reload", + 100, 0, 0) + +DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS, + "max-sched-region-blocks", + "The maximum number of blocks in a region to be considered for interblock scheduling", + 10, 0, 0) + +DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS, + "max-sched-region-insns", + "The maximum number of insns in a region to be considered for interblock scheduling", + 100, 0, 0) + +DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS, + "max-pipeline-region-blocks", + "The maximum number of blocks in a region to be considered for interblock scheduling", + 15, 0, 0) + +DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS, + "max-pipeline-region-insns", + "The maximum number of insns in a region to be considered for interblock scheduling", + 200, 0, 0) + +DEFPARAM(PARAM_MIN_SPEC_PROB, + "min-spec-prob", + "The minimum probability of reaching a source block for interblock speculative scheduling", + 40, 0, 0) + +DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, + "max-sched-extend-regions-iters", + "The maximum number of iterations through CFG to extend regions", + 0, 0, 0) + +DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY, + "max-sched-insn-conflict-delay", + "The maximum conflict delay for an insn to be considered for speculative motion", + 3, 1, 10) + +DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF, + "sched-spec-prob-cutoff", + "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.", + 40, 0, 100) + +DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD, + "selsched-max-lookahead", + "The maximum size of the lookahead window of selective scheduling", + 50, 0, 0) + +DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES, + "selsched-max-sched-times", + "Maximum number of times that an insn could be scheduled", + 2, 0, 0) + +DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME, + "selsched-insns-to-rename", + "Maximum number of instructions in the ready list that are considered eligible for renaming", + 2, 0, 0) + +DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST, + "sched-mem-true-dep-cost", + "Minimal distance between possibly conflicting store and load", + 1, 0, 0) + +DEFPARAM(PARAM_MAX_LAST_VALUE_RTL, + "max-last-value-rtl", + "The maximum number of RTL nodes that can be recorded as combiner's last value", + 10000, 0, 0) + +/* INTEGER_CST nodes are shared for values [{-1,0} .. N) for + {signed,unsigned} integral types. This determines N. + Experimentation shows 256 to be a good value. */ +DEFPARAM (PARAM_INTEGER_SHARE_LIMIT, + "integer-share-limit", + "The upper bound for sharing integer constants", + 256, 2, 2) + +/* Incremental SSA updates for virtual operands may be very slow if + there is a large number of mappings to process. In those cases, it + is faster to rewrite the virtual symbols from scratch as if they + had been recently introduced. This heuristic cannot be applied to + SSA mappings for real SSA names, only symbols kept in FUD chains. + + PARAM_MIN_VIRTUAL_MAPPINGS specifies the minimum number of virtual + mappings that should be registered to trigger the heuristic. + + PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO specifies the ratio between + mappings and symbols. If the number of virtual mappings is + PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO bigger than the number of + virtual symbols to be updated, then the updater switches to a full + update for those symbols. */ +DEFPARAM (PARAM_MIN_VIRTUAL_MAPPINGS, + "min-virtual-mappings", + "Minimum number of virtual mappings to consider switching to full virtual renames", + 100, 0, 0) + +DEFPARAM (PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO, + "virtual-mappings-ratio", + "Ratio between virtual mappings and virtual symbols to do full virtual renames", + 3, 0, 0) + +DEFPARAM (PARAM_SSP_BUFFER_SIZE, + "ssp-buffer-size", + "The lower bound for a buffer to be considered for stack smashing protection", + 8, 1, 0) + +/* When we thread through a block we have to make copies of the + statements within the block. Clearly for large blocks the code + duplication is bad. + + PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS specifies the maximum number + of statements and PHI nodes allowed in a block which is going to + be duplicated for thread jumping purposes. + + Some simple analysis showed that more than 99% of the jump + threading opportunities are for blocks with less than 15 + statements. So we can get the benefits of jump threading + without excessive code bloat for pathological cases with the + throttle set at 15 statements. */ +DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS, + "max-jump-thread-duplication-stmts", + "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps", + 15, 0, 0) + +/* This is the maximum number of fields a variable may have before the pointer analysis machinery + will stop trying to treat it in a field-sensitive manner. + There are programs out there with thousands of fields per structure, and handling them + field-sensitively is not worth the cost. */ +DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE, + "max-fields-for-field-sensitive", + "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable", + 0, 0, 0) + +DEFPARAM(PARAM_MAX_SCHED_READY_INSNS, + "max-sched-ready-insns", + "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass", + 100, 0, 0) + +/* This is the maximum number of active local stores RTL DSE will consider. */ +DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES, + "max-dse-active-local-stores", + "Maximum number of active local stores in RTL dead store elimination", + 5000, 0, 0) + +/* Prefetching and cache-optimizations related parameters. Default values are + usually set by machine description. */ + +/* The number of insns executed before prefetch is completed. */ + +DEFPARAM (PARAM_PREFETCH_LATENCY, + "prefetch-latency", + "The number of insns executed before prefetch is completed", + 200, 0, 0) + +/* The number of prefetches that can run at the same time. */ + +DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES, + "simultaneous-prefetches", + "The number of prefetches that can run at the same time", + 3, 0, 0) + +/* The size of L1 cache in kB. */ + +DEFPARAM (PARAM_L1_CACHE_SIZE, + "l1-cache-size", + "The size of L1 cache", + 64, 0, 0) + +/* The size of L1 cache line in bytes. */ + +DEFPARAM (PARAM_L1_CACHE_LINE_SIZE, + "l1-cache-line-size", + "The size of L1 cache line", + 32, 0, 0) + +/* The size of L2 cache in kB. */ + +DEFPARAM (PARAM_L2_CACHE_SIZE, + "l2-cache-size", + "The size of L2 cache", + 512, 0, 0) + +/* Whether we should use canonical types rather than deep "structural" + type checking. Setting this value to 1 (the default) improves + compilation performance in the C++ and Objective-C++ front end; + this value should only be set to zero to work around bugs in the + canonical type system by disabling it. */ + +DEFPARAM (PARAM_USE_CANONICAL_TYPES, + "use-canonical-types", + "Whether to use canonical types", + 1, 0, 1) + +DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH, + "max-partial-antic-length", + "Maximum length of partial antic set when performing tree pre optimization", + 100, 0, 0) + +/* The following is used as a stop-gap limit for cases where really huge + SCCs blow up memory and compile-time use too much. If we hit this limit, + SCCVN and such FRE and PRE will be not done at all for the current + function. */ + +DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE, + "sccvn-max-scc-size", + "Maximum size of a SCC before SCCVN stops processing a function", + 10000, 10, 0) + +DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM, + "ira-max-loops-num", + "Max loops number for regional RA", + 100, 0, 0) + +DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE, + "ira-max-conflict-table-size", + "Max size of conflict table in MB", + 1000, 0, 0) + +DEFPARAM (PARAM_IRA_LOOP_RESERVED_REGS, + "ira-loop-reserved-regs", + "The number of registers in each class kept unused by loop invariant motion", + 2, 0, 0) + +/* Switch initialization conversion will refuse to create arrays that are + bigger than this parameter times the number of switch branches. */ + +DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO, + "switch-conversion-max-branch-ratio", + "The maximum ratio between array size and switch branches for " + "a switch conversion to take place", + 8, 1, 0) + +/* Size of tiles when doing loop blocking. */ + +DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE, + "loop-block-tile-size", + "size of tiles for loop blocking", + 51, 0, 0) + +/* Maximal number of parameters that we allow in a SCoP. */ + +DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS, + "graphite-max-nb-scop-params", + "maximum number of parameters in a SCoP", + 10, 0, 0) + +/* Maximal number of basic blocks in the functions analyzed by Graphite. */ + +DEFPARAM (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION, + "graphite-max-bbs-per-function", + "maximum number of basic blocks per function to be analyzed by Graphite", + 100, 0, 0) + +/* Avoid doing loop invariant motion on very large loops. */ + +DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP, + "loop-invariant-max-bbs-in-loop", + "Max basic blocks number in loop for loop invariant motion", + 10000, 0, 0) + +/* Promote indirect call to conditional direct call only + when the percentage of the target count over the total + indirect call count is no smaller than the threshold. */ +DEFPARAM (PARAM_ICALL_PROMOTE_PERCENT_THRESHOLD, + "icall-promote-target-percent-threshold", + "percentage threshold for direct call promotion" + " of a callee target", + 33, 0, 100) + +DEFPARAM (PARAM_ICALL_PROMOTE_COUNT_THRESHOLD, + "icall-promote-target_count-threshold", + "call count threshold for direct call promotion" + " of a callee target", + 1, 0, 0) + +/* 0: do not always inline icall target: + other value: always inline icall target when call count + exceeds this value. +*/ +DEFPARAM (PARAM_ALWAYS_INLINE_ICALL_TARGET, + "always-inline-icall-target", + "force inline indirect call target when promoted", + 0, 0, 0) + +/* Force the compiler to be in LIPO mode even there is no + profile data available. -fripa is also needed. */ +DEFPARAM (PARAM_FORCE_LIPO_MODE, + "force-lipo", + "force LIPO compilation mode", + 0, 0, 1) + +/* Limit max module group size in LIPO mode. When the value + is set to 0 (which is the default), there is no limit. */ +DEFPARAM (PARAM_MAX_LIPO_GROUP, + "max-lipo-group", + "maximum module group size.", + 0, 0, 10000) + +/* In LIPO mode, stop processing any further auxiliary modules + if current memory consumption exceeds this limit (in kb). */ +DEFPARAM (PARAM_MAX_LIPO_MEMORY, + "max-lipo-mem", + "don't import aux files if memory consumption exceeds this value", + 2400000, 0, 0) + +DEFPARAM (PARAM_PROFILE_GENERATE_SAMPLING_RATE, + "profile-generate-sampling-rate", + "sampling rate with -fprofile-generate-sampling", + 100, 0, 2000000000) + +/* Used for debugging purpose. Tell the compiler to find + the gcda file in the current directory. */ +DEFPARAM (PARAM_GCOV_DEBUG, + "gcov-debug", + "Looking for gcda file in current dir.", + 1, 0, 1) + +DEFPARAM (PARAM_REUSEDIST_MEAN_DIST_LARGE_THRESH, + "reusedist-mean-dist-large-thresh", + "Generate NTA stringops only if reusedist at least this size", + 10000000, 0, 0) + +DEFPARAM (PARAM_REUSEDIST_MEAN_DIST_SMALL_THRESH, + "reusedist-mean-dist-small-thresh", + "Force temporal stringops if reusedist at most this size", + 100000, 0, 0) + +DEFPARAM (PARAM_REUSEDIST_CALL_COUNT_THRESH, + "reusedist-call-count-thresh", + "Generate NTA stringops only if call count at least this large", + 0, 0, 0) + +DEFPARAM (PARAM_REUSEDIST_MEMCPY_SIZE_THRESH, + "reusedist-memcpy-size-thresh", + "Generate memcpy-nta only if size at least this large", + 4096, 0, 0) + +DEFPARAM (PARAM_REUSEDIST_MEMSET_SIZE_THRESH, + "reusedist-memset-size-thresh", + "Generate NTA memset only if size at least this large", + 122880, 0, 0) + +/* Avoid SLP vectorization of large basic blocks. */ +DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB, + "slp-max-insns-in-bb", + "Maximum number of instructions in basic block to be considered for SLP vectorization", + 1000, 0, 0) + +DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO, + "min-insn-to-prefetch-ratio", + "Min. ratio of insns to prefetches to enable prefetching for " + "a loop with an unknown trip count", + 10, 0, 0) + +DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO, + "prefetch-min-insn-to-mem-ratio", + "Min. ratio of insns to mem ops to enable prefetching in a loop", + 3, 0, 0) + +/* Set maximum hash table size for var tracking. */ + +DEFPARAM (PARAM_MAX_VARTRACK_SIZE, + "max-vartrack-size", + "Max. size of var tracking hash tables", + 50000000, 0, 0) + +/* Set minimum insn uid for non-debug insns. */ + +DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID, + "min-nondebug-insn-uid", + "The minimum UID to be used for a nondebug insn", + 0, 1, 0) + +DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR, + "ipa-sra-ptr-growth-factor", + "Maximum allowed growth of size of new parameters ipa-sra replaces " + "a pointer to an aggregate with", + 2, 0, 0) + +DEFPARAM (PARAM_DEVIRT_TYPE_LIST_SIZE, + "devirt-type-list-size", + "Maximum size of a type list associated with each parameter for " + "devirtualization", + 8, 0, 0) + +/* WHOPR partitioning configuration. */ + +DEFPARAM (PARAM_LTO_PARTITIONS, + "lto-partitions", + "Number of paritions program should be split to", + 32, 0, 0) + +DEFPARAM (MIN_PARTITION_SIZE, + "lto-min-partition", + "Size of minimal paritition for WHOPR (in estimated instructions)", + 1000, 0, 0) + +DEFPARAM (PARAM_MIN_MCF_CANCEL_ITERS, + "min-mcf-cancel-iters", + "the minimum number of iterations of negative cycle cancellation " + "in MCF", + 10, 1, 0) + +/* Diagnostic parameters. */ + +DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP, + "cxx-max-namespaces-for-diagnostic-help", + "Maximum number of namespaces to search for alternatives when " + "name lookup fails", + 1000, 0, 0) + +DEFPARAM (PARAM_NUMBER_OF_MVERSN_CLONES, + "num-mversn-clones", + "maximum number of functions to be cloned while doing " + "multiversioning", + 10, 0, 1000) + +DEFPARAM (PARAM_MVERSN_CLONE_CGRAPH_DEPTH, + "mversn-clone-depth", + "maximum length of the call graph path to be cloned " + "while doing multiversioning", + 2, 0, 5) + +/* Only output those call graph edges in .gnu.callgraph.text sections + whose count is greater than this value. */ +DEFPARAM (PARAM_NOTE_CGRAPH_SECTION_EDGE_THRESHOLD, + "note-cgraph-section-edge-threshold", + "minimum call graph edge count for inclusion in " + ".gnu.callgraph.text section", + 0, 0, 0) + +DEFPARAM (PARAM_PMU_PROFILE_N_ADDRESS, + "pmu_profile_n_addresses", + "While doing PMU profiling symbolize this many top addresses.", + 50, 1, 10000) + +DEFPARAM (PARAM_MAX_FUNCTION_SIZE_FOR_AUTO_CLONING, + "autoclone-function-size-limit", + "Do not auto clone functions beyond this size.", + 450, 0, 100000) + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/params.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/params.h new file mode 100644 index 0000000..e36a5ea --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/params.h @@ -0,0 +1,209 @@ +/* params.h - Run-time parameters. + Copyright (C) 2001, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Written by Mark Mitchell <mark@codesourcery.com>. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +/* This module provides a means for setting integral parameters + dynamically. Instead of encoding magic numbers in various places, + use this module to organize all the magic numbers in a single + place. The values of the parameters can be set on the + command-line, thereby providing a way to control the amount of + effort spent on particular optimization passes, or otherwise tune + the behavior of the compiler. + + Since their values can be set on the command-line, these parameters + should not be used for non-dynamic memory allocation. */ + +#ifndef GCC_PARAMS_H +#define GCC_PARAMS_H + +/* No parameter shall have this value. */ + +#define INVALID_PARAM_VAL (-1) + +/* The information associated with each parameter. */ + +typedef struct param_info +{ + /* The name used with the `--param <name>=<value>' switch to set this + value. */ + const char *const option; + + /* The default value. */ + int default_value; + + /* Minimum acceptable value. */ + int min_value; + + /* Maximum acceptable value, if greater than minimum */ + int max_value; + + /* A short description of the option. */ + const char *const help; +} param_info; + +/* An array containing the compiler parameters and their current + values. */ + +extern param_info *compiler_params; + +/* Returns the number of entries in the table, for the use by plugins. */ +extern size_t get_num_compiler_params (void); + +/* Add the N PARAMS to the current list of compiler parameters. */ + +extern void add_params (const param_info params[], size_t n); + +/* Set the VALUE associated with the parameter given by NAME in the + table PARAMS using PARAMS_SET to indicate which have been + explicitly set. */ + +extern void set_param_value (const char *name, int value, + int *params, int *params_set); + + +/* The parameters in use by language-independent code. */ + +typedef enum compiler_param +{ +#define DEFPARAM(enumerator, option, msgid, default, min, max) \ + enumerator, +#include "params.def" +#undef DEFPARAM + LAST_PARAM +} compiler_param; + +/* The value of the parameter given by ENUM. Not an lvalue. */ +#define PARAM_VALUE(ENUM) \ + ((int) global_options.x_param_values[(int) ENUM]) + +/* Set the value of the parameter given by NUM to VALUE, implicitly, + if it has not been set explicitly by the user, in the table PARAMS + using PARAMS_SET to indicate which have been explicitly set. */ + +extern void maybe_set_param_value (compiler_param num, int value, + int *params, int *params_set); + +/* Set the default value of a parameter given by NUM to VALUE, before + option processing. */ + +extern void set_default_param_value (compiler_param num, int value); + +/* Note that all parameters have been added and all default values + set. */ +extern void finish_params (void); + +/* Return the default value of parameter NUM. */ + +extern int default_param_value (compiler_param num); + +/* Initialize an array PARAMS with default values of the + parameters. */ +extern void init_param_values (int *params); + +/* Macros for the various parameters. */ +#define STRUCT_REORG_COLD_STRUCT_RATIO \ + PARAM_VALUE (PARAM_STRUCT_REORG_COLD_STRUCT_RATIO) +#define MAX_INLINE_INSNS_SINGLE \ + PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SINGLE) +#define MAX_INLINE_INSNS \ + PARAM_VALUE (PARAM_MAX_INLINE_INSNS) +#define MAX_INLINE_SLOPE \ + PARAM_VALUE (PARAM_MAX_INLINE_SLOPE) +#define MIN_INLINE_INSNS \ + PARAM_VALUE (PARAM_MIN_INLINE_INSNS) +#define MAX_INLINE_INSNS_AUTO \ + PARAM_VALUE (PARAM_MAX_INLINE_INSNS_AUTO) +#define MAX_VARIABLE_EXPANSIONS \ + PARAM_VALUE (PARAM_MAX_VARIABLE_EXPANSIONS) +#define MIN_VECT_LOOP_BOUND \ + PARAM_VALUE (PARAM_MIN_VECT_LOOP_BOUND) +#define MAX_DELAY_SLOT_INSN_SEARCH \ + PARAM_VALUE (PARAM_MAX_DELAY_SLOT_INSN_SEARCH) +#define MAX_DELAY_SLOT_LIVE_SEARCH \ + PARAM_VALUE (PARAM_MAX_DELAY_SLOT_LIVE_SEARCH) +#define MAX_PENDING_LIST_LENGTH \ + PARAM_VALUE (PARAM_MAX_PENDING_LIST_LENGTH) +#define MAX_GCSE_MEMORY \ + ((size_t) PARAM_VALUE (PARAM_MAX_GCSE_MEMORY)) +#define MAX_GCSE_INSERTION_RATIO \ + ((size_t) PARAM_VALUE (PARAM_MAX_GCSE_INSERTION_RATIO)) +#define GCSE_AFTER_RELOAD_PARTIAL_FRACTION \ + PARAM_VALUE (PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION) +#define GCSE_AFTER_RELOAD_CRITICAL_FRACTION \ + PARAM_VALUE (PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION) +#define GCSE_COST_DISTANCE_RATIO \ + PARAM_VALUE (PARAM_GCSE_COST_DISTANCE_RATIO) +#define GCSE_UNRESTRICTED_COST \ + PARAM_VALUE (PARAM_GCSE_UNRESTRICTED_COST) +#define MAX_HOIST_DEPTH \ + PARAM_VALUE (PARAM_MAX_HOIST_DEPTH) +#define MAX_UNROLLED_INSNS \ + PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS) +#define MAX_SMS_LOOP_NUMBER \ + PARAM_VALUE (PARAM_MAX_SMS_LOOP_NUMBER) +#define SMS_MAX_II_FACTOR \ + PARAM_VALUE (PARAM_SMS_MAX_II_FACTOR) +#define SMS_DFA_HISTORY \ + PARAM_VALUE (PARAM_SMS_DFA_HISTORY) +#define SMS_LOOP_AVERAGE_COUNT_THRESHOLD \ + PARAM_VALUE (PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD) +#define INTEGER_SHARE_LIMIT \ + PARAM_VALUE (PARAM_INTEGER_SHARE_LIMIT) +#define MAX_LAST_VALUE_RTL \ + PARAM_VALUE (PARAM_MAX_LAST_VALUE_RTL) +#define MIN_VIRTUAL_MAPPINGS \ + PARAM_VALUE (PARAM_MIN_VIRTUAL_MAPPINGS) +#define VIRTUAL_MAPPINGS_TO_SYMS_RATIO \ + PARAM_VALUE (PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO) +#define MAX_FIELDS_FOR_FIELD_SENSITIVE \ + ((size_t) PARAM_VALUE (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE)) +#define MAX_SCHED_READY_INSNS \ + PARAM_VALUE (PARAM_MAX_SCHED_READY_INSNS) +#define PREFETCH_LATENCY \ + PARAM_VALUE (PARAM_PREFETCH_LATENCY) +#define SIMULTANEOUS_PREFETCHES \ + PARAM_VALUE (PARAM_SIMULTANEOUS_PREFETCHES) +#define L1_CACHE_SIZE \ + PARAM_VALUE (PARAM_L1_CACHE_SIZE) +#define L1_CACHE_LINE_SIZE \ + PARAM_VALUE (PARAM_L1_CACHE_LINE_SIZE) +#define L2_CACHE_SIZE \ + PARAM_VALUE (PARAM_L2_CACHE_SIZE) +#define USE_CANONICAL_TYPES \ + PARAM_VALUE (PARAM_USE_CANONICAL_TYPES) +#define IRA_MAX_LOOPS_NUM \ + PARAM_VALUE (PARAM_IRA_MAX_LOOPS_NUM) +#define IRA_MAX_CONFLICT_TABLE_SIZE \ + PARAM_VALUE (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE) +#define IRA_LOOP_RESERVED_REGS \ + PARAM_VALUE (PARAM_IRA_LOOP_RESERVED_REGS) +#define SWITCH_CONVERSION_BRANCH_RATIO \ + PARAM_VALUE (PARAM_SWITCH_CONVERSION_BRANCH_RATIO) +#define LOOP_INVARIANT_MAX_BBS_IN_LOOP \ + PARAM_VALUE (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) +#define SLP_MAX_INSNS_IN_BB \ + PARAM_VALUE (PARAM_SLP_MAX_INSNS_IN_BB) +#define MIN_INSN_TO_PREFETCH_RATIO \ + PARAM_VALUE (PARAM_MIN_INSN_TO_PREFETCH_RATIO) +#define PREFETCH_MIN_INSN_TO_MEM_RATIO \ + PARAM_VALUE (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO) +#define MIN_NONDEBUG_INSN_UID \ + PARAM_VALUE (PARAM_MIN_NONDEBUG_INSN_UID) +#endif /* ! GCC_PARAMS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin-api.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin-api.h new file mode 100644 index 0000000..df00393 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin-api.h @@ -0,0 +1,393 @@ +/* plugin-api.h -- External linker plugin API. */ + +/* Copyright 2009, 2010 Free Software Foundation, Inc. + Written by Cary Coutant <ccoutant@google.com>. + + This file is part of binutils. + + 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 3 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 file defines the interface for writing a linker plugin, which is + described at < http://gcc.gnu.org/wiki/whopr/driver >. */ + +#ifndef PLUGIN_API_H +#define PLUGIN_API_H + +#ifdef HAVE_STDINT_H +#include <stdint.h> +#elif defined(HAVE_INTTYPES_H) +#include <inttypes.h> +#endif +#include <sys/types.h> +#if !defined(HAVE_STDINT_H) && !defined(HAVE_INTTYPES_H) && \ + !defined(UINT64_MAX) && !defined(uint64_t) +#error can not find uint64_t type +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Status code returned by most API routines. */ + +enum ld_plugin_status +{ + LDPS_OK = 0, + LDPS_NO_SYMS, /* Attempt to get symbols that haven't been added. */ + LDPS_BAD_HANDLE, /* No claimed object associated with given handle. */ + LDPS_ERR + /* Additional Error codes TBD. */ +}; + +/* The version of the API specification. */ + +enum ld_plugin_api_version +{ + LD_PLUGIN_API_VERSION = 1 +}; + +/* The type of output file being generated by the linker. */ + +enum ld_plugin_output_file_type +{ + LDPO_REL, + LDPO_EXEC, + LDPO_DYN +}; + +/* An input file managed by the plugin library. */ + +struct ld_plugin_input_file +{ + const char *name; + int fd; + off_t offset; + off_t filesize; + void *handle; +}; + +/* A symbol belonging to an input file managed by the plugin library. */ + +struct ld_plugin_symbol +{ + char *name; + char *version; + int def; + int visibility; + uint64_t size; + char *comdat_key; + int resolution; +}; + +/* An object's section. */ + +struct ld_plugin_section +{ + const void* handle; + unsigned int shndx; +}; + +/* Whether the symbol is a definition, reference, or common, weak or not. */ + +enum ld_plugin_symbol_kind +{ + LDPK_DEF, + LDPK_WEAKDEF, + LDPK_UNDEF, + LDPK_WEAKUNDEF, + LDPK_COMMON +}; + +/* The visibility of the symbol. */ + +enum ld_plugin_symbol_visibility +{ + LDPV_DEFAULT, + LDPV_PROTECTED, + LDPV_INTERNAL, + LDPV_HIDDEN +}; + +/* How a symbol is resolved. */ + +enum ld_plugin_symbol_resolution +{ + LDPR_UNKNOWN = 0, + + /* Symbol is still undefined at this point. */ + LDPR_UNDEF, + + /* This is the prevailing definition of the symbol, with references from + regular object code. */ + LDPR_PREVAILING_DEF, + + /* This is the prevailing definition of the symbol, with no + references from regular objects. It is only referenced from IR + code. */ + LDPR_PREVAILING_DEF_IRONLY, + + /* This definition was pre-empted by a definition in a regular + object file. */ + LDPR_PREEMPTED_REG, + + /* This definition was pre-empted by a definition in another IR file. */ + LDPR_PREEMPTED_IR, + + /* This symbol was resolved by a definition in another IR file. */ + LDPR_RESOLVED_IR, + + /* This symbol was resolved by a definition in a regular object + linked into the main executable. */ + LDPR_RESOLVED_EXEC, + + /* This symbol was resolved by a definition in a shared object. */ + LDPR_RESOLVED_DYN +}; + +/* The plugin library's "claim file" handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_claim_file_handler) ( + const struct ld_plugin_input_file *file, int *claimed); + +/* The plugin library's "all symbols read" handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_all_symbols_read_handler) (void); + +/* The plugin library's cleanup handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_cleanup_handler) (void); + +/* The linker's interface for registering the "claim file" handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_register_claim_file) (ld_plugin_claim_file_handler handler); + +/* The linker's interface for registering the "all symbols read" handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_register_all_symbols_read) ( + ld_plugin_all_symbols_read_handler handler); + +/* The linker's interface for registering the cleanup handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_register_cleanup) (ld_plugin_cleanup_handler handler); + +/* The linker's interface for adding symbols from a claimed input file. */ + +typedef +enum ld_plugin_status +(*ld_plugin_add_symbols) (void *handle, int nsyms, + const struct ld_plugin_symbol *syms); + +/* The linker's interface for getting the input file information with + an open (possibly re-opened) file descriptor. */ + +typedef +enum ld_plugin_status +(*ld_plugin_get_input_file) (const void *handle, + struct ld_plugin_input_file *file); + +typedef +enum ld_plugin_status +(*ld_plugin_get_view) (const void *handle, const void **viewp); + +/* The linker's interface for releasing the input file. */ + +typedef +enum ld_plugin_status +(*ld_plugin_release_input_file) (const void *handle); + +/* The linker's interface for retrieving symbol resolution information. */ + +typedef +enum ld_plugin_status +(*ld_plugin_get_symbols) (const void *handle, int nsyms, + struct ld_plugin_symbol *syms); + +/* The linker's interface for adding a compiled input file. */ + +typedef +enum ld_plugin_status +(*ld_plugin_add_input_file) (const char *pathname); + +/* The linker's interface for adding a library that should be searched. */ + +typedef +enum ld_plugin_status +(*ld_plugin_add_input_library) (const char *libname); + +/* The linker's interface for adding a library path that should be searched. */ + +typedef +enum ld_plugin_status +(*ld_plugin_set_extra_library_path) (const char *path); + +/* The linker's interface for issuing a warning or error message. */ + +typedef +enum ld_plugin_status +(*ld_plugin_message) (int level, const char *format, ...); + +/* The linker's interface for retrieving the number of sections in an object. + The handle is obtained in the claim_file handler. This interface should + only be invoked in the claim_file handler. This function sets *COUNT to + the number of sections in the object. */ + +typedef +enum ld_plugin_status +(*ld_plugin_get_input_section_count) (const void* handle, unsigned int *count); + +/* The linker's interface for retrieving the section type of a specific + section in an object. This interface should only be invoked in the + claim_file handler. This function sets *TYPE to an ELF SHT_xxx value. */ + +typedef +enum ld_plugin_status +(*ld_plugin_get_input_section_type) (const struct ld_plugin_section section, + unsigned int *type); + +/* The linker's interface for retrieving the name of a specific section in + an object. This interface should only be invoked in the claim_file handler. + This function sets *SECTION_NAME_PTR to a null-terminated buffer allocated + by malloc. The plugin must free *SECTION_NAME_PTR. */ + +typedef +enum ld_plugin_status +(*ld_plugin_get_input_section_name) (const struct ld_plugin_section section, + char **section_name_ptr); + +/* The linker's interface for retrieving the contents of a specific section + in an object. This interface should only be invoked in the claim_file + handler. This function sets *SECTION_CONTENTS to point to a buffer that is + valid until clam_file handler returns. It sets *LEN to the size of the + buffer. */ + +typedef +enum ld_plugin_status +(*ld_plugin_get_input_section_contents) (const struct ld_plugin_section section, + const unsigned char **section_contents, + size_t* len); + +/* The linker's interface for specifying the desired order of sections. + The sections should be specifed using the array SECTION_LIST in the + order in which they should appear in the final layout. NUM_SECTIONS + specifies the number of entries in each array. This should be invoked + in the all_symbols_read handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_update_section_order) (const struct ld_plugin_section *section_list, + unsigned int num_sections); + +/* The linker's interface for specifying that reordering of sections is + desired so that the linker can prepare for it. This should be invoked + before update_section_order, preferably in the claim_file handler. */ + +typedef +enum ld_plugin_status +(*ld_plugin_allow_section_ordering) (void); + +enum ld_plugin_level +{ + LDPL_INFO, + LDPL_WARNING, + LDPL_ERROR, + LDPL_FATAL +}; + +/* Values for the tv_tag field of the transfer vector. */ + +enum ld_plugin_tag +{ + LDPT_NULL = 0, + LDPT_API_VERSION, + LDPT_GOLD_VERSION, + LDPT_LINKER_OUTPUT, + LDPT_OPTION, + LDPT_REGISTER_CLAIM_FILE_HOOK, + LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK, + LDPT_REGISTER_CLEANUP_HOOK, + LDPT_ADD_SYMBOLS, + LDPT_GET_SYMBOLS, + LDPT_ADD_INPUT_FILE, + LDPT_MESSAGE, + LDPT_GET_INPUT_FILE, + LDPT_RELEASE_INPUT_FILE, + LDPT_ADD_INPUT_LIBRARY, + LDPT_OUTPUT_NAME, + LDPT_SET_EXTRA_LIBRARY_PATH, + LDPT_GNU_LD_VERSION, + LDPT_GET_VIEW, + LDPT_GET_INPUT_SECTION_COUNT, + LDPT_GET_INPUT_SECTION_TYPE, + LDPT_GET_INPUT_SECTION_NAME, + LDPT_GET_INPUT_SECTION_CONTENTS, + LDPT_UPDATE_SECTION_ORDER, + LDPT_ALLOW_SECTION_ORDERING +}; + +/* The plugin transfer vector. */ + +struct ld_plugin_tv +{ + enum ld_plugin_tag tv_tag; + union + { + int tv_val; + const char *tv_string; + ld_plugin_register_claim_file tv_register_claim_file; + ld_plugin_register_all_symbols_read tv_register_all_symbols_read; + ld_plugin_register_cleanup tv_register_cleanup; + ld_plugin_add_symbols tv_add_symbols; + ld_plugin_get_symbols tv_get_symbols; + ld_plugin_add_input_file tv_add_input_file; + ld_plugin_message tv_message; + ld_plugin_get_input_file tv_get_input_file; + ld_plugin_get_view tv_get_view; + ld_plugin_release_input_file tv_release_input_file; + ld_plugin_add_input_library tv_add_input_library; + ld_plugin_set_extra_library_path tv_set_extra_library_path; + ld_plugin_get_input_section_count tv_get_input_section_count; + ld_plugin_get_input_section_type tv_get_input_section_type; + ld_plugin_get_input_section_name tv_get_input_section_name; + ld_plugin_get_input_section_contents tv_get_input_section_contents; + ld_plugin_update_section_order tv_update_section_order; + ld_plugin_allow_section_ordering tv_allow_section_ordering; + } tv_u; +}; + +/* The plugin library's "onload" entry point. */ + +typedef +enum ld_plugin_status +(*ld_plugin_onload) (struct ld_plugin_tv *tv); + +#ifdef __cplusplus +} +#endif + +#endif /* !defined(PLUGIN_API_H) */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin-version.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin-version.h new file mode 100644 index 0000000..b52b195 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin-version.h @@ -0,0 +1,13 @@ +#include "configargs.h" + +static char basever[] = "4.6.x-google"; +static char datestamp[] = "20120106"; +static char devphase[] = "prerelease"; +static char revision[] = ""; + +/* FIXME plugins: We should make the version information more precise. + One way to do is to add a checksum. */ + +static struct plugin_gcc_version gcc_version = {basever, datestamp, + devphase, revision, + configuration_arguments}; diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin.def new file mode 100644 index 0000000..4a40c2c --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin.def @@ -0,0 +1,94 @@ +/* This file contains the definitions for plugin events in GCC. + Copyright (C) 2009 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/>. */ + + +/* To hook into pass manager. */ +DEFEVENT (PLUGIN_PASS_MANAGER_SETUP) + +/* After finishing parsing a type. */ +DEFEVENT (PLUGIN_FINISH_TYPE) + +/* Useful for summary processing. */ +DEFEVENT (PLUGIN_FINISH_UNIT) + +/* Allows to see low level AST in C and C++ frontends. */ +DEFEVENT (PLUGIN_PRE_GENERICIZE) + +/* Called before GCC exits. */ +DEFEVENT (PLUGIN_FINISH) + +/* Information about the plugin. */ +DEFEVENT (PLUGIN_INFO) + +/* Called at start of GCC Garbage Collection. */ +DEFEVENT (PLUGIN_GGC_START) + +/* Extend the GGC marking. */ +DEFEVENT (PLUGIN_GGC_MARKING) + +/* Called at end of GGC. */ +DEFEVENT (PLUGIN_GGC_END) + +/* Register an extra GGC root table. */ +DEFEVENT (PLUGIN_REGISTER_GGC_ROOTS) + +/* Register an extra GGC cache table. */ +DEFEVENT (PLUGIN_REGISTER_GGC_CACHES) + +/* Called during attribute registration. */ +DEFEVENT (PLUGIN_ATTRIBUTES) + +/* Called before processing a translation unit. */ +DEFEVENT (PLUGIN_START_UNIT) + +/* Called during pragma registration. */ +DEFEVENT (PLUGIN_PRAGMAS) + +/* Called before first pass from all_passes. */ +DEFEVENT (PLUGIN_ALL_PASSES_START) + +/* Called after last pass from all_passes. */ +DEFEVENT (PLUGIN_ALL_PASSES_END) + +/* Called before first ipa pass. */ +DEFEVENT (PLUGIN_ALL_IPA_PASSES_START) + +/* Called after last ipa pass. */ +DEFEVENT (PLUGIN_ALL_IPA_PASSES_END) + +/* Allows to override pass gate decision for current_pass. */ +DEFEVENT (PLUGIN_OVERRIDE_GATE) + +/* Called before executing a pass. */ +DEFEVENT (PLUGIN_PASS_EXECUTION) + +/* Called before executing subpasses of a GIMPLE_PASS in + execute_ipa_pass_list. */ +DEFEVENT (PLUGIN_EARLY_GIMPLE_PASSES_START) + +/* Called after executing subpasses of a GIMPLE_PASS in + execute_ipa_pass_list. */ +DEFEVENT (PLUGIN_EARLY_GIMPLE_PASSES_END) + +/* Called when a pass is first instantiated. */ +DEFEVENT (PLUGIN_NEW_PASS) + +/* After the hard-coded events above, plugins can dynamically allocate events + at run time. + PLUGIN_EVENT_FIRST_DYNAMIC only appears as last enum element. */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin.h new file mode 100644 index 0000000..4d2d12a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/plugin.h @@ -0,0 +1,68 @@ +/* Header file for internal GCC plugin mechanism. + Copyright (C) 2009, 2010 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/>. */ + +#ifndef PLUGIN_H +#define PLUGIN_H + +#include "gcc-plugin.h" + +struct attribute_spec; + +extern void add_new_plugin (const char *); +extern void parse_plugin_arg_opt (const char *); +extern int invoke_plugin_callbacks_full (int, void *); +extern void initialize_plugins (void); +extern bool plugins_active_p (void); +extern void dump_active_plugins (FILE *); +extern void debug_active_plugins (void); +extern void warn_if_plugins (void); +extern void plugins_internal_error_function (diagnostic_context *, + const char *, va_list *); +extern void print_plugins_versions (FILE *file, const char *indent); +extern void print_plugins_help (FILE *file, const char *indent); +extern void finalize_plugins (void); + +extern bool flag_plugin_added; + +/* Called from inside GCC. Invoke all plugin callbacks registered with + the specified event. + Return PLUGEVT_SUCCESS if at least one callback was called, + PLUGEVT_NO_CALLBACK if there was no callback. + + EVENT - the event identifier + GCC_DATA - event-specific data provided by the compiler */ + +static inline int +invoke_plugin_callbacks (int event ATTRIBUTE_UNUSED, + void *gcc_data ATTRIBUTE_UNUSED) +{ +#ifdef ENABLE_PLUGIN + /* True iff at least one plugin has been added. */ + if (flag_plugin_added) + return invoke_plugin_callbacks_full (event, gcc_data); +#endif + + return PLUGEVT_NO_CALLBACK; +} + +/* In attribs.c. */ + +extern void register_attribute (const struct attribute_spec *attr); + +#endif /* PLUGIN_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/pointer-set.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/pointer-set.h new file mode 100644 index 0000000..d6f95c0 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/pointer-set.h @@ -0,0 +1,53 @@ +/* Set operations on pointers + Copyright (C) 2004, 2007 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/>. */ + +#ifndef POINTER_SET_H +#define POINTER_SET_H + +struct pointer_set_t; +struct pointer_set_t *pointer_set_create (void); +void pointer_set_destroy (struct pointer_set_t *pset); +struct pointer_set_t *pointer_set_copy (const struct pointer_set_t *pset); + +int pointer_set_contains (const struct pointer_set_t *pset, const void *p); +int pointer_set_insert (struct pointer_set_t *pset, const void *p); +int pointer_set_delete (struct pointer_set_t *pset, const void *p); +void pointer_set_traverse (const struct pointer_set_t *, + bool (*) (const void *, void *), + void *); + +void pointer_set_intersection_complement (struct pointer_set_t *dst_pset, + const struct pointer_set_t *src_pset, + struct pointer_set_t *comp_pset); + +void pointer_set_union_inplace (struct pointer_set_t *dst_pset, + const struct pointer_set_t *src_pset); + +size_t pointer_set_cardinality (const struct pointer_set_t *pset); + +struct pointer_map_t; +struct pointer_map_t *pointer_map_create (void); +void pointer_map_destroy (struct pointer_map_t *pmap); + +void **pointer_map_contains (const struct pointer_map_t *pmap, const void *p); +void **pointer_map_insert (struct pointer_map_t *pmap, const void *p); +void pointer_map_traverse (const struct pointer_map_t *, + bool (*) (const void *, void **, void *), void *); + +#endif /* POINTER_SET_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/predict.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/predict.def new file mode 100644 index 0000000..89d0787 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/predict.def @@ -0,0 +1,122 @@ +/* Definitions for the branch prediction routines in the GNU compiler. + Copyright (C) 2001, 2003, 2004, 2007, 2008 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, you should define a macro: + + DEF_PREDICTOR (ENUM, NAME, HITRATE) + + This macro will be called once for each predictor. The ENUM will + be of type `enum predictor', and will enumerate all supported + predictors. The order of DEF_PREDICTOR calls is important, as + in the first match combining heuristics, the predictor appearing + first in this file will win. + + NAME is used in the debugging output to determine predictor type. + + HITRATE is the probability that edge predicted by predictor as taken + will be really taken (so it should be always above + REG_BR_PROB_BASE / 2). */ + + +/* A value used as final outcome of all heuristics. */ +DEF_PREDICTOR (PRED_COMBINED, "combined", PROB_ALWAYS, 0) + +/* An outcome estimated by Dempster-Shaffer theory. */ +DEF_PREDICTOR (PRED_DS_THEORY, "DS theory", PROB_ALWAYS, 0) + +/* A combined heuristics using probability determined by first + matching heuristics from this list. */ +DEF_PREDICTOR (PRED_FIRST_MATCH, "first match", PROB_ALWAYS, 0) + +/* Heuristic applying when no heuristic below applies. */ +DEF_PREDICTOR (PRED_NO_PREDICTION, "no prediction", PROB_ALWAYS, 0) + +/* Mark unconditional jump as taken. */ +DEF_PREDICTOR (PRED_UNCONDITIONAL, "unconditional jump", PROB_ALWAYS, + PRED_FLAG_FIRST_MATCH) + +/* Use number of loop iterations determined by # of iterations + analysis to set probability. We don't want to use Dempster-Shaffer + theory here, as the predictions is exact. */ +DEF_PREDICTOR (PRED_LOOP_ITERATIONS, "loop iterations", PROB_ALWAYS, + PRED_FLAG_FIRST_MATCH) + +/* Hints dropped by user via __builtin_expect feature. */ +DEF_PREDICTOR (PRED_BUILTIN_EXPECT, "__builtin_expect", PROB_VERY_LIKELY, + PRED_FLAG_FIRST_MATCH) + +/* Use number of loop iterations guessed by the contents of the loop. */ +DEF_PREDICTOR (PRED_LOOP_ITERATIONS_GUESSED, "guessed loop iterations", + PROB_ALWAYS, PRED_FLAG_FIRST_MATCH) + +/* Branch containing goto is probably not taken. */ +DEF_PREDICTOR (PRED_CONTINUE, "continue", HITRATE (50), 0) + +/* Branch to basic block containing call marked by noreturn attribute. */ +DEF_PREDICTOR (PRED_NORETURN, "noreturn call", PROB_VERY_LIKELY, + PRED_FLAG_FIRST_MATCH) + +/* Branch to basic block containing call marked by cold function attribute. */ +DEF_PREDICTOR (PRED_COLD_FUNCTION, "cold function call", PROB_VERY_LIKELY, + PRED_FLAG_FIRST_MATCH) + +/* Loopback edge is taken. */ +DEF_PREDICTOR (PRED_LOOP_BRANCH, "loop branch", HITRATE (86), + PRED_FLAG_FIRST_MATCH) + +/* Edge causing loop to terminate is probably not taken. */ +DEF_PREDICTOR (PRED_LOOP_EXIT, "loop exit", HITRATE (91), + PRED_FLAG_FIRST_MATCH) + +/* Pointers are usually not NULL. */ +DEF_PREDICTOR (PRED_POINTER, "pointer", HITRATE (85), 0) +DEF_PREDICTOR (PRED_TREE_POINTER, "pointer (on trees)", HITRATE (85), 0) + +/* NE is probable, EQ not etc... */ +DEF_PREDICTOR (PRED_OPCODE_POSITIVE, "opcode values positive", HITRATE (79), 0) +DEF_PREDICTOR (PRED_OPCODE_NONEQUAL, "opcode values nonequal", HITRATE (71), 0) +DEF_PREDICTOR (PRED_FPOPCODE, "fp_opcode", HITRATE (90), 0) +DEF_PREDICTOR (PRED_TREE_OPCODE_POSITIVE, "opcode values positive (on trees)", HITRATE (73), 0) +DEF_PREDICTOR (PRED_TREE_OPCODE_NONEQUAL, "opcode values nonequal (on trees)", HITRATE (72), 0) +DEF_PREDICTOR (PRED_TREE_FPOPCODE, "fp_opcode (on trees)", HITRATE (90), 0) + +/* Branch guarding call is probably taken. */ +DEF_PREDICTOR (PRED_CALL, "call", HITRATE (71), 0) + +/* Branch causing function to terminate is probably not taken. */ +DEF_PREDICTOR (PRED_TREE_EARLY_RETURN, "early return (on trees)", HITRATE (61), 0) + +/* Branch containing goto is probably not taken. */ +DEF_PREDICTOR (PRED_GOTO, "goto", HITRATE (70), 0) + +/* Branch ending with return constant is probably not taken. */ +DEF_PREDICTOR (PRED_CONST_RETURN, "const return", HITRATE (67), 0) + +/* Branch ending with return negative constant is probably not taken. */ +DEF_PREDICTOR (PRED_NEGATIVE_RETURN, "negative return", HITRATE (96), 0) + +/* Branch ending with return; is probably not taken */ +DEF_PREDICTOR (PRED_NULL_RETURN, "null return", HITRATE (90), 0) + +/* Branches to a mudflap bounds check are extremely unlikely. */ +DEF_PREDICTOR (PRED_MUDFLAP, "mudflap check", PROB_VERY_LIKELY, 0) + +/* Branches to compare induction variable to a loop bound is + extremely likely. */ +DEF_PREDICTOR (PRED_LOOP_IV_COMPARE, "loop iv compare", PROB_VERY_LIKELY, 0) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/predict.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/predict.h new file mode 100644 index 0000000..0d3124b --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/predict.h @@ -0,0 +1,48 @@ +/* Definitions for branch prediction routines in the GNU compiler. + Copyright (C) 2001, 2003, 2004, 2007, 2008, 2010 + 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/>. */ + +#ifndef GCC_PREDICT_H +#define GCC_PREDICT_H + +#define DEF_PREDICTOR(ENUM, NAME, HITRATE, FLAGS) ENUM, +enum br_predictor +{ +#include "predict.def" + + /* Upper bound on non-language-specific builtins. */ + END_PREDICTORS +}; +#undef DEF_PREDICTOR +enum prediction +{ + NOT_TAKEN, + TAKEN +}; + +extern void predict_insn_def (rtx, enum br_predictor, enum prediction); +extern int counts_to_freqs (void); +extern void estimate_bb_frequencies (void); +extern const char *predictor_name (enum br_predictor); +extern tree build_predict_expr (enum br_predictor, enum prediction); +extern void tree_estimate_probability (void); +extern void compute_function_frequency (void); +extern void rebuild_frequencies (void); + +#endif /* GCC_PREDICT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/prefix.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/prefix.h new file mode 100644 index 0000000..c6d9ae5 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/prefix.h @@ -0,0 +1,30 @@ +/* Provide prototypes for functions exported from prefix.c. + Copyright (C) 1999, 2003, 2007 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 Library General Public License as published by +the Free Software Foundation; either version 3 of the License, 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + + +#ifndef GCC_PREFIX_H +#define GCC_PREFIX_H + +/* Update PATH using KEY if PATH starts with PREFIX. The returned + string is always malloc-ed, and the caller is responsible for + freeing it. */ +extern char *update_path (const char *path, const char *key); +extern void set_std_prefix (const char *, int); + +#endif /* ! GCC_PREFIX_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/pretty-print.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/pretty-print.h new file mode 100644 index 0000000..3b6d18e --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/pretty-print.h @@ -0,0 +1,345 @@ +/* Various declarations for language-independent pretty-print subroutines. + Copyright (C) 2002, 2003, 2004, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net> + +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/>. */ + +#ifndef GCC_PRETTY_PRINT_H +#define GCC_PRETTY_PRINT_H + +#include "obstack.h" +#include "input.h" + +/* Maximum number of format string arguments. */ +#define PP_NL_ARGMAX 30 + +/* The type of a text to be formatted according a format specification + along with a list of things. */ +typedef struct +{ + const char *format_spec; + va_list *args_ptr; + int err_no; /* for %m */ + location_t *locus; + void **x_data; +} text_info; + +/* How often diagnostics are prefixed by their locations: + o DIAGNOSTICS_SHOW_PREFIX_NEVER: never - not yet supported; + o DIAGNOSTICS_SHOW_PREFIX_ONCE: emit only once; + o DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE: emit each time a physical + line is started. */ +typedef enum +{ + DIAGNOSTICS_SHOW_PREFIX_ONCE = 0x0, + DIAGNOSTICS_SHOW_PREFIX_NEVER = 0x1, + DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE = 0x2 +} diagnostic_prefixing_rule_t; + +/* The chunk_info data structure forms a stack of the results from the + first phase of formatting (pp_base_format) which have not yet been + output (pp_base_output_formatted_text). A stack is necessary because + the diagnostic starter may decide to generate its own output by way + of the formatter. */ +struct chunk_info +{ + /* Pointer to previous chunk on the stack. */ + struct chunk_info *prev; + + /* Array of chunks to output. Each chunk is a NUL-terminated string. + In the first phase of formatting, even-numbered chunks are + to be output verbatim, odd-numbered chunks are format specifiers. + The second phase replaces all odd-numbered chunks with formatted + text, and the third phase simply emits all the chunks in sequence + with appropriate line-wrapping. */ + const char *args[PP_NL_ARGMAX * 2]; +}; + +/* The output buffer datatype. This is best seen as an abstract datatype + whose fields should not be accessed directly by clients. */ +typedef struct +{ + /* Obstack where the text is built up. */ + struct obstack formatted_obstack; + + /* Obstack containing a chunked representation of the format + specification plus arguments. */ + struct obstack chunk_obstack; + + /* Currently active obstack: one of the above two. This is used so + that the text formatters don't need to know which phase we're in. */ + struct obstack *obstack; + + /* Stack of chunk arrays. These come from the chunk_obstack. */ + struct chunk_info *cur_chunk_array; + + /* Where to output formatted text. */ + FILE *stream; + + /* The amount of characters output so far. */ + int line_length; + + /* This must be large enough to hold any printed integer or + floating-point value. */ + char digit_buffer[128]; +} output_buffer; + +/* The type of pretty-printer flags passed to clients. */ +typedef unsigned int pp_flags; + +typedef enum +{ + pp_none, pp_before, pp_after +} pp_padding; + +/* Structure for switching in and out of verbatim mode in a convenient + manner. */ +typedef struct +{ + /* Current prefixing rule. */ + diagnostic_prefixing_rule_t rule; + + /* The ideal upper bound of number of characters per line, as suggested + by front-end. */ + int line_cutoff; +} pp_wrapping_mode_t; + +/* Maximum characters per line in automatic line wrapping mode. + Zero means don't wrap lines. */ +#define pp_line_cutoff(PP) pp_base (PP)->wrapping.line_cutoff + +/* Prefixing rule used in formatting a diagnostic message. */ +#define pp_prefixing_rule(PP) pp_base (PP)->wrapping.rule + +/* Get or set the wrapping mode as a single entity. */ +#define pp_wrapping_mode(PP) pp_base (PP)->wrapping + +/* The type of a hook that formats client-specific data onto a pretty_pinter. + A client-supplied formatter returns true if everything goes well, + otherwise it returns false. */ +typedef struct pretty_print_info pretty_printer; +typedef bool (*printer_fn) (pretty_printer *, text_info *, const char *, + int, bool, bool, bool); + +/* Client supplied function used to decode formats. */ +#define pp_format_decoder(PP) pp_base (PP)->format_decoder + +/* TRUE if a newline character needs to be added before further + formatting. */ +#define pp_needs_newline(PP) pp_base (PP)->need_newline + +/* True if PRETTY-PRINTER is in line-wrapping mode. */ +#define pp_is_wrapping_line(PP) (pp_line_cutoff (PP) > 0) + +/* The amount of whitespace to be emitted when starting a new line. */ +#define pp_indentation(PP) pp_base (PP)->indent_skip + +/* True if identifiers are translated to the locale character set on + output. */ +#define pp_translate_identifiers(PP) pp_base (PP)->translate_identifiers + +/* The data structure that contains the bare minimum required to do + proper pretty-printing. Clients may derived from this structure + and add additional fields they need. */ +struct pretty_print_info +{ + /* Where we print external representation of ENTITY. */ + output_buffer *buffer; + + /* The prefix for each new line. */ + const char *prefix; + + /* Where to put whitespace around the entity being formatted. */ + pp_padding padding; + + /* The real upper bound of number of characters per line, taking into + account the case of a very very looong prefix. */ + int maximum_length; + + /* Indentation count. */ + int indent_skip; + + /* Current wrapping mode. */ + pp_wrapping_mode_t wrapping; + + /* If non-NULL, this function formats a TEXT into the BUFFER. When called, + TEXT->format_spec points to a format code. FORMAT_DECODER should call + pp_string (and related functions) to add data to the BUFFER. + FORMAT_DECODER can read arguments from *TEXT->args_pts using VA_ARG. + If the BUFFER needs additional characters from the format string, it + should advance the TEXT->format_spec as it goes. When FORMAT_DECODER + returns, TEXT->format_spec should point to the last character processed. + */ + printer_fn format_decoder; + + /* Nonzero if current PREFIX was emitted at least once. */ + bool emitted_prefix; + + /* Nonzero means one should emit a newline before outputting anything. */ + bool need_newline; + + /* Nonzero means identifiers are translated to the locale character + set on output. */ + bool translate_identifiers; +}; + +#define pp_set_line_maximum_length(PP, L) \ + pp_base_set_line_maximum_length (pp_base (PP), L) +#define pp_set_prefix(PP, P) pp_base_set_prefix (pp_base (PP), P) +#define pp_destroy_prefix(PP) pp_base_destroy_prefix (pp_base (PP)) +#define pp_remaining_character_count_for_line(PP) \ + pp_base_remaining_character_count_for_line (pp_base (PP)) +#define pp_clear_output_area(PP) \ + pp_base_clear_output_area (pp_base (PP)) +#define pp_formatted_text(PP) pp_base_formatted_text (pp_base (PP)) +#define pp_last_position_in_text(PP) \ + pp_base_last_position_in_text (pp_base (PP)) +#define pp_emit_prefix(PP) pp_base_emit_prefix (pp_base (PP)) +#define pp_append_text(PP, B, E) \ + pp_base_append_text (pp_base (PP), B, E) +#define pp_flush(PP) pp_base_flush (pp_base (PP)) +#define pp_format(PP, TI) pp_base_format (pp_base (PP), TI) +#define pp_output_formatted_text(PP) \ + pp_base_output_formatted_text (pp_base (PP)) +#define pp_format_verbatim(PP, TI) \ + pp_base_format_verbatim (pp_base (PP), TI) + +#define pp_character(PP, C) pp_base_character (pp_base (PP), C) +#define pp_string(PP, S) pp_base_string (pp_base (PP), S) +#define pp_newline(PP) pp_base_newline (pp_base (PP)) + +#define pp_space(PP) pp_character (PP, ' ') +#define pp_left_paren(PP) pp_character (PP, '(') +#define pp_right_paren(PP) pp_character (PP, ')') +#define pp_left_bracket(PP) pp_character (PP, '[') +#define pp_right_bracket(PP) pp_character (PP, ']') +#define pp_left_brace(PP) pp_character (PP, '{') +#define pp_right_brace(PP) pp_character (PP, '}') +#define pp_semicolon(PP) pp_character (PP, ';') +#define pp_comma(PP) pp_string (PP, ", ") +#define pp_dot(PP) pp_character (PP, '.') +#define pp_colon(PP) pp_character (PP, ':') +#define pp_colon_colon(PP) pp_string (PP, "::") +#define pp_arrow(PP) pp_string (PP, "->") +#define pp_equal(PP) pp_character (PP, '=') +#define pp_question(PP) pp_character (PP, '?') +#define pp_bar(PP) pp_character (PP, '|') +#define pp_carret(PP) pp_character (PP, '^') +#define pp_ampersand(PP) pp_character (PP, '&') +#define pp_less(PP) pp_character (PP, '<') +#define pp_greater(PP) pp_character (PP, '>') +#define pp_plus(PP) pp_character (PP, '+') +#define pp_minus(PP) pp_character (PP, '-') +#define pp_star(PP) pp_character (PP, '*') +#define pp_slash(PP) pp_character (PP, '/') +#define pp_modulo(PP) pp_character (PP, '%') +#define pp_exclamation(PP) pp_character (PP, '!') +#define pp_complement(PP) pp_character (PP, '~') +#define pp_quote(PP) pp_character (PP, '\'') +#define pp_backquote(PP) pp_character (PP, '`') +#define pp_doublequote(PP) pp_character (PP, '"') +#define pp_newline_and_indent(PP, N) \ + do { \ + pp_indentation (PP) += N; \ + pp_newline (PP); \ + pp_base_indent (pp_base (PP)); \ + pp_needs_newline (PP) = false; \ + } while (0) +#define pp_maybe_newline_and_indent(PP, N) \ + if (pp_needs_newline (PP)) pp_newline_and_indent (PP, N) +#define pp_maybe_space(PP) pp_base_maybe_space (pp_base (PP)) +#define pp_separate_with(PP, C) \ + do { \ + pp_character (PP, C); \ + pp_space (PP); \ + } while (0) +#define pp_scalar(PP, FORMAT, SCALAR) \ + do \ + { \ + sprintf (pp_buffer (PP)->digit_buffer, FORMAT, SCALAR); \ + pp_string (PP, pp_buffer (PP)->digit_buffer); \ + } \ + while (0) +#define pp_decimal_int(PP, I) pp_scalar (PP, "%d", I) +#define pp_wide_integer(PP, I) \ + pp_scalar (PP, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) I) +#define pp_widest_integer(PP, I) \ + pp_scalar (PP, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT) I) +#define pp_pointer(PP, P) pp_scalar (PP, "%p", P) + +#define pp_identifier(PP, ID) pp_string (PP, (pp_translate_identifiers (PP) \ + ? identifier_to_locale (ID) \ + : (ID))) + + +#define pp_buffer(PP) pp_base (PP)->buffer +/* Clients that directly derive from pretty_printer need to override + this macro to return a pointer to the base pretty_printer structure. */ +#define pp_base(PP) (PP) + +extern void pp_construct (pretty_printer *, const char *, int); +extern void pp_base_set_line_maximum_length (pretty_printer *, int); +extern void pp_base_set_prefix (pretty_printer *, const char *); +extern void pp_base_destroy_prefix (pretty_printer *); +extern int pp_base_remaining_character_count_for_line (pretty_printer *); +extern void pp_base_clear_output_area (pretty_printer *); +extern const char *pp_base_formatted_text (pretty_printer *); +extern const char *pp_base_last_position_in_text (const pretty_printer *); +extern void pp_base_emit_prefix (pretty_printer *); +extern void pp_base_append_text (pretty_printer *, const char *, const char *); + +/* This header may be included before diagnostics-core.h, hence the duplicate + definitions to allow for GCC-specific formats. */ +#if GCC_VERSION >= 3005 +#define ATTRIBUTE_GCC_PPDIAG(m, n) __attribute__ ((__format__ (__gcc_diag__, m ,n))) ATTRIBUTE_NONNULL(m) +#else +#define ATTRIBUTE_GCC_PPDIAG(m, n) ATTRIBUTE_NONNULL(m) +#endif +extern void pp_printf (pretty_printer *, const char *, ...) + ATTRIBUTE_GCC_PPDIAG(2,3); + +extern void pp_verbatim (pretty_printer *, const char *, ...) + ATTRIBUTE_GCC_PPDIAG(2,3); +extern void pp_base_flush (pretty_printer *); +extern void pp_base_format (pretty_printer *, text_info *); +extern void pp_base_output_formatted_text (pretty_printer *); +extern void pp_base_format_verbatim (pretty_printer *, text_info *); + +extern void pp_base_indent (pretty_printer *); +extern void pp_base_newline (pretty_printer *); +extern void pp_base_character (pretty_printer *, int); +extern void pp_base_string (pretty_printer *, const char *); +extern void pp_write_text_to_stream (pretty_printer *pp); +extern void pp_base_maybe_space (pretty_printer *); + +/* Switch into verbatim mode and return the old mode. */ +static inline pp_wrapping_mode_t +pp_set_verbatim_wrapping_ (pretty_printer *pp) +{ + pp_wrapping_mode_t oldmode = pp_wrapping_mode (pp); + pp_line_cutoff (pp) = 0; + pp_prefixing_rule (pp) = DIAGNOSTICS_SHOW_PREFIX_NEVER; + return oldmode; +} +#define pp_set_verbatim_wrapping(PP) pp_set_verbatim_wrapping_ (pp_base (PP)) + +extern const char *identifier_to_locale (const char *); +extern void *(*identifier_to_locale_alloc) (size_t); +extern void (*identifier_to_locale_free) (void *); + +#endif /* GCC_PRETTY_PRINT_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/real.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/real.h new file mode 100644 index 0000000..d16dc24 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/real.h @@ -0,0 +1,494 @@ +/* Definitions of floating-point access for GNU compiler. + Copyright (C) 1989, 1991, 1994, 1996, 1997, 1998, 1999, + 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_REAL_H +#define GCC_REAL_H + +#include "machmode.h" + +/* An expanded form of the represented number. */ + +/* Enumerate the special cases of numbers that we encounter. */ +enum real_value_class { + rvc_zero, + rvc_normal, + rvc_inf, + rvc_nan +}; + +#define SIGNIFICAND_BITS (128 + HOST_BITS_PER_LONG) +#define EXP_BITS (32 - 6) +#define MAX_EXP ((1 << (EXP_BITS - 1)) - 1) +#define SIGSZ (SIGNIFICAND_BITS / HOST_BITS_PER_LONG) +#define SIG_MSB ((unsigned long)1 << (HOST_BITS_PER_LONG - 1)) + +struct GTY(()) real_value { + /* Use the same underlying type for all bit-fields, so as to make + sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will + be miscomputed. */ + unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2; + unsigned int decimal : 1; + unsigned int sign : 1; + unsigned int signalling : 1; + unsigned int canonical : 1; + unsigned int uexp : EXP_BITS; + unsigned long sig[SIGSZ]; +}; + +#define REAL_EXP(REAL) \ + ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \ + - (1 << (EXP_BITS - 1))) +#define SET_REAL_EXP(REAL, EXP) \ + ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1))) + +/* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it + needs to be a macro. We do need to continue to have a structure tag + so that other headers can forward declare it. */ +#define REAL_VALUE_TYPE struct real_value + +/* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in + consecutive "w" slots. Moreover, we've got to compute the number of "w" + slots at preprocessor time, which means we can't use sizeof. Guess. */ + +#define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32) +#define REAL_WIDTH \ + (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \ + + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */ + +/* Verify the guess. */ +extern char test_real_width + [sizeof(REAL_VALUE_TYPE) <= REAL_WIDTH*sizeof(HOST_WIDE_INT) ? 1 : -1]; + +/* Calculate the format for CONST_DOUBLE. We need as many slots as + are necessary to overlay a REAL_VALUE_TYPE on them. This could be + as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE). + + A number of places assume that there are always at least two 'w' + slots in a CONST_DOUBLE, so we provide them even if one would suffice. */ + +#if REAL_WIDTH == 1 +# define CONST_DOUBLE_FORMAT "ww" +#else +# if REAL_WIDTH == 2 +# define CONST_DOUBLE_FORMAT "ww" +# else +# if REAL_WIDTH == 3 +# define CONST_DOUBLE_FORMAT "www" +# else +# if REAL_WIDTH == 4 +# define CONST_DOUBLE_FORMAT "wwww" +# else +# if REAL_WIDTH == 5 +# define CONST_DOUBLE_FORMAT "wwwww" +# else +# if REAL_WIDTH == 6 +# define CONST_DOUBLE_FORMAT "wwwwww" +# else + #error "REAL_WIDTH > 6 not supported" +# endif +# endif +# endif +# endif +# endif +#endif + + +/* Describes the properties of the specific target format in use. */ +struct real_format +{ + /* Move to and from the target bytes. */ + void (*encode) (const struct real_format *, long *, + const REAL_VALUE_TYPE *); + void (*decode) (const struct real_format *, REAL_VALUE_TYPE *, + const long *); + + /* The radix of the exponent and digits of the significand. */ + int b; + + /* Size of the significand in digits of radix B. */ + int p; + + /* Size of the significant of a NaN, in digits of radix B. */ + int pnan; + + /* The minimum negative integer, x, such that b**(x-1) is normalized. */ + int emin; + + /* The maximum integer, x, such that b**(x-1) is representable. */ + int emax; + + /* The bit position of the sign bit, for determining whether a value + is positive/negative, or -1 for a complex encoding. */ + int signbit_ro; + + /* The bit position of the sign bit, for changing the sign of a number, + or -1 for a complex encoding. */ + int signbit_rw; + + /* Default rounding mode for operations on this format. */ + bool round_towards_zero; + bool has_sign_dependent_rounding; + + /* Properties of the format. */ + bool has_nans; + bool has_inf; + bool has_denorm; + bool has_signed_zero; + bool qnan_msb_set; + bool canonical_nan_lsbs_set; +}; + + +/* The target format used for each floating point mode. + Float modes are followed by decimal float modes, with entries for + float modes indexed by (MODE - first float mode), and entries for + decimal float modes indexed by (MODE - first decimal float mode) + + the number of float modes. */ +extern const struct real_format * + real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 + + MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1]; + +#define REAL_MODE_FORMAT(MODE) \ + (real_format_for_mode[DECIMAL_FLOAT_MODE_P (MODE) \ + ? (((MODE) - MIN_MODE_DECIMAL_FLOAT) \ + + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) \ + : ((MODE) - MIN_MODE_FLOAT)]) + +#define FLOAT_MODE_FORMAT(MODE) \ + (REAL_MODE_FORMAT (SCALAR_FLOAT_MODE_P (MODE)? (MODE) \ + : GET_MODE_INNER (MODE))) + +/* The following macro determines whether the floating point format is + composite, i.e. may contain non-consecutive mantissa bits, in which + case compile-time FP overflow may not model run-time overflow. */ +#define MODE_COMPOSITE_P(MODE) \ + (FLOAT_MODE_P (MODE) \ + && FLOAT_MODE_FORMAT (MODE)->pnan < FLOAT_MODE_FORMAT (MODE)->p) + +/* Accessor macros for format properties. */ +#define MODE_HAS_NANS(MODE) \ + (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans) +#define MODE_HAS_INFINITIES(MODE) \ + (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf) +#define MODE_HAS_SIGNED_ZEROS(MODE) \ + (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero) +#define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \ + (FLOAT_MODE_P (MODE) \ + && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding) + +/* True if the given mode has a NaN representation and the treatment of + NaN operands is important. Certain optimizations, such as folding + x * 0 into 0, are not correct for NaN operands, and are normally + disabled for modes with NaNs. The user can ask for them to be + done anyway using the -funsafe-math-optimizations switch. */ +#define HONOR_NANS(MODE) \ + (MODE_HAS_NANS (MODE) && !flag_finite_math_only) + +/* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */ +#define HONOR_SNANS(MODE) (flag_signaling_nans && HONOR_NANS (MODE)) + +/* As for HONOR_NANS, but true if the mode can represent infinity and + the treatment of infinite values is important. */ +#define HONOR_INFINITIES(MODE) \ + (MODE_HAS_INFINITIES (MODE) && !flag_finite_math_only) + +/* Like HONOR_NANS, but true if the given mode distinguishes between + positive and negative zero, and the sign of zero is important. */ +#define HONOR_SIGNED_ZEROS(MODE) \ + (MODE_HAS_SIGNED_ZEROS (MODE) && flag_signed_zeros) + +/* Like HONOR_NANS, but true if given mode supports sign-dependent rounding, + and the rounding mode is important. */ +#define HONOR_SIGN_DEPENDENT_ROUNDING(MODE) \ + (MODE_HAS_SIGN_DEPENDENT_ROUNDING (MODE) && flag_rounding_math) + +/* Declare functions in real.c. */ + +/* Binary or unary arithmetic on tree_code. */ +extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *, + const REAL_VALUE_TYPE *); + +/* Compare reals by tree_code. */ +extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); + +/* Determine whether a floating-point value X is infinite. */ +extern bool real_isinf (const REAL_VALUE_TYPE *); + +/* Determine whether a floating-point value X is a NaN. */ +extern bool real_isnan (const REAL_VALUE_TYPE *); + +/* Determine whether a floating-point value X is finite. */ +extern bool real_isfinite (const REAL_VALUE_TYPE *); + +/* Determine whether a floating-point value X is negative. */ +extern bool real_isneg (const REAL_VALUE_TYPE *); + +/* Determine whether a floating-point value X is minus zero. */ +extern bool real_isnegzero (const REAL_VALUE_TYPE *); + +/* Compare two floating-point objects for bitwise identity. */ +extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); + +/* Extend or truncate to a new mode. */ +extern void real_convert (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *); + +/* Return true if truncating to NEW is exact. */ +extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *); + +/* Render R as a decimal floating point constant. */ +extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t, + size_t, int); + +/* Render R as a decimal floating point constant, rounded so as to be + parsed back to the same value when interpreted in mode MODE. */ +extern void real_to_decimal_for_mode (char *, const REAL_VALUE_TYPE *, size_t, + size_t, int, enum machine_mode); + +/* Render R as a hexadecimal floating point constant. */ +extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *, + size_t, size_t, int); + +/* Render R as an integer. */ +extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *); +extern void real_to_integer2 (HOST_WIDE_INT *, HOST_WIDE_INT *, + const REAL_VALUE_TYPE *); + +/* Initialize R from a decimal or hexadecimal string. Return -1 if + the value underflows, +1 if overflows, and 0 otherwise. */ +extern int real_from_string (REAL_VALUE_TYPE *, const char *); +/* Wrapper to allow different internal representation for decimal floats. */ +extern void real_from_string3 (REAL_VALUE_TYPE *, const char *, enum machine_mode); + +/* Initialize R from an integer pair HIGH/LOW. */ +extern void real_from_integer (REAL_VALUE_TYPE *, enum machine_mode, + unsigned HOST_WIDE_INT, HOST_WIDE_INT, int); + +extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *, + const struct real_format *); +extern long real_to_target (long *, const REAL_VALUE_TYPE *, enum machine_mode); + +extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *, + const struct real_format *); +extern void real_from_target (REAL_VALUE_TYPE *, const long *, + enum machine_mode); + +extern void real_inf (REAL_VALUE_TYPE *); + +extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, enum machine_mode); + +extern void real_maxval (REAL_VALUE_TYPE *, int, enum machine_mode); + +extern void real_2expN (REAL_VALUE_TYPE *, int, enum machine_mode); + +extern unsigned int real_hash (const REAL_VALUE_TYPE *); + + +/* Target formats defined in real.c. */ +extern const struct real_format ieee_single_format; +extern const struct real_format mips_single_format; +extern const struct real_format motorola_single_format; +extern const struct real_format spu_single_format; +extern const struct real_format ieee_double_format; +extern const struct real_format mips_double_format; +extern const struct real_format motorola_double_format; +extern const struct real_format ieee_extended_motorola_format; +extern const struct real_format ieee_extended_intel_96_format; +extern const struct real_format ieee_extended_intel_96_round_53_format; +extern const struct real_format ieee_extended_intel_128_format; +extern const struct real_format ibm_extended_format; +extern const struct real_format mips_extended_format; +extern const struct real_format ieee_quad_format; +extern const struct real_format mips_quad_format; +extern const struct real_format vax_f_format; +extern const struct real_format vax_d_format; +extern const struct real_format vax_g_format; +extern const struct real_format real_internal_format; +extern const struct real_format decimal_single_format; +extern const struct real_format decimal_double_format; +extern const struct real_format decimal_quad_format; +extern const struct real_format ieee_half_format; +extern const struct real_format arm_half_format; + + +/* ====================================================================== */ +/* Crap. */ + +#define REAL_ARITHMETIC(value, code, d1, d2) \ + real_arithmetic (&(value), code, &(d1), &(d2)) + +#define REAL_VALUES_IDENTICAL(x, y) real_identical (&(x), &(y)) +#define REAL_VALUES_EQUAL(x, y) real_compare (EQ_EXPR, &(x), &(y)) +#define REAL_VALUES_LESS(x, y) real_compare (LT_EXPR, &(x), &(y)) + +/* Determine whether a floating-point value X is infinite. */ +#define REAL_VALUE_ISINF(x) real_isinf (&(x)) + +/* Determine whether a floating-point value X is a NaN. */ +#define REAL_VALUE_ISNAN(x) real_isnan (&(x)) + +/* Determine whether a floating-point value X is negative. */ +#define REAL_VALUE_NEGATIVE(x) real_isneg (&(x)) + +/* Determine whether a floating-point value X is minus zero. */ +#define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x)) + +/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ +#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ + real_to_target (OUT, &(IN), \ + mode_for_size (LONG_DOUBLE_TYPE_SIZE, MODE_FLOAT, 0)) + +#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \ + real_to_target (OUT, &(IN), mode_for_size (64, MODE_FLOAT, 0)) + +/* IN is a REAL_VALUE_TYPE. OUT is a long. */ +#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \ + ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_FLOAT, 0))) + +#define REAL_VALUE_FROM_INT(r, lo, hi, mode) \ + real_from_integer (&(r), mode, lo, hi, 0) + +#define REAL_VALUE_FROM_UNSIGNED_INT(r, lo, hi, mode) \ + real_from_integer (&(r), mode, lo, hi, 1) + +/* Real values to IEEE 754 decimal floats. */ + +/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ +#define REAL_VALUE_TO_TARGET_DECIMAL128(IN, OUT) \ + real_to_target (OUT, &(IN), mode_for_size (128, MODE_DECIMAL_FLOAT, 0)) + +#define REAL_VALUE_TO_TARGET_DECIMAL64(IN, OUT) \ + real_to_target (OUT, &(IN), mode_for_size (64, MODE_DECIMAL_FLOAT, 0)) + +/* IN is a REAL_VALUE_TYPE. OUT is a long. */ +#define REAL_VALUE_TO_TARGET_DECIMAL32(IN, OUT) \ + ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_DECIMAL_FLOAT, 0))) + +extern REAL_VALUE_TYPE real_value_truncate (enum machine_mode, + REAL_VALUE_TYPE); + +#define REAL_VALUE_TO_INT(plow, phigh, r) \ + real_to_integer2 (plow, phigh, &(r)) + +extern REAL_VALUE_TYPE real_value_negate (const REAL_VALUE_TYPE *); +extern REAL_VALUE_TYPE real_value_abs (const REAL_VALUE_TYPE *); + +extern int significand_size (enum machine_mode); + +extern REAL_VALUE_TYPE real_from_string2 (const char *, enum machine_mode); + +#define REAL_VALUE_ATOF(s, m) \ + real_from_string2 (s, m) + +#define CONST_DOUBLE_ATOF(s, m) \ + CONST_DOUBLE_FROM_REAL_VALUE (real_from_string2 (s, m), m) + +#define REAL_VALUE_FIX(r) \ + real_to_integer (&(r)) + +/* ??? Not quite right. */ +#define REAL_VALUE_UNSIGNED_FIX(r) \ + real_to_integer (&(r)) + +/* ??? These were added for Paranoia support. */ + +/* Return floor log2(R). */ +extern int real_exponent (const REAL_VALUE_TYPE *); + +/* R = A * 2**EXP. */ +extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int); + +/* **** End of software floating point emulator interface macros **** */ + +/* Constant real values 0, 1, 2, -1 and 0.5. */ + +extern REAL_VALUE_TYPE dconst0; +extern REAL_VALUE_TYPE dconst1; +extern REAL_VALUE_TYPE dconst2; +extern REAL_VALUE_TYPE dconstm1; +extern REAL_VALUE_TYPE dconsthalf; + +#define dconst_e() (*dconst_e_ptr ()) +#define dconst_third() (*dconst_third_ptr ()) +#define dconst_sqrt2() (*dconst_sqrt2_ptr ()) + +/* Function to return the real value special constant 'e'. */ +extern const REAL_VALUE_TYPE * dconst_e_ptr (void); + +/* Returns the special REAL_VALUE_TYPE corresponding to 1/3. */ +extern const REAL_VALUE_TYPE * dconst_third_ptr (void); + +/* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */ +extern const REAL_VALUE_TYPE * dconst_sqrt2_ptr (void); + +/* Function to return a real value (not a tree node) + from a given integer constant. */ +REAL_VALUE_TYPE real_value_from_int_cst (const_tree, const_tree); + +/* Given a CONST_DOUBLE in FROM, store into TO the value it represents. */ +#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \ + ((to) = *CONST_DOUBLE_REAL_VALUE (from)) + +/* Return a CONST_DOUBLE with value R and mode M. */ +#define CONST_DOUBLE_FROM_REAL_VALUE(r, m) \ + const_double_from_real_value (r, m) +extern rtx const_double_from_real_value (REAL_VALUE_TYPE, enum machine_mode); + +/* Replace R by 1/R in the given machine mode, if the result is exact. */ +extern bool exact_real_inverse (enum machine_mode, REAL_VALUE_TYPE *); + +/* Return true if arithmetic on values in IMODE that were promoted + from values in TMODE is equivalent to direct arithmetic on values + in TMODE. */ +bool real_can_shorten_arithmetic (enum machine_mode, enum machine_mode); + +/* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node. */ +extern tree build_real (tree, REAL_VALUE_TYPE); + +/* Calculate R as the square root of X in the given machine mode. */ +extern bool real_sqrt (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *); + +/* Calculate R as X raised to the integer exponent N in mode MODE. */ +extern bool real_powi (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *, HOST_WIDE_INT); + +/* Standard round to integer value functions. */ +extern void real_trunc (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *); +extern void real_floor (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *); +extern void real_ceil (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *); +extern void real_round (REAL_VALUE_TYPE *, enum machine_mode, + const REAL_VALUE_TYPE *); + +/* Set the sign of R to the sign of X. */ +extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); + +/* Check whether the real constant value given is an integer. */ +extern bool real_isinteger (const REAL_VALUE_TYPE *c, enum machine_mode mode); + +/* Write into BUF the maximum representable finite floating-point + number, (1 - b**-p) * b**emax for a given FP format FMT as a hex + float string. BUF must be large enough to contain the result. */ +extern void get_max_float (const struct real_format *, char *, size_t); +#endif /* ! GCC_REAL_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/reg-notes.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/reg-notes.def new file mode 100644 index 0000000..329cd67 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/reg-notes.def @@ -0,0 +1,191 @@ +/* Register note definitions. + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + +/* This file defines all the codes that may appear on individual + EXPR_LIST rtxes in the REG_NOTES chain of an insn. The codes are + stored in the mode field of the EXPR_LIST. Source files define + DEF_REG_NOTE appropriately before including this file. */ + +/* Shorthand. */ +#define REG_NOTE(NAME) DEF_REG_NOTE (REG_##NAME) + +/* REG_DEP_TRUE is used in scheduler dependencies lists to represent a + read-after-write dependency (i.e. a true data dependency). This is + here, not grouped with REG_DEP_ANTI and REG_DEP_OUTPUT, because some + passes use a literal 0 for it. */ +REG_NOTE (DEP_TRUE) + +/* The value in REG dies in this insn (i.e., it is not needed past + this insn). If REG is set in this insn, the REG_DEAD note may, + but need not, be omitted. */ +REG_NOTE (DEAD) + +/* The REG is autoincremented or autodecremented in this insn. */ +REG_NOTE (INC) + +/* Describes the insn as a whole; it says that the insn sets a + register to a constant value or to be equivalent to a memory + address. If the register is spilled to the stack then the constant + value should be substituted for it. The contents of the REG_EQUIV + is the constant value or memory address, which may be different + from the source of the SET although it has the same value. A + REG_EQUIV note may also appear on an insn which copies a register + parameter to a pseudo-register, if there is a memory address which + could be used to hold that pseudo-register throughout the function. */ +REG_NOTE (EQUIV) + +/* Like REG_EQUIV except that the destination is only momentarily + equal to the specified rtx. Therefore, it cannot be used for + substitution; but it can be used for cse. */ +REG_NOTE (EQUAL) + +/* The register is always nonnegative during the containing loop. + This is used in branches so that decrement and branch instructions + terminating on zero can be matched. There must be an insn pattern + in the md file named `decrement_and_branch_until_zero' or else this + will never be added to any instructions. */ +REG_NOTE (NONNEG) + +/* Identifies a register set in this insn and never used. */ +REG_NOTE (UNUSED) + +/* REG_CC_SETTER and REG_CC_USER link a pair of insns that set and use + CC0, respectively. Normally, these are required to be consecutive + insns, but we permit putting a cc0-setting insn in the delay slot + of a branch as long as only one copy of the insn exists. In that + case, these notes point from one to the other to allow code + generation to determine what any require information and to + properly update CC_STATUS. These notes are INSN_LISTs. */ +REG_NOTE (CC_SETTER) +REG_NOTE (CC_USER) + +/* Points to a CODE_LABEL. Used by JUMP_INSNs to say that the CODE_LABEL + contained in the REG_LABEL_TARGET note is a possible jump target of + this insn. This note is an INSN_LIST. */ +REG_NOTE (LABEL_TARGET) + +/* Points to a CODE_LABEL. Used by any insn to say that the CODE_LABEL + contained in the REG_LABEL_OPERAND note is used by the insn, but as an + operand, not as a jump target (though it may indirectly be a jump + target for a later jump insn). This note is an INSN_LIST. */ +REG_NOTE (LABEL_OPERAND) + +/* REG_DEP_OUTPUT and REG_DEP_ANTI are used in scheduler dependencies lists + to represent write-after-write and write-after-read dependencies + respectively. */ +REG_NOTE (DEP_OUTPUT) +REG_NOTE (DEP_ANTI) + +/* REG_BR_PROB is attached to JUMP_INSNs and CALL_INSNs. It has an + integer value. For jumps, it is the probability that this is a + taken branch. For calls, it is the probability that this call + won't return. */ +REG_NOTE (BR_PROB) + +/* Attached to a call insn; indicates that the call is malloc-like and + that the pointer returned cannot alias anything else. */ +REG_NOTE (NOALIAS) + +/* REG_BR_PRED is attached to JUMP_INSNs and CALL_INSNSs. It contains + CONCAT of two integer value. First specifies the branch predictor + that added the note, second specifies the predicted hitrate of + branch in the same format as REG_BR_PROB note uses. */ +REG_NOTE (BR_PRED) + +/* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex + for DWARF to interpret what they imply. The attached rtx is used + instead of intuition. */ +REG_NOTE (FRAME_RELATED_EXPR) + +/* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex + for FRAME_RELATED_EXPR intuition. The insn's first pattern must be + a SET, and the destination must be the CFA register. The attached + rtx is an expression that defines the CFA. In the simplest case, the + rtx could be just the stack_pointer_rtx; more common would be a PLUS + with a base register and a constant offset. In the most complicated + cases, this will result in a DW_CFA_def_cfa_expression with the rtx + expression rendered in a dwarf location expression. */ +REG_NOTE (CFA_DEF_CFA) + +/* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex + for FRAME_RELATED_EXPR intuition. This note adjusts the expression + from which the CFA is computed. The attached rtx defines a new CFA + expression, relative to the old CFA expression. This rtx must be of + the form (SET new-cfa-reg (PLUS old-cfa-reg const_int)). If the note + rtx is NULL, we use the first SET of the insn. */ +REG_NOTE (CFA_ADJUST_CFA) + +/* Similar to FRAME_RELATED_EXPR, with the additional information that + this is a save to memory, i.e. will result in DW_CFA_offset or the + like. The pattern or the insn should be a simple store relative to + the CFA. */ +REG_NOTE (CFA_OFFSET) + +/* Similar to FRAME_RELATED_EXPR, with the additional information that this + is a save to a register, i.e. will result in DW_CFA_register. The insn + or the pattern should be simple reg-reg move. */ +REG_NOTE (CFA_REGISTER) + +/* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex + for FRAME_RELATED_EXPR intuition. This is a save to memory, i.e. will + result in a DW_CFA_expression. The pattern or the insn should be a + store of a register to an arbitrary (non-validated) memory address. */ +REG_NOTE (CFA_EXPRESSION) + +/* Attached to insns that are RTX_FRAME_RELATED_P, with the information + that this is a restore operation, i.e. will result in DW_CFA_restore + or the like. Either the attached rtx, or the destination of the insn's + first pattern is the register to be restored. */ +REG_NOTE (CFA_RESTORE) + +/* Attached to insn that is RTX_FRAME_RELATED_P, marks insn that sets + vDRAP from DRAP. If vDRAP is a register, vdrap_reg is initalized + to the argument, if it is a MEM, it is ignored. */ +REG_NOTE (CFA_SET_VDRAP) + +/* Indicates that REG holds the exception context for the function. + This context is shared by inline functions, so the code to acquire + the real exception context is delayed until after inlining. */ +REG_NOTE (EH_CONTEXT) + +/* Indicates what exception region an INSN belongs in. This is used + to indicate what region to which a call may throw. REGION 0 + indicates that a call cannot throw at all. REGION -1 indicates + that it cannot throw, nor will it execute a non-local goto. */ +REG_NOTE (EH_REGION) + +/* Used by haifa-sched to save NOTE_INSN notes across scheduling. */ +REG_NOTE (SAVE_NOTE) + +/* Indicates that a call does not return. */ +REG_NOTE (NORETURN) + +/* Indicates that an indirect jump is a non-local goto instead of a + computed goto. */ +REG_NOTE (NON_LOCAL_GOTO) + +/* Indicates that a jump crosses between hot and cold sections in a + (partitioned) assembly or .o file, and therefore should not be + reduced to a simpler jump by optimizations. */ +REG_NOTE (CROSSING_JUMP) + +/* This kind of note is generated at each to `setjmp', and similar + functions that can return twice. */ +REG_NOTE (SETJMP) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/rtl.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/rtl.def new file mode 100644 index 0000000..6e2aa8b --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/rtl.def @@ -0,0 +1,1272 @@ +/* This file contains the definitions and documentation for the + Register Transfer Expressions (rtx's) that make up the + Register Transfer Language (rtl) used in the Back End of the GNU compiler. + Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2004, + 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + + +/* Expression definitions and descriptions for all targets are in this file. + Some will not be used for some targets. + + The fields in the cpp macro call "DEF_RTL_EXPR()" + are used to create declarations in the C source of the compiler. + + The fields are: + + 1. The internal name of the rtx used in the C source. + It is a tag in the enumeration "enum rtx_code" defined in "rtl.h". + By convention these are in UPPER_CASE. + + 2. The name of the rtx in the external ASCII format read by + read_rtx(), and printed by print_rtx(). + These names are stored in rtx_name[]. + By convention these are the internal (field 1) names in lower_case. + + 3. The print format, and type of each rtx->u.fld[] (field) in this rtx. + These formats are stored in rtx_format[]. + The meaning of the formats is documented in front of this array in rtl.c + + 4. The class of the rtx. These are stored in rtx_class and are accessed + via the GET_RTX_CLASS macro. They are defined as follows: + + RTX_CONST_OBJ + an rtx code that can be used to represent a constant object + (e.g, CONST_INT) + RTX_OBJ + an rtx code that can be used to represent an object (e.g, REG, MEM) + RTX_COMPARE + an rtx code for a comparison (e.g, LT, GT) + RTX_COMM_COMPARE + an rtx code for a commutative comparison (e.g, EQ, NE, ORDERED) + RTX_UNARY + an rtx code for a unary arithmetic expression (e.g, NEG, NOT) + RTX_COMM_ARITH + an rtx code for a commutative binary operation (e.g,, PLUS, MULT) + RTX_TERNARY + an rtx code for a non-bitfield three input operation (IF_THEN_ELSE) + RTX_BIN_ARITH + an rtx code for a non-commutative binary operation (e.g., MINUS, DIV) + RTX_BITFIELD_OPS + an rtx code for a bit-field operation (ZERO_EXTRACT, SIGN_EXTRACT) + RTX_INSN + an rtx code for a machine insn (INSN, JUMP_INSN, CALL_INSN) + RTX_MATCH + an rtx code for something that matches in insns (e.g, MATCH_DUP) + RTX_AUTOINC + an rtx code for autoincrement addressing modes (e.g. POST_DEC) + RTX_EXTRA + everything else + + All of the expressions that appear only in machine descriptions, + not in RTL used by the compiler itself, are at the end of the file. */ + +/* Unknown, or no such operation; the enumeration constant should have + value zero. */ +DEF_RTL_EXPR(UNKNOWN, "UnKnown", "*", RTX_EXTRA) + +/* Used in the cselib routines to describe a value. Objects of this + kind are only allocated in cselib.c, in an alloc pool instead of in + GC memory. The only operand of a VALUE is a cselib_val_struct. + var-tracking requires this to have a distinct integral value from + DECL codes in trees. */ +DEF_RTL_EXPR(VALUE, "value", "0", RTX_OBJ) + +/* The RTL generated for a DEBUG_EXPR_DECL. It links back to the + DEBUG_EXPR_DECL in the first operand. */ +DEF_RTL_EXPR(DEBUG_EXPR, "debug_expr", "0", RTX_OBJ) + +/* --------------------------------------------------------------------- + Expressions used in constructing lists. + --------------------------------------------------------------------- */ + +/* a linked list of expressions */ +DEF_RTL_EXPR(EXPR_LIST, "expr_list", "ee", RTX_EXTRA) + +/* a linked list of instructions. + The insns are represented in print by their uids. */ +DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA) + +/* SEQUENCE appears in the result of a `gen_...' function + for a DEFINE_EXPAND that wants to make several insns. + Its elements are the bodies of the insns that should be made. + `emit_insn' takes the SEQUENCE apart and makes separate insns. */ +DEF_RTL_EXPR(SEQUENCE, "sequence", "E", RTX_EXTRA) + +/* Refers to the address of its argument. This is only used in alias.c. */ +DEF_RTL_EXPR(ADDRESS, "address", "e", RTX_MATCH) + +/* ---------------------------------------------------------------------- + Expression types used for things in the instruction chain. + + All formats must start with "iuu" to handle the chain. + Each insn expression holds an rtl instruction and its semantics + during back-end processing. + See macros's in "rtl.h" for the meaning of each rtx->u.fld[]. + + ---------------------------------------------------------------------- */ + +/* An annotation for variable assignment tracking. */ +DEF_RTL_EXPR(DEBUG_INSN, "debug_insn", "iuuBeiie", RTX_INSN) + +/* An instruction that cannot jump. */ +DEF_RTL_EXPR(INSN, "insn", "iuuBeiie", RTX_INSN) + +/* An instruction that can possibly jump. + Fields ( rtx->u.fld[] ) have exact same meaning as INSN's. */ +DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "iuuBeiie0", RTX_INSN) + +/* An instruction that can possibly call a subroutine + but which will not change which instruction comes next + in the current function. + Field ( rtx->u.fld[8] ) is CALL_INSN_FUNCTION_USAGE. + All other fields ( rtx->u.fld[] ) have exact same meaning as INSN's. */ +DEF_RTL_EXPR(CALL_INSN, "call_insn", "iuuBeiiee", RTX_INSN) + +/* A marker that indicates that control will not flow through. */ +DEF_RTL_EXPR(BARRIER, "barrier", "iuu00000", RTX_EXTRA) + +/* Holds a label that is followed by instructions. + Operand: + 4: is used in jump.c for the use-count of the label. + 5: is used in the sh backend. + 6: is a number that is unique in the entire compilation. + 7: is the user-given name of the label, if any. */ +DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuuB00is", RTX_EXTRA) + +/* Say where in the code a source line starts, for symbol table's sake. + Operand: + 4: note-specific data + 5: enum insn_note + 6: unique number if insn_note == note_insn_deleted_label. */ +DEF_RTL_EXPR(NOTE, "note", "iuuB0ni", RTX_EXTRA) + +/* ---------------------------------------------------------------------- + Top level constituents of INSN, JUMP_INSN and CALL_INSN. + ---------------------------------------------------------------------- */ + +/* Conditionally execute code. + Operand 0 is the condition that if true, the code is executed. + Operand 1 is the code to be executed (typically a SET). + + Semantics are that there are no side effects if the condition + is false. This pattern is created automatically by the if_convert + pass run after reload or by target-specific splitters. */ +DEF_RTL_EXPR(COND_EXEC, "cond_exec", "ee", RTX_EXTRA) + +/* Several operations to be done in parallel (perhaps under COND_EXEC). */ +DEF_RTL_EXPR(PARALLEL, "parallel", "E", RTX_EXTRA) + +/* A string that is passed through to the assembler as input. + One can obviously pass comments through by using the + assembler comment syntax. + These occur in an insn all by themselves as the PATTERN. + They also appear inside an ASM_OPERANDS + as a convenient way to hold a string. */ +DEF_RTL_EXPR(ASM_INPUT, "asm_input", "si", RTX_EXTRA) + +/* An assembler instruction with operands. + 1st operand is the instruction template. + 2nd operand is the constraint for the output. + 3rd operand is the number of the output this expression refers to. + When an insn stores more than one value, a separate ASM_OPERANDS + is made for each output; this integer distinguishes them. + 4th is a vector of values of input operands. + 5th is a vector of modes and constraints for the input operands. + Each element is an ASM_INPUT containing a constraint string + and whose mode indicates the mode of the input operand. + 6th is a vector of labels that may be branched to by the asm. + 7th is the source line number. */ +DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEEEi", RTX_EXTRA) + +/* A machine-specific operation. + 1st operand is a vector of operands being used by the operation so that + any needed reloads can be done. + 2nd operand is a unique value saying which of a number of machine-specific + operations is to be performed. + (Note that the vector must be the first operand because of the way that + genrecog.c record positions within an insn.) + + UNSPEC can occur all by itself in a PATTERN, as a component of a PARALLEL, + or inside an expression. + UNSPEC by itself or as a component of a PARALLEL + is currently considered not deletable. + + FIXME: Replace all uses of UNSPEC that appears by itself or as a component + of a PARALLEL with USE. + */ +DEF_RTL_EXPR(UNSPEC, "unspec", "Ei", RTX_EXTRA) + +/* Similar, but a volatile operation and one which may trap. */ +DEF_RTL_EXPR(UNSPEC_VOLATILE, "unspec_volatile", "Ei", RTX_EXTRA) + +/* Vector of addresses, stored as full words. */ +/* Each element is a LABEL_REF to a CODE_LABEL whose address we want. */ +DEF_RTL_EXPR(ADDR_VEC, "addr_vec", "E", RTX_EXTRA) + +/* Vector of address differences X0 - BASE, X1 - BASE, ... + First operand is BASE; the vector contains the X's. + The machine mode of this rtx says how much space to leave + for each difference and is adjusted by branch shortening if + CASE_VECTOR_SHORTEN_MODE is defined. + The third and fourth operands store the target labels with the + minimum and maximum addresses respectively. + The fifth operand stores flags for use by branch shortening. + Set at the start of shorten_branches: + min_align: the minimum alignment for any of the target labels. + base_after_vec: true iff BASE is after the ADDR_DIFF_VEC. + min_after_vec: true iff minimum addr target label is after the ADDR_DIFF_VEC. + max_after_vec: true iff maximum addr target label is after the ADDR_DIFF_VEC. + min_after_base: true iff minimum address target label is after BASE. + max_after_base: true iff maximum address target label is after BASE. + Set by the actual branch shortening process: + offset_unsigned: true iff offsets have to be treated as unsigned. + scale: scaling that is necessary to make offsets fit into the mode. + + The third, fourth and fifth operands are only valid when + CASE_VECTOR_SHORTEN_MODE is defined, and only in an optimizing + compilations. */ + +DEF_RTL_EXPR(ADDR_DIFF_VEC, "addr_diff_vec", "eEee0", RTX_EXTRA) + +/* Memory prefetch, with attributes supported on some targets. + Operand 1 is the address of the memory to fetch. + Operand 2 is 1 for a write access, 0 otherwise. + Operand 3 is the level of temporal locality; 0 means there is no + temporal locality and 1, 2, and 3 are for increasing levels of temporal + locality. + + The attributes specified by operands 2 and 3 are ignored for targets + whose prefetch instructions do not support them. */ +DEF_RTL_EXPR(PREFETCH, "prefetch", "eee", RTX_EXTRA) + +/* ---------------------------------------------------------------------- + At the top level of an instruction (perhaps under PARALLEL). + ---------------------------------------------------------------------- */ + +/* Assignment. + Operand 1 is the location (REG, MEM, PC, CC0 or whatever) assigned to. + Operand 2 is the value stored there. + ALL assignment must use SET. + Instructions that do multiple assignments must use multiple SET, + under PARALLEL. */ +DEF_RTL_EXPR(SET, "set", "ee", RTX_EXTRA) + +/* Indicate something is used in a way that we don't want to explain. + For example, subroutine calls will use the register + in which the static chain is passed. + + USE can not appear as an operand of other rtx except for PARALLEL. + USE is not deletable, as it indicates that the operand + is used in some unknown way. */ +DEF_RTL_EXPR(USE, "use", "e", RTX_EXTRA) + +/* Indicate something is clobbered in a way that we don't want to explain. + For example, subroutine calls will clobber some physical registers + (the ones that are by convention not saved). + + CLOBBER can not appear as an operand of other rtx except for PARALLEL. + CLOBBER of a hard register appearing by itself (not within PARALLEL) + is considered undeletable before reload. */ +DEF_RTL_EXPR(CLOBBER, "clobber", "e", RTX_EXTRA) + +/* Call a subroutine. + Operand 1 is the address to call. + Operand 2 is the number of arguments. */ + +DEF_RTL_EXPR(CALL, "call", "ee", RTX_EXTRA) + +/* Return from a subroutine. */ + +DEF_RTL_EXPR(RETURN, "return", "", RTX_EXTRA) + +/* Special for EH return from subroutine. */ + +DEF_RTL_EXPR(EH_RETURN, "eh_return", "", RTX_EXTRA) + +/* Conditional trap. + Operand 1 is the condition. + Operand 2 is the trap code. + For an unconditional trap, make the condition (const_int 1). */ +DEF_RTL_EXPR(TRAP_IF, "trap_if", "ee", RTX_EXTRA) + +/* ---------------------------------------------------------------------- + Primitive values for use in expressions. + ---------------------------------------------------------------------- */ + +/* numeric integer constant */ +DEF_RTL_EXPR(CONST_INT, "const_int", "w", RTX_CONST_OBJ) + +/* fixed-point constant */ +DEF_RTL_EXPR(CONST_FIXED, "const_fixed", "www", RTX_CONST_OBJ) + +/* numeric floating point constant. + Operands hold the value. They are all 'w' and there may be from 2 to 6; + see real.h. */ +DEF_RTL_EXPR(CONST_DOUBLE, "const_double", CONST_DOUBLE_FORMAT, RTX_CONST_OBJ) + +/* Describes a vector constant. */ +DEF_RTL_EXPR(CONST_VECTOR, "const_vector", "E", RTX_CONST_OBJ) + +/* String constant. Used for attributes in machine descriptions and + for special cases in DWARF2 debug output. NOT used for source- + language string constants. */ +DEF_RTL_EXPR(CONST_STRING, "const_string", "s", RTX_OBJ) + +/* This is used to encapsulate an expression whose value is constant + (such as the sum of a SYMBOL_REF and a CONST_INT) so that it will be + recognized as a constant operand rather than by arithmetic instructions. */ + +DEF_RTL_EXPR(CONST, "const", "e", RTX_CONST_OBJ) + +/* program counter. Ordinary jumps are represented + by a SET whose first operand is (PC). */ +DEF_RTL_EXPR(PC, "pc", "", RTX_OBJ) + +/* A register. The "operand" is the register number, accessed with + the REGNO macro. If this number is less than FIRST_PSEUDO_REGISTER + than a hardware register is being referred to. The second operand + holds the original register number - this will be different for a + pseudo register that got turned into a hard register. The third + operand points to a reg_attrs structure. + This rtx needs to have as many (or more) fields as a MEM, since we + can change REG rtx's into MEMs during reload. */ +DEF_RTL_EXPR(REG, "reg", "i00", RTX_OBJ) + +/* A scratch register. This represents a register used only within a + single insn. It will be turned into a REG during register allocation + or reload unless the constraint indicates that the register won't be + needed, in which case it can remain a SCRATCH. This code is + marked as having one operand so it can be turned into a REG. */ +DEF_RTL_EXPR(SCRATCH, "scratch", "0", RTX_OBJ) + +/* A reference to a part of another value. The first operand is the + complete value and the second is the byte offset of the selected part. */ +DEF_RTL_EXPR(SUBREG, "subreg", "ei", RTX_EXTRA) + +/* This one-argument rtx is used for move instructions + that are guaranteed to alter only the low part of a destination. + Thus, (SET (SUBREG:HI (REG...)) (MEM:HI ...)) + has an unspecified effect on the high part of REG, + but (SET (STRICT_LOW_PART (SUBREG:HI (REG...))) (MEM:HI ...)) + is guaranteed to alter only the bits of REG that are in HImode. + + The actual instruction used is probably the same in both cases, + but the register constraints may be tighter when STRICT_LOW_PART + is in use. */ + +DEF_RTL_EXPR(STRICT_LOW_PART, "strict_low_part", "e", RTX_EXTRA) + +/* (CONCAT a b) represents the virtual concatenation of a and b + to make a value that has as many bits as a and b put together. + This is used for complex values. Normally it appears only + in DECL_RTLs and during RTL generation, but not in the insn chain. */ +DEF_RTL_EXPR(CONCAT, "concat", "ee", RTX_OBJ) + +/* (CONCATN [a1 a2 ... an]) represents the virtual concatenation of + all An to make a value. This is an extension of CONCAT to larger + number of components. Like CONCAT, it should not appear in the + insn chain. Every element of the CONCATN is the same size. */ +DEF_RTL_EXPR(CONCATN, "concatn", "E", RTX_OBJ) + +/* A memory location; operand is the address. The second operand is the + alias set to which this MEM belongs. We use `0' instead of `w' for this + field so that the field need not be specified in machine descriptions. */ +DEF_RTL_EXPR(MEM, "mem", "e0", RTX_OBJ) + +/* Reference to an assembler label in the code for this function. + The operand is a CODE_LABEL found in the insn chain. */ +DEF_RTL_EXPR(LABEL_REF, "label_ref", "u", RTX_CONST_OBJ) + +/* Reference to a named label: + Operand 0: label name + Operand 1: flags (see SYMBOL_FLAG_* in rtl.h) + Operand 2: tree from which this symbol is derived, or null. + This is either a DECL node, or some kind of constant. */ +DEF_RTL_EXPR(SYMBOL_REF, "symbol_ref", "s00", RTX_CONST_OBJ) + +/* The condition code register is represented, in our imagination, + as a register holding a value that can be compared to zero. + In fact, the machine has already compared them and recorded the + results; but instructions that look at the condition code + pretend to be looking at the entire value and comparing it. */ +DEF_RTL_EXPR(CC0, "cc0", "", RTX_OBJ) + +/* ---------------------------------------------------------------------- + Expressions for operators in an rtl pattern + ---------------------------------------------------------------------- */ + +/* if_then_else. This is used in representing ordinary + conditional jump instructions. + Operand: + 0: condition + 1: then expr + 2: else expr */ +DEF_RTL_EXPR(IF_THEN_ELSE, "if_then_else", "eee", RTX_TERNARY) + +/* Comparison, produces a condition code result. */ +DEF_RTL_EXPR(COMPARE, "compare", "ee", RTX_BIN_ARITH) + +/* plus */ +DEF_RTL_EXPR(PLUS, "plus", "ee", RTX_COMM_ARITH) + +/* Operand 0 minus operand 1. */ +DEF_RTL_EXPR(MINUS, "minus", "ee", RTX_BIN_ARITH) + +/* Minus operand 0. */ +DEF_RTL_EXPR(NEG, "neg", "e", RTX_UNARY) + +DEF_RTL_EXPR(MULT, "mult", "ee", RTX_COMM_ARITH) + +/* Multiplication with signed saturation */ +DEF_RTL_EXPR(SS_MULT, "ss_mult", "ee", RTX_COMM_ARITH) +/* Multiplication with unsigned saturation */ +DEF_RTL_EXPR(US_MULT, "us_mult", "ee", RTX_COMM_ARITH) + +/* Operand 0 divided by operand 1. */ +DEF_RTL_EXPR(DIV, "div", "ee", RTX_BIN_ARITH) +/* Division with signed saturation */ +DEF_RTL_EXPR(SS_DIV, "ss_div", "ee", RTX_BIN_ARITH) +/* Division with unsigned saturation */ +DEF_RTL_EXPR(US_DIV, "us_div", "ee", RTX_BIN_ARITH) + +/* Remainder of operand 0 divided by operand 1. */ +DEF_RTL_EXPR(MOD, "mod", "ee", RTX_BIN_ARITH) + +/* Unsigned divide and remainder. */ +DEF_RTL_EXPR(UDIV, "udiv", "ee", RTX_BIN_ARITH) +DEF_RTL_EXPR(UMOD, "umod", "ee", RTX_BIN_ARITH) + +/* Bitwise operations. */ +DEF_RTL_EXPR(AND, "and", "ee", RTX_COMM_ARITH) +DEF_RTL_EXPR(IOR, "ior", "ee", RTX_COMM_ARITH) +DEF_RTL_EXPR(XOR, "xor", "ee", RTX_COMM_ARITH) +DEF_RTL_EXPR(NOT, "not", "e", RTX_UNARY) + +/* Operand: + 0: value to be shifted. + 1: number of bits. */ +DEF_RTL_EXPR(ASHIFT, "ashift", "ee", RTX_BIN_ARITH) /* shift left */ +DEF_RTL_EXPR(ROTATE, "rotate", "ee", RTX_BIN_ARITH) /* rotate left */ +DEF_RTL_EXPR(ASHIFTRT, "ashiftrt", "ee", RTX_BIN_ARITH) /* arithmetic shift right */ +DEF_RTL_EXPR(LSHIFTRT, "lshiftrt", "ee", RTX_BIN_ARITH) /* logical shift right */ +DEF_RTL_EXPR(ROTATERT, "rotatert", "ee", RTX_BIN_ARITH) /* rotate right */ + +/* Minimum and maximum values of two operands. We need both signed and + unsigned forms. (We cannot use MIN for SMIN because it conflicts + with a macro of the same name.) The signed variants should be used + with floating point. Further, if both operands are zeros, or if either + operand is NaN, then it is unspecified which of the two operands is + returned as the result. */ + +DEF_RTL_EXPR(SMIN, "smin", "ee", RTX_COMM_ARITH) +DEF_RTL_EXPR(SMAX, "smax", "ee", RTX_COMM_ARITH) +DEF_RTL_EXPR(UMIN, "umin", "ee", RTX_COMM_ARITH) +DEF_RTL_EXPR(UMAX, "umax", "ee", RTX_COMM_ARITH) + +/* These unary operations are used to represent incrementation + and decrementation as they occur in memory addresses. + The amount of increment or decrement are not represented + because they can be understood from the machine-mode of the + containing MEM. These operations exist in only two cases: + 1. pushes onto the stack. + 2. created automatically by the auto-inc-dec pass. */ +DEF_RTL_EXPR(PRE_DEC, "pre_dec", "e", RTX_AUTOINC) +DEF_RTL_EXPR(PRE_INC, "pre_inc", "e", RTX_AUTOINC) +DEF_RTL_EXPR(POST_DEC, "post_dec", "e", RTX_AUTOINC) +DEF_RTL_EXPR(POST_INC, "post_inc", "e", RTX_AUTOINC) + +/* These binary operations are used to represent generic address + side-effects in memory addresses, except for simple incrementation + or decrementation which use the above operations. They are + created automatically by the life_analysis pass in flow.c. + The first operand is a REG which is used as the address. + The second operand is an expression that is assigned to the + register, either before (PRE_MODIFY) or after (POST_MODIFY) + evaluating the address. + Currently, the compiler can only handle second operands of the + form (plus (reg) (reg)) and (plus (reg) (const_int)), where + the first operand of the PLUS has to be the same register as + the first operand of the *_MODIFY. */ +DEF_RTL_EXPR(PRE_MODIFY, "pre_modify", "ee", RTX_AUTOINC) +DEF_RTL_EXPR(POST_MODIFY, "post_modify", "ee", RTX_AUTOINC) + +/* Comparison operations. The ordered comparisons exist in two + flavors, signed and unsigned. */ +DEF_RTL_EXPR(NE, "ne", "ee", RTX_COMM_COMPARE) +DEF_RTL_EXPR(EQ, "eq", "ee", RTX_COMM_COMPARE) +DEF_RTL_EXPR(GE, "ge", "ee", RTX_COMPARE) +DEF_RTL_EXPR(GT, "gt", "ee", RTX_COMPARE) +DEF_RTL_EXPR(LE, "le", "ee", RTX_COMPARE) +DEF_RTL_EXPR(LT, "lt", "ee", RTX_COMPARE) +DEF_RTL_EXPR(GEU, "geu", "ee", RTX_COMPARE) +DEF_RTL_EXPR(GTU, "gtu", "ee", RTX_COMPARE) +DEF_RTL_EXPR(LEU, "leu", "ee", RTX_COMPARE) +DEF_RTL_EXPR(LTU, "ltu", "ee", RTX_COMPARE) + +/* Additional floating point unordered comparison flavors. */ +DEF_RTL_EXPR(UNORDERED, "unordered", "ee", RTX_COMM_COMPARE) +DEF_RTL_EXPR(ORDERED, "ordered", "ee", RTX_COMM_COMPARE) + +/* These are equivalent to unordered or ... */ +DEF_RTL_EXPR(UNEQ, "uneq", "ee", RTX_COMM_COMPARE) +DEF_RTL_EXPR(UNGE, "unge", "ee", RTX_COMPARE) +DEF_RTL_EXPR(UNGT, "ungt", "ee", RTX_COMPARE) +DEF_RTL_EXPR(UNLE, "unle", "ee", RTX_COMPARE) +DEF_RTL_EXPR(UNLT, "unlt", "ee", RTX_COMPARE) + +/* This is an ordered NE, ie !UNEQ, ie false for NaN. */ +DEF_RTL_EXPR(LTGT, "ltgt", "ee", RTX_COMM_COMPARE) + +/* Represents the result of sign-extending the sole operand. + The machine modes of the operand and of the SIGN_EXTEND expression + determine how much sign-extension is going on. */ +DEF_RTL_EXPR(SIGN_EXTEND, "sign_extend", "e", RTX_UNARY) + +/* Similar for zero-extension (such as unsigned short to int). */ +DEF_RTL_EXPR(ZERO_EXTEND, "zero_extend", "e", RTX_UNARY) + +/* Similar but here the operand has a wider mode. */ +DEF_RTL_EXPR(TRUNCATE, "truncate", "e", RTX_UNARY) + +/* Similar for extending floating-point values (such as SFmode to DFmode). */ +DEF_RTL_EXPR(FLOAT_EXTEND, "float_extend", "e", RTX_UNARY) +DEF_RTL_EXPR(FLOAT_TRUNCATE, "float_truncate", "e", RTX_UNARY) + +/* Conversion of fixed point operand to floating point value. */ +DEF_RTL_EXPR(FLOAT, "float", "e", RTX_UNARY) + +/* With fixed-point machine mode: + Conversion of floating point operand to fixed point value. + Value is defined only when the operand's value is an integer. + With floating-point machine mode (and operand with same mode): + Operand is rounded toward zero to produce an integer value + represented in floating point. */ +DEF_RTL_EXPR(FIX, "fix", "e", RTX_UNARY) + +/* Conversion of unsigned fixed point operand to floating point value. */ +DEF_RTL_EXPR(UNSIGNED_FLOAT, "unsigned_float", "e", RTX_UNARY) + +/* With fixed-point machine mode: + Conversion of floating point operand to *unsigned* fixed point value. + Value is defined only when the operand's value is an integer. */ +DEF_RTL_EXPR(UNSIGNED_FIX, "unsigned_fix", "e", RTX_UNARY) + +/* Conversions involving fractional fixed-point types without saturation, + including: + fractional to fractional (of different precision), + signed integer to fractional, + fractional to signed integer, + floating point to fractional, + fractional to floating point. + NOTE: fractional can be either signed or unsigned for conversions. */ +DEF_RTL_EXPR(FRACT_CONVERT, "fract_convert", "e", RTX_UNARY) + +/* Conversions involving fractional fixed-point types and unsigned integer + without saturation, including: + unsigned integer to fractional, + fractional to unsigned integer. + NOTE: fractional can be either signed or unsigned for conversions. */ +DEF_RTL_EXPR(UNSIGNED_FRACT_CONVERT, "unsigned_fract_convert", "e", RTX_UNARY) + +/* Conversions involving fractional fixed-point types with saturation, + including: + fractional to fractional (of different precision), + signed integer to fractional, + floating point to fractional. + NOTE: fractional can be either signed or unsigned for conversions. */ +DEF_RTL_EXPR(SAT_FRACT, "sat_fract", "e", RTX_UNARY) + +/* Conversions involving fractional fixed-point types and unsigned integer + with saturation, including: + unsigned integer to fractional. + NOTE: fractional can be either signed or unsigned for conversions. */ +DEF_RTL_EXPR(UNSIGNED_SAT_FRACT, "unsigned_sat_fract", "e", RTX_UNARY) + +/* Absolute value */ +DEF_RTL_EXPR(ABS, "abs", "e", RTX_UNARY) + +/* Square root */ +DEF_RTL_EXPR(SQRT, "sqrt", "e", RTX_UNARY) + +/* Swap bytes. */ +DEF_RTL_EXPR(BSWAP, "bswap", "e", RTX_UNARY) + +/* Find first bit that is set. + Value is 1 + number of trailing zeros in the arg., + or 0 if arg is 0. */ +DEF_RTL_EXPR(FFS, "ffs", "e", RTX_UNARY) + +/* Count leading zeros. */ +DEF_RTL_EXPR(CLZ, "clz", "e", RTX_UNARY) + +/* Count trailing zeros. */ +DEF_RTL_EXPR(CTZ, "ctz", "e", RTX_UNARY) + +/* Population count (number of 1 bits). */ +DEF_RTL_EXPR(POPCOUNT, "popcount", "e", RTX_UNARY) + +/* Population parity (number of 1 bits modulo 2). */ +DEF_RTL_EXPR(PARITY, "parity", "e", RTX_UNARY) + +/* Reference to a signed bit-field of specified size and position. + Operand 0 is the memory unit (usually SImode or QImode) which + contains the field's first bit. Operand 1 is the width, in bits. + Operand 2 is the number of bits in the memory unit before the + first bit of this field. + If BITS_BIG_ENDIAN is defined, the first bit is the msb and + operand 2 counts from the msb of the memory unit. + Otherwise, the first bit is the lsb and operand 2 counts from + the lsb of the memory unit. + This kind of expression can not appear as an lvalue in RTL. */ +DEF_RTL_EXPR(SIGN_EXTRACT, "sign_extract", "eee", RTX_BITFIELD_OPS) + +/* Similar for unsigned bit-field. + But note! This kind of expression _can_ appear as an lvalue. */ +DEF_RTL_EXPR(ZERO_EXTRACT, "zero_extract", "eee", RTX_BITFIELD_OPS) + +/* For RISC machines. These save memory when splitting insns. */ + +/* HIGH are the high-order bits of a constant expression. */ +DEF_RTL_EXPR(HIGH, "high", "e", RTX_CONST_OBJ) + +/* LO_SUM is the sum of a register and the low-order bits + of a constant expression. */ +DEF_RTL_EXPR(LO_SUM, "lo_sum", "ee", RTX_OBJ) + +/* Describes a merge operation between two vector values. + Operands 0 and 1 are the vectors to be merged, operand 2 is a bitmask + that specifies where the parts of the result are taken from. Set bits + indicate operand 0, clear bits indicate operand 1. The parts are defined + by the mode of the vectors. */ +DEF_RTL_EXPR(VEC_MERGE, "vec_merge", "eee", RTX_TERNARY) + +/* Describes an operation that selects parts of a vector. + Operands 0 is the source vector, operand 1 is a PARALLEL that contains + a CONST_INT for each of the subparts of the result vector, giving the + number of the source subpart that should be stored into it. */ +DEF_RTL_EXPR(VEC_SELECT, "vec_select", "ee", RTX_BIN_ARITH) + +/* Describes a vector concat operation. Operands 0 and 1 are the source + vectors, the result is a vector that is as long as operands 0 and 1 + combined and is the concatenation of the two source vectors. */ +DEF_RTL_EXPR(VEC_CONCAT, "vec_concat", "ee", RTX_BIN_ARITH) + +/* Describes an operation that converts a small vector into a larger one by + duplicating the input values. The output vector mode must have the same + submodes as the input vector mode, and the number of output parts must be + an integer multiple of the number of input parts. */ +DEF_RTL_EXPR(VEC_DUPLICATE, "vec_duplicate", "e", RTX_UNARY) + +/* Addition with signed saturation */ +DEF_RTL_EXPR(SS_PLUS, "ss_plus", "ee", RTX_COMM_ARITH) + +/* Addition with unsigned saturation */ +DEF_RTL_EXPR(US_PLUS, "us_plus", "ee", RTX_COMM_ARITH) + +/* Operand 0 minus operand 1, with signed saturation. */ +DEF_RTL_EXPR(SS_MINUS, "ss_minus", "ee", RTX_BIN_ARITH) + +/* Negation with signed saturation. */ +DEF_RTL_EXPR(SS_NEG, "ss_neg", "e", RTX_UNARY) +/* Negation with unsigned saturation. */ +DEF_RTL_EXPR(US_NEG, "us_neg", "e", RTX_UNARY) + +/* Absolute value with signed saturation. */ +DEF_RTL_EXPR(SS_ABS, "ss_abs", "e", RTX_UNARY) + +/* Shift left with signed saturation. */ +DEF_RTL_EXPR(SS_ASHIFT, "ss_ashift", "ee", RTX_BIN_ARITH) + +/* Shift left with unsigned saturation. */ +DEF_RTL_EXPR(US_ASHIFT, "us_ashift", "ee", RTX_BIN_ARITH) + +/* Operand 0 minus operand 1, with unsigned saturation. */ +DEF_RTL_EXPR(US_MINUS, "us_minus", "ee", RTX_BIN_ARITH) + +/* Signed saturating truncate. */ +DEF_RTL_EXPR(SS_TRUNCATE, "ss_truncate", "e", RTX_UNARY) + +/* Unsigned saturating truncate. */ +DEF_RTL_EXPR(US_TRUNCATE, "us_truncate", "e", RTX_UNARY) + +/* Floating point multiply/add combined instruction. */ +DEF_RTL_EXPR(FMA, "fma", "eee", RTX_TERNARY) + +/* Information about the variable and its location. */ +/* Changed 'te' to 'tei'; the 'i' field is for recording + initialization status of variables. */ +DEF_RTL_EXPR(VAR_LOCATION, "var_location", "tei", RTX_EXTRA) + +/* Used in VAR_LOCATION for a pointer to a decl that is no longer + addressable. */ +DEF_RTL_EXPR(DEBUG_IMPLICIT_PTR, "debug_implicit_ptr", "t", RTX_OBJ) + +/* All expressions from this point forward appear only in machine + descriptions. */ +#ifdef GENERATOR_FILE + +/* Pattern-matching operators: */ + +/* Use the function named by the second arg (the string) + as a predicate; if matched, store the structure that was matched + in the operand table at index specified by the first arg (the integer). + If the second arg is the null string, the structure is just stored. + + A third string argument indicates to the register allocator restrictions + on where the operand can be allocated. + + If the target needs no restriction on any instruction this field should + be the null string. + + The string is prepended by: + '=' to indicate the operand is only written to. + '+' to indicate the operand is both read and written to. + + Each character in the string represents an allocable class for an operand. + 'g' indicates the operand can be any valid class. + 'i' indicates the operand can be immediate (in the instruction) data. + 'r' indicates the operand can be in a register. + 'm' indicates the operand can be in memory. + 'o' a subset of the 'm' class. Those memory addressing modes that + can be offset at compile time (have a constant added to them). + + Other characters indicate target dependent operand classes and + are described in each target's machine description. + + For instructions with more than one operand, sets of classes can be + separated by a comma to indicate the appropriate multi-operand constraints. + There must be a 1 to 1 correspondence between these sets of classes in + all operands for an instruction. + */ +DEF_RTL_EXPR(MATCH_OPERAND, "match_operand", "iss", RTX_MATCH) + +/* Match a SCRATCH or a register. When used to generate rtl, a + SCRATCH is generated. As for MATCH_OPERAND, the mode specifies + the desired mode and the first argument is the operand number. + The second argument is the constraint. */ +DEF_RTL_EXPR(MATCH_SCRATCH, "match_scratch", "is", RTX_MATCH) + +/* Apply a predicate, AND match recursively the operands of the rtx. + Operand 0 is the operand-number, as in match_operand. + Operand 1 is a predicate to apply (as a string, a function name). + Operand 2 is a vector of expressions, each of which must match + one subexpression of the rtx this construct is matching. */ +DEF_RTL_EXPR(MATCH_OPERATOR, "match_operator", "isE", RTX_MATCH) + +/* Match a PARALLEL of arbitrary length. The predicate is applied + to the PARALLEL and the initial expressions in the PARALLEL are matched. + Operand 0 is the operand-number, as in match_operand. + Operand 1 is a predicate to apply to the PARALLEL. + Operand 2 is a vector of expressions, each of which must match the + corresponding element in the PARALLEL. */ +DEF_RTL_EXPR(MATCH_PARALLEL, "match_parallel", "isE", RTX_MATCH) + +/* Match only something equal to what is stored in the operand table + at the index specified by the argument. Use with MATCH_OPERAND. */ +DEF_RTL_EXPR(MATCH_DUP, "match_dup", "i", RTX_MATCH) + +/* Match only something equal to what is stored in the operand table + at the index specified by the argument. Use with MATCH_OPERATOR. */ +DEF_RTL_EXPR(MATCH_OP_DUP, "match_op_dup", "iE", RTX_MATCH) + +/* Match only something equal to what is stored in the operand table + at the index specified by the argument. Use with MATCH_PARALLEL. */ +DEF_RTL_EXPR(MATCH_PAR_DUP, "match_par_dup", "iE", RTX_MATCH) + +/* Appears only in define_predicate/define_special_predicate + expressions. Evaluates true only if the operand has an RTX code + from the set given by the argument (a comma-separated list). If the + second argument is present and nonempty, it is a sequence of digits + and/or letters which indicates the subexpression to test, using the + same syntax as genextract/genrecog's location strings: 0-9 for + XEXP (op, n), a-z for XVECEXP (op, 0, n); each character applies to + the result of the one before it. */ +DEF_RTL_EXPR(MATCH_CODE, "match_code", "ss", RTX_MATCH) + +/* Appears only in define_predicate/define_special_predicate + expressions. The argument is a C expression to be injected at this + point in the predicate formula. */ +DEF_RTL_EXPR(MATCH_TEST, "match_test", "s", RTX_MATCH) + +/* Insn (and related) definitions. */ + +/* Definition of the pattern for one kind of instruction. + Operand: + 0: names this instruction. + If the name is the null string, the instruction is in the + machine description just to be recognized, and will never be emitted by + the tree to rtl expander. + 1: is the pattern. + 2: is a string which is a C expression + giving an additional condition for recognizing this pattern. + A null string means no extra condition. + 3: is the action to execute if this pattern is matched. + If this assembler code template starts with a * then it is a fragment of + C code to run to decide on a template to use. Otherwise, it is the + template to use. + 4: optionally, a vector of attributes for this insn. + */ +DEF_RTL_EXPR(DEFINE_INSN, "define_insn", "sEsTV", RTX_EXTRA) + +/* Definition of a peephole optimization. + 1st operand: vector of insn patterns to match + 2nd operand: C expression that must be true + 3rd operand: template or C code to produce assembler output. + 4: optionally, a vector of attributes for this insn. + + This form is deprecated; use define_peephole2 instead. */ +DEF_RTL_EXPR(DEFINE_PEEPHOLE, "define_peephole", "EsTV", RTX_EXTRA) + +/* Definition of a split operation. + 1st operand: insn pattern to match + 2nd operand: C expression that must be true + 3rd operand: vector of insn patterns to place into a SEQUENCE + 4th operand: optionally, some C code to execute before generating the + insns. This might, for example, create some RTX's and store them in + elements of `recog_data.operand' for use by the vector of + insn-patterns. + (`operands' is an alias here for `recog_data.operand'). */ +DEF_RTL_EXPR(DEFINE_SPLIT, "define_split", "EsES", RTX_EXTRA) + +/* Definition of an insn and associated split. + This is the concatenation, with a few modifications, of a define_insn + and a define_split which share the same pattern. + Operand: + 0: names this instruction. + If the name is the null string, the instruction is in the + machine description just to be recognized, and will never be emitted by + the tree to rtl expander. + 1: is the pattern. + 2: is a string which is a C expression + giving an additional condition for recognizing this pattern. + A null string means no extra condition. + 3: is the action to execute if this pattern is matched. + If this assembler code template starts with a * then it is a fragment of + C code to run to decide on a template to use. Otherwise, it is the + template to use. + 4: C expression that must be true for split. This may start with "&&" + in which case the split condition is the logical and of the insn + condition and what follows the "&&" of this operand. + 5: vector of insn patterns to place into a SEQUENCE + 6: optionally, some C code to execute before generating the + insns. This might, for example, create some RTX's and store them in + elements of `recog_data.operand' for use by the vector of + insn-patterns. + (`operands' is an alias here for `recog_data.operand'). + 7: optionally, a vector of attributes for this insn. */ +DEF_RTL_EXPR(DEFINE_INSN_AND_SPLIT, "define_insn_and_split", "sEsTsESV", RTX_EXTRA) + +/* Definition of an RTL peephole operation. + Follows the same arguments as define_split. */ +DEF_RTL_EXPR(DEFINE_PEEPHOLE2, "define_peephole2", "EsES", RTX_EXTRA) + +/* Define how to generate multiple insns for a standard insn name. + 1st operand: the insn name. + 2nd operand: vector of insn-patterns. + Use match_operand to substitute an element of `recog_data.operand'. + 3rd operand: C expression that must be true for this to be available. + This may not test any operands. + 4th operand: Extra C code to execute before generating the insns. + This might, for example, create some RTX's and store them in + elements of `recog_data.operand' for use by the vector of + insn-patterns. + (`operands' is an alias here for `recog_data.operand'). */ +DEF_RTL_EXPR(DEFINE_EXPAND, "define_expand", "sEss", RTX_EXTRA) + +/* Define a requirement for delay slots. + 1st operand: Condition involving insn attributes that, if true, + indicates that the insn requires the number of delay slots + shown. + 2nd operand: Vector whose length is the three times the number of delay + slots required. + Each entry gives three conditions, each involving attributes. + The first must be true for an insn to occupy that delay slot + location. The second is true for all insns that can be + annulled if the branch is true and the third is true for all + insns that can be annulled if the branch is false. + + Multiple DEFINE_DELAYs may be present. They indicate differing + requirements for delay slots. */ +DEF_RTL_EXPR(DEFINE_DELAY, "define_delay", "eE", RTX_EXTRA) + +/* Define attribute computation for `asm' instructions. */ +DEF_RTL_EXPR(DEFINE_ASM_ATTRIBUTES, "define_asm_attributes", "V", RTX_EXTRA) + +/* Definition of a conditional execution meta operation. Automatically + generates new instances of DEFINE_INSN, selected by having attribute + "predicable" true. The new pattern will contain a COND_EXEC and the + predicate at top-level. + + Operand: + 0: The predicate pattern. The top-level form should match a + relational operator. Operands should have only one alternative. + 1: A C expression giving an additional condition for recognizing + the generated pattern. + 2: A template or C code to produce assembler output. */ +DEF_RTL_EXPR(DEFINE_COND_EXEC, "define_cond_exec", "Ess", RTX_EXTRA) + +/* Definition of an operand predicate. The difference between + DEFINE_PREDICATE and DEFINE_SPECIAL_PREDICATE is that genrecog will + not warn about a match_operand with no mode if it has a predicate + defined with DEFINE_SPECIAL_PREDICATE. + + Operand: + 0: The name of the predicate. + 1: A boolean expression which computes whether or not the predicate + matches. This expression can use IOR, AND, NOT, MATCH_OPERAND, + MATCH_CODE, and MATCH_TEST. It must be specific enough that genrecog + can calculate the set of RTX codes that can possibly match. + 2: A C function body which must return true for the predicate to match. + Optional. Use this when the test is too complicated to fit into a + match_test expression. */ +DEF_RTL_EXPR(DEFINE_PREDICATE, "define_predicate", "ses", RTX_EXTRA) +DEF_RTL_EXPR(DEFINE_SPECIAL_PREDICATE, "define_special_predicate", "ses", RTX_EXTRA) + +/* Definition of a register operand constraint. This simply maps the + constraint string to a register class. + + Operand: + 0: The name of the constraint (often, but not always, a single letter). + 1: A C expression which evaluates to the appropriate register class for + this constraint. If this is not just a constant, it should look only + at -m switches and the like. + 2: A docstring for this constraint, in Texinfo syntax; not currently + used, in future will be incorporated into the manual's list of + machine-specific operand constraints. */ +DEF_RTL_EXPR(DEFINE_REGISTER_CONSTRAINT, "define_register_constraint", "sss", RTX_EXTRA) + +/* Definition of a non-register operand constraint. These look at the + operand and decide whether it fits the constraint. + + DEFINE_CONSTRAINT gets no special treatment if it fails to match. + It is appropriate for constant-only constraints, and most others. + + DEFINE_MEMORY_CONSTRAINT tells reload that this constraint can be made + to match, if it doesn't already, by converting the operand to the form + (mem (reg X)) where X is a base register. It is suitable for constraints + that describe a subset of all memory references. + + DEFINE_ADDRESS_CONSTRAINT tells reload that this constraint can be made + to match, if it doesn't already, by converting the operand to the form + (reg X) where X is a base register. It is suitable for constraints that + describe a subset of all address references. + + When in doubt, use plain DEFINE_CONSTRAINT. + + Operand: + 0: The name of the constraint (often, but not always, a single letter). + 1: A docstring for this constraint, in Texinfo syntax; not currently + used, in future will be incorporated into the manual's list of + machine-specific operand constraints. + 2: A boolean expression which computes whether or not the constraint + matches. It should follow the same rules as a define_predicate + expression, including the bit about specifying the set of RTX codes + that could possibly match. MATCH_TEST subexpressions may make use of + these variables: + `op' - the RTL object defining the operand. + `mode' - the mode of `op'. + `ival' - INTVAL(op), if op is a CONST_INT. + `hval' - CONST_DOUBLE_HIGH(op), if op is an integer CONST_DOUBLE. + `lval' - CONST_DOUBLE_LOW(op), if op is an integer CONST_DOUBLE. + `rval' - CONST_DOUBLE_REAL_VALUE(op), if op is a floating-point + CONST_DOUBLE. + Do not use ival/hval/lval/rval if op is not the appropriate kind of + RTL object. */ +DEF_RTL_EXPR(DEFINE_CONSTRAINT, "define_constraint", "sse", RTX_EXTRA) +DEF_RTL_EXPR(DEFINE_MEMORY_CONSTRAINT, "define_memory_constraint", "sse", RTX_EXTRA) +DEF_RTL_EXPR(DEFINE_ADDRESS_CONSTRAINT, "define_address_constraint", "sse", RTX_EXTRA) + + +/* Constructions for CPU pipeline description described by NDFAs. */ + +/* (define_cpu_unit string [string]) describes cpu functional + units (separated by comma). + + 1st operand: Names of cpu functional units. + 2nd operand: Name of automaton (see comments for DEFINE_AUTOMATON). + + All define_reservations, define_cpu_units, and + define_query_cpu_units should have unique names which may not be + "nothing". */ +DEF_RTL_EXPR(DEFINE_CPU_UNIT, "define_cpu_unit", "sS", RTX_EXTRA) + +/* (define_query_cpu_unit string [string]) describes cpu functional + units analogously to define_cpu_unit. The reservation of such + units can be queried for automaton state. */ +DEF_RTL_EXPR(DEFINE_QUERY_CPU_UNIT, "define_query_cpu_unit", "sS", RTX_EXTRA) + +/* (exclusion_set string string) means that each CPU functional unit + in the first string can not be reserved simultaneously with any + unit whose name is in the second string and vise versa. CPU units + in the string are separated by commas. For example, it is useful + for description CPU with fully pipelined floating point functional + unit which can execute simultaneously only single floating point + insns or only double floating point insns. All CPU functional + units in a set should belong to the same automaton. */ +DEF_RTL_EXPR(EXCLUSION_SET, "exclusion_set", "ss", RTX_EXTRA) + +/* (presence_set string string) means that each CPU functional unit in + the first string can not be reserved unless at least one of pattern + of units whose names are in the second string is reserved. This is + an asymmetric relation. CPU units or unit patterns in the strings + are separated by commas. Pattern is one unit name or unit names + separated by white-spaces. + + For example, it is useful for description that slot1 is reserved + after slot0 reservation for a VLIW processor. We could describe it + by the following construction + + (presence_set "slot1" "slot0") + + Or slot1 is reserved only after slot0 and unit b0 reservation. In + this case we could write + + (presence_set "slot1" "slot0 b0") + + All CPU functional units in a set should belong to the same + automaton. */ +DEF_RTL_EXPR(PRESENCE_SET, "presence_set", "ss", RTX_EXTRA) + +/* (final_presence_set string string) is analogous to `presence_set'. + The difference between them is when checking is done. When an + instruction is issued in given automaton state reflecting all + current and planned unit reservations, the automaton state is + changed. The first state is a source state, the second one is a + result state. Checking for `presence_set' is done on the source + state reservation, checking for `final_presence_set' is done on the + result reservation. This construction is useful to describe a + reservation which is actually two subsequent reservations. For + example, if we use + + (presence_set "slot1" "slot0") + + the following insn will be never issued (because slot1 requires + slot0 which is absent in the source state). + + (define_reservation "insn_and_nop" "slot0 + slot1") + + but it can be issued if we use analogous `final_presence_set'. */ +DEF_RTL_EXPR(FINAL_PRESENCE_SET, "final_presence_set", "ss", RTX_EXTRA) + +/* (absence_set string string) means that each CPU functional unit in + the first string can be reserved only if each pattern of units + whose names are in the second string is not reserved. This is an + asymmetric relation (actually exclusion set is analogous to this + one but it is symmetric). CPU units or unit patterns in the string + are separated by commas. Pattern is one unit name or unit names + separated by white-spaces. + + For example, it is useful for description that slot0 can not be + reserved after slot1 or slot2 reservation for a VLIW processor. We + could describe it by the following construction + + (absence_set "slot2" "slot0, slot1") + + Or slot2 can not be reserved if slot0 and unit b0 are reserved or + slot1 and unit b1 are reserved . In this case we could write + + (absence_set "slot2" "slot0 b0, slot1 b1") + + All CPU functional units in a set should to belong the same + automaton. */ +DEF_RTL_EXPR(ABSENCE_SET, "absence_set", "ss", RTX_EXTRA) + +/* (final_absence_set string string) is analogous to `absence_set' but + checking is done on the result (state) reservation. See comments + for `final_presence_set'. */ +DEF_RTL_EXPR(FINAL_ABSENCE_SET, "final_absence_set", "ss", RTX_EXTRA) + +/* (define_bypass number out_insn_names in_insn_names) names bypass + with given latency (the first number) from insns given by the first + string (see define_insn_reservation) into insns given by the second + string. Insn names in the strings are separated by commas. The + third operand is optional name of function which is additional + guard for the bypass. The function will get the two insns as + parameters. If the function returns zero the bypass will be + ignored for this case. Additional guard is necessary to recognize + complicated bypasses, e.g. when consumer is load address. If there + are more one bypass with the same output and input insns, the + chosen bypass is the first bypass with a guard in description whose + guard function returns nonzero. If there is no such bypass, then + bypass without the guard function is chosen. */ +DEF_RTL_EXPR(DEFINE_BYPASS, "define_bypass", "issS", RTX_EXTRA) + +/* (define_automaton string) describes names of automata generated and + used for pipeline hazards recognition. The names are separated by + comma. Actually it is possibly to generate the single automaton + but unfortunately it can be very large. If we use more one + automata, the summary size of the automata usually is less than the + single one. The automaton name is used in define_cpu_unit and + define_query_cpu_unit. All automata should have unique names. */ +DEF_RTL_EXPR(DEFINE_AUTOMATON, "define_automaton", "s", RTX_EXTRA) + +/* (automata_option string) describes option for generation of + automata. Currently there are the following options: + + o "no-minimization" which makes no minimization of automata. This + is only worth to do when we are debugging the description and + need to look more accurately at reservations of states. + + o "time" which means printing additional time statistics about + generation of automata. + + o "v" which means generation of file describing the result + automata. The file has suffix `.dfa' and can be used for the + description verification and debugging. + + o "w" which means generation of warning instead of error for + non-critical errors. + + o "ndfa" which makes nondeterministic finite state automata. + + o "progress" which means output of a progress bar showing how many + states were generated so far for automaton being processed. */ +DEF_RTL_EXPR(AUTOMATA_OPTION, "automata_option", "s", RTX_EXTRA) + +/* (define_reservation string string) names reservation (the first + string) of cpu functional units (the 2nd string). Sometimes unit + reservations for different insns contain common parts. In such + case, you can describe common part and use its name (the 1st + parameter) in regular expression in define_insn_reservation. All + define_reservations, define_cpu_units, and define_query_cpu_units + should have unique names which may not be "nothing". */ +DEF_RTL_EXPR(DEFINE_RESERVATION, "define_reservation", "ss", RTX_EXTRA) + +/* (define_insn_reservation name default_latency condition regexpr) + describes reservation of cpu functional units (the 3nd operand) for + instruction which is selected by the condition (the 2nd parameter). + The first parameter is used for output of debugging information. + The reservations are described by a regular expression according + the following syntax: + + regexp = regexp "," oneof + | oneof + + oneof = oneof "|" allof + | allof + + allof = allof "+" repeat + | repeat + + repeat = element "*" number + | element + + element = cpu_function_unit_name + | reservation_name + | result_name + | "nothing" + | "(" regexp ")" + + 1. "," is used for describing start of the next cycle in + reservation. + + 2. "|" is used for describing the reservation described by the + first regular expression *or* the reservation described by the + second regular expression *or* etc. + + 3. "+" is used for describing the reservation described by the + first regular expression *and* the reservation described by the + second regular expression *and* etc. + + 4. "*" is used for convenience and simply means sequence in + which the regular expression are repeated NUMBER times with + cycle advancing (see ","). + + 5. cpu functional unit name which means its reservation. + + 6. reservation name -- see define_reservation. + + 7. string "nothing" means no units reservation. */ + +DEF_RTL_EXPR(DEFINE_INSN_RESERVATION, "define_insn_reservation", "sies", RTX_EXTRA) + +/* Expressions used for insn attributes. */ + +/* Definition of an insn attribute. + 1st operand: name of the attribute + 2nd operand: comma-separated list of possible attribute values + 3rd operand: expression for the default value of the attribute. */ +DEF_RTL_EXPR(DEFINE_ATTR, "define_attr", "sse", RTX_EXTRA) + +/* Definition of an insn attribute that uses an existing enumerated type. + 1st operand: name of the attribute + 2nd operand: the name of the enumerated type + 3rd operand: expression for the default value of the attribute. */ +DEF_RTL_EXPR(DEFINE_ENUM_ATTR, "define_enum_attr", "sse", RTX_EXTRA) + +/* Marker for the name of an attribute. */ +DEF_RTL_EXPR(ATTR, "attr", "s", RTX_EXTRA) + +/* For use in the last (optional) operand of DEFINE_INSN or DEFINE_PEEPHOLE and + in DEFINE_ASM_INSN to specify an attribute to assign to insns matching that + pattern. + + (set_attr "name" "value") is equivalent to + (set (attr "name") (const_string "value")) */ +DEF_RTL_EXPR(SET_ATTR, "set_attr", "ss", RTX_EXTRA) + +/* In the last operand of DEFINE_INSN and DEFINE_PEEPHOLE, this can be used to + specify that attribute values are to be assigned according to the + alternative matched. + + The following three expressions are equivalent: + + (set (attr "att") (cond [(eq_attrq "alternative" "1") (const_string "a1") + (eq_attrq "alternative" "2") (const_string "a2")] + (const_string "a3"))) + (set_attr_alternative "att" [(const_string "a1") (const_string "a2") + (const_string "a3")]) + (set_attr "att" "a1,a2,a3") + */ +DEF_RTL_EXPR(SET_ATTR_ALTERNATIVE, "set_attr_alternative", "sE", RTX_EXTRA) + +/* A conditional expression true if the value of the specified attribute of + the current insn equals the specified value. The first operand is the + attribute name and the second is the comparison value. */ +DEF_RTL_EXPR(EQ_ATTR, "eq_attr", "ss", RTX_EXTRA) + +/* A special case of the above representing a set of alternatives. The first + operand is bitmap of the set, the second one is the default value. */ +DEF_RTL_EXPR(EQ_ATTR_ALT, "eq_attr_alt", "ii", RTX_EXTRA) + +/* A conditional expression which is true if the specified flag is + true for the insn being scheduled in reorg. + + genattr.c defines the following flags which can be tested by + (attr_flag "foo") expressions in eligible_for_delay. + + forward, backward, very_likely, likely, very_unlikely, and unlikely. */ + +DEF_RTL_EXPR (ATTR_FLAG, "attr_flag", "s", RTX_EXTRA) + +/* General conditional. The first operand is a vector composed of pairs of + expressions. The first element of each pair is evaluated, in turn. + The value of the conditional is the second expression of the first pair + whose first expression evaluates nonzero. If none of the expressions is + true, the second operand will be used as the value of the conditional. */ +DEF_RTL_EXPR(COND, "cond", "Ee", RTX_EXTRA) + +#endif /* GENERATOR_FILE */ + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/rtl.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/rtl.h new file mode 100644 index 0000000..0ade7bf --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/rtl.h @@ -0,0 +1,2586 @@ +/* Register Transfer Language (RTL) definitions for GCC + Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + 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/>. */ + +#ifndef GCC_RTL_H +#define GCC_RTL_H + +#include "statistics.h" +#include "machmode.h" +#include "input.h" +#include "real.h" +#include "vec.h" +#include "vecir.h" +#include "fixed-value.h" +#include "alias.h" +#include "hashtab.h" + +#undef FFS /* Some systems predefine this symbol; don't let it interfere. */ +#undef FLOAT /* Likewise. */ +#undef ABS /* Likewise. */ +#undef PC /* Likewise. */ + +/* Value used by some passes to "recognize" noop moves as valid + instructions. */ +#define NOOP_MOVE_INSN_CODE INT_MAX + +/* Register Transfer Language EXPRESSIONS CODES */ + +#define RTX_CODE enum rtx_code +enum rtx_code { + +#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM , +#include "rtl.def" /* rtl expressions are documented here */ +#undef DEF_RTL_EXPR + + LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for + NUM_RTX_CODE. + Assumes default enum value assignment. */ + +#define NUM_RTX_CODE ((int) LAST_AND_UNUSED_RTX_CODE) + /* The cast here, saves many elsewhere. */ + +/* Register Transfer Language EXPRESSIONS CODE CLASSES */ + +enum rtx_class { + /* We check bit 0-1 of some rtx class codes in the predicates below. */ + + /* Bit 0 = comparison if 0, arithmetic is 1 + Bit 1 = 1 if commutative. */ + RTX_COMPARE, /* 0 */ + RTX_COMM_COMPARE, + RTX_BIN_ARITH, + RTX_COMM_ARITH, + + /* Must follow the four preceding values. */ + RTX_UNARY, /* 4 */ + + RTX_EXTRA, + RTX_MATCH, + RTX_INSN, + + /* Bit 0 = 1 if constant. */ + RTX_OBJ, /* 8 */ + RTX_CONST_OBJ, + + RTX_TERNARY, + RTX_BITFIELD_OPS, + RTX_AUTOINC +}; + +#define RTX_OBJ_MASK (~1) +#define RTX_OBJ_RESULT (RTX_OBJ & RTX_OBJ_MASK) +#define RTX_COMPARE_MASK (~1) +#define RTX_COMPARE_RESULT (RTX_COMPARE & RTX_COMPARE_MASK) +#define RTX_ARITHMETIC_MASK (~1) +#define RTX_ARITHMETIC_RESULT (RTX_COMM_ARITH & RTX_ARITHMETIC_MASK) +#define RTX_BINARY_MASK (~3) +#define RTX_BINARY_RESULT (RTX_COMPARE & RTX_BINARY_MASK) +#define RTX_COMMUTATIVE_MASK (~2) +#define RTX_COMMUTATIVE_RESULT (RTX_COMM_COMPARE & RTX_COMMUTATIVE_MASK) +#define RTX_NON_COMMUTATIVE_RESULT (RTX_COMPARE & RTX_COMMUTATIVE_MASK) + +extern const unsigned char rtx_length[NUM_RTX_CODE]; +#define GET_RTX_LENGTH(CODE) (rtx_length[(int) (CODE)]) + +extern const char * const rtx_name[NUM_RTX_CODE]; +#define GET_RTX_NAME(CODE) (rtx_name[(int) (CODE)]) + +extern const char * const rtx_format[NUM_RTX_CODE]; +#define GET_RTX_FORMAT(CODE) (rtx_format[(int) (CODE)]) + +extern const enum rtx_class rtx_class[NUM_RTX_CODE]; +#define GET_RTX_CLASS(CODE) (rtx_class[(int) (CODE)]) + +extern const unsigned char rtx_code_size[NUM_RTX_CODE]; +extern const unsigned char rtx_next[NUM_RTX_CODE]; + +/* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label + relative to which the offsets are calculated, as explained in rtl.def. */ +typedef struct +{ + /* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */ + unsigned min_align: 8; + /* Flags: */ + unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC. */ + unsigned min_after_vec: 1; /* minimum address target label is + after the ADDR_DIFF_VEC. */ + unsigned max_after_vec: 1; /* maximum address target label is + after the ADDR_DIFF_VEC. */ + unsigned min_after_base: 1; /* minimum address target label is + after BASE. */ + unsigned max_after_base: 1; /* maximum address target label is + after BASE. */ + /* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */ + unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */ + unsigned : 2; + unsigned scale : 8; +} addr_diff_vec_flags; + +/* Structure used to describe the attributes of a MEM. These are hashed + so MEMs that the same attributes share a data structure. This means + they cannot be modified in place. If any element is nonzero, it means + the value of the corresponding attribute is unknown. */ +/* ALIGN and SIZE are the alignment and size of the MEM itself, + while EXPR can describe a larger underlying object, which might have a + stricter alignment; OFFSET is the offset of the MEM within that object. */ +typedef struct GTY(()) mem_attrs +{ + tree expr; /* expr corresponding to MEM. */ + rtx offset; /* Offset from start of DECL, as CONST_INT. */ + rtx size; /* Size in bytes, as a CONST_INT. */ + alias_set_type alias; /* Memory alias set. */ + unsigned int align; /* Alignment of MEM in bits. */ + unsigned char addrspace; /* Address space (0 for generic). */ +} mem_attrs; + +/* Structure used to describe the attributes of a REG in similar way as + mem_attrs does for MEM above. Note that the OFFSET field is calculated + in the same way as for mem_attrs, rather than in the same way as a + SUBREG_BYTE. For example, if a big-endian target stores a byte + object in the low part of a 4-byte register, the OFFSET field + will be -3 rather than 0. */ + +typedef struct GTY(()) reg_attrs { + tree decl; /* decl corresponding to REG. */ + HOST_WIDE_INT offset; /* Offset from start of DECL. */ +} reg_attrs; + +/* Common union for an element of an rtx. */ + +union rtunion_def +{ + int rt_int; + unsigned int rt_uint; + const char *rt_str; + rtx rt_rtx; + rtvec rt_rtvec; + enum machine_mode rt_type; + addr_diff_vec_flags rt_addr_diff_vec_flags; + struct cselib_val_struct *rt_cselib; + tree rt_tree; + struct basic_block_def *rt_bb; + mem_attrs *rt_mem; + reg_attrs *rt_reg; + struct constant_descriptor_rtx *rt_constant; +}; +typedef union rtunion_def rtunion; + +/* This structure remembers the position of a SYMBOL_REF within an + object_block structure. A SYMBOL_REF only provides this information + if SYMBOL_REF_HAS_BLOCK_INFO_P is true. */ +struct GTY(()) block_symbol { + /* The usual SYMBOL_REF fields. */ + rtunion GTY ((skip)) fld[3]; + + /* The block that contains this object. */ + struct object_block *block; + + /* The offset of this object from the start of its block. It is negative + if the symbol has not yet been assigned an offset. */ + HOST_WIDE_INT offset; +}; + +/* Describes a group of objects that are to be placed together in such + a way that their relative positions are known. */ +struct GTY(()) object_block { + /* The section in which these objects should be placed. */ + section *sect; + + /* The alignment of the first object, measured in bits. */ + unsigned int alignment; + + /* The total size of the objects, measured in bytes. */ + HOST_WIDE_INT size; + + /* The SYMBOL_REFs for each object. The vector is sorted in + order of increasing offset and the following conditions will + hold for each element X: + + SYMBOL_REF_HAS_BLOCK_INFO_P (X) + !SYMBOL_REF_ANCHOR_P (X) + SYMBOL_REF_BLOCK (X) == [address of this structure] + SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */ + VEC(rtx,gc) *objects; + + /* All the anchor SYMBOL_REFs used to address these objects, sorted + in order of increasing offset, and then increasing TLS model. + The following conditions will hold for each element X in this vector: + + SYMBOL_REF_HAS_BLOCK_INFO_P (X) + SYMBOL_REF_ANCHOR_P (X) + SYMBOL_REF_BLOCK (X) == [address of this structure] + SYMBOL_REF_BLOCK_OFFSET (X) >= 0. */ + VEC(rtx,gc) *anchors; +}; + +/* RTL expression ("rtx"). */ + +struct GTY((chain_next ("RTX_NEXT (&%h)"), + chain_prev ("RTX_PREV (&%h)"), variable_size)) rtx_def { + /* The kind of expression this is. */ + ENUM_BITFIELD(rtx_code) code: 16; + + /* The kind of value the expression has. */ + ENUM_BITFIELD(machine_mode) mode : 8; + + /* 1 in a MEM if we should keep the alias set for this mem unchanged + when we access a component. + 1 in a CALL_INSN if it is a sibling call. + 1 in a SET that is for a return. + In a CODE_LABEL, part of the two-bit alternate entry field. */ + unsigned int jump : 1; + /* In a CODE_LABEL, part of the two-bit alternate entry field. + 1 in a MEM if it cannot trap. + 1 in a CALL_INSN logically equivalent to + ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. */ + unsigned int call : 1; + /* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere. + 1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P. + 1 in a SYMBOL_REF if it addresses something in the per-function + constants pool. + 1 in a CALL_INSN logically equivalent to ECF_CONST and TREE_READONLY. + 1 in a NOTE, or EXPR_LIST for a const call. + 1 in a JUMP_INSN, CALL_INSN, or INSN of an annulling branch. */ + unsigned int unchanging : 1; + /* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile. + 1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE + if it has been deleted. + 1 in a REG expression if corresponds to a variable declared by the user, + 0 for an internally generated temporary. + 1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P. + 1 in a LABEL_REF, REG_LABEL_TARGET or REG_LABEL_OPERAND note for a + non-local label. + In a SYMBOL_REF, this flag is used for machine-specific purposes. + In a PREFETCH, this flag indicates that it should be considered a scheduling + barrier. */ + unsigned int volatil : 1; + /* 1 in a MEM referring to a field of an aggregate. + 0 if the MEM was a variable or the result of a * operator in C; + 1 if it was the result of a . or -> operator (on a struct) in C. + 1 in a REG if the register is used only in exit code a loop. + 1 in a SUBREG expression if was generated from a variable with a + promoted mode. + 1 in a CODE_LABEL if the label is used for nonlocal gotos + and must not be deleted even if its count is zero. + 1 in an INSN, JUMP_INSN or CALL_INSN if this insn must be scheduled + together with the preceding insn. Valid only within sched. + 1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and + from the target of a branch. Valid from reorg until end of compilation; + cleared before used. */ + unsigned int in_struct : 1; + /* At the end of RTL generation, 1 if this rtx is used. This is used for + copying shared structure. See `unshare_all_rtl'. + In a REG, this is not needed for that purpose, and used instead + in `leaf_renumber_regs_insn'. + 1 in a SYMBOL_REF, means that emit_library_call + has used it as the function. */ + unsigned int used : 1; + /* 1 in an INSN or a SET if this rtx is related to the call frame, + either changing how we compute the frame address or saving and + restoring registers in the prologue and epilogue. + 1 in a REG or MEM if it is a pointer. + 1 in a SYMBOL_REF if it addresses something in the per-function + constant string pool. */ + unsigned frame_related : 1; + /* 1 in a REG or PARALLEL that is the current function's return value. + 1 in a MEM if it refers to a scalar. + 1 in a SYMBOL_REF for a weak symbol. + 1 in a CALL_INSN logically equivalent to ECF_PURE and DECL_PURE_P. */ + unsigned return_val : 1; + + /* The first element of the operands of this rtx. + The number of operands and their types are controlled + by the `code' field, according to rtl.def. */ + union u { + rtunion fld[1]; + HOST_WIDE_INT hwint[1]; + struct block_symbol block_sym; + struct real_value rv; + struct fixed_value fv; + } GTY ((special ("rtx_def"), desc ("GET_CODE (&%0)"))) u; +}; + +/* The size in bytes of an rtx header (code, mode and flags). */ +#define RTX_HDR_SIZE offsetof (struct rtx_def, u) + +/* The size in bytes of an rtx with code CODE. */ +#define RTX_CODE_SIZE(CODE) rtx_code_size[CODE] + +#define NULL_RTX (rtx) 0 + +/* The "next" and "previous" RTX, relative to this one. */ + +#define RTX_NEXT(X) (rtx_next[GET_CODE (X)] == 0 ? NULL \ + : *(rtx *)(((char *)X) + rtx_next[GET_CODE (X)])) + +/* FIXME: the "NEXT_INSN (PREV_INSN (X)) == X" condition shouldn't be needed. + */ +#define RTX_PREV(X) ((INSN_P (X) \ + || NOTE_P (X) \ + || BARRIER_P (X) \ + || LABEL_P (X)) \ + && PREV_INSN (X) != NULL \ + && NEXT_INSN (PREV_INSN (X)) == X \ + ? PREV_INSN (X) : NULL) + +/* Define macros to access the `code' field of the rtx. */ + +#define GET_CODE(RTX) ((enum rtx_code) (RTX)->code) +#define PUT_CODE(RTX, CODE) ((RTX)->code = (CODE)) + +#define GET_MODE(RTX) ((enum machine_mode) (RTX)->mode) +#define PUT_MODE(RTX, MODE) ((RTX)->mode = (MODE)) + +/* RTL vector. These appear inside RTX's when there is a need + for a variable number of things. The principle use is inside + PARALLEL expressions. */ + +struct GTY((variable_size)) rtvec_def { + int num_elem; /* number of elements */ + rtx GTY ((length ("%h.num_elem"))) elem[1]; +}; + +#define NULL_RTVEC (rtvec) 0 + +#define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem) +#define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (NUM)) + +/* Predicate yielding nonzero iff X is an rtx for a register. */ +#define REG_P(X) (GET_CODE (X) == REG) + +/* Predicate yielding nonzero iff X is an rtx for a memory location. */ +#define MEM_P(X) (GET_CODE (X) == MEM) + +/* Predicate yielding nonzero iff X is an rtx for a constant integer. */ +#define CONST_INT_P(X) (GET_CODE (X) == CONST_INT) + +/* Predicate yielding true iff X is an rtx for a double-int + or floating point constant. */ +#define CONST_DOUBLE_P(X) (GET_CODE (X) == CONST_DOUBLE) + +/* Predicate yielding nonzero iff X is a label insn. */ +#define LABEL_P(X) (GET_CODE (X) == CODE_LABEL) + +/* Predicate yielding nonzero iff X is a jump insn. */ +#define JUMP_P(X) (GET_CODE (X) == JUMP_INSN) + +/* Predicate yielding nonzero iff X is a call insn. */ +#define CALL_P(X) (GET_CODE (X) == CALL_INSN) + +/* Predicate yielding nonzero iff X is an insn that cannot jump. */ +#define NONJUMP_INSN_P(X) (GET_CODE (X) == INSN) + +/* Predicate yielding nonzero iff X is a debug note/insn. */ +#define DEBUG_INSN_P(X) (GET_CODE (X) == DEBUG_INSN) + +/* Predicate yielding nonzero iff X is an insn that is not a debug insn. */ +#define NONDEBUG_INSN_P(X) (INSN_P (X) && !DEBUG_INSN_P (X)) + +/* Nonzero if DEBUG_INSN_P may possibly hold. */ +#define MAY_HAVE_DEBUG_INSNS MAY_HAVE_DEBUG_STMTS + +/* Predicate yielding nonzero iff X is a real insn. */ +#define INSN_P(X) \ + (NONJUMP_INSN_P (X) || DEBUG_INSN_P (X) || JUMP_P (X) || CALL_P (X)) + +/* Predicate yielding nonzero iff X is a note insn. */ +#define NOTE_P(X) (GET_CODE (X) == NOTE) + +/* Predicate yielding nonzero iff X is a barrier insn. */ +#define BARRIER_P(X) (GET_CODE (X) == BARRIER) + +/* Predicate yielding nonzero iff X is a data for a jump table. */ +#define JUMP_TABLE_DATA_P(INSN) \ + (JUMP_P (INSN) && (GET_CODE (PATTERN (INSN)) == ADDR_VEC || \ + GET_CODE (PATTERN (INSN)) == ADDR_DIFF_VEC)) + +/* 1 if X is a unary operator. */ + +#define UNARY_P(X) \ + (GET_RTX_CLASS (GET_CODE (X)) == RTX_UNARY) + +/* 1 if X is a binary operator. */ + +#define BINARY_P(X) \ + ((GET_RTX_CLASS (GET_CODE (X)) & RTX_BINARY_MASK) == RTX_BINARY_RESULT) + +/* 1 if X is an arithmetic operator. */ + +#define ARITHMETIC_P(X) \ + ((GET_RTX_CLASS (GET_CODE (X)) & RTX_ARITHMETIC_MASK) \ + == RTX_ARITHMETIC_RESULT) + +/* 1 if X is an arithmetic operator. */ + +#define COMMUTATIVE_ARITH_P(X) \ + (GET_RTX_CLASS (GET_CODE (X)) == RTX_COMM_ARITH) + +/* 1 if X is a commutative arithmetic operator or a comparison operator. + These two are sometimes selected together because it is possible to + swap the two operands. */ + +#define SWAPPABLE_OPERANDS_P(X) \ + ((1 << GET_RTX_CLASS (GET_CODE (X))) \ + & ((1 << RTX_COMM_ARITH) | (1 << RTX_COMM_COMPARE) \ + | (1 << RTX_COMPARE))) + +/* 1 if X is a non-commutative operator. */ + +#define NON_COMMUTATIVE_P(X) \ + ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK) \ + == RTX_NON_COMMUTATIVE_RESULT) + +/* 1 if X is a commutative operator on integers. */ + +#define COMMUTATIVE_P(X) \ + ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK) \ + == RTX_COMMUTATIVE_RESULT) + +/* 1 if X is a relational operator. */ + +#define COMPARISON_P(X) \ + ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMPARE_MASK) == RTX_COMPARE_RESULT) + +/* 1 if X is a constant value that is an integer. */ + +#define CONSTANT_P(X) \ + (GET_RTX_CLASS (GET_CODE (X)) == RTX_CONST_OBJ) + +/* 1 if X can be used to represent an object. */ +#define OBJECT_P(X) \ + ((GET_RTX_CLASS (GET_CODE (X)) & RTX_OBJ_MASK) == RTX_OBJ_RESULT) + +/* General accessor macros for accessing the fields of an rtx. */ + +#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) +/* The bit with a star outside the statement expr and an & inside is + so that N can be evaluated only once. */ +#define RTL_CHECK1(RTX, N, C1) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ + const enum rtx_code _code = GET_CODE (_rtx); \ + if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ + rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ + __FUNCTION__); \ + if (GET_RTX_FORMAT(_code)[_n] != C1) \ + rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtx->u.fld[_n]; })) + +#define RTL_CHECK2(RTX, N, C1, C2) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ + const enum rtx_code _code = GET_CODE (_rtx); \ + if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ + rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ + __FUNCTION__); \ + if (GET_RTX_FORMAT(_code)[_n] != C1 \ + && GET_RTX_FORMAT(_code)[_n] != C2) \ + rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtx->u.fld[_n]; })) + +#define RTL_CHECKC1(RTX, N, C) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ + if (GET_CODE (_rtx) != (C)) \ + rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtx->u.fld[_n]; })) + +#define RTL_CHECKC2(RTX, N, C1, C2) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ + const enum rtx_code _code = GET_CODE (_rtx); \ + if (_code != (C1) && _code != (C2)) \ + rtl_check_failed_code2 (_rtx, (C1), (C2), __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtx->u.fld[_n]; })) + +#define RTVEC_ELT(RTVEC, I) __extension__ \ +(*({ __typeof (RTVEC) const _rtvec = (RTVEC); const int _i = (I); \ + if (_i < 0 || _i >= GET_NUM_ELEM (_rtvec)) \ + rtvec_check_failed_bounds (_rtvec, _i, __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtvec->elem[_i]; })) + +#define XWINT(RTX, N) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N); \ + const enum rtx_code _code = GET_CODE (_rtx); \ + if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ + rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ + __FUNCTION__); \ + if (GET_RTX_FORMAT(_code)[_n] != 'w') \ + rtl_check_failed_type1 (_rtx, _n, 'w', __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtx->u.hwint[_n]; })) + +#define XCWINT(RTX, N, C) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE (_rtx) != (C)) \ + rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \ + __FUNCTION__); \ + &_rtx->u.hwint[N]; })) + +#define XCMWINT(RTX, N, C, M) __extension__ \ +(*({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) != (M)) \ + rtl_check_failed_code_mode (_rtx, (C), (M), false, __FILE__, \ + __LINE__, __FUNCTION__); \ + &_rtx->u.hwint[N]; })) + +#define XCNMPRV(RTX, C, M) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) == (M)) \ + rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__, \ + __LINE__, __FUNCTION__); \ + &_rtx->u.rv; }) + +#define XCNMPFV(RTX, C, M) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) == (M)) \ + rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__, \ + __LINE__, __FUNCTION__); \ + &_rtx->u.fv; }) + +#define BLOCK_SYMBOL_CHECK(RTX) __extension__ \ +({ __typeof (RTX) const _symbol = (RTX); \ + const unsigned int flags = RTL_CHECKC1 (_symbol, 1, SYMBOL_REF).rt_int; \ + if ((flags & SYMBOL_FLAG_HAS_BLOCK_INFO) == 0) \ + rtl_check_failed_block_symbol (__FILE__, __LINE__, \ + __FUNCTION__); \ + &_symbol->u.block_sym; }) + +extern void rtl_check_failed_bounds (const_rtx, int, const char *, int, + const char *) + ATTRIBUTE_NORETURN; +extern void rtl_check_failed_type1 (const_rtx, int, int, const char *, int, + const char *) + ATTRIBUTE_NORETURN; +extern void rtl_check_failed_type2 (const_rtx, int, int, int, const char *, + int, const char *) + ATTRIBUTE_NORETURN; +extern void rtl_check_failed_code1 (const_rtx, enum rtx_code, const char *, + int, const char *) + ATTRIBUTE_NORETURN; +extern void rtl_check_failed_code2 (const_rtx, enum rtx_code, enum rtx_code, + const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void rtl_check_failed_code_mode (const_rtx, enum rtx_code, enum machine_mode, + bool, const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void rtl_check_failed_block_symbol (const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int, + const char *) + ATTRIBUTE_NORETURN; + +#else /* not ENABLE_RTL_CHECKING */ + +#define RTL_CHECK1(RTX, N, C1) ((RTX)->u.fld[N]) +#define RTL_CHECK2(RTX, N, C1, C2) ((RTX)->u.fld[N]) +#define RTL_CHECKC1(RTX, N, C) ((RTX)->u.fld[N]) +#define RTL_CHECKC2(RTX, N, C1, C2) ((RTX)->u.fld[N]) +#define RTVEC_ELT(RTVEC, I) ((RTVEC)->elem[I]) +#define XWINT(RTX, N) ((RTX)->u.hwint[N]) +#define XCWINT(RTX, N, C) ((RTX)->u.hwint[N]) +#define XCMWINT(RTX, N, C, M) ((RTX)->u.hwint[N]) +#define XCNMWINT(RTX, N, C, M) ((RTX)->u.hwint[N]) +#define XCNMPRV(RTX, C, M) (&(RTX)->u.rv) +#define XCNMPFV(RTX, C, M) (&(RTX)->u.fv) +#define BLOCK_SYMBOL_CHECK(RTX) (&(RTX)->u.block_sym) + +#endif + +/* General accessor macros for accessing the flags of an rtx. */ + +/* Access an individual rtx flag, with no checking of any kind. */ +#define RTX_FLAG(RTX, FLAG) ((RTX)->FLAG) + +#if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007) +#define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1) \ + rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2) \ + rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE(_rtx) != C3) \ + rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4) \ + rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ + && GET_CODE(_rtx) != C5) \ + rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \ + __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ + && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6) \ + rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \ + __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ + && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \ + && GET_CODE(_rtx) != C7) \ + rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +#define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) \ + __extension__ \ +({ __typeof (RTX) const _rtx = (RTX); \ + if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ + && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \ + && GET_CODE(_rtx) != C7 && GET_CODE(_rtx) != C8) \ + rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ + __FUNCTION__); \ + _rtx; }) + +extern void rtl_check_failed_flag (const char *, const_rtx, const char *, + int, const char *) + ATTRIBUTE_NORETURN + ; + +#else /* not ENABLE_RTL_FLAG_CHECKING */ + +#define RTL_FLAG_CHECK1(NAME, RTX, C1) (RTX) +#define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) (RTX) +#define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) (RTX) +#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) (RTX) +#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) (RTX) +#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) (RTX) +#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) (RTX) +#define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) (RTX) +#endif + +#define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rt_int) +#define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rt_str) +#define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rt_rtx) +#define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rt_rtvec) +#define XMODE(RTX, N) (RTL_CHECK1 (RTX, N, 'M').rt_type) +#define XTREE(RTX, N) (RTL_CHECK1 (RTX, N, 't').rt_tree) +#define XBBDEF(RTX, N) (RTL_CHECK1 (RTX, N, 'B').rt_bb) +#define XTMPL(RTX, N) (RTL_CHECK1 (RTX, N, 'T').rt_str) + +#define XVECEXP(RTX, N, M) RTVEC_ELT (XVEC (RTX, N), M) +#define XVECLEN(RTX, N) GET_NUM_ELEM (XVEC (RTX, N)) + +/* These are like XINT, etc. except that they expect a '0' field instead + of the normal type code. */ + +#define X0INT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_int) +#define X0UINT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_uint) +#define X0STR(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_str) +#define X0EXP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_rtx) +#define X0VEC(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_rtvec) +#define X0MODE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_type) +#define X0TREE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_tree) +#define X0BBDEF(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_bb) +#define X0ADVFLAGS(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_addr_diff_vec_flags) +#define X0CSELIB(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_cselib) +#define X0MEMATTR(RTX, N) (RTL_CHECKC1 (RTX, N, MEM).rt_mem) +#define X0REGATTR(RTX, N) (RTL_CHECKC1 (RTX, N, REG).rt_reg) +#define X0CONSTANT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_constant) + +/* Access a '0' field with any type. */ +#define X0ANY(RTX, N) RTL_CHECK1 (RTX, N, '0') + +#define XCINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_int) +#define XCUINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_uint) +#define XCSTR(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_str) +#define XCEXP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_rtx) +#define XCVEC(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_rtvec) +#define XCMODE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_type) +#define XCTREE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_tree) +#define XCBBDEF(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_bb) +#define XCCSELIB(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_cselib) + +#define XCVECEXP(RTX, N, M, C) RTVEC_ELT (XCVEC (RTX, N, C), M) +#define XCVECLEN(RTX, N, C) GET_NUM_ELEM (XCVEC (RTX, N, C)) + +#define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rt_rtx) + +/* ACCESS MACROS for particular fields of insns. */ + +/* Holds a unique number for each insn. + These are not necessarily sequentially increasing. */ +#define INSN_UID(INSN) XINT (INSN, 0) + +/* Chain insns together in sequence. */ +#define PREV_INSN(INSN) XEXP (INSN, 1) +#define NEXT_INSN(INSN) XEXP (INSN, 2) + +#define BLOCK_FOR_INSN(INSN) XBBDEF (INSN, 3) + +/* The body of an insn. */ +#define PATTERN(INSN) XEXP (INSN, 4) + +#define INSN_LOCATOR(INSN) XINT (INSN, 5) +/* LOCATION of an RTX if relevant. */ +#define RTL_LOCATION(X) (INSN_P (X) ? \ + locator_location (INSN_LOCATOR (X)) \ + : UNKNOWN_LOCATION) +/* LOCATION of current INSN. */ +#define CURR_INSN_LOCATION (locator_location (curr_insn_locator ())) + +/* Code number of instruction, from when it was recognized. + -1 means this instruction has not been recognized yet. */ +#define INSN_CODE(INSN) XINT (INSN, 6) + +#define RTX_FRAME_RELATED_P(RTX) \ + (RTL_FLAG_CHECK6("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN, \ + CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related) + +/* 1 if RTX is an insn that has been deleted. */ +#define INSN_DELETED_P(RTX) \ + (RTL_FLAG_CHECK7("INSN_DELETED_P", (RTX), DEBUG_INSN, INSN, \ + CALL_INSN, JUMP_INSN, \ + CODE_LABEL, BARRIER, NOTE)->volatil) + +/* 1 if RTX is a call to a const function. Built from ECF_CONST and + TREE_READONLY. */ +#define RTL_CONST_CALL_P(RTX) \ + (RTL_FLAG_CHECK1("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging) + +/* 1 if RTX is a call to a pure function. Built from ECF_PURE and + DECL_PURE_P. */ +#define RTL_PURE_CALL_P(RTX) \ + (RTL_FLAG_CHECK1("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val) + +/* 1 if RTX is a call to a const or pure function. */ +#define RTL_CONST_OR_PURE_CALL_P(RTX) \ + (RTL_CONST_CALL_P(RTX) || RTL_PURE_CALL_P(RTX)) + +/* 1 if RTX is a call to a looping const or pure function. Built from + ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. */ +#define RTL_LOOPING_CONST_OR_PURE_CALL_P(RTX) \ + (RTL_FLAG_CHECK1("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call) + +/* 1 if RTX is a call_insn for a sibling call. */ +#define SIBLING_CALL_P(RTX) \ + (RTL_FLAG_CHECK1("SIBLING_CALL_P", (RTX), CALL_INSN)->jump) + +/* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch. */ +#define INSN_ANNULLED_BRANCH_P(RTX) \ + (RTL_FLAG_CHECK3("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN, CALL_INSN, INSN)->unchanging) + +/* 1 if RTX is an insn in a delay slot and is from the target of the branch. + If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be + executed if the branch is taken. For annulled branches with this bit + clear, the insn should be executed only if the branch is not taken. */ +#define INSN_FROM_TARGET_P(RTX) \ + (RTL_FLAG_CHECK3("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, CALL_INSN)->in_struct) + +/* In an ADDR_DIFF_VEC, the flags for RTX for use by branch shortening. + See the comments for ADDR_DIFF_VEC in rtl.def. */ +#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS(RTX, 4) + +/* In a VALUE, the value cselib has assigned to RTX. + This is a "struct cselib_val_struct", see cselib.h. */ +#define CSELIB_VAL_PTR(RTX) X0CSELIB(RTX, 0) + +/* Holds a list of notes on what this insn does to various REGs. + It is a chain of EXPR_LIST rtx's, where the second operand is the + chain pointer and the first operand is the REG being described. + The mode field of the EXPR_LIST contains not a real machine mode + but a value from enum reg_note. */ +#define REG_NOTES(INSN) XEXP(INSN, 7) + +enum reg_note +{ +#define DEF_REG_NOTE(NAME) NAME, +#include "reg-notes.def" +#undef DEF_REG_NOTE + REG_NOTE_MAX +}; + +/* Define macros to extract and insert the reg-note kind in an EXPR_LIST. */ +#define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK)) +#define PUT_REG_NOTE_KIND(LINK, KIND) \ + PUT_MODE (LINK, (enum machine_mode) (KIND)) + +/* Names for REG_NOTE's in EXPR_LIST insn's. */ + +extern const char * const reg_note_name[]; +#define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int) (MODE)]) + +/* This field is only present on CALL_INSNs. It holds a chain of EXPR_LIST of + USE and CLOBBER expressions. + USE expressions list the registers filled with arguments that + are passed to the function. + CLOBBER expressions document the registers explicitly clobbered + by this CALL_INSN. + Pseudo registers can not be mentioned in this list. */ +#define CALL_INSN_FUNCTION_USAGE(INSN) XEXP(INSN, 8) + +/* The label-number of a code-label. The assembler label + is made from `L' and the label-number printed in decimal. + Label numbers are unique in a compilation. */ +#define CODE_LABEL_NUMBER(INSN) XINT (INSN, 6) + +/* In a NOTE that is a line number, this is a string for the file name that the + line is in. We use the same field to record block numbers temporarily in + NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes. (We avoid lots of casts + between ints and pointers if we use a different macro for the block number.) + */ + +/* Opaque data. */ +#define NOTE_DATA(INSN) RTL_CHECKC1 (INSN, 4, NOTE) +#define NOTE_DELETED_LABEL_NAME(INSN) XCSTR (INSN, 4, NOTE) +#define SET_INSN_DELETED(INSN) set_insn_deleted (INSN); +#define NOTE_BLOCK(INSN) XCTREE (INSN, 4, NOTE) +#define NOTE_EH_HANDLER(INSN) XCINT (INSN, 4, NOTE) +#define NOTE_BASIC_BLOCK(INSN) XCBBDEF (INSN, 4, NOTE) +#define NOTE_VAR_LOCATION(INSN) XCEXP (INSN, 4, NOTE) + +/* In a NOTE that is a line number, this is the line number. + Other kinds of NOTEs are identified by negative numbers here. */ +#define NOTE_KIND(INSN) XCINT (INSN, 5, NOTE) + +/* Nonzero if INSN is a note marking the beginning of a basic block. */ +#define NOTE_INSN_BASIC_BLOCK_P(INSN) \ + (GET_CODE (INSN) == NOTE \ + && NOTE_KIND (INSN) == NOTE_INSN_BASIC_BLOCK) + +/* Variable declaration and the location of a variable. */ +#define PAT_VAR_LOCATION_DECL(PAT) (XCTREE ((PAT), 0, VAR_LOCATION)) +#define PAT_VAR_LOCATION_LOC(PAT) (XCEXP ((PAT), 1, VAR_LOCATION)) + +/* Initialization status of the variable in the location. Status + can be unknown, uninitialized or initialized. See enumeration + type below. */ +#define PAT_VAR_LOCATION_STATUS(PAT) \ + ((enum var_init_status) (XCINT ((PAT), 2, VAR_LOCATION))) + +/* Accessors for a NOTE_INSN_VAR_LOCATION. */ +#define NOTE_VAR_LOCATION_DECL(NOTE) \ + PAT_VAR_LOCATION_DECL (NOTE_VAR_LOCATION (NOTE)) +#define NOTE_VAR_LOCATION_LOC(NOTE) \ + PAT_VAR_LOCATION_LOC (NOTE_VAR_LOCATION (NOTE)) +#define NOTE_VAR_LOCATION_STATUS(NOTE) \ + PAT_VAR_LOCATION_STATUS (NOTE_VAR_LOCATION (NOTE)) + +/* The VAR_LOCATION rtx in a DEBUG_INSN. */ +#define INSN_VAR_LOCATION(INSN) PATTERN (INSN) + +/* Accessors for a tree-expanded var location debug insn. */ +#define INSN_VAR_LOCATION_DECL(INSN) \ + PAT_VAR_LOCATION_DECL (INSN_VAR_LOCATION (INSN)) +#define INSN_VAR_LOCATION_LOC(INSN) \ + PAT_VAR_LOCATION_LOC (INSN_VAR_LOCATION (INSN)) +#define INSN_VAR_LOCATION_STATUS(INSN) \ + PAT_VAR_LOCATION_STATUS (INSN_VAR_LOCATION (INSN)) + +/* Expand to the RTL that denotes an unknown variable location in a + DEBUG_INSN. */ +#define gen_rtx_UNKNOWN_VAR_LOC() (gen_rtx_CLOBBER (VOIDmode, const0_rtx)) + +/* Determine whether X is such an unknown location. */ +#define VAR_LOC_UNKNOWN_P(X) \ + (GET_CODE (X) == CLOBBER && XEXP ((X), 0) == const0_rtx) + +/* 1 if RTX is emitted after a call, but it should take effect before + the call returns. */ +#define NOTE_DURING_CALL_P(RTX) \ + (RTL_FLAG_CHECK1("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call) + +/* DEBUG_EXPR_DECL corresponding to a DEBUG_EXPR RTX. */ +#define DEBUG_EXPR_TREE_DECL(RTX) XCTREE (RTX, 0, DEBUG_EXPR) + +/* VAR_DECL/PARM_DECL DEBUG_IMPLICIT_PTR takes address of. */ +#define DEBUG_IMPLICIT_PTR_DECL(RTX) XCTREE (RTX, 0, DEBUG_IMPLICIT_PTR) + +/* 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 +}; + +/* Codes that appear in the NOTE_KIND field for kinds of notes + that are not line numbers. These codes are all negative. + + Notice that we do not try to use zero here for any of + the special note codes because sometimes the source line + actually can be zero! This happens (for example) when we + are generating code for the per-translation-unit constructor + and destructor routines for some C++ translation unit. */ + +enum insn_note +{ +#define DEF_INSN_NOTE(NAME) NAME, +#include "insn-notes.def" +#undef DEF_INSN_NOTE + + NOTE_INSN_MAX +}; + +/* Names for NOTE insn's other than line numbers. */ + +extern const char * const note_insn_name[NOTE_INSN_MAX]; +#define GET_NOTE_INSN_NAME(NOTE_CODE) \ + (note_insn_name[(NOTE_CODE)]) + +/* The name of a label, in case it corresponds to an explicit label + in the input source code. */ +#define LABEL_NAME(RTX) XCSTR (RTX, 7, CODE_LABEL) + +/* In jump.c, each label contains a count of the number + of LABEL_REFs that point at it, so unused labels can be deleted. */ +#define LABEL_NUSES(RTX) XCINT (RTX, 5, CODE_LABEL) + +/* Labels carry a two-bit field composed of the ->jump and ->call + bits. This field indicates whether the label is an alternate + entry point, and if so, what kind. */ +enum label_kind +{ + LABEL_NORMAL = 0, /* ordinary label */ + LABEL_STATIC_ENTRY, /* alternate entry point, not exported */ + LABEL_GLOBAL_ENTRY, /* alternate entry point, exported */ + LABEL_WEAK_ENTRY /* alternate entry point, exported as weak symbol */ +}; + +#if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION > 2007) + +/* Retrieve the kind of LABEL. */ +#define LABEL_KIND(LABEL) __extension__ \ +({ __typeof (LABEL) const _label = (LABEL); \ + if (GET_CODE (_label) != CODE_LABEL) \ + rtl_check_failed_flag ("LABEL_KIND", _label, __FILE__, __LINE__, \ + __FUNCTION__); \ + (enum label_kind) ((_label->jump << 1) | _label->call); }) + +/* Set the kind of LABEL. */ +#define SET_LABEL_KIND(LABEL, KIND) do { \ + __typeof (LABEL) const _label = (LABEL); \ + const unsigned int _kind = (KIND); \ + if (GET_CODE (_label) != CODE_LABEL) \ + rtl_check_failed_flag ("SET_LABEL_KIND", _label, __FILE__, __LINE__, \ + __FUNCTION__); \ + _label->jump = ((_kind >> 1) & 1); \ + _label->call = (_kind & 1); \ +} while (0) + +#else + +/* Retrieve the kind of LABEL. */ +#define LABEL_KIND(LABEL) \ + ((enum label_kind) (((LABEL)->jump << 1) | (LABEL)->call)) + +/* Set the kind of LABEL. */ +#define SET_LABEL_KIND(LABEL, KIND) do { \ + rtx const _label = (LABEL); \ + const unsigned int _kind = (KIND); \ + _label->jump = ((_kind >> 1) & 1); \ + _label->call = (_kind & 1); \ +} while (0) + +#endif /* rtl flag checking */ + +#define LABEL_ALT_ENTRY_P(LABEL) (LABEL_KIND (LABEL) != LABEL_NORMAL) + +/* In jump.c, each JUMP_INSN can point to a label that it can jump to, + so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can + be decremented and possibly the label can be deleted. */ +#define JUMP_LABEL(INSN) XCEXP (INSN, 8, JUMP_INSN) + +/* Once basic blocks are found, each CODE_LABEL starts a chain that + goes through all the LABEL_REFs that jump to that label. The chain + eventually winds up at the CODE_LABEL: it is circular. */ +#define LABEL_REFS(LABEL) XCEXP (LABEL, 4, CODE_LABEL) + +/* For a REG rtx, REGNO extracts the register number. REGNO can only + be used on RHS. Use SET_REGNO to change the value. */ +#define REGNO(RTX) (rhs_regno(RTX)) +#define SET_REGNO(RTX,N) (df_ref_change_reg_with_loc (REGNO(RTX), N, RTX), XCUINT (RTX, 0, REG) = N) +#define SET_REGNO_RAW(RTX,N) (XCUINT (RTX, 0, REG) = N) + +/* ORIGINAL_REGNO holds the number the register originally had; for a + pseudo register turned into a hard reg this will hold the old pseudo + register number. */ +#define ORIGINAL_REGNO(RTX) X0UINT (RTX, 1) + +/* Force the REGNO macro to only be used on the lhs. */ +static inline unsigned int +rhs_regno (const_rtx x) +{ + return XCUINT (x, 0, REG); +} + + +/* 1 if RTX is a reg or parallel that is the current function's return + value. */ +#define REG_FUNCTION_VALUE_P(RTX) \ + (RTL_FLAG_CHECK2("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val) + +/* 1 if RTX is a reg that corresponds to a variable declared by the user. */ +#define REG_USERVAR_P(RTX) \ + (RTL_FLAG_CHECK1("REG_USERVAR_P", (RTX), REG)->volatil) + +/* 1 if RTX is a reg that holds a pointer value. */ +#define REG_POINTER(RTX) \ + (RTL_FLAG_CHECK1("REG_POINTER", (RTX), REG)->frame_related) + +/* 1 if RTX is a mem that holds a pointer value. */ +#define MEM_POINTER(RTX) \ + (RTL_FLAG_CHECK1("MEM_POINTER", (RTX), MEM)->frame_related) + +/* 1 if the given register REG corresponds to a hard register. */ +#define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG))) + +/* 1 if the given register number REG_NO corresponds to a hard register. */ +#define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER) + +/* For a CONST_INT rtx, INTVAL extracts the integer. */ +#define INTVAL(RTX) XCWINT(RTX, 0, CONST_INT) +#define UINTVAL(RTX) ((unsigned HOST_WIDE_INT) INTVAL (RTX)) + +/* For a CONST_DOUBLE: + For a VOIDmode, there are two integers CONST_DOUBLE_LOW is the + low-order word and ..._HIGH the high-order. + For a float, there is a REAL_VALUE_TYPE structure, and + CONST_DOUBLE_REAL_VALUE(r) is a pointer to it. */ +#define CONST_DOUBLE_LOW(r) XCMWINT (r, 0, CONST_DOUBLE, VOIDmode) +#define CONST_DOUBLE_HIGH(r) XCMWINT (r, 1, CONST_DOUBLE, VOIDmode) +#define CONST_DOUBLE_REAL_VALUE(r) \ + ((const struct real_value *) XCNMPRV (r, CONST_DOUBLE, VOIDmode)) + +#define CONST_FIXED_VALUE(r) \ + ((const struct fixed_value *) XCNMPFV (r, CONST_FIXED, VOIDmode)) +#define CONST_FIXED_VALUE_HIGH(r) \ + ((HOST_WIDE_INT) (CONST_FIXED_VALUE(r)->data.high)) +#define CONST_FIXED_VALUE_LOW(r) \ + ((HOST_WIDE_INT) (CONST_FIXED_VALUE(r)->data.low)) + +/* For a CONST_VECTOR, return element #n. */ +#define CONST_VECTOR_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR) + +/* For a CONST_VECTOR, return the number of elements in a vector. */ +#define CONST_VECTOR_NUNITS(RTX) XCVECLEN (RTX, 0, CONST_VECTOR) + +/* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of. + SUBREG_BYTE extracts the byte-number. */ + +#define SUBREG_REG(RTX) XCEXP (RTX, 0, SUBREG) +#define SUBREG_BYTE(RTX) XCUINT (RTX, 1, SUBREG) + +/* in rtlanal.c */ +/* Return the right cost to give to an operation + to make the cost of the corresponding register-to-register instruction + N times that of a fast register-to-register instruction. */ +#define COSTS_N_INSNS(N) ((N) * 4) + +/* Maximum cost of an rtl expression. This value has the special meaning + not to use an rtx with this cost under any circumstances. */ +#define MAX_COST INT_MAX + +/* A structure to hold all available cost information about an rtl + expression. */ +struct full_rtx_costs +{ + int speed; + int size; +}; + +/* Initialize a full_rtx_costs structure C to the maximum cost. */ +static inline void +init_costs_to_max (struct full_rtx_costs *c) +{ + c->speed = MAX_COST; + c->size = MAX_COST; +} + +/* Initialize a full_rtx_costs structure C to zero cost. */ +static inline void +init_costs_to_zero (struct full_rtx_costs *c) +{ + c->speed = 0; + c->size = 0; +} + +/* Compare two full_rtx_costs structures A and B, returning true + if A < B when optimizing for speed. */ +static inline bool +costs_lt_p (struct full_rtx_costs *a, struct full_rtx_costs *b, + bool speed) +{ + if (speed) + return (a->speed < b->speed + || (a->speed == b->speed && a->size < b->size)); + else + return (a->size < b->size + || (a->size == b->size && a->speed < b->speed)); +} + +/* Increase both members of the full_rtx_costs structure C by the + cost of N insns. */ +static inline void +costs_add_n_insns (struct full_rtx_costs *c, int n) +{ + c->speed += COSTS_N_INSNS (n); + c->size += COSTS_N_INSNS (n); +} + +extern void init_rtlanal (void); +extern int rtx_cost (rtx, enum rtx_code, bool); +extern int address_cost (rtx, enum machine_mode, addr_space_t, bool); +extern void get_full_rtx_cost (rtx, enum rtx_code, struct full_rtx_costs *); +extern unsigned int subreg_lsb (const_rtx); +extern unsigned int subreg_lsb_1 (enum machine_mode, enum machine_mode, + unsigned int); +extern unsigned int subreg_regno_offset (unsigned int, enum machine_mode, + unsigned int, enum machine_mode); +extern bool subreg_offset_representable_p (unsigned int, enum machine_mode, + unsigned int, enum machine_mode); +extern unsigned int subreg_regno (const_rtx); +extern int simplify_subreg_regno (unsigned int, enum machine_mode, + unsigned int, enum machine_mode); +extern unsigned int subreg_nregs (const_rtx); +extern unsigned int subreg_nregs_with_regno (unsigned int, const_rtx); +extern unsigned HOST_WIDE_INT nonzero_bits (const_rtx, enum machine_mode); +extern unsigned int num_sign_bit_copies (const_rtx, enum machine_mode); +extern bool constant_pool_constant_p (rtx); +extern bool truncated_to_mode (enum machine_mode, const_rtx); +extern int low_bitmask_len (enum machine_mode, unsigned HOST_WIDE_INT); + + +/* 1 if RTX is a subreg containing a reg that is already known to be + sign- or zero-extended from the mode of the subreg to the mode of + the reg. SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the + extension. + + When used as a LHS, is means that this extension must be done + when assigning to SUBREG_REG. */ + +#define SUBREG_PROMOTED_VAR_P(RTX) \ + (RTL_FLAG_CHECK1("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct) + +#define SUBREG_PROMOTED_UNSIGNED_SET(RTX, VAL) \ +do { \ + rtx const _rtx = RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_SET", (RTX), SUBREG); \ + if ((VAL) < 0) \ + _rtx->volatil = 1; \ + else { \ + _rtx->volatil = 0; \ + _rtx->unchanging = (VAL); \ + } \ +} while (0) + +/* Valid for subregs which are SUBREG_PROMOTED_VAR_P(). In that case + this gives the necessary extensions: + 0 - signed + 1 - normal unsigned + -1 - pointer unsigned, which most often can be handled like unsigned + extension, except for generating instructions where we need to + emit special code (ptr_extend insns) on some architectures. */ + +#define SUBREG_PROMOTED_UNSIGNED_P(RTX) \ + ((RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \ + ? -1 : (int) (RTX)->unchanging) + +/* Access various components of an ASM_OPERANDS rtx. */ + +#define ASM_OPERANDS_TEMPLATE(RTX) XCSTR (RTX, 0, ASM_OPERANDS) +#define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XCSTR (RTX, 1, ASM_OPERANDS) +#define ASM_OPERANDS_OUTPUT_IDX(RTX) XCINT (RTX, 2, ASM_OPERANDS) +#define ASM_OPERANDS_INPUT_VEC(RTX) XCVEC (RTX, 3, ASM_OPERANDS) +#define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XCVEC (RTX, 4, ASM_OPERANDS) +#define ASM_OPERANDS_INPUT(RTX, N) XCVECEXP (RTX, 3, N, ASM_OPERANDS) +#define ASM_OPERANDS_INPUT_LENGTH(RTX) XCVECLEN (RTX, 3, ASM_OPERANDS) +#define ASM_OPERANDS_INPUT_CONSTRAINT_EXP(RTX, N) \ + XCVECEXP (RTX, 4, N, ASM_OPERANDS) +#define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) \ + XSTR (XCVECEXP (RTX, 4, N, ASM_OPERANDS), 0) +#define ASM_OPERANDS_INPUT_MODE(RTX, N) \ + GET_MODE (XCVECEXP (RTX, 4, N, ASM_OPERANDS)) +#define ASM_OPERANDS_LABEL_VEC(RTX) XCVEC (RTX, 5, ASM_OPERANDS) +#define ASM_OPERANDS_LABEL_LENGTH(RTX) XCVECLEN (RTX, 5, ASM_OPERANDS) +#define ASM_OPERANDS_LABEL(RTX, N) XCVECEXP (RTX, 5, N, ASM_OPERANDS) +#define ASM_OPERANDS_SOURCE_LOCATION(RTX) XCUINT (RTX, 6, ASM_OPERANDS) +#define ASM_INPUT_SOURCE_LOCATION(RTX) XCUINT (RTX, 1, ASM_INPUT) + +/* 1 if RTX is a mem that is statically allocated in read-only memory. */ +#define MEM_READONLY_P(RTX) \ + (RTL_FLAG_CHECK1("MEM_READONLY_P", (RTX), MEM)->unchanging) + +/* 1 if RTX is a mem and we should keep the alias set for this mem + unchanged when we access a component. Set to 1, or example, when we + are already in a non-addressable component of an aggregate. */ +#define MEM_KEEP_ALIAS_SET_P(RTX) \ + (RTL_FLAG_CHECK1("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump) + +/* 1 if RTX is a mem or asm_operand for a volatile reference. */ +#define MEM_VOLATILE_P(RTX) \ + (RTL_FLAG_CHECK3("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \ + ASM_INPUT)->volatil) + +/* 1 if RTX is a mem that refers to an aggregate, either to the + aggregate itself or to a field of the aggregate. If zero, RTX may + or may not be such a reference. */ +#define MEM_IN_STRUCT_P(RTX) \ + (RTL_FLAG_CHECK1("MEM_IN_STRUCT_P", (RTX), MEM)->in_struct) + +/* 1 if RTX is a MEM that refers to a scalar. If zero, RTX may or may + not refer to a scalar. */ +#define MEM_SCALAR_P(RTX) \ + (RTL_FLAG_CHECK1("MEM_SCALAR_P", (RTX), MEM)->return_val) + +/* 1 if RTX is a mem that cannot trap. */ +#define MEM_NOTRAP_P(RTX) \ + (RTL_FLAG_CHECK1("MEM_NOTRAP_P", (RTX), MEM)->call) + +/* The memory attribute block. We provide access macros for each value + in the block and provide defaults if none specified. */ +#define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1) + +/* The register attribute block. We provide access macros for each value + in the block and provide defaults if none specified. */ +#define REG_ATTRS(RTX) X0REGATTR (RTX, 2) + +/* For a MEM rtx, the alias set. If 0, this MEM is not in any alias + set, and may alias anything. Otherwise, the MEM can only alias + MEMs in a conflicting alias set. This value is set in a + language-dependent manner in the front-end, and should not be + altered in the back-end. These set numbers are tested with + alias_sets_conflict_p. */ +#define MEM_ALIAS_SET(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->alias) + +/* For a MEM rtx, the decl it is known to refer to, if it is known to + refer to part of a DECL. It may also be a COMPONENT_REF. */ +#define MEM_EXPR(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->expr) + +/* For a MEM rtx, the offset from the start of MEM_EXPR, if known, as a + RTX that is always a CONST_INT. */ +#define MEM_OFFSET(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->offset) + +/* For a MEM rtx, the address space. */ +#define MEM_ADDR_SPACE(RTX) (MEM_ATTRS (RTX) == 0 ? ADDR_SPACE_GENERIC \ + : MEM_ATTRS (RTX)->addrspace) + +/* For a MEM rtx, the size in bytes of the MEM, if known, as an RTX that + is always a CONST_INT. */ +#define MEM_SIZE(RTX) \ +(MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->size \ + : GET_MODE (RTX) != BLKmode ? GEN_INT (GET_MODE_SIZE (GET_MODE (RTX))) \ + : 0) + +/* For a MEM rtx, the alignment in bits. We can use the alignment of the + mode as a default when STRICT_ALIGNMENT, but not if not. */ +#define MEM_ALIGN(RTX) \ +(MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->align \ + : (STRICT_ALIGNMENT && GET_MODE (RTX) != BLKmode \ + ? GET_MODE_ALIGNMENT (GET_MODE (RTX)) : BITS_PER_UNIT)) + +/* For a REG rtx, the decl it is known to refer to, if it is known to + refer to part of a DECL. */ +#define REG_EXPR(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->decl) + +/* For a REG rtx, the offset from the start of REG_EXPR, if known, as an + HOST_WIDE_INT. */ +#define REG_OFFSET(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->offset) + +/* Copy the attributes that apply to memory locations from RHS to LHS. */ +#define MEM_COPY_ATTRIBUTES(LHS, RHS) \ + (MEM_VOLATILE_P (LHS) = MEM_VOLATILE_P (RHS), \ + MEM_IN_STRUCT_P (LHS) = MEM_IN_STRUCT_P (RHS), \ + MEM_SCALAR_P (LHS) = MEM_SCALAR_P (RHS), \ + MEM_NOTRAP_P (LHS) = MEM_NOTRAP_P (RHS), \ + MEM_READONLY_P (LHS) = MEM_READONLY_P (RHS), \ + MEM_KEEP_ALIAS_SET_P (LHS) = MEM_KEEP_ALIAS_SET_P (RHS), \ + MEM_POINTER (LHS) = MEM_POINTER (RHS), \ + MEM_ATTRS (LHS) = MEM_ATTRS (RHS)) + +/* 1 if RTX is a label_ref for a nonlocal label. */ +/* Likewise in an expr_list for a REG_LABEL_OPERAND or + REG_LABEL_TARGET note. */ +#define LABEL_REF_NONLOCAL_P(RTX) \ + (RTL_FLAG_CHECK1("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil) + +/* 1 if RTX is a code_label that should always be considered to be needed. */ +#define LABEL_PRESERVE_P(RTX) \ + (RTL_FLAG_CHECK2("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct) + +/* During sched, 1 if RTX is an insn that must be scheduled together + with the preceding insn. */ +#define SCHED_GROUP_P(RTX) \ + (RTL_FLAG_CHECK4("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN, \ + JUMP_INSN, CALL_INSN \ + )->in_struct) + +/* For a SET rtx, SET_DEST is the place that is set + and SET_SRC is the value it is set to. */ +#define SET_DEST(RTX) XC2EXP(RTX, 0, SET, CLOBBER) +#define SET_SRC(RTX) XCEXP(RTX, 1, SET) +#define SET_IS_RETURN_P(RTX) \ + (RTL_FLAG_CHECK1("SET_IS_RETURN_P", (RTX), SET)->jump) + +/* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */ +#define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF) +#define TRAP_CODE(RTX) XCEXP (RTX, 1, TRAP_IF) + +/* For a COND_EXEC rtx, COND_EXEC_TEST is the condition to base + conditionally executing the code on, COND_EXEC_CODE is the code + to execute if the condition is true. */ +#define COND_EXEC_TEST(RTX) XCEXP (RTX, 0, COND_EXEC) +#define COND_EXEC_CODE(RTX) XCEXP (RTX, 1, COND_EXEC) + +/* 1 if RTX is a symbol_ref that addresses this function's rtl + constants pool. */ +#define CONSTANT_POOL_ADDRESS_P(RTX) \ + (RTL_FLAG_CHECK1("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging) + +/* 1 if RTX is a symbol_ref that addresses a value in the file's + tree constant pool. This information is private to varasm.c. */ +#define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \ + (RTL_FLAG_CHECK1("TREE_CONSTANT_POOL_ADDRESS_P", \ + (RTX), SYMBOL_REF)->frame_related) + +/* Used if RTX is a symbol_ref, for machine-specific purposes. */ +#define SYMBOL_REF_FLAG(RTX) \ + (RTL_FLAG_CHECK1("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil) + +/* 1 if RTX is a symbol_ref that has been the library function in + emit_library_call. */ +#define SYMBOL_REF_USED(RTX) \ + (RTL_FLAG_CHECK1("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used) + +/* 1 if RTX is a symbol_ref for a weak symbol. */ +#define SYMBOL_REF_WEAK(RTX) \ + (RTL_FLAG_CHECK1("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val) + +/* A pointer attached to the SYMBOL_REF; either SYMBOL_REF_DECL or + SYMBOL_REF_CONSTANT. */ +#define SYMBOL_REF_DATA(RTX) X0ANY ((RTX), 2) + +/* Set RTX's SYMBOL_REF_DECL to DECL. RTX must not be a constant + pool symbol. */ +#define SET_SYMBOL_REF_DECL(RTX, DECL) \ + (gcc_assert (!CONSTANT_POOL_ADDRESS_P (RTX)), X0TREE ((RTX), 2) = (DECL)) + +/* The tree (decl or constant) associated with the symbol, or null. */ +#define SYMBOL_REF_DECL(RTX) \ + (CONSTANT_POOL_ADDRESS_P (RTX) ? NULL : X0TREE ((RTX), 2)) + +/* Set RTX's SYMBOL_REF_CONSTANT to C. RTX must be a constant pool symbol. */ +#define SET_SYMBOL_REF_CONSTANT(RTX, C) \ + (gcc_assert (CONSTANT_POOL_ADDRESS_P (RTX)), X0CONSTANT ((RTX), 2) = (C)) + +/* The rtx constant pool entry for a symbol, or null. */ +#define SYMBOL_REF_CONSTANT(RTX) \ + (CONSTANT_POOL_ADDRESS_P (RTX) ? X0CONSTANT ((RTX), 2) : NULL) + +/* A set of flags on a symbol_ref that are, in some respects, redundant with + information derivable from the tree decl associated with this symbol. + Except that we build a *lot* of SYMBOL_REFs that aren't associated with a + decl. In some cases this is a bug. But beyond that, it's nice to cache + this information to avoid recomputing it. Finally, this allows space for + the target to store more than one bit of information, as with + SYMBOL_REF_FLAG. */ +#define SYMBOL_REF_FLAGS(RTX) X0INT ((RTX), 1) + +/* These flags are common enough to be defined for all targets. They + are computed by the default version of targetm.encode_section_info. */ + +/* Set if this symbol is a function. */ +#define SYMBOL_FLAG_FUNCTION (1 << 0) +#define SYMBOL_REF_FUNCTION_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_FUNCTION) != 0) +/* Set if targetm.binds_local_p is true. */ +#define SYMBOL_FLAG_LOCAL (1 << 1) +#define SYMBOL_REF_LOCAL_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_LOCAL) != 0) +/* Set if targetm.in_small_data_p is true. */ +#define SYMBOL_FLAG_SMALL (1 << 2) +#define SYMBOL_REF_SMALL_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_SMALL) != 0) +/* The three-bit field at [5:3] is true for TLS variables; use + SYMBOL_REF_TLS_MODEL to extract the field as an enum tls_model. */ +#define SYMBOL_FLAG_TLS_SHIFT 3 +#define SYMBOL_REF_TLS_MODEL(RTX) \ + ((enum tls_model) ((SYMBOL_REF_FLAGS (RTX) >> SYMBOL_FLAG_TLS_SHIFT) & 7)) +/* Set if this symbol is not defined in this translation unit. */ +#define SYMBOL_FLAG_EXTERNAL (1 << 6) +#define SYMBOL_REF_EXTERNAL_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_EXTERNAL) != 0) +/* Set if this symbol has a block_symbol structure associated with it. */ +#define SYMBOL_FLAG_HAS_BLOCK_INFO (1 << 7) +#define SYMBOL_REF_HAS_BLOCK_INFO_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_HAS_BLOCK_INFO) != 0) +/* Set if this symbol is a section anchor. SYMBOL_REF_ANCHOR_P implies + SYMBOL_REF_HAS_BLOCK_INFO_P. */ +#define SYMBOL_FLAG_ANCHOR (1 << 8) +#define SYMBOL_REF_ANCHOR_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_ANCHOR) != 0) + +/* Subsequent bits are available for the target to use. */ +#define SYMBOL_FLAG_MACH_DEP_SHIFT 9 +#define SYMBOL_FLAG_MACH_DEP (1 << SYMBOL_FLAG_MACH_DEP_SHIFT) + +/* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the object_block + structure to which the symbol belongs, or NULL if it has not been + assigned a block. */ +#define SYMBOL_REF_BLOCK(RTX) (BLOCK_SYMBOL_CHECK (RTX)->block) + +/* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the offset of RTX from + the first object in SYMBOL_REF_BLOCK (RTX). The value is negative if + RTX has not yet been assigned to a block, or it has not been given an + offset within that block. */ +#define SYMBOL_REF_BLOCK_OFFSET(RTX) (BLOCK_SYMBOL_CHECK (RTX)->offset) + +/* True if RTX is flagged to be a scheduling barrier. */ +#define PREFETCH_SCHEDULE_BARRIER_P(RTX) \ + (RTL_FLAG_CHECK1("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil) + +/* Indicate whether the machine has any sort of auto increment addressing. + If not, we can avoid checking for REG_INC notes. */ + +#if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) \ + || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) \ + || defined (HAVE_PRE_MODIFY_DISP) || defined (HAVE_PRE_MODIFY_DISP) \ + || defined (HAVE_PRE_MODIFY_REG) || defined (HAVE_POST_MODIFY_REG)) +#define AUTO_INC_DEC +#endif + +/* Define a macro to look for REG_INC notes, + but save time on machines where they never exist. */ + +#ifdef AUTO_INC_DEC +#define FIND_REG_INC_NOTE(INSN, REG) \ + ((REG) != NULL_RTX && REG_P ((REG)) \ + ? find_regno_note ((INSN), REG_INC, REGNO (REG)) \ + : find_reg_note ((INSN), REG_INC, (REG))) +#else +#define FIND_REG_INC_NOTE(INSN, REG) 0 +#endif + +#ifndef HAVE_PRE_INCREMENT +#define HAVE_PRE_INCREMENT 0 +#endif + +#ifndef HAVE_PRE_DECREMENT +#define HAVE_PRE_DECREMENT 0 +#endif + +#ifndef HAVE_POST_INCREMENT +#define HAVE_POST_INCREMENT 0 +#endif + +#ifndef HAVE_POST_DECREMENT +#define HAVE_POST_DECREMENT 0 +#endif + +#ifndef HAVE_POST_MODIFY_DISP +#define HAVE_POST_MODIFY_DISP 0 +#endif + +#ifndef HAVE_POST_MODIFY_REG +#define HAVE_POST_MODIFY_REG 0 +#endif + +#ifndef HAVE_PRE_MODIFY_DISP +#define HAVE_PRE_MODIFY_DISP 0 +#endif + +#ifndef HAVE_PRE_MODIFY_REG +#define HAVE_PRE_MODIFY_REG 0 +#endif + + +/* Some architectures do not have complete pre/post increment/decrement + instruction sets, or only move some modes efficiently. These macros + allow us to tune autoincrement generation. */ + +#ifndef USE_LOAD_POST_INCREMENT +#define USE_LOAD_POST_INCREMENT(MODE) HAVE_POST_INCREMENT +#endif + +#ifndef USE_LOAD_POST_DECREMENT +#define USE_LOAD_POST_DECREMENT(MODE) HAVE_POST_DECREMENT +#endif + +#ifndef USE_LOAD_PRE_INCREMENT +#define USE_LOAD_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT +#endif + +#ifndef USE_LOAD_PRE_DECREMENT +#define USE_LOAD_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT +#endif + +#ifndef USE_STORE_POST_INCREMENT +#define USE_STORE_POST_INCREMENT(MODE) HAVE_POST_INCREMENT +#endif + +#ifndef USE_STORE_POST_DECREMENT +#define USE_STORE_POST_DECREMENT(MODE) HAVE_POST_DECREMENT +#endif + +#ifndef USE_STORE_PRE_INCREMENT +#define USE_STORE_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT +#endif + +#ifndef USE_STORE_PRE_DECREMENT +#define USE_STORE_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT +#endif + +/* Nonzero when we are generating CONCATs. */ +extern int generating_concat_p; + +/* Nonzero when we are expanding trees to RTL. */ +extern int currently_expanding_to_rtl; + +/* Generally useful functions. */ + +/* In expmed.c */ +extern int ceil_log2 (unsigned HOST_WIDE_INT); + +/* In explow.c */ +extern HOST_WIDE_INT trunc_int_for_mode (HOST_WIDE_INT, enum machine_mode); +extern rtx plus_constant (rtx, HOST_WIDE_INT); + +/* In rtl.c */ +extern rtx rtx_alloc_stat (RTX_CODE MEM_STAT_DECL); +#define rtx_alloc(c) rtx_alloc_stat (c MEM_STAT_INFO) + +extern rtvec rtvec_alloc (int); +extern rtvec shallow_copy_rtvec (rtvec); +extern bool shared_const_p (const_rtx); +extern rtx copy_rtx (rtx); +extern void dump_rtx_statistics (void); + +/* In emit-rtl.c */ +extern rtx copy_rtx_if_shared (rtx); + +/* In rtl.c */ +extern unsigned int rtx_size (const_rtx); +extern rtx shallow_copy_rtx_stat (const_rtx MEM_STAT_DECL); +#define shallow_copy_rtx(a) shallow_copy_rtx_stat (a MEM_STAT_INFO) +extern int rtx_equal_p (const_rtx, const_rtx); +extern hashval_t iterative_hash_rtx (const_rtx, hashval_t); + +/* In emit-rtl.c */ +extern rtvec gen_rtvec_v (int, rtx *); +extern rtx gen_reg_rtx (enum machine_mode); +extern rtx gen_rtx_REG_offset (rtx, enum machine_mode, unsigned int, int); +extern rtx gen_reg_rtx_offset (rtx, enum machine_mode, int); +extern rtx gen_reg_rtx_and_attrs (rtx); +extern rtx gen_label_rtx (void); +extern rtx gen_lowpart_common (enum machine_mode, rtx); + +/* In cse.c */ +extern rtx gen_lowpart_if_possible (enum machine_mode, rtx); + +/* In emit-rtl.c */ +extern rtx gen_highpart (enum machine_mode, rtx); +extern rtx gen_highpart_mode (enum machine_mode, enum machine_mode, rtx); +extern rtx operand_subword (rtx, unsigned int, int, enum machine_mode); + +/* In emit-rtl.c */ +extern rtx operand_subword_force (rtx, unsigned int, enum machine_mode); +extern int subreg_lowpart_p (const_rtx); +extern unsigned int subreg_lowpart_offset (enum machine_mode, + enum machine_mode); +extern unsigned int subreg_highpart_offset (enum machine_mode, + enum machine_mode); +extern int byte_lowpart_offset (enum machine_mode, enum machine_mode); +extern rtx make_safe_from (rtx, rtx); +extern rtx convert_memory_address_addr_space (enum machine_mode, rtx, + addr_space_t); +#define convert_memory_address(to_mode,x) \ + convert_memory_address_addr_space ((to_mode), (x), ADDR_SPACE_GENERIC) +extern const char *get_insn_name (int); +extern rtx get_last_insn_anywhere (void); +extern rtx get_first_nonnote_insn (void); +extern rtx get_last_nonnote_insn (void); +extern void start_sequence (void); +extern void push_to_sequence (rtx); +extern void push_to_sequence2 (rtx, rtx); +extern void end_sequence (void); +extern double_int rtx_to_double_int (const_rtx); +extern rtx immed_double_int_const (double_int, enum machine_mode); +extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT, + enum machine_mode); + +/* In loop-iv.c */ + +extern rtx lowpart_subreg (enum machine_mode, rtx, enum machine_mode); + +/* In varasm.c */ +extern rtx force_const_mem (enum machine_mode, rtx); + +/* In varasm.c */ + +struct function; +extern rtx get_pool_constant (rtx); +extern rtx get_pool_constant_mark (rtx, bool *); +extern enum machine_mode get_pool_mode (const_rtx); +extern rtx simplify_subtraction (rtx); + +/* In function.c */ +extern rtx assign_stack_local (enum machine_mode, HOST_WIDE_INT, int); +#define ASLK_REDUCE_ALIGN 1 +#define ASLK_RECORD_PAD 2 +extern rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int, int); +extern rtx assign_stack_temp (enum machine_mode, HOST_WIDE_INT, int); +extern rtx assign_stack_temp_for_type (enum machine_mode, + HOST_WIDE_INT, int, tree); +extern rtx assign_temp (tree, int, int, int); + +/* In emit-rtl.c */ +extern rtx emit_insn_before (rtx, rtx); +extern rtx emit_insn_before_noloc (rtx, rtx, struct basic_block_def *); +extern rtx emit_insn_before_setloc (rtx, rtx, int); +extern rtx emit_jump_insn_before (rtx, rtx); +extern rtx emit_jump_insn_before_noloc (rtx, rtx); +extern rtx emit_jump_insn_before_setloc (rtx, rtx, int); +extern rtx emit_call_insn_before (rtx, rtx); +extern rtx emit_call_insn_before_noloc (rtx, rtx); +extern rtx emit_call_insn_before_setloc (rtx, rtx, int); +extern rtx emit_debug_insn_before (rtx, rtx); +extern rtx emit_debug_insn_before_noloc (rtx, rtx); +extern rtx emit_debug_insn_before_setloc (rtx, rtx, int); +extern rtx emit_barrier_before (rtx); +extern rtx emit_label_before (rtx, rtx); +extern rtx emit_note_before (enum insn_note, rtx); +extern rtx emit_insn_after (rtx, rtx); +extern rtx emit_insn_after_noloc (rtx, rtx, struct basic_block_def *); +extern rtx emit_insn_after_setloc (rtx, rtx, int); +extern rtx emit_jump_insn_after (rtx, rtx); +extern rtx emit_jump_insn_after_noloc (rtx, rtx); +extern rtx emit_jump_insn_after_setloc (rtx, rtx, int); +extern rtx emit_call_insn_after (rtx, rtx); +extern rtx emit_call_insn_after_noloc (rtx, rtx); +extern rtx emit_call_insn_after_setloc (rtx, rtx, int); +extern rtx emit_debug_insn_after (rtx, rtx); +extern rtx emit_debug_insn_after_noloc (rtx, rtx); +extern rtx emit_debug_insn_after_setloc (rtx, rtx, int); +extern rtx emit_barrier_after (rtx); +extern rtx emit_label_after (rtx, rtx); +extern rtx emit_note_after (enum insn_note, rtx); +extern rtx emit_insn (rtx); +extern rtx emit_debug_insn (rtx); +extern rtx emit_jump_insn (rtx); +extern rtx emit_call_insn (rtx); +extern rtx emit_label (rtx); +extern rtx emit_barrier (void); +extern rtx emit_note (enum insn_note); +extern rtx emit_note_copy (rtx); +extern rtx gen_clobber (rtx); +extern rtx emit_clobber (rtx); +extern rtx gen_use (rtx); +extern rtx emit_use (rtx); +extern rtx make_insn_raw (rtx); +extern rtx make_debug_insn_raw (rtx); +extern rtx make_jump_insn_raw (rtx); +extern void add_function_usage_to (rtx, rtx); +extern rtx last_call_insn (void); +extern rtx previous_insn (rtx); +extern rtx next_insn (rtx); +extern rtx prev_nonnote_insn (rtx); +extern rtx prev_nonnote_insn_bb (rtx); +extern rtx next_nonnote_insn (rtx); +extern rtx next_nonnote_insn_bb (rtx); +extern rtx prev_nondebug_insn (rtx); +extern rtx next_nondebug_insn (rtx); +extern rtx prev_nonnote_nondebug_insn (rtx); +extern rtx next_nonnote_nondebug_insn (rtx); +extern rtx prev_real_insn (rtx); +extern rtx next_real_insn (rtx); +extern rtx prev_active_insn (rtx); +extern rtx next_active_insn (rtx); +extern int active_insn_p (const_rtx); +extern rtx prev_label (rtx); +extern rtx next_label (rtx); +extern rtx skip_consecutive_labels (rtx); +extern rtx next_cc0_user (rtx); +extern rtx prev_cc0_setter (rtx); + +/* In cfglayout.c */ +extern int insn_line (const_rtx); +extern const char * insn_file (const_rtx); +extern int insn_discriminator (const_rtx); +extern location_t locator_location (int); +extern int locator_line (int); +extern const char * locator_file (int); +extern bool locator_eq (int, int); +extern int prologue_locator, epilogue_locator; + +/* In jump.c */ +extern enum rtx_code reverse_condition (enum rtx_code); +extern enum rtx_code reverse_condition_maybe_unordered (enum rtx_code); +extern enum rtx_code swap_condition (enum rtx_code); +extern enum rtx_code unsigned_condition (enum rtx_code); +extern enum rtx_code signed_condition (enum rtx_code); +extern void mark_jump_label (rtx, rtx, int); +extern unsigned int cleanup_barriers (void); + +/* In jump.c */ +extern rtx delete_related_insns (rtx); + +/* In recog.c */ +extern rtx *find_constant_term_loc (rtx *); + +/* In emit-rtl.c */ +extern rtx try_split (rtx, rtx, int); +extern int split_branch_probability; + +/* In unknown file */ +extern rtx split_insns (rtx, rtx); + +/* In simplify-rtx.c */ +extern rtx simplify_const_unary_operation (enum rtx_code, enum machine_mode, + rtx, enum machine_mode); +extern rtx simplify_unary_operation (enum rtx_code, enum machine_mode, rtx, + enum machine_mode); +extern rtx simplify_const_binary_operation (enum rtx_code, enum machine_mode, + rtx, rtx); +extern rtx simplify_binary_operation (enum rtx_code, enum machine_mode, rtx, + rtx); +extern rtx simplify_ternary_operation (enum rtx_code, enum machine_mode, + enum machine_mode, rtx, rtx, rtx); +extern rtx simplify_const_relational_operation (enum rtx_code, + enum machine_mode, rtx, rtx); +extern rtx simplify_relational_operation (enum rtx_code, enum machine_mode, + enum machine_mode, rtx, rtx); +extern rtx simplify_gen_binary (enum rtx_code, enum machine_mode, rtx, rtx); +extern rtx simplify_gen_unary (enum rtx_code, enum machine_mode, rtx, + enum machine_mode); +extern rtx simplify_gen_ternary (enum rtx_code, enum machine_mode, + enum machine_mode, rtx, rtx, rtx); +extern rtx simplify_gen_relational (enum rtx_code, enum machine_mode, + enum machine_mode, rtx, rtx); +extern rtx simplify_subreg (enum machine_mode, rtx, enum machine_mode, + unsigned int); +extern rtx simplify_gen_subreg (enum machine_mode, rtx, enum machine_mode, + unsigned int); +extern rtx simplify_replace_fn_rtx (rtx, const_rtx, + rtx (*fn) (rtx, const_rtx, void *), void *); +extern rtx simplify_replace_rtx (rtx, const_rtx, rtx); +extern rtx simplify_rtx (const_rtx); +extern rtx avoid_constant_pool_reference (rtx); +extern rtx delegitimize_mem_from_attrs (rtx); +extern bool mode_signbit_p (enum machine_mode, const_rtx); + +/* In reginfo.c */ +extern enum machine_mode choose_hard_reg_mode (unsigned int, unsigned int, + bool); + +/* In emit-rtl.c */ +extern rtx set_unique_reg_note (rtx, enum reg_note, rtx); +extern void set_insn_deleted (rtx); + +/* Functions in rtlanal.c */ + +/* Single set is implemented as macro for performance reasons. */ +#define single_set(I) (INSN_P (I) \ + ? (GET_CODE (PATTERN (I)) == SET \ + ? PATTERN (I) : single_set_1 (I)) \ + : NULL_RTX) +#define single_set_1(I) single_set_2 (I, PATTERN (I)) + +/* Structure used for passing data to REPLACE_LABEL. */ +typedef struct replace_label_data +{ + rtx r1; + rtx r2; + bool update_label_nuses; +} replace_label_data; + +extern int rtx_addr_can_trap_p (const_rtx); +extern bool nonzero_address_p (const_rtx); +extern int rtx_unstable_p (const_rtx); +extern bool rtx_varies_p (const_rtx, bool); +extern bool rtx_addr_varies_p (const_rtx, bool); +extern HOST_WIDE_INT get_integer_term (const_rtx); +extern rtx get_related_value (const_rtx); +extern bool offset_within_block_p (const_rtx, HOST_WIDE_INT); +extern void split_const (rtx, rtx *, rtx *); +extern int reg_mentioned_p (const_rtx, const_rtx); +extern int count_occurrences (const_rtx, const_rtx, int); +extern int reg_referenced_p (const_rtx, const_rtx); +extern int reg_used_between_p (const_rtx, const_rtx, const_rtx); +extern int reg_set_between_p (const_rtx, const_rtx, const_rtx); +extern int commutative_operand_precedence (rtx); +extern bool swap_commutative_operands_p (rtx, rtx); +extern int modified_between_p (const_rtx, const_rtx, const_rtx); +extern int no_labels_between_p (const_rtx, const_rtx); +extern int modified_in_p (const_rtx, const_rtx); +extern int reg_set_p (const_rtx, const_rtx); +extern rtx single_set_2 (const_rtx, const_rtx); +extern int multiple_sets (const_rtx); +extern int set_noop_p (const_rtx); +extern int noop_move_p (const_rtx); +extern rtx find_last_value (rtx, rtx *, rtx, int); +extern int refers_to_regno_p (unsigned int, unsigned int, const_rtx, rtx *); +extern int reg_overlap_mentioned_p (const_rtx, const_rtx); +extern const_rtx set_of (const_rtx, const_rtx); +extern void note_stores (const_rtx, void (*) (rtx, const_rtx, void *), void *); +extern void note_uses (rtx *, void (*) (rtx *, void *), void *); +extern int dead_or_set_p (const_rtx, const_rtx); +extern int dead_or_set_regno_p (const_rtx, unsigned int); +extern rtx find_reg_note (const_rtx, enum reg_note, const_rtx); +extern rtx find_regno_note (const_rtx, enum reg_note, unsigned int); +extern rtx find_reg_equal_equiv_note (const_rtx); +extern rtx find_constant_src (const_rtx); +extern int find_reg_fusage (const_rtx, enum rtx_code, const_rtx); +extern int find_regno_fusage (const_rtx, enum rtx_code, unsigned int); +extern rtx alloc_reg_note (enum reg_note, rtx, rtx); +extern void add_reg_note (rtx, enum reg_note, rtx); +extern void remove_note (rtx, const_rtx); +extern void remove_reg_equal_equiv_notes (rtx); +extern void remove_reg_equal_equiv_notes_for_regno (unsigned int); +extern int side_effects_p (const_rtx); +extern int volatile_refs_p (const_rtx); +extern int volatile_insn_p (const_rtx); +extern int may_trap_p_1 (const_rtx, unsigned); +extern int may_trap_p (const_rtx); +extern int may_trap_or_fault_p (const_rtx); +extern bool can_throw_internal (const_rtx); +extern bool can_throw_external (const_rtx); +extern bool insn_could_throw_p (const_rtx); +extern bool insn_nothrow_p (const_rtx); +extern bool can_nonlocal_goto (const_rtx); +extern void copy_reg_eh_region_note_forward (rtx, rtx, rtx); +extern void copy_reg_eh_region_note_backward(rtx, rtx, rtx); +extern int inequality_comparisons_p (const_rtx); +extern rtx replace_rtx (rtx, rtx, rtx); +extern int replace_label (rtx *, void *); +extern int rtx_referenced_p (rtx, rtx); +extern bool tablejump_p (const_rtx, rtx *, rtx *); +extern int computed_jump_p (const_rtx); + +typedef int (*rtx_function) (rtx *, void *); +extern int for_each_rtx (rtx *, rtx_function, void *); + +/* Callback for for_each_inc_dec, to process the autoinc operation OP + within MEM that sets DEST to SRC + SRCOFF, or SRC if SRCOFF is + NULL. The callback is passed the same opaque ARG passed to + for_each_inc_dec. Return zero to continue looking for other + autoinc operations, -1 to skip OP's operands, and any other value + to interrupt the traversal and return that value to the caller of + for_each_inc_dec. */ +typedef int (*for_each_inc_dec_fn) (rtx mem, rtx op, rtx dest, rtx src, + rtx srcoff, void *arg); +extern int for_each_inc_dec (rtx *, for_each_inc_dec_fn, void *arg); + +typedef int (*rtx_equal_p_callback_function) (const_rtx *, const_rtx *, + rtx *, rtx *); +extern int rtx_equal_p_cb (const_rtx, const_rtx, + rtx_equal_p_callback_function); + +typedef int (*hash_rtx_callback_function) (const_rtx, enum machine_mode, rtx *, + enum machine_mode *); +extern unsigned hash_rtx_cb (const_rtx, enum machine_mode, int *, int *, + bool, hash_rtx_callback_function); + +extern rtx regno_use_in (unsigned int, rtx); +extern int auto_inc_p (const_rtx); +extern int in_expr_list_p (const_rtx, const_rtx); +extern void remove_node_from_expr_list (const_rtx, rtx *); +extern int loc_mentioned_in_p (rtx *, const_rtx); +extern rtx find_first_parameter_load (rtx, rtx); +extern bool keep_with_call_p (const_rtx); +extern bool label_is_jump_target_p (const_rtx, const_rtx); +extern int insn_rtx_cost (rtx, bool); + +/* Given an insn and condition, return a canonical description of + the test being made. */ +extern rtx canonicalize_condition (rtx, rtx, int, rtx *, rtx, int, int); + +/* Given a JUMP_INSN, return a canonical description of the test + being made. */ +extern rtx get_condition (rtx, rtx *, int, int); + +/* Information about a subreg of a hard register. */ +struct subreg_info +{ + /* Offset of first hard register involved in the subreg. */ + int offset; + /* Number of hard registers involved in the subreg. */ + int nregs; + /* Whether this subreg can be represented as a hard reg with the new + mode. */ + bool representable_p; +}; + +extern void subreg_get_info (unsigned int, enum machine_mode, + unsigned int, enum machine_mode, + struct subreg_info *); + +/* lists.c */ + +extern void free_EXPR_LIST_list (rtx *); +extern void free_INSN_LIST_list (rtx *); +extern void free_EXPR_LIST_node (rtx); +extern void free_INSN_LIST_node (rtx); +extern rtx alloc_INSN_LIST (rtx, rtx); +extern rtx alloc_EXPR_LIST (int, rtx, rtx); +extern void remove_free_INSN_LIST_elem (rtx, rtx *); +extern rtx remove_list_elem (rtx, rtx *); +extern rtx remove_free_INSN_LIST_node (rtx *); +extern rtx remove_free_EXPR_LIST_node (rtx *); + + +/* reginfo.c */ + +/* Initialize may_move_cost and friends for mode M. */ +extern void init_move_cost (enum machine_mode); +/* Resize reg info. */ +extern bool resize_reg_info (void); +/* Free up register info memory. */ +extern void free_reg_info (void); +extern void init_subregs_of_mode (void); +extern void finish_subregs_of_mode (void); + +/* recog.c */ +extern rtx extract_asm_operands (rtx); +extern int asm_noperands (const_rtx); +extern const char *decode_asm_operands (rtx, rtx *, rtx **, const char **, + enum machine_mode *, location_t *); + +extern enum reg_class reg_preferred_class (int); +extern enum reg_class reg_alternate_class (int); +extern enum reg_class reg_cover_class (int); +extern void setup_reg_classes (int, enum reg_class, enum reg_class, + enum reg_class); + +extern void split_all_insns (void); +extern unsigned int split_all_insns_noflow (void); + +#define MAX_SAVED_CONST_INT 64 +extern GTY(()) rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1]; + +#define const0_rtx (const_int_rtx[MAX_SAVED_CONST_INT]) +#define const1_rtx (const_int_rtx[MAX_SAVED_CONST_INT+1]) +#define const2_rtx (const_int_rtx[MAX_SAVED_CONST_INT+2]) +#define constm1_rtx (const_int_rtx[MAX_SAVED_CONST_INT-1]) +extern GTY(()) rtx const_true_rtx; + +extern GTY(()) rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE]; + +/* Returns a constant 0 rtx in mode MODE. Integer modes are treated the + same as VOIDmode. */ + +#define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)]) + +/* Likewise, for the constants 1 and 2. */ + +#define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)]) +#define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)]) + +/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg + is used to represent the frame pointer. This is because the + hard frame pointer and the automatic variables are separated by an amount + that cannot be determined until after register allocation. We can assume + that in this case ELIMINABLE_REGS will be defined, one action of which + will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */ +#ifndef HARD_FRAME_POINTER_REGNUM +#define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM +#endif + +#ifndef HARD_FRAME_POINTER_IS_FRAME_POINTER +#define HARD_FRAME_POINTER_IS_FRAME_POINTER \ + (HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM) +#endif + +#ifndef HARD_FRAME_POINTER_IS_ARG_POINTER +#define HARD_FRAME_POINTER_IS_ARG_POINTER \ + (HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM) +#endif + +/* Index labels for global_rtl. */ +enum global_rtl_index +{ + GR_PC, + GR_CC0, + GR_STACK_POINTER, + GR_FRAME_POINTER, +/* For register elimination to work properly these hard_frame_pointer_rtx, + frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to + the same register. */ +#if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM + GR_ARG_POINTER = GR_FRAME_POINTER, +#endif +#if HARD_FRAME_POINTER_IS_FRAME_POINTER + GR_HARD_FRAME_POINTER = GR_FRAME_POINTER, +#else + GR_HARD_FRAME_POINTER, +#endif +#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM +#if HARD_FRAME_POINTER_IS_ARG_POINTER + GR_ARG_POINTER = GR_HARD_FRAME_POINTER, +#else + GR_ARG_POINTER, +#endif +#endif + GR_VIRTUAL_INCOMING_ARGS, + GR_VIRTUAL_STACK_ARGS, + GR_VIRTUAL_STACK_DYNAMIC, + GR_VIRTUAL_OUTGOING_ARGS, + GR_VIRTUAL_CFA, + GR_VIRTUAL_PREFERRED_STACK_BOUNDARY, + + GR_MAX +}; + +/* Target-dependent globals. */ +struct GTY(()) target_rtl { + /* All references to the hard registers in global_rtl_index go through + these unique rtl objects. On machines where the frame-pointer and + arg-pointer are the same register, they use the same unique object. + + After register allocation, other rtl objects which used to be pseudo-regs + may be clobbered to refer to the frame-pointer register. + But references that were originally to the frame-pointer can be + distinguished from the others because they contain frame_pointer_rtx. + + When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little + tricky: until register elimination has taken place hard_frame_pointer_rtx + should be used if it is being set, and frame_pointer_rtx otherwise. After + register elimination hard_frame_pointer_rtx should always be used. + On machines where the two registers are same (most) then these are the + same. */ + rtx x_global_rtl[GR_MAX]; + + /* A unique representation of (REG:Pmode PIC_OFFSET_TABLE_REGNUM). */ + rtx x_pic_offset_table_rtx; + + /* A unique representation of (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM). + This is used to implement __builtin_return_address for some machines; + see for instance the MIPS port. */ + rtx x_return_address_pointer_rtx; + + /* Commonly used RTL for hard registers. These objects are not + necessarily unique, so we allocate them separately from global_rtl. + They are initialized once per compilation unit, then copied into + regno_reg_rtx at the beginning of each function. */ + rtx x_initial_regno_reg_rtx[FIRST_PSEUDO_REGISTER]; + + /* A sample (mem:M stack_pointer_rtx) rtx for each mode M. */ + rtx x_top_of_stack[MAX_MACHINE_MODE]; + + /* Static hunks of RTL used by the aliasing code; these are treated + as persistent to avoid unnecessary RTL allocations. */ + rtx x_static_reg_base_value[FIRST_PSEUDO_REGISTER]; +}; + +extern GTY(()) struct target_rtl default_target_rtl; +#if SWITCHABLE_TARGET +extern struct target_rtl *this_target_rtl; +#else +#define this_target_rtl (&default_target_rtl) +#endif + +#define global_rtl \ + (this_target_rtl->x_global_rtl) +#define pic_offset_table_rtx \ + (this_target_rtl->x_pic_offset_table_rtx) +#define return_address_pointer_rtx \ + (this_target_rtl->x_return_address_pointer_rtx) +#define top_of_stack \ + (this_target_rtl->x_top_of_stack) + +/* Standard pieces of rtx, to be substituted directly into things. */ +#define pc_rtx (global_rtl[GR_PC]) +#define cc0_rtx (global_rtl[GR_CC0]) + +/* All references to certain hard regs, except those created + by allocating pseudo regs into them (when that's possible), + go through these unique rtx objects. */ +#define stack_pointer_rtx (global_rtl[GR_STACK_POINTER]) +#define frame_pointer_rtx (global_rtl[GR_FRAME_POINTER]) +#define hard_frame_pointer_rtx (global_rtl[GR_HARD_FRAME_POINTER]) +#define arg_pointer_rtx (global_rtl[GR_ARG_POINTER]) + +/* Include the RTL generation functions. */ + +#ifndef GENERATOR_FILE +#include "genrtl.h" +#undef gen_rtx_ASM_INPUT +#define gen_rtx_ASM_INPUT(MODE, ARG0) \ + gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), 0) +#define gen_rtx_ASM_INPUT_loc(MODE, ARG0, LOC) \ + gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), (LOC)) +#endif + +/* There are some RTL codes that require special attention; the + generation functions included above do the raw handling. If you + add to this list, modify special_rtx in gengenrtl.c as well. */ + +extern rtx gen_rtx_CONST_INT (enum machine_mode, HOST_WIDE_INT); +extern rtx gen_rtx_CONST_VECTOR (enum machine_mode, rtvec); +extern rtx gen_raw_REG (enum machine_mode, int); +extern rtx gen_rtx_REG (enum machine_mode, unsigned); +extern rtx gen_rtx_SUBREG (enum machine_mode, rtx, int); +extern rtx gen_rtx_MEM (enum machine_mode, rtx); + +#define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (N)) + +/* Virtual registers are used during RTL generation to refer to locations into + the stack frame when the actual location isn't known until RTL generation + is complete. The routine instantiate_virtual_regs replaces these with + the proper value, which is normally {frame,arg,stack}_pointer_rtx plus + a constant. */ + +#define FIRST_VIRTUAL_REGISTER (FIRST_PSEUDO_REGISTER) + +/* This points to the first word of the incoming arguments passed on the stack, + either by the caller or by the callee when pretending it was passed by the + caller. */ + +#define virtual_incoming_args_rtx (global_rtl[GR_VIRTUAL_INCOMING_ARGS]) + +#define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER) + +/* If FRAME_GROWS_DOWNWARD, this points to immediately above the first + variable on the stack. Otherwise, it points to the first variable on + the stack. */ + +#define virtual_stack_vars_rtx (global_rtl[GR_VIRTUAL_STACK_ARGS]) + +#define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1) + +/* This points to the location of dynamically-allocated memory on the stack + immediately after the stack pointer has been adjusted by the amount + desired. */ + +#define virtual_stack_dynamic_rtx (global_rtl[GR_VIRTUAL_STACK_DYNAMIC]) + +#define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2) + +/* This points to the location in the stack at which outgoing arguments should + be written when the stack is pre-pushed (arguments pushed using push + insns always use sp). */ + +#define virtual_outgoing_args_rtx (global_rtl[GR_VIRTUAL_OUTGOING_ARGS]) + +#define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3) + +/* This points to the Canonical Frame Address of the function. This + should correspond to the CFA produced by INCOMING_FRAME_SP_OFFSET, + but is calculated relative to the arg pointer for simplicity; the + frame pointer nor stack pointer are necessarily fixed relative to + the CFA until after reload. */ + +#define virtual_cfa_rtx (global_rtl[GR_VIRTUAL_CFA]) + +#define VIRTUAL_CFA_REGNUM ((FIRST_VIRTUAL_REGISTER) + 4) + +#define LAST_VIRTUAL_POINTER_REGISTER ((FIRST_VIRTUAL_REGISTER) + 4) + +/* This is replaced by crtl->preferred_stack_boundary / BITS_PER_UNIT + when finalized. */ + +#define virtual_preferred_stack_boundary_rtx \ + (global_rtl[GR_VIRTUAL_PREFERRED_STACK_BOUNDARY]) + +#define VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM \ + ((FIRST_VIRTUAL_REGISTER) + 5) + +#define LAST_VIRTUAL_REGISTER ((FIRST_VIRTUAL_REGISTER) + 5) + +/* Nonzero if REGNUM is a pointer into the stack frame. */ +#define REGNO_PTR_FRAME_P(REGNUM) \ + ((REGNUM) == STACK_POINTER_REGNUM \ + || (REGNUM) == FRAME_POINTER_REGNUM \ + || (REGNUM) == HARD_FRAME_POINTER_REGNUM \ + || (REGNUM) == ARG_POINTER_REGNUM \ + || ((REGNUM) >= FIRST_VIRTUAL_REGISTER \ + && (REGNUM) <= LAST_VIRTUAL_POINTER_REGISTER)) + +/* REGNUM never really appearing in the INSN stream. */ +#define INVALID_REGNUM (~(unsigned int) 0) + +extern rtx output_constant_def (tree, int); +extern rtx lookup_constant_def (tree); + +/* Nonzero after end of reload pass. + Set to 1 or 0 by reload1.c. */ + +extern int reload_completed; + +/* Nonzero after thread_prologue_and_epilogue_insns has run. */ +extern int epilogue_completed; + +/* Set to 1 while reload_as_needed is operating. + Required by some machines to handle any generated moves differently. */ + +extern int reload_in_progress; + +/* This macro indicates whether you may create a new + pseudo-register. */ + +#define can_create_pseudo_p() (!reload_in_progress && !reload_completed) + +#ifdef STACK_REGS +/* Nonzero after end of regstack pass. + Set to 1 or 0 by reg-stack.c. */ +extern int regstack_completed; +#endif + +/* If this is nonzero, we do not bother generating VOLATILE + around volatile memory references, and we are willing to + output indirect addresses. If cse is to follow, we reject + indirect addresses so a useful potential cse is generated; + if it is used only once, instruction combination will produce + the same indirect address eventually. */ +extern int cse_not_expected; + +/* Translates rtx code to tree code, for those codes needed by + REAL_ARITHMETIC. The function returns an int because the caller may not + know what `enum tree_code' means. */ + +extern int rtx_to_tree_code (enum rtx_code); + +/* In cse.c */ +extern int delete_trivially_dead_insns (rtx, int); +extern int cse_main (rtx, int); +extern int exp_equiv_p (const_rtx, const_rtx, int, bool); +extern unsigned hash_rtx (const_rtx x, enum machine_mode, int *, int *, bool); + +/* In dse.c */ +extern void check_for_inc_dec (rtx insn); + +/* In jump.c */ +extern int comparison_dominates_p (enum rtx_code, enum rtx_code); +extern int condjump_p (const_rtx); +extern int any_condjump_p (const_rtx); +extern int any_uncondjump_p (const_rtx); +extern rtx pc_set (const_rtx); +extern rtx condjump_label (const_rtx); +extern int simplejump_p (const_rtx); +extern int returnjump_p (rtx); +extern int eh_returnjump_p (rtx); +extern int onlyjump_p (const_rtx); +extern int only_sets_cc0_p (const_rtx); +extern int sets_cc0_p (const_rtx); +extern int invert_jump_1 (rtx, rtx); +extern int invert_jump (rtx, rtx, int); +extern int rtx_renumbered_equal_p (const_rtx, const_rtx); +extern int true_regnum (const_rtx); +extern unsigned int reg_or_subregno (const_rtx); +extern int redirect_jump_1 (rtx, rtx); +extern void redirect_jump_2 (rtx, rtx, rtx, int, int); +extern int redirect_jump (rtx, rtx, int); +extern void rebuild_jump_labels (rtx); +extern rtx reversed_comparison (const_rtx, enum machine_mode); +extern enum rtx_code reversed_comparison_code (const_rtx, const_rtx); +extern enum rtx_code reversed_comparison_code_parts (enum rtx_code, const_rtx, + const_rtx, const_rtx); +extern void delete_for_peephole (rtx, rtx); +extern int condjump_in_parallel_p (const_rtx); + +/* In emit-rtl.c. */ +extern int max_reg_num (void); +extern int max_label_num (void); +extern int get_first_label_num (void); +extern void maybe_set_first_label_num (rtx); +extern void delete_insns_since (rtx); +extern void mark_reg_pointer (rtx, int); +extern void mark_user_reg (rtx); +extern void reset_used_flags (rtx); +extern void set_used_flags (rtx); +extern void reorder_insns (rtx, rtx, rtx); +extern void reorder_insns_nobb (rtx, rtx, rtx); +extern int get_max_insn_count (void); +extern int in_sequence_p (void); +extern void force_next_line_note (void); +extern void init_emit (void); +extern void init_emit_regs (void); +extern void init_emit_once (void); +extern void push_topmost_sequence (void); +extern void pop_topmost_sequence (void); +extern void set_new_first_and_last_insn (rtx, rtx); +extern unsigned int unshare_all_rtl (void); +extern void unshare_all_rtl_again (rtx); +extern void unshare_all_rtl_in_chain (rtx); +extern void verify_rtl_sharing (void); +extern void link_cc0_insns (rtx); +extern void add_insn (rtx); +extern void add_insn_before (rtx, rtx, struct basic_block_def *); +extern void add_insn_after (rtx, rtx, struct basic_block_def *); +extern void remove_insn (rtx); +extern rtx emit (rtx); +extern rtx delete_insn (rtx); +extern rtx entry_of_function (void); +extern void emit_insn_at_entry (rtx); +extern void delete_insn_chain (rtx, rtx, bool); +extern rtx unlink_insn_chain (rtx, rtx); +extern rtx delete_insn_and_edges (rtx); +extern rtx gen_lowpart_SUBREG (enum machine_mode, rtx); +extern rtx gen_const_mem (enum machine_mode, rtx); +extern rtx gen_frame_mem (enum machine_mode, rtx); +extern rtx gen_tmp_stack_mem (enum machine_mode, rtx); +extern bool validate_subreg (enum machine_mode, enum machine_mode, + const_rtx, unsigned int); + +/* In combine.c */ +extern unsigned int extended_count (const_rtx, enum machine_mode, int); +extern rtx remove_death (unsigned int, rtx); +extern void dump_combine_stats (FILE *); +extern void dump_combine_total_stats (FILE *); + +/* In cfgcleanup.c */ +extern void delete_dead_jumptables (void); + +/* In sched-vis.c. */ +extern void debug_bb_n_slim (int); +extern void debug_bb_slim (struct basic_block_def *); +extern void print_rtl_slim (FILE *, rtx, rtx, int, int); +extern void print_rtl_slim_with_bb (FILE *, rtx, int); +extern void dump_insn_slim (FILE *f, rtx x); +extern void debug_insn_slim (rtx x); + +/* In sched-rgn.c. */ +extern void schedule_insns (void); + +/* In sched-ebb.c. */ +extern void schedule_ebbs (void); + +/* In sel-sched-dump.c. */ +extern void sel_sched_fix_param (const char *param, const char *val); + +/* In print-rtl.c */ +extern const char *print_rtx_head; +extern void debug_rtx (const_rtx); +extern void debug_rtx_list (const_rtx, int); +extern void debug_rtx_range (const_rtx, const_rtx); +extern const_rtx debug_rtx_find (const_rtx, int); +extern void print_mem_expr (FILE *, const_tree); +extern void print_rtl (FILE *, const_rtx); +extern void print_simple_rtl (FILE *, const_rtx); +extern int print_rtl_single (FILE *, const_rtx); +extern void print_inline_rtx (FILE *, const_rtx, int); + +/* In function.c */ +extern void reposition_prologue_and_epilogue_notes (void); +extern int prologue_epilogue_contains (const_rtx); +extern int sibcall_epilogue_contains (const_rtx); +extern void mark_temp_addr_taken (rtx); +extern void update_temp_slot_address (rtx, rtx); +extern void maybe_copy_prologue_epilogue_insn (rtx, rtx); + +/* In stmt.c */ +extern void expand_null_return (void); +extern void expand_naked_return (void); +extern void emit_jump (rtx); + +/* In expr.c */ +extern rtx move_by_pieces (rtx, rtx, unsigned HOST_WIDE_INT, + unsigned int, int); + +/* In cfgrtl.c */ +extern void print_rtl_with_bb (FILE *, const_rtx); + +/* In cfg.c. */ +extern void dump_reg_info (FILE *); +extern void dump_flow_info (FILE *, int); + +/* In expmed.c */ +extern void init_expmed (void); +extern void expand_inc (rtx, rtx); +extern void expand_dec (rtx, rtx); + +/* In gcse.c */ +extern bool can_copy_p (enum machine_mode); +extern bool can_assign_to_reg_without_clobbers_p (rtx); +extern rtx fis_get_condition (rtx); + +/* In ira.c */ +#ifdef HARD_CONST +extern HARD_REG_SET eliminable_regset; +#endif +extern void mark_elimination (int, int); + +/* In reginfo.c */ +extern int reg_classes_intersect_p (reg_class_t, reg_class_t); +extern int reg_class_subset_p (reg_class_t, reg_class_t); +extern void globalize_reg (int); +extern void init_reg_modes_target (void); +extern void init_regs (void); +extern void reinit_regs (void); +extern void init_fake_stack_mems (void); +extern void save_register_info (void); +extern void init_reg_sets (void); +extern void regclass (rtx, int); +extern void reg_scan (rtx, unsigned int); +extern void fix_register (const char *, int, int); +extern bool invalid_mode_change_p (unsigned int, enum reg_class); + +/* In reorg.c */ +extern void dbr_schedule (rtx); + +/* In reload1.c */ +extern int function_invariant_p (const_rtx); + +/* In calls.c */ +enum libcall_type +{ + LCT_NORMAL = 0, + LCT_CONST = 1, + LCT_PURE = 2, + LCT_NORETURN = 3, + LCT_THROW = 4, + LCT_RETURNS_TWICE = 5 +}; + +extern void emit_library_call (rtx, enum libcall_type, enum machine_mode, int, + ...); +extern rtx emit_library_call_value (rtx, rtx, enum libcall_type, + enum machine_mode, int, ...); + +/* In varasm.c */ +extern void init_varasm_once (void); + +extern rtx make_debug_expr_from_rtl (const_rtx); + +/* In read-rtl.c */ +extern bool read_rtx (const char *, rtx *); + +/* In alias.c */ +extern rtx canon_rtx (rtx); +extern int true_dependence (const_rtx, enum machine_mode, const_rtx, bool (*)(const_rtx, bool)); +extern rtx get_addr (rtx); +extern int canon_true_dependence (const_rtx, enum machine_mode, rtx, const_rtx, + rtx, bool (*)(const_rtx, bool)); +extern int read_dependence (const_rtx, const_rtx); +extern int anti_dependence (const_rtx, const_rtx); +extern int output_dependence (const_rtx, const_rtx); +extern int may_alias_p (const_rtx, const_rtx); +extern void init_alias_target (void); +extern void init_alias_analysis (void); +extern void end_alias_analysis (void); +extern void vt_equate_reg_base_value (const_rtx, const_rtx); +extern bool memory_modified_in_insn_p (const_rtx, const_rtx); +extern rtx find_base_term (rtx); +extern rtx gen_hard_reg_clobber (enum machine_mode, unsigned int); +extern rtx get_reg_known_value (unsigned int); +extern bool get_reg_known_equiv_p (unsigned int); +extern rtx get_reg_base_value (unsigned int); + +#ifdef STACK_REGS +extern int stack_regs_mentioned (const_rtx insn); +#endif + +/* In toplev.c */ +extern GTY(()) rtx stack_limit_rtx; + +/* In predict.c */ +extern void invert_br_probabilities (rtx); +extern bool expensive_function_p (int); + +/* In var-tracking.c */ +extern unsigned int variable_tracking_main (void); + +/* In stor-layout.c. */ +extern void get_mode_bounds (enum machine_mode, int, enum machine_mode, + rtx *, rtx *); + +/* In loop-unswitch.c */ +extern rtx reversed_condition (rtx); +extern rtx compare_and_jump_seq (rtx, rtx, enum rtx_code, rtx, int, rtx); + +/* In loop-iv.c */ +extern rtx canon_condition (rtx); +extern void simplify_using_condition (rtx, rtx *, struct bitmap_head_def *); + +/* In final.c */ +extern unsigned int compute_alignments (void); +extern int asm_str_count (const char *templ); + +struct rtl_hooks +{ + rtx (*gen_lowpart) (enum machine_mode, rtx); + rtx (*gen_lowpart_no_emit) (enum machine_mode, rtx); + rtx (*reg_nonzero_bits) (const_rtx, enum machine_mode, const_rtx, enum machine_mode, + unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT *); + rtx (*reg_num_sign_bit_copies) (const_rtx, enum machine_mode, const_rtx, enum machine_mode, + unsigned int, unsigned int *); + bool (*reg_truncated_to_mode) (enum machine_mode, const_rtx); + + /* Whenever you add entries here, make sure you adjust rtlhooks-def.h. */ +}; + +/* Each pass can provide its own. */ +extern struct rtl_hooks rtl_hooks; + +/* ... but then it has to restore these. */ +extern const struct rtl_hooks general_rtl_hooks; + +/* Keep this for the nonce. */ +#define gen_lowpart rtl_hooks.gen_lowpart + +extern void insn_locators_alloc (void); +extern void insn_locators_free (void); +extern void insn_locators_finalize (void); +extern void set_curr_insn_source_location (location_t); +extern location_t get_curr_insn_source_location (void); +extern void set_curr_insn_block (tree); +extern tree get_curr_insn_block (void); +extern int curr_insn_locator (void); +extern bool optimize_insn_for_size_p (void); +extern bool optimize_insn_for_speed_p (void); + +/* rtl-error.c */ +extern void _fatal_insn_not_found (const_rtx, const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void _fatal_insn (const char *, const_rtx, const char *, int, const char *) + ATTRIBUTE_NORETURN; + +#define fatal_insn(msgid, insn) \ + _fatal_insn (msgid, insn, __FILE__, __LINE__, __FUNCTION__) +#define fatal_insn_not_found(insn) \ + _fatal_insn_not_found (insn, __FILE__, __LINE__, __FUNCTION__) + + + +#endif /* ! GCC_RTL_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/safe-ctype.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/safe-ctype.h new file mode 100644 index 0000000..0266bf1 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/safe-ctype.h @@ -0,0 +1,150 @@ +/* <ctype.h> replacement macros. + + Copyright (C) 2000, 2001 Free Software Foundation, Inc. + Contributed by Zack Weinberg <zackw@stanford.edu>. + +This file is part of the libiberty library. +Libiberty is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public +License as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. + +Libiberty 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with libiberty; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, +Boston, MA 02110-1301, USA. */ + +/* This is a compatible replacement of the standard C library's <ctype.h> + with the following properties: + + - Implements all isxxx() macros required by C99. + - Also implements some character classes useful when + parsing C-like languages. + - Does not change behavior depending on the current locale. + - Behaves properly for all values in the range of a signed or + unsigned char. + + To avoid conflicts, this header defines the isxxx functions in upper + case, e.g. ISALPHA not isalpha. */ + +#ifndef SAFE_CTYPE_H +#define SAFE_CTYPE_H + +/* Determine host character set. */ +#define HOST_CHARSET_UNKNOWN 0 +#define HOST_CHARSET_ASCII 1 +#define HOST_CHARSET_EBCDIC 2 + +#if '\n' == 0x0A && ' ' == 0x20 && '0' == 0x30 \ + && 'A' == 0x41 && 'a' == 0x61 && '!' == 0x21 +# define HOST_CHARSET HOST_CHARSET_ASCII +#else +# if '\n' == 0x15 && ' ' == 0x40 && '0' == 0xF0 \ + && 'A' == 0xC1 && 'a' == 0x81 && '!' == 0x5A +# define HOST_CHARSET HOST_CHARSET_EBCDIC +# else +# define HOST_CHARSET HOST_CHARSET_UNKNOWN +# endif +#endif + +/* Categories. */ + +enum { + /* In C99 */ + _sch_isblank = 0x0001, /* space \t */ + _sch_iscntrl = 0x0002, /* nonprinting characters */ + _sch_isdigit = 0x0004, /* 0-9 */ + _sch_islower = 0x0008, /* a-z */ + _sch_isprint = 0x0010, /* any printing character including ' ' */ + _sch_ispunct = 0x0020, /* all punctuation */ + _sch_isspace = 0x0040, /* space \t \n \r \f \v */ + _sch_isupper = 0x0080, /* A-Z */ + _sch_isxdigit = 0x0100, /* 0-9A-Fa-f */ + + /* Extra categories useful to cpplib. */ + _sch_isidst = 0x0200, /* A-Za-z_ */ + _sch_isvsp = 0x0400, /* \n \r */ + _sch_isnvsp = 0x0800, /* space \t \f \v \0 */ + + /* Combinations of the above. */ + _sch_isalpha = _sch_isupper|_sch_islower, /* A-Za-z */ + _sch_isalnum = _sch_isalpha|_sch_isdigit, /* A-Za-z0-9 */ + _sch_isidnum = _sch_isidst|_sch_isdigit, /* A-Za-z0-9_ */ + _sch_isgraph = _sch_isalnum|_sch_ispunct, /* isprint and not space */ + _sch_iscppsp = _sch_isvsp|_sch_isnvsp, /* isspace + \0 */ + _sch_isbasic = _sch_isprint|_sch_iscppsp /* basic charset of ISO C + (plus ` and @) */ +}; + +/* Character classification. */ +extern const unsigned short _sch_istable[256]; + +#define _sch_test(c, bit) (_sch_istable[(c) & 0xff] & (unsigned short)(bit)) + +#define ISALPHA(c) _sch_test(c, _sch_isalpha) +#define ISALNUM(c) _sch_test(c, _sch_isalnum) +#define ISBLANK(c) _sch_test(c, _sch_isblank) +#define ISCNTRL(c) _sch_test(c, _sch_iscntrl) +#define ISDIGIT(c) _sch_test(c, _sch_isdigit) +#define ISGRAPH(c) _sch_test(c, _sch_isgraph) +#define ISLOWER(c) _sch_test(c, _sch_islower) +#define ISPRINT(c) _sch_test(c, _sch_isprint) +#define ISPUNCT(c) _sch_test(c, _sch_ispunct) +#define ISSPACE(c) _sch_test(c, _sch_isspace) +#define ISUPPER(c) _sch_test(c, _sch_isupper) +#define ISXDIGIT(c) _sch_test(c, _sch_isxdigit) + +#define ISIDNUM(c) _sch_test(c, _sch_isidnum) +#define ISIDST(c) _sch_test(c, _sch_isidst) +#define IS_ISOBASIC(c) _sch_test(c, _sch_isbasic) +#define IS_VSPACE(c) _sch_test(c, _sch_isvsp) +#define IS_NVSPACE(c) _sch_test(c, _sch_isnvsp) +#define IS_SPACE_OR_NUL(c) _sch_test(c, _sch_iscppsp) + +/* Character transformation. */ +extern const unsigned char _sch_toupper[256]; +extern const unsigned char _sch_tolower[256]; +#define TOUPPER(c) _sch_toupper[(c) & 0xff] +#define TOLOWER(c) _sch_tolower[(c) & 0xff] + +/* Prevent the users of safe-ctype.h from accidently using the routines + from ctype.h. Initially, the approach was to produce an error when + detecting that ctype.h has been included. But this was causing + trouble as ctype.h might get indirectly included as a result of + including another system header (for instance gnulib's stdint.h). + So we include ctype.h here and then immediately redefine its macros. */ + +#include <ctype.h> +#undef isalpha +#define isalpha(c) do_not_use_isalpha_with_safe_ctype +#undef isalnum +#define isalnum(c) do_not_use_isalnum_with_safe_ctype +#undef iscntrl +#define iscntrl(c) do_not_use_iscntrl_with_safe_ctype +#undef isdigit +#define isdigit(c) do_not_use_isdigit_with_safe_ctype +#undef isgraph +#define isgraph(c) do_not_use_isgraph_with_safe_ctype +#undef islower +#define islower(c) do_not_use_islower_with_safe_ctype +#undef isprint +#define isprint(c) do_not_use_isprint_with_safe_ctype +#undef ispunct +#define ispunct(c) do_not_use_ispunct_with_safe_ctype +#undef isspace +#define isspace(c) do_not_use_isspace_with_safe_ctype +#undef isupper +#define isupper(c) do_not_use_isupper_with_safe_ctype +#undef isxdigit +#define isxdigit(c) do_not_use_isxdigit_with_safe_ctype +#undef toupper +#define toupper(c) do_not_use_toupper_with_safe_ctype +#undef tolower +#define tolower(c) do_not_use_tolower_with_safe_ctype + +#endif /* SAFE_CTYPE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/sbitmap.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/sbitmap.h new file mode 100644 index 0000000..f78e0bf --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/sbitmap.h @@ -0,0 +1,266 @@ +/* Simple bitmaps. + Copyright (C) 1999, 2000, 2002, 2003, 2004, 2006, 2007, 2008, 2010 + 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/>. */ + +#ifndef GCC_SBITMAP_H +#define GCC_SBITMAP_H + +/* It's not clear yet whether using bitmap.[ch] will be a win. + It should be straightforward to convert so for now we keep things simple + while more important issues are dealt with. */ + +#define SBITMAP_ELT_BITS ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT) +#define SBITMAP_ELT_TYPE unsigned HOST_WIDEST_FAST_INT + +/* Can't use SBITMAP_ELT_BITS in this macro because it contains a + cast. There is no perfect macro in GCC to test against. This + suffices for roughly 99% of the hosts we run on, and the rest + don't have 256 bit integers. */ +#if HOST_BITS_PER_WIDEST_FAST_INT > 255 +#error Need to increase size of datatype used for popcount +#endif + +struct simple_bitmap_def +{ + unsigned char *popcount; /* Population count. */ + unsigned int n_bits; /* Number of bits. */ + unsigned int size; /* Size in elements. */ + SBITMAP_ELT_TYPE elms[1]; /* The elements. */ +}; + +/* Return the set size needed for N elements. */ +#define SBITMAP_SET_SIZE(N) (((N) + SBITMAP_ELT_BITS - 1) / SBITMAP_ELT_BITS) +#define SBITMAP_SIZE_BYTES(BITMAP) ((BITMAP)->size * sizeof (SBITMAP_ELT_TYPE)) + +/* Test if bit number bitno in the bitmap is set. */ +#define TEST_BIT(BITMAP, BITNO) \ +((BITMAP)->elms [(BITNO) / SBITMAP_ELT_BITS] >> (BITNO) % SBITMAP_ELT_BITS & 1) + +/* Set bit number BITNO in the sbitmap MAP. Updates population count + if this bitmap has one. */ + +static inline void +SET_BIT (sbitmap map, unsigned int bitno) +{ + if (map->popcount) + { + bool oldbit; + oldbit = TEST_BIT (map, bitno); + if (!oldbit) + map->popcount[bitno / SBITMAP_ELT_BITS]++; + } + map->elms[bitno / SBITMAP_ELT_BITS] + |= (SBITMAP_ELT_TYPE) 1 << (bitno) % SBITMAP_ELT_BITS; +} + + + +/* Reset bit number BITNO in the sbitmap MAP. Updates population + count if this bitmap has one. */ + +static inline void +RESET_BIT (sbitmap map, unsigned int bitno) +{ + if (map->popcount) + { + bool oldbit; + oldbit = TEST_BIT (map, bitno); + if (oldbit) + map->popcount[bitno / SBITMAP_ELT_BITS]--; + } + map->elms[bitno / SBITMAP_ELT_BITS] + &= ~((SBITMAP_ELT_TYPE) 1 << (bitno) % SBITMAP_ELT_BITS); +} + +/* The iterator for sbitmap. */ +typedef struct { + /* The pointer to the first word of the bitmap. */ + const SBITMAP_ELT_TYPE *ptr; + + /* The size of the bitmap. */ + unsigned int size; + + /* The current word index. */ + unsigned int word_num; + + /* The current bit index (not modulo SBITMAP_ELT_BITS). */ + unsigned int bit_num; + + /* The words currently visited. */ + SBITMAP_ELT_TYPE word; +} sbitmap_iterator; + +/* Initialize the iterator I with sbitmap BMP and the initial index + MIN. */ + +static inline void +sbitmap_iter_init (sbitmap_iterator *i, const_sbitmap bmp, unsigned int min) +{ + i->word_num = min / (unsigned int) SBITMAP_ELT_BITS; + i->bit_num = min; + i->size = bmp->size; + i->ptr = bmp->elms; + + if (i->word_num >= i->size) + i->word = 0; + else + i->word = (i->ptr[i->word_num] + >> (i->bit_num % (unsigned int) SBITMAP_ELT_BITS)); +} + +/* Return true if we have more bits to visit, in which case *N is set + to the index of the bit to be visited. Otherwise, return + false. */ + +static inline bool +sbitmap_iter_cond (sbitmap_iterator *i, unsigned int *n) +{ + /* Skip words that are zeros. */ + for (; i->word == 0; i->word = i->ptr[i->word_num]) + { + i->word_num++; + + /* If we have reached the end, break. */ + if (i->word_num >= i->size) + return false; + + i->bit_num = i->word_num * SBITMAP_ELT_BITS; + } + + /* Skip bits that are zero. */ + for (; (i->word & 1) == 0; i->word >>= 1) + i->bit_num++; + + *n = i->bit_num; + + return true; +} + +/* Advance to the next bit. */ + +static inline void +sbitmap_iter_next (sbitmap_iterator *i) +{ + i->word >>= 1; + i->bit_num++; +} + +/* Loop over all elements of SBITMAP, starting with MIN. In each + iteration, N is set to the index of the bit being visited. ITER is + an instance of sbitmap_iterator used to iterate the bitmap. */ + +#define EXECUTE_IF_SET_IN_SBITMAP(SBITMAP, MIN, N, ITER) \ + for (sbitmap_iter_init (&(ITER), (SBITMAP), (MIN)); \ + sbitmap_iter_cond (&(ITER), &(N)); \ + sbitmap_iter_next (&(ITER))) + +#define EXECUTE_IF_SET_IN_SBITMAP_REV(SBITMAP, N, CODE) \ +do { \ + unsigned int word_num_; \ + unsigned int bit_num_; \ + unsigned int size_ = (SBITMAP)->size; \ + SBITMAP_ELT_TYPE *ptr_ = (SBITMAP)->elms; \ + \ + for (word_num_ = size_; word_num_ > 0; word_num_--) \ + { \ + SBITMAP_ELT_TYPE word_ = ptr_[word_num_ - 1]; \ + \ + if (word_ != 0) \ + for (bit_num_ = SBITMAP_ELT_BITS; bit_num_ > 0; bit_num_--) \ + { \ + SBITMAP_ELT_TYPE _mask = (SBITMAP_ELT_TYPE)1 << (bit_num_ - 1);\ + \ + if ((word_ & _mask) != 0) \ + { \ + word_ &= ~ _mask; \ + (N) = (word_num_ - 1) * SBITMAP_ELT_BITS + bit_num_ - 1;\ + CODE; \ + if (word_ == 0) \ + break; \ + } \ + } \ + } \ +} while (0) + +#define sbitmap_free(MAP) (free((MAP)->popcount), free((MAP))) +#define sbitmap_vector_free(VEC) free(VEC) + +struct int_list; + +extern void dump_sbitmap (FILE *, const_sbitmap); +extern void dump_sbitmap_file (FILE *, const_sbitmap); +extern void dump_sbitmap_vector (FILE *, const char *, const char *, sbitmap *, + int); +extern sbitmap sbitmap_alloc (unsigned int); +extern sbitmap sbitmap_alloc_with_popcount (unsigned int); +extern sbitmap *sbitmap_vector_alloc (unsigned int, unsigned int); +extern sbitmap sbitmap_resize (sbitmap, unsigned int, int); +extern void sbitmap_copy (sbitmap, const_sbitmap); +extern void sbitmap_copy_n (sbitmap, const_sbitmap, unsigned int); +extern int sbitmap_equal (const_sbitmap, const_sbitmap); +extern bool sbitmap_empty_p (const_sbitmap); +extern bool sbitmap_range_empty_p (const_sbitmap, unsigned int, unsigned int); +extern void sbitmap_zero (sbitmap); +extern void sbitmap_ones (sbitmap); +extern void sbitmap_vector_zero (sbitmap *, unsigned int); +extern void sbitmap_vector_ones (sbitmap *, unsigned int); + +extern void sbitmap_union_of_diff (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_union_of_diff_cg (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap); +extern void sbitmap_difference (sbitmap, const_sbitmap, const_sbitmap); +extern void sbitmap_not (sbitmap, const_sbitmap); +extern void sbitmap_a_or_b_and_c (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_a_or_b_and_c_cg (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap); +extern void sbitmap_a_and_b_or_c (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_a_and_b_or_c_cg (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_any_common_bits (const_sbitmap, const_sbitmap); +extern void sbitmap_a_and_b (sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_a_and_b_cg (sbitmap, const_sbitmap, const_sbitmap); +extern void sbitmap_a_or_b (sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_a_or_b_cg (sbitmap, const_sbitmap, const_sbitmap); +extern void sbitmap_a_xor_b (sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_a_xor_b_cg (sbitmap, const_sbitmap, const_sbitmap); +extern bool sbitmap_a_subset_b_p (const_sbitmap, const_sbitmap); + +extern int sbitmap_first_set_bit (const_sbitmap); +extern int sbitmap_last_set_bit (const_sbitmap); + +extern void sbitmap_intersect_of_predsucc (sbitmap, sbitmap *, int, + struct int_list **); +#define sbitmap_intersect_of_predecessors sbitmap_intersect_of_predsucc +#define sbitmap_intersect_of_successors sbitmap_intersect_of_predsucc + +extern void sbitmap_union_of_predsucc (sbitmap, sbitmap *, int, + struct int_list **); +#define sbitmap_union_of_predecessors sbitmap_union_of_predsucc +#define sbitmap_union_of_successors sbitmap_union_of_predsucc + +/* Intersection and Union of preds/succs using the new flow graph + structure instead of the pred/succ arrays. */ + +extern void sbitmap_intersection_of_succs (sbitmap, sbitmap *, int); +extern void sbitmap_intersection_of_preds (sbitmap, sbitmap *, int); +extern void sbitmap_union_of_succs (sbitmap, sbitmap *, int); +extern void sbitmap_union_of_preds (sbitmap, sbitmap *, int); + +extern void debug_sbitmap (const_sbitmap); +extern sbitmap sbitmap_realloc (sbitmap, unsigned int); +extern unsigned long sbitmap_popcount(const_sbitmap, unsigned long); +extern void sbitmap_verify_popcount (const_sbitmap); +#endif /* ! GCC_SBITMAP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/splay-tree.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/splay-tree.h new file mode 100644 index 0000000..480b2c4 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/splay-tree.h @@ -0,0 +1,168 @@ +/* A splay-tree datatype. + Copyright 1998, 1999, 2000, 2002, 2005, 2007, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Mark Mitchell (mark@markmitchell.com). + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, 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 COPYING. If not, write to + the Free Software Foundation, 51 Franklin Street - Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* For an easily readable description of splay-trees, see: + + Lewis, Harry R. and Denenberg, Larry. Data Structures and Their + Algorithms. Harper-Collins, Inc. 1991. + + The major feature of splay trees is that all basic tree operations + are amortized O(log n) time for a tree with n nodes. */ + +#ifndef _SPLAY_TREE_H +#define _SPLAY_TREE_H + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include "ansidecl.h" + +#ifndef _WIN64 + typedef unsigned long int libi_uhostptr_t; + typedef long int libi_shostptr_t; +#else +#ifdef __GNUC__ + __extension__ +#endif + typedef unsigned long long libi_uhostptr_t; +#ifdef __GNUC__ + __extension__ +#endif + typedef long long libi_shostptr_t; +#endif + +#ifndef GTY +#define GTY(X) +#endif + +/* Use typedefs for the key and data types to facilitate changing + these types, if necessary. These types should be sufficiently wide + that any pointer or scalar can be cast to these types, and then + cast back, without loss of precision. */ +typedef libi_uhostptr_t splay_tree_key; +typedef libi_uhostptr_t splay_tree_value; + +/* Forward declaration for a node in the tree. */ +typedef struct splay_tree_node_s *splay_tree_node; + +/* The type of a function which compares two splay-tree keys. The + function should return values as for qsort. */ +typedef int (*splay_tree_compare_fn) (splay_tree_key, splay_tree_key); + +/* The type of a function used to deallocate any resources associated + with the key. */ +typedef void (*splay_tree_delete_key_fn) (splay_tree_key); + +/* The type of a function used to deallocate any resources associated + with the value. */ +typedef void (*splay_tree_delete_value_fn) (splay_tree_value); + +/* The type of a function used to iterate over the tree. */ +typedef int (*splay_tree_foreach_fn) (splay_tree_node, void*); + +/* The type of a function used to allocate memory for tree root and + node structures. The first argument is the number of bytes needed; + the second is a data pointer the splay tree functions pass through + to the allocator. This function must never return zero. */ +typedef void *(*splay_tree_allocate_fn) (int, void *); + +/* The type of a function used to free memory allocated using the + corresponding splay_tree_allocate_fn. The first argument is the + memory to be freed; the latter is a data pointer the splay tree + functions pass through to the freer. */ +typedef void (*splay_tree_deallocate_fn) (void *, void *); + +/* The nodes in the splay tree. */ +struct GTY(()) splay_tree_node_s { + /* The key. */ + splay_tree_key GTY ((use_param1)) key; + + /* The value. */ + splay_tree_value GTY ((use_param2)) value; + + /* The left and right children, respectively. */ + splay_tree_node GTY ((use_params)) left; + splay_tree_node GTY ((use_params)) right; +}; + +/* The splay tree itself. */ +struct GTY(()) splay_tree_s { + /* The root of the tree. */ + splay_tree_node GTY ((use_params)) root; + + /* The comparision function. */ + splay_tree_compare_fn comp; + + /* The deallocate-key function. NULL if no cleanup is necessary. */ + splay_tree_delete_key_fn delete_key; + + /* The deallocate-value function. NULL if no cleanup is necessary. */ + splay_tree_delete_value_fn delete_value; + + /* Node allocate function. Takes allocate_data as a parameter. */ + splay_tree_allocate_fn allocate; + + /* Free function for nodes and trees. Takes allocate_data as a parameter. */ + splay_tree_deallocate_fn deallocate; + + /* Parameter for allocate/free functions. */ + void * GTY((skip)) allocate_data; +}; + +typedef struct splay_tree_s *splay_tree; + +extern splay_tree splay_tree_new (splay_tree_compare_fn, + splay_tree_delete_key_fn, + splay_tree_delete_value_fn); +extern splay_tree splay_tree_new_with_allocator (splay_tree_compare_fn, + splay_tree_delete_key_fn, + splay_tree_delete_value_fn, + splay_tree_allocate_fn, + splay_tree_deallocate_fn, + void *); +extern splay_tree splay_tree_new_typed_alloc (splay_tree_compare_fn, + splay_tree_delete_key_fn, + splay_tree_delete_value_fn, + splay_tree_allocate_fn, + splay_tree_allocate_fn, + splay_tree_deallocate_fn, + void *); +extern void splay_tree_delete (splay_tree); +extern splay_tree_node splay_tree_insert (splay_tree, + splay_tree_key, + splay_tree_value); +extern void splay_tree_remove (splay_tree, splay_tree_key); +extern splay_tree_node splay_tree_lookup (splay_tree, splay_tree_key); +extern splay_tree_node splay_tree_predecessor (splay_tree, splay_tree_key); +extern splay_tree_node splay_tree_successor (splay_tree, splay_tree_key); +extern splay_tree_node splay_tree_max (splay_tree); +extern splay_tree_node splay_tree_min (splay_tree); +extern int splay_tree_foreach (splay_tree, splay_tree_foreach_fn, void*); +extern int splay_tree_compare_ints (splay_tree_key, splay_tree_key); +extern int splay_tree_compare_pointers (splay_tree_key, splay_tree_key); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* _SPLAY_TREE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/statistics.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/statistics.h new file mode 100644 index 0000000..6e21e85 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/statistics.h @@ -0,0 +1,51 @@ +/* Memory and optimization statistics helpers. + Copyright (C) 2004, 2007, 2008 + Free Software Foundation, Inc. + Contributed by Cygnus Solutions. + + 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/>. */ + +#ifndef GCC_STATISTICS +#define GCC_STATISTICS + +#ifdef GATHER_STATISTICS +#define MEM_STAT_DECL , const char * ARG_UNUSED (_loc_name), int ARG_UNUSED (_loc_line), const char * ARG_UNUSED (_loc_function) +#define ALONE_MEM_STAT_DECL const char * ARG_UNUSED (_loc_name), int ARG_UNUSED (_loc_line), const char * ARG_UNUSED (_loc_function) +#define PASS_MEM_STAT , _loc_name, _loc_line, _loc_function +#define ALONE_PASS_MEM_STAT _loc_name, _loc_line, _loc_function +#define MEM_STAT_INFO , __FILE__, __LINE__, __FUNCTION__ +#define ALONE_MEM_STAT_INFO __FILE__, __LINE__, __FUNCTION__ +#else +#define MEM_STAT_DECL +#define ALONE_MEM_STAT_DECL void +#define PASS_MEM_STAT +#define ALONE_PASS_MEM_STAT +#define MEM_STAT_INFO +#define ALONE_MEM_STAT_INFO +#endif + +struct function; + +/* In statistics.c */ +extern void statistics_early_init (void); +extern void statistics_init (void); +extern void statistics_fini (void); +extern void statistics_fini_pass (void); +extern void statistics_counter_event (struct function *, const char *, int); +extern void statistics_histogram_event (struct function *, const char *, int); + +#endif diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/symtab.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/symtab.h new file mode 100644 index 0000000..4107a6f --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/symtab.h @@ -0,0 +1,104 @@ +/* Hash tables. + Copyright (C) 2000, 2001, 2003, 2004, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + +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 3, 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; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + +#ifndef LIBCPP_SYMTAB_H +#define LIBCPP_SYMTAB_H + +#include "obstack.h" + +#ifndef GTY +#define GTY(x) /* nothing */ +#endif + +/* This is what each hash table entry points to. It may be embedded + deeply within another object. */ +typedef struct ht_identifier ht_identifier; +typedef struct ht_identifier *ht_identifier_ptr; +struct GTY(()) ht_identifier { + const unsigned char *str; + unsigned int len; + unsigned int hash_value; +}; + +#define HT_LEN(NODE) ((NODE)->len) +#define HT_STR(NODE) ((NODE)->str) + +typedef struct ht hash_table; +typedef struct ht_identifier *hashnode; + +enum ht_lookup_option {HT_NO_INSERT = 0, HT_ALLOC}; + +/* An identifier hash table for cpplib and the front ends. */ +struct ht +{ + /* Identifiers are allocated from here. */ + struct obstack stack; + + hashnode *entries; + /* Call back, allocate a node. */ + hashnode (*alloc_node) (hash_table *); + /* Call back, allocate something that hangs off a node like a cpp_macro. + NULL means use the usual allocator. */ + void * (*alloc_subobject) (size_t); + + unsigned int nslots; /* Total slots in the entries array. */ + unsigned int nelements; /* Number of live elements. */ + + /* Link to reader, if any. For the benefit of cpplib. */ + struct cpp_reader *pfile; + + /* Table usage statistics. */ + unsigned int searches; + unsigned int collisions; + + /* Should 'entries' be freed when it is no longer needed? */ + bool entries_owned; +}; + +/* Initialize the hashtable with 2 ^ order entries. */ +extern hash_table *ht_create (unsigned int order); + +/* Frees all memory associated with a hash table. */ +extern void ht_destroy (hash_table *); + +extern hashnode ht_lookup (hash_table *, const unsigned char *, + size_t, enum ht_lookup_option); +extern hashnode ht_lookup_with_hash (hash_table *, const unsigned char *, + size_t, unsigned int, + enum ht_lookup_option); +#define HT_HASHSTEP(r, c) ((r) * 67 + ((c) - 113)); +#define HT_HASHFINISH(r, len) ((r) + (len)) + +/* For all nodes in TABLE, make a callback. The callback takes + TABLE->PFILE, the node, and a PTR, and the callback sequence stops + if the callback returns zero. */ +typedef int (*ht_cb) (struct cpp_reader *, hashnode, const void *); +extern void ht_forall (hash_table *, ht_cb, const void *); + +/* For all nodes in TABLE, call the callback. If the callback returns + a nonzero value, the node is removed from the table. */ +extern void ht_purge (hash_table *, ht_cb, const void *); + +/* Restore the hash table. */ +extern void ht_load (hash_table *ht, hashnode *entries, + unsigned int nslots, unsigned int nelements, bool own); + +/* Dump allocation statistics to stderr. */ +extern void ht_dump_statistics (hash_table *); + +#endif /* LIBCPP_SYMTAB_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/sync-builtins.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/sync-builtins.def new file mode 100644 index 0000000..614e6e3 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/sync-builtins.def @@ -0,0 +1,252 @@ +/* This file contains the definitions and documentation for the + synchronization builtins used in the GNU compiler. + Copyright (C) 2005, 2007, 2010 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, you should define a macro: + + DEF_SYNC_BUILTIN (ENUM, NAME, TYPE, ATTRS) + + See builtins.def for details. */ + +/* Synchronization Primitives. The "_N" version is the one that the user + is supposed to be using. It's overloaded, and is resolved to one of the + "_1" through "_16" versions, plus some extra casts. */ + +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_ADD_N, "__sync_fetch_and_add", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_ADD_1, "__sync_fetch_and_add_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_ADD_2, "__sync_fetch_and_add_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_ADD_4, "__sync_fetch_and_add_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_ADD_8, "__sync_fetch_and_add_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_ADD_16, "__sync_fetch_and_add_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_SUB_N, "__sync_fetch_and_sub", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_SUB_1, "__sync_fetch_and_sub_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_SUB_2, "__sync_fetch_and_sub_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_SUB_4, "__sync_fetch_and_sub_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_SUB_8, "__sync_fetch_and_sub_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_SUB_16, "__sync_fetch_and_sub_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_OR_N, "__sync_fetch_and_or", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_OR_1, "__sync_fetch_and_or_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_OR_2, "__sync_fetch_and_or_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_OR_4, "__sync_fetch_and_or_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_OR_8, "__sync_fetch_and_or_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_OR_16, "__sync_fetch_and_or_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_AND_N, "__sync_fetch_and_and", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_AND_1, "__sync_fetch_and_and_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_AND_2, "__sync_fetch_and_and_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_AND_4, "__sync_fetch_and_and_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_AND_8, "__sync_fetch_and_and_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_AND_16, "__sync_fetch_and_and_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_XOR_N, "__sync_fetch_and_xor", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_XOR_1, "__sync_fetch_and_xor_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_XOR_2, "__sync_fetch_and_xor_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_XOR_4, "__sync_fetch_and_xor_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_XOR_8, "__sync_fetch_and_xor_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_XOR_16, "__sync_fetch_and_xor_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_NAND_N, "__sync_fetch_and_nand", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_NAND_1, "__sync_fetch_and_nand_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_NAND_2, "__sync_fetch_and_nand_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_NAND_4, "__sync_fetch_and_nand_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_NAND_8, "__sync_fetch_and_nand_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_FETCH_AND_NAND_16, "__sync_fetch_and_nand_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_ADD_AND_FETCH_N, "__sync_add_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ADD_AND_FETCH_1, "__sync_add_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ADD_AND_FETCH_2, "__sync_add_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ADD_AND_FETCH_4, "__sync_add_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ADD_AND_FETCH_8, "__sync_add_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_ADD_AND_FETCH_16, "__sync_add_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SUB_AND_FETCH_N, "__sync_sub_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SUB_AND_FETCH_1, "__sync_sub_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SUB_AND_FETCH_2, "__sync_sub_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SUB_AND_FETCH_4, "__sync_sub_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SUB_AND_FETCH_8, "__sync_sub_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_SUB_AND_FETCH_16, "__sync_sub_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_OR_AND_FETCH_N, "__sync_or_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_OR_AND_FETCH_1, "__sync_or_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_OR_AND_FETCH_2, "__sync_or_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_OR_AND_FETCH_4, "__sync_or_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_OR_AND_FETCH_8, "__sync_or_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_OR_AND_FETCH_16, "__sync_or_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_AND_AND_FETCH_N, "__sync_and_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_AND_AND_FETCH_1, "__sync_and_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_AND_AND_FETCH_2, "__sync_and_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_AND_AND_FETCH_4, "__sync_and_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_AND_AND_FETCH_8, "__sync_and_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_AND_AND_FETCH_16, "__sync_and_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_XOR_AND_FETCH_N, "__sync_xor_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_XOR_AND_FETCH_1, "__sync_xor_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_XOR_AND_FETCH_2, "__sync_xor_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_XOR_AND_FETCH_4, "__sync_xor_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_XOR_AND_FETCH_8, "__sync_xor_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_XOR_AND_FETCH_16, "__sync_xor_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_NAND_AND_FETCH_N, "__sync_nand_and_fetch", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_NAND_AND_FETCH_1, "__sync_nand_and_fetch_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_NAND_AND_FETCH_2, "__sync_nand_and_fetch_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_NAND_AND_FETCH_4, "__sync_nand_and_fetch_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_NAND_AND_FETCH_8, "__sync_nand_and_fetch_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_NAND_AND_FETCH_16, "__sync_nand_and_fetch_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_BOOL_COMPARE_AND_SWAP_N, + "__sync_bool_compare_and_swap", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_BOOL_COMPARE_AND_SWAP_1, + "__sync_bool_compare_and_swap_1", + BT_FN_BOOL_VPTR_I1_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_BOOL_COMPARE_AND_SWAP_2, + "__sync_bool_compare_and_swap_2", + BT_FN_BOOL_VPTR_I2_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_BOOL_COMPARE_AND_SWAP_4, + "__sync_bool_compare_and_swap_4", + BT_FN_BOOL_VPTR_I4_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_BOOL_COMPARE_AND_SWAP_8, + "__sync_bool_compare_and_swap_8", + BT_FN_BOOL_VPTR_I8_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_BOOL_COMPARE_AND_SWAP_16, + "__sync_bool_compare_and_swap_16", + BT_FN_BOOL_VPTR_I16_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_VAL_COMPARE_AND_SWAP_N, + "__sync_val_compare_and_swap", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_VAL_COMPARE_AND_SWAP_1, + "__sync_val_compare_and_swap_1", + BT_FN_I1_VPTR_I1_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_VAL_COMPARE_AND_SWAP_2, + "__sync_val_compare_and_swap_2", + BT_FN_I2_VPTR_I2_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_VAL_COMPARE_AND_SWAP_4, + "__sync_val_compare_and_swap_4", + BT_FN_I4_VPTR_I4_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_VAL_COMPARE_AND_SWAP_8, + "__sync_val_compare_and_swap_8", + BT_FN_I8_VPTR_I8_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_VAL_COMPARE_AND_SWAP_16, + "__sync_val_compare_and_swap_16", + BT_FN_I16_VPTR_I16_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_TEST_AND_SET_N, "__sync_lock_test_and_set", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_TEST_AND_SET_1, "__sync_lock_test_and_set_1", + BT_FN_I1_VPTR_I1, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_TEST_AND_SET_2, "__sync_lock_test_and_set_2", + BT_FN_I2_VPTR_I2, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_TEST_AND_SET_4, "__sync_lock_test_and_set_4", + BT_FN_I4_VPTR_I4, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_TEST_AND_SET_8, "__sync_lock_test_and_set_8", + BT_FN_I8_VPTR_I8, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_TEST_AND_SET_16, "__sync_lock_test_and_set_16", + BT_FN_I16_VPTR_I16, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_RELEASE_N, "__sync_lock_release", + BT_FN_VOID_VAR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_RELEASE_1, "__sync_lock_release_1", + BT_FN_VOID_VPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_RELEASE_2, "__sync_lock_release_2", + BT_FN_VOID_VPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_RELEASE_4, "__sync_lock_release_4", + BT_FN_VOID_VPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_RELEASE_8, "__sync_lock_release_8", + BT_FN_VOID_VPTR, ATTR_NOTHROW_LEAF_LIST) +DEF_SYNC_BUILTIN (BUILT_IN_LOCK_RELEASE_16, "__sync_lock_release_16", + BT_FN_VOID_VPTR, ATTR_NOTHROW_LEAF_LIST) + +DEF_SYNC_BUILTIN (BUILT_IN_SYNCHRONIZE, "__sync_synchronize", + BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/system.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/system.h new file mode 100644 index 0000000..0bf9b92 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/system.h @@ -0,0 +1,972 @@ +/* Get common system includes and various definitions and declarations based + on autoconf macros. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, + 2009, 2010 + 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/>. */ + + +#ifndef GCC_SYSTEM_H +#define GCC_SYSTEM_H + +/* We must include stdarg.h before stdio.h. */ +#include <stdarg.h> + +#ifndef va_copy +# ifdef __va_copy +# define va_copy(d,s) __va_copy((d),(s)) +# else +# define va_copy(d,s) ((d) = (s)) +# endif +#endif + +#ifdef HAVE_STDDEF_H +# include <stddef.h> +#endif + +#include <stdio.h> + +/* Define a generic NULL if one hasn't already been defined. */ +#ifndef NULL +#define NULL 0 +#endif + +/* Use the unlocked open routines from libiberty. */ +#ifdef fopen /* fopen is a #define on VMS. */ +#undef fopen +#endif +#define fopen(PATH,MODE) fopen_unlocked(PATH,MODE) +#define fdopen(FILDES,MODE) fdopen_unlocked(FILDES,MODE) +#define freopen(PATH,MODE,STREAM) freopen_unlocked(PATH,MODE,STREAM) + +/* The compiler is not a multi-threaded application and therefore we + do not have to use the locking functions. In fact, using the locking + functions can cause the compiler to be significantly slower under + I/O bound conditions (such as -g -O0 on very large source files). + + HAVE_DECL_PUTC_UNLOCKED actually indicates whether or not the stdio + code is multi-thread safe by default. If it is set to 0, then do + not worry about using the _unlocked functions. + + fputs_unlocked, fwrite_unlocked, and fprintf_unlocked are + extensions and need to be prototyped by hand (since we do not + define _GNU_SOURCE). */ + +#if defined HAVE_DECL_PUTC_UNLOCKED && HAVE_DECL_PUTC_UNLOCKED + +# ifdef HAVE_PUTC_UNLOCKED +# undef putc +# define putc(C, Stream) putc_unlocked (C, Stream) +# endif +# ifdef HAVE_PUTCHAR_UNLOCKED +# undef putchar +# define putchar(C) putchar_unlocked (C) +# endif +# ifdef HAVE_GETC_UNLOCKED +# undef getc +# define getc(Stream) getc_unlocked (Stream) +# endif +# ifdef HAVE_GETCHAR_UNLOCKED +# undef getchar +# define getchar() getchar_unlocked () +# endif +# ifdef HAVE_FPUTC_UNLOCKED +# undef fputc +# define fputc(C, Stream) fputc_unlocked (C, Stream) +# endif + +# ifdef HAVE_CLEARERR_UNLOCKED +# undef clearerr +# define clearerr(Stream) clearerr_unlocked (Stream) +# if defined (HAVE_DECL_CLEARERR_UNLOCKED) && !HAVE_DECL_CLEARERR_UNLOCKED +extern void clearerr_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FEOF_UNLOCKED +# undef feof +# define feof(Stream) feof_unlocked (Stream) +# if defined (HAVE_DECL_FEOF_UNLOCKED) && !HAVE_DECL_FEOF_UNLOCKED +extern int feof_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FILENO_UNLOCKED +# undef fileno +# define fileno(Stream) fileno_unlocked (Stream) +# if defined (HAVE_DECL_FILENO_UNLOCKED) && !HAVE_DECL_FILENO_UNLOCKED +extern int fileno_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FFLUSH_UNLOCKED +# undef fflush +# define fflush(Stream) fflush_unlocked (Stream) +# if defined (HAVE_DECL_FFLUSH_UNLOCKED) && !HAVE_DECL_FFLUSH_UNLOCKED +extern int fflush_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FGETC_UNLOCKED +# undef fgetc +# define fgetc(Stream) fgetc_unlocked (Stream) +# if defined (HAVE_DECL_FGETC_UNLOCKED) && !HAVE_DECL_FGETC_UNLOCKED +extern int fgetc_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FGETS_UNLOCKED +# undef fgets +# define fgets(S, n, Stream) fgets_unlocked (S, n, Stream) +# if defined (HAVE_DECL_FGETS_UNLOCKED) && !HAVE_DECL_FGETS_UNLOCKED +extern char *fgets_unlocked (char *, int, FILE *); +# endif +# endif +# ifdef HAVE_FPUTS_UNLOCKED +# undef fputs +# define fputs(String, Stream) fputs_unlocked (String, Stream) +# if defined (HAVE_DECL_FPUTS_UNLOCKED) && !HAVE_DECL_FPUTS_UNLOCKED +extern int fputs_unlocked (const char *, FILE *); +# endif +# endif +# ifdef HAVE_FERROR_UNLOCKED +# undef ferror +# define ferror(Stream) ferror_unlocked (Stream) +# if defined (HAVE_DECL_FERROR_UNLOCKED) && !HAVE_DECL_FERROR_UNLOCKED +extern int ferror_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FREAD_UNLOCKED +# undef fread +# define fread(Ptr, Size, N, Stream) fread_unlocked (Ptr, Size, N, Stream) +# if defined (HAVE_DECL_FREAD_UNLOCKED) && !HAVE_DECL_FREAD_UNLOCKED +extern size_t fread_unlocked (void *, size_t, size_t, FILE *); +# endif +# endif +# ifdef HAVE_FWRITE_UNLOCKED +# undef fwrite +# define fwrite(Ptr, Size, N, Stream) fwrite_unlocked (Ptr, Size, N, Stream) +# if defined (HAVE_DECL_FWRITE_UNLOCKED) && !HAVE_DECL_FWRITE_UNLOCKED +extern size_t fwrite_unlocked (const void *, size_t, size_t, FILE *); +# endif +# endif +# ifdef HAVE_FPRINTF_UNLOCKED +# undef fprintf +/* We can't use a function-like macro here because we don't know if + we have varargs macros. */ +# define fprintf fprintf_unlocked +# if defined (HAVE_DECL_FPRINTF_UNLOCKED) && !HAVE_DECL_FPRINTF_UNLOCKED +extern int fprintf_unlocked (FILE *, const char *, ...); +# endif +# endif + +#endif + +/* ??? Glibc's fwrite/fread_unlocked macros cause + "warning: signed and unsigned type in conditional expression". */ +#undef fread_unlocked +#undef fwrite_unlocked + +/* There are an extraordinary number of issues with <ctype.h>. + The last straw is that it varies with the locale. Use libiberty's + replacement instead. */ +#include "safe-ctype.h" + +#include <sys/types.h> + +#include <errno.h> + +#if !defined (errno) && defined (HAVE_DECL_ERRNO) && !HAVE_DECL_ERRNO +extern int errno; +#endif + +#ifdef __cplusplus +# include <cstring> +#endif + +/* Some of glibc's string inlines cause warnings. Plus we'd rather + rely on (and therefore test) GCC's string builtins. */ +#define __NO_STRING_INLINES + +#ifdef STRING_WITH_STRINGS +# include <string.h> +# include <strings.h> +#else +# ifdef HAVE_STRING_H +# include <string.h> +# else +# ifdef HAVE_STRINGS_H +# include <strings.h> +# endif +# endif +#endif + +#ifdef HAVE_STDLIB_H +# include <stdlib.h> +#endif + +/* If we don't have an overriding definition, set SUCCESS_EXIT_CODE and + FATAL_EXIT_CODE to EXIT_SUCCESS and EXIT_FAILURE respectively, + or 0 and 1 if those macros are not defined. */ +#ifndef SUCCESS_EXIT_CODE +# ifdef EXIT_SUCCESS +# define SUCCESS_EXIT_CODE EXIT_SUCCESS +# else +# define SUCCESS_EXIT_CODE 0 +# endif +#endif + +#ifndef FATAL_EXIT_CODE +# ifdef EXIT_FAILURE +# define FATAL_EXIT_CODE EXIT_FAILURE +# else +# define FATAL_EXIT_CODE 1 +# endif +#endif + +#define ICE_EXIT_CODE 4 + +#ifdef HAVE_UNISTD_H +# include <unistd.h> +#endif + +#ifdef HAVE_SYS_PARAM_H +# include <sys/param.h> +/* We use this identifier later and it appears in some vendor param.h's. */ +# undef PREFETCH +#endif + +#if HAVE_LIMITS_H +# include <limits.h> +#endif + +/* Get definitions of HOST_WIDE_INT and HOST_WIDEST_INT. */ +#include "hwint.h" + +/* A macro to determine whether a VALUE lies inclusively within a + certain range without evaluating the VALUE more than once. This + macro won't warn if the VALUE is unsigned and the LOWER bound is + zero, as it would e.g. with "VALUE >= 0 && ...". Note the LOWER + bound *is* evaluated twice, and LOWER must not be greater than + UPPER. However the bounds themselves can be either positive or + negative. */ +#define IN_RANGE(VALUE, LOWER, UPPER) \ + ((unsigned HOST_WIDE_INT) (VALUE) - (unsigned HOST_WIDE_INT) (LOWER) \ + <= (unsigned HOST_WIDE_INT) (UPPER) - (unsigned HOST_WIDE_INT) (LOWER)) + +/* Infrastructure for defining missing _MAX and _MIN macros. Note that + macros defined with these cannot be used in #if. */ + +/* The extra casts work around common compiler bugs. */ +#define INTTYPE_SIGNED(t) (! ((t) 0 < (t) -1)) +/* The outer cast is needed to work around a bug in Cray C 5.0.3.0. + It is necessary at least when t == time_t. */ +#define INTTYPE_MINIMUM(t) ((t) (INTTYPE_SIGNED (t) \ + ? ~ (t) 0 << (sizeof(t) * CHAR_BIT - 1) : (t) 0)) +#define INTTYPE_MAXIMUM(t) ((t) (~ (t) 0 - INTTYPE_MINIMUM (t))) + +/* Use that infrastructure to provide a few constants. */ +#ifndef UCHAR_MAX +# define UCHAR_MAX INTTYPE_MAXIMUM (unsigned char) +#endif + +#ifdef TIME_WITH_SYS_TIME +# include <sys/time.h> +# include <time.h> +#else +# if HAVE_SYS_TIME_H +# include <sys/time.h> +# else +# ifdef HAVE_TIME_H +# include <time.h> +# endif +# endif +#endif + +#ifdef HAVE_FCNTL_H +# include <fcntl.h> +#else +# ifdef HAVE_SYS_FILE_H +# include <sys/file.h> +# endif +#endif + +#ifndef SEEK_SET +# define SEEK_SET 0 +# define SEEK_CUR 1 +# define SEEK_END 2 +#endif +#ifndef F_OK +# define F_OK 0 +# define X_OK 1 +# define W_OK 2 +# define R_OK 4 +#endif +#ifndef O_RDONLY +# define O_RDONLY 0 +#endif +#ifndef O_WRONLY +# define O_WRONLY 1 +#endif +#ifndef O_BINARY +# define O_BINARY 0 +#endif + +/* Some systems define these in, e.g., param.h. We undefine these names + here to avoid the warnings. We prefer to use our definitions since we + know they are correct. */ + +#undef MIN +#undef MAX +#define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) +#define MAX(X,Y) ((X) > (Y) ? (X) : (Y)) + +/* Returns the least number N such that N * Y >= X. */ +#define CEIL(x,y) (((x) + (y) - 1) / (y)) + +#ifdef HAVE_SYS_WAIT_H +#include <sys/wait.h> +#endif + +#ifndef WIFSIGNALED +#define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f) +#endif +#ifndef WTERMSIG +#define WTERMSIG(S) ((S) & 0x7f) +#endif +#ifndef WIFEXITED +#define WIFEXITED(S) (((S) & 0xff) == 0) +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(S) (((S) & 0xff00) >> 8) +#endif +#ifndef WSTOPSIG +#define WSTOPSIG WEXITSTATUS +#endif +#ifndef WCOREDUMP +#define WCOREDUMP(S) ((S) & WCOREFLG) +#endif +#ifndef WCOREFLG +#define WCOREFLG 0200 +#endif + +#include <signal.h> +#if !defined (SIGCHLD) && defined (SIGCLD) +# define SIGCHLD SIGCLD +#endif + +#ifdef HAVE_SYS_MMAN_H +# include <sys/mman.h> +#endif + +#ifndef MAP_FAILED +# define MAP_FAILED ((void *)-1) +#endif + +#if !defined (MAP_ANONYMOUS) && defined (MAP_ANON) +# define MAP_ANONYMOUS MAP_ANON +#endif + +#ifdef HAVE_SYS_RESOURCE_H +# include <sys/resource.h> +#endif + +#ifdef HAVE_SYS_TIMES_H +# include <sys/times.h> +#endif + +/* The HAVE_DECL_* macros are three-state, undefined, 0 or 1. If they + are defined to 0 then we must provide the relevant declaration + here. These checks will be in the undefined state while configure + is running so be careful to test "defined (HAVE_DECL_*)". */ + +#if defined (HAVE_DECL_ATOF) && !HAVE_DECL_ATOF +extern double atof (const char *); +#endif + +#if defined (HAVE_DECL_ATOL) && !HAVE_DECL_ATOL +extern long atol (const char *); +#endif + +#if defined (HAVE_DECL_FREE) && !HAVE_DECL_FREE +extern void free (void *); +#endif + +#if defined (HAVE_DECL_GETCWD) && !HAVE_DECL_GETCWD +extern char *getcwd (char *, size_t); +#endif + +#if defined (HAVE_DECL_GETENV) && !HAVE_DECL_GETENV +extern char *getenv (const char *); +#endif + +#if defined (HAVE_DECL_GETOPT) && !HAVE_DECL_GETOPT +extern int getopt (int, char * const *, const char *); +#endif + +#if defined (HAVE_DECL_GETPAGESIZE) && !HAVE_DECL_GETPAGESIZE +extern int getpagesize (void); +#endif + +#if defined (HAVE_DECL_GETWD) && !HAVE_DECL_GETWD +extern char *getwd (char *); +#endif + +#if defined (HAVE_DECL_SBRK) && !HAVE_DECL_SBRK +extern void *sbrk (int); +#endif + +#if defined (HAVE_DECL_STRSTR) && !HAVE_DECL_STRSTR +extern char *strstr (const char *, const char *); +#endif + +#ifdef HAVE_MALLOC_H +#include <malloc.h> +#endif + +#if defined (HAVE_DECL_MALLOC) && !HAVE_DECL_MALLOC +extern void *malloc (size_t); +#endif + +#if defined (HAVE_DECL_CALLOC) && !HAVE_DECL_CALLOC +extern void *calloc (size_t, size_t); +#endif + +#if defined (HAVE_DECL_REALLOC) && !HAVE_DECL_REALLOC +extern void *realloc (void *, size_t); +#endif + +#ifdef HAVE_STDINT_H +#include <stdint.h> +#endif + +#ifdef HAVE_INTTYPES_H +#include <inttypes.h> +#endif + +/* If the system doesn't provide strsignal, we get it defined in + libiberty but no declaration is supplied. */ +#if !defined (HAVE_STRSIGNAL) \ + || (defined (HAVE_DECL_STRSIGNAL) && !HAVE_DECL_STRSIGNAL) +# ifndef strsignal +extern const char *strsignal (int); +# endif +#endif + +#ifdef HAVE_GETRLIMIT +# if defined (HAVE_DECL_GETRLIMIT) && !HAVE_DECL_GETRLIMIT +# ifndef getrlimit +struct rlimit; +extern int getrlimit (int, struct rlimit *); +# endif +# endif +#endif + +#ifdef HAVE_SETRLIMIT +# if defined (HAVE_DECL_SETRLIMIT) && !HAVE_DECL_SETRLIMIT +# ifndef setrlimit +struct rlimit; +extern int setrlimit (int, const struct rlimit *); +# endif +# endif +#endif + +#if defined (HAVE_DECL_ABORT) && !HAVE_DECL_ABORT +extern void abort (void); +#endif + +#if defined (HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF +extern int snprintf (char *, size_t, const char *, ...); +#endif + +#if defined (HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF +extern int vsnprintf(char *, size_t, const char *, va_list); +#endif + +/* 1 if we have C99 designated initializers. */ +#if !defined(HAVE_DESIGNATED_INITIALIZERS) +#define HAVE_DESIGNATED_INITIALIZERS \ + (((GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)) \ + && !defined(__cplusplus)) +#endif + +#if HAVE_SYS_STAT_H +# include <sys/stat.h> +#endif + +/* Test if something is a normal file. */ +#ifndef S_ISREG +#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) +#endif + +/* Test if something is a directory. */ +#ifndef S_ISDIR +#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) +#endif + +/* Test if something is a character special file. */ +#ifndef S_ISCHR +#define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR) +#endif + +/* Test if something is a block special file. */ +#ifndef S_ISBLK +#define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK) +#endif + +/* Test if something is a socket. */ +#ifndef S_ISSOCK +# ifdef S_IFSOCK +# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK) +# else +# define S_ISSOCK(m) 0 +# endif +#endif + +/* Test if something is a FIFO. */ +#ifndef S_ISFIFO +# ifdef S_IFIFO +# define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO) +# else +# define S_ISFIFO(m) 0 +# endif +#endif + +/* Define well known filenos if the system does not define them. */ +#ifndef STDIN_FILENO +# define STDIN_FILENO 0 +#endif +#ifndef STDOUT_FILENO +# define STDOUT_FILENO 1 +#endif +#ifndef STDERR_FILENO +# define STDERR_FILENO 2 +#endif + +/* Some systems have mkdir that takes a single argument. */ +#ifdef MKDIR_TAKES_ONE_ARG +# define mkdir(a,b) mkdir(a) +#endif + +#ifndef HAVE_KILL +# define kill(p,s) raise(s) +#endif + +/* Provide a way to print an address via printf. */ +#ifndef HOST_PTR_PRINTF +#define HOST_PTR_PRINTF "%p" +#endif /* ! HOST_PTR_PRINTF */ + +/* By default, colon separates directories in a path. */ +#ifndef PATH_SEPARATOR +#define PATH_SEPARATOR ':' +#endif + +/* Filename handling macros. */ +#include "filenames.h" + +/* These should be phased out in favor of IS_DIR_SEPARATOR, where possible. */ +#ifndef DIR_SEPARATOR +# define DIR_SEPARATOR '/' +# ifdef HAVE_DOS_BASED_FILE_SYSTEM +# define DIR_SEPARATOR_2 '\\' +# endif +#endif + +#if defined (ENABLE_PLUGIN) && defined (HAVE_DLFCN_H) +/* If plugin support is enabled, we could use libdl. */ +#include <dlfcn.h> +#endif + +/* Get libiberty declarations. */ +#include "libiberty.h" + +/* Provide a default for the HOST_BIT_BUCKET. + This suffices for POSIX-like hosts. */ + +#ifndef HOST_BIT_BUCKET +#define HOST_BIT_BUCKET "/dev/null" +#endif + +/* Be conservative and only use enum bitfields with GCC. + FIXME: provide a complete autoconf test for buggy enum bitfields. */ + +#if (GCC_VERSION > 2000) +#define ENUM_BITFIELD(TYPE) __extension__ enum TYPE +#else +#define ENUM_BITFIELD(TYPE) unsigned int +#endif + +#ifndef offsetof +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *) 0)->MEMBER) +#endif + +/* Various error reporting routines want to use __FUNCTION__. */ +#if (GCC_VERSION < 2007) +#ifndef __FUNCTION__ +#define __FUNCTION__ "?" +#endif /* ! __FUNCTION__ */ +#endif + +/* __builtin_expect(A, B) evaluates to A, but notifies the compiler that + the most likely value of A is B. This feature was added at some point + between 2.95 and 3.0. Let's use 3.0 as the lower bound for now. */ +#if (GCC_VERSION < 3000) +#define __builtin_expect(a, b) (a) +#endif + +/* Redefine abort to report an internal error w/o coredump, and + reporting the location of the error in the source file. */ +extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN; +#define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__) + +/* Use gcc_assert(EXPR) to test invariants. */ +#if ENABLE_ASSERT_CHECKING +#define gcc_assert(EXPR) \ + ((void)(!(EXPR) ? fancy_abort (__FILE__, __LINE__, __FUNCTION__), 0 : 0)) +#elif (GCC_VERSION >= 4005) +#define gcc_assert(EXPR) \ + ((void)(__builtin_expect(!(EXPR), 0) ? __builtin_unreachable(), 0 : 0)) +#else +/* Include EXPR, so that unused variable warnings do not occur. */ +#define gcc_assert(EXPR) ((void)(0 && (EXPR))) +#endif + +#ifdef ENABLE_CHECKING +#define gcc_checking_assert(EXPR) gcc_assert (EXPR) +#else +#define gcc_checking_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). */ +#if (GCC_VERSION >= 4005) && !ENABLE_ASSERT_CHECKING +#define gcc_unreachable() __builtin_unreachable() +#else +#define gcc_unreachable() (fancy_abort (__FILE__, __LINE__, __FUNCTION__)) +#endif + +/* Provide a fake boolean type. We make no attempt to use the + C99 _Bool, as it may not be available in the bootstrap compiler, + and even if it is, it is liable to be buggy. + This must be after all inclusion of system headers, as some of + them will mess us up. */ + +#undef TRUE +#undef FALSE + +#ifdef __cplusplus + /* Obsolete. */ +# define TRUE true +# define FALSE false +#else /* !__cplusplus */ +# undef bool +# undef true +# undef false + +# define bool unsigned char +# define true 1 +# define false 0 + + /* Obsolete. */ +# define TRUE true +# define FALSE false +#endif /* !__cplusplus */ + +/* Some compilers do not allow the use of unsigned char in bitfields. */ +#define BOOL_BITFIELD unsigned int + +/* As the last action in this file, we poison the identifiers that + shouldn't be used. Note, luckily gcc-3.0's token-based integrated + preprocessor won't trip on poisoned identifiers that arrive from + the expansion of macros. E.g. #define strrchr rindex, won't error + if rindex is poisoned after this directive is issued and later on + strrchr is called. + + Note: We define bypass macros for the few cases where we really + want to use the libc memory allocation routines. Otherwise we + insist you use the "x" versions from libiberty. */ + +#define really_call_malloc malloc +#define really_call_calloc calloc +#define really_call_realloc realloc + +#if defined(FLEX_SCANNER) || defined(YYBISON) || defined(YYBYACC) +/* Flex and bison use malloc and realloc. Yuk. Note that this means + really_call_* cannot be used in a .l or .y file. */ +#define malloc xmalloc +#define realloc xrealloc +#endif + +#if (GCC_VERSION >= 3000) + +/* Note autoconf checks for prototype declarations and includes + system.h while doing so. Only poison these tokens if actually + compiling gcc, so that the autoconf declaration tests for malloc + etc don't spuriously fail. */ +#ifdef IN_GCC +#undef calloc +#undef strdup + #pragma GCC poison calloc strdup + +#if !defined(FLEX_SCANNER) && !defined(YYBISON) +#undef malloc +#undef realloc + #pragma GCC poison malloc realloc +#endif + +/* The %m format should be used when GCC's main diagnostic functions + supporting %m are available, and xstrerror from libiberty + otherwise. */ +#undef strerror + #pragma GCC poison strerror + +/* Old target macros that have moved to the target hooks structure. */ + #pragma GCC poison ASM_OPEN_PAREN ASM_CLOSE_PAREN \ + FUNCTION_PROLOGUE FUNCTION_EPILOGUE \ + FUNCTION_END_PROLOGUE FUNCTION_BEGIN_EPILOGUE \ + DECL_MACHINE_ATTRIBUTES COMP_TYPE_ATTRIBUTES INSERT_ATTRIBUTES \ + VALID_MACHINE_DECL_ATTRIBUTE VALID_MACHINE_TYPE_ATTRIBUTE \ + SET_DEFAULT_TYPE_ATTRIBUTES SET_DEFAULT_DECL_ATTRIBUTES \ + MERGE_MACHINE_TYPE_ATTRIBUTES MERGE_MACHINE_DECL_ATTRIBUTES \ + MD_INIT_BUILTINS MD_EXPAND_BUILTIN ASM_OUTPUT_CONSTRUCTOR \ + ASM_OUTPUT_DESTRUCTOR SIGNED_CHAR_SPEC MAX_CHAR_TYPE_SIZE \ + WCHAR_UNSIGNED UNIQUE_SECTION SELECT_SECTION SELECT_RTX_SECTION \ + ENCODE_SECTION_INFO STRIP_NAME_ENCODING ASM_GLOBALIZE_LABEL \ + ASM_OUTPUT_MI_THUNK CONST_COSTS RTX_COSTS DEFAULT_RTX_COSTS \ + ADDRESS_COST MACHINE_DEPENDENT_REORG ASM_FILE_START ASM_FILE_END \ + ASM_SIMPLIFY_DWARF_ADDR INIT_TARGET_OPTABS INIT_SUBTARGET_OPTABS \ + INIT_GOFAST_OPTABS MULSI3_LIBCALL MULDI3_LIBCALL DIVSI3_LIBCALL \ + DIVDI3_LIBCALL UDIVSI3_LIBCALL UDIVDI3_LIBCALL MODSI3_LIBCALL \ + MODDI3_LIBCALL UMODSI3_LIBCALL UMODDI3_LIBCALL BUILD_VA_LIST_TYPE \ + PRETEND_OUTGOING_VARARGS_NAMED STRUCT_VALUE_INCOMING_REGNUM \ + ASM_OUTPUT_SECTION_NAME PROMOTE_FUNCTION_ARGS PROMOTE_FUNCTION_MODE \ + STRUCT_VALUE_INCOMING STRICT_ARGUMENT_NAMING \ + PROMOTE_FUNCTION_RETURN PROMOTE_PROTOTYPES STRUCT_VALUE_REGNUM \ + SETUP_INCOMING_VARARGS EXPAND_BUILTIN_SAVEREGS \ + DEFAULT_SHORT_ENUMS SPLIT_COMPLEX_ARGS MD_ASM_CLOBBERS \ + HANDLE_PRAGMA_REDEFINE_EXTNAME HANDLE_PRAGMA_EXTERN_PREFIX \ + MUST_PASS_IN_STACK FUNCTION_ARG_PASS_BY_REFERENCE \ + VECTOR_MODE_SUPPORTED_P TARGET_SUPPORTS_HIDDEN \ + FUNCTION_ARG_PARTIAL_NREGS ASM_OUTPUT_DWARF_DTPREL \ + ALLOCATE_INITIAL_VALUE LEGITIMIZE_ADDRESS FRAME_POINTER_REQUIRED \ + CAN_ELIMINATE TRAMPOLINE_TEMPLATE INITIALIZE_TRAMPOLINE \ + TRAMPOLINE_ADJUST_ADDRESS STATIC_CHAIN STATIC_CHAIN_INCOMING \ + RETURN_POPS_ARGS UNITS_PER_SIMD_WORD OVERRIDE_OPTIONS \ + OPTIMIZATION_OPTIONS CLASS_LIKELY_SPILLED_P \ + USING_SJLJ_EXCEPTIONS TARGET_UNWIND_INFO \ + LABEL_ALIGN_MAX_SKIP LOOP_ALIGN_MAX_SKIP \ + LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP JUMP_ALIGN_MAX_SKIP \ + CAN_DEBUG_WITHOUT_FP UNLIKELY_EXECUTED_TEXT_SECTION_NAME \ + HOT_TEXT_SECTION_NAME + +/* Other obsolete target macros, or macros that used to be in target + headers and were not used, and may be obsolete or may never have + been used. */ + #pragma GCC poison INT_ASM_OP ASM_OUTPUT_EH_REGION_BEG CPP_PREDEFINES \ + ASM_OUTPUT_EH_REGION_END ASM_OUTPUT_LABELREF_AS_INT SMALL_STACK \ + DOESNT_NEED_UNWINDER EH_TABLE_LOOKUP OBJC_SELECTORS_WITHOUT_LABELS \ + OMIT_EH_TABLE EASY_DIV_EXPR IMPLICIT_FIX_EXPR \ + LONGJMP_RESTORE_FROM_STACK MAX_INT_TYPE_SIZE ASM_IDENTIFY_GCC \ + STDC_VALUE TRAMPOLINE_ALIGN ASM_IDENTIFY_GCC_AFTER_SOURCE \ + SLOW_ZERO_EXTEND SUBREG_REGNO_OFFSET DWARF_LINE_MIN_INSTR_LENGTH \ + TRADITIONAL_RETURN_FLOAT NO_BUILTIN_SIZE_TYPE \ + NO_BUILTIN_PTRDIFF_TYPE NO_BUILTIN_WCHAR_TYPE NO_BUILTIN_WINT_TYPE \ + BLOCK_PROFILER BLOCK_PROFILER_CODE FUNCTION_BLOCK_PROFILER \ + FUNCTION_BLOCK_PROFILER_EXIT MACHINE_STATE_SAVE \ + MACHINE_STATE_RESTORE SCCS_DIRECTIVE SECTION_ASM_OP BYTEORDER \ + ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL HOST_WORDS_BIG_ENDIAN \ + OBJC_PROLOGUE ALLOCATE_TRAMPOLINE HANDLE_PRAGMA ROUND_TYPE_SIZE \ + ROUND_TYPE_SIZE_UNIT CONST_SECTION_ASM_OP CRT_GET_RFIB_TEXT \ + DBX_LBRAC_FIRST DBX_OUTPUT_ENUM DBX_OUTPUT_SOURCE_FILENAME \ + DBX_WORKING_DIRECTORY INSN_CACHE_DEPTH INSN_CACHE_SIZE \ + INSN_CACHE_LINE_WIDTH INIT_SECTION_PREAMBLE NEED_ATEXIT ON_EXIT \ + EXIT_BODY OBJECT_FORMAT_ROSE MULTIBYTE_CHARS MAP_CHARACTER \ + LIBGCC_NEEDS_DOUBLE FINAL_PRESCAN_LABEL DEFAULT_CALLER_SAVES \ + LOAD_ARGS_REVERSED MAX_INTEGER_COMPUTATION_MODE \ + CONVERT_HARD_REGISTER_TO_SSA_P ASM_OUTPUT_MAIN_SOURCE_FILENAME \ + FIRST_INSN_ADDRESS TEXT_SECTION SHARED_BSS_SECTION_ASM_OP \ + PROMOTED_MODE EXPAND_BUILTIN_VA_END \ + LINKER_DOES_NOT_WORK_WITH_DWARF2 FUNCTION_ARG_KEEP_AS_REFERENCE \ + GIV_SORT_CRITERION MAX_LONG_TYPE_SIZE MAX_LONG_DOUBLE_TYPE_SIZE \ + MAX_WCHAR_TYPE_SIZE SHARED_SECTION_ASM_OP INTEGRATE_THRESHOLD \ + FINAL_REG_PARM_STACK_SPACE MAYBE_REG_PARM_STACK_SPACE \ + TRADITIONAL_PIPELINE_INTERFACE DFA_PIPELINE_INTERFACE \ + DBX_OUTPUT_STANDARD_TYPES BUILTIN_SETJMP_FRAME_VALUE \ + SUNOS4_SHARED_LIBRARIES PROMOTE_FOR_CALL_ONLY \ + SPACE_AFTER_L_OPTION NO_RECURSIVE_FUNCTION_CSE \ + DEFAULT_MAIN_RETURN TARGET_MEM_FUNCTIONS EXPAND_BUILTIN_VA_ARG \ + COLLECT_PARSE_FLAG DWARF2_GENERATE_TEXT_SECTION_LABEL WINNING_GDB \ + ASM_OUTPUT_FILENAME ASM_OUTPUT_SOURCE_LINE FILE_NAME_JOINER \ + GDB_INV_REF_REGPARM_STABS_LETTER DBX_MEMPARM_STABS_LETTER \ + PUT_SDB_SRC_FILE STABS_GCC_MARKER DBX_OUTPUT_FUNCTION_END \ + DBX_OUTPUT_GCC_MARKER DBX_FINISH_SYMBOL SDB_GENERATE_FAKE \ + NON_SAVING_SETJMP TARGET_LATE_RTL_PROLOGUE_EPILOGUE \ + CASE_DROPS_THROUGH TARGET_BELL TARGET_BS TARGET_CR TARGET_DIGIT0 \ + TARGET_ESC TARGET_FF TARGET_NEWLINE TARGET_TAB TARGET_VT \ + LINK_LIBGCC_SPECIAL DONT_ACCESS_GBLS_AFTER_EPILOGUE \ + TARGET_OPTIONS TARGET_SWITCHES EXTRA_CC_MODES FINALIZE_PIC \ + PREDICATE_CODES SPECIAL_MODE_PREDICATES UNALIGNED_WORD_ASM_OP \ + EXTRA_SECTIONS EXTRA_SECTION_FUNCTIONS READONLY_DATA_SECTION \ + TARGET_ASM_EXCEPTION_SECTION TARGET_ASM_EH_FRAME_SECTION \ + SMALL_ARG_MAX ASM_OUTPUT_SHARED_BSS ASM_OUTPUT_SHARED_COMMON \ + ASM_OUTPUT_SHARED_LOCAL ASM_MAKE_LABEL_LINKONCE \ + STACK_CHECK_PROBE_INTERVAL STACK_CHECK_PROBE_LOAD \ + ORDER_REGS_FOR_LOCAL_ALLOC FUNCTION_OUTGOING_VALUE \ + ASM_DECLARE_CONSTANT_NAME MODIFY_TARGET_NAME SWITCHES_NEED_SPACES \ + SWITCH_CURTAILS_COMPILATION SWITCH_TAKES_ARG WORD_SWITCH_TAKES_ARG \ + TARGET_OPTION_TRANSLATE_TABLE HANDLE_PRAGMA_PACK_PUSH_POP \ + HANDLE_SYSV_PRAGMA HANDLE_PRAGMA_WEAK CONDITIONAL_REGISTER_USAGE \ + FUNCTION_ARG_BOUNDARY MUST_USE_SJLJ_EXCEPTIONS US_SOFTWARE_GOFAST \ + USING_SVR4_H SVR4_ASM_SPEC + +/* Hooks that are no longer used. */ + #pragma GCC poison LANG_HOOKS_FUNCTION_MARK LANG_HOOKS_FUNCTION_FREE \ + LANG_HOOKS_MARK_TREE LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES \ + LANG_HOOKS_TREE_INLINING_ESTIMATE_NUM_INSNS \ + LANG_HOOKS_PUSHLEVEL LANG_HOOKS_SET_BLOCK \ + LANG_HOOKS_MAYBE_BUILD_CLEANUP LANG_HOOKS_UPDATE_DECL_AFTER_SAVING \ + LANG_HOOKS_POPLEVEL LANG_HOOKS_TRUTHVALUE_CONVERSION \ + TARGET_PROMOTE_FUNCTION_ARGS TARGET_PROMOTE_FUNCTION_RETURN \ + LANG_HOOKS_MISSING_ARGUMENT LANG_HOOKS_HASH_TYPES \ + TARGET_HANDLE_OFAST TARGET_OPTION_OPTIMIZATION + +/* Hooks into libgcc2. */ + #pragma GCC poison LIBGCC2_DOUBLE_TYPE_SIZE LIBGCC2_WORDS_BIG_ENDIAN \ + LIBGCC2_FLOAT_WORDS_BIG_ENDIAN + +/* Miscellaneous macros that are no longer used. */ + #pragma GCC poison USE_MAPPED_LOCATION GET_ENVIRONMENT + +/* Libiberty macros that are no longer used in GCC. */ +#undef ANSI_PROTOTYPES +#undef PTR_CONST +#undef LONG_DOUBLE +#undef VPARAMS +#undef VA_OPEN +#undef VA_FIXEDARG +#undef VA_CLOSE +#undef VA_START + #pragma GCC poison ANSI_PROTOTYPES PTR_CONST LONG_DOUBLE VPARAMS VA_OPEN \ + VA_FIXEDARG VA_CLOSE VA_START +#endif /* IN_GCC */ + +/* Front ends should never have to include middle-end headers. Enforce + this by poisoning the header double-include protection defines. */ +#ifdef IN_GCC_FRONTEND +#pragma GCC poison GCC_RTL_H GCC_EXCEPT_H GCC_EXPR_H +#endif + +/* Note: not all uses of the `index' token (e.g. variable names and + structure members) have been eliminated. */ +#undef bcopy +#undef bzero +#undef bcmp +#undef rindex + #pragma GCC poison bcopy bzero bcmp rindex + +#endif /* GCC >= 3.0 */ + +/* This macro allows casting away const-ness to pass -Wcast-qual + warnings. DO NOT USE THIS UNLESS YOU REALLY HAVE TO! It should + only be used in certain specific cases. One valid case is where + the C standard definitions or prototypes force you to. E.g. if you + need to free a const object, or if you pass a const string to + execv, et al. Another valid use would be in an allocation function + that creates const objects that need to be initialized. In some + cases we have non-const functions that return the argument + (e.g. next_nonnote_insn). Rather than create const shadow + functions, we can cast away const-ness in calling these interfaces + if we're careful to verify that the called function does indeed not + modify its argument and the return value is only used in a const + context. (This can be somewhat dangerous as these assumptions can + change after the fact). Beyond these uses, most other cases of + using this macro should be viewed with extreme caution. */ + +#ifdef __cplusplus +#define CONST_CAST2(TOTYPE,FROMTYPE,X) (const_cast<TOTYPE> (X)) +#else +#if defined(__GNUC__) && GCC_VERSION > 4000 +/* GCC 4.0.x has a bug where it may ICE on this expression, + so does GCC 3.4.x (PR17436). */ +#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq) +#elif defined(__GNUC__) +static inline char * +helper_const_non_const_cast (const char *p) +{ + union { + const char *const_c; + char *c; + } val; + val.const_c = p; + return val.c; +} + +#define CONST_CAST2(TOTYPE,FROMTYPE,X) \ + ((TOTYPE) helper_const_non_const_cast ((const char *) (FROMTYPE) (X))) +#else +#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((TOTYPE)(FROMTYPE)(X)) +#endif +#endif +#define CONST_CAST(TYPE,X) CONST_CAST2(TYPE, const TYPE, (X)) +#define CONST_CAST_TREE(X) CONST_CAST(union tree_node *, (X)) +#define CONST_CAST_RTX(X) CONST_CAST(struct rtx_def *, (X)) +#define CONST_CAST_BB(X) CONST_CAST(struct basic_block_def *, (X)) +#define CONST_CAST_GIMPLE(X) CONST_CAST(union gimple_statement_d *, (X)) + +/* Activate certain diagnostics as warnings (not errors via the + -Werror flag). */ +#if GCC_VERSION >= 4003 +/* If asserts are disabled, activate -Wuninitialized as a warning (not + an error/-Werror). */ +#ifndef ENABLE_ASSERT_CHECKING +#pragma GCC diagnostic warning "-Wuninitialized" +#endif +#endif + +#ifdef ENABLE_VALGRIND_CHECKING +# ifdef HAVE_VALGRIND_MEMCHECK_H +# include <valgrind/memcheck.h> +# elif defined HAVE_MEMCHECK_H +# include <memcheck.h> +# else +# include <valgrind.h> +# endif +/* Compatibility macros to let valgrind 3.1 work. */ +# ifndef VALGRIND_MAKE_MEM_NOACCESS +# define VALGRIND_MAKE_MEM_NOACCESS VALGRIND_MAKE_NOACCESS +# endif +# ifndef VALGRIND_MAKE_MEM_DEFINED +# define VALGRIND_MAKE_MEM_DEFINED VALGRIND_MAKE_READABLE +# endif +# ifndef VALGRIND_MAKE_MEM_UNDEFINED +# define VALGRIND_MAKE_MEM_UNDEFINED VALGRIND_MAKE_WRITABLE +# endif +#else +/* Avoid #ifdef:s when we can help it. */ +#define VALGRIND_DISCARD(x) +#define VALGRIND_MALLOCLIKE_BLOCK(w,x,y,z) +#define VALGRIND_FREELIKE_BLOCK(x,y) +#endif + +/* In LTO -fwhole-program build we still want to keep the debug functions available + for debugger. Mark them as used to prevent removal. */ +#if (GCC_VERSION > 4000) +#define DEBUG_FUNCTION __attribute__ ((__used__)) +#define DEBUG_VARIABLE __attribute__ ((__used__)) +#else +#define DEBUG_FUNCTION +#define DEBUG_VARIABLE +#endif + +#endif /* ! GCC_SYSTEM_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/target.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/target.def new file mode 100644 index 0000000..756caf3 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/target.def @@ -0,0 +1,2866 @@ +/* Target hook definitions. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + + 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 3, 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; see the file COPYING3. If not see + <http://www.gnu.org/licenses/>. + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ + +/* The following macros should be provided by the including file: + + DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT): Define a function-valued hook. + DEFHOOKPOD(DOC, TYPE, NAME, INIT): Define a piece-of-data 'hook'. */ + +/* Defaults for optional macros: + DEFHOOKPODX(NAME, TYPE, INIT): Like DEFHOOKPOD, but share documentation + with the previous 'hook'. */ +#ifndef DEFHOOKPODX +#define DEFHOOKPODX(NAME, TYPE, INIT) DEFHOOKPOD (NAME, 0, TYPE, INIT) +#endif + +/* HOOKSTRUCT(FRAGMENT): Declarator fragments to encapsulate all the + members into a struct gcc_target, which in turn contains several + sub-structs. */ +#ifndef HOOKSTRUCT +#define HOOKSTRUCT(FRAGMENT) +#endif +/* HOOK_VECTOR: Start a struct declaration, which then gets its own initializer. + HOOK_VECTOR_END: Close a struct declaration, providing a member declarator + name for nested use. */ +#ifndef HOOK_VECTOR_1 +#define HOOK_VECTOR_1(NAME, FRAGMENT) HOOKSTRUCT(FRAGMENT) +#endif +#define HOOK_VECTOR(INIT_NAME, SNAME) HOOK_VECTOR_1 (INIT_NAME, struct SNAME {) +#define HOOK_VECTOR_END(DECL_NAME) HOOK_VECTOR_1(,} DECL_NAME ;) + +HOOK_VECTOR (TARGET_INITIALIZER, gcc_target) + +/* FIXME: For pre-existing hooks, we can't place the documentation in the + documentation field here till we get permission from the FSF to include + it in GPLed software - the target hook documentation is so far only + available under the GFDL. */ + +/* A hook should generally be documented by a string in the DOC parameter, + which should contain texinfo markup. If the documentation is only available + under the GPL, but not under the GFDL, put it in a comment above the hook + definition. If the function declaration is available both under GPL and + GFDL, but the documentation is only available under the GFDL, put the + documentaton in tm.texi.in, heading with @hook <hookname> and closing + the paragraph with @end deftypefn / deftypevr as appropriate, and marking + the next autogenerated hook with @hook <hookname>. + In both these cases, leave the DOC string empty, i.e. "". + Sometimes, for some historic reason the function declaration + has to be documented differently + than what it is. In that case, use DEFHOOK_UNDOC to supress auto-generation + of documentation. DEFHOOK_UNDOC takes a DOC string which it ignores, so + you can put GPLed documentation string there if you have hopes that you + can clear the declaration & documentation for GFDL distribution later, + in which case you can then simply change the DEFHOOK_UNDOC to DEFHOOK + to turn on the autogeneration of the documentation. + + A documentation string of "*" means not to emit any documentation at all, + and is mainly used internally for DEFHOOK_UNDOC. It should generally not + be used otherwise, but it has its use for exceptional cases where automatic + documentation is not wanted, and the real documentation is elsewere, like + for TARGET_ASM_{,UN}ALIGNED_INT_OP, which are hooks only for implementation + purposes; they refer to structs, the components of which are documented as + separate hooks TARGET_ASM_{,UN}ALIGNED_[HSDT]I_OP. + A DOC string of 0 is for internal use of DEFHOOKPODX and special table + entries only. */ + +/* Functions that output assembler for the target. */ +#define HOOK_PREFIX "TARGET_ASM_" +HOOK_VECTOR (TARGET_ASM_OUT, asm_out) + +/* Opening and closing parentheses for asm expression grouping. */ +DEFHOOKPOD +(open_paren, + "", + const char *, "(") +DEFHOOKPODX (close_paren, const char *, ")") + +/* Assembler instructions for creating various kinds of integer object. */ +DEFHOOKPOD +(byte_op, + "", + const char *, "\t.byte\t") +DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP) +DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP) + +/* The maximum number of bytes to skip when applying + LABEL_ALIGN_AFTER_BARRIER. */ +DEFHOOK +(label_align_after_barrier_max_skip, + "", + int, (rtx label), + default_label_align_after_barrier_max_skip) + +/* The maximum number of bytes to skip when applying + LOOP_ALIGN. */ +DEFHOOK +(loop_align_max_skip, + "", + int, (rtx label), + default_loop_align_max_skip) + +/* The maximum number of bytes to skip when applying + LABEL_ALIGN. */ +DEFHOOK +(label_align_max_skip, + "", + int, (rtx label), + default_label_align_max_skip) + +/* The maximum number of bytes to skip when applying + JUMP_ALIGN. */ +DEFHOOK +(jump_align_max_skip, + "", + int, (rtx label), + default_jump_align_max_skip) + +/* Try to output the assembler code for an integer object whose + value is given by X. SIZE is the size of the object in bytes and + ALIGNED_P indicates whether it is aligned. Return true if + successful. Only handles cases for which BYTE_OP, ALIGNED_OP + and UNALIGNED_OP are NULL. */ +DEFHOOK +(integer, + "", + /* Only handles cases for which BYTE_OP, ALIGNED_OP and UNALIGNED_OP are + NULL. */ + bool, (rtx x, unsigned int size, int aligned_p), + default_assemble_integer) + +/* Output code that will globalize a label. */ +DEFHOOK +(globalize_label, + "", + void, (FILE *stream, const char *name), + default_globalize_label) + +/* Output code that will globalize a declaration. */ +DEFHOOK +(globalize_decl_name, + "", + void, (FILE *stream, tree decl), default_globalize_decl_name) + +/* Output code that will emit a label for unwind info, if this + target requires such labels. Second argument is the decl the + unwind info is associated with, third is a boolean: true if + this is for exception handling, fourth is a boolean: true if + this is only a placeholder for an omitted FDE. */ +DEFHOOK +(emit_unwind_label, + "", + void, (FILE *stream, tree decl, int for_eh, int empty), + default_emit_unwind_label) + +/* Output code that will emit a label to divide up the exception table. */ +DEFHOOK +(emit_except_table_label, + "", + void, (FILE *stream), + default_emit_except_table_label) + +/* Emit a directive for setting the personality for the function. */ +DEFHOOK +(emit_except_personality, + "If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be\ + used to emit a directive to install a personality hook into the unwind\ + info. This hook should not be used if dwarf2 unwind info is used.", + void, (rtx personality), + NULL) + +/* Emit any directives required to unwind this instruction. */ +DEFHOOK +(unwind_emit, + "", + void, (FILE *stream, rtx insn), + NULL) + +DEFHOOKPOD +(unwind_emit_before_insn, + "True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before\ + the assembly for @var{insn} has been emitted, false if the hook should\ + be called afterward.", + bool, true) + +/* Generate an internal label. + For now this is just a wrapper for ASM_GENERATE_INTERNAL_LABEL. */ +DEFHOOK_UNDOC +(generate_internal_label, + "", + void, (char *buf, const char *prefix, unsigned long labelno), + default_generate_internal_label) + +/* Output an internal label. */ +DEFHOOK +(internal_label, + "", + void, (FILE *stream, const char *prefix, unsigned long labelno), + default_internal_label) + +/* Output label for the constant. */ +DEFHOOK +(declare_constant_name, + "", + void, (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size), + default_asm_declare_constant_name) + +/* Emit a ttype table reference to a typeinfo object. */ +DEFHOOK +(ttype, + "", + bool, (rtx sym), + hook_bool_rtx_false) + +/* Emit an assembler directive to set visibility for the symbol + associated with the tree decl. */ +DEFHOOK +(assemble_visibility, + "", + void, (tree decl, int visibility), + default_assemble_visibility) + +/* Output the assembler code for entry to a function. */ +DEFHOOK +(function_prologue, + "", + void, (FILE *file, HOST_WIDE_INT size), + default_function_pro_epilogue) + +/* Output the assembler code for end of prologue. */ +DEFHOOK +(function_end_prologue, + "", + void, (FILE *file), + no_asm_to_stream) + +/* Output the assembler code for start of epilogue. */ +DEFHOOK +(function_begin_epilogue, + "", + void, (FILE *file), + no_asm_to_stream) + +/* Output the assembler code for function exit. */ +DEFHOOK +(function_epilogue, + "", + void, (FILE *file, HOST_WIDE_INT size), + default_function_pro_epilogue) + +/* Initialize target-specific sections. */ +DEFHOOK +(init_sections, + "", + void, (void), + hook_void_void) + +/* Tell assembler to change to section NAME with attributes FLAGS. + If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with + which this section is associated. */ +DEFHOOK +(named_section, + "", + void, (const char *name, unsigned int flags, tree decl), + default_no_named_section) + +/* Return preferred text (sub)section for function DECL. + Main purpose of this function is to separate cold, normal and hot + functions. STARTUP is true when function is known to be used only + at startup (from static constructors or it is main()). + EXIT is true when function is known to be used only at exit + (from static destructors). + Return NULL if function should go to default text section. */ +DEFHOOK +(function_section, + "", + section *, (tree decl, enum node_frequency freq, bool startup, bool exit), + default_function_section) + +/* Output the assembler code for function exit. */ +DEFHOOK +(function_switched_text_sections, + "Used by the target to emit any assembler directives or additional\ + labels needed when a function is partitioned between different\ + sections. Output should be written to @var{file}. The function\ + decl is available as @var{decl} and the new section is `cold' if\ + @var{new_is_cold} is @code{true}.", + void, (FILE *file, tree decl, bool new_is_cold), + default_function_switched_text_sections) + +/* Return a mask describing how relocations should be treated when + selecting sections. Bit 1 should be set if global relocations + should be placed in a read-write section; bit 0 should be set if + local relocations should be placed in a read-write section. */ +DEFHOOK +(reloc_rw_mask, + "", + int, (void), + default_reloc_rw_mask) + + /* Return a section for EXP. It may be a DECL or a constant. RELOC + is nonzero if runtime relocations must be applied; bit 1 will be + set if the runtime relocations require non-local name resolution. + ALIGN is the required alignment of the data. */ +DEFHOOK +(select_section, + "", + section *, (tree exp, int reloc, unsigned HOST_WIDE_INT align), + default_select_section) + +/* Return a section for X. MODE is X's mode and ALIGN is its + alignment in bits. */ +DEFHOOK +(select_rtx_section, + "", + section *, (enum machine_mode mode, rtx x, unsigned HOST_WIDE_INT align), + default_select_rtx_section) + +/* Select a unique section name for DECL. RELOC is the same as + for SELECT_SECTION. */ +DEFHOOK +(unique_section, + "", + void, (tree decl, int reloc), + default_unique_section) + +/* Return the readonly data section associated with function DECL. */ +DEFHOOK +(function_rodata_section, + "", + section *, (tree decl), + default_function_rodata_section) + +/* Output a constructor for a symbol with a given priority. */ +DEFHOOK +(constructor, + "", + void, (rtx symbol, int priority), NULL) + +/* Output a destructor for a symbol with a given priority. */ +DEFHOOK +(destructor, + "", + void, (rtx symbol, int priority), NULL) + +/* Output the assembler code for a thunk function. THUNK_DECL is the + declaration for the thunk function itself, FUNCTION is the decl for + the target function. DELTA is an immediate constant offset to be + added to THIS. If VCALL_OFFSET is nonzero, the word at + *(*this + vcall_offset) should be added to THIS. */ +DEFHOOK +(output_mi_thunk, + "", + void, (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta, + HOST_WIDE_INT vcall_offset, tree function), + NULL) + +/* Determine whether output_mi_thunk would succeed. */ +/* ??? Ideally, this hook would not exist, and success or failure + would be returned from output_mi_thunk directly. But there's + too much undo-able setup involved in invoking output_mi_thunk. + Could be fixed by making output_mi_thunk emit rtl instead of + text to the output file. */ +DEFHOOK +(can_output_mi_thunk, + "", + bool, (const_tree thunk_fndecl, HOST_WIDE_INT delta, + HOST_WIDE_INT vcall_offset, const_tree function), + hook_bool_const_tree_hwi_hwi_const_tree_false) + +/* Output any boilerplate text needed at the beginning of a + translation unit. */ +DEFHOOK +(file_start, + "", + void, (void), + default_file_start) + +/* Output any boilerplate text needed at the end of a translation unit. */ +DEFHOOK +(file_end, + "", + void, (void), + hook_void_void) + +/* Output any boilerplate text needed at the beginning of an + LTO output stream. */ +DEFHOOK +(lto_start, + "", + void, (void), + hook_void_void) + +/* Output any boilerplate text needed at the end of an + LTO output stream. */ +DEFHOOK +(lto_end, + "", + void, (void), + hook_void_void) + +/* Output any boilerplace text needed at the end of a + translation unit before debug and unwind info is emitted. */ +DEFHOOK +(code_end, + "", + void, (void), + hook_void_void) + +/* Output an assembler pseudo-op to declare a library function name + external. */ +DEFHOOK +(external_libcall, + "", + void, (rtx symref), + default_external_libcall) + +/* Output an assembler directive to mark decl live. This instructs + linker to not dead code strip this symbol. */ +DEFHOOK +(mark_decl_preserved, + "", + void, (const char *symbol), + hook_void_constcharptr) + +/* Output a record of the command line switches that have been passed. */ +DEFHOOK +(record_gcc_switches, + "", + int, (print_switch_type type, const char *text), + NULL) + +/* The name of the section that the example ELF implementation of + record_gcc_switches will use to store the information. Target + specific versions of record_gcc_switches may or may not use + this information. */ +DEFHOOKPOD +(record_gcc_switches_section, + "", + const char *, ".GCC.command.line") + +/* Output the definition of a section anchor. */ +DEFHOOK +(output_anchor, + "", + void, (rtx x), + default_asm_output_anchor) + +/* Output a DTP-relative reference to a TLS symbol. */ +DEFHOOK +(output_dwarf_dtprel, + "", + void, (FILE *file, int size, rtx x), + NULL) + +/* Some target machines need to postscan each insn after it is output. */ +DEFHOOK +(final_postscan_insn, + "", + void, (FILE *file, rtx insn, rtx *opvec, int noperands), + NULL) + +/* Emit the trampoline template. This hook may be NULL. */ +DEFHOOK +(trampoline_template, + "", + void, (FILE *f), + NULL) + +DEFHOOK +(output_source_filename, + "Output COFF information or DWARF debugging information which indicates\ + that filename @var{name} is the current source file to the stdio\ + stream @var{file}.\n\ + \n\ + This target hook need not be defined if the standard form of output\ + for the file format in use is appropriate.", + void ,(FILE *file, const char *name), + default_asm_output_source_filename) + +DEFHOOK +(output_addr_const_extra, + "", + bool, (FILE *file, rtx x), + default_asm_output_addr_const_extra) + +/* ??? The TARGET_PRINT_OPERAND* hooks are part of the asm_out struct, + even though that is not reflected in the macro name to override their + initializers. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_" + +/* Emit a machine-specific insn operand. */ +/* ??? tm.texi only documents the old macro PRINT_OPERAND, + not this hook, and uses a different name for the argument FILE. */ +DEFHOOK_UNDOC +(print_operand, + "", + void, (FILE *file, rtx x, int code), + default_print_operand) + +/* Emit a machine-specific memory address. */ +/* ??? tm.texi only documents the old macro PRINT_OPERAND_ADDRESS, + not this hook, and uses different argument names. */ +DEFHOOK_UNDOC +(print_operand_address, + "", + void, (FILE *file, rtx addr), + default_print_operand_address) + +/* Determine whether CODE is a valid punctuation character for the + `print_operand' hook. */ +/* ??? tm.texi only documents the old macro PRINT_OPERAND_PUNCT_VALID_P, + not this hook. */ +DEFHOOK_UNDOC +(print_operand_punct_valid_p, + "", + bool ,(unsigned char code), + default_print_operand_punct_valid_p) + +/* Given a symbol name, perform same mangling as assemble_name and + ASM_OUTPUT_LABELREF, returning result as an IDENTIFIER_NODE. */ +DEFHOOK +(mangle_assembler_name, + "Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s\ + @code{assemble_name}, but in memory rather than to a file stream, returning\ + result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The\ + default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and\ + then prepends the @code{USER_LABEL_PREFIX}, if any.", + tree, (const char *name), + default_mangle_assembler_name) + +HOOK_VECTOR_END (asm_out) + +/* Functions relating to instruction scheduling. All of these + default to null pointers, which haifa-sched.c looks for and handles. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_SCHED_" +HOOK_VECTOR (TARGET_SCHED, sched) + +/* Given the current cost, COST, of an insn, INSN, calculate and + return a new cost based on its relationship to DEP_INSN through + the dependence LINK. The default is to make no adjustment. */ +DEFHOOK +(adjust_cost, + "", + int, (rtx insn, rtx link, rtx dep_insn, int cost), NULL) + +/* Adjust the priority of an insn as you see fit. Returns the new priority. */ +DEFHOOK +(adjust_priority, + "", + int, (rtx insn, int priority), NULL) + +/* Function which returns the maximum number of insns that can be + scheduled in the same machine cycle. This must be constant + over an entire compilation. The default is 1. */ +DEFHOOK +(issue_rate, + "", + int, (void), NULL) + +/* Calculate how much this insn affects how many more insns we + can emit this cycle. Default is they all cost the same. */ +DEFHOOK +(variable_issue, + "", + int, (FILE *file, int verbose, rtx insn, int more), NULL) + +/* Initialize machine-dependent scheduling code. */ +DEFHOOK +(init, + "", + void, (FILE *file, int verbose, int max_ready), NULL) + +/* Finalize machine-dependent scheduling code. */ +DEFHOOK +(finish, + "", + void, (FILE *file, int verbose), NULL) + + /* Initialize machine-dependent function wide scheduling code. */ +DEFHOOK +(init_global, + "", + void, (FILE *file, int verbose, int old_max_uid), NULL) + +/* Finalize machine-dependent function wide scheduling code. */ +DEFHOOK +(finish_global, + "", + void, (FILE *file, int verbose), NULL) + +/* Reorder insns in a machine-dependent fashion, in two different + places. Default does nothing. */ +DEFHOOK +(reorder, + "", + int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) + +DEFHOOK +(reorder2, + "", + int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) + +/* The following member value is a pointer to a function called + after evaluation forward dependencies of insns in chain given + by two parameter values (head and tail correspondingly). */ +DEFHOOK +(dependencies_evaluation_hook, + "", + void, (rtx head, rtx tail), NULL) + +/* The values of the following four members are pointers to functions + used to simplify the automaton descriptions. dfa_pre_cycle_insn and + dfa_post_cycle_insn give functions returning insns which are used to + change the pipeline hazard recognizer state when the new simulated + processor cycle correspondingly starts and finishes. The function + defined by init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are + used to initialize the corresponding insns. The default values of + the members result in not changing the automaton state when the + new simulated processor cycle correspondingly starts and finishes. */ + +DEFHOOK +(init_dfa_pre_cycle_insn, + "", + void, (void), NULL) + +DEFHOOK +(dfa_pre_cycle_insn, + "", + rtx, (void), NULL) + +DEFHOOK +(init_dfa_post_cycle_insn, + "", + void, (void), NULL) + +DEFHOOK +(dfa_post_cycle_insn, + "", + rtx, (void), NULL) + +/* The values of the following two members are pointers to + functions used to simplify the automaton descriptions. + dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called + immediately before and after cycle is advanced. */ + +DEFHOOK +(dfa_pre_advance_cycle, + "", + void, (void), NULL) + +DEFHOOK +(dfa_post_advance_cycle, + "", + void, (void), NULL) + +/* The following member value is a pointer to a function returning value + which defines how many insns in queue `ready' will we try for + multi-pass scheduling. If the member value is nonzero and the + function returns positive value, the DFA based scheduler will make + multi-pass scheduling for the first cycle. In other words, we will + try to choose ready insn which permits to start maximum number of + insns on the same cycle. */ +DEFHOOK +(first_cycle_multipass_dfa_lookahead, + "", + int, (void), NULL) + +/* The following member value is pointer to a function controlling + what insns from the ready insn queue will be considered for the + multipass insn scheduling. If the hook returns zero for insn + passed as the parameter, the insn will be not chosen to be issued. */ +DEFHOOK +(first_cycle_multipass_dfa_lookahead_guard, + "", + int, (rtx insn), NULL) + +/* This hook prepares the target for a new round of multipass + scheduling. + DATA is a pointer to target-specific data used for multipass scheduling. + READY_TRY and N_READY represent the current state of search in the + optimization space. The target can filter out instructions that + should not be tried during current round by setting corresponding + elements in READY_TRY to non-zero. + FIRST_CYCLE_INSN_P is true if this is the first round of multipass + scheduling on current cycle. */ +DEFHOOK +(first_cycle_multipass_begin, + "", + void, (void *data, char *ready_try, int n_ready, bool first_cycle_insn_p), + NULL) + +/* This hook is called when multipass scheduling evaluates instruction INSN. + DATA is a pointer to target-specific data that can be used to record effects + of INSN on CPU that are not described in DFA. + READY_TRY and N_READY represent the current state of search in the + optimization space. The target can filter out instructions that + should not be tried after issueing INSN by setting corresponding + elements in READY_TRY to non-zero. + INSN is the instruction being evaluated. + PREV_DATA is a pointer to target-specific data corresponding + to a state before issueing INSN. */ +DEFHOOK +(first_cycle_multipass_issue, + "", + void, (void *data, char *ready_try, int n_ready, rtx insn, + const void *prev_data), NULL) + +/* This hook is called when multipass scheduling backtracks from evaluation of + instruction corresponding to DATA. + DATA is a pointer to target-specific data that stores the effects + of instruction from which the algorithm backtracks on CPU that are not + described in DFA. + READY_TRY and N_READY represent the current state of search in the + optimization space. The target can filter out instructions that + should not be tried after issueing INSN by setting corresponding + elements in READY_TRY to non-zero. */ +DEFHOOK +(first_cycle_multipass_backtrack, + "", + void, (const void *data, char *ready_try, int n_ready), NULL) + +/* This hook notifies the target about the result of the concluded current + round of multipass scheduling. + DATA is a pointer. + If DATA is non-NULL it points to target-specific data used for multipass + scheduling which corresponds to instruction at the start of the chain of + the winning solution. DATA is NULL when multipass scheduling cannot find + a good enough solution on current cycle and decides to retry later, + usually after advancing the cycle count. */ +DEFHOOK +(first_cycle_multipass_end, + "", + void, (const void *data), NULL) + +/* This hook is called to initialize target-specific data for multipass + scheduling after it has been allocated. + DATA is a pointer to target-specific data that stores the effects + of instruction from which the algorithm backtracks on CPU that are not + described in DFA. */ +DEFHOOK +(first_cycle_multipass_init, + "", + void, (void *data), NULL) + +/* This hook is called to finalize target-specific data for multipass + scheduling before it is deallocated. + DATA is a pointer to target-specific data that stores the effects + of instruction from which the algorithm backtracks on CPU that are not + described in DFA. */ +DEFHOOK +(first_cycle_multipass_fini, + "", + void, (void *data), NULL) + +/* The following member value is pointer to a function called by + the insn scheduler before issuing insn passed as the third + parameter on given cycle. If the hook returns nonzero, the + insn is not issued on given processors cycle. Instead of that, + the processor cycle is advanced. If the value passed through + the last parameter is zero, the insn ready queue is not sorted + on the new cycle start as usually. The first parameter passes + file for debugging output. The second one passes the scheduler + verbose level of the debugging output. The forth and the fifth + parameter values are correspondingly processor cycle on which + the previous insn has been issued and the current processor cycle. */ +DEFHOOK +(dfa_new_cycle, + "", + int, (FILE *dump, int verbose, rtx insn, int last_clock, + int clock, int *sort_p), + NULL) + +/* The following member value is a pointer to a function called by the + insn scheduler. It should return true if there exists a dependence + which is considered costly by the target, between the insn + DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is + the dep that represents the dependence between the two insns. The + second argument is the cost of the dependence as estimated by + the scheduler. The last argument is the distance in cycles + between the already scheduled insn (first parameter) and the + second insn (second parameter). */ +DEFHOOK +(is_costly_dependence, + "", + bool, (struct _dep *_dep, int cost, int distance), NULL) + +DEFHOOK_UNDOC +(adjust_cost_2, + "Given the current cost, @var{cost}, of an insn, @var{insn}, calculate and\ + return a new cost based on its relationship to @var{dep_insn} through the\ + dependence of weakness @var{dw}. The default is to make no adjustment.", + int, (rtx insn, int dep_type1, rtx dep_insn, int cost, int dw), NULL) + +/* The following member value is a pointer to a function called + by the insn scheduler. This hook is called to notify the backend + that new instructions were emitted. */ +DEFHOOK +(h_i_d_extended, + "", + void, (void), NULL) + +/* Next 5 functions are for multi-point scheduling. */ + +/* Allocate memory for scheduler context. */ +DEFHOOK +(alloc_sched_context, + "", + void *, (void), NULL) + +/* Fills the context from the local machine scheduler context. */ +DEFHOOK +(init_sched_context, + "", + void, (void *tc, bool clean_p), NULL) + +/* Sets local machine scheduler context to a saved value. */ +DEFHOOK +(set_sched_context, + "", + void, (void *tc), NULL) + +/* Clears a scheduler context so it becomes like after init. */ +DEFHOOK +(clear_sched_context, + "", + void, (void *tc), NULL) + +/* Frees the scheduler context. */ +DEFHOOK +(free_sched_context, + "", + void, (void *tc), NULL) + +/* The following member value is a pointer to a function called + by the insn scheduler. + The first parameter is an instruction, the second parameter is the type + of the requested speculation, and the third parameter is a pointer to the + speculative pattern of the corresponding type (set if return value == 1). + It should return + -1, if there is no pattern, that will satisfy the requested speculation type, + 0, if current pattern satisfies the requested speculation type, + 1, if pattern of the instruction should be changed to the newly + generated one. */ +DEFHOOK +(speculate_insn, + "", + int, (rtx insn, int request, rtx *new_pat), NULL) + +/* The following member value is a pointer to a function called + by the insn scheduler. It should return true if the check instruction + passed as the parameter needs a recovery block. */ +DEFHOOK +(needs_block_p, + "", + bool, (int dep_status), NULL) + +/* The following member value is a pointer to a function called + by the insn scheduler. It should return a pattern for the check + instruction. + The first parameter is a speculative instruction, the second parameter + is the label of the corresponding recovery block (or null, if it is a + simple check). If the mutation of the check is requested (e.g. from + ld.c to chk.a), the third parameter is true - in this case the first + parameter is the previous check. */ +DEFHOOK +(gen_spec_check, + "", + rtx, (rtx insn, rtx label, int mutate_p), NULL) + +/* The following member value is a pointer to a function controlling + what insns from the ready insn queue will be considered for the + multipass insn scheduling. If the hook returns zero for the insn + passed as the parameter, the insn will not be chosen to be + issued. This hook is used to discard speculative instructions, + that stand at the first position of the ready list. */ +DEFHOOK +(first_cycle_multipass_dfa_lookahead_guard_spec, + "", + bool, (const_rtx insn), NULL) + +/* The following member value is a pointer to a function that provides + information about the speculation capabilities of the target. + The parameter is a pointer to spec_info variable. */ +DEFHOOK +(set_sched_flags, + "", + void, (struct spec_info_def *spec_info), NULL) + +DEFHOOK_UNDOC +(get_insn_spec_ds, + "Return speculation types of instruction @var{insn}.", + int, (rtx insn), NULL) + +DEFHOOK_UNDOC +(get_insn_checked_ds, + "Return speculation types that are checked for instruction @var{insn}", + int, (rtx insn), NULL) + +DEFHOOK_UNDOC +(skip_rtx_p, + "Return bool if rtx scanning should just skip current layer and\ + advance to the inner rtxes.", + bool, (const_rtx x), NULL) + +/* The following member value is a pointer to a function that provides + information about the target resource-based lower bound which is + used by the swing modulo scheduler. The parameter is a pointer + to ddg variable. */ +DEFHOOK +(sms_res_mii, + "", + int, (struct ddg *g), NULL) + +/* The following member value is a function that initializes dispatch + schedling and adds instructions to dispatch window according to its + parameters. */ +DEFHOOK +(dispatch_do, +"", +void, (rtx insn, int x), +hook_void_rtx_int) + +/* The following member value is a a function that returns true is + dispatch schedling is supported in hardware and condition passed + as the second parameter is true. */ +DEFHOOK +(dispatch, +"", +bool, (rtx insn, int x), +hook_bool_rtx_int_false) + +HOOK_VECTOR_END (sched) + +/* Functions relating to vectorization. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_VECTORIZE_" +HOOK_VECTOR (TARGET_VECTORIZE, vectorize) + +/* The following member value is a pointer to a function called + by the vectorizer, and return the decl of the target builtin + function. */ +DEFHOOK +(builtin_mask_for_load, + "", + tree, (void), NULL) + +/* Returns a code for builtin that realizes vectorized version of + function, or NULL_TREE if not available. */ +DEFHOOK +(builtin_vectorized_function, + "", + tree, (tree fndecl, tree vec_type_out, tree vec_type_in), + default_builtin_vectorized_function) + +/* Returns a function declaration for a builtin that realizes the + vector conversion, or NULL_TREE if not available. */ +DEFHOOK +(builtin_conversion, + "", + tree, (unsigned code, tree dest_type, tree src_type), + default_builtin_vectorized_conversion) + +/* Target builtin that implements vector widening multiplication. + builtin_mul_widen_eve computes the element-by-element products + for the even elements, and builtin_mul_widen_odd computes the + element-by-element products for the odd elements. */ +DEFHOOK +(builtin_mul_widen_even, + "", + tree, (tree x), NULL) + +DEFHOOK +(builtin_mul_widen_odd, + "", + tree, (tree x), NULL) + +/* Cost of different vector/scalar statements in vectorization cost + model. In case of misaligned vector loads and stores the cost depends + on the data type and misalignment value. */ +DEFHOOK +(builtin_vectorization_cost, + "", + int, (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign), + default_builtin_vectorization_cost) + +/* Return true if vector alignment is reachable (by peeling N + iterations) for the given type. */ +DEFHOOK +(vector_alignment_reachable, + "", + bool, (const_tree type, bool is_packed), + default_builtin_vector_alignment_reachable) + +/* Target builtin that implements vector permute. */ +DEFHOOK +(builtin_vec_perm, + "", + tree, (tree type, tree *mask_element_type), NULL) + +/* Return true if a vector created for builtin_vec_perm is valid. */ +DEFHOOK +(builtin_vec_perm_ok, + "", + bool, (tree vec_type, tree mask), + hook_bool_tree_tree_true) + +/* Return true if the target supports misaligned store/load of a + specific factor denoted in the third parameter. The last parameter + is true if the access is defined in a packed struct. */ +DEFHOOK +(support_vector_misalignment, + "", + bool, + (enum machine_mode mode, const_tree type, int misalignment, bool is_packed), + default_builtin_support_vector_misalignment) + +/* Returns the preferred mode for SIMD operations for the specified + scalar mode. */ +DEFHOOK +(preferred_simd_mode, + "", + enum machine_mode, + (enum machine_mode mode), + default_preferred_simd_mode) + +/* Returns a mask of vector sizes to iterate over when auto-vectorizing + after processing the preferred one derived from preferred_simd_mode. */ +DEFHOOK +(autovectorize_vector_sizes, + "", + unsigned int, + (void), + default_autovectorize_vector_sizes) + +HOOK_VECTOR_END (vectorize) + +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_" + +/* The initial value of target_flags. */ +DEFHOOKPOD +(default_target_flags, + "", + int, 0) + +/* Allow target specific overriding of option settings after options have + been changed by an attribute or pragma or when it is reset at the + end of the code affected by an attribute or pragma. */ +DEFHOOK +(override_options_after_change, + "", + void, (void), + hook_void_void) + +/* Handle target switch CODE (an OPT_* value). ARG is the argument + passed to the switch; it is NULL if no argument was. VALUE is the + value of ARG if CODE specifies a UInteger option, otherwise it is + 1 if the positive form of the switch was used and 0 if the negative + form was. Return true if the switch was valid. */ +DEFHOOK +(handle_option, + "", + bool, (size_t code, const char *arg, int value), + hook_bool_size_t_constcharptr_int_true) + +/* Display extra, target specific information in response to a + --target-help switch. */ +DEFHOOK +(help, + "", + void, (void), NULL) + +DEFHOOK_UNDOC +(eh_return_filter_mode, + "Return machine mode for filter value.", + enum machine_mode, (void), + default_eh_return_filter_mode) + +/* Return machine mode for libgcc expanded cmp instructions. */ +DEFHOOK +(libgcc_cmp_return_mode, + "", + enum machine_mode, (void), + default_libgcc_cmp_return_mode) + +/* Return machine mode for libgcc expanded shift instructions. */ +DEFHOOK +(libgcc_shift_count_mode, + "", + enum machine_mode, (void), + default_libgcc_shift_count_mode) + +/* Return machine mode to be used for _Unwind_Word type. */ +DEFHOOK +(unwind_word_mode, + "", + enum machine_mode, (void), + default_unwind_word_mode) + +/* Given two decls, merge their attributes and return the result. */ +DEFHOOK +(merge_decl_attributes, + "", + tree, (tree olddecl, tree newdecl), + merge_decl_attributes) + +/* Given two types, merge their attributes and return the result. */ +DEFHOOK +(merge_type_attributes, + "", + tree, (tree type1, tree type2), + merge_type_attributes) + +/* Table of machine attributes and functions to handle them. + Ignored if NULL. */ +DEFHOOKPOD +(attribute_table, + "", + const struct attribute_spec *, NULL) + +/* Return true iff attribute NAME expects a plain identifier as its first + argument. */ +DEFHOOK +(attribute_takes_identifier_p, + "", + bool, (const_tree name), + hook_bool_const_tree_false) + +/* Return zero if the attributes on TYPE1 and TYPE2 are incompatible, + one if they are compatible and two if they are nearly compatible + (which causes a warning to be generated). */ +DEFHOOK +(comp_type_attributes, + "", + int, (const_tree type1, const_tree type2), + hook_int_const_tree_const_tree_1) + +/* Assign default attributes to the newly defined TYPE. */ +DEFHOOK +(set_default_type_attributes, + "", + void, (tree type), + hook_void_tree) + +/* Insert attributes on the newly created DECL. */ +DEFHOOK +(insert_attributes, + "", + void, (tree node, tree *attr_ptr), + hook_void_tree_treeptr) + +/* Return true if FNDECL (which has at least one machine attribute) + can be inlined despite its machine attributes, false otherwise. */ +DEFHOOK +(function_attribute_inlinable_p, + "", + bool, (const_tree fndecl), + hook_bool_const_tree_false) + +/* Return true if bitfields in RECORD_TYPE should follow the + Microsoft Visual C++ bitfield layout rules. */ +DEFHOOK +(ms_bitfield_layout_p, + "", + bool, (const_tree record_type), + hook_bool_const_tree_false) + +/* For now this is only an interface to WORDS_BIG_ENDIAN for + target-independent code like the front ends, need performance testing + before switching completely to the target hook. */ +DEFHOOK_UNDOC +(words_big_endian, + "", + bool, (void), + targhook_words_big_endian) + +/* Likewise for FLOAT_WORDS_BIG_ENDIAN. */ +DEFHOOK_UNDOC +(float_words_big_endian, + "", + bool, (void), + targhook_float_words_big_endian) + +/* True if the target supports decimal floating point. */ +DEFHOOK +(decimal_float_supported_p, + "", + bool, (void), + default_decimal_float_supported_p) + +/* True if the target supports fixed-point. */ +DEFHOOK +(fixed_point_supported_p, + "", + bool, (void), + default_fixed_point_supported_p) + +/* Return true if anonymous bitfields affect structure alignment. */ +DEFHOOK +(align_anon_bitfield, + "", + bool, (void), + hook_bool_void_false) + +/* Return true if volatile bitfields should use the narrowest type possible. + Return false if they should use the container type. */ +DEFHOOK +(narrow_volatile_bitfield, + "", + bool, (void), + hook_bool_void_false) + +/* Set up target-specific built-in functions. */ +DEFHOOK +(init_builtins, + "", + void, (void), + hook_void_void) + +/* Initialize (if INITIALIZE_P is true) and return the target-specific + built-in function decl for CODE. + Return NULL if that is not possible. Return error_mark_node if CODE + is outside of the range of valid target builtin function codes. */ +DEFHOOK +(builtin_decl, + "", + tree, (unsigned code, bool initialize_p), NULL) + +/* Expand a target-specific builtin. */ +DEFHOOK +(expand_builtin, + "", + rtx, + (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore), + default_expand_builtin) + +/* Select a replacement for a target-specific builtin. This is done + *before* regular type checking, and so allows the target to + implement a crude form of function overloading. The result is a + complete expression that implements the operation. PARAMS really + has type VEC(tree,gc)*, but we don't want to include tree.h here. */ +DEFHOOK +(resolve_overloaded_builtin, + "", + tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL) + +/* Fold a target-specific builtin. */ +DEFHOOK +(fold_builtin, + "", + tree, (tree fndecl, int n_args, tree *argp, bool ignore), + hook_tree_tree_int_treep_bool_null) + +/* Returns true if unaligned vector loads/stores are slow. */ +DEFHOOK +(slow_unaligned_vector_memop, + "", + bool, (void), NULL) + +/* Target hook to check if this function should be versioned. */ +DEFHOOK +(mversion_function, + "", + int, (tree fndecl, tree *optimization_node_chain, tree *cond_func_decl), NULL) + +/* Returns a code for a target-specific builtin that implements + reciprocal of the function, or NULL_TREE if not available. */ +DEFHOOK +(builtin_reciprocal, + "", + tree, (unsigned fn, bool md_fn, bool sqrt), + default_builtin_reciprocal) + +/* For a vendor-specific TYPE, return a pointer to a statically-allocated + string containing the C++ mangling for TYPE. In all other cases, return + NULL. */ +DEFHOOK +(mangle_type, + "", + const char *, (const_tree type), + hook_constcharptr_const_tree_null) + +/* Make any adjustments to libfunc names needed for this target. */ +DEFHOOK +(init_libfuncs, + "", + void, (void), + hook_void_void) + +/* Given a decl, a section name, and whether the decl initializer + has relocs, choose attributes for the section. */ +/* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */ +DEFHOOK +(section_type_flags, + "", + unsigned int, (tree decl, const char *name, int reloc), + default_section_type_flags) + +/* True if new jumps cannot be created, to replace existing ones or + not, at the current point in the compilation. */ +DEFHOOK +(cannot_modify_jumps_p, + "", + bool, (void), + hook_bool_void_false) + +/* Return a register class for which branch target register + optimizations should be applied. */ +DEFHOOK +(branch_target_register_class, + "", + reg_class_t, (void), + default_branch_target_register_class) + +/* Return true if branch target register optimizations should include + callee-saved registers that are not already live during the current + function. AFTER_PE_GEN is true if prologues and epilogues have + already been generated. */ +DEFHOOK +(branch_target_register_callee_saved, + "", + bool, (bool after_prologue_epilogue_gen), + hook_bool_bool_false) + +/* Return true if the target supports conditional execution. */ +DEFHOOK +(have_conditional_execution, + "", + bool, (void), + default_have_conditional_execution) + +/* Return a new value for loop unroll size. */ +DEFHOOK +(loop_unroll_adjust, + "", + unsigned, (unsigned nunroll, struct loop *loop), + NULL) + +/* True if the constant X cannot be placed in the constant pool. */ +DEFHOOK +(cannot_force_const_mem, + "", + bool, (rtx x), + hook_bool_rtx_false) + +DEFHOOK_UNDOC +(cannot_copy_insn_p, + "True if the insn @var{x} cannot be duplicated.", + bool, (rtx), NULL) + +/* True if X is considered to be commutative. */ +DEFHOOK +(commutative_p, + "", + bool, (const_rtx x, int outer_code), + hook_bool_const_rtx_commutative_p) + +/* True if ADDR is an address-expression whose effect depends + on the mode of the memory reference it is used in. */ +DEFHOOK +(mode_dependent_address_p, + "", + bool, (const_rtx addr), + default_mode_dependent_address_p) + +/* Given an invalid address X for a given machine mode, try machine-specific + ways to make it legitimate. Return X or an invalid address on failure. */ +DEFHOOK +(legitimize_address, + "", + rtx, (rtx x, rtx oldx, enum machine_mode mode), + default_legitimize_address) + +/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */ +DEFHOOK +(delegitimize_address, + "", + rtx, (rtx x), + delegitimize_mem_from_attrs) + +/* Given an address RTX, say whether it is valid. */ +DEFHOOK +(legitimate_address_p, + "", + bool, (enum machine_mode mode, rtx x, bool strict), + default_legitimate_address_p) + +/* True if the given constant can be put into an object_block. */ +DEFHOOK +(use_blocks_for_constant_p, + "", + bool, (enum machine_mode mode, const_rtx x), + hook_bool_mode_const_rtx_false) + +/* The minimum and maximum byte offsets for anchored addresses. */ +DEFHOOKPOD +(min_anchor_offset, + "", + HOST_WIDE_INT, 0) + +DEFHOOKPOD +(max_anchor_offset, + "", + HOST_WIDE_INT, 0) + +/* True if section anchors can be used to access the given symbol. */ +DEFHOOK +(use_anchors_for_symbol_p, + "", + bool, (const_rtx x), + default_use_anchors_for_symbol_p) + +/* True if it is OK to do sibling call optimization for the specified + call expression EXP. DECL will be the called function, or NULL if + this is an indirect call. */ +DEFHOOK +(function_ok_for_sibcall, + "", + bool, (tree decl, tree exp), + hook_bool_tree_tree_false) + +/* Establish appropriate back-end context for processing the function + FNDECL. The argument might be NULL to indicate processing at top + level, outside of any function scope. */ +DEFHOOK +(set_current_function, + "", + void, (tree decl), hook_void_tree) + +/* True if EXP should be placed in a "small data" section. */ +DEFHOOK +(in_small_data_p, + "", + bool, (const_tree exp), + hook_bool_const_tree_false) + +/* True if EXP names an object for which name resolution must resolve + to the current executable or shared library. */ +DEFHOOK +(binds_local_p, + "", + bool, (const_tree exp), + default_binds_local_p) + +/* Check if profiling code is before or after prologue. */ +DEFHOOK +(profile_before_prologue, + "It returns true if target wants profile code emitted before prologue.\n\n\ +The default version of this hook use the target macro\n\ +@code{PROFILE_BEFORE_PROLOGUE}.", + bool, (void), + default_profile_before_prologue) + +/* Modify and return the identifier of a DECL's external name, + originally identified by ID, as required by the target, + (eg, append @nn to windows32 stdcall function names). + The default is to return ID without modification. */ +DEFHOOK +(mangle_decl_assembler_name, + "", + tree, (tree decl, tree id), + default_mangle_decl_assembler_name) + +/* Do something target-specific to record properties of the DECL into + the associated SYMBOL_REF. */ +DEFHOOK +(encode_section_info, + "", + void, (tree decl, rtx rtl, int new_decl_p), + default_encode_section_info) + +/* Undo the effects of encode_section_info on the symbol string. */ +DEFHOOK +(strip_name_encoding, + "", + const char *, (const char *name), + default_strip_name_encoding) + +/* If shift optabs for MODE are known to always truncate the shift count, + return the mask that they apply. Return 0 otherwise. */ +DEFHOOK +(shift_truncation_mask, + "", + unsigned HOST_WIDE_INT, (enum machine_mode mode), + default_shift_truncation_mask) + +/* Return the number of divisions in the given MODE that should be present, + so that it is profitable to turn the division into a multiplication by + the reciprocal. */ +DEFHOOK +(min_divisions_for_recip_mul, + "", + unsigned int, (enum machine_mode mode), + default_min_divisions_for_recip_mul) + +/* If the representation of integral MODE is such that values are + always sign-extended to a wider mode MODE_REP then return + SIGN_EXTEND. Return UNKNOWN otherwise. */ +/* Note that the return type ought to be RTX_CODE, but that's not + necessarily defined at this point. */ +DEFHOOK +(mode_rep_extended, + "", + int, (enum machine_mode mode, enum machine_mode rep_mode), + default_mode_rep_extended) + +/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */ +DEFHOOK +(valid_pointer_mode, + "", + bool, (enum machine_mode mode), + default_valid_pointer_mode) + +/* Disambiguate with errno. */ +DEFHOOK +(ref_may_alias_errno, + "Define this to return nonzero if the memory reference @var{ref}\ + may alias with the system C library errno location. The default\ + version of this hook assumes the system C library errno location\ + is either a declaration of type int or accessed by dereferencing\ + a pointer to int.", + bool, (struct ao_ref_s *ref), + default_ref_may_alias_errno) + +/* Support for named address spaces. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_ADDR_SPACE_" +HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space) + +/* MODE to use for a pointer into another address space. */ +DEFHOOK +(pointer_mode, + "", + enum machine_mode, (addr_space_t address_space), + default_addr_space_pointer_mode) + +/* MODE to use for an address in another address space. */ +DEFHOOK +(address_mode, + "", + enum machine_mode, (addr_space_t address_space), + default_addr_space_address_mode) + +/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))) + in another address space. */ +DEFHOOK +(valid_pointer_mode, + "", + bool, (enum machine_mode mode, addr_space_t as), + default_addr_space_valid_pointer_mode) + +/* True if an address is a valid memory address to a given named address + space for a given mode. */ +DEFHOOK +(legitimate_address_p, + "", + bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as), + default_addr_space_legitimate_address_p) + +/* Return an updated address to convert an invalid pointer to a named + address space to a valid one. If NULL_RTX is returned use machine + independent methods to make the address valid. */ +DEFHOOK +(legitimize_address, + "", + rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as), + default_addr_space_legitimize_address) + +/* True if one named address space is a subset of another named address. */ +DEFHOOK +(subset_p, + "", + bool, (addr_space_t superset, addr_space_t subset), + default_addr_space_subset_p) + +/* Function to convert an rtl expression from one address space to another. */ +DEFHOOK +(convert, + "", + rtx, (rtx op, tree from_type, tree to_type), + default_addr_space_convert) + +HOOK_VECTOR_END (addr_space) + +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_" + +/* True if MODE is valid for the target. By "valid", we mean able to + be manipulated in non-trivial ways. In particular, this means all + the arithmetic is supported. */ +DEFHOOK +(scalar_mode_supported_p, + "", + bool, (enum machine_mode mode), + default_scalar_mode_supported_p) + +/* Similarly for vector modes. "Supported" here is less strict. At + least some operations are supported; need to check optabs or builtins + for further details. */ +DEFHOOK +(vector_mode_supported_p, + "", + bool, (enum machine_mode mode), + hook_bool_mode_false) + +/* Compute cost of moving data from a register of class FROM to one of + TO, using MODE. */ +DEFHOOK +(register_move_cost, + "", + int, (enum machine_mode mode, reg_class_t from, reg_class_t to), + default_register_move_cost) + +/* Compute cost of moving registers to/from memory. */ +/* ??? Documenting the argument types for this hook requires a GFDL + license grant. Also, the documentation uses a different name for RCLASS. */ +DEFHOOK +(memory_move_cost, + "", + int, (enum machine_mode mode, reg_class_t rclass, bool in), + default_memory_move_cost) + +/* True for MODE if the target expects that registers in this mode will + be allocated to registers in a small register class. The compiler is + allowed to use registers explicitly used in the rtl as spill registers + but it should prevent extending the lifetime of these registers. */ +DEFHOOK +(small_register_classes_for_mode_p, + "", + bool, (enum machine_mode mode), + hook_bool_mode_false) + +/* Register number for a flags register. Only needs to be defined if the + target is constrainted to use post-reload comparison elimination. */ +DEFHOOKPOD +(flags_regnum, + "If the target has a dedicated flags register, and it needs to use the\ + post-reload comparison elimination pass, then this value should be set\ + appropriately.", + unsigned int, INVALID_REGNUM) + +/* Compute a (partial) cost for rtx X. Return true if the complete + cost has been computed, and false if subexpressions should be + scanned. In either case, *TOTAL contains the cost result. */ +/* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's + not necessarily defined at this point. */ +DEFHOOK +(rtx_costs, + "", + bool, (rtx x, int code, int outer_code, int *total, bool speed), + hook_bool_rtx_int_int_intp_bool_false) + +/* Compute the cost of X, used as an address. Never called with + invalid addresses. */ +DEFHOOK +(address_cost, + "", + int, (rtx address, bool speed), + default_address_cost) + +/* Return where to allocate pseudo for a given hard register initial value. */ +DEFHOOK +(allocate_initial_value, + "", + rtx, (rtx hard_reg), NULL) + +/* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap. + FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */ +DEFHOOK +(unspec_may_trap_p, + "", + int, (const_rtx x, unsigned flags), + default_unspec_may_trap_p) + +/* Given a register, this hook should return a parallel of registers + to represent where to find the register pieces. Define this hook + if the register and its mode are represented in Dwarf in + non-contiguous locations, or if the register should be + represented in more than one register in Dwarf. Otherwise, this + hook should return NULL_RTX. */ +DEFHOOK +(dwarf_register_span, + "", + rtx, (rtx reg), + hook_rtx_rtx_null) + +/* If expand_builtin_init_dwarf_reg_sizes needs to fill in table + entries not corresponding directly to registers below + FIRST_PSEUDO_REGISTER, this hook should generate the necessary + code, given the address of the table. */ +DEFHOOK +(init_dwarf_reg_sizes_extra, + "", + void, (tree address), + hook_void_tree) + +/* Fetch the fixed register(s) which hold condition codes, for + targets where it makes sense to look for duplicate assignments to + the condition codes. This should return true if there is such a + register, false otherwise. The arguments should be set to the + fixed register numbers. Up to two condition code registers are + supported. If there is only one for this target, the int pointed + at by the second argument should be set to -1. */ +DEFHOOK +(fixed_condition_code_regs, + "", + bool, (unsigned int *p1, unsigned int *p2), + hook_bool_uintp_uintp_false) + +/* If two condition code modes are compatible, return a condition + code mode which is compatible with both, such that a comparison + done in the returned mode will work for both of the original + modes. If the condition code modes are not compatible, return + VOIDmode. */ +DEFHOOK +(cc_modes_compatible, + "", + enum machine_mode, (enum machine_mode m1, enum machine_mode m2), + default_cc_modes_compatible) + +/* Do machine-dependent code transformations. Called just before + delayed-branch scheduling. */ +DEFHOOK +(machine_dependent_reorg, + "", + void, (void), NULL) + +/* Create the __builtin_va_list type. */ +DEFHOOK +(build_builtin_va_list, + "", + tree, (void), + std_build_builtin_va_list) + +/* Enumerate the va list variants. */ +DEFHOOK +(enum_va_list_p, + "", + int, (int idx, const char **pname, tree *ptree), + NULL) + +/* Get the cfun/fndecl calling abi __builtin_va_list type. */ +DEFHOOK +(fn_abi_va_list, + "", + tree, (tree fndecl), + std_fn_abi_va_list) + +/* Get the __builtin_va_list type dependent on input type. */ +DEFHOOK +(canonical_va_list_type, + "", + tree, (tree type), + std_canonical_va_list_type) + +/* ??? Documenting this hook requires a GFDL license grant. */ +DEFHOOK_UNDOC +(expand_builtin_va_start, +"Expand the @code{__builtin_va_start} builtin.", + void, (tree valist, rtx nextarg), NULL) + +/* Gimplifies a VA_ARG_EXPR. */ +DEFHOOK +(gimplify_va_arg_expr, + "", + tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p), + std_gimplify_va_arg_expr) + +/* Validity-checking routines for PCH files, target-specific. + get_pch_validity returns a pointer to the data to be stored, + and stores the size in its argument. pch_valid_p gets the same + information back and returns NULL if the PCH is valid, + or an error message if not. */ +DEFHOOK +(get_pch_validity, + "", + void *, (size_t *sz), + default_get_pch_validity) + +DEFHOOK +(pch_valid_p, + "", + const char *, (const void *data, size_t sz), + default_pch_valid_p) + +/* If nonnull, this function checks whether a PCH file with the + given set of target flags can be used. It returns NULL if so, + otherwise it returns an error message. */ +DEFHOOK +(check_pch_target_flags, + "", + const char *, (int pch_flags), NULL) + +/* True if the compiler should give an enum type only as many + bytes as it takes to represent the range of possible values of + that type. */ +DEFHOOK +(default_short_enums, + "", + bool, (void), + hook_bool_void_false) + +/* This target hook returns an rtx that is used to store the address + of the current frame into the built-in setjmp buffer. */ +DEFHOOK +(builtin_setjmp_frame_value, + "", + rtx, (void), + default_builtin_setjmp_frame_value) + +/* This target hook should add STRING_CST trees for any hard regs + the port wishes to automatically clobber for an asm. */ +DEFHOOK +(md_asm_clobbers, + "", + tree, (tree outputs, tree inputs, tree clobbers), + hook_tree_tree_tree_tree_3rd_identity) + +/* This target hook allows the backend to specify a calling convention + in the debug information. This function actually returns an + enum dwarf_calling_convention, but because of forward declarations + and not wanting to include dwarf2.h everywhere target.h is included + the function is being declared as an int. */ +DEFHOOK +(dwarf_calling_convention, + "", + int, (const_tree function), + hook_int_const_tree_0) + +/* This target hook allows the backend to emit frame-related insns that + contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info + engine will invoke it on insns of the form + (set (reg) (unspec [...] UNSPEC_INDEX)) + and + (set (reg) (unspec_volatile [...] UNSPECV_INDEX)) + to let the backend emit the call frame instructions. */ +DEFHOOK +(dwarf_handle_frame_unspec, + "", + void, (const char *label, rtx pattern, int index), NULL) + +/* ??? Documenting this hook requires a GFDL license grant. */ +DEFHOOK_UNDOC +(stdarg_optimize_hook, +"Perform architecture specific checking of statements gimplified\ + from @code{VA_ARG_EXPR}. @var{stmt} is the statement. Returns true if\ + the statement doesn't need to be checked for @code{va_list} references.", + bool, (struct stdarg_info *ai, const_gimple stmt), NULL) + +/* This target hook allows the operating system to override the DECL + that represents the external variable that contains the stack + protection guard variable. The type of this DECL is ptr_type_node. */ +DEFHOOK +(stack_protect_guard, + "", + tree, (void), + default_stack_protect_guard) + +/* This target hook allows the operating system to override the CALL_EXPR + that is invoked when a check vs the guard variable fails. */ +DEFHOOK +(stack_protect_fail, + "", + tree, (void), + default_external_stack_protect_fail) + +DEFHOOK +(supports_split_stack, + "Whether this target supports splitting the stack when the options\ + described in @var{opts} have been passed. This is called\ + after options have been parsed, so the target may reject splitting\ + the stack in some configurations. The default version of this hook\ + returns false. If @var{report} is true, this function may issue a warning\ + or error; if @var{report} is false, it must simply return a value", + bool, (bool report, struct gcc_options *opts), + hook_bool_bool_gcc_optionsp_false) + +/* Returns NULL if target supports the insn within a doloop block, + otherwise it returns an error message. */ +DEFHOOK +(invalid_within_doloop, + "", + const char *, (const_rtx insn), + default_invalid_within_doloop) + +DEFHOOK +(valid_dllimport_attribute_p, +"@var{decl} is a variable or function with @code{__attribute__((dllimport))}\ + specified. Use this hook if the target needs to add extra validation\ + checks to @code{handle_dll_attribute}.", + bool, (const_tree decl), + hook_bool_const_tree_true) + +/* If non-zero, align constant anchors in CSE to a multiple of this + value. */ +DEFHOOKPOD +(const_anchor, + "", + unsigned HOST_WIDE_INT, 0) + +/* Functions relating to calls - argument passing, returns, etc. */ +/* Members of struct call have no special macro prefix. */ +HOOK_VECTOR (TARGET_CALLS, calls) + +DEFHOOK +(promote_function_mode, + "", + enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp, + const_tree funtype, int for_return), + default_promote_function_mode) + +DEFHOOK +(promote_prototypes, + "", + bool, (const_tree fntype), + hook_bool_const_tree_false) + +DEFHOOK +(struct_value_rtx, + "", + rtx, (tree fndecl, int incoming), + hook_rtx_tree_int_null) +DEFHOOK +(return_in_memory, + "", + bool, (const_tree type, const_tree fntype), + default_return_in_memory) + +DEFHOOK +(return_in_msb, + "", + bool, (const_tree type), + hook_bool_const_tree_false) + +/* Return true if a parameter must be passed by reference. TYPE may + be null if this is a libcall. CA may be null if this query is + from __builtin_va_arg. */ +DEFHOOK +(pass_by_reference, + "", + bool, + (CUMULATIVE_ARGS *cum, enum machine_mode mode, const_tree type, bool named), + hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false) + +DEFHOOK +(expand_builtin_saveregs, + "", + rtx, (void), + default_expand_builtin_saveregs) + +/* Returns pretend_argument_size. */ +DEFHOOK +(setup_incoming_varargs, + "", + void, (CUMULATIVE_ARGS *args_so_far, enum machine_mode mode, tree type, + int *pretend_args_size, int second_time), + default_setup_incoming_varargs) + +DEFHOOK +(strict_argument_naming, + "", + bool, (CUMULATIVE_ARGS *ca), + hook_bool_CUMULATIVE_ARGS_false) + +/* Returns true if we should use + targetm.calls.setup_incoming_varargs() and/or + targetm.calls.strict_argument_naming(). */ +DEFHOOK +(pretend_outgoing_varargs_named, + "", + bool, (CUMULATIVE_ARGS *ca), + default_pretend_outgoing_varargs_named) + +/* Given a complex type T, return true if a parameter of type T + should be passed as two scalars. */ +DEFHOOK +(split_complex_arg, + "", + bool, (const_tree type), NULL) + +/* Return true if type T, mode MODE, may not be passed in registers, + but must be passed on the stack. */ +/* ??? This predicate should be applied strictly after pass-by-reference. + Need audit to verify that this is the case. */ +DEFHOOK +(must_pass_in_stack, + "", + bool, (enum machine_mode mode, const_tree type), + must_pass_in_stack_var_size_or_pad) + +/* Return true if type TYPE, mode MODE, which is passed by reference, + should have the object copy generated by the callee rather than + the caller. It is never called for TYPE requiring constructors. */ +DEFHOOK +(callee_copies, + "", + bool, + (CUMULATIVE_ARGS *cum, enum machine_mode mode, const_tree type, bool named), + hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false) + +/* Return zero for arguments passed entirely on the stack or entirely + in registers. If passed in both, return the number of bytes passed + in registers; the balance is therefore passed on the stack. */ +DEFHOOK +(arg_partial_bytes, + "", + int, (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type, bool named), + hook_int_CUMULATIVE_ARGS_mode_tree_bool_0) + +/* Update the state in CA to advance past an argument in the + argument list. The values MODE, TYPE, and NAMED describe that + argument. */ +/* ??? tm.texi still only describes the old macro. */ +DEFHOOK_UNDOC +(function_arg_advance, + "", + void, + (CUMULATIVE_ARGS *ca, enum machine_mode mode, const_tree type, bool named), + default_function_arg_advance) + +/* Return zero if the argument described by the state of CA should + be placed on a stack, or a hard register in which to store the + argument. The values MODE, TYPE, and NAMED describe that + argument. */ +/* ??? tm.texi still only describes the old macro. */ +DEFHOOK_UNDOC +(function_arg, + "", + rtx, (CUMULATIVE_ARGS *ca, enum machine_mode mode, const_tree type, + bool named), + default_function_arg) + +/* Likewise, but for machines with register windows. Return the + location where the argument will appear to the callee. */ +/* ??? tm.texi still only describes the old macro. */ +DEFHOOK_UNDOC +(function_incoming_arg, + "", + rtx, (CUMULATIVE_ARGS *ca, enum machine_mode mode, const_tree type, + bool named), + default_function_incoming_arg) + +DEFHOOK +(function_arg_boundary, + "", + unsigned int, (enum machine_mode mode, const_tree type), + default_function_arg_boundary) + +/* Return the diagnostic message string if function without a prototype + is not allowed for this 'val' argument; NULL otherwise. */ +DEFHOOK +(invalid_arg_for_unprototyped_fn, + "", + const char *, (const_tree typelist, const_tree funcdecl, const_tree val), + hook_invalid_arg_for_unprototyped_fn) + +/* Return an rtx for the return value location of the function + specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */ +DEFHOOK +(function_value, + "", + rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing), + default_function_value) + +/* Return the rtx for the result of a libcall of mode MODE, + calling the function FN_NAME. */ +DEFHOOK +(libcall_value, + "", + rtx, (enum machine_mode mode, const_rtx fun), + default_libcall_value) + +/* Return true if REGNO is a possible register number for + a function value as seen by the caller. */ +DEFHOOK +(function_value_regno_p, + "", + bool, (const unsigned int regno), + default_function_value_regno_p) + +/* ??? Documenting this hook requires a GFDL license grant. */ +DEFHOOK_UNDOC +(internal_arg_pointer, +"Return an rtx for the argument pointer incoming to the\ + current function.", + rtx, (void), + default_internal_arg_pointer) + +/* Update the current function stack boundary if needed. */ +DEFHOOK +(update_stack_boundary, + "", + void, (void), NULL) + +/* Handle stack alignment and return an rtx for Dynamic Realign + Argument Pointer if necessary. */ +DEFHOOK +(get_drap_rtx, + "", + rtx, (void), NULL) + +/* Return true if all function parameters should be spilled to the + stack. */ +DEFHOOK +(allocate_stack_slots_for_args, + "", + bool, (void), + hook_bool_void_true) + +/* Return an rtx for the static chain for FNDECL. If INCOMING_P is true, + then it should be for the callee; otherwise for the caller. */ +DEFHOOK +(static_chain, + "", + rtx, (const_tree fndecl, bool incoming_p), + default_static_chain) + +/* Fill in the trampoline at MEM with a call to FNDECL and a + static chain value of CHAIN. */ +DEFHOOK +(trampoline_init, + "", + void, (rtx m_tramp, tree fndecl, rtx static_chain), + default_trampoline_init) + +/* Adjust the address of the trampoline in a target-specific way. */ +DEFHOOK +(trampoline_adjust_address, + "", + rtx, (rtx addr), NULL) + +/* Return the number of bytes of its own arguments that a function + pops on returning, or 0 if the function pops no arguments and the + caller must therefore pop them all after the function returns. */ +/* ??? tm.texi has no types for the parameters. */ +DEFHOOK +(return_pops_args, + "", + int, (tree fundecl, tree funtype, int size), + default_return_pops_args) + +/* Return a mode wide enough to copy any function value that might be + returned. */ +DEFHOOK +(get_raw_result_mode, + "This target hook returns the mode to be used when accessing raw return\ + registers in @code{__builtin_return}. Define this macro if the value\ + in @var{reg_raw_mode} is not correct.", + enum machine_mode, (int regno), + default_get_reg_raw_mode) + +/* Return a mode wide enough to copy any argument value that might be + passed. */ +DEFHOOK +(get_raw_arg_mode, + "This target hook returns the mode to be used when accessing raw argument\ + registers in @code{__builtin_apply_args}. Define this macro if the value\ + in @var{reg_raw_mode} is not correct.", + enum machine_mode, (int regno), + default_get_reg_raw_mode) + +HOOK_VECTOR_END (calls) + +/* Return the diagnostic message string if conversion from FROMTYPE + to TOTYPE is not allowed, NULL otherwise. */ +DEFHOOK +(invalid_conversion, + "", + const char *, (const_tree fromtype, const_tree totype), + hook_constcharptr_const_tree_const_tree_null) + +/* Return the diagnostic message string if the unary operation OP is + not permitted on TYPE, NULL otherwise. */ +DEFHOOK +(invalid_unary_op, + "", + const char *, (int op, const_tree type), + hook_constcharptr_int_const_tree_null) + +/* Return the diagnostic message string if the binary operation OP + is not permitted on TYPE1 and TYPE2, NULL otherwise. */ +DEFHOOK +(invalid_binary_op, + "", + const char *, (int op, const_tree type1, const_tree type2), + hook_constcharptr_int_const_tree_const_tree_null) + +/* Return the diagnostic message string if TYPE is not valid as a + function parameter type, NULL otherwise. */ +DEFHOOK +(invalid_parameter_type, + "", + const char *, (const_tree type), + hook_constcharptr_const_tree_null) + +/* Return the diagnostic message string if TYPE is not valid as a + function return type, NULL otherwise. */ +DEFHOOK +(invalid_return_type, + "", + const char *, (const_tree type), + hook_constcharptr_const_tree_null) + +/* If values of TYPE are promoted to some other type when used in + expressions (analogous to the integer promotions), return that type, + or NULL_TREE otherwise. */ +DEFHOOK +(promoted_type, + "", + tree, (const_tree type), + hook_tree_const_tree_null) + +/* Convert EXPR to TYPE, if target-specific types with special conversion + rules are involved. Return the converted expression, or NULL to apply + the standard conversion rules. */ +DEFHOOK +(convert_to_type, + "", + tree, (tree type, tree expr), + hook_tree_tree_tree_null) + +/* Return the array of IRA cover classes for the current target. */ +DEFHOOK +(ira_cover_classes, + "", + const reg_class_t *, (void), + default_ira_cover_classes) + +/* Return the class for a secondary reload, and fill in extra information. */ +DEFHOOK +(secondary_reload, + "", + reg_class_t, + (bool in_p, rtx x, reg_class_t reload_class, enum machine_mode reload_mode, + secondary_reload_info *sri), + default_secondary_reload) + +/* Given an rtx X being reloaded into a reg required to be in class CLASS, + return the class of reg to actually use. */ +DEFHOOK +(preferred_reload_class, + "", + reg_class_t, + (rtx x, reg_class_t rclass), + default_preferred_reload_class) + +/* Like TARGET_PREFERRED_RELOAD_CLASS, but for output reloads instead of + input reloads. */ +DEFHOOK +(preferred_output_reload_class, + "", + reg_class_t, + (rtx x, reg_class_t rclass), + default_preferred_output_reload_class) + +DEFHOOK +(class_likely_spilled_p, + "", + bool, (reg_class_t rclass), + default_class_likely_spilled_p) + +DEFHOOK +(preferred_rename_class, + "A target hook that places additional preference on the register\ + class to use when it is necessary to rename a register in class\ + @var{rclass} to another class, or perhaps @var{NO_REGS}, if no\ + preferred register class is found or hook @code{preferred_rename_class}\ + is not implemented.\ + Sometimes returning a more restrictive class makes better code. For\ + example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\ + smaller than instructions using @code{GENERIC_REGS}. By returning\ + @code{LO_REGS} from @code{preferred_rename_class}, code size can\ + be reduced.", + reg_class_t, (reg_class_t rclass), + default_preferred_rename_class) + +/* This target hook allows the backend to perform additional + processing while initializing for variable expansion. */ +DEFHOOK +(expand_to_rtl_hook, + "", + void, (void), + hook_void_void) + +/* This target hook allows the backend to perform additional + instantiations on rtx that are not actually in insns yet, + but will be later. */ +DEFHOOK +(instantiate_decls, + "", + void, (void), + hook_void_void) + +/* Return true if is OK to use a hard register REGNO as scratch register + in peephole2. */ +DEFHOOK +(hard_regno_scratch_ok, + "", + bool, (unsigned int regno), + default_hard_regno_scratch_ok) + +/* Return the smallest number of different values for which it is best to + use a jump-table instead of a tree of conditional branches. */ +DEFHOOK +(case_values_threshold, + "", + unsigned int, (void), + default_case_values_threshold) + +/* Retutn true if a function must have and use a frame pointer. */ +DEFHOOK +(frame_pointer_required, + "", + bool, (void), + hook_bool_void_false) + +/* Returns true if the compiler is allowed to try to replace register number + from-reg with register number to-reg. */ +DEFHOOK +(can_eliminate, + "", + bool, (const int from_reg, const int to_reg), + hook_bool_const_int_const_int_true) + +/* Modify any or all of fixed_regs, call_used_regs, global_regs, + reg_names, and reg_class_contents to account of the vagaries of the + target. */ +DEFHOOK +(conditional_register_usage, + "", + void, (void), + hook_void_void) + +/* Functions specific to the C family of frontends. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_C_" +HOOK_VECTOR (TARGET_C, c) + +/* ??? Documenting this hook requires a GFDL license grant. */ +DEFHOOK_UNDOC +(mode_for_suffix, +"Return machine mode for non-standard constant literal suffix @var{c},\ + or VOIDmode if non-standard suffixes are unsupported.", + enum machine_mode, (char c), + default_mode_for_suffix) + +HOOK_VECTOR_END (c) + +/* Functions specific to the C++ frontend. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_CXX_" +HOOK_VECTOR (TARGET_CXX, cxx) + +/* Return the integer type used for guard variables. */ +DEFHOOK +(guard_type, + "", + tree, (void), + default_cxx_guard_type) + +/* Return true if only the low bit of the guard should be tested. */ +DEFHOOK +(guard_mask_bit, + "", + bool, (void), + hook_bool_void_false) + +/* Returns the size of the array cookie for an array of type. */ +DEFHOOK +(get_cookie_size, + "", + tree, (tree type), + default_cxx_get_cookie_size) + +/* Returns true if the element size should be stored in the array cookie. */ +DEFHOOK +(cookie_has_size, + "", + bool, (void), + hook_bool_void_false) + +/* Allows backends to perform additional processing when + deciding if a class should be exported or imported. */ +DEFHOOK +(import_export_class, + "", + int, (tree type, int import_export), NULL) + +/* Returns true if constructors and destructors return "this". */ +DEFHOOK +(cdtor_returns_this, + "", + bool, (void), + hook_bool_void_false) + +/* Returns true if the key method for a class can be an inline + function, so long as it is not declared inline in the class + itself. Returning true is the behavior required by the Itanium C++ ABI. */ +DEFHOOK +(key_method_may_be_inline, + "", + bool, (void), + hook_bool_void_true) + +DEFHOOK +(determine_class_data_visibility, +"@var{decl} is a virtual table, virtual table table, typeinfo object,\ + or other similar implicit class data object that will be emitted with\ + external linkage in this translation unit. No ELF visibility has been\ + explicitly specified. If the target needs to specify a visibility\ + other than that of the containing class, use this hook to set\ + @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.", + void, (tree decl), + hook_void_tree) + +/* Returns true (the default) if virtual tables and other + similar implicit class data objects are always COMDAT if they + have external linkage. If this hook returns false, then + class data for classes whose virtual table will be emitted in + only one translation unit will not be COMDAT. */ +DEFHOOK +(class_data_always_comdat, + "", + bool, (void), + hook_bool_void_true) + +/* Returns true (the default) if the RTTI for the basic types, + which is always defined in the C++ runtime, should be COMDAT; + false if it should not be COMDAT. */ +DEFHOOK +(library_rtti_comdat, + "", + bool, (void), + hook_bool_void_true) + +/* Returns true if __aeabi_atexit should be used to register static + destructors. */ +DEFHOOK +(use_aeabi_atexit, + "", + bool, (void), + hook_bool_void_false) + +/* Returns true if target may use atexit in the same manner as + __cxa_atexit to register static destructors. */ +DEFHOOK +(use_atexit_for_cxa_atexit, + "", + bool, (void), + hook_bool_void_false) + +DEFHOOK +(adjust_class_at_definition, +"@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\ + been defined. Use this hook to make adjustments to the class (eg, tweak\ + visibility or perform any other required target modifications).", + void, (tree type), + hook_void_tree) + +HOOK_VECTOR_END (cxx) + +/* Functions and data for emulated TLS support. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_EMUTLS_" +HOOK_VECTOR (TARGET_EMUTLS, emutls) + +/* Name of the address and common functions. */ +DEFHOOKPOD +(get_address, + "", + const char *, "__builtin___emutls_get_address") + +DEFHOOKPOD +(register_common, + "", + const char *, "__builtin___emutls_register_common") + +/* Prefixes for proxy variable and template. */ +DEFHOOKPOD +(var_section, + "", + const char *, NULL) + +DEFHOOKPOD +(tmpl_section, + "", + const char *, NULL) + +/* Prefixes for proxy variable and template. */ +DEFHOOKPOD +(var_prefix, + "", + const char *, NULL) + +DEFHOOKPOD +(tmpl_prefix, + "", + const char *, NULL) + +/* Function to generate field definitions of the proxy variable. */ +DEFHOOK +(var_fields, + "", + tree, (tree type, tree *name), + default_emutls_var_fields) + +/* Function to initialize a proxy variable. */ +DEFHOOK +(var_init, + "", + tree, (tree var, tree decl, tree tmpl_addr), + default_emutls_var_init) + +/* Whether we are allowed to alter the usual alignment of the + proxy variable. */ +DEFHOOKPOD +(var_align_fixed, + "", + bool, false) + +/* Whether we can emit debug information for TLS vars. */ +DEFHOOKPOD +(debug_form_tls_address, + "", + bool, false) + +HOOK_VECTOR_END (emutls) + +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_OPTION_" +HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks) + +/* Function to validate the attribute((option(...))) strings or NULL. If + the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will + be filled in in the function decl node. */ +DEFHOOK +(valid_attribute_p, + "", + bool, (tree fndecl, tree name, tree args, int flags), + default_target_option_valid_attribute_p) + +/* Function to save any extra target state in the target options structure. */ +DEFHOOK +(save, + "", + void, (struct cl_target_option *ptr), NULL) + +/* Function to restore any extra target state from the target options + structure. */ +DEFHOOK +(restore, + "", + void, (struct cl_target_option *ptr), NULL) + +/* Function to print any extra target state from the target options + structure. */ +DEFHOOK +(print, + "", + void, (FILE *file, int indent, struct cl_target_option *ptr), NULL) + +/* Function to parse arguments to be validated for #pragma option, and to + change the state if the options are valid. If the first argument is + NULL, the second argument specifies the default options to use. Return + true if the options are valid, and set the current state. */ +/* ??? The documentation in tm.texi is incomplete. */ +DEFHOOK +(pragma_parse, + "", + bool, (tree args, tree pop_target), + default_target_option_pragma_parse) + +/* Do option overrides for the target. */ +DEFHOOK +(override, + "", + void, (void), + hook_void_void) + +/* Set default optimizations for the target. */ +DEFHOOKPOD +(optimization_table, + "", + const struct default_options *, empty_optimization_table) + +DEFHOOK +(default_params, +"Set target-dependent default values for @option{--param} settings, using\ + calls to @code{set_default_param_value}.", + void, (void), + hook_void_void) + +DEFHOOK +(init_struct, +"Set target-dependent initial values of fields in @var{opts}.", + void, (struct gcc_options *opts), + hook_void_gcc_optionsp) + +/* Function to determine if one function can inline another function. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_" +DEFHOOK +(can_inline_p, + "", + bool, (tree caller, tree callee), + default_target_can_inline_p) + +HOOK_VECTOR_END (target_option) + +/* Functions used to simplify GOT access. */ +#undef HOOK_PREFIX +#define HOOK_PREFIX "TARGET_" +HOOK_VECTOR (TARGET_SIMPLIFY_GOT_ACCESS, simplify_got_access) + +/* Function to get the pic_reg which holds the base address of GOT. */ +DEFHOOK +(get_pic_reg, +"Return the pic_reg pseudo register which holds the base address of GOT.\ + It is only required by the simplify-got optimization.", + rtx, (void), + hook_rtx_void_null) + +/* Function to clear the pic_reg which is useless now. */ +DEFHOOK +(clear_pic_reg, +"After successful simplify-got optimization, the pic_reg is useless. So a\ + target can use this hook to clear pic_reg.", + void, (void), + NULL) + +/* Function to detect if the specified insn loads a global variable's + address from GOT. If so returns that symbol. */ +DEFHOOK +(loaded_global_var, +"This hook is used to detect if the given @var{insn} loads a global\ + variable's address from GOT with the form of\ + @smallexample\ + (set @var{address_reg} (mem (plus pic_reg @var{offset_reg})))\ + @end smallexample\ + If so return the global variable whose address will be loaded and fill in\ + @var{offset_insn} and @var{offset_reg}. @var{offset_reg} is set at\ + @var{offset_insn} to hold the offset from GOT base to the GOT entry of the\ + global variable. Otherwise return @code{NULL_RTX}.", + rtx, (rtx insn, rtx *offset_reg, rtx *offset_insn), + NULL) + +/* This function checks if it satisfies the target dependent conditions + that we can simplify GOT accesses. */ +DEFHOOK +(can_simplify_got_access, +"This hook determines if it satisfy the target dependent conditions to do\ + simplify-got when given the number of global variable accessing and the\ + number of accessed symbols. If the returned value is false the GOT access\ + insns will not be rewritten. Otherwise we will rewrite these insns.", + bool, (int n_symbol, int n_access), + NULL) + +/* This function does the actual rewriting of GOT accesses. */ +DEFHOOK +(load_global_address, +"This hook does the actual rewriting of GOT access insn @var{load_insn}.\ + The global variable is @var{symbol}. The global address should be loaded\ + into @var{address_reg}. The register @var{offset_reg} was previously set\ + in insn @var{offset_insn} to hold the offset from GOT base to the GOT\ + entry of the global variable. Now it can be used as a scratch register.", + void, (rtx symbol, rtx offset_reg, rtx address_reg, rtx load_insn, + rtx offset_insn), + NULL) + +HOOK_VECTOR_END (got_access) + +/* For targets that need to mark extra registers as live on entry to + the function, they should define this target hook and set their + bits in the bitmap passed in. */ +DEFHOOK +(extra_live_on_entry, + "", + void, (bitmap regs), + hook_void_bitmap) + +/* Determine the type of unwind info to emit for debugging. */ +DEFHOOK +(debug_unwind_info, + "", + enum unwind_info_type, (void), + default_debug_unwind_info) + +/* Determine the type of unwind info to emit for exceptions. */ +DEFHOOK +(except_unwind_info, + "", + enum unwind_info_type, (struct gcc_options *opts), + default_except_unwind_info) + +/* Leave the boolean fields at the end. */ + +/* True if unwinding tables should be generated by default. */ +DEFHOOKPOD +(unwind_tables_default, + "", + bool, false) + +/* True if arbitrary sections are supported. */ +DEFHOOKPOD +(have_named_sections, + "", + bool, false) + +/* True if we can create zeroed data by switching to a BSS section + and then using ASM_OUTPUT_SKIP to allocate the space. */ +DEFHOOKPOD +(have_switchable_bss_sections, + "", + bool, false) + +/* True if "native" constructors and destructors are supported, + false if we're using collect2 for the job. */ +DEFHOOKPOD +(have_ctors_dtors, + "", + bool, false) + +/* True if thread-local storage is supported. */ +DEFHOOKPOD +(have_tls, + "", + bool, false) + +/* True if a small readonly data section is supported. */ +DEFHOOKPOD +(have_srodata_section, + "", + bool, false) + +/* True if EH frame info sections should be zero-terminated. */ +DEFHOOKPOD +(terminate_dw2_eh_frame_info, + "", + bool, true) + +/* True if #NO_APP should be emitted at the beginning of assembly output. */ +DEFHOOKPOD +(asm_file_start_app_off, + "", + bool, false) + +/* True if output_file_directive should be called for main_input_filename + at the beginning of assembly output. */ +DEFHOOKPOD +(asm_file_start_file_directive, + "", + bool, false) + +DEFHOOKPOD +(handle_pragma_extern_prefix, +"True if @code{#pragma extern_prefix} is to be supported.", + bool, 0) + +/* True if the target is allowed to reorder memory accesses unless + synchronization is explicitly requested. */ +DEFHOOKPOD +(relaxed_ordering, + "", + bool, false) + +/* Returns true if we should generate exception tables for use with the + ARM EABI. The effects the encoding of function exception specifications. */ +DEFHOOKPOD +(arm_eabi_unwinder, + "", + bool, false) + +DEFHOOKPOD +(want_debug_pub_sections, + "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\ + should be emitted. These sections are not used on most platforms, and\ + in particular GDB does not use them.", + bool, true) + +DEFHOOKPOD +(delay_sched2, "True if sched2 is not to be run at its normal place. \ +This usually means it will be run as part of machine-specific reorg.", +bool, false) + +DEFHOOKPOD +(delay_vartrack, "True if vartrack is not to be run at its normal place. \ +This usually means it will be run as part of machine-specific reorg.", +bool, false) + +/* Leave the boolean fields at the end. */ + +/* Empty macro arguments are undefined in C90, so use an empty macro. */ +#define C90_EMPTY_HACK +/* Close the 'struct gcc_target' definition. */ +HOOK_VECTOR_END (C90_EMPTY_HACK) + +HOOK_VECTOR (TARGETCM_INITIALIZER, gcc_targetcm) + +/* Handle target switch CODE (an OPT_* value). ARG is the argument + passed to the switch; it is NULL if no argument was. VALUE is the + value of ARG if CODE specifies a UInteger option, otherwise it is + 1 if the positive form of the switch was used and 0 if the negative + form was. Return true if the switch was valid. */ +DEFHOOK +(handle_c_option, + "", + bool, (size_t code, const char *arg, int value), + default_handle_c_option) + +/* Targets may provide a string object type that can be used within + and between C, C++, and Objective-C dialects. */ + +DEFHOOK +(objc_construct_string_object, + "Targets may provide a string object type that can be used within\ + and between C, C++ and their respective Objective-C dialects.\ + A string object might, for example, embed encoding and length information.\ + These objects are considered opaque to the compiler and handled as references.\ + An ideal implementation makes the composition of the string object\ + match that of the Objective-C @code{NSString} (@code{NXString} for GNUStep),\ + allowing efficient interworking between C-only and Objective-C code.\ + If a target implements string objects then this hook should return a\ + reference to such an object constructed from the normal `C' string\ + representation provided in @var{string}.\ + At present, the hook is used by Objective-C only, to obtain a\ + common-format string object when the target provides one.", + tree, (tree string), + NULL) + +DEFHOOK +(string_object_ref_type_p, + "If a target implements string objects then this hook should return\ + @code{true} if @var{stringref} is a valid reference to such an object.", + bool, (const_tree stringref), + hook_bool_const_tree_false) + +DEFHOOK +(check_string_object_format_arg, + "If a target implements string objects then this hook should should\ + provide a facility to check the function arguments in @var{args_list}\ + against the format specifiers in @var{format_arg} where the type of\ + @var{format_arg} is one recognized as a valid string reference type.", + void, (tree format_arg, tree args_list), + NULL) + +HOOK_VECTOR_END (C90_EMPTY_HACK) diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/target.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/target.h new file mode 100644 index 0000000..eaf7aad --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/target.h @@ -0,0 +1,182 @@ +/* Data structure definitions for a generic GCC target. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + + 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 3, 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; see the file COPYING3. If not see + <http://www.gnu.org/licenses/>. + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ + + +/* This file contains a data structure that describes a GCC target. + At present it is incomplete, but in future it should grow to + contain most or all target machine and target O/S specific + information. + + This structure has its initializer declared in target-def.h in the + form of large macro TARGET_INITIALIZER that expands to many smaller + macros. + + The smaller macros each initialize one component of the structure, + and each has a default. Each target should have a file that + includes target.h and target-def.h, and overrides any inappropriate + defaults by undefining the relevant macro and defining a suitable + replacement. That file should then contain the definition of + "targetm" like so: + + struct gcc_target targetm = TARGET_INITIALIZER; + + Doing things this way allows us to bring together everything that + defines a GCC target. By supplying a default that is appropriate + to most targets, we can easily add new items without needing to + edit dozens of target configuration files. It should also allow us + to gradually reduce the amount of conditional compilation that is + scattered throughout GCC. */ + +#ifndef GCC_TARGET_H +#define GCC_TARGET_H + +#include "tm.h" +#include "insn-modes.h" + +/* Types used by the record_gcc_switches() target function. */ +typedef enum +{ + SWITCH_TYPE_PASSED, /* A switch passed on the command line. */ + SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */ + SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */ + SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */ + SWITCH_TYPE_LINE_END /* Please emit a line terminator. */ +} +print_switch_type; + +typedef int (* print_switch_fn_type) (print_switch_type, const char *); + +/* An example implementation for ELF targets. Defined in varasm.c */ +extern int elf_record_gcc_switches (print_switch_type type, const char *); + +/* Some places still assume that all pointer or address modes are the + standard Pmode and ptr_mode. These optimizations become invalid if + the target actually supports multiple different modes. For now, + we disable such optimizations on such targets, using this function. */ +extern bool target_default_pointer_address_modes_p (void); + +struct stdarg_info; +struct spec_info_def; + +/* The struct used by the secondary_reload target hook. */ +typedef struct secondary_reload_info +{ + /* icode is actually an enum insn_code, but we don't want to force every + file that includes target.h to include optabs.h . */ + int icode; + int extra_cost; /* Cost for using (a) scratch register(s) to be taken + into account by copy_cost. */ + /* The next two members are for the use of the backward + compatibility hook. */ + struct secondary_reload_info *prev_sri; + int t_icode; /* Actually an enum insn_code - see above. */ +} secondary_reload_info; + +/* This is defined in sched-int.h . */ +struct _dep; + +/* This is defined in ddg.h . */ +struct ddg; + +/* This is defined in cfgloop.h . */ +struct loop; + +/* This is defined in tree-ssa-alias.h. */ +struct ao_ref_s; + +/* Assembler instructions for creating various kinds of integer object. */ + +struct asm_int_op +{ + const char *hi; + const char *si; + const char *di; + const char *ti; +}; + +/* Types of costs for vectorizer cost model. */ +enum vect_cost_for_stmt +{ + scalar_stmt, + scalar_load, + scalar_store, + vector_stmt, + vector_load, + unaligned_load, + unaligned_store, + vector_store, + vec_to_scalar, + scalar_to_vec, + cond_branch_not_taken, + cond_branch_taken, + vec_perm +}; + +/* Sets of optimization levels at which an option may be enabled by + default_options_optimization. */ +enum opt_levels +{ + OPT_LEVELS_NONE, /* No levels (mark end of array). */ + OPT_LEVELS_ALL, /* All levels (used by targets to disable options + enabled in target-independent code). */ + OPT_LEVELS_0_ONLY, /* -O0 only. */ + OPT_LEVELS_1_PLUS, /* -O1 and above, including -Os. */ + OPT_LEVELS_1_PLUS_SPEED_ONLY, /* -O1 and above, but not -Os. */ + OPT_LEVELS_2_PLUS, /* -O2 and above, including -Os. */ + OPT_LEVELS_2_PLUS_SPEED_ONLY, /* -O2 and above, but not -Os. */ + OPT_LEVELS_3_PLUS, /* -O3 and above. */ + OPT_LEVELS_3_PLUS_AND_SIZE, /* -O3 and above and -Os. */ + OPT_LEVELS_SIZE, /* -Os only. */ + OPT_LEVELS_FAST /* -Ofast only. */ +}; + +/* Description of options to enable by default at given levels. */ +struct default_options +{ + /* The levels at which to enable the option. */ + enum opt_levels levels; + + /* The option index and argument or enabled/disabled sense of the + option, as passed to handle_generated_option. If ARG is NULL and + the option allows a negative form, the option is considered to be + passed in negative form when the optimization level is not one of + those in LEVELS (in order to handle changes to the optimization + level with the "optimize" attribute). */ + size_t opt_index; + const char *arg; + int value; +}; + +/* The target structure. This holds all the backend hooks. */ +#define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME; +#define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS; +#define DEFHOOK_UNDOC DEFHOOK +#define HOOKSTRUCT(FRAGMENT) FRAGMENT + +#include "target.def" + +extern struct gcc_target targetm; + +/* Each target can provide their own. */ +extern struct gcc_targetcm targetcm; + +#endif /* GCC_TARGET_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/timevar.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/timevar.def new file mode 100644 index 0000000..87d4157 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/timevar.def @@ -0,0 +1,269 @@ +/* This file contains the definitions for timing variables used to + measure run-time performance of the compiler. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2010 + Free Software Foundation, Inc. + Contributed by Alex Samuel <samuel@codesourcery.com> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + GCC is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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/>. */ + +/* This file contains timing variable definitions, used by timevar.h + and timevar.c. + + Syntax: + + DEFTIMEVAR (id, name) + + where ID is the enumeral value used to identify the timing + variable, and NAME is a character string describing its purpose. */ + +/* The total execution time. */ +DEFTIMEVAR (TV_TOTAL , "total time") +DEFTIMEVAR (TV_PHASE_SETUP , "phase setup") +DEFTIMEVAR (TV_PHASE_PARSING , "phase parsing") +DEFTIMEVAR (TV_PHASE_DEFERRED , "phase lang. deferred") +DEFTIMEVAR (TV_PHASE_CGRAPH , "phase cgraph") +DEFTIMEVAR (TV_PHASE_DBGINFO , "phase debug info") +DEFTIMEVAR (TV_PHASE_CHECK_DBGINFO , "phase check & debug info") +DEFTIMEVAR (TV_PHASE_GENERATE , "phase generate") +DEFTIMEVAR (TV_PHASE_FINALIZE , "phase finalize") + +/* Concurrent timers, indicated by "|". */ +DEFTIMEVAR (TV_NAME_LOOKUP , "|name lookup") +DEFTIMEVAR (TV_OVERLOAD , "|overload resolution") + +/* Time spent garbage-collecting. */ +DEFTIMEVAR (TV_GC , "garbage collection") + +/* Time spent generating dump files. */ +DEFTIMEVAR (TV_DUMP , "dump files") + +/* Time spent saving/restoring PCH state. */ +DEFTIMEVAR (TV_PCH_SAVE , "PCH main state save") +DEFTIMEVAR (TV_PCH_CPP_SAVE , "PCH preprocessor state save") +DEFTIMEVAR (TV_PCH_PTR_REALLOC , "PCH pointer reallocation") +DEFTIMEVAR (TV_PCH_PTR_SORT , "PCH pointer sort") +DEFTIMEVAR (TV_PCH_RESTORE , "PCH main state restore") +DEFTIMEVAR (TV_PCH_CPP_RESTORE , "PCH preprocessor state restore") + +DEFTIMEVAR (TV_CGRAPH , "callgraph construction") +DEFTIMEVAR (TV_CGRAPHOPT , "callgraph optimization") +DEFTIMEVAR (TV_VARPOOL , "varpool construction") +DEFTIMEVAR (TV_IPA_CONSTANT_PROP , "ipa cp") +DEFTIMEVAR (TV_IPA_FNSPLIT , "ipa function splitting") +DEFTIMEVAR (TV_IPA_OPT , "ipa various optimizations") +DEFTIMEVAR (TV_IPA_LTO_GIMPLE_IN , "ipa lto gimple in") +DEFTIMEVAR (TV_IPA_LTO_GIMPLE_OUT , "ipa lto gimple out") +DEFTIMEVAR (TV_IPA_LTO_DECL_IN , "ipa lto decl in") +DEFTIMEVAR (TV_IPA_LTO_DECL_OUT , "ipa lto decl out") +DEFTIMEVAR (TV_IPA_LTO_DECL_INIT_IO , "ipa lto decl init I/O") +DEFTIMEVAR (TV_IPA_LTO_CGRAPH_IO , "ipa lto cgraph I/O") +DEFTIMEVAR (TV_IPA_LTO_DECL_MERGE , "ipa lto decl merge") +DEFTIMEVAR (TV_IPA_LTO_CGRAPH_MERGE , "ipa lto cgraph merge") +DEFTIMEVAR (TV_LTO , "lto") +DEFTIMEVAR (TV_WHOPR_WPA , "whopr wpa") +DEFTIMEVAR (TV_WHOPR_WPA_IO , "whopr wpa I/O") +DEFTIMEVAR (TV_WHOPR_LTRANS , "whopr ltrans") +DEFTIMEVAR (TV_WHOPR_WPA_LTRANS_EXEC , "whopr wpa->ltrans") +DEFTIMEVAR (TV_IPA_REFERENCE , "ipa reference") +DEFTIMEVAR (TV_IPA_PROFILE , "ipa profile") +DEFTIMEVAR (TV_IPA_PURE_CONST , "ipa pure const") +DEFTIMEVAR (TV_IPA_TYPE_ESCAPE , "ipa type escape") +DEFTIMEVAR (TV_IPA_PTA , "ipa points-to") +DEFTIMEVAR (TV_IPA_SRA , "ipa SRA") +DEFTIMEVAR (TV_IPA_FREE_LANG_DATA , "ipa free lang data") +/* Time spent by constructing CFG. */ +DEFTIMEVAR (TV_CFG , "cfg construction") +/* Time spent by cleaning up CFG. */ +DEFTIMEVAR (TV_CLEANUP_CFG , "cfg cleanup") +DEFTIMEVAR (TV_CFG_VERIFY , "CFG verifier") +DEFTIMEVAR (TV_DELETE_TRIVIALLY_DEAD , "trivially dead code") +/* Time spent by life analysis. */ +DEFTIMEVAR (TV_LIFE , "life analysis") +DEFTIMEVAR (TV_LIFE_UPDATE , "life info update") + +/* Time spent in dataflow problems. */ +DEFTIMEVAR (TV_DF_SCAN , "df scan insns") +DEFTIMEVAR (TV_DF_MD , "df multiple defs") +DEFTIMEVAR (TV_DF_RD , "df reaching defs") +DEFTIMEVAR (TV_DF_LR , "df live regs") +DEFTIMEVAR (TV_DF_LIVE , "df live&initialized regs") +DEFTIMEVAR (TV_DF_UREC , "df uninitialized regs 2") +DEFTIMEVAR (TV_DF_CHAIN , "df use-def / def-use chains") +DEFTIMEVAR (TV_DF_WORD_LR , "df live reg subwords") +DEFTIMEVAR (TV_DF_NOTE , "df reg dead/unused notes") +DEFTIMEVAR (TV_REG_STATS , "register information") + +DEFTIMEVAR (TV_ALIAS_ANALYSIS , "alias analysis") +DEFTIMEVAR (TV_ALIAS_STMT_WALK , "alias stmt walking") +DEFTIMEVAR (TV_REG_SCAN , "register scan") +DEFTIMEVAR (TV_REBUILD_JUMP , "rebuild jump labels") +/* Timing in various stages of the compiler. */ +DEFTIMEVAR (TV_CPP , "preprocessing") +DEFTIMEVAR (TV_LEX , "lexical analysis") +DEFTIMEVAR (TV_PARSE_GLOBAL , "parser (global)") +DEFTIMEVAR (TV_PARSE_STRUCT , "parser struct body") +DEFTIMEVAR (TV_PARSE_ENUM , "parser enumerator list") +DEFTIMEVAR (TV_PARSE_FUNC , "parser function body") +DEFTIMEVAR (TV_PARSE_INLINE , "parser inl. func. body") +DEFTIMEVAR (TV_PARSE_INMETH , "parser inl. meth. body") +DEFTIMEVAR (TV_TEMPLATE_INST , "template instantiation") +DEFTIMEVAR (TV_INLINE_HEURISTICS , "inline heuristics") +DEFTIMEVAR (TV_MVERSN_DISPATCH , "multiversion dispatch") +DEFTIMEVAR (TV_INTEGRATION , "integration") +DEFTIMEVAR (TV_TREE_GIMPLIFY , "tree gimplify") +DEFTIMEVAR (TV_TREE_EH , "tree eh") +DEFTIMEVAR (TV_TREE_CFG , "tree CFG construction") +DEFTIMEVAR (TV_TREE_CLEANUP_CFG , "tree CFG cleanup") +DEFTIMEVAR (TV_TREE_VRP , "tree VRP") +DEFTIMEVAR (TV_TREE_COPY_PROP , "tree copy propagation") +DEFTIMEVAR (TV_FIND_REFERENCED_VARS , "tree find ref. vars") +DEFTIMEVAR (TV_TREE_PTA , "tree PTA") +DEFTIMEVAR (TV_TREE_INSERT_PHI_NODES , "tree PHI insertion") +DEFTIMEVAR (TV_TREE_SSA_REWRITE_BLOCKS, "tree SSA rewrite") +DEFTIMEVAR (TV_TREE_SSA_OTHER , "tree SSA other") +DEFTIMEVAR (TV_TREE_SSA_INCREMENTAL , "tree SSA incremental") +DEFTIMEVAR (TV_TREE_OPS , "tree operand scan") +DEFTIMEVAR (TV_TREE_SSA_DOMINATOR_OPTS , "dominator optimization") +DEFTIMEVAR (TV_TREE_SRA , "tree SRA") +DEFTIMEVAR (TV_TREE_CCP , "tree CCP") +DEFTIMEVAR (TV_TREE_PHI_CPROP , "tree PHI const/copy prop") +DEFTIMEVAR (TV_TREE_SPLIT_EDGES , "tree split crit edges") +DEFTIMEVAR (TV_TREE_REASSOC , "tree reassociation") +DEFTIMEVAR (TV_TREE_PRE , "tree PRE") +DEFTIMEVAR (TV_TREE_FRE , "tree FRE") +DEFTIMEVAR (TV_TREE_SINK , "tree code sinking") +DEFTIMEVAR (TV_TREE_PHIOPT , "tree linearize phis") +DEFTIMEVAR (TV_TREE_FORWPROP , "tree forward propagate") +DEFTIMEVAR (TV_TREE_PHIPROP , "tree phiprop") +DEFTIMEVAR (TV_TREE_DCE , "tree conservative DCE") +DEFTIMEVAR (TV_TREE_CD_DCE , "tree aggressive DCE") +DEFTIMEVAR (TV_TREE_CALL_CDCE , "tree buildin call DCE") +DEFTIMEVAR (TV_TREE_DSE , "tree DSE") +DEFTIMEVAR (TV_TREE_MERGE_PHI , "PHI merge") +DEFTIMEVAR (TV_TREE_LOOP , "tree loop optimization") +DEFTIMEVAR (TV_TREE_LOOP_BOUNDS , "tree loop bounds") +DEFTIMEVAR (TV_LIM , "tree loop invariant motion") +DEFTIMEVAR (TV_TREE_LOOP_IVCANON , "tree canonical iv") +DEFTIMEVAR (TV_SCEV_CONST , "scev constant prop") +DEFTIMEVAR (TV_TREE_LOOP_UNSWITCH , "tree loop unswitching") +DEFTIMEVAR (TV_COMPLETE_UNROLL , "complete unrolling") +DEFTIMEVAR (TV_TREE_PARALLELIZE_LOOPS, "tree parallelize loops") +DEFTIMEVAR (TV_TREE_VECTORIZATION , "tree vectorization") +DEFTIMEVAR (TV_TREE_SLP_VECTORIZATION, "tree slp vectorization") +DEFTIMEVAR (TV_GRAPHITE , "Graphite") +DEFTIMEVAR (TV_GRAPHITE_TRANSFORMS , "Graphite loop transforms") +DEFTIMEVAR (TV_GRAPHITE_DATA_DEPS , "Graphite data dep analysis") +DEFTIMEVAR (TV_GRAPHITE_CODE_GEN , "Graphite code generation") +DEFTIMEVAR (TV_TREE_LINEAR_TRANSFORM , "tree loop linear") +DEFTIMEVAR (TV_TREE_LOOP_DISTRIBUTION, "tree loop distribution") +DEFTIMEVAR (TV_CHECK_DATA_DEPS , "tree check data dependences") +DEFTIMEVAR (TV_TREE_PREFETCH , "tree prefetching") +DEFTIMEVAR (TV_TREE_LOOP_IVOPTS , "tree iv optimization") +DEFTIMEVAR (TV_PREDCOM , "predictive commoning") +DEFTIMEVAR (TV_TREE_LOOP_INIT , "tree loop init") +DEFTIMEVAR (TV_TREE_LOOP_FINI , "tree loop fini") +DEFTIMEVAR (TV_TREE_CH , "tree copy headers") +DEFTIMEVAR (TV_TREE_SSA_UNCPROP , "tree SSA uncprop") +DEFTIMEVAR (TV_TREE_SSA_TO_NORMAL , "tree SSA to normal") +DEFTIMEVAR (TV_TREE_NRV , "tree NRV optimization") +DEFTIMEVAR (TV_TREE_COPY_RENAME , "tree rename SSA copies") +DEFTIMEVAR (TV_TREE_SSA_VERIFY , "tree SSA verifier") +DEFTIMEVAR (TV_TREE_STMT_VERIFY , "tree STMT verifier") +DEFTIMEVAR (TV_TREE_SWITCH_CONVERSION, "tree switch initialization conversion") +DEFTIMEVAR (TV_CGRAPH_VERIFY , "callgraph verifier") +DEFTIMEVAR (TV_DOM_FRONTIERS , "dominance frontiers") +DEFTIMEVAR (TV_DOMINANCE , "dominance computation") +DEFTIMEVAR (TV_CONTROL_DEPENDENCES , "control dependences") +DEFTIMEVAR (TV_OUT_OF_SSA , "out of ssa") +DEFTIMEVAR (TV_VAR_EXPAND , "expand vars") +DEFTIMEVAR (TV_EXPAND , "expand") +DEFTIMEVAR (TV_POST_EXPAND , "post expand cleanups") +DEFTIMEVAR (TV_VARCONST , "varconst") +DEFTIMEVAR (TV_LOWER_SUBREG , "lower subreg") +DEFTIMEVAR (TV_JUMP , "jump") +DEFTIMEVAR (TV_FWPROP , "forward prop") +DEFTIMEVAR (TV_CSE , "CSE") +DEFTIMEVAR (TV_DCE , "dead code elimination") +DEFTIMEVAR (TV_DSE1 , "dead store elim1") +DEFTIMEVAR (TV_DSE2 , "dead store elim2") +DEFTIMEVAR (TV_LOOP , "loop analysis") +DEFTIMEVAR (TV_LOOP_MOVE_INVARIANTS , "loop invariant motion") +DEFTIMEVAR (TV_LOOP_UNSWITCH , "loop unswitching") +DEFTIMEVAR (TV_LOOP_UNROLL , "loop unrolling") +DEFTIMEVAR (TV_LOOP_DOLOOP , "loop doloop") +DEFTIMEVAR (TV_CPROP , "CPROP") +DEFTIMEVAR (TV_PRE , "PRE") +DEFTIMEVAR (TV_HOIST , "code hoisting") +DEFTIMEVAR (TV_LSM , "LSM") +DEFTIMEVAR (TV_TRACER , "tracer") +DEFTIMEVAR (TV_WEB , "web") +DEFTIMEVAR (TV_AUTO_INC_DEC , "auto inc dec") +DEFTIMEVAR (TV_CSE2 , "CSE 2") +DEFTIMEVAR (TV_BRANCH_PROB , "branch prediction") +DEFTIMEVAR (TV_VPT , "value profile opts") +DEFTIMEVAR (TV_COMBINE , "combiner") +DEFTIMEVAR (TV_IFCVT , "if-conversion") +DEFTIMEVAR (TV_REGMOVE , "regmove") +DEFTIMEVAR (TV_MODE_SWITCH , "mode switching") +DEFTIMEVAR (TV_SMS , "sms modulo scheduling") +DEFTIMEVAR (TV_SCHED , "scheduling") +DEFTIMEVAR (TV_LOCAL_ALLOC , "local alloc") +DEFTIMEVAR (TV_GLOBAL_ALLOC , "global alloc") +DEFTIMEVAR (TV_IRA , "integrated RA") +DEFTIMEVAR (TV_RELOAD , "reload") +DEFTIMEVAR (TV_RELOAD_CSE_REGS , "reload CSE regs") +DEFTIMEVAR (TV_SEQABSTR , "sequence abstraction") +DEFTIMEVAR (TV_GCSE_AFTER_RELOAD , "load CSE after reload") +DEFTIMEVAR (TV_ZEE , "zee") +DEFTIMEVAR (TV_THREAD_PROLOGUE_AND_EPILOGUE, "thread pro- & epilogue") +DEFTIMEVAR (TV_IFCVT2 , "if-conversion 2") +DEFTIMEVAR (TV_COMBINE_STACK_ADJUST , "combine stack adjustments") +DEFTIMEVAR (TV_PEEPHOLE2 , "peephole 2") +DEFTIMEVAR (TV_RENAME_REGISTERS , "rename registers") +DEFTIMEVAR (TV_CPROP_REGISTERS , "hard reg cprop") +DEFTIMEVAR (TV_SCHED2 , "scheduling 2") +DEFTIMEVAR (TV_MACH_DEP , "machine dep reorg") +DEFTIMEVAR (TV_DBR_SCHED , "delay branch sched") +DEFTIMEVAR (TV_REORDER_BLOCKS , "reorder blocks") +DEFTIMEVAR (TV_SHORTEN_BRANCH , "shorten branches") +DEFTIMEVAR (TV_REG_STACK , "reg stack") +DEFTIMEVAR (TV_FINAL , "final") +DEFTIMEVAR (TV_VAROUT , "variable output") +DEFTIMEVAR (TV_SYMOUT , "symout") +DEFTIMEVAR (TV_VAR_TRACKING , "variable tracking") +DEFTIMEVAR (TV_VAR_TRACKING_DATAFLOW , "var-tracking dataflow") +DEFTIMEVAR (TV_VAR_TRACKING_EMIT , "var-tracking emit") +DEFTIMEVAR (TV_TREE_IFCOMBINE , "tree if-combine") +DEFTIMEVAR (TV_TREE_UNINIT , "uninit var analysis") +DEFTIMEVAR (TV_TREE_THREADSAFE , "thread safety analysis") +DEFTIMEVAR (TV_PLUGIN_INIT , "plugin initialization") +DEFTIMEVAR (TV_PLUGIN_RUN , "plugin execution") +DEFTIMEVAR (TV_SIMPLIFY_GOT , "simplify got") + +/* Everything else in rest_of_compilation not included above. */ +DEFTIMEVAR (TV_EARLY_LOCAL , "early local passes") +DEFTIMEVAR (TV_OPTIMIZE , "unaccounted optimizations") +DEFTIMEVAR (TV_REST_OF_COMPILATION , "rest of compilation") +DEFTIMEVAR (TV_POSTRELOAD , "unaccounted post reload") +DEFTIMEVAR (TV_REMOVE_UNUSED , "remove unused locals") +DEFTIMEVAR (TV_ADDRESS_TAKEN , "address taken") +DEFTIMEVAR (TV_TODO , "unaccounted todo") +DEFTIMEVAR (TV_VERIFY_LOOP_CLOSED , "verify loop closed") +DEFTIMEVAR (TV_VERIFY_RTL_SHARING , "verify RTL sharing") +DEFTIMEVAR (TV_REBUILD_FREQUENCIES , "rebuild frequencies") +DEFTIMEVAR (TV_REPAIR_LOOPS , "repair loop structures") diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/timevar.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/timevar.h new file mode 100644 index 0000000..dad9dfd --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/timevar.h @@ -0,0 +1,116 @@ +/* Timing variables for measuring compiler performance. + Copyright (C) 2000, 2003, 2004, 2005, 2007, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Alex Samuel <samuel@codesourcery.com> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + GCC is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + 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/>. */ + +#ifndef GCC_TIMEVAR_H +#define GCC_TIMEVAR_H + +/* Timing variables are used to measure elapsed time in various + portions of the compiler. Each measures elapsed user, system, and + wall-clock time, as appropriate to and supported by the host + system. + + Timing variables are defined using the DEFTIMEVAR macro in + timevar.def. Each has an enumeral identifier, used when referring + to the timing variable in code, and a character string name. + + Timing variables can be used in two ways: + + - On the timing stack, using timevar_push and timevar_pop. + Timing variables may be pushed onto the stack; elapsed time is + attributed to the topmost timing variable on the stack. When + another variable is pushed on, the previous topmost variable is + `paused' until the pushed variable is popped back off. + + - As a standalone timer, using timevar_start and timevar_stop. + All time elapsed between the two calls is attributed to the + variable. +*/ + +/* This structure stores the various varieties of time that can be + measured. Times are stored in seconds. The time may be an + absolute time or a time difference; in the former case, the time + base is undefined, except that the difference between two times + produces a valid time difference. */ + +struct timevar_time_def +{ + /* User time in this process. */ + double user; + + /* System time (if applicable for this host platform) in this + process. */ + double sys; + + /* Wall clock time. */ + double wall; + + /* Garbage collector memory. */ + unsigned ggc_mem; +}; + +/* An enumeration of timing variable identifiers. Constructed from + the contents of timevar.def. */ + +#define DEFTIMEVAR(identifier__, name__) \ + identifier__, +typedef enum +{ + TV_NONE, +#include "timevar.def" + TIMEVAR_LAST +} +timevar_id_t; +#undef DEFTIMEVAR + +/* True if timevars should be used. In GCC, this happens with + the -ftime-report flag. */ +extern bool timevar_enable; + +/* Total amount of memory allocated by garbage collector. */ +extern size_t timevar_ggc_mem_total; + +extern void timevar_init (void); +extern void timevar_push_1 (timevar_id_t); +extern void timevar_pop_1 (timevar_id_t); +extern void timevar_start (timevar_id_t); +extern void timevar_stop (timevar_id_t); +extern bool timevar_cond_start (timevar_id_t); +extern void timevar_cond_stop (timevar_id_t, bool); +extern void timevar_print (FILE *); + +/* Provided for backward compatibility. */ +static inline void +timevar_push (timevar_id_t tv) +{ + if (timevar_enable) + timevar_push_1 (tv); +} + +static inline void +timevar_pop (timevar_id_t tv) +{ + if (timevar_enable) + timevar_pop_1 (tv); +} + +extern void print_time (const char *, long); + +#endif /* ! GCC_TIMEVAR_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm-preds.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm-preds.h new file mode 100644 index 0000000..05b9ca7 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm-preds.h @@ -0,0 +1,193 @@ +/* Generated automatically by the program 'build/genpreds' + from the machine description file '/Volumes/androidtc/androidtoolchain/./src/build/../gcc/gcc-4.6/gcc/config/arm/arm.md'. */ + +#ifndef GCC_TM_PREDS_H +#define GCC_TM_PREDS_H + +#ifdef HAVE_MACHINE_MODES +extern int general_operand (rtx, enum machine_mode); +extern int address_operand (rtx, enum machine_mode); +extern int register_operand (rtx, enum machine_mode); +extern int pmode_register_operand (rtx, enum machine_mode); +extern int scratch_operand (rtx, enum machine_mode); +extern int immediate_operand (rtx, enum machine_mode); +extern int const_int_operand (rtx, enum machine_mode); +extern int const_double_operand (rtx, enum machine_mode); +extern int nonimmediate_operand (rtx, enum machine_mode); +extern int nonmemory_operand (rtx, enum machine_mode); +extern int push_operand (rtx, enum machine_mode); +extern int pop_operand (rtx, enum machine_mode); +extern int memory_operand (rtx, enum machine_mode); +extern int indirect_operand (rtx, enum machine_mode); +extern int ordered_comparison_operator (rtx, enum machine_mode); +extern int comparison_operator (rtx, enum machine_mode); +extern int s_register_operand (rtx, enum machine_mode); +extern int arm_hard_register_operand (rtx, enum machine_mode); +extern int low_register_operand (rtx, enum machine_mode); +extern int low_reg_or_int_operand (rtx, enum machine_mode); +extern int arm_general_register_operand (rtx, enum machine_mode); +extern int f_register_operand (rtx, enum machine_mode); +extern int vfp_register_operand (rtx, enum machine_mode); +extern int subreg_lowpart_operator (rtx, enum machine_mode); +extern int reg_or_int_operand (rtx, enum machine_mode); +extern int arm_immediate_operand (rtx, enum machine_mode); +extern int arm_immediate_di_operand (rtx, enum machine_mode); +extern int arm_neg_immediate_operand (rtx, enum machine_mode); +extern int arm_not_immediate_operand (rtx, enum machine_mode); +extern int const0_operand (rtx, enum machine_mode); +extern int arm_rhs_operand (rtx, enum machine_mode); +extern int arm_rhsm_operand (rtx, enum machine_mode); +extern int shift_amount_operand (rtx, enum machine_mode); +extern int arm_add_operand (rtx, enum machine_mode); +extern int arm_addimm_operand (rtx, enum machine_mode); +extern int arm_not_operand (rtx, enum machine_mode); +extern int arm_di_operand (rtx, enum machine_mode); +extern int offsettable_memory_operand (rtx, enum machine_mode); +extern int call_memory_operand (rtx, enum machine_mode); +extern int arm_reload_memory_operand (rtx, enum machine_mode); +extern int arm_float_rhs_operand (rtx, enum machine_mode); +extern int arm_float_add_operand (rtx, enum machine_mode); +extern int vfp_compare_operand (rtx, enum machine_mode); +extern int arm_float_compare_operand (rtx, enum machine_mode); +extern int index_operand (rtx, enum machine_mode); +extern int shiftable_operator (rtx, enum machine_mode); +extern int logical_binary_operator (rtx, enum machine_mode); +extern int commutative_binary_operator (rtx, enum machine_mode); +extern int shift_operator (rtx, enum machine_mode); +extern int mult_operator (rtx, enum machine_mode); +extern int thumb_16bit_operator (rtx, enum machine_mode); +extern int equality_operator (rtx, enum machine_mode); +extern int arm_comparison_operator (rtx, enum machine_mode); +extern int lt_ge_comparison_operator (rtx, enum machine_mode); +extern int noov_comparison_operator (rtx, enum machine_mode); +extern int minmax_operator (rtx, enum machine_mode); +extern int cc_register (rtx, enum machine_mode); +extern int dominant_cc_register (rtx, enum machine_mode); +extern int arm_extendqisi_mem_op (rtx, enum machine_mode); +extern int arm_reg_or_extendqisi_mem_op (rtx, enum machine_mode); +extern int power_of_two_operand (rtx, enum machine_mode); +extern int nonimmediate_di_operand (rtx, enum machine_mode); +extern int di_operand (rtx, enum machine_mode); +extern int nonimmediate_soft_df_operand (rtx, enum machine_mode); +extern int soft_df_operand (rtx, enum machine_mode); +extern int const_shift_operand (rtx, enum machine_mode); +extern int load_multiple_operation (rtx, enum machine_mode); +extern int store_multiple_operation (rtx, enum machine_mode); +extern int multi_register_push (rtx, enum machine_mode); +extern int thumb1_cmp_operand (rtx, enum machine_mode); +extern int thumb1_cmpneg_operand (rtx, enum machine_mode); +extern int thumb_cbrch_target_operand (rtx, enum machine_mode); +extern int cirrus_register_operand (rtx, enum machine_mode); +extern int cirrus_fp_register (rtx, enum machine_mode); +extern int cirrus_shift_const (rtx, enum machine_mode); +extern int const_multiple_of_8_operand (rtx, enum machine_mode); +extern int imm_for_neon_mov_operand (rtx, enum machine_mode); +extern int imm_for_neon_logic_operand (rtx, enum machine_mode); +extern int imm_for_neon_inv_logic_operand (rtx, enum machine_mode); +extern int neon_logic_op2 (rtx, enum machine_mode); +extern int neon_inv_logic_op2 (rtx, enum machine_mode); +extern int neon_lane_number (rtx, enum machine_mode); +extern int cmpdi_operand (rtx, enum machine_mode); +extern int arm_sync_memory_operand (rtx, enum machine_mode); +extern int vect_par_constant_high (rtx, enum machine_mode); +extern int vect_par_constant_low (rtx, enum machine_mode); +extern int add_operator (rtx, enum machine_mode); +#endif /* HAVE_MACHINE_MODES */ + +#define CONSTRAINT_NUM_DEFINED_P 1 +enum constraint_num +{ + CONSTRAINT__UNKNOWN = 0, + CONSTRAINT_f, + CONSTRAINT_t, + CONSTRAINT_v, + CONSTRAINT_w, + CONSTRAINT_x, + CONSTRAINT_y, + CONSTRAINT_z, + CONSTRAINT_l, + CONSTRAINT_h, + CONSTRAINT_j, + CONSTRAINT_k, + CONSTRAINT_b, + CONSTRAINT_c, + CONSTRAINT_I, + CONSTRAINT_J, + CONSTRAINT_K, + CONSTRAINT_L, + CONSTRAINT_M, + CONSTRAINT_N, + CONSTRAINT_O, + CONSTRAINT_Pa, + CONSTRAINT_Pb, + CONSTRAINT_Pc, + CONSTRAINT_Pd, + CONSTRAINT_Ps, + CONSTRAINT_Pt, + CONSTRAINT_Pu, + CONSTRAINT_Pv, + CONSTRAINT_Pw, + CONSTRAINT_Px, + CONSTRAINT_G, + CONSTRAINT_H, + CONSTRAINT_Dz, + CONSTRAINT_Da, + CONSTRAINT_Db, + CONSTRAINT_Dc, + CONSTRAINT_Di, + CONSTRAINT_Dn, + CONSTRAINT_Dl, + CONSTRAINT_DL, + CONSTRAINT_Dv, + CONSTRAINT_Dy, + CONSTRAINT_Ut, + CONSTRAINT_Uv, + CONSTRAINT_Uy, + CONSTRAINT_Un, + CONSTRAINT_Um, + CONSTRAINT_Us, + CONSTRAINT_Uq, + CONSTRAINT_Q, + CONSTRAINT__LIMIT +}; + +extern enum constraint_num lookup_constraint (const char *); +extern bool constraint_satisfied_p (rtx, enum constraint_num); + +static inline size_t +insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED) +{ + switch (fc) + { + case 'D': return 2; + case 'P': return 2; + case 'U': return 2; + default: break; + } + return 1; +} + +#define CONSTRAINT_LEN(c_,s_) insn_constraint_len (c_,s_) + +extern enum reg_class regclass_for_constraint (enum constraint_num); +#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \ + regclass_for_constraint (lookup_constraint (s_)) +#define REG_CLASS_FOR_CONSTRAINT(x_) \ + regclass_for_constraint (x_) + +extern bool insn_const_int_ok_for_constraint (HOST_WIDE_INT, enum constraint_num); +#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \ + insn_const_int_ok_for_constraint (v_, lookup_constraint (s_)) + +#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \ + constraint_satisfied_p (v_, lookup_constraint (s_)) + +#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \ + constraint_satisfied_p (v_, lookup_constraint (s_)) + +extern bool insn_extra_memory_constraint (enum constraint_num); +#define EXTRA_MEMORY_CONSTRAINT(c_,s_) insn_extra_memory_constraint (lookup_constraint (s_)) + +#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false + +#endif /* tm-preds.h */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm.h new file mode 100644 index 0000000..5607431 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm.h @@ -0,0 +1,31 @@ +#ifndef GCC_TM_H +#define GCC_TM_H +#define TARGET_CPU_DEFAULT (TARGET_CPU_generic) +#ifndef LIBC_GLIBC +# define LIBC_GLIBC 1 +#endif +#ifndef LIBC_UCLIBC +# define LIBC_UCLIBC 2 +#endif +#ifndef LIBC_BIONIC +# define LIBC_BIONIC 3 +#endif +#ifdef IN_GCC +# include "options.h" +# include "insn-constants.h" +# include "config/dbxelf.h" +# include "config/elfos.h" +# include "config/arm/unknown-elf.h" +# include "config/arm/elf.h" +# include "config/arm/bpabi.h" +# include "config/../../libgcc/config/arm/bpabi-lib.h" +# include "config/newlib-stdint.h" +# include "config/arm/aout.h" +# include "config/arm/arm.h" +# include "config/initfini-array.h" +#endif +#if defined IN_GCC && !defined GENERATOR_FILE && !defined USED_FOR_TARGET +# include "insn-flags.h" +#endif +# include "defaults.h" +#endif /* GCC_TM_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm_p.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm_p.h new file mode 100644 index 0000000..be57f16 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tm_p.h @@ -0,0 +1,7 @@ +#ifndef GCC_TM_P_H +#define GCC_TM_P_H +#ifdef IN_GCC +# include "config/arm/arm-protos.h" +# include "tm-preds.h" +#endif +#endif /* GCC_TM_P_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/toplev.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/toplev.h new file mode 100644 index 0000000..2455dc0 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/toplev.h @@ -0,0 +1,83 @@ +/* toplev.h - Various declarations for functions found in toplev.c + Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, + 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_TOPLEV_H +#define GCC_TOPLEV_H + +/* Decoded options, and number of such options. */ +extern struct cl_decoded_option *save_decoded_options; +extern unsigned int save_decoded_options_count; + +extern int toplev_main (int, char **); +extern void rest_of_decl_compilation (tree, int, int); +extern void rest_of_type_compilation (tree, int); +extern void tree_rest_of_compilation (tree); +extern void init_optimization_passes (void); +extern void finish_optimization_passes (void); +extern bool enable_rtl_dump_file (void); + +/* In except.c. Initialize exception handling. This is used by the Ada + and LTO front ends to initialize EH "on demand". See lto-streamer-in.c + and ada/gcc-interface/misc.c. */ +extern void init_eh (void); + +extern void announce_function (tree); + +extern void wrapup_global_declaration_1 (tree); +extern bool wrapup_global_declaration_2 (tree); +extern bool wrapup_global_declarations (tree *, int); +extern void check_global_declaration_1 (tree); +extern void check_global_declarations (tree *, int); +extern void emit_debug_global_declarations (tree *, int); +extern void write_global_declarations (void); + +extern void dump_memory_report (bool); + +extern void target_reinit (void); + +/* A unique local time stamp, might be zero if none is available. */ +extern unsigned local_tick; + +/* True if the user has tagged the function with the 'section' + attribute. */ + +extern bool user_defined_section_attribute; + +/* See toplev.c. */ +extern int flag_rerun_cse_after_global_opts; + +extern void print_version (FILE *, const char *); + +/* The hashtable, so that the C front ends can pass it to cpplib. */ +extern struct ht *ident_hash; + +/* Functions used to get and set GCC's notion of in what directory + compilation was started. */ + +extern const char *get_src_pwd (void); +extern bool set_src_pwd (const char *); + +/* Functions used to manipulate the random seed. */ + +extern const char *get_random_seed (bool); +extern const char *set_random_seed (const char *); + +#endif /* ! GCC_TOPLEV_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-check.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-check.h new file mode 100644 index 0000000..95a7a9b --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-check.h @@ -0,0 +1,296 @@ +/* This file is generated using gencheck. Do not edit. */ + +#ifndef GCC_TREE_CHECK_H +#define GCC_TREE_CHECK_H + +#define ERROR_MARK_CHECK(t) TREE_CHECK (t, ERROR_MARK) +#define IDENTIFIER_NODE_CHECK(t) TREE_CHECK (t, IDENTIFIER_NODE) +#define TREE_LIST_CHECK(t) TREE_CHECK (t, TREE_LIST) +#define TREE_VEC_CHECK(t) TREE_CHECK (t, TREE_VEC) +#define BLOCK_CHECK(t) TREE_CHECK (t, BLOCK) +#define OFFSET_TYPE_CHECK(t) TREE_CHECK (t, OFFSET_TYPE) +#define ENUMERAL_TYPE_CHECK(t) TREE_CHECK (t, ENUMERAL_TYPE) +#define BOOLEAN_TYPE_CHECK(t) TREE_CHECK (t, BOOLEAN_TYPE) +#define INTEGER_TYPE_CHECK(t) TREE_CHECK (t, INTEGER_TYPE) +#define REAL_TYPE_CHECK(t) TREE_CHECK (t, REAL_TYPE) +#define POINTER_TYPE_CHECK(t) TREE_CHECK (t, POINTER_TYPE) +#define REFERENCE_TYPE_CHECK(t) TREE_CHECK (t, REFERENCE_TYPE) +#define NULLPTR_TYPE_CHECK(t) TREE_CHECK (t, NULLPTR_TYPE) +#define FIXED_POINT_TYPE_CHECK(t) TREE_CHECK (t, FIXED_POINT_TYPE) +#define COMPLEX_TYPE_CHECK(t) TREE_CHECK (t, COMPLEX_TYPE) +#define VECTOR_TYPE_CHECK(t) TREE_CHECK (t, VECTOR_TYPE) +#define ARRAY_TYPE_CHECK(t) TREE_CHECK (t, ARRAY_TYPE) +#define RECORD_TYPE_CHECK(t) TREE_CHECK (t, RECORD_TYPE) +#define UNION_TYPE_CHECK(t) TREE_CHECK (t, UNION_TYPE) +#define QUAL_UNION_TYPE_CHECK(t) TREE_CHECK (t, QUAL_UNION_TYPE) +#define VOID_TYPE_CHECK(t) TREE_CHECK (t, VOID_TYPE) +#define FUNCTION_TYPE_CHECK(t) TREE_CHECK (t, FUNCTION_TYPE) +#define METHOD_TYPE_CHECK(t) TREE_CHECK (t, METHOD_TYPE) +#define LANG_TYPE_CHECK(t) TREE_CHECK (t, LANG_TYPE) +#define INTEGER_CST_CHECK(t) TREE_CHECK (t, INTEGER_CST) +#define REAL_CST_CHECK(t) TREE_CHECK (t, REAL_CST) +#define FIXED_CST_CHECK(t) TREE_CHECK (t, FIXED_CST) +#define COMPLEX_CST_CHECK(t) TREE_CHECK (t, COMPLEX_CST) +#define VECTOR_CST_CHECK(t) TREE_CHECK (t, VECTOR_CST) +#define STRING_CST_CHECK(t) TREE_CHECK (t, STRING_CST) +#define FUNCTION_DECL_CHECK(t) TREE_CHECK (t, FUNCTION_DECL) +#define LABEL_DECL_CHECK(t) TREE_CHECK (t, LABEL_DECL) +#define FIELD_DECL_CHECK(t) TREE_CHECK (t, FIELD_DECL) +#define VAR_DECL_CHECK(t) TREE_CHECK (t, VAR_DECL) +#define CONST_DECL_CHECK(t) TREE_CHECK (t, CONST_DECL) +#define PARM_DECL_CHECK(t) TREE_CHECK (t, PARM_DECL) +#define TYPE_DECL_CHECK(t) TREE_CHECK (t, TYPE_DECL) +#define RESULT_DECL_CHECK(t) TREE_CHECK (t, RESULT_DECL) +#define DEBUG_EXPR_DECL_CHECK(t) TREE_CHECK (t, DEBUG_EXPR_DECL) +#define NAMESPACE_DECL_CHECK(t) TREE_CHECK (t, NAMESPACE_DECL) +#define IMPORTED_DECL_CHECK(t) TREE_CHECK (t, IMPORTED_DECL) +#define TRANSLATION_UNIT_DECL_CHECK(t) TREE_CHECK (t, TRANSLATION_UNIT_DECL) +#define COMPONENT_REF_CHECK(t) TREE_CHECK (t, COMPONENT_REF) +#define BIT_FIELD_REF_CHECK(t) TREE_CHECK (t, BIT_FIELD_REF) +#define REALPART_EXPR_CHECK(t) TREE_CHECK (t, REALPART_EXPR) +#define IMAGPART_EXPR_CHECK(t) TREE_CHECK (t, IMAGPART_EXPR) +#define ARRAY_REF_CHECK(t) TREE_CHECK (t, ARRAY_REF) +#define ARRAY_RANGE_REF_CHECK(t) TREE_CHECK (t, ARRAY_RANGE_REF) +#define INDIRECT_REF_CHECK(t) TREE_CHECK (t, INDIRECT_REF) +#define OBJ_TYPE_REF_CHECK(t) TREE_CHECK (t, OBJ_TYPE_REF) +#define CONSTRUCTOR_CHECK(t) TREE_CHECK (t, CONSTRUCTOR) +#define COMPOUND_EXPR_CHECK(t) TREE_CHECK (t, COMPOUND_EXPR) +#define MODIFY_EXPR_CHECK(t) TREE_CHECK (t, MODIFY_EXPR) +#define INIT_EXPR_CHECK(t) TREE_CHECK (t, INIT_EXPR) +#define TARGET_EXPR_CHECK(t) TREE_CHECK (t, TARGET_EXPR) +#define COND_EXPR_CHECK(t) TREE_CHECK (t, COND_EXPR) +#define VEC_COND_EXPR_CHECK(t) TREE_CHECK (t, VEC_COND_EXPR) +#define BIND_EXPR_CHECK(t) TREE_CHECK (t, BIND_EXPR) +#define CALL_EXPR_CHECK(t) TREE_CHECK (t, CALL_EXPR) +#define WITH_CLEANUP_EXPR_CHECK(t) TREE_CHECK (t, WITH_CLEANUP_EXPR) +#define CLEANUP_POINT_EXPR_CHECK(t) TREE_CHECK (t, CLEANUP_POINT_EXPR) +#define PLACEHOLDER_EXPR_CHECK(t) TREE_CHECK (t, PLACEHOLDER_EXPR) +#define PLUS_EXPR_CHECK(t) TREE_CHECK (t, PLUS_EXPR) +#define MINUS_EXPR_CHECK(t) TREE_CHECK (t, MINUS_EXPR) +#define MULT_EXPR_CHECK(t) TREE_CHECK (t, MULT_EXPR) +#define POINTER_PLUS_EXPR_CHECK(t) TREE_CHECK (t, POINTER_PLUS_EXPR) +#define TRUNC_DIV_EXPR_CHECK(t) TREE_CHECK (t, TRUNC_DIV_EXPR) +#define CEIL_DIV_EXPR_CHECK(t) TREE_CHECK (t, CEIL_DIV_EXPR) +#define FLOOR_DIV_EXPR_CHECK(t) TREE_CHECK (t, FLOOR_DIV_EXPR) +#define ROUND_DIV_EXPR_CHECK(t) TREE_CHECK (t, ROUND_DIV_EXPR) +#define TRUNC_MOD_EXPR_CHECK(t) TREE_CHECK (t, TRUNC_MOD_EXPR) +#define CEIL_MOD_EXPR_CHECK(t) TREE_CHECK (t, CEIL_MOD_EXPR) +#define FLOOR_MOD_EXPR_CHECK(t) TREE_CHECK (t, FLOOR_MOD_EXPR) +#define ROUND_MOD_EXPR_CHECK(t) TREE_CHECK (t, ROUND_MOD_EXPR) +#define RDIV_EXPR_CHECK(t) TREE_CHECK (t, RDIV_EXPR) +#define EXACT_DIV_EXPR_CHECK(t) TREE_CHECK (t, EXACT_DIV_EXPR) +#define FIX_TRUNC_EXPR_CHECK(t) TREE_CHECK (t, FIX_TRUNC_EXPR) +#define FLOAT_EXPR_CHECK(t) TREE_CHECK (t, FLOAT_EXPR) +#define NEGATE_EXPR_CHECK(t) TREE_CHECK (t, NEGATE_EXPR) +#define MIN_EXPR_CHECK(t) TREE_CHECK (t, MIN_EXPR) +#define MAX_EXPR_CHECK(t) TREE_CHECK (t, MAX_EXPR) +#define ABS_EXPR_CHECK(t) TREE_CHECK (t, ABS_EXPR) +#define LSHIFT_EXPR_CHECK(t) TREE_CHECK (t, LSHIFT_EXPR) +#define RSHIFT_EXPR_CHECK(t) TREE_CHECK (t, RSHIFT_EXPR) +#define LROTATE_EXPR_CHECK(t) TREE_CHECK (t, LROTATE_EXPR) +#define RROTATE_EXPR_CHECK(t) TREE_CHECK (t, RROTATE_EXPR) +#define BIT_IOR_EXPR_CHECK(t) TREE_CHECK (t, BIT_IOR_EXPR) +#define BIT_XOR_EXPR_CHECK(t) TREE_CHECK (t, BIT_XOR_EXPR) +#define BIT_AND_EXPR_CHECK(t) TREE_CHECK (t, BIT_AND_EXPR) +#define BIT_NOT_EXPR_CHECK(t) TREE_CHECK (t, BIT_NOT_EXPR) +#define TRUTH_ANDIF_EXPR_CHECK(t) TREE_CHECK (t, TRUTH_ANDIF_EXPR) +#define TRUTH_ORIF_EXPR_CHECK(t) TREE_CHECK (t, TRUTH_ORIF_EXPR) +#define TRUTH_AND_EXPR_CHECK(t) TREE_CHECK (t, TRUTH_AND_EXPR) +#define TRUTH_OR_EXPR_CHECK(t) TREE_CHECK (t, TRUTH_OR_EXPR) +#define TRUTH_XOR_EXPR_CHECK(t) TREE_CHECK (t, TRUTH_XOR_EXPR) +#define TRUTH_NOT_EXPR_CHECK(t) TREE_CHECK (t, TRUTH_NOT_EXPR) +#define LT_EXPR_CHECK(t) TREE_CHECK (t, LT_EXPR) +#define LE_EXPR_CHECK(t) TREE_CHECK (t, LE_EXPR) +#define GT_EXPR_CHECK(t) TREE_CHECK (t, GT_EXPR) +#define GE_EXPR_CHECK(t) TREE_CHECK (t, GE_EXPR) +#define EQ_EXPR_CHECK(t) TREE_CHECK (t, EQ_EXPR) +#define NE_EXPR_CHECK(t) TREE_CHECK (t, NE_EXPR) +#define UNORDERED_EXPR_CHECK(t) TREE_CHECK (t, UNORDERED_EXPR) +#define ORDERED_EXPR_CHECK(t) TREE_CHECK (t, ORDERED_EXPR) +#define UNLT_EXPR_CHECK(t) TREE_CHECK (t, UNLT_EXPR) +#define UNLE_EXPR_CHECK(t) TREE_CHECK (t, UNLE_EXPR) +#define UNGT_EXPR_CHECK(t) TREE_CHECK (t, UNGT_EXPR) +#define UNGE_EXPR_CHECK(t) TREE_CHECK (t, UNGE_EXPR) +#define UNEQ_EXPR_CHECK(t) TREE_CHECK (t, UNEQ_EXPR) +#define LTGT_EXPR_CHECK(t) TREE_CHECK (t, LTGT_EXPR) +#define RANGE_EXPR_CHECK(t) TREE_CHECK (t, RANGE_EXPR) +#define PAREN_EXPR_CHECK(t) TREE_CHECK (t, PAREN_EXPR) +#define CONVERT_EXPR_CHECK(t) TREE_CHECK (t, CONVERT_EXPR) +#define ADDR_SPACE_CONVERT_EXPR_CHECK(t) TREE_CHECK (t, ADDR_SPACE_CONVERT_EXPR) +#define FIXED_CONVERT_EXPR_CHECK(t) TREE_CHECK (t, FIXED_CONVERT_EXPR) +#define NOP_EXPR_CHECK(t) TREE_CHECK (t, NOP_EXPR) +#define NON_LVALUE_EXPR_CHECK(t) TREE_CHECK (t, NON_LVALUE_EXPR) +#define VIEW_CONVERT_EXPR_CHECK(t) TREE_CHECK (t, VIEW_CONVERT_EXPR) +#define COMPOUND_LITERAL_EXPR_CHECK(t) TREE_CHECK (t, COMPOUND_LITERAL_EXPR) +#define SAVE_EXPR_CHECK(t) TREE_CHECK (t, SAVE_EXPR) +#define ADDR_EXPR_CHECK(t) TREE_CHECK (t, ADDR_EXPR) +#define FDESC_EXPR_CHECK(t) TREE_CHECK (t, FDESC_EXPR) +#define COMPLEX_EXPR_CHECK(t) TREE_CHECK (t, COMPLEX_EXPR) +#define CONJ_EXPR_CHECK(t) TREE_CHECK (t, CONJ_EXPR) +#define PREDECREMENT_EXPR_CHECK(t) TREE_CHECK (t, PREDECREMENT_EXPR) +#define PREINCREMENT_EXPR_CHECK(t) TREE_CHECK (t, PREINCREMENT_EXPR) +#define POSTDECREMENT_EXPR_CHECK(t) TREE_CHECK (t, POSTDECREMENT_EXPR) +#define POSTINCREMENT_EXPR_CHECK(t) TREE_CHECK (t, POSTINCREMENT_EXPR) +#define VA_ARG_EXPR_CHECK(t) TREE_CHECK (t, VA_ARG_EXPR) +#define TRY_CATCH_EXPR_CHECK(t) TREE_CHECK (t, TRY_CATCH_EXPR) +#define TRY_FINALLY_EXPR_CHECK(t) TREE_CHECK (t, TRY_FINALLY_EXPR) +#define DECL_EXPR_CHECK(t) TREE_CHECK (t, DECL_EXPR) +#define LABEL_EXPR_CHECK(t) TREE_CHECK (t, LABEL_EXPR) +#define GOTO_EXPR_CHECK(t) TREE_CHECK (t, GOTO_EXPR) +#define RETURN_EXPR_CHECK(t) TREE_CHECK (t, RETURN_EXPR) +#define EXIT_EXPR_CHECK(t) TREE_CHECK (t, EXIT_EXPR) +#define LOOP_EXPR_CHECK(t) TREE_CHECK (t, LOOP_EXPR) +#define SWITCH_EXPR_CHECK(t) TREE_CHECK (t, SWITCH_EXPR) +#define CASE_LABEL_EXPR_CHECK(t) TREE_CHECK (t, CASE_LABEL_EXPR) +#define ASM_EXPR_CHECK(t) TREE_CHECK (t, ASM_EXPR) +#define SSA_NAME_CHECK(t) TREE_CHECK (t, SSA_NAME) +#define CATCH_EXPR_CHECK(t) TREE_CHECK (t, CATCH_EXPR) +#define EH_FILTER_EXPR_CHECK(t) TREE_CHECK (t, EH_FILTER_EXPR) +#define SCEV_KNOWN_CHECK(t) TREE_CHECK (t, SCEV_KNOWN) +#define SCEV_NOT_KNOWN_CHECK(t) TREE_CHECK (t, SCEV_NOT_KNOWN) +#define POLYNOMIAL_CHREC_CHECK(t) TREE_CHECK (t, POLYNOMIAL_CHREC) +#define STATEMENT_LIST_CHECK(t) TREE_CHECK (t, STATEMENT_LIST) +#define ASSERT_EXPR_CHECK(t) TREE_CHECK (t, ASSERT_EXPR) +#define TREE_BINFO_CHECK(t) TREE_CHECK (t, TREE_BINFO) +#define WITH_SIZE_EXPR_CHECK(t) TREE_CHECK (t, WITH_SIZE_EXPR) +#define REALIGN_LOAD_EXPR_CHECK(t) TREE_CHECK (t, REALIGN_LOAD_EXPR) +#define TARGET_MEM_REF_CHECK(t) TREE_CHECK (t, TARGET_MEM_REF) +#define MEM_REF_CHECK(t) TREE_CHECK (t, MEM_REF) +#define OMP_PARALLEL_CHECK(t) TREE_CHECK (t, OMP_PARALLEL) +#define OMP_TASK_CHECK(t) TREE_CHECK (t, OMP_TASK) +#define OMP_FOR_CHECK(t) TREE_CHECK (t, OMP_FOR) +#define OMP_SECTIONS_CHECK(t) TREE_CHECK (t, OMP_SECTIONS) +#define OMP_SINGLE_CHECK(t) TREE_CHECK (t, OMP_SINGLE) +#define OMP_SECTION_CHECK(t) TREE_CHECK (t, OMP_SECTION) +#define OMP_MASTER_CHECK(t) TREE_CHECK (t, OMP_MASTER) +#define OMP_ORDERED_CHECK(t) TREE_CHECK (t, OMP_ORDERED) +#define OMP_CRITICAL_CHECK(t) TREE_CHECK (t, OMP_CRITICAL) +#define OMP_ATOMIC_CHECK(t) TREE_CHECK (t, OMP_ATOMIC) +#define OMP_CLAUSE_CHECK(t) TREE_CHECK (t, OMP_CLAUSE) +#define REDUC_MAX_EXPR_CHECK(t) TREE_CHECK (t, REDUC_MAX_EXPR) +#define REDUC_MIN_EXPR_CHECK(t) TREE_CHECK (t, REDUC_MIN_EXPR) +#define REDUC_PLUS_EXPR_CHECK(t) TREE_CHECK (t, REDUC_PLUS_EXPR) +#define DOT_PROD_EXPR_CHECK(t) TREE_CHECK (t, DOT_PROD_EXPR) +#define WIDEN_SUM_EXPR_CHECK(t) TREE_CHECK (t, WIDEN_SUM_EXPR) +#define WIDEN_MULT_EXPR_CHECK(t) TREE_CHECK (t, WIDEN_MULT_EXPR) +#define WIDEN_MULT_PLUS_EXPR_CHECK(t) TREE_CHECK (t, WIDEN_MULT_PLUS_EXPR) +#define WIDEN_MULT_MINUS_EXPR_CHECK(t) TREE_CHECK (t, WIDEN_MULT_MINUS_EXPR) +#define FMA_EXPR_CHECK(t) TREE_CHECK (t, FMA_EXPR) +#define VEC_LSHIFT_EXPR_CHECK(t) TREE_CHECK (t, VEC_LSHIFT_EXPR) +#define VEC_RSHIFT_EXPR_CHECK(t) TREE_CHECK (t, VEC_RSHIFT_EXPR) +#define VEC_WIDEN_MULT_HI_EXPR_CHECK(t) TREE_CHECK (t, VEC_WIDEN_MULT_HI_EXPR) +#define VEC_WIDEN_MULT_LO_EXPR_CHECK(t) TREE_CHECK (t, VEC_WIDEN_MULT_LO_EXPR) +#define VEC_UNPACK_HI_EXPR_CHECK(t) TREE_CHECK (t, VEC_UNPACK_HI_EXPR) +#define VEC_UNPACK_LO_EXPR_CHECK(t) TREE_CHECK (t, VEC_UNPACK_LO_EXPR) +#define VEC_UNPACK_FLOAT_HI_EXPR_CHECK(t) TREE_CHECK (t, VEC_UNPACK_FLOAT_HI_EXPR) +#define VEC_UNPACK_FLOAT_LO_EXPR_CHECK(t) TREE_CHECK (t, VEC_UNPACK_FLOAT_LO_EXPR) +#define VEC_PACK_TRUNC_EXPR_CHECK(t) TREE_CHECK (t, VEC_PACK_TRUNC_EXPR) +#define VEC_PACK_SAT_EXPR_CHECK(t) TREE_CHECK (t, VEC_PACK_SAT_EXPR) +#define VEC_PACK_FIX_TRUNC_EXPR_CHECK(t) TREE_CHECK (t, VEC_PACK_FIX_TRUNC_EXPR) +#define VEC_EXTRACT_EVEN_EXPR_CHECK(t) TREE_CHECK (t, VEC_EXTRACT_EVEN_EXPR) +#define VEC_EXTRACT_ODD_EXPR_CHECK(t) TREE_CHECK (t, VEC_EXTRACT_ODD_EXPR) +#define VEC_INTERLEAVE_HIGH_EXPR_CHECK(t) TREE_CHECK (t, VEC_INTERLEAVE_HIGH_EXPR) +#define VEC_INTERLEAVE_LOW_EXPR_CHECK(t) TREE_CHECK (t, VEC_INTERLEAVE_LOW_EXPR) +#define PREDICT_EXPR_CHECK(t) TREE_CHECK (t, PREDICT_EXPR) +#define OPTIMIZATION_NODE_CHECK(t) TREE_CHECK (t, OPTIMIZATION_NODE) +#define TARGET_OPTION_NODE_CHECK(t) TREE_CHECK (t, TARGET_OPTION_NODE) +#define C_MAYBE_CONST_EXPR_CHECK(t) TREE_CHECK (t, C_MAYBE_CONST_EXPR) +#define EXCESS_PRECISION_EXPR_CHECK(t) TREE_CHECK (t, EXCESS_PRECISION_EXPR) +#define UNCONSTRAINED_ARRAY_TYPE_CHECK(t) TREE_CHECK (t, UNCONSTRAINED_ARRAY_TYPE) +#define UNCONSTRAINED_ARRAY_REF_CHECK(t) TREE_CHECK (t, UNCONSTRAINED_ARRAY_REF) +#define NULL_EXPR_CHECK(t) TREE_CHECK (t, NULL_EXPR) +#define PLUS_NOMOD_EXPR_CHECK(t) TREE_CHECK (t, PLUS_NOMOD_EXPR) +#define MINUS_NOMOD_EXPR_CHECK(t) TREE_CHECK (t, MINUS_NOMOD_EXPR) +#define ATTR_ADDR_EXPR_CHECK(t) TREE_CHECK (t, ATTR_ADDR_EXPR) +#define STMT_STMT_CHECK(t) TREE_CHECK (t, STMT_STMT) +#define LOOP_STMT_CHECK(t) TREE_CHECK (t, LOOP_STMT) +#define EXIT_STMT_CHECK(t) TREE_CHECK (t, EXIT_STMT) +#define OFFSET_REF_CHECK(t) TREE_CHECK (t, OFFSET_REF) +#define PTRMEM_CST_CHECK(t) TREE_CHECK (t, PTRMEM_CST) +#define NEW_EXPR_CHECK(t) TREE_CHECK (t, NEW_EXPR) +#define VEC_NEW_EXPR_CHECK(t) TREE_CHECK (t, VEC_NEW_EXPR) +#define DELETE_EXPR_CHECK(t) TREE_CHECK (t, DELETE_EXPR) +#define VEC_DELETE_EXPR_CHECK(t) TREE_CHECK (t, VEC_DELETE_EXPR) +#define SCOPE_REF_CHECK(t) TREE_CHECK (t, SCOPE_REF) +#define MEMBER_REF_CHECK(t) TREE_CHECK (t, MEMBER_REF) +#define TYPE_EXPR_CHECK(t) TREE_CHECK (t, TYPE_EXPR) +#define AGGR_INIT_EXPR_CHECK(t) TREE_CHECK (t, AGGR_INIT_EXPR) +#define VEC_INIT_EXPR_CHECK(t) TREE_CHECK (t, VEC_INIT_EXPR) +#define THROW_EXPR_CHECK(t) TREE_CHECK (t, THROW_EXPR) +#define EMPTY_CLASS_EXPR_CHECK(t) TREE_CHECK (t, EMPTY_CLASS_EXPR) +#define BASELINK_CHECK(t) TREE_CHECK (t, BASELINK) +#define TEMPLATE_DECL_CHECK(t) TREE_CHECK (t, TEMPLATE_DECL) +#define TEMPLATE_PARM_INDEX_CHECK(t) TREE_CHECK (t, TEMPLATE_PARM_INDEX) +#define TEMPLATE_TEMPLATE_PARM_CHECK(t) TREE_CHECK (t, TEMPLATE_TEMPLATE_PARM) +#define TEMPLATE_TYPE_PARM_CHECK(t) TREE_CHECK (t, TEMPLATE_TYPE_PARM) +#define TYPENAME_TYPE_CHECK(t) TREE_CHECK (t, TYPENAME_TYPE) +#define TYPEOF_TYPE_CHECK(t) TREE_CHECK (t, TYPEOF_TYPE) +#define BOUND_TEMPLATE_TEMPLATE_PARM_CHECK(t) TREE_CHECK (t, BOUND_TEMPLATE_TEMPLATE_PARM) +#define UNBOUND_CLASS_TEMPLATE_CHECK(t) TREE_CHECK (t, UNBOUND_CLASS_TEMPLATE) +#define USING_DECL_CHECK(t) TREE_CHECK (t, USING_DECL) +#define USING_STMT_CHECK(t) TREE_CHECK (t, USING_STMT) +#define DEFAULT_ARG_CHECK(t) TREE_CHECK (t, DEFAULT_ARG) +#define TEMPLATE_ID_EXPR_CHECK(t) TREE_CHECK (t, TEMPLATE_ID_EXPR) +#define OVERLOAD_CHECK(t) TREE_CHECK (t, OVERLOAD) +#define PSEUDO_DTOR_EXPR_CHECK(t) TREE_CHECK (t, PSEUDO_DTOR_EXPR) +#define MODOP_EXPR_CHECK(t) TREE_CHECK (t, MODOP_EXPR) +#define CAST_EXPR_CHECK(t) TREE_CHECK (t, CAST_EXPR) +#define REINTERPRET_CAST_EXPR_CHECK(t) TREE_CHECK (t, REINTERPRET_CAST_EXPR) +#define CONST_CAST_EXPR_CHECK(t) TREE_CHECK (t, CONST_CAST_EXPR) +#define STATIC_CAST_EXPR_CHECK(t) TREE_CHECK (t, STATIC_CAST_EXPR) +#define DYNAMIC_CAST_EXPR_CHECK(t) TREE_CHECK (t, DYNAMIC_CAST_EXPR) +#define DOTSTAR_EXPR_CHECK(t) TREE_CHECK (t, DOTSTAR_EXPR) +#define TYPEID_EXPR_CHECK(t) TREE_CHECK (t, TYPEID_EXPR) +#define NOEXCEPT_EXPR_CHECK(t) TREE_CHECK (t, NOEXCEPT_EXPR) +#define NON_DEPENDENT_EXPR_CHECK(t) TREE_CHECK (t, NON_DEPENDENT_EXPR) +#define CTOR_INITIALIZER_CHECK(t) TREE_CHECK (t, CTOR_INITIALIZER) +#define TRY_BLOCK_CHECK(t) TREE_CHECK (t, TRY_BLOCK) +#define EH_SPEC_BLOCK_CHECK(t) TREE_CHECK (t, EH_SPEC_BLOCK) +#define HANDLER_CHECK(t) TREE_CHECK (t, HANDLER) +#define MUST_NOT_THROW_EXPR_CHECK(t) TREE_CHECK (t, MUST_NOT_THROW_EXPR) +#define CLEANUP_STMT_CHECK(t) TREE_CHECK (t, CLEANUP_STMT) +#define IF_STMT_CHECK(t) TREE_CHECK (t, IF_STMT) +#define FOR_STMT_CHECK(t) TREE_CHECK (t, FOR_STMT) +#define RANGE_FOR_STMT_CHECK(t) TREE_CHECK (t, RANGE_FOR_STMT) +#define WHILE_STMT_CHECK(t) TREE_CHECK (t, WHILE_STMT) +#define DO_STMT_CHECK(t) TREE_CHECK (t, DO_STMT) +#define BREAK_STMT_CHECK(t) TREE_CHECK (t, BREAK_STMT) +#define CONTINUE_STMT_CHECK(t) TREE_CHECK (t, CONTINUE_STMT) +#define SWITCH_STMT_CHECK(t) TREE_CHECK (t, SWITCH_STMT) +#define EXPR_STMT_CHECK(t) TREE_CHECK (t, EXPR_STMT) +#define TAG_DEFN_CHECK(t) TREE_CHECK (t, TAG_DEFN) +#define OFFSETOF_EXPR_CHECK(t) TREE_CHECK (t, OFFSETOF_EXPR) +#define SIZEOF_EXPR_CHECK(t) TREE_CHECK (t, SIZEOF_EXPR) +#define ARROW_EXPR_CHECK(t) TREE_CHECK (t, ARROW_EXPR) +#define ALIGNOF_EXPR_CHECK(t) TREE_CHECK (t, ALIGNOF_EXPR) +#define AT_ENCODE_EXPR_CHECK(t) TREE_CHECK (t, AT_ENCODE_EXPR) +#define STMT_EXPR_CHECK(t) TREE_CHECK (t, STMT_EXPR) +#define UNARY_PLUS_EXPR_CHECK(t) TREE_CHECK (t, UNARY_PLUS_EXPR) +#define STATIC_ASSERT_CHECK(t) TREE_CHECK (t, STATIC_ASSERT) +#define TYPE_ARGUMENT_PACK_CHECK(t) TREE_CHECK (t, TYPE_ARGUMENT_PACK) +#define NONTYPE_ARGUMENT_PACK_CHECK(t) TREE_CHECK (t, NONTYPE_ARGUMENT_PACK) +#define TYPE_PACK_EXPANSION_CHECK(t) TREE_CHECK (t, TYPE_PACK_EXPANSION) +#define EXPR_PACK_EXPANSION_CHECK(t) TREE_CHECK (t, EXPR_PACK_EXPANSION) +#define ARGUMENT_PACK_SELECT_CHECK(t) TREE_CHECK (t, ARGUMENT_PACK_SELECT) +#define TRAIT_EXPR_CHECK(t) TREE_CHECK (t, TRAIT_EXPR) +#define LAMBDA_EXPR_CHECK(t) TREE_CHECK (t, LAMBDA_EXPR) +#define DECLTYPE_TYPE_CHECK(t) TREE_CHECK (t, DECLTYPE_TYPE) +#define TEMPLATE_INFO_CHECK(t) TREE_CHECK (t, TEMPLATE_INFO) +#define URSHIFT_EXPR_CHECK(t) TREE_CHECK (t, URSHIFT_EXPR) +#define COMPARE_EXPR_CHECK(t) TREE_CHECK (t, COMPARE_EXPR) +#define COMPARE_L_EXPR_CHECK(t) TREE_CHECK (t, COMPARE_L_EXPR) +#define COMPARE_G_EXPR_CHECK(t) TREE_CHECK (t, COMPARE_G_EXPR) +#define CLASS_INTERFACE_TYPE_CHECK(t) TREE_CHECK (t, CLASS_INTERFACE_TYPE) +#define CLASS_IMPLEMENTATION_TYPE_CHECK(t) TREE_CHECK (t, CLASS_IMPLEMENTATION_TYPE) +#define CATEGORY_INTERFACE_TYPE_CHECK(t) TREE_CHECK (t, CATEGORY_INTERFACE_TYPE) +#define CATEGORY_IMPLEMENTATION_TYPE_CHECK(t) TREE_CHECK (t, CATEGORY_IMPLEMENTATION_TYPE) +#define PROTOCOL_INTERFACE_TYPE_CHECK(t) TREE_CHECK (t, PROTOCOL_INTERFACE_TYPE) +#define KEYWORD_DECL_CHECK(t) TREE_CHECK (t, KEYWORD_DECL) +#define INSTANCE_METHOD_DECL_CHECK(t) TREE_CHECK (t, INSTANCE_METHOD_DECL) +#define CLASS_METHOD_DECL_CHECK(t) TREE_CHECK (t, CLASS_METHOD_DECL) +#define PROPERTY_DECL_CHECK(t) TREE_CHECK (t, PROPERTY_DECL) +#define MESSAGE_SEND_EXPR_CHECK(t) TREE_CHECK (t, MESSAGE_SEND_EXPR) +#define CLASS_REFERENCE_EXPR_CHECK(t) TREE_CHECK (t, CLASS_REFERENCE_EXPR) +#define PROPERTY_REF_CHECK(t) TREE_CHECK (t, PROPERTY_REF) + +#endif /* GCC_TREE_CHECK_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-dump.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-dump.h new file mode 100644 index 0000000..6b7df72 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-dump.h @@ -0,0 +1,102 @@ +/* Tree-dumping functionality for intermediate representation. + Copyright (C) 1999, 2000, 2003, 2004, 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Written by Mark Mitchell <mark@codesourcery.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_TREE_DUMP_H +#define GCC_TREE_DUMP_H + +#include "splay-tree.h" +#include "tree-pass.h" + +typedef struct dump_info *dump_info_p; + +/* Flags used with queue functions. */ +#define DUMP_NONE 0 +#define DUMP_BINFO 1 + +/* Information about a node to be dumped. */ + +typedef struct dump_node_info +{ + /* The index for the node. */ + unsigned int index; + /* Nonzero if the node is a binfo. */ + unsigned int binfo_p : 1; +} *dump_node_info_p; + +/* A dump_queue is a link in the queue of things to be dumped. */ + +typedef struct dump_queue +{ + /* The queued tree node. */ + splay_tree_node node; + /* The next node in the queue. */ + struct dump_queue *next; +} *dump_queue_p; + +/* A dump_info gives information about how we should perform the dump + and about the current state of the dump. */ + +struct dump_info +{ + /* The stream on which to dump the information. */ + FILE *stream; + /* The original node. */ + const_tree node; + /* User flags. */ + int flags; + /* The next unused node index. */ + unsigned int index; + /* The next column. */ + unsigned int column; + /* The first node in the queue of nodes to be written out. */ + dump_queue_p queue; + /* The last node in the queue. */ + dump_queue_p queue_end; + /* Free queue nodes. */ + dump_queue_p free_list; + /* The tree nodes which we have already written out. The + keys are the addresses of the nodes; the values are the integer + indices we assigned them. */ + splay_tree nodes; +}; + +/* Dump the CHILD and its children. */ +#define dump_child(field, child) \ + queue_and_dump_index (di, field, child, DUMP_NONE) + +extern void dump_pointer (dump_info_p, const char *, void *); +extern void dump_int (dump_info_p, const char *, int); +extern void dump_string (dump_info_p, const char *); +extern void dump_string_field (dump_info_p, const char *, const char *); +extern void dump_stmt (dump_info_p, const_tree); +extern void queue_and_dump_index (dump_info_p, const char *, const_tree, int); +extern void queue_and_dump_type (dump_info_p, const_tree); +extern void dump_function (int, tree); +extern void dump_function_to_file (tree, FILE *, int); +extern void dump_enumerated_decls (FILE *, int); +extern void debug_function (tree, int); +extern int dump_flag (dump_info_p, int, const_tree); + +extern unsigned int dump_register (const char *, const char *, const char *, + int); + + +#endif /* ! GCC_TREE_DUMP_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-flow-inline.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-flow-inline.h new file mode 100644 index 0000000..8656610 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-flow-inline.h @@ -0,0 +1,1230 @@ +/* Inline functions for tree-flow.h + Copyright (C) 2001, 2003, 2005, 2006, 2007, 2008, 2010 + Free Software Foundation, Inc. + Contributed by Diego Novillo <dnovillo@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + +#ifndef _TREE_FLOW_INLINE_H +#define _TREE_FLOW_INLINE_H 1 + +/* Inline functions for manipulating various data structures defined in + tree-flow.h. See tree-flow.h for documentation. */ + +/* Return true when gimple SSA form was built. + gimple_in_ssa_p is queried by gimplifier in various early stages before SSA + infrastructure is initialized. Check for presence of the datastructures + at first place. */ +static inline bool +gimple_in_ssa_p (const struct function *fun) +{ + return fun && fun->gimple_df && fun->gimple_df->in_ssa_p; +} + +/* Array of all variables referenced in the function. */ +static inline htab_t +gimple_referenced_vars (const struct function *fun) +{ + if (!fun->gimple_df) + return NULL; + return fun->gimple_df->referenced_vars; +} + +/* Artificial variable used for the virtual operand FUD chain. */ +static inline tree +gimple_vop (const struct function *fun) +{ + gcc_checking_assert (fun && fun->gimple_df); + return fun->gimple_df->vop; +} + +/* Initialize the hashtable iterator HTI to point to hashtable TABLE */ + +static inline void * +first_htab_element (htab_iterator *hti, htab_t table) +{ + hti->htab = table; + hti->slot = table->entries; + hti->limit = hti->slot + htab_size (table); + do + { + PTR x = *(hti->slot); + if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) + break; + } while (++(hti->slot) < hti->limit); + + if (hti->slot < hti->limit) + return *(hti->slot); + return NULL; +} + +/* Return current non-empty/deleted slot of the hashtable pointed to by HTI, + or NULL if we have reached the end. */ + +static inline bool +end_htab_p (const htab_iterator *hti) +{ + if (hti->slot >= hti->limit) + return true; + return false; +} + +/* Advance the hashtable iterator pointed to by HTI to the next element of the + hashtable. */ + +static inline void * +next_htab_element (htab_iterator *hti) +{ + while (++(hti->slot) < hti->limit) + { + PTR x = *(hti->slot); + if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) + return x; + }; + return NULL; +} + +/* Get the variable with uid UID from the list of referenced vars. */ + +static inline tree +referenced_var (unsigned int uid) +{ + tree var = referenced_var_lookup (cfun, uid); + gcc_assert (var || uid == 0); + return var; +} + +/* Initialize ITER to point to the first referenced variable in the + referenced_vars hashtable, and return that variable. */ + +static inline tree +first_referenced_var (struct function *fn, referenced_var_iterator *iter) +{ + return (tree) first_htab_element (&iter->hti, + gimple_referenced_vars (fn)); +} + +/* Return true if we have hit the end of the referenced variables ITER is + iterating through. */ + +static inline bool +end_referenced_vars_p (const referenced_var_iterator *iter) +{ + return end_htab_p (&iter->hti); +} + +/* Make ITER point to the next referenced_var in the referenced_var hashtable, + and return that variable. */ + +static inline tree +next_referenced_var (referenced_var_iterator *iter) +{ + return (tree) next_htab_element (&iter->hti); +} + +/* Return the variable annotation for T, which must be a _DECL node. + Return NULL if the variable annotation doesn't already exist. */ +static inline var_ann_t +var_ann (const_tree t) +{ + const var_ann_t *p = DECL_VAR_ANN_PTR (t); + return p ? *p : NULL; +} + +/* Return the variable annotation for T, which must be a _DECL node. + Create the variable annotation if it doesn't exist. */ +static inline var_ann_t +get_var_ann (tree var) +{ + var_ann_t *p = DECL_VAR_ANN_PTR (var); + gcc_checking_assert (p); + return *p ? *p : create_var_ann (var); +} + +/* Get the number of the next statement uid to be allocated. */ +static inline unsigned int +gimple_stmt_max_uid (struct function *fn) +{ + return fn->last_stmt_uid; +} + +/* Set the number of the next statement uid to be allocated. */ +static inline void +set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid) +{ + fn->last_stmt_uid = maxid; +} + +/* Set the number of the next statement uid to be allocated. */ +static inline unsigned int +inc_gimple_stmt_max_uid (struct function *fn) +{ + return fn->last_stmt_uid++; +} + +/* Return the line number for EXPR, or return -1 if we have no line + number information for it. */ +static inline int +get_lineno (const_gimple stmt) +{ + location_t loc; + + if (!stmt) + return -1; + + loc = gimple_location (stmt); + if (loc == UNKNOWN_LOCATION) + return -1; + + return LOCATION_LINE (loc); +} + +/* Delink an immediate_uses node from its chain. */ +static inline void +delink_imm_use (ssa_use_operand_t *linknode) +{ + /* Return if this node is not in a list. */ + if (linknode->prev == NULL) + return; + + linknode->prev->next = linknode->next; + linknode->next->prev = linknode->prev; + linknode->prev = NULL; + linknode->next = NULL; +} + +/* Link ssa_imm_use node LINKNODE into the chain for LIST. */ +static inline void +link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list) +{ + /* Link the new node at the head of the list. If we are in the process of + traversing the list, we won't visit any new nodes added to it. */ + linknode->prev = list; + linknode->next = list->next; + list->next->prev = linknode; + list->next = linknode; +} + +/* Link ssa_imm_use node LINKNODE into the chain for DEF. */ +static inline void +link_imm_use (ssa_use_operand_t *linknode, tree def) +{ + ssa_use_operand_t *root; + + if (!def || TREE_CODE (def) != SSA_NAME) + linknode->prev = NULL; + else + { + root = &(SSA_NAME_IMM_USE_NODE (def)); + if (linknode->use) + gcc_checking_assert (*(linknode->use) == def); + link_imm_use_to_list (linknode, root); + } +} + +/* Set the value of a use pointed to by USE to VAL. */ +static inline void +set_ssa_use_from_ptr (use_operand_p use, tree val) +{ + delink_imm_use (use); + *(use->use) = val; + link_imm_use (use, val); +} + +/* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring + in STMT. */ +static inline void +link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt) +{ + if (stmt) + link_imm_use (linknode, def); + else + link_imm_use (linknode, NULL); + linknode->loc.stmt = stmt; +} + +/* Relink a new node in place of an old node in the list. */ +static inline void +relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old) +{ + /* The node one had better be in the same list. */ + gcc_checking_assert (*(old->use) == *(node->use)); + node->prev = old->prev; + node->next = old->next; + if (old->prev) + { + old->prev->next = node; + old->next->prev = node; + /* Remove the old node from the list. */ + old->prev = NULL; + } +} + +/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring + in STMT. */ +static inline void +relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, + gimple stmt) +{ + if (stmt) + relink_imm_use (linknode, old); + else + link_imm_use (linknode, NULL); + linknode->loc.stmt = stmt; +} + + +/* Return true is IMM has reached the end of the immediate use list. */ +static inline bool +end_readonly_imm_use_p (const imm_use_iterator *imm) +{ + return (imm->imm_use == imm->end_p); +} + +/* Initialize iterator IMM to process the list for VAR. */ +static inline use_operand_p +first_readonly_imm_use (imm_use_iterator *imm, tree var) +{ + imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); + imm->imm_use = imm->end_p->next; +#ifdef ENABLE_CHECKING + imm->iter_node.next = imm->imm_use->next; +#endif + if (end_readonly_imm_use_p (imm)) + return NULL_USE_OPERAND_P; + return imm->imm_use; +} + +/* Bump IMM to the next use in the list. */ +static inline use_operand_p +next_readonly_imm_use (imm_use_iterator *imm) +{ + use_operand_p old = imm->imm_use; + +#ifdef ENABLE_CHECKING + /* If this assertion fails, it indicates the 'next' pointer has changed + since the last bump. This indicates that the list is being modified + via stmt changes, or SET_USE, or somesuch thing, and you need to be + using the SAFE version of the iterator. */ + gcc_assert (imm->iter_node.next == old->next); + imm->iter_node.next = old->next->next; +#endif + + imm->imm_use = old->next; + if (end_readonly_imm_use_p (imm)) + return NULL_USE_OPERAND_P; + return imm->imm_use; +} + +/* tree-cfg.c */ +extern bool has_zero_uses_1 (const ssa_use_operand_t *head); +extern bool single_imm_use_1 (const ssa_use_operand_t *head, + use_operand_p *use_p, gimple *stmt); + +/* Return true if VAR has no nondebug uses. */ +static inline bool +has_zero_uses (const_tree var) +{ + const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); + + /* A single use_operand means there is no items in the list. */ + if (ptr == ptr->next) + return true; + + /* If there are debug stmts, we have to look at each use and see + whether there are any nondebug uses. */ + if (!MAY_HAVE_DEBUG_STMTS) + return false; + + return has_zero_uses_1 (ptr); +} + +/* Return true if VAR has a single nondebug use. */ +static inline bool +has_single_use (const_tree var) +{ + const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); + + /* If there aren't any uses whatsoever, we're done. */ + if (ptr == ptr->next) + return false; + + /* If there's a single use, check that it's not a debug stmt. */ + if (ptr == ptr->next->next) + return !is_gimple_debug (USE_STMT (ptr->next)); + + /* If there are debug stmts, we have to look at each of them. */ + if (!MAY_HAVE_DEBUG_STMTS) + return false; + + return single_imm_use_1 (ptr, NULL, NULL); +} + + +/* If VAR has only a single immediate nondebug use, return true, and + set USE_P and STMT to the use pointer and stmt of occurrence. */ +static inline bool +single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt) +{ + const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); + + /* If there aren't any uses whatsoever, we're done. */ + if (ptr == ptr->next) + { + return_false: + *use_p = NULL_USE_OPERAND_P; + *stmt = NULL; + return false; + } + + /* If there's a single use, check that it's not a debug stmt. */ + if (ptr == ptr->next->next) + { + if (!is_gimple_debug (USE_STMT (ptr->next))) + { + *use_p = ptr->next; + *stmt = ptr->next->loc.stmt; + return true; + } + else + goto return_false; + } + + /* If there are debug stmts, we have to look at each of them. */ + if (!MAY_HAVE_DEBUG_STMTS) + goto return_false; + + return single_imm_use_1 (ptr, use_p, stmt); +} + +/* Return the number of nondebug immediate uses of VAR. */ +static inline unsigned int +num_imm_uses (const_tree var) +{ + const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var)); + const ssa_use_operand_t *ptr; + unsigned int num = 0; + + if (!MAY_HAVE_DEBUG_STMTS) + for (ptr = start->next; ptr != start; ptr = ptr->next) + num++; + else + for (ptr = start->next; ptr != start; ptr = ptr->next) + if (!is_gimple_debug (USE_STMT (ptr))) + num++; + + return num; +} + +/* Return the tree pointed-to by USE. */ +static inline tree +get_use_from_ptr (use_operand_p use) +{ + return *(use->use); +} + +/* Return the tree pointed-to by DEF. */ +static inline tree +get_def_from_ptr (def_operand_p def) +{ + return *def; +} + +/* Return a use_operand_p pointer for argument I of PHI node GS. */ + +static inline use_operand_p +gimple_phi_arg_imm_use_ptr (gimple gs, int i) +{ + return &gimple_phi_arg (gs, i)->imm_use; +} + +/* Return the tree operand for argument I of PHI node GS. */ + +static inline tree +gimple_phi_arg_def (gimple gs, size_t index) +{ + struct phi_arg_d *pd = gimple_phi_arg (gs, index); + return get_use_from_ptr (&pd->imm_use); +} + +/* Return a pointer to the tree operand for argument I of PHI node GS. */ + +static inline tree * +gimple_phi_arg_def_ptr (gimple gs, size_t index) +{ + return &gimple_phi_arg (gs, index)->def; +} + +/* Return the edge associated with argument I of phi node GS. */ + +static inline edge +gimple_phi_arg_edge (gimple gs, size_t i) +{ + return EDGE_PRED (gimple_bb (gs), i); +} + +/* Return the source location of gimple argument I of phi node GS. */ + +static inline source_location +gimple_phi_arg_location (gimple gs, size_t i) +{ + return gimple_phi_arg (gs, i)->locus; +} + +/* Return the source location of the argument on edge E of phi node GS. */ + +static inline source_location +gimple_phi_arg_location_from_edge (gimple gs, edge e) +{ + return gimple_phi_arg (gs, e->dest_idx)->locus; +} + +/* Set the source location of gimple argument I of phi node GS to LOC. */ + +static inline void +gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc) +{ + gimple_phi_arg (gs, i)->locus = loc; +} + +/* Return TRUE if argument I of phi node GS has a location record. */ + +static inline bool +gimple_phi_arg_has_location (gimple gs, size_t i) +{ + return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION; +} + + +/* Return the PHI nodes for basic block BB, or NULL if there are no + PHI nodes. */ +static inline gimple_seq +phi_nodes (const_basic_block bb) +{ + gcc_checking_assert (!(bb->flags & BB_RTL)); + if (!bb->il.gimple) + return NULL; + return bb->il.gimple->phi_nodes; +} + +/* Set PHI nodes of a basic block BB to SEQ. */ + +static inline void +set_phi_nodes (basic_block bb, gimple_seq seq) +{ + gimple_stmt_iterator i; + + gcc_checking_assert (!(bb->flags & BB_RTL)); + bb->il.gimple->phi_nodes = seq; + if (seq) + for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) + gimple_set_bb (gsi_stmt (i), bb); +} + +/* Return the phi argument which contains the specified use. */ + +static inline int +phi_arg_index_from_use (use_operand_p use) +{ + struct phi_arg_d *element, *root; + size_t index; + gimple phi; + + /* Since the use is the first thing in a PHI argument element, we can + calculate its index based on casting it to an argument, and performing + pointer arithmetic. */ + + phi = USE_STMT (use); + + element = (struct phi_arg_d *)use; + root = gimple_phi_arg (phi, 0); + index = element - root; + + /* Make sure the calculation doesn't have any leftover bytes. If it does, + then imm_use is likely not the first element in phi_arg_d. */ + gcc_checking_assert ((((char *)element - (char *)root) + % sizeof (struct phi_arg_d)) == 0 + && index < gimple_phi_capacity (phi)); + + return index; +} + +/* Mark VAR as used, so that it'll be preserved during rtl expansion. */ + +static inline void +set_is_used (tree var) +{ + var_ann_t ann = get_var_ann (var); + ann->used = true; +} + +/* Clear VAR's used flag. */ + +static inline void +clear_is_used (tree var) +{ + var_ann_t ann = var_ann (var); + ann->used = false; +} + +/* Return true if VAR is marked as used. */ + +static inline bool +is_used_p (tree var) +{ + var_ann_t ann = var_ann (var); + return ann->used; +} + +/* Return true if T (assumed to be a DECL) is a global variable. + A variable is considered global if its storage is not automatic. */ + +static inline bool +is_global_var (const_tree t) +{ + return (TREE_STATIC (t) || DECL_EXTERNAL (t)); +} + + +/* Return true if VAR may be aliased. A variable is considered as + maybe aliased if it has its address taken by the local TU + or possibly by another TU and might be modified through a pointer. */ + +static inline bool +may_be_aliased (const_tree var) +{ + return (TREE_CODE (var) != CONST_DECL + && !((TREE_STATIC (var) || TREE_PUBLIC (var) || DECL_EXTERNAL (var)) + && TREE_READONLY (var) + && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (var))) + && (TREE_PUBLIC (var) + || DECL_EXTERNAL (var) + || TREE_ADDRESSABLE (var))); +} + + +/* PHI nodes should contain only ssa_names and invariants. A test + for ssa_name is definitely simpler; don't let invalid contents + slip in in the meantime. */ + +static inline bool +phi_ssa_name_p (const_tree t) +{ + if (TREE_CODE (t) == SSA_NAME) + return true; + gcc_checking_assert (is_gimple_min_invariant (t)); + return false; +} + + +/* Returns the loop of the statement STMT. */ + +static inline struct loop * +loop_containing_stmt (gimple stmt) +{ + basic_block bb = gimple_bb (stmt); + if (!bb) + return NULL; + + return bb->loop_father; +} + + +/* ----------------------------------------------------------------------- */ + +/* The following set of routines are used to iterator over various type of + SSA operands. */ + +/* Return true if PTR is finished iterating. */ +static inline bool +op_iter_done (const ssa_op_iter *ptr) +{ + return ptr->done; +} + +/* Get the next iterator use value for PTR. */ +static inline use_operand_p +op_iter_next_use (ssa_op_iter *ptr) +{ + use_operand_p use_p; + gcc_checking_assert (ptr->iter_type == ssa_op_iter_use); + if (ptr->uses) + { + use_p = USE_OP_PTR (ptr->uses); + ptr->uses = ptr->uses->next; + return use_p; + } + if (ptr->phi_i < ptr->num_phi) + { + return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++); + } + ptr->done = true; + return NULL_USE_OPERAND_P; +} + +/* Get the next iterator def value for PTR. */ +static inline def_operand_p +op_iter_next_def (ssa_op_iter *ptr) +{ + def_operand_p def_p; + gcc_checking_assert (ptr->iter_type == ssa_op_iter_def); + if (ptr->defs) + { + def_p = DEF_OP_PTR (ptr->defs); + ptr->defs = ptr->defs->next; + return def_p; + } + ptr->done = true; + return NULL_DEF_OPERAND_P; +} + +/* Get the next iterator tree value for PTR. */ +static inline tree +op_iter_next_tree (ssa_op_iter *ptr) +{ + tree val; + gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree); + if (ptr->uses) + { + val = USE_OP (ptr->uses); + ptr->uses = ptr->uses->next; + return val; + } + if (ptr->defs) + { + val = DEF_OP (ptr->defs); + ptr->defs = ptr->defs->next; + return val; + } + + ptr->done = true; + return NULL_TREE; + +} + + +/* This functions clears the iterator PTR, and marks it done. This is normally + used to prevent warnings in the compile about might be uninitialized + components. */ + +static inline void +clear_and_done_ssa_iter (ssa_op_iter *ptr) +{ + ptr->defs = NULL; + ptr->uses = NULL; + ptr->iter_type = ssa_op_iter_none; + ptr->phi_i = 0; + ptr->num_phi = 0; + ptr->phi_stmt = NULL; + ptr->done = true; +} + +/* Initialize the iterator PTR to the virtual defs in STMT. */ +static inline void +op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags) +{ + /* We do not support iterating over virtual defs or uses without + iterating over defs or uses at the same time. */ + gcc_checking_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF)) + && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE))); + ptr->defs = (flags & (SSA_OP_DEF|SSA_OP_VDEF)) ? gimple_def_ops (stmt) : NULL; + if (!(flags & SSA_OP_VDEF) + && ptr->defs + && gimple_vdef (stmt) != NULL_TREE) + ptr->defs = ptr->defs->next; + ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL; + if (!(flags & SSA_OP_VUSE) + && ptr->uses + && gimple_vuse (stmt) != NULL_TREE) + ptr->uses = ptr->uses->next; + ptr->done = false; + + ptr->phi_i = 0; + ptr->num_phi = 0; + ptr->phi_stmt = NULL; +} + +/* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return + the first use. */ +static inline use_operand_p +op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags) +{ + gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0 + && (flags & SSA_OP_USE)); + op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_use; + return op_iter_next_use (ptr); +} + +/* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return + the first def. */ +static inline def_operand_p +op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags) +{ + gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0 + && (flags & SSA_OP_DEF)); + op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_def; + return op_iter_next_def (ptr); +} + +/* Initialize iterator PTR to the operands in STMT based on FLAGS. Return + the first operand as a tree. */ +static inline tree +op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags) +{ + op_iter_init (ptr, stmt, flags); + ptr->iter_type = ssa_op_iter_tree; + return op_iter_next_tree (ptr); +} + + +/* If there is a single operand in STMT matching FLAGS, return it. Otherwise + return NULL. */ +static inline tree +single_ssa_tree_operand (gimple stmt, int flags) +{ + tree var; + ssa_op_iter iter; + + var = op_iter_init_tree (&iter, stmt, flags); + if (op_iter_done (&iter)) + return NULL_TREE; + op_iter_next_tree (&iter); + if (op_iter_done (&iter)) + return var; + return NULL_TREE; +} + + +/* If there is a single operand in STMT matching FLAGS, return it. Otherwise + return NULL. */ +static inline use_operand_p +single_ssa_use_operand (gimple stmt, int flags) +{ + use_operand_p var; + ssa_op_iter iter; + + var = op_iter_init_use (&iter, stmt, flags); + if (op_iter_done (&iter)) + return NULL_USE_OPERAND_P; + op_iter_next_use (&iter); + if (op_iter_done (&iter)) + return var; + return NULL_USE_OPERAND_P; +} + + + +/* If there is a single operand in STMT matching FLAGS, return it. Otherwise + return NULL. */ +static inline def_operand_p +single_ssa_def_operand (gimple stmt, int flags) +{ + def_operand_p var; + ssa_op_iter iter; + + var = op_iter_init_def (&iter, stmt, flags); + if (op_iter_done (&iter)) + return NULL_DEF_OPERAND_P; + op_iter_next_def (&iter); + if (op_iter_done (&iter)) + return var; + return NULL_DEF_OPERAND_P; +} + + +/* Return true if there are zero operands in STMT matching the type + given in FLAGS. */ +static inline bool +zero_ssa_operands (gimple stmt, int flags) +{ + ssa_op_iter iter; + + op_iter_init_tree (&iter, stmt, flags); + return op_iter_done (&iter); +} + + +/* Return the number of operands matching FLAGS in STMT. */ +static inline int +num_ssa_operands (gimple stmt, int flags) +{ + ssa_op_iter iter; + tree t; + int num = 0; + + FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags) + num++; + return num; +} + + +/* Delink all immediate_use information for STMT. */ +static inline void +delink_stmt_imm_use (gimple stmt) +{ + ssa_op_iter iter; + use_operand_p use_p; + + if (ssa_operands_active ()) + FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES) + delink_imm_use (use_p); +} + + +/* If there is a single DEF in the PHI node which matches FLAG, return it. + Otherwise return NULL_DEF_OPERAND_P. */ +static inline tree +single_phi_def (gimple stmt, int flags) +{ + tree def = PHI_RESULT (stmt); + if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) + return def; + if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def)) + return def; + return NULL_TREE; +} + +/* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should + be either SSA_OP_USES or SSA_OP_VIRTUAL_USES. */ +static inline use_operand_p +op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags) +{ + tree phi_def = gimple_phi_result (phi); + int comp; + + clear_and_done_ssa_iter (ptr); + ptr->done = false; + + gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0); + + comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); + + /* If the PHI node doesn't the operand type we care about, we're done. */ + if ((flags & comp) == 0) + { + ptr->done = true; + return NULL_USE_OPERAND_P; + } + + ptr->phi_stmt = phi; + ptr->num_phi = gimple_phi_num_args (phi); + ptr->iter_type = ssa_op_iter_use; + return op_iter_next_use (ptr); +} + + +/* Start an iterator for a PHI definition. */ + +static inline def_operand_p +op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags) +{ + tree phi_def = PHI_RESULT (phi); + int comp; + + clear_and_done_ssa_iter (ptr); + ptr->done = false; + + gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0); + + comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS); + + /* If the PHI node doesn't have the operand type we care about, + we're done. */ + if ((flags & comp) == 0) + { + ptr->done = true; + return NULL_DEF_OPERAND_P; + } + + ptr->iter_type = ssa_op_iter_def; + /* The first call to op_iter_next_def will terminate the iterator since + all the fields are NULL. Simply return the result here as the first and + therefore only result. */ + return PHI_RESULT_PTR (phi); +} + +/* Return true is IMM has reached the end of the immediate use stmt list. */ + +static inline bool +end_imm_use_stmt_p (const imm_use_iterator *imm) +{ + return (imm->imm_use == imm->end_p); +} + +/* Finished the traverse of an immediate use stmt list IMM by removing the + placeholder node from the list. */ + +static inline void +end_imm_use_stmt_traverse (imm_use_iterator *imm) +{ + delink_imm_use (&(imm->iter_node)); +} + +/* Immediate use traversal of uses within a stmt require that all the + uses on a stmt be sequentially listed. This routine is used to build up + this sequential list by adding USE_P to the end of the current list + currently delimited by HEAD and LAST_P. The new LAST_P value is + returned. */ + +static inline use_operand_p +move_use_after_head (use_operand_p use_p, use_operand_p head, + use_operand_p last_p) +{ + gcc_checking_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head)); + /* Skip head when we find it. */ + if (use_p != head) + { + /* If use_p is already linked in after last_p, continue. */ + if (last_p->next == use_p) + last_p = use_p; + else + { + /* Delink from current location, and link in at last_p. */ + delink_imm_use (use_p); + link_imm_use_to_list (use_p, last_p); + last_p = use_p; + } + } + return last_p; +} + + +/* This routine will relink all uses with the same stmt as HEAD into the list + immediately following HEAD for iterator IMM. */ + +static inline void +link_use_stmts_after (use_operand_p head, imm_use_iterator *imm) +{ + use_operand_p use_p; + use_operand_p last_p = head; + gimple head_stmt = USE_STMT (head); + tree use = USE_FROM_PTR (head); + ssa_op_iter op_iter; + int flag; + + /* Only look at virtual or real uses, depending on the type of HEAD. */ + flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); + + if (gimple_code (head_stmt) == GIMPLE_PHI) + { + FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag) + if (USE_FROM_PTR (use_p) == use) + last_p = move_use_after_head (use_p, head, last_p); + } + else + { + if (flag == SSA_OP_USE) + { + FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag) + if (USE_FROM_PTR (use_p) == use) + last_p = move_use_after_head (use_p, head, last_p); + } + else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P) + { + if (USE_FROM_PTR (use_p) == use) + last_p = move_use_after_head (use_p, head, last_p); + } + } + /* Link iter node in after last_p. */ + if (imm->iter_node.prev != NULL) + delink_imm_use (&imm->iter_node); + link_imm_use_to_list (&(imm->iter_node), last_p); +} + +/* Initialize IMM to traverse over uses of VAR. Return the first statement. */ +static inline gimple +first_imm_use_stmt (imm_use_iterator *imm, tree var) +{ + imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); + imm->imm_use = imm->end_p->next; + imm->next_imm_name = NULL_USE_OPERAND_P; + + /* iter_node is used as a marker within the immediate use list to indicate + where the end of the current stmt's uses are. Initialize it to NULL + stmt and use, which indicates a marker node. */ + imm->iter_node.prev = NULL_USE_OPERAND_P; + imm->iter_node.next = NULL_USE_OPERAND_P; + imm->iter_node.loc.stmt = NULL; + imm->iter_node.use = NULL; + + if (end_imm_use_stmt_p (imm)) + return NULL; + + link_use_stmts_after (imm->imm_use, imm); + + return USE_STMT (imm->imm_use); +} + +/* Bump IMM to the next stmt which has a use of var. */ + +static inline gimple +next_imm_use_stmt (imm_use_iterator *imm) +{ + imm->imm_use = imm->iter_node.next; + if (end_imm_use_stmt_p (imm)) + { + if (imm->iter_node.prev != NULL) + delink_imm_use (&imm->iter_node); + return NULL; + } + + link_use_stmts_after (imm->imm_use, imm); + return USE_STMT (imm->imm_use); +} + +/* This routine will return the first use on the stmt IMM currently refers + to. */ + +static inline use_operand_p +first_imm_use_on_stmt (imm_use_iterator *imm) +{ + imm->next_imm_name = imm->imm_use->next; + return imm->imm_use; +} + +/* Return TRUE if the last use on the stmt IMM refers to has been visited. */ + +static inline bool +end_imm_use_on_stmt_p (const imm_use_iterator *imm) +{ + return (imm->imm_use == &(imm->iter_node)); +} + +/* Bump to the next use on the stmt IMM refers to, return NULL if done. */ + +static inline use_operand_p +next_imm_use_on_stmt (imm_use_iterator *imm) +{ + imm->imm_use = imm->next_imm_name; + if (end_imm_use_on_stmt_p (imm)) + return NULL_USE_OPERAND_P; + else + { + imm->next_imm_name = imm->imm_use->next; + return imm->imm_use; + } +} + +/* Return true if VAR cannot be modified by the program. */ + +static inline bool +unmodifiable_var_p (const_tree var) +{ + if (TREE_CODE (var) == SSA_NAME) + var = SSA_NAME_VAR (var); + + return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var)); +} + +/* Return true if REF, a handled component reference, has an ARRAY_REF + somewhere in it. */ + +static inline bool +ref_contains_array_ref (const_tree ref) +{ + gcc_checking_assert (handled_component_p (ref)); + + do { + if (TREE_CODE (ref) == ARRAY_REF) + return true; + ref = TREE_OPERAND (ref, 0); + } while (handled_component_p (ref)); + + return false; +} + +/* Return true if REF has an VIEW_CONVERT_EXPR somewhere in it. */ + +static inline bool +contains_view_convert_expr_p (const_tree ref) +{ + while (handled_component_p (ref)) + { + if (TREE_CODE (ref) == VIEW_CONVERT_EXPR) + return true; + ref = TREE_OPERAND (ref, 0); + } + + return false; +} + +/* Return true, if the two ranges [POS1, SIZE1] and [POS2, SIZE2] + overlap. SIZE1 and/or SIZE2 can be (unsigned)-1 in which case the + range is open-ended. Otherwise return false. */ + +static inline bool +ranges_overlap_p (unsigned HOST_WIDE_INT pos1, + unsigned HOST_WIDE_INT size1, + unsigned HOST_WIDE_INT pos2, + unsigned HOST_WIDE_INT size2) +{ + if (pos1 >= pos2 + && (size2 == (unsigned HOST_WIDE_INT)-1 + || pos1 < (pos2 + size2))) + return true; + if (pos2 >= pos1 + && (size1 == (unsigned HOST_WIDE_INT)-1 + || pos2 < (pos1 + size1))) + return true; + + return false; +} + +/* Accessor to tree-ssa-operands.c caches. */ +static inline struct ssa_operands * +gimple_ssa_operands (const struct function *fun) +{ + return &fun->gimple_df->ssa_operands; +} + +/* Given an edge_var_map V, return the PHI arg definition. */ + +static inline tree +redirect_edge_var_map_def (edge_var_map *v) +{ + return v->def; +} + +/* Given an edge_var_map V, return the PHI result. */ + +static inline tree +redirect_edge_var_map_result (edge_var_map *v) +{ + return v->result; +} + +/* Given an edge_var_map V, return the PHI arg location. */ + +static inline source_location +redirect_edge_var_map_location (edge_var_map *v) +{ + return v->locus; +} + + +/* Return an SSA_NAME node for variable VAR defined in statement STMT + in function cfun. */ + +static inline tree +make_ssa_name (tree var, gimple stmt) +{ + return make_ssa_name_fn (cfun, var, stmt); +} + +#endif /* _TREE_FLOW_INLINE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-flow.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-flow.h new file mode 100644 index 0000000..a36d4c7 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-flow.h @@ -0,0 +1,863 @@ +/* Data and Control Flow Analysis for Trees. + Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Diego Novillo <dnovillo@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + +#ifndef _TREE_FLOW_H +#define _TREE_FLOW_H 1 + +#include "bitmap.h" +#include "sbitmap.h" +#include "basic-block.h" +#include "hashtab.h" +#include "gimple.h" +#include "tree-ssa-operands.h" +#include "cgraph.h" +#include "ipa-reference.h" +#include "tree-ssa-alias.h" + + +/* Gimple dataflow datastructure. All publicly available fields shall have + gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable + fields should have gimple_set accessor. */ +struct GTY(()) gimple_df { + /* Array of all variables referenced in the function. */ + htab_t GTY((param_is (union tree_node))) referenced_vars; + + /* A vector of all the noreturn calls passed to modify_stmt. + cleanup_control_flow uses it to detect cases where a mid-block + indirect call has been turned into a noreturn call. When this + happens, all the instructions after the call are no longer + reachable and must be deleted as dead. */ + VEC(gimple,gc) *modified_noreturn_calls; + + /* Array of all SSA_NAMEs used in the function. */ + VEC(tree,gc) *ssa_names; + + /* Artificial variable used for the virtual operand FUD chain. */ + tree vop; + + /* The PTA solution for the ESCAPED artificial variable. */ + struct pt_solution escaped; + + /* A map of decls to artificial ssa-names that point to the partition + of the decl. */ + struct pointer_map_t * GTY((skip(""))) decls_to_pointers; + + /* Free list of SSA_NAMEs. */ + tree free_ssanames; + + /* Hashtable holding definition for symbol. If this field is not NULL, it + means that the first reference to this variable in the function is a + USE or a VUSE. In those cases, the SSA renamer creates an SSA name + for this variable with an empty defining statement. */ + htab_t GTY((param_is (union tree_node))) default_defs; + + /* Symbols whose SSA form needs to be updated or created for the first + time. */ + bitmap syms_to_rename; + + /* True if the code is in ssa form. */ + unsigned int in_ssa_p : 1; + + /* True if IPA points-to information was computed for this function. */ + unsigned int ipa_pta : 1; + + struct ssa_operands ssa_operands; +}; + +/* Accessors for internal use only. Generic code should use abstraction + provided by tree-flow-inline.h or specific modules. */ +#define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames +#define SSANAMES(fun) (fun)->gimple_df->ssa_names +#define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls +#define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs +#define SYMS_TO_RENAME(fun) (fun)->gimple_df->syms_to_rename + +typedef struct +{ + htab_t htab; + PTR *slot; + PTR *limit; +} htab_iterator; + +/* Iterate through the elements of hashtable HTAB, using htab_iterator ITER, + storing each element in RESULT, which is of type TYPE. */ +#define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \ + for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \ + !end_htab_p (&(ITER)); \ + RESULT = (TYPE) next_htab_element (&(ITER))) + +/*--------------------------------------------------------------------------- + Attributes for SSA_NAMEs. + + NOTE: These structures are stored in struct tree_ssa_name + but are only used by the tree optimizers, so it makes better sense + to declare them here to avoid recompiling unrelated files when + making changes. +---------------------------------------------------------------------------*/ + +/* Aliasing information for SSA_NAMEs representing pointer variables. */ + +struct GTY(()) ptr_info_def +{ + /* The points-to solution. */ + struct pt_solution pt; + + /* Alignment and misalignment of the pointer in bytes. Together + align and misalign specify low known bits of the pointer. + ptr & (align - 1) == misalign. */ + + /* The power-of-two byte alignment of the object this pointer + points into. This is usually DECL_ALIGN_UNIT for decls and + MALLOC_ABI_ALIGNMENT for allocated storage. */ + unsigned int align; + + /* The byte offset this pointer differs from the above alignment. */ + unsigned int misalign; +}; + + +/* It is advantageous to avoid things like life analysis for variables which + do not need PHI nodes. This enum describes whether or not a particular + variable may need a PHI node. */ + +enum need_phi_state { + /* This is the default. If we are still in this state after finding + all the definition and use sites, then we will assume the variable + needs PHI nodes. This is probably an overly conservative assumption. */ + NEED_PHI_STATE_UNKNOWN, + + /* This state indicates that we have seen one or more sets of the + variable in a single basic block and that the sets dominate all + uses seen so far. If after finding all definition and use sites + we are still in this state, then the variable does not need any + PHI nodes. */ + NEED_PHI_STATE_NO, + + /* This state indicates that we have either seen multiple definitions of + the variable in multiple blocks, or that we encountered a use in a + block that was not dominated by the block containing the set(s) of + this variable. This variable is assumed to need PHI nodes. */ + NEED_PHI_STATE_MAYBE +}; + + +struct GTY(()) var_ann_d { + /* Used when building base variable structures in a var_map. */ + unsigned base_var_processed : 1; + + /* Nonzero if this variable was used after SSA optimizations were + applied. We set this when translating out of SSA form. */ + unsigned used : 1; + + /* This field indicates whether or not the variable may need PHI nodes. + See the enum's definition for more detailed information about the + states. */ + ENUM_BITFIELD (need_phi_state) need_phi_state : 2; + + /* True for HEAP artificial variables. These variables represent + the memory area allocated by a call to malloc. */ + unsigned is_heapvar : 1; + + /* Used by var_map for the base index of ssa base variables. */ + unsigned base_index; + + /* During into-ssa and the dominator optimizer, this field holds the + current version of this variable (an SSA_NAME). */ + tree current_def; +}; + + +/* Immediate use lists are used to directly access all uses for an SSA + name and get pointers to the statement for each use. + + The structure ssa_use_operand_d consists of PREV and NEXT pointers + to maintain the list. A USE pointer, which points to address where + the use is located and a LOC pointer which can point to the + statement where the use is located, or, in the case of the root + node, it points to the SSA name itself. + + The list is anchored by an occurrence of ssa_operand_d *in* the + ssa_name node itself (named 'imm_uses'). This node is uniquely + identified by having a NULL USE pointer. and the LOC pointer + pointing back to the ssa_name node itself. This node forms the + base for a circular list, and initially this is the only node in + the list. + + Fast iteration allows each use to be examined, but does not allow + any modifications to the uses or stmts. + + Normal iteration allows insertion, deletion, and modification. the + iterator manages this by inserting a marker node into the list + immediately before the node currently being examined in the list. + this marker node is uniquely identified by having null stmt *and* a + null use pointer. + + When iterating to the next use, the iteration routines check to see + if the node after the marker has changed. if it has, then the node + following the marker is now the next one to be visited. if not, the + marker node is moved past that node in the list (visualize it as + bumping the marker node through the list). this continues until + the marker node is moved to the original anchor position. the + marker node is then removed from the list. + + If iteration is halted early, the marker node must be removed from + the list before continuing. */ +typedef struct immediate_use_iterator_d +{ + /* This is the current use the iterator is processing. */ + ssa_use_operand_t *imm_use; + /* This marks the last use in the list (use node from SSA_NAME) */ + ssa_use_operand_t *end_p; + /* This node is inserted and used to mark the end of the uses for a stmt. */ + ssa_use_operand_t iter_node; + /* This is the next ssa_name to visit. IMM_USE may get removed before + the next one is traversed to, so it must be cached early. */ + ssa_use_operand_t *next_imm_name; +} imm_use_iterator; + + +/* Use this iterator when simply looking at stmts. Adding, deleting or + modifying stmts will cause this iterator to malfunction. */ + +#define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ + for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \ + !end_readonly_imm_use_p (&(ITER)); \ + (void) ((DEST) = next_readonly_imm_use (&(ITER)))) + +/* Use this iterator to visit each stmt which has a use of SSAVAR. */ + +#define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ + for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ + !end_imm_use_stmt_p (&(ITER)); \ + (void) ((STMT) = next_imm_use_stmt (&(ITER)))) + +/* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to + do so will result in leaving a iterator marker node in the immediate + use list, and nothing good will come from that. */ +#define BREAK_FROM_IMM_USE_STMT(ITER) \ + { \ + end_imm_use_stmt_traverse (&(ITER)); \ + break; \ + } + + +/* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to + get access to each occurrence of ssavar on the stmt returned by + that iterator.. for instance: + + FOR_EACH_IMM_USE_STMT (stmt, iter, var) + { + FOR_EACH_IMM_USE_ON_STMT (use_p, iter) + { + SET_USE (use_p, blah); + } + update_stmt (stmt); + } */ + +#define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ + for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ + !end_imm_use_on_stmt_p (&(ITER)); \ + (void) ((DEST) = next_imm_use_on_stmt (&(ITER)))) + + + +typedef struct var_ann_d *var_ann_t; + +static inline var_ann_t var_ann (const_tree); +static inline var_ann_t get_var_ann (tree); +static inline void update_stmt (gimple); +static inline int get_lineno (const_gimple); + +/* Accessors for basic block annotations. */ +static inline gimple_seq phi_nodes (const_basic_block); +static inline void set_phi_nodes (basic_block, gimple_seq); + +/*--------------------------------------------------------------------------- + Global declarations +---------------------------------------------------------------------------*/ +struct int_tree_map { + unsigned int uid; + tree to; +}; + +extern unsigned int int_tree_map_hash (const void *); +extern int int_tree_map_eq (const void *, const void *); + +extern unsigned int uid_decl_map_hash (const void *); +extern int uid_decl_map_eq (const void *, const void *); + +typedef struct +{ + htab_iterator hti; +} referenced_var_iterator; + +/* This macro loops over all the referenced vars, one at a time, putting the + current var in VAR. Note: You are not allowed to add referenced variables + to the hashtable while using this macro. Doing so may cause it to behave + erratically. */ + +#define FOR_EACH_REFERENCED_VAR(FN, VAR, ITER) \ + for ((VAR) = first_referenced_var ((FN), &(ITER)); \ + !end_referenced_vars_p (&(ITER)); \ + (VAR) = next_referenced_var (&(ITER))) + +extern tree referenced_var_lookup (struct function *, unsigned int); +extern bool referenced_var_check_and_insert (tree); +#define num_referenced_vars htab_elements (gimple_referenced_vars (cfun)) + +#define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names)) +#define ssa_name(i) (VEC_index (tree, cfun->gimple_df->ssa_names, (i))) + +/* Macros for showing usage statistics. */ +#define SCALE(x) ((unsigned long) ((x) < 1024*10 \ + ? (x) \ + : ((x) < 1024*1024*10 \ + ? (x) / 1024 \ + : (x) / (1024*1024)))) + +#define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) + +#define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y)) + +/*--------------------------------------------------------------------------- + OpenMP Region Tree +---------------------------------------------------------------------------*/ + +/* Parallel region information. Every parallel and workshare + directive is enclosed between two markers, the OMP_* directive + and a corresponding OMP_RETURN statement. */ + +struct omp_region +{ + /* The enclosing region. */ + struct omp_region *outer; + + /* First child region. */ + struct omp_region *inner; + + /* Next peer region. */ + struct omp_region *next; + + /* Block containing the omp directive as its last stmt. */ + basic_block entry; + + /* Block containing the OMP_RETURN as its last stmt. */ + basic_block exit; + + /* Block containing the OMP_CONTINUE as its last stmt. */ + basic_block cont; + + /* If this is a combined parallel+workshare region, this is a list + of additional arguments needed by the combined parallel+workshare + library call. */ + VEC(tree,gc) *ws_args; + + /* The code for the omp directive of this region. */ + enum gimple_code type; + + /* Schedule kind, only used for OMP_FOR type regions. */ + enum omp_clause_schedule_kind sched_kind; + + /* True if this is a combined parallel+workshare region. */ + bool is_combined_parallel; +}; + +extern struct omp_region *root_omp_region; +extern struct omp_region *new_omp_region (basic_block, enum gimple_code, + struct omp_region *); +extern void free_omp_regions (void); +void omp_expand_local (basic_block); +extern tree find_omp_clause (tree, enum omp_clause_code); +tree copy_var_decl (tree, tree, tree); + +/*--------------------------------------------------------------------------- + Function prototypes +---------------------------------------------------------------------------*/ +/* In tree-cfg.c */ + +/* Location to track pending stmt for edge insertion. */ +#define PENDING_STMT(e) ((e)->insns.g) + +extern void delete_tree_cfg_annotations (void); +extern bool stmt_ends_bb_p (gimple); +extern bool is_ctrl_stmt (gimple); +extern bool is_ctrl_altering_stmt (gimple); +extern bool simple_goto_p (gimple); +extern bool stmt_can_make_abnormal_goto (gimple); +extern basic_block single_noncomplex_succ (basic_block bb); +extern void gimple_dump_bb (basic_block, FILE *, int, int); +extern void gimple_debug_bb (basic_block); +extern basic_block gimple_debug_bb_n (int); +extern void gimple_dump_cfg (FILE *, int); +extern void gimple_debug_cfg (int); +extern void dump_cfg_stats (FILE *); +extern void dot_cfg (void); +extern void debug_cfg_stats (void); +extern void debug_loops (int); +extern void debug_loop (struct loop *, int); +extern void debug_loop_num (unsigned, int); +extern void print_loops (FILE *, int); +extern void print_loops_bb (FILE *, basic_block, int, int); +extern void cleanup_dead_labels (void); +extern void group_case_labels (void); +extern gimple first_stmt (basic_block); +extern gimple last_stmt (basic_block); +extern gimple last_and_only_stmt (basic_block); +extern edge find_taken_edge (basic_block, tree); +extern basic_block label_to_block_fn (struct function *, tree); +#define label_to_block(t) (label_to_block_fn (cfun, t)) +extern void notice_special_calls (gimple); +extern void clear_special_calls (void); +extern void verify_stmts (void); +extern void verify_gimple (void); +extern void verify_types_in_gimple_seq (gimple_seq); +extern tree gimple_block_label (basic_block); +extern void extract_true_false_edges_from_block (basic_block, edge *, edge *); +extern bool gimple_duplicate_sese_region (edge, edge, basic_block *, unsigned, + basic_block *); +extern bool gimple_duplicate_sese_tail (edge, edge, basic_block *, unsigned, + basic_block *); +extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit, + VEC(basic_block,heap) **bbs_p); +extern void add_phi_args_after_copy_bb (basic_block); +extern void add_phi_args_after_copy (basic_block *, unsigned, edge); +extern bool gimple_purge_dead_eh_edges (basic_block); +extern bool gimple_purge_all_dead_eh_edges (const_bitmap); +extern bool gimple_purge_dead_abnormal_call_edges (basic_block); +extern bool gimple_purge_all_dead_abnormal_call_edges (const_bitmap); +extern tree gimplify_build1 (gimple_stmt_iterator *, enum tree_code, + tree, tree); +extern tree gimplify_build2 (gimple_stmt_iterator *, enum tree_code, + tree, tree, tree); +extern tree gimplify_build3 (gimple_stmt_iterator *, enum tree_code, + tree, tree, tree, tree); +extern void init_empty_tree_cfg (void); +extern void init_empty_tree_cfg_for_function (struct function *); +extern void fold_cond_expr_cond (void); +extern void make_abnormal_goto_edges (basic_block, bool); +extern void replace_uses_by (tree, tree); +extern void start_recording_case_labels (void); +extern void end_recording_case_labels (void); +extern basic_block move_sese_region_to_fn (struct function *, basic_block, + basic_block, tree); +void remove_edge_and_dominated_blocks (edge); +bool tree_node_can_be_shared (tree); + +/* In tree-cfgcleanup.c */ +extern bitmap cfgcleanup_altered_bbs; +extern bool cleanup_tree_cfg (void); + +/* In tree-pretty-print.c. */ +extern void dump_generic_bb (FILE *, basic_block, int, int); +extern int op_code_prio (enum tree_code); +extern int op_prio (const_tree); +extern const char *op_symbol_code (enum tree_code); + +/* In tree-dfa.c */ +extern var_ann_t create_var_ann (tree); +extern void renumber_gimple_stmt_uids (void); +extern void renumber_gimple_stmt_uids_in_blocks (basic_block *, int); +extern void dump_dfa_stats (FILE *); +extern void debug_dfa_stats (void); +extern void debug_referenced_vars (void); +extern void dump_referenced_vars (FILE *); +extern void dump_variable (FILE *, tree); +extern void debug_variable (tree); +extern tree get_virtual_var (tree); +extern bool add_referenced_var (tree); +extern void remove_referenced_var (tree); +extern void mark_symbols_for_renaming (gimple); +extern void find_new_referenced_vars (gimple); +extern tree make_rename_temp (tree, const char *); +extern void set_default_def (tree, tree); +extern tree gimple_default_def (struct function *, tree); +extern bool stmt_references_abnormal_ssa_name (gimple); +extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, + HOST_WIDE_INT *, HOST_WIDE_INT *); +extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *); +extern void find_referenced_vars_in (gimple); + +/* In tree-phinodes.c */ +extern void reserve_phi_args_for_new_edge (basic_block); +extern void add_phi_node_to_bb (gimple phi, basic_block bb); +extern gimple make_phi_node (tree var, int len); +extern gimple create_phi_node (tree, basic_block); +extern void add_phi_arg (gimple, tree, edge, source_location); +extern void remove_phi_args (edge); +extern void remove_phi_node (gimple_stmt_iterator *, bool); +extern void remove_phi_nodes (basic_block); +extern void init_phinodes (void); +extern void fini_phinodes (void); +extern void release_phi_node (gimple); +#ifdef GATHER_STATISTICS +extern void phinodes_print_statistics (void); +#endif + +/* In gimple-low.c */ +extern void record_vars_into (tree, tree); +extern void record_vars (tree); +extern bool gimple_seq_may_fallthru (gimple_seq); +extern bool gimple_stmt_may_fallthru (gimple); +extern bool gimple_check_call_matching_types (gimple, tree); + + +/* In tree-ssa.c */ + +/* Mapping for redirected edges. */ +struct _edge_var_map { + tree result; /* PHI result. */ + tree def; /* PHI arg definition. */ + source_location locus; /* PHI arg location. */ +}; +typedef struct _edge_var_map edge_var_map; + +DEF_VEC_O(edge_var_map); +DEF_VEC_ALLOC_O(edge_var_map, heap); + +/* A vector of var maps. */ +typedef VEC(edge_var_map, heap) *edge_var_map_vector; + +extern void init_tree_ssa (struct function *); +extern void redirect_edge_var_map_add (edge, tree, tree, source_location); +extern void redirect_edge_var_map_clear (edge); +extern void redirect_edge_var_map_dup (edge, edge); +extern edge_var_map_vector redirect_edge_var_map_vector (edge); +extern void redirect_edge_var_map_destroy (void); + +extern edge ssa_redirect_edge (edge, basic_block); +extern void flush_pending_stmts (edge); +extern void verify_ssa (bool); +extern void delete_tree_ssa (void); +extern bool ssa_undefined_value_p (tree); +extern void warn_uninit (enum opt_code, tree, const char *, void *); +extern unsigned int warn_uninitialized_vars (bool); +extern void execute_update_addresses_taken (void); + +/* Call-back function for walk_use_def_chains(). At each reaching + definition, a function with this prototype is called. */ +typedef bool (*walk_use_def_chains_fn) (tree, gimple, void *); + +extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); + +void insert_debug_temps_for_defs (gimple_stmt_iterator *); +void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree); +void reset_debug_uses (gimple); +void release_defs_bitset (bitmap toremove); + +/* In tree-into-ssa.c */ +void update_ssa (unsigned); +void delete_update_ssa (void); +void register_new_name_mapping (tree, tree); +tree create_new_def_for (tree, gimple, def_operand_p); +bool need_ssa_update_p (struct function *); +bool name_mappings_registered_p (void); +bool name_registered_for_update_p (tree); +bitmap ssa_names_to_replace (void); +void release_ssa_name_after_update_ssa (tree); +void compute_global_livein (bitmap, bitmap); +void mark_sym_for_renaming (tree); +void mark_set_for_renaming (bitmap); +bool symbol_marked_for_renaming (tree); +tree get_current_def (tree); +void set_current_def (tree, tree); + +/* In tree-ssanames.c */ +extern void init_ssanames (struct function *, int); +extern void fini_ssanames (void); +extern tree make_ssa_name_fn (struct function *, tree, gimple); +extern tree duplicate_ssa_name (tree, gimple); +extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *); +extern void release_ssa_name (tree); +extern void release_defs (gimple); +extern void replace_ssa_name_symbol (tree, tree); + +#ifdef GATHER_STATISTICS +extern void ssanames_print_statistics (void); +#endif + +/* In tree-ssa-ccp.c */ +tree fold_const_aggregate_ref (tree); + +/* In tree-ssa-dom.c */ +extern void dump_dominator_optimization_stats (FILE *); +extern void debug_dominator_optimization_stats (void); +int loop_depth_of_name (tree); +tree degenerate_phi_result (gimple); + +/* In tree-ssa-copy.c */ +extern void propagate_value (use_operand_p, tree); +extern void propagate_tree_value (tree *, tree); +extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); +extern void replace_exp (use_operand_p, tree); +extern bool may_propagate_copy (tree, tree); +extern bool may_propagate_copy_into_stmt (gimple, tree); +extern bool may_propagate_copy_into_asm (tree); + +/* Affine iv. */ + +typedef struct +{ + /* Iv = BASE + STEP * i. */ + tree base, step; + + /* True if this iv does not overflow. */ + bool no_overflow; +} affine_iv; + +/* Description of number of iterations of a loop. All the expressions inside + the structure can be evaluated at the end of the loop's preheader + (and due to ssa form, also anywhere inside the body of the loop). */ + +struct tree_niter_desc +{ + tree assumptions; /* The boolean expression. If this expression evaluates + to false, then the other fields in this structure + should not be used; there is no guarantee that they + will be correct. */ + tree may_be_zero; /* The boolean expression. If it evaluates to true, + the loop will exit in the first iteration (i.e. + its latch will not be executed), even if the niter + field says otherwise. */ + tree niter; /* The expression giving the number of iterations of + a loop (provided that assumptions == true and + may_be_zero == false), more precisely the number + of executions of the latch of the loop. */ + double_int max; /* The upper bound on the number of iterations of + the loop. */ + + /* The simplified shape of the exit condition. The loop exits if + CONTROL CMP BOUND is false, where CMP is one of NE_EXPR, + LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is + LE_EXPR and negative if CMP is GE_EXPR. This information is used + by loop unrolling. */ + affine_iv control; + tree bound; + enum tree_code cmp; +}; + +/* In tree-ssa-phiopt.c */ +bool empty_block_p (basic_block); +basic_block *blocks_in_phiopt_order (void); + +/* In tree-ssa-loop*.c */ + +unsigned int tree_ssa_lim (void); +unsigned int tree_ssa_unswitch_loops (void); +unsigned int canonicalize_induction_variables (void); +unsigned int tree_unroll_loops_completely (bool, bool); +unsigned int tree_ssa_prefetch_arrays (void); +void tree_ssa_iv_optimize (void); +unsigned tree_predictive_commoning (void); +tree canonicalize_loop_ivs (struct loop *, tree *, bool); +bool parallelize_loops (void); + +bool loop_only_exit_p (const struct loop *, const_edge); +bool number_of_iterations_exit (struct loop *, edge, + struct tree_niter_desc *niter, bool); +tree find_loop_niter (struct loop *, edge *); +tree loop_niter_by_eval (struct loop *, edge); +tree find_loop_niter_by_eval (struct loop *, edge *); +void estimate_numbers_of_iterations (bool); +bool array_at_struct_end_p (tree); +bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool); +bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool); + +bool nowrap_type_p (tree); +enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; +enum ev_direction scev_direction (const_tree); + +void free_numbers_of_iterations_estimates (void); +void free_numbers_of_iterations_estimates_loop (struct loop *); +void rewrite_into_loop_closed_ssa (bitmap, unsigned); +void verify_loop_closed_ssa (bool); +bool for_each_index (tree *, bool (*) (tree, tree *, void *), void *); +void create_iv (tree, tree, tree, struct loop *, gimple_stmt_iterator *, bool, + tree *, tree *); +basic_block split_loop_exit_edge (edge); +void standard_iv_increment_position (struct loop *, gimple_stmt_iterator *, + bool *); +basic_block ip_end_pos (struct loop *); +basic_block ip_normal_pos (struct loop *); +bool gimple_duplicate_loop_to_header_edge (struct loop *, edge, + unsigned int, sbitmap, + edge, VEC (edge, heap) **, + int); +struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *, edge); +void rename_variables_in_loop (struct loop *); +void rename_variables_in_bb (basic_block bb); +struct loop *tree_ssa_loop_version (struct loop *, tree, + basic_block *); +tree expand_simple_operations (tree); +void substitute_in_loop_info (struct loop *, tree, tree); +edge single_dom_exit (struct loop *); +bool can_unroll_loop_p (struct loop *loop, unsigned factor, + struct tree_niter_desc *niter); +void tree_unroll_loop (struct loop *, unsigned, + edge, struct tree_niter_desc *); +typedef void (*transform_callback)(struct loop *, void *); +void tree_transform_and_unroll_loop (struct loop *, unsigned, + edge, struct tree_niter_desc *, + transform_callback, void *); +bool contains_abnormal_ssa_name_p (tree); +bool stmt_dominates_stmt_p (gimple, gimple); +void mark_virtual_ops_for_renaming (gimple); + +/* In tree-ssa-dce.c */ +void mark_virtual_phi_result_for_renaming (gimple); + +/* In tree-ssa-threadedge.c */ +extern void threadedge_initialize_values (void); +extern void threadedge_finalize_values (void); +extern VEC(tree,heap) *ssa_name_values; +#define SSA_NAME_VALUE(x) \ + (SSA_NAME_VERSION(x) < VEC_length(tree, ssa_name_values) \ + ? VEC_index(tree, ssa_name_values, SSA_NAME_VERSION(x)) \ + : NULL_TREE) +extern void set_ssa_name_value (tree, tree); +extern bool potentially_threadable_block (basic_block); +extern void thread_across_edge (gimple, edge, bool, + VEC(tree, heap) **, tree (*) (gimple, gimple)); + +/* In tree-ssa-loop-im.c */ +/* The possibilities of statement movement. */ + +enum move_pos + { + MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */ + MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement + become executed -- memory accesses, ... */ + MOVE_POSSIBLE /* Unlimited movement. */ + }; +extern enum move_pos movement_possibility (gimple); +char *get_lsm_tmp_name (tree, unsigned); + +/* In tree-flow-inline.h */ +static inline void set_is_used (tree); +static inline bool unmodifiable_var_p (const_tree); +static inline bool ref_contains_array_ref (const_tree); + +/* In tree-eh.c */ +extern void make_eh_edges (gimple); +extern bool make_eh_dispatch_edges (gimple); +extern edge redirect_eh_edge (edge, basic_block); +extern void redirect_eh_dispatch_edge (gimple, edge, basic_block); +extern bool tree_could_trap_p (tree); +extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool, + bool, tree, bool *); +extern bool operation_could_trap_p (enum tree_code, bool, bool, tree); +extern bool stmt_could_throw_p (gimple); +extern bool tree_could_throw_p (tree); +extern bool stmt_can_throw_internal (gimple); +extern bool stmt_can_throw_external (gimple); +extern void add_stmt_to_eh_lp_fn (struct function *, gimple, int); +extern void add_stmt_to_eh_lp (gimple, int); +extern bool remove_stmt_from_eh_lp (gimple); +extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple); +extern int lookup_stmt_eh_lp_fn (struct function *, gimple); +extern int lookup_stmt_eh_lp (gimple); +extern bool maybe_clean_eh_stmt_fn (struct function *, gimple); +extern bool maybe_clean_eh_stmt (gimple); +extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple); +extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple, + struct function *, gimple, + struct pointer_map_t *, int); +extern bool maybe_duplicate_eh_stmt (gimple, gimple); +extern bool verify_eh_edges (gimple); +extern bool verify_eh_dispatch_edge (gimple); + +/* In tree-ssa-pre.c */ +struct pre_expr_d; +void add_to_value (unsigned int, struct pre_expr_d *); +void debug_value_expressions (unsigned int); +void print_value_expressions (FILE *, unsigned int); + +/* In tree-ssa-sink.c */ +bool is_hidden_global_store (gimple); + +/* In tree-loop-linear.c */ +extern void linear_transform_loops (void); +extern unsigned perfect_loop_nest_depth (struct loop *); + +/* In graphite.c */ +extern void graphite_transform_loops (void); + +/* In tree-data-ref.c */ +extern void tree_check_data_deps (void); + +/* In tree-ssa-loop-ivopts.c */ +bool expr_invariant_in_loop_p (struct loop *, tree); +bool stmt_invariant_in_loop_p (struct loop *, gimple); +bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode, + addr_space_t); +unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool); +bool may_be_nonaddressable_p (tree expr); + +/* In tree-ssa-threadupdate.c. */ +extern bool thread_through_all_blocks (bool); +extern void register_jump_thread (edge, edge); + +/* In gimplify.c */ +tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree); +tree force_gimple_operand (tree, gimple_seq *, bool, tree); +tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree, + gimple_predicate, tree, + bool, enum gsi_iterator_update); +tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree, + bool, enum gsi_iterator_update); +tree gimple_fold_indirect_ref (tree); + +/* In tree-ssa-live.c */ +extern void remove_unused_locals (void); +extern void dump_scope_blocks (FILE *, int); +extern void debug_scope_blocks (int); +extern void debug_scope_block (tree, int); + +/* In tree-ssa-address.c */ + +/* Description of a memory address. */ + +struct mem_address +{ + tree symbol, base, index, step, offset; +}; + +struct affine_tree_combination; +tree create_mem_ref (gimple_stmt_iterator *, tree, + struct affine_tree_combination *, tree, tree, tree, bool); +rtx addr_for_mem_ref (struct mem_address *, addr_space_t, bool); +void get_address_description (tree, struct mem_address *); +tree maybe_fold_tmr (tree); + +unsigned int execute_free_datastructures (void); +unsigned int execute_fixup_cfg (void); +bool fixup_noreturn_call (gimple stmt); + +/* In ipa-pure-const.c */ +void warn_function_noreturn (tree); + +/* In tree-ssa-ter.c */ +bool stmt_is_replaceable_p (gimple); + +#include "tree-flow-inline.h" + +void swap_tree_operands (gimple, tree *, tree *); + +#endif /* _TREE_FLOW_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-inline.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-inline.h new file mode 100644 index 0000000..66cc334 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-inline.h @@ -0,0 +1,193 @@ +/* Tree inlining hooks and declarations. + Copyright 2001, 2003, 2004, 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Alexandre Oliva <aoliva@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + +#ifndef GCC_TREE_INLINE_H +#define GCC_TREE_INLINE_H + +#include "vecir.h" /* For VEC(gimple,heap). */ + +struct cgraph_edge; + +/* Indicate the desired behavior wrt call graph edges. We can either + duplicate the edge (inlining, cloning), move the edge (versioning, + parallelization), or move the edges of the clones (saving). */ + +enum copy_body_cge_which +{ + CB_CGE_DUPLICATE, + CB_CGE_MOVE, + CB_CGE_MOVE_CLONES +}; + +/* Data required for function body duplication. */ + +typedef struct copy_body_data +{ + /* FUNCTION_DECL for function being inlined, or in general the + source function providing the original trees. */ + tree src_fn; + + /* FUNCTION_DECL for function being inlined into, or in general + the destination function receiving the new trees. */ + tree dst_fn; + + /* Callgraph node of the source function. */ + struct cgraph_node *src_node; + + /* Callgraph node of the destination function. */ + struct cgraph_node *dst_node; + + /* struct function for function being inlined. Usually this is the same + as DECL_STRUCT_FUNCTION (src_fn), but can be different if saved_cfg + and saved_eh are in use. */ + struct function *src_cfun; + + /* The VAR_DECL for the return value. */ + tree retvar; + + /* The map from local declarations in the inlined function to + equivalents in the function into which it is being inlined. */ + struct pointer_map_t *decl_map; + + /* Create a new decl to replace DECL in the destination function. */ + tree (*copy_decl) (tree, struct copy_body_data *); + + /* Current BLOCK. */ + tree block; + + /* GIMPLE_CALL if va arg parameter packs should be expanded or NULL + is not. */ + gimple gimple_call; + + /* Exception landing pad the inlined call lies in. */ + int eh_lp_nr; + + /* Maps region and landing pad structures from the function being copied + to duplicates created within the function we inline into. */ + struct pointer_map_t *eh_map; + + /* We use the same mechanism do all sorts of different things. Rather + than enumerating the different cases, we categorize the behavior + in the various situations. */ + + /* What to do with call graph edges. */ + enum copy_body_cge_which transform_call_graph_edges; + + /* True if a new CFG should be created. False for inlining, true for + everything else. */ + bool transform_new_cfg; + + /* True if RETURN_EXPRs should be transformed to just the contained + MODIFY_EXPR. The branch semantics of the return will be handled + by manipulating the CFG rather than a statement. */ + bool transform_return_to_modify; + + /* True if this statement will need to be regimplified. */ + bool regimplify; + + /* True if trees should not be unshared. */ + bool do_not_unshare; + + /* > 0 if we are remapping a type currently. */ + int remapping_type_depth; + + /* A function to be called when duplicating BLOCK nodes. */ + void (*transform_lang_insert_block) (tree); + + /* Statements that might be possibly folded. */ + struct pointer_set_t *statements_to_fold; + + /* Entry basic block to currently copied body. */ + struct basic_block_def *entry_bb; + + /* Debug statements that need processing. */ + VEC(gimple,heap) *debug_stmts; + + /* A map from local declarations in the inlined function to + equivalents in the function into which it is being inlined, where + the originals have been mapped to a value rather than to a + variable. */ + struct pointer_map_t *debug_map; +} copy_body_data; + +/* Weights of constructions for estimate_num_insns. */ + +typedef struct eni_weights_d +{ + /* Cost per call. */ + unsigned call_cost; + + /* Cost per call to a target specific builtin */ + unsigned target_builtin_call_cost; + + /* Cost of "expensive" div and mod operations. */ + unsigned div_mod_cost; + + /* Cost for omp construct. */ + unsigned omp_cost; + + /* Cost of return. */ + unsigned return_cost; + + /* True when time of statemnt should be estimated. Thus i.e + cost of switch statement is logarithmic rather than linear in number + of cases. */ + bool time_based; +} eni_weights; + +/* Weights that estimate_num_insns uses for heuristics in inlining. */ + +extern eni_weights eni_inlining_weights; + +/* Weights that estimate_num_insns uses to estimate the size of the + produced code. */ + +extern eni_weights eni_size_weights; + +/* Weights that estimate_num_insns uses to estimate the time necessary + to execute the produced code. */ + +extern eni_weights eni_time_weights; + +/* Function prototypes. */ + +extern tree copy_tree_body_r (tree *, int *, void *); +extern void insert_decl_map (copy_body_data *, tree, tree); + +unsigned int optimize_inline_calls (tree); +tree maybe_inline_call_in_expr (tree); +bool tree_inlinable_function_p (tree); +tree copy_tree_r (tree *, int *, void *); +tree copy_decl_no_change (tree decl, copy_body_data *id); +int estimate_move_cost (tree type); +int estimate_num_insns (gimple, eni_weights *); +int estimate_num_insns_fn (tree, eni_weights *); +int count_insns_seq (gimple_seq, eni_weights *); +bool tree_versionable_function_p (tree); +bool tree_can_inline_p (struct cgraph_edge *e); + +extern tree remap_decl (tree decl, copy_body_data *id); +extern tree remap_type (tree type, copy_body_data *id); +extern gimple_seq copy_gimple_seq_and_replace_locals (gimple_seq seq); + +extern HOST_WIDE_INT estimated_stack_frame_size (struct cgraph_node *); + +#endif /* GCC_TREE_INLINE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-iterator.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-iterator.h new file mode 100644 index 0000000..7cdd22a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-iterator.h @@ -0,0 +1,121 @@ +/* Iterator routines for manipulating GENERIC tree statement list. + Copyright (C) 2003, 2004, 2007, 2010 Free Software Foundation, Inc. + Contributed by Andrew MacLeod <amacleod@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + + +/* This file is dependent upon the implementation of tree's. It provides an + abstract interface to the tree objects such that if all tree creation and + manipulations are done through this interface, we can easily change the + implementation of tree's, and not impact other code. */ + +#ifndef GCC_TREE_ITERATOR_H +#define GCC_TREE_ITERATOR_H 1 + +/* Iterator object for GENERIC or GIMPLE TREE statements. */ + +typedef struct { + struct tree_statement_list_node *ptr; + tree container; +} tree_stmt_iterator; + +static inline tree_stmt_iterator +tsi_start (tree t) +{ + tree_stmt_iterator i; + + i.ptr = STATEMENT_LIST_HEAD (t); + i.container = t; + + return i; +} + +static inline tree_stmt_iterator +tsi_last (tree t) +{ + tree_stmt_iterator i; + + i.ptr = STATEMENT_LIST_TAIL (t); + i.container = t; + + return i; +} + +static inline bool +tsi_end_p (tree_stmt_iterator i) +{ + return i.ptr == NULL; +} + +static inline bool +tsi_one_before_end_p (tree_stmt_iterator i) +{ + return i.ptr != NULL && i.ptr->next == NULL; +} + +static inline void +tsi_next (tree_stmt_iterator *i) +{ + i->ptr = i->ptr->next; +} + +static inline void +tsi_prev (tree_stmt_iterator *i) +{ + i->ptr = i->ptr->prev; +} + +static inline tree * +tsi_stmt_ptr (tree_stmt_iterator i) +{ + return &i.ptr->stmt; +} + +static inline tree +tsi_stmt (tree_stmt_iterator i) +{ + return i.ptr->stmt; +} + +enum tsi_iterator_update +{ + TSI_NEW_STMT, /* Only valid when single statement is added, move + iterator to it. */ + TSI_SAME_STMT, /* Leave the iterator at the same statement. */ + TSI_CHAIN_START, /* Only valid when chain of statements is added, move + iterator to the first statement in the chain. */ + TSI_CHAIN_END, /* Only valid when chain of statements is added, move + iterator to the last statement in the chain. */ + TSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable for + linking other statements/chains of statements in + the same direction. */ +}; + +extern void tsi_link_before (tree_stmt_iterator *, tree, + enum tsi_iterator_update); +extern void tsi_link_after (tree_stmt_iterator *, tree, + enum tsi_iterator_update); + +extern void tsi_delink (tree_stmt_iterator *); + +extern tree alloc_stmt_list (void); +extern void free_stmt_list (tree); +extern void append_to_statement_list (tree, tree *); +extern void append_to_statement_list_force (tree, tree *); + +#endif /* GCC_TREE_ITERATOR_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-pass.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-pass.h new file mode 100644 index 0000000..08ef8f7 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-pass.h @@ -0,0 +1,652 @@ +/* Definitions for describing one tree-ssa optimization pass. + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Richard Henderson <rth@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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/>. */ + + +#ifndef GCC_TREE_PASS_H +#define GCC_TREE_PASS_H 1 + +#include "timevar.h" + +/* Different tree dump places. When you add new tree dump places, + extend the DUMP_FILES array in tree-dump.c. */ +enum tree_dump_index +{ + TDI_none, /* No dump */ + TDI_cgraph, /* dump function call graph. */ + TDI_tu, /* dump the whole translation unit. */ + TDI_class, /* dump class hierarchy. */ + TDI_original, /* dump each function before optimizing it */ + TDI_generic, /* dump each function after genericizing it */ + TDI_nested, /* dump each function after unnesting it */ + TDI_vcg, /* create a VCG graph file for each + function's flowgraph. */ + TDI_ada, /* dump declarations in Ada syntax. */ + TDI_tree_all, /* enable all the GENERIC/GIMPLE dumps. */ + TDI_rtl_all, /* enable all the RTL dumps. */ + TDI_ipa_all, /* enable all the IPA dumps. */ + + TDI_end +}; + +/* Bit masks to control dumping. Not all values are applicable to + all dumps. Add new ones at the end. When you define new + values, extend the DUMP_OPTIONS array in tree-dump.c */ +#define TDF_ADDRESS (1 << 0) /* dump node addresses */ +#define TDF_SLIM (1 << 1) /* don't go wild following links */ +#define TDF_RAW (1 << 2) /* don't unparse the function */ +#define TDF_DETAILS (1 << 3) /* show more detailed info about + each pass */ +#define TDF_STATS (1 << 4) /* dump various statistics about + each pass */ +#define TDF_BLOCKS (1 << 5) /* display basic block boundaries */ +#define TDF_VOPS (1 << 6) /* display virtual operands */ +#define TDF_LINENO (1 << 7) /* display statement line numbers */ +#define TDF_UID (1 << 8) /* display decl UIDs */ + +#define TDF_TREE (1 << 9) /* is a tree dump */ +#define TDF_RTL (1 << 10) /* is a RTL dump */ +#define TDF_IPA (1 << 11) /* is an IPA dump */ +#define TDF_STMTADDR (1 << 12) /* Address of stmt. */ + +#define TDF_GRAPH (1 << 13) /* a graph dump is being emitted */ +#define TDF_MEMSYMS (1 << 14) /* display memory symbols in expr. + Implies TDF_VOPS. */ + +#define TDF_DIAGNOSTIC (1 << 15) /* A dump to be put in a diagnostic + message. */ +#define TDF_VERBOSE (1 << 16) /* A dump that uses the full tree + dumper to print stmts. */ +#define TDF_RHS_ONLY (1 << 17) /* a flag to only print the RHS of + a gimple stmt. */ +#define TDF_ASMNAME (1 << 18) /* display asm names of decls */ +#define TDF_EH (1 << 19) /* display EH region number + holding this gimple statement. */ +#define TDF_NOUID (1 << 20) /* omit UIDs from dumps. */ +#define TDF_ALIAS (1 << 21) /* display alias information */ +#define TDF_ENUMERATE_LOCALS (1 << 22) /* Enumerate locals by uid. */ +#define TDF_CSELIB (1 << 23) /* Dump cselib details. */ + + +/* In tree-dump.c */ + +extern char *get_dump_file_name (int); +extern int dump_enabled_p (int); +extern int dump_initialized_p (int); +extern FILE *dump_begin (int, int *); +extern void dump_end (int, FILE *); +extern void dump_node (const_tree, int, FILE *); +extern int dump_switch_p (const char *); +extern const char *dump_flag_name (int); + +/* Global variables used to communicate with passes. */ +extern FILE *dump_file; +extern int dump_flags; +extern const char *dump_file_name; + +/* Return the dump_file_info for the given phase. */ +extern struct dump_file_info *get_dump_file_info (int); + +/* Optimization pass type. */ +enum opt_pass_type +{ + GIMPLE_PASS, + RTL_PASS, + SIMPLE_IPA_PASS, + IPA_PASS +}; + +/* Describe one pass; this is the common part shared across different pass + types. */ +struct opt_pass +{ + /* Optimization pass type. */ + enum opt_pass_type type; + + /* Terse name of the pass used as a fragment of the dump file + name. If the name starts with a star, no dump happens. */ + const char *name; + + /* If non-null, this pass and all sub-passes are executed only if + the function returns true. */ + bool (*gate) (void); + + /* This is the code to run. If null, then there should be sub-passes + otherwise this pass does nothing. The return value contains + TODOs to execute in addition to those in TODO_flags_finish. */ + unsigned int (*execute) (void); + + /* A list of sub-passes to run, dependent on gate predicate. */ + struct opt_pass *sub; + + /* Next in the list of passes to run, independent of gate predicate. */ + struct opt_pass *next; + + /* Static pass number, used as a fragment of the dump file name. */ + int static_pass_number; + + /* The timevar id associated with this pass. */ + /* ??? Ideally would be dynamically assigned. */ + timevar_id_t tv_id; + + /* Sets of properties input and output from this pass. */ + unsigned int properties_required; + unsigned int properties_provided; + unsigned int properties_destroyed; + + /* Flags indicating common sets things to do before and after. */ + unsigned int todo_flags_start; + unsigned int todo_flags_finish; +}; + +/* Description of GIMPLE pass. */ +struct gimple_opt_pass +{ + struct opt_pass pass; +}; + +/* Description of RTL pass. */ +struct rtl_opt_pass +{ + struct opt_pass pass; +}; + +struct varpool_node; +struct cgraph_node; +struct cgraph_node_set_def; +struct varpool_node_set_def; + +/* Description of IPA pass with generate summary, write, execute, read and + transform stages. */ +struct ipa_opt_pass_d +{ + struct opt_pass pass; + + /* IPA passes can analyze function body and variable initializers + using this hook and produce summary. */ + void (*generate_summary) (void); + + /* This hook is used to serialize IPA summaries on disk. */ + void (*write_summary) (struct cgraph_node_set_def *, + struct varpool_node_set_def *); + + /* This hook is used to deserialize IPA summaries from disk. */ + void (*read_summary) (void); + + /* This hook is used to serialize IPA optimization summaries on disk. */ + void (*write_optimization_summary) (struct cgraph_node_set_def *, + struct varpool_node_set_def *); + + /* This hook is used to deserialize IPA summaries from disk. */ + void (*read_optimization_summary) (void); + + /* Hook to convert gimple stmt uids into true gimple statements. The second + parameter is an array of statements indexed by their uid. */ + void (*stmt_fixup) (struct cgraph_node *, gimple *); + + /* Results of interprocedural propagation of an IPA pass is applied to + function body via this hook. */ + unsigned int function_transform_todo_flags_start; + unsigned int (*function_transform) (struct cgraph_node *); + void (*variable_transform) (struct varpool_node *); +}; + +/* Description of simple IPA pass. Simple IPA passes have just one execute + hook. */ +struct simple_ipa_opt_pass +{ + struct opt_pass pass; +}; + +/* Define a tree dump switch. */ +struct dump_file_info +{ + const char *suffix; /* suffix to give output file. */ + const char *swtch; /* command line switch */ + const char *glob; /* command line glob */ + int flags; /* user flags */ + int state; /* state of play */ + int num; /* dump file number */ +}; + +/* Pass properties. */ +#define PROP_gimple_any (1 << 0) /* entire gimple grammar */ +#define PROP_gimple_lcf (1 << 1) /* lowered control flow */ +#define PROP_gimple_leh (1 << 2) /* lowered eh */ +#define PROP_cfg (1 << 3) +#define PROP_referenced_vars (1 << 4) +#define PROP_ssa (1 << 5) +#define PROP_no_crit_edges (1 << 6) +#define PROP_rtl (1 << 7) +#define PROP_gimple_lomp (1 << 8) /* lowered OpenMP directives */ +#define PROP_cfglayout (1 << 9) /* cfglayout mode on RTL */ +#define PROP_gimple_lcx (1 << 10) /* lowered complex */ + +#define PROP_trees \ + (PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh | PROP_gimple_lomp) + +/* To-do flags. */ +#define TODO_dump_func (1 << 0) +#define TODO_ggc_collect (1 << 1) +#define TODO_verify_ssa (1 << 2) +#define TODO_verify_flow (1 << 3) +#define TODO_verify_stmts (1 << 4) +#define TODO_cleanup_cfg (1 << 5) +#define TODO_dump_cgraph (1 << 7) +#define TODO_remove_functions (1 << 8) +#define TODO_rebuild_frequencies (1 << 9) +#define TODO_verify_rtl_sharing (1 << 10) + +/* To-do flags for calls to update_ssa. */ + +/* Update the SSA form inserting PHI nodes for newly exposed symbols + and virtual names marked for updating. When updating real names, + only insert PHI nodes for a real name O_j in blocks reached by all + the new and old definitions for O_j. If the iterated dominance + frontier for O_j is not pruned, we may end up inserting PHI nodes + in blocks that have one or more edges with no incoming definition + for O_j. This would lead to uninitialized warnings for O_j's + symbol. */ +#define TODO_update_ssa (1 << 11) + +/* Update the SSA form without inserting any new PHI nodes at all. + This is used by passes that have either inserted all the PHI nodes + themselves or passes that need only to patch use-def and def-def + chains for virtuals (e.g., DCE). */ +#define TODO_update_ssa_no_phi (1 << 12) + +/* Insert PHI nodes everywhere they are needed. No pruning of the + IDF is done. This is used by passes that need the PHI nodes for + O_j even if it means that some arguments will come from the default + definition of O_j's symbol. + + WARNING: If you need to use this flag, chances are that your pass + may be doing something wrong. Inserting PHI nodes for an old name + where not all edges carry a new replacement may lead to silent + codegen errors or spurious uninitialized warnings. */ +#define TODO_update_ssa_full_phi (1 << 13) + +/* Passes that update the SSA form on their own may want to delegate + the updating of virtual names to the generic updater. Since FUD + chains are easier to maintain, this simplifies the work they need + to do. NOTE: If this flag is used, any OLD->NEW mappings for real + names are explicitly destroyed and only the symbols marked for + renaming are processed. */ +#define TODO_update_ssa_only_virtuals (1 << 14) + +/* Some passes leave unused local variables that can be removed from + cfun->local_decls. This reduces the size of dump files + and the memory footprint for VAR_DECLs. */ +#define TODO_remove_unused_locals (1 << 15) + +/* Call df_finish at the end of the pass. This is done after all of + the dumpers have been allowed to run so that they have access to + the instance before it is destroyed. */ +#define TODO_df_finish (1 << 17) + +/* Call df_verify at the end of the pass if checking is enabled. */ +#define TODO_df_verify (1 << 18) + +/* Internally used for the first instance of a pass. */ +#define TODO_mark_first_instance (1 << 19) + +/* Rebuild aliasing info. */ +#define TODO_rebuild_alias (1 << 20) + +/* Rebuild the addressable-vars bitmap and do register promotion. */ +#define TODO_update_address_taken (1 << 21) + +/* Rebuild the callgraph edges. */ +#define TODO_rebuild_cgraph_edges (1 << 22) + +/* Internally used in execute_function_todo(). */ +#define TODO_update_ssa_any \ + (TODO_update_ssa \ + | TODO_update_ssa_no_phi \ + | TODO_update_ssa_full_phi \ + | TODO_update_ssa_only_virtuals) + +#define TODO_verify_all \ + (TODO_verify_ssa | TODO_verify_flow | TODO_verify_stmts) + + +/* Register pass info. */ + +enum pass_positioning_ops +{ + PASS_POS_INSERT_AFTER, /* Insert after the reference pass. */ + PASS_POS_INSERT_BEFORE, /* Insert before the reference pass. */ + PASS_POS_REPLACE /* Replace the reference pass. */ +}; + +struct register_pass_info +{ + struct opt_pass *pass; /* New pass to register. */ + const char *reference_pass_name; /* Name of the reference pass for hooking + up the new pass. */ + int ref_pass_instance_number; /* Insert the pass at the specified + instance number of the reference pass. + Do it for every instance if it is 0. */ + enum pass_positioning_ops pos_op; /* how to insert the new pass. */ +}; + +extern void tree_lowering_passes (tree decl); + +extern struct gimple_opt_pass pass_mudflap_1; +extern struct gimple_opt_pass pass_mudflap_2; +extern struct gimple_opt_pass pass_lower_cf; +extern struct gimple_opt_pass pass_refactor_eh; +extern struct gimple_opt_pass pass_lower_eh; +extern struct gimple_opt_pass pass_lower_eh_dispatch; +extern struct gimple_opt_pass pass_lower_resx; +extern struct gimple_opt_pass pass_build_cfg; +extern struct gimple_opt_pass pass_direct_call_profile; +extern struct gimple_opt_pass pass_early_tree_profile; +extern struct gimple_opt_pass pass_referenced_vars; +extern struct gimple_opt_pass pass_cleanup_eh; +extern struct gimple_opt_pass pass_sra; +extern struct gimple_opt_pass pass_sra_early; +extern struct gimple_opt_pass pass_early_ipa_sra; +extern struct gimple_opt_pass pass_tail_recursion; +extern struct gimple_opt_pass pass_tail_calls; +extern struct gimple_opt_pass pass_tree_loop; +extern struct gimple_opt_pass pass_tree_loop_init; +extern struct gimple_opt_pass pass_lim; +extern struct gimple_opt_pass pass_tree_unswitch; +extern struct gimple_opt_pass pass_predcom; +extern struct gimple_opt_pass pass_iv_canon; +extern struct gimple_opt_pass pass_scev_cprop; +extern struct gimple_opt_pass pass_empty_loop; +extern struct gimple_opt_pass pass_record_bounds; +extern struct gimple_opt_pass pass_graphite; +extern struct gimple_opt_pass pass_graphite_transforms; +extern struct gimple_opt_pass pass_if_conversion; +extern struct gimple_opt_pass pass_loop_distribution; +extern struct gimple_opt_pass pass_vectorize; +extern struct gimple_opt_pass pass_slp_vectorize; +extern struct gimple_opt_pass pass_complete_unroll; +extern struct gimple_opt_pass pass_complete_unrolli; +extern struct gimple_opt_pass pass_parallelize_loops; +extern struct gimple_opt_pass pass_loop_prefetch; +extern struct gimple_opt_pass pass_iv_optimize; +extern struct gimple_opt_pass pass_tree_loop_done; +extern struct gimple_opt_pass pass_ch; +extern struct gimple_opt_pass pass_ccp; +extern struct gimple_opt_pass pass_phi_only_cprop; +extern struct gimple_opt_pass pass_build_ssa; +extern struct gimple_opt_pass pass_build_alias; +extern struct gimple_opt_pass pass_build_ealias; +extern struct gimple_opt_pass pass_dominator; +extern struct gimple_opt_pass pass_dce; +extern struct gimple_opt_pass pass_dce_loop; +extern struct gimple_opt_pass pass_cd_dce; +extern struct gimple_opt_pass pass_call_cdce; +extern struct gimple_opt_pass pass_merge_phi; +extern struct gimple_opt_pass pass_split_crit_edges; +extern struct gimple_opt_pass pass_pre; +extern struct gimple_opt_pass pass_profile; +extern struct gimple_opt_pass pass_strip_predict_hints; +extern struct gimple_opt_pass pass_lower_complex_O0; +extern struct gimple_opt_pass pass_lower_complex; +extern struct gimple_opt_pass pass_lower_vector; +extern struct gimple_opt_pass pass_lower_vector_ssa; +extern struct gimple_opt_pass pass_lower_omp; +extern struct gimple_opt_pass pass_diagnose_omp_blocks; +extern struct gimple_opt_pass pass_expand_omp; +extern struct gimple_opt_pass pass_expand_omp_ssa; +extern struct gimple_opt_pass pass_object_sizes; +extern struct gimple_opt_pass pass_fold_builtins; +extern struct gimple_opt_pass pass_stdarg; +extern struct gimple_opt_pass pass_early_warn_uninitialized; +extern struct gimple_opt_pass pass_late_warn_uninitialized; +extern struct gimple_opt_pass pass_cse_reciprocals; +extern struct gimple_opt_pass pass_cse_sincos; +extern struct gimple_opt_pass pass_optimize_bswap; +extern struct gimple_opt_pass pass_optimize_widening_mul; +extern struct gimple_opt_pass pass_warn_function_return; +extern struct gimple_opt_pass pass_warn_function_noreturn; +extern struct gimple_opt_pass pass_cselim; +extern struct gimple_opt_pass pass_phiopt; +extern struct gimple_opt_pass pass_forwprop; +extern struct gimple_opt_pass pass_phiprop; +extern struct gimple_opt_pass pass_tree_ifcombine; +extern struct gimple_opt_pass pass_dse; +extern struct gimple_opt_pass pass_nrv; +extern struct gimple_opt_pass pass_rename_ssa_copies; +extern struct gimple_opt_pass pass_rest_of_compilation; +extern struct gimple_opt_pass pass_sink_code; +extern struct gimple_opt_pass pass_fre; +extern struct gimple_opt_pass pass_check_data_deps; +extern struct gimple_opt_pass pass_copy_prop; +extern struct gimple_opt_pass pass_vrp; +extern struct gimple_opt_pass pass_uncprop; +extern struct gimple_opt_pass pass_return_slot; +extern struct gimple_opt_pass pass_reassoc; +extern struct gimple_opt_pass pass_rebuild_cgraph_edges; +extern struct gimple_opt_pass pass_remove_cgraph_callee_edges; +extern struct gimple_opt_pass pass_build_cgraph_edges; +extern struct gimple_opt_pass pass_local_pure_const; +extern struct gimple_opt_pass pass_tracer; +extern struct gimple_opt_pass pass_warn_unused_result; +extern struct gimple_opt_pass pass_split_functions; +extern struct gimple_opt_pass pass_feedback_split_functions; +extern struct gimple_opt_pass pass_threadsafe_analyze; +extern struct gimple_opt_pass pass_tree_convert_builtin_dispatch; +extern struct gimple_opt_pass pass_auto_clone; + +/* IPA Passes */ +extern struct simple_ipa_opt_pass pass_ipa_lower_emutls; +extern struct simple_ipa_opt_pass pass_ipa_function_and_variable_visibility; +extern struct simple_ipa_opt_pass pass_ipa_tree_profile; + +extern struct simple_ipa_opt_pass pass_early_local_passes; + +extern struct ipa_opt_pass_d pass_ipa_whole_program_visibility; +extern struct ipa_opt_pass_d pass_ipa_lto_gimple_out; +extern struct simple_ipa_opt_pass pass_ipa_increase_alignment; +extern struct simple_ipa_opt_pass pass_ipa_matrix_reorg; +extern struct ipa_opt_pass_d pass_ipa_inline; +extern struct simple_ipa_opt_pass pass_ipa_free_lang_data; +extern struct ipa_opt_pass_d pass_ipa_cp; +extern struct ipa_opt_pass_d pass_ipa_reference; +extern struct ipa_opt_pass_d pass_ipa_pure_const; +extern struct simple_ipa_opt_pass pass_ipa_type_escape; +extern struct simple_ipa_opt_pass pass_ipa_pta; +extern struct simple_ipa_opt_pass pass_ipa_struct_reorg; +extern struct ipa_opt_pass_d pass_ipa_lto_wpa_fixup; +extern struct ipa_opt_pass_d pass_ipa_lto_finish_out; +extern struct ipa_opt_pass_d pass_ipa_profile; +extern struct ipa_opt_pass_d pass_ipa_cdtor_merge; +extern struct simple_ipa_opt_pass pass_ipa_multiversion_dispatch; + +extern struct gimple_opt_pass pass_all_optimizations; +extern struct gimple_opt_pass pass_cleanup_cfg_post_optimizing; +extern struct gimple_opt_pass pass_init_datastructures; +extern struct gimple_opt_pass pass_fixup_cfg; + +extern struct rtl_opt_pass pass_expand; +extern struct rtl_opt_pass pass_init_function; +extern struct rtl_opt_pass pass_jump; +extern struct rtl_opt_pass pass_rtl_eh; +extern struct rtl_opt_pass pass_initial_value_sets; +extern struct rtl_opt_pass pass_unshare_all_rtl; +extern struct rtl_opt_pass pass_instantiate_virtual_regs; +extern struct rtl_opt_pass pass_rtl_fwprop; +extern struct rtl_opt_pass pass_rtl_fwprop_addr; +extern struct rtl_opt_pass pass_jump2; +extern struct rtl_opt_pass pass_lower_subreg; +extern struct rtl_opt_pass pass_cse; +extern struct rtl_opt_pass pass_fast_rtl_dce; +extern struct rtl_opt_pass pass_ud_rtl_dce; +extern struct rtl_opt_pass pass_rtl_dce; +extern struct rtl_opt_pass pass_rtl_dse1; +extern struct rtl_opt_pass pass_rtl_dse2; +extern struct rtl_opt_pass pass_rtl_dse3; +extern struct rtl_opt_pass pass_rtl_cprop; +extern struct rtl_opt_pass pass_rtl_pre; +extern struct rtl_opt_pass pass_rtl_hoist; +extern struct rtl_opt_pass pass_rtl_store_motion; +extern struct rtl_opt_pass pass_cse_after_global_opts; +extern struct rtl_opt_pass pass_rtl_ifcvt; +extern struct rtl_opt_pass pass_simplify_got; + +extern struct rtl_opt_pass pass_into_cfg_layout_mode; +extern struct rtl_opt_pass pass_outof_cfg_layout_mode; + +extern struct rtl_opt_pass pass_loop2; +extern struct rtl_opt_pass pass_rtl_loop_init; +extern struct rtl_opt_pass pass_rtl_move_loop_invariants; +extern struct rtl_opt_pass pass_rtl_unswitch; +extern struct rtl_opt_pass pass_rtl_unroll_and_peel_loops; +extern struct rtl_opt_pass pass_rtl_doloop; +extern struct rtl_opt_pass pass_rtl_loop_done; + +extern struct rtl_opt_pass pass_web; +extern struct rtl_opt_pass pass_cse2; +extern struct rtl_opt_pass pass_df_initialize_opt; +extern struct rtl_opt_pass pass_df_initialize_no_opt; +extern struct rtl_opt_pass pass_reginfo_init; +extern struct rtl_opt_pass pass_inc_dec; +extern struct rtl_opt_pass pass_stack_ptr_mod; +extern struct rtl_opt_pass pass_initialize_regs; +extern struct rtl_opt_pass pass_combine; +extern struct rtl_opt_pass pass_if_after_combine; +extern struct rtl_opt_pass pass_implicit_zee; +extern struct rtl_opt_pass pass_partition_blocks; +extern struct rtl_opt_pass pass_match_asm_constraints; +extern struct rtl_opt_pass pass_regmove; +extern struct rtl_opt_pass pass_split_all_insns; +extern struct rtl_opt_pass pass_fast_rtl_byte_dce; +extern struct rtl_opt_pass pass_lower_subreg2; +extern struct rtl_opt_pass pass_mode_switching; +extern struct rtl_opt_pass pass_sms; +extern struct rtl_opt_pass pass_sched; +extern struct rtl_opt_pass pass_ira; +extern struct rtl_opt_pass pass_postreload; +extern struct rtl_opt_pass pass_clean_state; +extern struct rtl_opt_pass pass_branch_prob; +extern struct rtl_opt_pass pass_value_profile_transformations; +extern struct rtl_opt_pass pass_postreload_cse; +extern struct rtl_opt_pass pass_gcse2; +extern struct rtl_opt_pass pass_split_after_reload; +extern struct rtl_opt_pass pass_branch_target_load_optimize1; +extern struct rtl_opt_pass pass_thread_prologue_and_epilogue; +extern struct rtl_opt_pass pass_stack_adjustments; +extern struct rtl_opt_pass pass_peephole2; +extern struct rtl_opt_pass pass_if_after_reload; +extern struct rtl_opt_pass pass_regrename; +extern struct rtl_opt_pass pass_cprop_hardreg; +extern struct rtl_opt_pass pass_reorder_blocks; +extern struct rtl_opt_pass pass_branch_target_load_optimize2; +extern struct rtl_opt_pass pass_leaf_regs; +extern struct rtl_opt_pass pass_split_before_sched2; +extern struct rtl_opt_pass pass_compare_elim_after_reload; +extern struct rtl_opt_pass pass_sched2; +extern struct rtl_opt_pass pass_stack_regs; +extern struct rtl_opt_pass pass_stack_regs_run; +extern struct rtl_opt_pass pass_df_finish; +extern struct rtl_opt_pass pass_compute_alignments; +extern struct rtl_opt_pass pass_duplicate_computed_gotos; +extern struct rtl_opt_pass pass_variable_tracking; +extern struct rtl_opt_pass pass_free_cfg; +extern struct rtl_opt_pass pass_machine_reorg; +extern struct rtl_opt_pass pass_cleanup_barriers; +extern struct rtl_opt_pass pass_delay_slots; +extern struct rtl_opt_pass pass_split_for_shorten_branches; +extern struct rtl_opt_pass pass_split_before_regstack; +extern struct rtl_opt_pass pass_convert_to_eh_region_ranges; +extern struct rtl_opt_pass pass_shorten_branches; +extern struct rtl_opt_pass pass_set_nothrow_function_flags; +extern struct rtl_opt_pass pass_final; +extern struct rtl_opt_pass pass_rtl_seqabstr; +extern struct gimple_opt_pass pass_release_ssa_names; +extern struct gimple_opt_pass pass_early_inline; +extern struct gimple_opt_pass pass_inline_parameters; +extern struct gimple_opt_pass pass_all_early_optimizations; +extern struct gimple_opt_pass pass_update_address_taken; +extern struct gimple_opt_pass pass_convert_switch; + +/* The root of the compilation pass tree, once constructed. */ +extern struct opt_pass *all_passes, *all_small_ipa_passes, *all_lowering_passes, + *all_regular_ipa_passes, *all_lto_gen_passes; + +/* Define a list of pass lists so that both passes.c and plugins can easily + find all the pass lists. */ +#define GCC_PASS_LISTS \ + DEF_PASS_LIST (all_lowering_passes) \ + DEF_PASS_LIST (all_small_ipa_passes) \ + DEF_PASS_LIST (all_regular_ipa_passes) \ + DEF_PASS_LIST (all_lto_gen_passes) \ + DEF_PASS_LIST (all_passes) + +#define DEF_PASS_LIST(LIST) PASS_LIST_NO_##LIST, +enum +{ + GCC_PASS_LISTS + PASS_LIST_NUM +}; +#undef DEF_PASS_LIST + +/* This is used by plugins, and should also be used in + passes.c:register_pass. */ +extern struct opt_pass **gcc_pass_lists[]; + +/* Current optimization pass. */ +extern struct opt_pass *current_pass; + +extern struct opt_pass * get_pass_for_id (int); +extern bool execute_one_pass (struct opt_pass *); +extern void execute_pass_list (struct opt_pass *); +extern void execute_ipa_pass_list (struct opt_pass *); +extern void execute_ipa_summary_passes (struct ipa_opt_pass_d *); +extern void execute_all_ipa_transforms (void); +extern void execute_all_ipa_stmt_fixups (struct cgraph_node *, gimple *); +extern bool pass_init_dump_file (struct opt_pass *); +extern void pass_fini_dump_file (struct opt_pass *); + +extern const char *get_current_pass_name (void); +extern void print_current_pass (FILE *); +extern void debug_pass (void); +extern void ipa_write_summaries (void); +extern void ipa_write_optimization_summaries (struct cgraph_node_set_def *, + struct varpool_node_set_def *); +extern void ipa_read_summaries (void); +extern void ipa_read_optimization_summaries (void); +extern void register_one_dump_file (struct opt_pass *); +extern bool function_called_by_processed_nodes_p (void); +extern void register_pass (struct register_pass_info *); + +/* Set to true if the pass is called the first time during compilation of the + current function. Note that using this information in the optimization + passes is considered not to be clean, and it should be avoided if possible. + This flag is currently used to prevent loops from being peeled repeatedly + in jump threading; it will be removed once we preserve loop structures + throughout the compilation -- we will be able to mark the affected loops + directly in jump threading, and avoid peeling them next time. */ +extern bool first_pass_instance; + +/* Declare for plugins. */ +extern void do_per_function_toporder (void (*) (void *), void *); + +extern void disable_pass (const char *); +extern void enable_pass (const char *); +extern void dump_passes (void); + +#endif /* GCC_TREE_PASS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-alias.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-alias.h new file mode 100644 index 0000000..8a9da0e --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-alias.h @@ -0,0 +1,144 @@ +/* Tree based alias analysis and alias oracle. + Copyright (C) 2008, 2010 Free Software Foundation, Inc. + Contributed by Richard Guenther <rguenther@suse.de> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, 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/>. */ + +#ifndef TREE_SSA_ALIAS_H +#define TREE_SSA_ALIAS_H + +#include "coretypes.h" + + +/* The points-to solution. + + The points-to solution is a union of pt_vars and the abstract + sets specified by the flags. */ +struct GTY(()) pt_solution +{ + /* Nonzero if points-to analysis couldn't determine where this pointer + is pointing to. */ + unsigned int anything : 1; + + /* Nonzero if the points-to set includes any global memory. Note that + even if this is zero pt_vars can still include global variables. */ + unsigned int nonlocal : 1; + + /* Nonzero if the points-to set includes the local escaped solution by + reference. */ + unsigned int escaped : 1; + + /* Nonzero if the points-to set includes the IPA escaped solution by + reference. */ + unsigned int ipa_escaped : 1; + + /* Nonzero if the points-to set includes 'nothing', the points-to set + includes memory at address NULL. */ + unsigned int null : 1; + + + /* Nonzero if the pt_vars bitmap includes a global variable. */ + unsigned int vars_contains_global : 1; + + /* Nonzero if the pt_vars bitmap includes a restrict tag variable. */ + unsigned int vars_contains_restrict : 1; + + /* Set of variables that this pointer may point to. */ + bitmap vars; +}; + + +/* Simplified and cached information about a memory reference tree. + Used by the alias-oracle internally and externally in alternate + interfaces. */ +typedef struct ao_ref_s +{ + /* The original full memory reference tree or NULL_TREE if that is + not available. */ + tree ref; + + /* The following fields are the decomposed reference as returned + by get_ref_base_and_extent. */ + /* The base object of the memory reference or NULL_TREE if all of + the following fields are not yet computed. */ + tree base; + /* The offset relative to the base. */ + HOST_WIDE_INT offset; + /* The size of the access. */ + HOST_WIDE_INT size; + /* The maximum possible extent of the access or -1 if unconstrained. */ + HOST_WIDE_INT max_size; + + /* The alias set of the access or -1 if not yet computed. */ + alias_set_type ref_alias_set; + + /* The alias set of the base object or -1 if not yet computed. */ + alias_set_type base_alias_set; +} ao_ref; + + +/* In tree-ssa-alias.c */ +extern void ao_ref_init (ao_ref *, tree); +extern void ao_ref_init_from_ptr_and_size (ao_ref *, tree, tree); +extern tree ao_ref_base (ao_ref *); +extern alias_set_type ao_ref_alias_set (ao_ref *); +extern bool ptr_deref_may_alias_global_p (tree); +extern bool ptr_derefs_may_alias_p (tree, tree); +extern bool refs_may_alias_p (tree, tree); +extern bool refs_may_alias_p_1 (ao_ref *, ao_ref *, bool); +extern bool refs_anti_dependent_p (tree, tree); +extern bool refs_output_dependent_p (tree, tree); +extern bool ref_maybe_used_by_stmt_p (gimple, tree); +extern bool stmt_may_clobber_ref_p (gimple, tree); +extern bool stmt_may_clobber_ref_p_1 (gimple, ao_ref *); +extern bool call_may_clobber_ref_p (gimple, tree); +extern bool stmt_kills_ref_p (gimple, tree); +extern tree get_continuation_for_phi (gimple, ao_ref *, bitmap *); +extern void *walk_non_aliased_vuses (ao_ref *, tree, + void *(*)(ao_ref *, tree, void *), + void *(*)(ao_ref *, tree, void *), void *); +extern unsigned int walk_aliased_vdefs (ao_ref *, tree, + bool (*)(ao_ref *, tree, void *), + void *, bitmap *); +extern struct ptr_info_def *get_ptr_info (tree); +extern void dump_alias_info (FILE *); +extern void debug_alias_info (void); +extern void dump_points_to_solution (FILE *, struct pt_solution *); +extern void dump_points_to_info_for (FILE *, tree); +extern void debug_points_to_info_for (tree); +extern void dump_alias_stats (FILE *); + + +/* In tree-ssa-structalias.c */ +extern unsigned int compute_may_aliases (void); +extern void delete_alias_heapvars (void); +extern bool pt_solution_empty_p (struct pt_solution *); +extern bool pt_solution_includes_global (struct pt_solution *); +extern bool pt_solution_includes (struct pt_solution *, const_tree); +extern bool pt_solutions_intersect (struct pt_solution *, struct pt_solution *); +extern bool pt_solutions_same_restrict_base (struct pt_solution *, + struct pt_solution *); +extern void pt_solution_reset (struct pt_solution *); +extern void pt_solution_set (struct pt_solution *, bitmap, bool, bool); +extern void pt_solution_set_var (struct pt_solution *, tree); + +extern void dump_pta_stats (FILE *); + +extern GTY(()) struct pt_solution ipa_escaped_pt; + + +#endif /* TREE_SSA_ALIAS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-operands.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-operands.h new file mode 100644 index 0000000..4c586f7 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-operands.h @@ -0,0 +1,233 @@ +/* SSA operand management for trees. + Copyright (C) 2003, 2005, 2006, 2007, 2008, 2010 + 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/>. */ + +#ifndef GCC_TREE_SSA_OPERANDS_H +#define GCC_TREE_SSA_OPERANDS_H + +/* Interface to SSA operands. */ + + +/* This represents a pointer to a DEF operand. */ +typedef tree *def_operand_p; + +/* This represents a pointer to a USE operand. */ +typedef ssa_use_operand_t *use_operand_p; + +/* NULL operand types. */ +#define NULL_USE_OPERAND_P ((use_operand_p)NULL) +#define NULL_DEF_OPERAND_P ((def_operand_p)NULL) + +/* This represents the DEF operands of a stmt. */ +struct def_optype_d +{ + struct def_optype_d *next; + tree *def_ptr; +}; +typedef struct def_optype_d *def_optype_p; + +/* This represents the USE operands of a stmt. */ +struct use_optype_d +{ + struct use_optype_d *next; + struct ssa_use_operand_d use_ptr; +}; +typedef struct use_optype_d *use_optype_p; + +/* This structure represents a variable sized buffer which is allocated by the + operand memory manager. Operands are suballocated out of this block. The + MEM array varies in size. */ + +struct GTY((chain_next("%h.next"), variable_size)) ssa_operand_memory_d { + struct ssa_operand_memory_d *next; + char mem[1]; +}; + +/* Per-function operand caches. */ +struct GTY(()) ssa_operands { + struct ssa_operand_memory_d *operand_memory; + unsigned operand_memory_index; + /* Current size of the operand memory buffer. */ + unsigned int ssa_operand_mem_size; + + bool ops_active; + + struct def_optype_d * GTY ((skip (""))) free_defs; + struct use_optype_d * GTY ((skip (""))) free_uses; +}; + +#define USE_FROM_PTR(PTR) get_use_from_ptr (PTR) +#define DEF_FROM_PTR(PTR) get_def_from_ptr (PTR) +#define SET_USE(USE, V) set_ssa_use_from_ptr (USE, V) +#define SET_DEF(DEF, V) ((*(DEF)) = (V)) + +#define USE_STMT(USE) (USE)->loc.stmt + +#define USE_OP_PTR(OP) (&((OP)->use_ptr)) +#define USE_OP(OP) (USE_FROM_PTR (USE_OP_PTR (OP))) + +#define DEF_OP_PTR(OP) ((OP)->def_ptr) +#define DEF_OP(OP) (DEF_FROM_PTR (DEF_OP_PTR (OP))) + +#define PHI_RESULT_PTR(PHI) gimple_phi_result_ptr (PHI) +#define PHI_RESULT(PHI) DEF_FROM_PTR (PHI_RESULT_PTR (PHI)) +#define SET_PHI_RESULT(PHI, V) SET_DEF (PHI_RESULT_PTR (PHI), (V)) + +#define PHI_ARG_DEF_PTR(PHI, I) gimple_phi_arg_imm_use_ptr ((PHI), (I)) +#define PHI_ARG_DEF(PHI, I) USE_FROM_PTR (PHI_ARG_DEF_PTR ((PHI), (I))) +#define SET_PHI_ARG_DEF(PHI, I, V) \ + SET_USE (PHI_ARG_DEF_PTR ((PHI), (I)), (V)) +#define PHI_ARG_DEF_FROM_EDGE(PHI, E) \ + PHI_ARG_DEF ((PHI), (E)->dest_idx) +#define PHI_ARG_DEF_PTR_FROM_EDGE(PHI, E) \ + PHI_ARG_DEF_PTR ((PHI), (E)->dest_idx) +#define PHI_ARG_INDEX_FROM_USE(USE) phi_arg_index_from_use (USE) + + +extern void init_ssa_operands (void); +extern void fini_ssa_operands (void); +extern void update_stmt_operands (gimple); +extern void free_stmt_operands (gimple); +extern bool verify_imm_links (FILE *f, tree var); + +extern void dump_immediate_uses (FILE *file); +extern void dump_immediate_uses_for (FILE *file, tree var); +extern void debug_immediate_uses (void); +extern void debug_immediate_uses_for (tree var); +extern void dump_decl_set (FILE *, bitmap); +extern void debug_decl_set (bitmap); + +extern bool ssa_operands_active (void); + +extern void unlink_stmt_vdef (gimple); + +enum ssa_op_iter_type { + ssa_op_iter_none = 0, + ssa_op_iter_tree, + ssa_op_iter_use, + ssa_op_iter_def +}; + +/* This structure is used in the operand iterator loops. It contains the + items required to determine which operand is retrieved next. During + optimization, this structure is scalarized, and any unused fields are + optimized away, resulting in little overhead. */ + +typedef struct ssa_operand_iterator_d +{ + bool done; + enum ssa_op_iter_type iter_type; + def_optype_p defs; + use_optype_p uses; + int phi_i; + int num_phi; + gimple phi_stmt; +} ssa_op_iter; + +/* These flags are used to determine which operands are returned during + execution of the loop. */ +#define SSA_OP_USE 0x01 /* Real USE operands. */ +#define SSA_OP_DEF 0x02 /* Real DEF operands. */ +#define SSA_OP_VUSE 0x04 /* VUSE operands. */ +#define SSA_OP_VDEF 0x08 /* VDEF operands. */ + +/* These are commonly grouped operand flags. */ +#define SSA_OP_VIRTUAL_USES (SSA_OP_VUSE) +#define SSA_OP_VIRTUAL_DEFS (SSA_OP_VDEF) +#define SSA_OP_ALL_VIRTUALS (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS) +#define SSA_OP_ALL_USES (SSA_OP_VIRTUAL_USES | SSA_OP_USE) +#define SSA_OP_ALL_DEFS (SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF) +#define SSA_OP_ALL_OPERANDS (SSA_OP_ALL_USES | SSA_OP_ALL_DEFS) + +/* This macro executes a loop over the operands of STMT specified in FLAG, + returning each operand as a 'tree' in the variable TREEVAR. ITER is an + ssa_op_iter structure used to control the loop. */ +#define FOR_EACH_SSA_TREE_OPERAND(TREEVAR, STMT, ITER, FLAGS) \ + for (TREEVAR = op_iter_init_tree (&(ITER), STMT, FLAGS); \ + !op_iter_done (&(ITER)); \ + (void) (TREEVAR = op_iter_next_tree (&(ITER)))) + +/* This macro executes a loop over the operands of STMT specified in FLAG, + returning each operand as a 'use_operand_p' in the variable USEVAR. + ITER is an ssa_op_iter structure used to control the loop. */ +#define FOR_EACH_SSA_USE_OPERAND(USEVAR, STMT, ITER, FLAGS) \ + for (USEVAR = op_iter_init_use (&(ITER), STMT, FLAGS); \ + !op_iter_done (&(ITER)); \ + USEVAR = op_iter_next_use (&(ITER))) + +/* This macro executes a loop over the operands of STMT specified in FLAG, + returning each operand as a 'def_operand_p' in the variable DEFVAR. + ITER is an ssa_op_iter structure used to control the loop. */ +#define FOR_EACH_SSA_DEF_OPERAND(DEFVAR, STMT, ITER, FLAGS) \ + for (DEFVAR = op_iter_init_def (&(ITER), STMT, FLAGS); \ + !op_iter_done (&(ITER)); \ + DEFVAR = op_iter_next_def (&(ITER))) + +/* This macro will execute a loop over all the arguments of a PHI which + match FLAGS. A use_operand_p is always returned via USEVAR. FLAGS + can be either SSA_OP_USE or SSA_OP_VIRTUAL_USES or SSA_OP_ALL_USES. */ +#define FOR_EACH_PHI_ARG(USEVAR, STMT, ITER, FLAGS) \ + for ((USEVAR) = op_iter_init_phiuse (&(ITER), STMT, FLAGS); \ + !op_iter_done (&(ITER)); \ + (USEVAR) = op_iter_next_use (&(ITER))) + + +/* This macro will execute a loop over a stmt, regardless of whether it is + a real stmt or a PHI node, looking at the USE nodes matching FLAGS. */ +#define FOR_EACH_PHI_OR_STMT_USE(USEVAR, STMT, ITER, FLAGS) \ + for ((USEVAR) = (gimple_code (STMT) == GIMPLE_PHI \ + ? op_iter_init_phiuse (&(ITER), STMT, FLAGS) \ + : op_iter_init_use (&(ITER), STMT, FLAGS)); \ + !op_iter_done (&(ITER)); \ + (USEVAR) = op_iter_next_use (&(ITER))) + +/* This macro will execute a loop over a stmt, regardless of whether it is + a real stmt or a PHI node, looking at the DEF nodes matching FLAGS. */ +#define FOR_EACH_PHI_OR_STMT_DEF(DEFVAR, STMT, ITER, FLAGS) \ + for ((DEFVAR) = (gimple_code (STMT) == GIMPLE_PHI \ + ? op_iter_init_phidef (&(ITER), STMT, FLAGS) \ + : op_iter_init_def (&(ITER), STMT, FLAGS)); \ + !op_iter_done (&(ITER)); \ + (DEFVAR) = op_iter_next_def (&(ITER))) + +/* This macro returns an operand in STMT as a tree if it is the ONLY + operand matching FLAGS. If there are 0 or more than 1 operand matching + FLAGS, then NULL_TREE is returned. */ +#define SINGLE_SSA_TREE_OPERAND(STMT, FLAGS) \ + single_ssa_tree_operand (STMT, FLAGS) + +/* This macro returns an operand in STMT as a use_operand_p if it is the ONLY + operand matching FLAGS. If there are 0 or more than 1 operand matching + FLAGS, then NULL_USE_OPERAND_P is returned. */ +#define SINGLE_SSA_USE_OPERAND(STMT, FLAGS) \ + single_ssa_use_operand (STMT, FLAGS) + +/* This macro returns an operand in STMT as a def_operand_p if it is the ONLY + operand matching FLAGS. If there are 0 or more than 1 operand matching + FLAGS, then NULL_DEF_OPERAND_P is returned. */ +#define SINGLE_SSA_DEF_OPERAND(STMT, FLAGS) \ + single_ssa_def_operand (STMT, FLAGS) + +/* This macro returns TRUE if there are no operands matching FLAGS in STMT. */ +#define ZERO_SSA_OPERANDS(STMT, FLAGS) zero_ssa_operands (STMT, FLAGS) + +/* This macro counts the number of operands in STMT matching FLAGS. */ +#define NUM_SSA_OPERANDS(STMT, FLAGS) num_ssa_operands (STMT, FLAGS) + +#endif /* GCC_TREE_SSA_OPERANDS_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-sccvn.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-sccvn.h new file mode 100644 index 0000000..bf99702 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree-ssa-sccvn.h @@ -0,0 +1,212 @@ +/* Tree SCC value numbering + Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Contributed by Daniel Berlin <dberlin@dberlin.org> + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, 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/>. */ + +#ifndef TREE_SSA_SCCVN_H +#define TREE_SSA_SCCVN_H + +/* In tree-ssa-sccvn.c */ +bool expressions_equal_p (tree, tree); + + +/* TOP of the VN lattice. */ +extern tree VN_TOP; + +/* N-ary operations in the hashtable consist of length operands, an + opcode, and a type. Result is the value number of the operation, + and hashcode is stored to avoid having to calculate it + repeatedly. */ + +typedef struct vn_nary_op_s +{ + /* Unique identify that all expressions with the same value have. */ + unsigned int value_id; + ENUM_BITFIELD(tree_code) opcode : 16; + unsigned length : 16; + hashval_t hashcode; + tree result; + tree type; + tree op[4]; +} *vn_nary_op_t; +typedef const struct vn_nary_op_s *const_vn_nary_op_t; + +/* Phi nodes in the hashtable consist of their non-VN_TOP phi + arguments, and the basic block the phi is in. Result is the value + number of the operation, and hashcode is stored to avoid having to + calculate it repeatedly. Phi nodes not in the same block are never + considered equivalent. */ + +typedef struct vn_phi_s +{ + /* Unique identifier that all expressions with the same value have. */ + unsigned int value_id; + hashval_t hashcode; + VEC (tree, heap) *phiargs; + basic_block block; + tree result; +} *vn_phi_t; +typedef const struct vn_phi_s *const_vn_phi_t; + +/* Reference operands only exist in reference operations structures. + They consist of an opcode, type, and some number of operands. For + a given opcode, some, all, or none of the operands may be used. + The operands are there to store the information that makes up the + portion of the addressing calculation that opcode performs. */ + +typedef struct vn_reference_op_struct +{ + enum tree_code opcode; + /* Constant offset this op adds or -1 if it is variable. */ + HOST_WIDE_INT off; + tree type; + tree op0; + tree op1; + tree op2; +} vn_reference_op_s; +typedef vn_reference_op_s *vn_reference_op_t; +typedef const vn_reference_op_s *const_vn_reference_op_t; + +DEF_VEC_O(vn_reference_op_s); +DEF_VEC_ALLOC_O(vn_reference_op_s, heap); + +/* A reference operation in the hashtable is representation as + the vuse, representing the memory state at the time of + the operation, and a collection of operands that make up the + addressing calculation. If two vn_reference_t's have the same set + of operands, they access the same memory location. We also store + the resulting value number, and the hashcode. */ + +typedef struct vn_reference_s +{ + /* Unique identifier that all expressions with the same value have. */ + unsigned int value_id; + hashval_t hashcode; + tree vuse; + alias_set_type set; + tree type; + VEC (vn_reference_op_s, heap) *operands; + tree result; +} *vn_reference_t; +typedef const struct vn_reference_s *const_vn_reference_t; + +typedef struct vn_constant_s +{ + unsigned int value_id; + hashval_t hashcode; + tree constant; +} *vn_constant_t; + +/* Hash the constant CONSTANT with distinguishing type incompatible + constants in the types_compatible_p sense. */ + +static inline hashval_t +vn_hash_constant_with_type (tree constant) +{ + tree type = TREE_TYPE (constant); + return (iterative_hash_expr (constant, 0) + + INTEGRAL_TYPE_P (type) + + (INTEGRAL_TYPE_P (type) + ? TYPE_PRECISION (type) + TYPE_UNSIGNED (type) : 0)); +} + +/* Compare the constants C1 and C2 with distinguishing type incompatible + constants in the types_compatible_p sense. */ + +static inline bool +vn_constant_eq_with_type (tree c1, tree c2) +{ + return (expressions_equal_p (c1, c2) + && types_compatible_p (TREE_TYPE (c1), TREE_TYPE (c2))); +} + +typedef struct vn_ssa_aux +{ + /* Value number. This may be an SSA name or a constant. */ + tree valnum; + /* Representative expression, if not a direct constant. */ + tree expr; + + /* Unique identifier that all expressions with the same value have. */ + unsigned int value_id; + + /* SCC information. */ + unsigned int dfsnum; + unsigned int low; + unsigned visited : 1; + unsigned on_sccstack : 1; + + /* Whether the representative expression contains constants. */ + unsigned has_constants : 1; + /* Whether the SSA_NAME has been value numbered already. This is + only saying whether visit_use has been called on it at least + once. It cannot be used to avoid visitation for SSA_NAME's + involved in non-singleton SCC's. */ + unsigned use_processed : 1; + + /* Whether the SSA_NAME has no defining statement and thus an + insertion of such with EXPR as definition is required before + a use can be created of it. */ + unsigned needs_insertion : 1; +} *vn_ssa_aux_t; + +typedef enum { VN_NOWALK, VN_WALK, VN_WALKREWRITE } vn_lookup_kind; + +/* Return the value numbering info for an SSA_NAME. */ +extern vn_ssa_aux_t VN_INFO (tree); +extern vn_ssa_aux_t VN_INFO_GET (tree); +tree vn_get_expr_for (tree); +bool run_scc_vn (vn_lookup_kind); +void free_scc_vn (void); +tree vn_nary_op_lookup (tree, vn_nary_op_t *); +tree vn_nary_op_lookup_stmt (gimple, vn_nary_op_t *); +tree vn_nary_op_lookup_pieces (unsigned int, enum tree_code, + tree, tree, tree, tree, tree, + vn_nary_op_t *); +vn_nary_op_t vn_nary_op_insert (tree, tree); +vn_nary_op_t vn_nary_op_insert_stmt (gimple, tree); +vn_nary_op_t vn_nary_op_insert_pieces (unsigned int, enum tree_code, + tree, tree, tree, tree, + tree, tree, unsigned int); +void vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **, + unsigned int *); +void copy_reference_ops_from_ref (tree, VEC(vn_reference_op_s, heap) **); +void copy_reference_ops_from_call (gimple, VEC(vn_reference_op_s, heap) **); +bool ao_ref_init_from_vn_reference (ao_ref *, alias_set_type, tree, + VEC (vn_reference_op_s, heap) *); +tree vn_reference_lookup_pieces (tree, alias_set_type, tree, + VEC (vn_reference_op_s, heap) *, + vn_reference_t *, vn_lookup_kind); +tree vn_reference_lookup (tree, tree, vn_lookup_kind, vn_reference_t *); +vn_reference_t vn_reference_insert (tree, tree, tree); +vn_reference_t vn_reference_insert_pieces (tree, alias_set_type, tree, + VEC (vn_reference_op_s, heap) *, + tree, unsigned int); + +hashval_t vn_nary_op_compute_hash (const vn_nary_op_t); +int vn_nary_op_eq (const void *, const void *); +bool vn_nary_may_trap (vn_nary_op_t); +hashval_t vn_reference_compute_hash (const vn_reference_t); +int vn_reference_eq (const void *, const void *); +unsigned int get_max_value_id (void); +unsigned int get_next_value_id (void); +unsigned int get_constant_value_id (tree); +unsigned int get_or_alloc_constant_value_id (tree); +bool value_id_constant_p (unsigned int); +tree fully_constant_vn_reference_p (vn_reference_t); +#endif /* TREE_SSA_SCCVN_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree.def new file mode 100644 index 0000000..eb94ad2 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree.def @@ -0,0 +1,1167 @@ +/* This file contains the definitions and documentation for the + tree codes used in GCC. + Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004, 2005, + 2006, 2007, 2008, 2009, 2010 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/>. */ + + +/* For tcc_references, tcc_expression, tcc_comparison, tcc_unary, + tcc_binary, and tcc_statement nodes, which use struct tree_exp, the + 4th element is the number of argument slots to allocate. This + determines the size of the tree node object. Other nodes use + different structures, and the size is determined by the tree_union + member structure; the 4th element should be zero. Languages that + define language-specific tcc_exceptional or tcc_constant codes must + define the tree_size langhook to say how big they are. + + These tree codes have been sorted so that the macros in tree.h that + check for various tree codes are optimized into range checks. This + gives a measurable performance improvement. When adding a new + code, consider its placement in relation to the other codes. */ + +/* Any erroneous construct is parsed into a node of this type. + This type of node is accepted without complaint in all contexts + by later parsing activities, to avoid multiple error messages + for one error. + No fields in these nodes are used except the TREE_CODE. */ +DEFTREECODE (ERROR_MARK, "error_mark", tcc_exceptional, 0) + +/* Used to represent a name (such as, in the DECL_NAME of a decl node). + Internally it looks like a STRING_CST node. + There is only one IDENTIFIER_NODE ever made for any particular name. + Use `get_identifier' to get it (or create it, the first time). */ +DEFTREECODE (IDENTIFIER_NODE, "identifier_node", tcc_exceptional, 0) + +/* Has the TREE_VALUE and TREE_PURPOSE fields. */ +/* These nodes are made into lists by chaining through the + TREE_CHAIN field. The elements of the list live in the + TREE_VALUE fields, while TREE_PURPOSE fields are occasionally + used as well to get the effect of Lisp association lists. */ +DEFTREECODE (TREE_LIST, "tree_list", tcc_exceptional, 0) + +/* These nodes contain an array of tree nodes. */ +DEFTREECODE (TREE_VEC, "tree_vec", tcc_exceptional, 0) + +/* A symbol binding block. These are arranged in a tree, + where the BLOCK_SUBBLOCKS field contains a chain of subblocks + chained through the BLOCK_CHAIN field. + BLOCK_SUPERCONTEXT points to the parent block. + For a block which represents the outermost scope of a function, it + points to the FUNCTION_DECL node. + BLOCK_VARS points to a chain of decl nodes. + BLOCK_CHAIN points to the next BLOCK at the same level. + BLOCK_ABSTRACT_ORIGIN points to the original (abstract) tree node which + this block is an instance of, or else is NULL to indicate that this + block is not an instance of anything else. When non-NULL, the value + could either point to another BLOCK node or it could point to a + FUNCTION_DECL node (e.g. in the case of a block representing the + outermost scope of a particular inlining of a function). + BLOCK_ABSTRACT is nonzero if the block represents an abstract + instance of a block (i.e. one which is nested within an abstract + instance of an inline function). + TREE_ASM_WRITTEN is nonzero if the block was actually referenced + in the generated assembly. */ +DEFTREECODE (BLOCK, "block", tcc_exceptional, 0) + +/* Each data type is represented by a tree node whose code is one of + the following: */ +/* Each node that represents a data type has a component TYPE_SIZE + containing a tree that is an expression for the size in bits. + The TYPE_MODE contains the machine mode for values of this type. + The TYPE_POINTER_TO field contains a type for a pointer to this type, + or zero if no such has been created yet. + The TYPE_NEXT_VARIANT field is used to chain together types + that are variants made by type modifiers such as "const" and "volatile". + The TYPE_MAIN_VARIANT field, in any member of such a chain, + points to the start of the chain. + The TYPE_NAME field contains info on the name used in the program + for this type (for GDB symbol table output). It is either a + TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE + in the case of structs, unions or enums that are known with a tag, + or zero for types that have no special name. + The TYPE_CONTEXT for any sort of type which could have a name or + which could have named members (e.g. tagged types in C/C++) will + point to the node which represents the scope of the given type, or + will be NULL_TREE if the type has "file scope". For most types, this + will point to a BLOCK node or a FUNCTION_DECL node, but it could also + point to a FUNCTION_TYPE node (for types whose scope is limited to the + formal parameter list of some function type specification) or it + could point to a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE node + (for C++ "member" types). + For non-tagged-types, TYPE_CONTEXT need not be set to anything in + particular, since any type which is of some type category (e.g. + an array type or a function type) which cannot either have a name + itself or have named members doesn't really have a "scope" per se. + The TREE_CHAIN field is used as a forward-references to names for + ENUMERAL_TYPE, RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE nodes; + see below. */ + +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE, + REAL_TYPE, POINTER_TYPE. */ + +/* An offset is a pointer relative to an object. + The TREE_TYPE field is the type of the object at the offset. + The TYPE_OFFSET_BASETYPE points to the node for the type of object + that the offset is relative to. */ +DEFTREECODE (OFFSET_TYPE, "offset_type", tcc_type, 0) + +/* C enums. The type node looks just like an INTEGER_TYPE node. + The symbols for the values of the enum type are defined by + CONST_DECL nodes, but the type does not point to them; + however, the TYPE_VALUES is a list in which each element's TREE_PURPOSE + is a name and the TREE_VALUE is the value (an INTEGER_CST node). */ +/* A forward reference `enum foo' when no enum named foo is defined yet + has zero (a null pointer) in its TYPE_SIZE. The tag name is in + the TYPE_NAME field. If the type is later defined, the normal + fields are filled in. + RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE forward refs are + treated similarly. */ +DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", tcc_type, 0) + +/* Boolean type (true or false are the only values). Looks like an + INTEGRAL_TYPE. */ +DEFTREECODE (BOOLEAN_TYPE, "boolean_type", tcc_type, 0) + +/* Integer types in all languages, including char in C. + Also used for sub-ranges of other discrete types. + Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive) + and TYPE_PRECISION (number of bits used by this type). + In the case of a subrange type in Pascal, the TREE_TYPE + of this will point at the supertype (another INTEGER_TYPE, + or an ENUMERAL_TYPE or BOOLEAN_TYPE). + Otherwise, the TREE_TYPE is zero. */ +DEFTREECODE (INTEGER_TYPE, "integer_type", tcc_type, 0) + +/* C's float and double. Different floating types are distinguished + by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */ +DEFTREECODE (REAL_TYPE, "real_type", tcc_type, 0) + +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. POINTER_TYPE, REFERENCE_TYPE. Note that this range + overlaps the previous range of ordered types. */ + +/* All pointer-to-x types have code POINTER_TYPE. + The TREE_TYPE points to the node for the type pointed to. */ +DEFTREECODE (POINTER_TYPE, "pointer_type", tcc_type, 0) + +/* A reference is like a pointer except that it is coerced + automatically to the value it points to. Used in C++. */ +DEFTREECODE (REFERENCE_TYPE, "reference_type", tcc_type, 0) + +/* The C++ decltype(nullptr) type. */ +DEFTREECODE (NULLPTR_TYPE, "nullptr_type", tcc_type, 0) + +/* _Fract and _Accum types in Embedded-C. Different fixed-point types + are distinguished by machine mode and by the TYPE_SIZE and the + TYPE_PRECISION. */ +DEFTREECODE (FIXED_POINT_TYPE, "fixed_point_type", tcc_type, 0) + +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE. */ + +/* Complex number types. The TREE_TYPE field is the data type + of the real and imaginary parts. It must be of scalar + arithmetic type, not including pointer type. */ +DEFTREECODE (COMPLEX_TYPE, "complex_type", tcc_type, 0) + +/* Vector types. The TREE_TYPE field is the data type of the vector + elements. The TYPE_PRECISION field is the number of subparts of + the vector. */ +DEFTREECODE (VECTOR_TYPE, "vector_type", tcc_type, 0) + +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE. + Note that this range overlaps the previous range. */ + +/* Types of arrays. Special fields: + TREE_TYPE Type of an array element. + TYPE_DOMAIN Type to index by. + Its range of values specifies the array length. + The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero + and holds the type to coerce a value of that array type to in C. + TYPE_STRING_FLAG indicates a string (in contrast to an array of chars) + in languages (such as Chill) that make a distinction. */ +/* Array types in C or Pascal */ +DEFTREECODE (ARRAY_TYPE, "array_type", tcc_type, 0) + +/* Struct in C, or record in Pascal. */ +/* Special fields: + TYPE_FIELDS chain of FIELD_DECLs for the fields of the struct, + and VAR_DECLs, TYPE_DECLs and CONST_DECLs for record-scope variables, + types and enumerators. + A few may need to be added for Pascal. */ +/* See the comment above, before ENUMERAL_TYPE, for how + forward references to struct tags are handled in C. */ +DEFTREECODE (RECORD_TYPE, "record_type", tcc_type, 0) + +/* Union in C. Like a struct, except that the offsets of the fields + will all be zero. */ +/* See the comment above, before ENUMERAL_TYPE, for how + forward references to union tags are handled in C. */ +DEFTREECODE (UNION_TYPE, "union_type", tcc_type, 0) /* C union type */ + +/* Similar to UNION_TYPE, except that the expressions in DECL_QUALIFIER + in each FIELD_DECL determine what the union contains. The first + field whose DECL_QUALIFIER expression is true is deemed to occupy + the union. */ +DEFTREECODE (QUAL_UNION_TYPE, "qual_union_type", tcc_type, 0) + +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. VOID_TYPE, FUNCTION_TYPE, METHOD_TYPE. */ + +/* The void type in C */ +DEFTREECODE (VOID_TYPE, "void_type", tcc_type, 0) + +/* Type of functions. Special fields: + TREE_TYPE type of value returned. + TYPE_ARG_TYPES list of types of arguments expected. + this list is made of TREE_LIST nodes. + Types of "Procedures" in languages where they are different from functions + have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */ +DEFTREECODE (FUNCTION_TYPE, "function_type", tcc_type, 0) + +/* METHOD_TYPE is the type of a function which takes an extra first + argument for "self", which is not present in the declared argument list. + The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE + is the type of "self". TYPE_ARG_TYPES is the real argument list, which + includes the hidden argument for "self". */ +DEFTREECODE (METHOD_TYPE, "method_type", tcc_type, 0) + +/* This is a language-specific kind of type. + Its meaning is defined by the language front end. + layout_type does not know how to lay this out, + so the front-end must do so manually. */ +DEFTREECODE (LANG_TYPE, "lang_type", tcc_type, 0) + +/* Expressions */ + +/* First, the constants. */ + +/* Contents are in TREE_INT_CST_LOW and TREE_INT_CST_HIGH fields, + 32 bits each, giving us a 64 bit constant capability. INTEGER_CST + nodes can be shared, and therefore should be considered read only. + They should be copied, before setting a flag such as TREE_OVERFLOW. + If an INTEGER_CST has TREE_OVERFLOW already set, it is known to be unique. + INTEGER_CST nodes are created for the integral types, for pointer + types and for vector and float types in some circumstances. */ +DEFTREECODE (INTEGER_CST, "integer_cst", tcc_constant, 0) + +/* Contents are in TREE_REAL_CST field. */ +DEFTREECODE (REAL_CST, "real_cst", tcc_constant, 0) + +/* Contents are in TREE_FIXED_CST field. */ +DEFTREECODE (FIXED_CST, "fixed_cst", tcc_constant, 0) + +/* Contents are in TREE_REALPART and TREE_IMAGPART fields, + whose contents are other constant nodes. */ +DEFTREECODE (COMPLEX_CST, "complex_cst", tcc_constant, 0) + +/* Contents are in TREE_VECTOR_CST_ELTS field. */ +DEFTREECODE (VECTOR_CST, "vector_cst", tcc_constant, 0) + +/* Contents are TREE_STRING_LENGTH and the actual contents of the string. */ +DEFTREECODE (STRING_CST, "string_cst", tcc_constant, 0) + +/* Declarations. All references to names are represented as ..._DECL + nodes. The decls in one binding context are chained through the + TREE_CHAIN field. Each DECL has a DECL_NAME field which contains + an IDENTIFIER_NODE. (Some decls, most often labels, may have zero + as the DECL_NAME). DECL_CONTEXT points to the node representing + the context in which this declaration has its scope. For + FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or + QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL, + PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this + points to either the FUNCTION_DECL for the containing function, the + RECORD_TYPE or UNION_TYPE for the containing type, or NULL_TREE or + a TRANSLATION_UNIT_DECL if the given decl has "file scope". + DECL_ABSTRACT_ORIGIN, if non-NULL, points to the original (abstract) + ..._DECL node of which this decl is an (inlined or template expanded) + instance. + The TREE_TYPE field holds the data type of the object, when relevant. + LABEL_DECLs have no data type. For TYPE_DECL, the TREE_TYPE field + contents are the type whose name is being declared. + The DECL_ALIGN, DECL_SIZE, + and DECL_MODE fields exist in decl nodes just as in type nodes. + They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes. + + DECL_FIELD_BIT_OFFSET holds an integer number of bits offset for + the location. DECL_VOFFSET holds an expression for a variable + offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer). + These fields are relevant only in FIELD_DECLs and PARM_DECLs. + + DECL_INITIAL holds the value to initialize a variable to, + or the value of a constant. For a function, it holds the body + (a node of type BLOCK representing the function's binding contour + and whose body contains the function's statements.) For a LABEL_DECL + in C, it is a flag, nonzero if the label's definition has been seen. + + PARM_DECLs use a special field: + DECL_ARG_TYPE is the type in which the argument is actually + passed, which may be different from its type within the function. + + FUNCTION_DECLs use four special fields: + DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments. + DECL_RESULT holds a RESULT_DECL node for the value of a function. + The DECL_RTL field is 0 for a function that returns no value. + (C functions returning void have zero here.) + The TREE_TYPE field is the type in which the result is actually + returned. This is usually the same as the return type of the + FUNCTION_DECL, but it may be a wider integer type because of + promotion. + DECL_FUNCTION_CODE is a code number that is nonzero for + built-in functions. Its value is an enum built_in_function + that says which built-in function it is. + + DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE + holds a line number. In some cases these can be the location of + a reference, if no definition has been seen. + + DECL_ABSTRACT is nonzero if the decl represents an abstract instance + of a decl (i.e. one which is nested within an abstract instance of a + inline function. */ + +DEFTREECODE (FUNCTION_DECL, "function_decl", tcc_declaration, 0) +DEFTREECODE (LABEL_DECL, "label_decl", tcc_declaration, 0) +/* The ordering of the following codes is optimized for the checking + macros in tree.h. Changing the order will degrade the speed of the + compiler. FIELD_DECL, VAR_DECL, CONST_DECL, PARM_DECL, + TYPE_DECL. */ +DEFTREECODE (FIELD_DECL, "field_decl", tcc_declaration, 0) +DEFTREECODE (VAR_DECL, "var_decl", tcc_declaration, 0) +DEFTREECODE (CONST_DECL, "const_decl", tcc_declaration, 0) +DEFTREECODE (PARM_DECL, "parm_decl", tcc_declaration, 0) +DEFTREECODE (TYPE_DECL, "type_decl", tcc_declaration, 0) +DEFTREECODE (RESULT_DECL, "result_decl", tcc_declaration, 0) + +/* A "declaration" of a debug temporary. It should only appear in + DEBUG stmts. */ +DEFTREECODE (DEBUG_EXPR_DECL, "debug_expr_decl", tcc_declaration, 0) + +/* A namespace declaration. Namespaces appear in DECL_CONTEXT of other + _DECLs, providing a hierarchy of names. */ +DEFTREECODE (NAMESPACE_DECL, "namespace_decl", tcc_declaration, 0) + +/* A declaration import. + The C++ FE uses this to represent a using-directive; eg: + "using namespace foo". + But it could be used to represent any declaration import construct. + Whenever a declaration import appears in a lexical block, the BLOCK node + representing that lexical block in GIMPLE will contain an IMPORTED_DECL + node, linked via BLOCK_VARS accessor of the said BLOCK. + For a given NODE which code is IMPORTED_DECL, + IMPORTED_DECL_ASSOCIATED_DECL (NODE) accesses the imported declaration. */ +DEFTREECODE (IMPORTED_DECL, "imported_decl", tcc_declaration, 0) + +/* A translation unit. This is not technically a declaration, since it + can't be looked up, but it's close enough. */ +DEFTREECODE (TRANSLATION_UNIT_DECL, "translation_unit_decl",\ + tcc_declaration, 0) + +/* References to storage. */ + +/* The ordering of the following codes is optimized for the classification + in handled_component_p. Keep them in a consecutive group. */ + +/* Value is structure or union component. + Operand 0 is the structure or union (an expression). + Operand 1 is the field (a node of type FIELD_DECL). + Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured + in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. */ +DEFTREECODE (COMPONENT_REF, "component_ref", tcc_reference, 3) + +/* Reference to a group of bits within an object. Similar to COMPONENT_REF + except the position is given explicitly rather than via a FIELD_DECL. + Operand 0 is the structure or union expression; + operand 1 is a tree giving the constant number of bits being referenced; + operand 2 is a tree giving the constant position of the first referenced bit. + The result type width has to match the number of bits referenced. + If the result type is integral, its signedness specifies how it is extended + to its mode width. */ +DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", tcc_reference, 3) + +/* Used only on an operand of complex type, these return + a value of the corresponding component type. */ +DEFTREECODE (REALPART_EXPR, "realpart_expr", tcc_reference, 1) +DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", tcc_reference, 1) + +/* Array indexing. + Operand 0 is the array; operand 1 is a (single) array index. + Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index. + Operand 3, if present, is the element size, measured in units of + the alignment of the element type. */ +DEFTREECODE (ARRAY_REF, "array_ref", tcc_reference, 4) + +/* Likewise, except that the result is a range ("slice") of the array. The + starting index of the resulting array is taken from operand 1 and the size + of the range is taken from the type of the expression. */ +DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", tcc_reference, 4) + +/* C unary `*' or Pascal `^'. One operand, an expression for a pointer. */ +DEFTREECODE (INDIRECT_REF, "indirect_ref", tcc_reference, 1) + +/* Used to represent lookup in a virtual method table which is dependent on + the runtime type of an object. Operands are: + OBJ_TYPE_REF_EXPR: An expression that evaluates the value to use. + OBJ_TYPE_REF_OBJECT: Is the object on whose behalf the lookup is + being performed. Through this the optimizers may be able to statically + determine the dynamic type of the object. + OBJ_TYPE_REF_TOKEN: An integer index to the virtual method table. */ +DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref", tcc_expression, 3) + +/* Constructor: return an aggregate value made from specified components. + In C, this is used only for structure and array initializers. + The operand is a sequence of component values made out of a VEC of + struct constructor_elt. + + For ARRAY_TYPE: + The field INDEX of each constructor_elt is the corresponding index. + If the index is a RANGE_EXPR, it is a short-hand for many nodes, + one for each index in the range. (If the corresponding field VALUE + has side-effects, they are evaluated once for each element. Wrap the + value in a SAVE_EXPR if you want to evaluate side effects only once.) + + For RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE: + The field INDEX of each node is a FIELD_DECL. */ +DEFTREECODE (CONSTRUCTOR, "constructor", tcc_exceptional, 0) + +/* The expression types are mostly straightforward, with the fourth argument + of DEFTREECODE saying how many operands there are. + Unless otherwise specified, the operands are expressions and the + types of all the operands and the expression must all be the same. */ + +/* Contains two expressions to compute, one followed by the other. + the first value is ignored. The second one's value is used. The + type of the first expression need not agree with the other types. */ +DEFTREECODE (COMPOUND_EXPR, "compound_expr", tcc_expression, 2) + +/* Assignment expression. Operand 0 is the what to set; 1, the new value. */ +DEFTREECODE (MODIFY_EXPR, "modify_expr", tcc_expression, 2) + +/* Initialization expression. Operand 0 is the variable to initialize; + Operand 1 is the initializer. This differs from MODIFY_EXPR in that any + reference to the referent of operand 0 within operand 1 is undefined. */ +DEFTREECODE (INIT_EXPR, "init_expr", tcc_expression, 2) + +/* For TARGET_EXPR, operand 0 is the target of an initialization, + operand 1 is the initializer for the target, which may be void + if simply expanding it initializes the target. + operand 2 is the cleanup for this node, if any. + operand 3 is the saved initializer after this node has been + expanded once; this is so we can re-expand the tree later. */ +DEFTREECODE (TARGET_EXPR, "target_expr", tcc_expression, 4) + +/* Conditional expression ( ... ? ... : ... in C). + Operand 0 is the condition. + Operand 1 is the then-value. + Operand 2 is the else-value. + Operand 0 may be of any type. + Operand 1 must have the same type as the entire expression, unless + it unconditionally throws an exception, in which case it should + have VOID_TYPE. The same constraints apply to operand 2. The + condition in operand 0 must be of integral type. + + In cfg gimple, if you do not have a selection expression, operands + 1 and 2 are NULL. The operands are then taken from the cfg edges. */ +DEFTREECODE (COND_EXPR, "cond_expr", tcc_expression, 3) + +/* Vector conditional expression. It is like COND_EXPR, but with + vector operands. + + A = VEC_COND_EXPR ( X < Y, B, C) + + means + + for (i=0; i<N; i++) + A[i] = X[i] < Y[i] ? B[i] : C[i]; +*/ +DEFTREECODE (VEC_COND_EXPR, "vec_cond_expr", tcc_expression, 3) + +/* Declare local variables, including making RTL and allocating space. + BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables. + BIND_EXPR_BODY is the body, the expression to be computed using + the variables. The value of operand 1 becomes that of the BIND_EXPR. + BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings + for debugging purposes. If this BIND_EXPR is actually expanded, + that sets the TREE_USED flag in the BLOCK. + + The BIND_EXPR is not responsible for informing parsers + about these variables. If the body is coming from the input file, + then the code that creates the BIND_EXPR is also responsible for + informing the parser of the variables. + + If the BIND_EXPR is ever expanded, its TREE_USED flag is set. + This tells the code for debugging symbol tables not to ignore the BIND_EXPR. + If the BIND_EXPR should be output for debugging but will not be expanded, + set the TREE_USED flag by hand. + + In order for the BIND_EXPR to be known at all, the code that creates it + must also install it as a subblock in the tree of BLOCK + nodes for the function. */ +DEFTREECODE (BIND_EXPR, "bind_expr", tcc_expression, 3) + +/* Function call. CALL_EXPRs are represented by variably-sized expression + nodes. There are at least three fixed operands. Operand 0 is an + INTEGER_CST node containing the total operand count, the number of + arguments plus 3. Operand 1 is the function, while operand 2 is + is static chain argument, or NULL. The remaining operands are the + arguments to the call. */ +DEFTREECODE (CALL_EXPR, "call_expr", tcc_vl_exp, 3) + +/* Specify a value to compute along with its corresponding cleanup. + Operand 0 is the cleanup expression. + The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR, + which must exist. This differs from TRY_CATCH_EXPR in that operand 1 + is always evaluated when cleanups are run. */ +DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", tcc_expression, 1) + +/* Specify a cleanup point. + Operand 0 is an expression that may have cleanups. If it does, those + cleanups are executed after the expression is expanded. + + Note that if the expression is a reference to storage, it is forced out + of memory before the cleanups are run. This is necessary to handle + cases where the cleanups modify the storage referenced; in the + expression 't.i', if 't' is a struct with an integer member 'i' and a + cleanup which modifies 'i', the value of the expression depends on + whether the cleanup is run before or after 't.i' is evaluated. When + expand_expr is run on 't.i', it returns a MEM. This is not good enough; + the value of 't.i' must be forced out of memory. + + As a consequence, the operand of a CLEANUP_POINT_EXPR must not have + BLKmode, because it will not be forced out of memory. */ +DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", tcc_expression, 1) + +/* The following code is used in languages that have types where some + field in an object of the type contains a value that is used in the + computation of another field's offset or size and/or the size of the + type. The positions and/or sizes of fields can vary from object to + object of the same type or even for one and the same object within + its scope. + + Record types with discriminants in Ada or schema types in Pascal are + examples of such types. This mechanism is also used to create "fat + pointers" for unconstrained array types in Ada; the fat pointer is a + structure one of whose fields is a pointer to the actual array type + and the other field is a pointer to a template, which is a structure + containing the bounds of the array. The bounds in the type pointed + to by the first field in the fat pointer refer to the values in the + template. + + When you wish to construct such a type you need "self-references" + that allow you to reference the object having this type from the + TYPE node, i.e. without having a variable instantiating this type. + + Such a "self-references" is done using a PLACEHOLDER_EXPR. This is + a node that will later be replaced with the object being referenced. + Its type is that of the object and selects which object to use from + a chain of references (see below). No other slots are used in the + PLACEHOLDER_EXPR. + + For example, if your type FOO is a RECORD_TYPE with a field BAR, + and you need the value of <variable>.BAR to calculate TYPE_SIZE + (FOO), just substitute <variable> above with a PLACEHOLDER_EXPR + whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with + the PLACEHOLDER_EXPR as the first operand (which has the correct + type). Later, when the size is needed in the program, the back-end + will find this PLACEHOLDER_EXPR and generate code to calculate the + actual size at run-time. In the following, we describe how this + calculation is done. + + When we wish to evaluate a size or offset, we check whether it contains a + PLACEHOLDER_EXPR. If it does, we call substitute_placeholder_in_expr + passing both that tree and an expression within which the object may be + found. The latter expression is the object itself in the simple case of + an Ada record with discriminant, but it can be the array in the case of an + unconstrained array. + + In the latter case, we need the fat pointer, because the bounds of + the array can only be accessed from it. However, we rely here on the + fact that the expression for the array contains the dereference of + the fat pointer that obtained the array pointer. */ + +/* Denotes a record to later be substituted before evaluating this expression. + The type of this expression is used to find the record to replace it. */ +DEFTREECODE (PLACEHOLDER_EXPR, "placeholder_expr", tcc_exceptional, 0) + +/* Simple arithmetic. */ +DEFTREECODE (PLUS_EXPR, "plus_expr", tcc_binary, 2) +DEFTREECODE (MINUS_EXPR, "minus_expr", tcc_binary, 2) +DEFTREECODE (MULT_EXPR, "mult_expr", tcc_binary, 2) + +/* Pointer addition. The first operand is always a pointer and the + second operand is an integer of type sizetype. */ +DEFTREECODE (POINTER_PLUS_EXPR, "pointer_plus_expr", tcc_binary, 2) + +/* Division for integer result that rounds the quotient toward zero. */ +DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr", tcc_binary, 2) + +/* Division for integer result that rounds the quotient toward infinity. */ +DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr", tcc_binary, 2) + +/* Division for integer result that rounds toward minus infinity. */ +DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr", tcc_binary, 2) + +/* Division for integer result that rounds toward nearest integer. */ +DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr", tcc_binary, 2) + +/* Four kinds of remainder that go with the four kinds of division. */ +DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr", tcc_binary, 2) +DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr", tcc_binary, 2) +DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr", tcc_binary, 2) +DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr", tcc_binary, 2) + +/* Division for real result. */ +DEFTREECODE (RDIV_EXPR, "rdiv_expr", tcc_binary, 2) + +/* Division which is not supposed to need rounding. + Used for pointer subtraction in C. */ +DEFTREECODE (EXACT_DIV_EXPR, "exact_div_expr", tcc_binary, 2) + +/* Conversion of real to fixed point by truncation. */ +DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr", tcc_unary, 1) + +/* Conversion of an integer to a real. */ +DEFTREECODE (FLOAT_EXPR, "float_expr", tcc_unary, 1) + +/* Unary negation. */ +DEFTREECODE (NEGATE_EXPR, "negate_expr", tcc_unary, 1) + +/* Minimum and maximum values. When used with floating point, if both + operands are zeros, or if either operand is NaN, then it is unspecified + which of the two operands is returned as the result. */ +DEFTREECODE (MIN_EXPR, "min_expr", tcc_binary, 2) +DEFTREECODE (MAX_EXPR, "max_expr", tcc_binary, 2) + +/* Represents the absolute value of the operand. + + An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE. The + operand of the ABS_EXPR must have the same type. */ +DEFTREECODE (ABS_EXPR, "abs_expr", tcc_unary, 1) + +/* Shift operations for shift and rotate. + Shift means logical shift if done on an + unsigned type, arithmetic shift if done on a signed type. + The second operand is the number of bits to + shift by; it need not be the same type as the first operand and result. + Note that the result is undefined if the second operand is larger + than or equal to the first operand's type size. + + The first operand of a shift can have either an integer or a + (non-integer) fixed-point type. We follow the ISO/IEC TR 18037:2004 + semantics for the latter. + + Rotates are defined for integer types only. */ +DEFTREECODE (LSHIFT_EXPR, "lshift_expr", tcc_binary, 2) +DEFTREECODE (RSHIFT_EXPR, "rshift_expr", tcc_binary, 2) +DEFTREECODE (LROTATE_EXPR, "lrotate_expr", tcc_binary, 2) +DEFTREECODE (RROTATE_EXPR, "rrotate_expr", tcc_binary, 2) + +/* Bitwise operations. Operands have same mode as result. */ +DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", tcc_binary, 2) +DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", tcc_binary, 2) +DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", tcc_binary, 2) +DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", tcc_unary, 1) + +/* ANDIF and ORIF allow the second operand not to be computed if the + value of the expression is determined from the first operand. AND, + OR, and XOR always compute the second operand whether its value is + needed or not (for side effects). The operand may have + BOOLEAN_TYPE or INTEGER_TYPE. In either case, the argument will be + either zero or one. For example, a TRUTH_NOT_EXPR will never have + an INTEGER_TYPE VAR_DECL as its argument; instead, a NE_EXPR will be + used to compare the VAR_DECL to zero, thereby obtaining a node with + value zero or one. */ +DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", tcc_expression, 2) +DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr", tcc_expression, 2) +DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", tcc_expression, 2) +DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr", tcc_expression, 2) +DEFTREECODE (TRUTH_XOR_EXPR, "truth_xor_expr", tcc_expression, 2) +DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", tcc_expression, 1) + +/* Relational operators. + `EQ_EXPR' and `NE_EXPR' are allowed for any types. + The others are allowed only for integer (or pointer or enumeral) + or real types. + In all cases the operands will have the same type, + and the value is always the type used by the language for booleans. */ +DEFTREECODE (LT_EXPR, "lt_expr", tcc_comparison, 2) +DEFTREECODE (LE_EXPR, "le_expr", tcc_comparison, 2) +DEFTREECODE (GT_EXPR, "gt_expr", tcc_comparison, 2) +DEFTREECODE (GE_EXPR, "ge_expr", tcc_comparison, 2) +DEFTREECODE (EQ_EXPR, "eq_expr", tcc_comparison, 2) +DEFTREECODE (NE_EXPR, "ne_expr", tcc_comparison, 2) + +/* Additional relational operators for floating point unordered. */ +DEFTREECODE (UNORDERED_EXPR, "unordered_expr", tcc_comparison, 2) +DEFTREECODE (ORDERED_EXPR, "ordered_expr", tcc_comparison, 2) + +/* These are equivalent to unordered or ... */ +DEFTREECODE (UNLT_EXPR, "unlt_expr", tcc_comparison, 2) +DEFTREECODE (UNLE_EXPR, "unle_expr", tcc_comparison, 2) +DEFTREECODE (UNGT_EXPR, "ungt_expr", tcc_comparison, 2) +DEFTREECODE (UNGE_EXPR, "unge_expr", tcc_comparison, 2) +DEFTREECODE (UNEQ_EXPR, "uneq_expr", tcc_comparison, 2) + +/* This is the reverse of uneq_expr. */ +DEFTREECODE (LTGT_EXPR, "ltgt_expr", tcc_comparison, 2) + +DEFTREECODE (RANGE_EXPR, "range_expr", tcc_binary, 2) + +/* Represents a re-association barrier for floating point expressions + like explicit parenthesis in fortran. */ +DEFTREECODE (PAREN_EXPR, "paren_expr", tcc_unary, 1) + +/* Represents a conversion of type of a value. + All conversions, including implicit ones, must be + represented by CONVERT_EXPR or NOP_EXPR nodes. */ +DEFTREECODE (CONVERT_EXPR, "convert_expr", tcc_unary, 1) + +/* Conversion of a pointer value to a pointer to a different + address space. */ +DEFTREECODE (ADDR_SPACE_CONVERT_EXPR, "addr_space_convert_expr", tcc_unary, 1) + +/* Conversion of a fixed-point value to an integer, a real, or a fixed-point + value. Or conversion of a fixed-point value from an integer, a real, or + a fixed-point value. */ +DEFTREECODE (FIXED_CONVERT_EXPR, "fixed_convert_expr", tcc_unary, 1) + +/* Represents a conversion expected to require no code to be generated. */ +DEFTREECODE (NOP_EXPR, "nop_expr", tcc_unary, 1) + +/* Value is same as argument, but guaranteed not an lvalue. */ +DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", tcc_unary, 1) + +/* Represents viewing something of one type as being of a second type. + This corresponds to an "Unchecked Conversion" in Ada and roughly to + the idiom *(type2 *)&X in C. The only operand is the value to be + viewed as being of another type. It is undefined if the type of the + input and of the expression have different sizes. + + This code may also be used within the LHS of a MODIFY_EXPR, in which + case no actual data motion may occur. TREE_ADDRESSABLE will be set in + this case and GCC must abort if it could not do the operation without + generating insns. */ +DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", tcc_reference, 1) + +/* A COMPOUND_LITERAL_EXPR represents a literal that is placed in a DECL. The + COMPOUND_LITERAL_EXPR_DECL_EXPR is the a DECL_EXPR containing the decl + for the anonymous object represented by the COMPOUND_LITERAL; + the DECL_INITIAL of that decl is the CONSTRUCTOR that initializes + the compound literal. */ +DEFTREECODE (COMPOUND_LITERAL_EXPR, "compound_literal_expr", tcc_expression, 1) + +/* Represents something we computed once and will use multiple times. + First operand is that expression. After it is evaluated once, it + will be replaced by the temporary variable that holds the value. */ +DEFTREECODE (SAVE_EXPR, "save_expr", tcc_expression, 1) + +/* & in C. Value is the address at which the operand's value resides. + Operand may have any mode. Result mode is Pmode. */ +DEFTREECODE (ADDR_EXPR, "addr_expr", tcc_expression, 1) + +/* Operand0 is a function constant; result is part N of a function + descriptor of type ptr_mode. */ +DEFTREECODE (FDESC_EXPR, "fdesc_expr", tcc_expression, 2) + +/* Given two real or integer operands of the same type, + returns a complex value of the corresponding complex type. */ +DEFTREECODE (COMPLEX_EXPR, "complex_expr", tcc_binary, 2) + +/* Complex conjugate of operand. Used only on complex types. */ +DEFTREECODE (CONJ_EXPR, "conj_expr", tcc_unary, 1) + +/* Nodes for ++ and -- in C. + The second arg is how much to increment or decrement by. + For a pointer, it would be the size of the object pointed to. */ +DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr", tcc_expression, 2) +DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr", tcc_expression, 2) +DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", tcc_expression, 2) +DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", tcc_expression, 2) + +/* Used to implement `va_arg'. */ +DEFTREECODE (VA_ARG_EXPR, "va_arg_expr", tcc_expression, 1) + +/* Evaluate operand 1. If and only if an exception is thrown during + the evaluation of operand 1, evaluate operand 2. + + This differs from TRY_FINALLY_EXPR in that operand 2 is not evaluated + on a normal or jump exit, only on an exception. */ +DEFTREECODE (TRY_CATCH_EXPR, "try_catch_expr", tcc_statement, 2) + +/* Evaluate the first operand. + The second operand is a cleanup expression which is evaluated + on any exit (normal, exception, or jump out) from this expression. */ +DEFTREECODE (TRY_FINALLY_EXPR, "try_finally", tcc_statement, 2) + +/* These types of expressions have no useful value, + and always have side effects. */ + +/* Used to represent a local declaration. The operand is DECL_EXPR_DECL. */ +DEFTREECODE (DECL_EXPR, "decl_expr", tcc_statement, 1) + +/* A label definition, encapsulated as a statement. + Operand 0 is the LABEL_DECL node for the label that appears here. + The type should be void and the value should be ignored. */ +DEFTREECODE (LABEL_EXPR, "label_expr", tcc_statement, 1) + +/* GOTO. Operand 0 is a LABEL_DECL node or an expression. + The type should be void and the value should be ignored. */ +DEFTREECODE (GOTO_EXPR, "goto_expr", tcc_statement, 1) + +/* RETURN. Evaluates operand 0, then returns from the current function. + Presumably that operand is an assignment that stores into the + RESULT_DECL that hold the value to be returned. + The operand may be null. + The type should be void and the value should be ignored. */ +DEFTREECODE (RETURN_EXPR, "return_expr", tcc_statement, 1) + +/* Exit the inner most loop conditionally. Operand 0 is the condition. + The type should be void and the value should be ignored. */ +DEFTREECODE (EXIT_EXPR, "exit_expr", tcc_statement, 1) + +/* A loop. Operand 0 is the body of the loop. + It must contain an EXIT_EXPR or is an infinite loop. + The type should be void and the value should be ignored. */ +DEFTREECODE (LOOP_EXPR, "loop_expr", tcc_statement, 1) + +/* Switch expression. + + TREE_TYPE is the original type of the condition, before any + language required type conversions. It may be NULL, in which case + the original type and final types are assumed to be the same. + + Operand 0 is the expression used to perform the branch, + Operand 1 is the body of the switch, which probably contains + CASE_LABEL_EXPRs. It may also be NULL, in which case operand 2 + must not be NULL. + Operand 2 is either NULL_TREE or a TREE_VEC of the CASE_LABEL_EXPRs + of all the cases. */ +DEFTREECODE (SWITCH_EXPR, "switch_expr", tcc_statement, 3) + +/* Used to represent a case label. The operands are CASE_LOW and + CASE_HIGH, respectively. If CASE_LOW is NULL_TREE, the label is a + 'default' label. If CASE_HIGH is NULL_TREE, the label is a normal case + label. CASE_LABEL is the corresponding LABEL_DECL. */ +DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", tcc_statement, 3) + +/* Used to represent an inline assembly statement. ASM_STRING returns a + STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS, + ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers + for the statement. ASM_LABELS, if present, indicates various destinations + for the asm; labels cannot be combined with outputs. */ +DEFTREECODE (ASM_EXPR, "asm_expr", tcc_statement, 5) + +/* Variable references for SSA analysis. New SSA names are created every + time a variable is assigned a new value. The SSA builder uses SSA_NAME + nodes to implement SSA versioning. */ +DEFTREECODE (SSA_NAME, "ssa_name", tcc_exceptional, 0) + +/* Used to represent a typed exception handler. CATCH_TYPES is the type (or + list of types) handled, and CATCH_BODY is the code for the handler. */ +DEFTREECODE (CATCH_EXPR, "catch_expr", tcc_statement, 2) + +/* Used to represent an exception specification. EH_FILTER_TYPES is a list + of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on + failure. EH_FILTER_MUST_NOT_THROW controls which range type to use when + expanding. */ +DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", tcc_statement, 2) + +/* Node used for describing a property that is known at compile + time. */ +DEFTREECODE (SCEV_KNOWN, "scev_known", tcc_expression, 0) + +/* Node used for describing a property that is not known at compile + time. */ +DEFTREECODE (SCEV_NOT_KNOWN, "scev_not_known", tcc_expression, 0) + +/* Polynomial chains of recurrences. + Under the form: cr = {CHREC_LEFT (cr), +, CHREC_RIGHT (cr)}. */ +DEFTREECODE (POLYNOMIAL_CHREC, "polynomial_chrec", tcc_expression, 3) + +/* Used to chain children of container statements together. + Use the interface in tree-iterator.h to access this node. */ +DEFTREECODE (STATEMENT_LIST, "statement_list", tcc_exceptional, 0) + +/* Predicate assertion. Artificial expression generated by the optimizers + to keep track of predicate values. This expression may only appear on + the RHS of assignments. + + Given X = ASSERT_EXPR <Y, EXPR>, the optimizers can infer + two things: + + 1- X is a copy of Y. + 2- EXPR is a conditional expression and is known to be true. + + Valid and to be expected forms of conditional expressions are + valid GIMPLE conditional expressions (as defined by is_gimple_condexpr) + and conditional expressions with the first operand being a + PLUS_EXPR with a variable possibly wrapped in a NOP_EXPR first + operand and an integer constant second operand. + + The type of the expression is the same as Y. */ +DEFTREECODE (ASSERT_EXPR, "assert_expr", tcc_expression, 2) + +/* Base class information. Holds information about a class as a + baseclass of itself or another class. */ +DEFTREECODE (TREE_BINFO, "tree_binfo", tcc_exceptional, 0) + +/* Records the size for an expression of variable size type. This is + for use in contexts in which we are accessing the entire object, + such as for a function call, or block copy. + Operand 0 is the real expression. + Operand 1 is the size of the type in the expression. */ +DEFTREECODE (WITH_SIZE_EXPR, "with_size_expr", tcc_expression, 2) + +/* Extract elements from two input vectors Operand 0 and Operand 1 + size VS, according to the offset OFF defined by Operand 2 as + follows: + If OFF > 0, the last VS - OFF elements of vector OP0 are concatenated to + the first OFF elements of the vector OP1. + If OFF == 0, then the returned vector is OP1. + On different targets OFF may take different forms; It can be an address, in + which case its low log2(VS)-1 bits define the offset, or it can be a mask + generated by the builtin targetm.vectorize.mask_for_load_builtin_decl. */ +DEFTREECODE (REALIGN_LOAD_EXPR, "realign_load", tcc_expression, 3) + +/* Low-level memory addressing. Operands are BASE (address of static or + global variable or register), OFFSET (integer constant), + INDEX (register), STEP (integer constant), INDEX2 (register), + The corresponding address is BASE + STEP * INDEX + INDEX2 + OFFSET. + Only variations and values valid on the target are allowed. + + The type of STEP, INDEX and INDEX2 is sizetype. + + The type of BASE is a pointer type. If BASE is not an address of + a static or global variable INDEX2 will be NULL. + + The type of OFFSET is a pointer type and determines TBAA the same as + the constant offset operand in MEM_REF. */ + +DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 5) + +/* Memory addressing. Operands are a pointer and a tree constant integer + byte offset of the pointer type that when dereferenced yields the + type of the base object the pointer points into and which is used for + TBAA purposes. + The type of the MEM_REF is the type the bytes at the memory location + are interpreted as. + MEM_REF <p, c> is equivalent to ((typeof(c))p)->x... where x... is a + chain of component references offsetting p by c. */ +DEFTREECODE (MEM_REF, "mem_ref", tcc_reference, 2) + +/* The ordering of the codes between OMP_PARALLEL and OMP_CRITICAL is + exposed to TREE_RANGE_CHECK. */ +/* OpenMP - #pragma omp parallel [clause1 ... clauseN] + Operand 0: OMP_PARALLEL_BODY: Code to be executed by all threads. + Operand 1: OMP_PARALLEL_CLAUSES: List of clauses. */ + +DEFTREECODE (OMP_PARALLEL, "omp_parallel", tcc_statement, 2) + +/* OpenMP - #pragma omp task [clause1 ... clauseN] + Operand 0: OMP_TASK_BODY: Code to be executed by all threads. + Operand 1: OMP_TASK_CLAUSES: List of clauses. */ + +DEFTREECODE (OMP_TASK, "omp_task", tcc_statement, 2) + +/* OpenMP - #pragma omp for [clause1 ... clauseN] + Operand 0: OMP_FOR_BODY: Loop body. + Operand 1: OMP_FOR_CLAUSES: List of clauses. + Operand 2: OMP_FOR_INIT: Initialization code of the form + VAR = N1. + Operand 3: OMP_FOR_COND: Loop conditional expression of the form + VAR { <, >, <=, >= } N2. + Operand 4: OMP_FOR_INCR: Loop index increment of the form + VAR { +=, -= } INCR. + Operand 5: OMP_FOR_PRE_BODY: Filled by the gimplifier with things + from INIT, COND, and INCR that are technically part of the + OMP_FOR structured block, but are evaluated before the loop + body begins. + + VAR must be an integer or pointer variable, which is implicitly thread + private. N1, N2 and INCR are required to be loop invariant integer + expressions that are evaluated without any synchronization. + The evaluation order, frequency of evaluation and side-effects are + unspecified by the standard. */ +DEFTREECODE (OMP_FOR, "omp_for", tcc_statement, 6) + +/* OpenMP - #pragma omp sections [clause1 ... clauseN] + Operand 0: OMP_SECTIONS_BODY: Sections body. + Operand 1: OMP_SECTIONS_CLAUSES: List of clauses. */ +DEFTREECODE (OMP_SECTIONS, "omp_sections", tcc_statement, 2) + +/* OpenMP - #pragma omp single + Operand 0: OMP_SINGLE_BODY: Single section body. + Operand 1: OMP_SINGLE_CLAUSES: List of clauses. */ +DEFTREECODE (OMP_SINGLE, "omp_single", tcc_statement, 2) + +/* OpenMP - #pragma omp section + Operand 0: OMP_SECTION_BODY: Section body. */ +DEFTREECODE (OMP_SECTION, "omp_section", tcc_statement, 1) + +/* OpenMP - #pragma omp master + Operand 0: OMP_MASTER_BODY: Master section body. */ +DEFTREECODE (OMP_MASTER, "omp_master", tcc_statement, 1) + +/* OpenMP - #pragma omp ordered + Operand 0: OMP_ORDERED_BODY: Master section body. */ +DEFTREECODE (OMP_ORDERED, "omp_ordered", tcc_statement, 1) + +/* OpenMP - #pragma omp critical [name] + Operand 0: OMP_CRITICAL_BODY: Critical section body. + Operand 1: OMP_CRITICAL_NAME: Identifier for critical section. */ +DEFTREECODE (OMP_CRITICAL, "omp_critical", tcc_statement, 2) + +/* OpenMP - #pragma omp atomic + Operand 0: The address at which the atomic operation is to be performed. + This address should be stabilized with save_expr. + Operand 1: The expression to evaluate. When the old value of the object + at the address is used in the expression, it should appear as if + build_fold_indirect_ref of the address. */ +DEFTREECODE (OMP_ATOMIC, "omp_atomic", tcc_statement, 2) + +/* OpenMP clauses. */ +DEFTREECODE (OMP_CLAUSE, "omp_clause", tcc_exceptional, 0) + +/* Reduction operations. + Operations that take a vector of elements and "reduce" it to a scalar + result (e.g. summing the elements of the vector, finding the minimum over + the vector elements, etc). + Operand 0 is a vector; the first element in the vector has the result. + Operand 1 is a vector. */ +DEFTREECODE (REDUC_MAX_EXPR, "reduc_max_expr", tcc_unary, 1) +DEFTREECODE (REDUC_MIN_EXPR, "reduc_min_expr", tcc_unary, 1) +DEFTREECODE (REDUC_PLUS_EXPR, "reduc_plus_expr", tcc_unary, 1) + +/* Widening dot-product. + The first two arguments are of type t1. + The third argument and the result are of type t2, such that t2 is at least + twice the size of t1. DOT_PROD_EXPR(arg1,arg2,arg3) is equivalent to: + tmp = WIDEN_MULT_EXPR(arg1, arg2); + arg3 = PLUS_EXPR (tmp, arg3); + or: + tmp = WIDEN_MULT_EXPR(arg1, arg2); + arg3 = WIDEN_SUM_EXPR (tmp, arg3); */ +DEFTREECODE (DOT_PROD_EXPR, "dot_prod_expr", tcc_expression, 3) + +/* Widening summation. + The first argument is of type t1. + The second argument is of type t2, such that t2 is at least twice + the size of t1. The type of the entire expression is also t2. + WIDEN_SUM_EXPR is equivalent to first widening (promoting) + the first argument from type t1 to type t2, and then summing it + with the second argument. */ +DEFTREECODE (WIDEN_SUM_EXPR, "widen_sum_expr", tcc_binary, 2) + +/* Widening multiplication. + The two arguments are of type t1. + The result is of type t2, such that t2 is at least twice + the size of t1. WIDEN_MULT_EXPR is equivalent to first widening (promoting) + the arguments from type t1 to type t2, and then multiplying them. */ +DEFTREECODE (WIDEN_MULT_EXPR, "widen_mult_expr", tcc_binary, 2) + +/* Widening multiply-accumulate. + The first two arguments are of type t1. + The third argument and the result are of type t2, such as t2 is at least + twice the size of t1. t1 and t2 must be integral or fixed-point types. + The expression is equivalent to a WIDEN_MULT_EXPR operation + of the first two operands followed by an add or subtract of the third + operand. */ +DEFTREECODE (WIDEN_MULT_PLUS_EXPR, "widen_mult_plus_expr", tcc_expression, 3) +/* This is like the above, except in the final expression the multiply result + is subtracted from t3. */ +DEFTREECODE (WIDEN_MULT_MINUS_EXPR, "widen_mult_minus_expr", tcc_expression, 3) + +/* Fused multiply-add. + All operands and the result are of the same type. No intermediate + rounding is performed after multiplying operand one with operand two + before adding operand three. */ +DEFTREECODE (FMA_EXPR, "fma_expr", tcc_expression, 3) + +/* Whole vector left/right shift in bits. + Operand 0 is a vector to be shifted. + Operand 1 is an integer shift amount in bits. */ +DEFTREECODE (VEC_LSHIFT_EXPR, "vec_lshift_expr", tcc_binary, 2) +DEFTREECODE (VEC_RSHIFT_EXPR, "vec_rshift_expr", tcc_binary, 2) + +/* Widening vector multiplication. + The two operands are vectors with N elements of size S. Multiplying the + elements of the two vectors will result in N products of size 2*S. + VEC_WIDEN_MULT_HI_EXPR computes the N/2 high products. + VEC_WIDEN_MULT_LO_EXPR computes the N/2 low products. */ +DEFTREECODE (VEC_WIDEN_MULT_HI_EXPR, "widen_mult_hi_expr", tcc_binary, 2) +DEFTREECODE (VEC_WIDEN_MULT_LO_EXPR, "widen_mult_lo_expr", tcc_binary, 2) + +/* Unpack (extract and promote/widen) the high/low elements of the input + vector into the output vector. The input vector has twice as many + elements as the output vector, that are half the size of the elements + of the output vector. This is used to support type promotion. */ +DEFTREECODE (VEC_UNPACK_HI_EXPR, "vec_unpack_hi_expr", tcc_unary, 1) +DEFTREECODE (VEC_UNPACK_LO_EXPR, "vec_unpack_lo_expr", tcc_unary, 1) + +/* Unpack (extract) the high/low elements of the input vector, convert + fixed point values to floating point and widen elements into the + output vector. The input vector has twice as many elements as the output + vector, that are half the size of the elements of the output vector. */ +DEFTREECODE (VEC_UNPACK_FLOAT_HI_EXPR, "vec_unpack_float_hi_expr", tcc_unary, 1) +DEFTREECODE (VEC_UNPACK_FLOAT_LO_EXPR, "vec_unpack_float_lo_expr", tcc_unary, 1) + +/* Pack (demote/narrow and merge) the elements of the two input vectors + into the output vector using truncation/saturation. + The elements of the input vectors are twice the size of the elements of the + output vector. This is used to support type demotion. */ +DEFTREECODE (VEC_PACK_TRUNC_EXPR, "vec_pack_trunc_expr", tcc_binary, 2) +DEFTREECODE (VEC_PACK_SAT_EXPR, "vec_pack_sat_expr", tcc_binary, 2) + +/* Convert floating point values of the two input vectors to integer + and pack (narrow and merge) the elements into the output vector. The + elements of the input vector are twice the size of the elements of + the output vector. */ +DEFTREECODE (VEC_PACK_FIX_TRUNC_EXPR, "vec_pack_fix_trunc_expr", tcc_binary, 2) + +/* Extract even/odd fields from vectors. */ +DEFTREECODE (VEC_EXTRACT_EVEN_EXPR, "vec_extracteven_expr", tcc_binary, 2) +DEFTREECODE (VEC_EXTRACT_ODD_EXPR, "vec_extractodd_expr", tcc_binary, 2) + +/* Merge input vectors interleaving their fields. */ +DEFTREECODE (VEC_INTERLEAVE_HIGH_EXPR, "vec_interleavehigh_expr", tcc_binary, 2) +DEFTREECODE (VEC_INTERLEAVE_LOW_EXPR, "vec_interleavelow_expr", tcc_binary, 2) + +/* PREDICT_EXPR. Specify hint for branch prediction. The + PREDICT_EXPR_PREDICTOR specify predictor and PREDICT_EXPR_OUTCOME the + outcome (0 for not taken and 1 for taken). Once the profile is guessed + all conditional branches leading to execution paths executing the + PREDICT_EXPR will get predicted by the specified predictor. */ +DEFTREECODE (PREDICT_EXPR, "predict_expr", tcc_expression, 1) + +/* OPTIMIZATION_NODE. Node to store the optimization options. */ +DEFTREECODE (OPTIMIZATION_NODE, "optimization_node", tcc_exceptional, 0) + +/* TARGET_OPTION_NODE. Node to store the target specific options. */ +DEFTREECODE (TARGET_OPTION_NODE, "target_option_node", tcc_exceptional, 0) + +/* +Local variables: +mode:c +End: +*/ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree.h new file mode 100644 index 0000000..1ec0c06 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/tree.h @@ -0,0 +1,5750 @@ +/* Front-end tree definitions for GNU compiler. + Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, + 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + 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/>. */ + +#ifndef GCC_TREE_H +#define GCC_TREE_H + +#include "hashtab.h" +#include "machmode.h" +#include "input.h" +#include "statistics.h" +#include "vec.h" +#include "vecir.h" +#include "double-int.h" +#include "real.h" +#include "fixed-value.h" +#include "alias.h" +#include "flags.h" + +/* Codes of tree nodes */ + +#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, +#define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE, + +enum tree_code { +#include "all-tree.def" +MAX_TREE_CODES +}; + +#undef DEFTREECODE +#undef END_OF_BASE_TREE_CODES + +extern unsigned char tree_contains_struct[MAX_TREE_CODES][64]; +#define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)]) + +/* Number of language-independent tree codes. */ +#define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE) + +/* Tree code classes. */ + +/* Each tree_code has an associated code class represented by a + TREE_CODE_CLASS. */ + +enum tree_code_class { + tcc_exceptional, /* An exceptional code (fits no category). */ + tcc_constant, /* A constant. */ + /* Order of tcc_type and tcc_declaration is important. */ + tcc_type, /* A type object code. */ + tcc_declaration, /* A declaration (also serving as variable refs). */ + tcc_reference, /* A reference to storage. */ + tcc_comparison, /* A comparison expression. */ + tcc_unary, /* A unary arithmetic expression. */ + tcc_binary, /* A binary arithmetic expression. */ + tcc_statement, /* A statement expression, which have side effects + but usually no interesting value. */ + tcc_vl_exp, /* A function call or other expression with a + variable-length operand vector. */ + tcc_expression /* Any other expression. */ +}; + +/* Each tree code class has an associated string representation. + These must correspond to the tree_code_class entries. */ + +extern const char *const tree_code_class_strings[]; + +/* Returns the string representing CLASS. */ + +#define TREE_CODE_CLASS_STRING(CLASS)\ + tree_code_class_strings[(int) (CLASS)] + +extern const enum tree_code_class tree_code_type[]; +#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)] + +/* Nonzero if CODE represents an exceptional code. */ + +#define EXCEPTIONAL_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional) + +/* Nonzero if CODE represents a constant. */ + +#define CONSTANT_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant) + +/* Nonzero if CODE represents a type. */ + +#define TYPE_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type) + +/* Nonzero if CODE represents a declaration. */ + +#define DECL_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration) + +/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */ + +#define VAR_OR_FUNCTION_DECL_P(DECL)\ + (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL) + +/* Nonzero if CODE represents a INDIRECT_REF. Keep these checks in + ascending code order. */ + +#define INDIRECT_REF_P(CODE)\ + (TREE_CODE (CODE) == INDIRECT_REF) + +/* Nonzero if CODE represents a reference. */ + +#define REFERENCE_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference) + +/* Nonzero if CODE represents a comparison. */ + +#define COMPARISON_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison) + +/* Nonzero if CODE represents a unary arithmetic expression. */ + +#define UNARY_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary) + +/* Nonzero if CODE represents a binary arithmetic expression. */ + +#define BINARY_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary) + +/* Nonzero if CODE represents a statement expression. */ + +#define STATEMENT_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement) + +/* Nonzero if CODE represents a function call-like expression with a + variable-length operand vector. */ + +#define VL_EXP_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_vl_exp) + +/* Nonzero if CODE represents any other expression. */ + +#define EXPRESSION_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression) + +/* Returns nonzero iff CODE represents a type or declaration. */ + +#define IS_TYPE_OR_DECL_P(CODE)\ + (TYPE_P (CODE) || DECL_P (CODE)) + +/* Returns nonzero iff CLASS is the tree-code class of an + expression. */ + +#define IS_EXPR_CODE_CLASS(CLASS)\ + ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression) + +/* Returns nonzero iff NODE is an expression of some kind. */ + +#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) + +/* Number of argument-words in each kind of tree-node. */ + +extern const unsigned char tree_code_length[]; +#define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)] + +/* Names of tree components. */ + +extern const char *const tree_code_name[]; + +/* We have to be able to tell cgraph about the needed-ness of the target + of an alias. This requires that the decl have been defined. Aliases + that precede their definition have to be queued for later processing. */ + +/* The deferred processing proceeds in several passes. We memorize the + diagnostics emitted for a pair to prevent repeating messages when the + queue gets re-scanned after possible updates. */ + +typedef enum { + ALIAS_DIAG_NONE = 0x0, + ALIAS_DIAG_TO_UNDEF = 0x1, + ALIAS_DIAG_TO_EXTERN = 0x2 +} alias_diag_flags; + +typedef struct GTY(()) alias_pair +{ + tree decl; + tree target; + int emitted_diags; /* alias_diags already emitted for this pair. */ +} alias_pair; + +/* Define gc'd vector type. */ +DEF_VEC_O(alias_pair); +DEF_VEC_ALLOC_O(alias_pair,gc); + +extern GTY(()) VEC(alias_pair,gc) * alias_pairs; + + +/* Classify which part of the compiler has defined a given builtin function. + Note that we assume below that this is no more than two bits. */ +enum built_in_class +{ + NOT_BUILT_IN = 0, + BUILT_IN_FRONTEND, + BUILT_IN_MD, + BUILT_IN_NORMAL +}; + +/* Names for the above. */ +extern const char *const built_in_class_names[4]; + +/* Codes that identify the various built in functions + so that expand_call can identify them quickly. */ + +#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM, +enum built_in_function +{ +#include "builtins.def" + + /* Complex division routines in libgcc. These are done via builtins + because emit_library_call_value can't handle complex values. */ + BUILT_IN_COMPLEX_MUL_MIN, + BUILT_IN_COMPLEX_MUL_MAX + = BUILT_IN_COMPLEX_MUL_MIN + + MAX_MODE_COMPLEX_FLOAT + - MIN_MODE_COMPLEX_FLOAT, + + BUILT_IN_COMPLEX_DIV_MIN, + BUILT_IN_COMPLEX_DIV_MAX + = BUILT_IN_COMPLEX_DIV_MIN + + MAX_MODE_COMPLEX_FLOAT + - MIN_MODE_COMPLEX_FLOAT, + + /* Upper bound on non-language-specific builtins. */ + END_BUILTINS +}; +#undef DEF_BUILTIN + +/* Names for the above. */ +extern const char * built_in_names[(int) END_BUILTINS]; + +/* Helper macros for math builtins. */ + +#define BUILTIN_EXP10_P(FN) \ + ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \ + || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L) + +#define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \ + || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \ + || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L) + +#define BUILTIN_SQRT_P(FN) \ + ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL) + +#define BUILTIN_CBRT_P(FN) \ + ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL) + +#define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN)) + +#define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L +#define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R +#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL + +/* An array of _DECL trees for the above. */ +extern GTY(()) tree built_in_decls[(int) END_BUILTINS]; +extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS]; + +/* In an OMP_CLAUSE node. */ + +/* Number of operands and names for each clause. */ +extern unsigned const char omp_clause_num_ops[]; +extern const char * const omp_clause_code_name[]; + +/* Clause codes. Do not reorder, as this is used to index into the tables + omp_clause_num_ops and omp_clause_code_name. */ +enum omp_clause_code +{ + /* Clause zero is special-cased inside the parser + (c_parser_omp_variable_list). */ + OMP_CLAUSE_ERROR = 0, + + /* OpenMP clause: private (variable_list). */ + OMP_CLAUSE_PRIVATE, + + /* OpenMP clause: shared (variable_list). */ + OMP_CLAUSE_SHARED, + + /* OpenMP clause: firstprivate (variable_list). */ + OMP_CLAUSE_FIRSTPRIVATE, + + /* OpenMP clause: lastprivate (variable_list). */ + OMP_CLAUSE_LASTPRIVATE, + + /* OpenMP clause: reduction (operator:variable_list). + OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator. + Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var. + Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var + into the shared one. + Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL + placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}. */ + OMP_CLAUSE_REDUCTION, + + /* OpenMP clause: copyin (variable_list). */ + OMP_CLAUSE_COPYIN, + + /* OpenMP clause: copyprivate (variable_list). */ + OMP_CLAUSE_COPYPRIVATE, + + /* OpenMP clause: if (scalar-expression). */ + OMP_CLAUSE_IF, + + /* OpenMP clause: num_threads (integer-expression). */ + OMP_CLAUSE_NUM_THREADS, + + /* OpenMP clause: schedule. */ + OMP_CLAUSE_SCHEDULE, + + /* OpenMP clause: nowait. */ + OMP_CLAUSE_NOWAIT, + + /* OpenMP clause: ordered. */ + OMP_CLAUSE_ORDERED, + + /* OpenMP clause: default. */ + OMP_CLAUSE_DEFAULT, + + /* OpenMP clause: collapse (constant-integer-expression). */ + OMP_CLAUSE_COLLAPSE, + + /* OpenMP clause: untied. */ + OMP_CLAUSE_UNTIED +}; + +/* The definition of tree nodes fills the next several pages. */ + +/* A tree node can represent a data type, a variable, an expression + or a statement. Each node has a TREE_CODE which says what kind of + thing it represents. Some common codes are: + INTEGER_TYPE -- represents a type of integers. + ARRAY_TYPE -- represents a type of pointer. + VAR_DECL -- represents a declared variable. + INTEGER_CST -- represents a constant integer value. + PLUS_EXPR -- represents a sum (an expression). + + As for the contents of a tree node: there are some fields + that all nodes share. Each TREE_CODE has various special-purpose + fields as well. The fields of a node are never accessed directly, + always through accessor macros. */ + +/* Every kind of tree node starts with this structure, + so all nodes have these fields. + + See the accessor macros, defined below, for documentation of the + fields. */ + +struct GTY(()) tree_base { + ENUM_BITFIELD(tree_code) code : 16; + + unsigned side_effects_flag : 1; + unsigned constant_flag : 1; + unsigned addressable_flag : 1; + unsigned volatile_flag : 1; + unsigned readonly_flag : 1; + unsigned unsigned_flag : 1; + unsigned asm_written_flag: 1; + unsigned nowarning_flag : 1; + + unsigned used_flag : 1; + unsigned nothrow_flag : 1; + unsigned static_flag : 1; + unsigned public_flag : 1; + unsigned private_flag : 1; + unsigned protected_flag : 1; + unsigned deprecated_flag : 1; + unsigned saturating_flag : 1; + + unsigned default_def_flag : 1; + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; + + unsigned visited : 1; + unsigned packed_flag : 1; + unsigned user_align : 1; + unsigned nameless_flag : 1; + unsigned expr_folded_flag : 1; + + unsigned spare : 11; + + /* This field is only used with type nodes; the only reason it is present + in tree_base instead of tree_type is to save space. The size of the + field must be large enough to hold addr_space_t values. */ + unsigned address_space : 8; +}; + +struct GTY(()) tree_common { + struct tree_base base; + tree chain; + tree type; +}; + +/* The following table lists the uses of each of the above flags and + for which types of nodes they are defined. + + addressable_flag: + + TREE_ADDRESSABLE in + VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL + all types + CONSTRUCTOR, IDENTIFIER_NODE + STMT_EXPR, it means we want the result of the enclosed expression + + CALL_EXPR_TAILCALL in + CALL_EXPR + + CASE_LOW_SEEN in + CASE_LABEL_EXPR + + static_flag: + + TREE_STATIC in + VAR_DECL, FUNCTION_DECL + CONSTRUCTOR + + TREE_NO_TRAMPOLINE in + ADDR_EXPR + + BINFO_VIRTUAL_P in + TREE_BINFO + + TREE_SYMBOL_REFERENCED in + IDENTIFIER_NODE + + CLEANUP_EH_ONLY in + TARGET_EXPR, WITH_CLEANUP_EXPR + + TRY_CATCH_IS_CLEANUP in + TRY_CATCH_EXPR + + ASM_INPUT_P in + ASM_EXPR + + TYPE_REF_CAN_ALIAS_ALL in + POINTER_TYPE, REFERENCE_TYPE + + MOVE_NONTEMPORAL in + MODIFY_EXPR + + CASE_HIGH_SEEN in + CASE_LABEL_EXPR + + CALL_CANNOT_INLINE_P in + CALL_EXPR + + ENUM_IS_SCOPED in + ENUMERAL_TYPE + + public_flag: + + TREE_OVERFLOW in + INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST + + TREE_PUBLIC in + VAR_DECL, FUNCTION_DECL + IDENTIFIER_NODE + + ASM_VOLATILE_P in + ASM_EXPR + + CALL_EXPR_VA_ARG_PACK in + CALL_EXPR + + TYPE_CACHED_VALUES_P in + all types + + SAVE_EXPR_RESOLVED_P in + SAVE_EXPR + + OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in + OMP_CLAUSE_LASTPRIVATE + + OMP_CLAUSE_PRIVATE_DEBUG in + OMP_CLAUSE_PRIVATE + + private_flag: + + TREE_PRIVATE in + all decls + + CALL_EXPR_RETURN_SLOT_OPT in + CALL_EXPR + + OMP_SECTION_LAST in + OMP_SECTION + + OMP_PARALLEL_COMBINED in + OMP_PARALLEL + OMP_CLAUSE_PRIVATE_OUTER_REF in + OMP_CLAUSE_PRIVATE + + TYPE_REF_IS_RVALUE in + REFERENCE_TYPE + + protected_flag: + + TREE_PROTECTED in + BLOCK + all decls + + CALL_FROM_THUNK_P and + ALLOCA_FOR_VAR_P in + CALL_EXPR + + side_effects_flag: + + TREE_SIDE_EFFECTS in + all expressions + all decls + all constants + + FORCED_LABEL in + LABEL_DECL + + volatile_flag: + + TREE_THIS_VOLATILE in + all expressions + all decls + + TYPE_VOLATILE in + all types + + readonly_flag: + + TREE_READONLY in + all expressions + all decls + + TYPE_READONLY in + all types + + constant_flag: + + TREE_CONSTANT in + all expressions + all decls + all constants + + TYPE_SIZES_GIMPLIFIED in + all types + + unsigned_flag: + + TYPE_UNSIGNED in + all types + + DECL_UNSIGNED in + all decls + + REGISTER_DEFS_IN_THIS_STMT in + all expressions (tree-into-ssa.c) + + asm_written_flag: + + TREE_ASM_WRITTEN in + VAR_DECL, FUNCTION_DECL + RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE + BLOCK, SSA_NAME, STRING_CST + + NECESSARY in + all expressions (tree-ssa-dce.c, tree-ssa-pre.c) + + used_flag: + + TREE_USED in + all expressions + all decls + IDENTIFIER_NODE + + nothrow_flag: + + TREE_NOTHROW in + CALL_EXPR + FUNCTION_DECL + + TYPE_ALIGN_OK in + all types + + TREE_THIS_NOTRAP in + INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF + + deprecated_flag: + + TREE_DEPRECATED in + all decls + all types + + IDENTIFIER_TRANSPARENT_ALIAS in + IDENTIFIER_NODE + + STMT_IN_SSA_EDGE_WORKLIST in + all expressions (tree-ssa-propagate.c) + + visited: + + TREE_VISITED in + all trees (used liberally by many passes) + + saturating_flag: + + TYPE_SATURATING in + all types + + nowarning_flag: + + TREE_NO_WARNING in + all expressions + all decls + + default_def_flag: + + TYPE_VECTOR_OPAQUE in + VECTOR_TYPE + + SSA_NAME_IS_DEFAULT_DEF in + SSA_NAME + + expr_folded_flag: + + EXPR_FOLDED in + all expressions + all decls + all constants +*/ + +#undef DEFTREESTRUCT +#define DEFTREESTRUCT(ENUM, NAME) ENUM, +enum tree_node_structure_enum { +#include "treestruct.def" + LAST_TS_ENUM +}; +#undef DEFTREESTRUCT + +/* Define accessors for the fields that all tree nodes have + (though some fields are not used for all kinds of nodes). */ + +/* The tree-code says what kind of node it is. + Codes are defined in tree.def. */ +#define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code) +#define TREE_SET_CODE(NODE, VALUE) ((NODE)->base.code = (VALUE)) + +/* When checking is enabled, errors will be generated if a tree node + is accessed incorrectly. The macros die with a fatal error. */ +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) + +#define TREE_CHECK(T, CODE) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != (CODE)) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE), 0); \ + __t; }) + +#define TREE_NOT_CHECK(T, CODE) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) == (CODE)) \ + tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE), 0); \ + __t; }) + +#define TREE_CHECK2(T, CODE1, CODE2) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2)) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), 0); \ + __t; }) + +#define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) == (CODE1) \ + || TREE_CODE (__t) == (CODE2)) \ + tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), 0); \ + __t; }) + +#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2) \ + && TREE_CODE (__t) != (CODE3)) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), (CODE3), 0); \ + __t; }) + +#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) == (CODE1) \ + || TREE_CODE (__t) == (CODE2) \ + || TREE_CODE (__t) == (CODE3)) \ + tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), (CODE3), 0); \ + __t; }) + +#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2) \ + && TREE_CODE (__t) != (CODE3) \ + && TREE_CODE (__t) != (CODE4)) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), (CODE3), (CODE4), 0); \ + __t; }) + +#define NON_TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) == (CODE1) \ + || TREE_CODE (__t) == (CODE2) \ + || TREE_CODE (__t) == (CODE3) \ + || TREE_CODE (__t) == (CODE4)) \ + tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), (CODE3), (CODE4), 0); \ + __t; }) + +#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2) \ + && TREE_CODE (__t) != (CODE3) \ + && TREE_CODE (__t) != (CODE4) \ + && TREE_CODE (__t) != (CODE5)) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\ + __t; }) + +#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) == (CODE1) \ + || TREE_CODE (__t) == (CODE2) \ + || TREE_CODE (__t) == (CODE3) \ + || TREE_CODE (__t) == (CODE4) \ + || TREE_CODE (__t) == (CODE5)) \ + tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\ + __t; }) + +#define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1) \ + tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__, \ + __FUNCTION__); \ + __t; }) + +#define TREE_CLASS_CHECK(T, CLASS) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \ + tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__, \ + __FUNCTION__); \ + __t; }) + +#define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) < (CODE1) || TREE_CODE (__t) > (CODE2)) \ + tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE1), (CODE2)); \ + __t; }) + +#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != OMP_CLAUSE) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + OMP_CLAUSE, 0); \ + if (__t->omp_clause.code != (CODE)) \ + omp_clause_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + (CODE)); \ + __t; }) + +#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TREE_CODE (__t) != OMP_CLAUSE) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + OMP_CLAUSE, 0); \ + if ((int) __t->omp_clause.code < (int) (CODE1) \ + || (int) __t->omp_clause.code > (int) (CODE2)) \ + omp_clause_range_check_failed (__t, __FILE__, __LINE__, \ + __FUNCTION__, (CODE1), (CODE2)); \ + __t; }) + +/* These checks have to be special cased. */ +#define EXPR_CHECK(T) __extension__ \ +({ __typeof (T) const __t = (T); \ + char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \ + if (!IS_EXPR_CODE_CLASS (__c)) \ + tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \ + __FUNCTION__); \ + __t; }) + +/* These checks have to be special cased. */ +#define NON_TYPE_CHECK(T) __extension__ \ +({ __typeof (T) const __t = (T); \ + if (TYPE_P (__t)) \ + tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__, \ + __FUNCTION__); \ + __t; }) + +#define TREE_VEC_ELT_CHECK(T, I) __extension__ \ +(*({__typeof (T) const __t = (T); \ + const int __i = (I); \ + if (TREE_CODE (__t) != TREE_VEC) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + TREE_VEC, 0); \ + if (__i < 0 || __i >= __t->vec.length) \ + tree_vec_elt_check_failed (__i, __t->vec.length, \ + __FILE__, __LINE__, __FUNCTION__); \ + &__t->vec.a[__i]; })) + +#define OMP_CLAUSE_ELT_CHECK(T, I) __extension__ \ +(*({__typeof (T) const __t = (T); \ + const int __i = (I); \ + if (TREE_CODE (__t) != OMP_CLAUSE) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ + OMP_CLAUSE, 0); \ + if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code]) \ + omp_clause_operand_check_failed (__i, __t, __FILE__, __LINE__, \ + __FUNCTION__); \ + &__t->omp_clause.ops[__i]; })) + +/* Special checks for TREE_OPERANDs. */ +#define TREE_OPERAND_CHECK(T, I) __extension__ \ +(*({__typeof (T) const __t = EXPR_CHECK (T); \ + const int __i = (I); \ + if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t)) \ + tree_operand_check_failed (__i, __t, \ + __FILE__, __LINE__, __FUNCTION__); \ + &__t->exp.operands[__i]; })) + +#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__ \ +(*({__typeof (T) const __t = (T); \ + const int __i = (I); \ + if (TREE_CODE (__t) != CODE) \ + tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\ + if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t)) \ + tree_operand_check_failed (__i, __t, \ + __FILE__, __LINE__, __FUNCTION__); \ + &__t->exp.operands[__i]; })) + +/* Nodes are chained together for many purposes. + Types are chained together to record them for being output to the debugger + (see the function `chain_type'). + Decls in the same scope are chained together to record the contents + of the scope. + Statement nodes for successive statements used to be chained together. + Often lists of things are represented by TREE_LIST nodes that + are chained together. */ + +#define TREE_CHAIN(NODE) __extension__ \ +(*({__typeof (NODE) const __t = (NODE); \ + &__t->common.chain; })) + +/* In all nodes that are expressions, this is the data type of the expression. + In POINTER_TYPE nodes, this is the type that the pointer points to. + In ARRAY_TYPE nodes, this is the type of the elements. + In VECTOR_TYPE nodes, this is the type of the elements. */ +#define TREE_TYPE(NODE) __extension__ \ +(*({__typeof (NODE) const __t = (NODE); \ + &__t->common.type; })) + +extern void tree_contains_struct_check_failed (const_tree, + const enum tree_node_structure_enum, + const char *, int, const char *) + ATTRIBUTE_NORETURN; + +extern void tree_check_failed (const_tree, const char *, int, const char *, + ...) ATTRIBUTE_NORETURN; +extern void tree_not_check_failed (const_tree, const char *, int, const char *, + ...) ATTRIBUTE_NORETURN; +extern void tree_class_check_failed (const_tree, const enum tree_code_class, + const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void tree_range_check_failed (const_tree, const char *, int, + const char *, enum tree_code, + enum tree_code) + ATTRIBUTE_NORETURN; +extern void tree_not_class_check_failed (const_tree, + const enum tree_code_class, + const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void tree_vec_elt_check_failed (int, int, const char *, + int, const char *) + ATTRIBUTE_NORETURN; +extern void phi_node_elt_check_failed (int, int, const char *, + int, const char *) + ATTRIBUTE_NORETURN; +extern void tree_operand_check_failed (int, const_tree, + const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void omp_clause_check_failed (const_tree, const char *, int, + const char *, enum omp_clause_code) + ATTRIBUTE_NORETURN; +extern void omp_clause_operand_check_failed (int, const_tree, const char *, + int, const char *) + ATTRIBUTE_NORETURN; +extern void omp_clause_range_check_failed (const_tree, const char *, int, + const char *, enum omp_clause_code, + enum omp_clause_code) + ATTRIBUTE_NORETURN; + +#else /* not ENABLE_TREE_CHECKING, or not gcc */ + +#define CONTAINS_STRUCT_CHECK(T, ENUM) (T) +#define TREE_CHECK(T, CODE) (T) +#define TREE_NOT_CHECK(T, CODE) (T) +#define TREE_CHECK2(T, CODE1, CODE2) (T) +#define TREE_NOT_CHECK2(T, CODE1, CODE2) (T) +#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T) +#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T) +#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) +#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) +#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) +#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) +#define TREE_CLASS_CHECK(T, CODE) (T) +#define TREE_RANGE_CHECK(T, CODE1, CODE2) (T) +#define EXPR_CHECK(T) (T) +#define NON_TYPE_CHECK(T) (T) +#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I]) +#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I]) +#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I]) +#define OMP_CLAUSE_ELT_CHECK(T, i) ((T)->omp_clause.ops[i]) +#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T) +#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T) + +#define TREE_CHAIN(NODE) ((NODE)->common.chain) +#define TREE_TYPE(NODE) ((NODE)->common.type) + +#endif + +#define TREE_BLOCK(NODE) *(tree_block (NODE)) + +#include "tree-check.h" + +#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type) +#define DECL_MINIMAL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL) +#define DECL_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON) +#define DECL_WRTL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL) +#define DECL_WITH_VIS_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS) +#define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON) +#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant) +#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement) +#define VL_EXP_CHECK(T) TREE_CLASS_CHECK (T, tcc_vl_exp) +#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE) +#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE) + +#define RECORD_OR_UNION_CHECK(T) \ + TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) +#define NOT_RECORD_OR_UNION_CHECK(T) \ + TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) + +#define NUMERICAL_TYPE_CHECK(T) \ + TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \ + FIXED_POINT_TYPE) + +/* Here is how primitive or already-canonicalized types' hash codes + are made. */ +#define TYPE_HASH(TYPE) (TYPE_UID (TYPE)) + +/* A simple hash function for an arbitrary tree node. This must not be + used in hash tables which are saved to a PCH. */ +#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777) + +/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */ +#define CONVERT_EXPR_CODE_P(CODE) \ + ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR) + +/* Similarly, but accept an expressions instead of a tree code. */ +#define CONVERT_EXPR_P(EXP) CONVERT_EXPR_CODE_P (TREE_CODE (EXP)) + +/* Generate case for NOP_EXPR, CONVERT_EXPR. */ + +#define CASE_CONVERT \ + case NOP_EXPR: \ + case CONVERT_EXPR + +/* Given an expression as a tree, strip any conversion that generates + no instruction. Accepts both tree and const_tree arguments since + we are not modifying the tree itself. */ + +#define STRIP_NOPS(EXP) \ + (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP)) + +/* Like STRIP_NOPS, but don't let the signedness change either. */ + +#define STRIP_SIGN_NOPS(EXP) \ + (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP)) + +/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */ + +#define STRIP_TYPE_NOPS(EXP) \ + while ((CONVERT_EXPR_P (EXP) \ + || TREE_CODE (EXP) == NON_LVALUE_EXPR) \ + && TREE_OPERAND (EXP, 0) != error_mark_node \ + && (TREE_TYPE (EXP) \ + == TREE_TYPE (TREE_OPERAND (EXP, 0)))) \ + (EXP) = TREE_OPERAND (EXP, 0) + +/* Remove unnecessary type conversions according to + tree_ssa_useless_type_conversion. */ + +#define STRIP_USELESS_TYPE_CONVERSION(EXP) \ + (EXP) = tree_ssa_strip_useless_type_conversions (EXP) + +/* Nonzero if TYPE represents an integral type. Note that we do not + include COMPLEX types here. Keep these checks in ascending code + order. */ + +#define INTEGRAL_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == ENUMERAL_TYPE \ + || TREE_CODE (TYPE) == BOOLEAN_TYPE \ + || TREE_CODE (TYPE) == INTEGER_TYPE) + +/* Nonzero if TYPE represents a non-saturating fixed-point type. */ + +#define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE)) + +/* Nonzero if TYPE represents a saturating fixed-point type. */ + +#define SAT_FIXED_POINT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE)) + +/* Nonzero if TYPE represents a fixed-point type. */ + +#define FIXED_POINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == FIXED_POINT_TYPE) + +/* Nonzero if TYPE represents a scalar floating-point type. */ + +#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE) + +/* Nonzero if TYPE represents a complex floating-point type. */ + +#define COMPLEX_FLOAT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == COMPLEX_TYPE \ + && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE) + +/* Nonzero if TYPE represents a vector floating-point type. */ + +#define VECTOR_FLOAT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == VECTOR_TYPE \ + && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE) + +/* Nonzero if TYPE represents a floating-point type, including complex + and vector floating-point types. The vector and complex check does + not use the previous two macros to enable early folding. */ + +#define FLOAT_TYPE_P(TYPE) \ + (SCALAR_FLOAT_TYPE_P (TYPE) \ + || ((TREE_CODE (TYPE) == COMPLEX_TYPE \ + || TREE_CODE (TYPE) == VECTOR_TYPE) \ + && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE)))) + +/* Nonzero if TYPE represents a decimal floating-point type. */ +#define DECIMAL_FLOAT_TYPE_P(TYPE) \ + (SCALAR_FLOAT_TYPE_P (TYPE) \ + && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE))) + +/* Nonzero if TYPE is a record or union type. */ +#define RECORD_OR_UNION_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == RECORD_TYPE \ + || TREE_CODE (TYPE) == UNION_TYPE \ + || TREE_CODE (TYPE) == QUAL_UNION_TYPE) + +/* Nonzero if TYPE represents an aggregate (multi-component) type. + Keep these checks in ascending code order. */ + +#define AGGREGATE_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE)) + +/* Nonzero if TYPE represents a pointer or reference type. + (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in + ascending code order. */ + +#define POINTER_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE) + +/* Nonzero if this type is a complete type. */ +#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE) + +/* Nonzero if this type is the (possibly qualified) void type. */ +#define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE) + +/* Nonzero if this type is complete or is cv void. */ +#define COMPLETE_OR_VOID_TYPE_P(NODE) \ + (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE)) + +/* Nonzero if this type is complete or is an array with unspecified bound. */ +#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \ + (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE))) + + +/* Define many boolean fields that all tree nodes have. */ + +/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address + of this is needed. So it cannot be in a register. + In a FUNCTION_DECL it has no meaning. + In CONSTRUCTOR nodes, it means object constructed must be in memory. + In LABEL_DECL nodes, it means a goto for this label has been seen + from a place outside all binding contours that restore stack levels. + In ..._TYPE nodes, it means that objects of this type must be fully + addressable. This means that pieces of this object cannot go into + register parameters, for example. If this a function type, this + means that the value must be returned in memory. + In IDENTIFIER_NODEs, this means that some extern decl for this name + had its address taken. That matters for inline functions. */ +#define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag) + +/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the + exit of a function. Calls for which this is true are candidates for tail + call optimizations. */ +#define CALL_EXPR_TAILCALL(NODE) \ + (CALL_EXPR_CHECK(NODE)->base.addressable_flag) + +/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the + CASE_LOW operand has been processed. */ +#define CASE_LOW_SEEN(NODE) \ + (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag) + +#define PREDICT_EXPR_OUTCOME(NODE) \ + ((enum prediction) (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag)) +#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \ + (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag = (int) OUTCOME) +#define PREDICT_EXPR_PREDICTOR(NODE) \ + ((enum br_predictor)tree_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 0)) + +/* In a VAR_DECL, nonzero means allocate static storage. + In a FUNCTION_DECL, nonzero if function has been defined. + In a CONSTRUCTOR, nonzero means allocate static storage. */ +#define TREE_STATIC(NODE) ((NODE)->base.static_flag) + +/* In an ADDR_EXPR, nonzero means do not use a trampoline. */ +#define TREE_NO_TRAMPOLINE(NODE) (ADDR_EXPR_CHECK (NODE)->base.static_flag) + +/* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup + should only be executed if an exception is thrown, not on normal exit + of its scope. */ +#define CLEANUP_EH_ONLY(NODE) ((NODE)->base.static_flag) + +/* In a TRY_CATCH_EXPR, means that the handler should be considered a + separate cleanup in honor_protect_cleanup_actions. */ +#define TRY_CATCH_IS_CLEANUP(NODE) \ + (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag) + +/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the + CASE_HIGH operand has been processed. */ +#define CASE_HIGH_SEEN(NODE) \ + (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag) + +/* Used to mark a CALL_EXPR as not suitable for inlining. */ +#define CALL_CANNOT_INLINE_P(NODE) (CALL_EXPR_CHECK (NODE)->base.static_flag) + +/* Used to mark scoped enums. */ +#define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag) + +/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */ +#define ENUM_IS_OPAQUE(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag) + +/* In an expr node (usually a conversion) this means the node was made + implicitly and should not lead to any sort of warning. In a decl node, + warnings concerning the decl should be suppressed. This is used at + least for used-before-set warnings, and it set after one warning is + emitted. */ +#define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_flag) + +/* In an IDENTIFIER_NODE, this means that assemble_name was called with + this string as an argument. */ +#define TREE_SYMBOL_REFERENCED(NODE) \ + (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag) + +/* Nonzero in a pointer or reference type means the data pointed to + by this type can alias anything. */ +#define TYPE_REF_CAN_ALIAS_ALL(NODE) \ + (PTR_OR_REF_CHECK (NODE)->base.static_flag) + +/* In a MODIFY_EXPR, means that the store in the expression is nontemporal. */ +#define MOVE_NONTEMPORAL(NODE) \ + (EXPR_CHECK (NODE)->base.static_flag) + +/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means + there was an overflow in folding. */ + +#define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag) + +/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */ + +#define TREE_OVERFLOW_P(EXPR) \ + (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR)) + +/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL, + nonzero means name is to be accessible from outside this translation unit. + In an IDENTIFIER_NODE, nonzero means an external declaration + accessible from outside this translation unit was previously seen + for this name in an inner scope. */ +#define TREE_PUBLIC(NODE) ((NODE)->base.public_flag) + +/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector + of cached values, or is something else. */ +#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->base.public_flag) + +/* In a SAVE_EXPR, indicates that the original expression has already + been substituted with a VAR_DECL that contains the value. */ +#define SAVE_EXPR_RESOLVED_P(NODE) \ + (SAVE_EXPR_CHECK (NODE)->base.public_flag) + +/* Set on a CALL_EXPR if this stdarg call should be passed the argument + pack. */ +#define CALL_EXPR_VA_ARG_PACK(NODE) \ + (CALL_EXPR_CHECK(NODE)->base.public_flag) + +/* In any expression, decl, or constant, nonzero means it has side effects or + reevaluation of the whole expression could produce a different value. + This is set if any subexpression is a function call, a side effect or a + reference to a volatile variable. In a ..._DECL, this is set only if the + declaration said `volatile'. This will never be set for a constant. */ +#define TREE_SIDE_EFFECTS(NODE) \ + (NON_TYPE_CHECK (NODE)->base.side_effects_flag) + +/* In a LABEL_DECL, nonzero means this label had its address taken + and therefore can never be deleted and is a jump target for + computed gotos. */ +#define FORCED_LABEL(NODE) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag) + +/* Nonzero means this expression is volatile in the C sense: + its address should be of type `volatile WHATEVER *'. + In other words, the declared item is volatile qualified. + This is used in _DECL nodes and _REF nodes. + On a FUNCTION_DECL node, this means the function does not + return normally. This is the same effect as setting + the attribute noreturn on the function in C. + + In a ..._TYPE node, means this type is volatile-qualified. + But use TYPE_VOLATILE instead of this macro when the node is a type, + because eventually we may make that a different bit. + + If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */ +#define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag) + +/* Nonzero means this node will not trap. In an INDIRECT_REF, means + accessing the memory pointed to won't generate a trap. However, + this only applies to an object when used appropriately: it doesn't + mean that writing a READONLY mem won't trap. + + In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index + (or slice of the array) always belongs to the range of the array. + I.e. that the access will not trap, provided that the access to + the base to the array will not trap. */ +#define TREE_THIS_NOTRAP(NODE) \ + (TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \ + ARRAY_RANGE_REF)->base.nothrow_flag) + +/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node, + nonzero means it may not be the lhs of an assignment. + Nonzero in a FUNCTION_DECL means this function should be treated + as "const" function (can only read its arguments). */ +#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag) + +/* Value of expression is constant. Always on in all ..._CST nodes. May + also appear in an expression or decl where the value is constant. */ +#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->base.constant_flag) + +/* Nonzero if NODE, a type, has had its sizes gimplified. */ +#define TYPE_SIZES_GIMPLIFIED(NODE) \ + (TYPE_CHECK (NODE)->base.constant_flag) + +/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */ +#define DECL_UNSIGNED(NODE) \ + (DECL_COMMON_CHECK (NODE)->base.unsigned_flag) + +/* In integral and pointer types, means an unsigned type. */ +#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.unsigned_flag) + +/* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written. + Nonzero in a FUNCTION_DECL means that the function has been compiled. + This is interesting in an inline function, since it might not need + to be compiled separately. + Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE + if the debugging info for the type has been written. + In a BLOCK node, nonzero if reorder_blocks has already seen this block. + In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal + PHI node. */ +#define TREE_ASM_WRITTEN(NODE) ((NODE)->base.asm_written_flag) + +/* Nonzero in a _DECL if the name is used in its scope. + Nonzero in an expr node means inhibit warning if value is unused. + In IDENTIFIER_NODEs, this means that some extern decl for this name + was used. + In a BLOCK, this means that the block contains variables that are used. */ +#define TREE_USED(NODE) ((NODE)->base.used_flag) + +/* In a FUNCTION_DECL, nonzero means a call to the function cannot + throw an exception. In a CALL_EXPR, nonzero means the call cannot + throw. We can't easily check the node type here as the C++ + frontend also uses this flag (for AGGR_INIT_EXPR). */ +#define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_flag) + +/* In a CALL_EXPR, means that it's safe to use the target of the call + expansion as the return slot for a call that returns in memory. */ +#define CALL_EXPR_RETURN_SLOT_OPT(NODE) \ + (CALL_EXPR_CHECK (NODE)->base.private_flag) + +/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is + passed by invisible reference (and the TREE_TYPE is a pointer to the true + type). */ +#define DECL_BY_REFERENCE(NODE) \ + (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \ + RESULT_DECL)->decl_common.decl_by_reference_flag) + +/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that this decl + can be used as restricted tag to disambiguate against other restrict + pointers. Used by fortran to capture something like non-addressability + (which it isn't really because the middle-end does take addresses of + such variables). */ +#define DECL_RESTRICTED_P(NODE) \ + (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \ + RESULT_DECL)->decl_common.decl_restricted_flag) + +#define DECL_READ_P(NODE) \ + (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag) + +#define DECL_NONSHAREABLE(NODE) \ + (TREE_CHECK2 (NODE, VAR_DECL, \ + RESULT_DECL)->decl_common.decl_nonshareable_flag) + +/* In a CALL_EXPR, means that the call is the jump from a thunk to the + thunked-to function. */ +#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag) + +/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that + it has been built for the declaration of a variable-sized object. */ +#define ALLOCA_FOR_VAR_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag) + +/* In a type, nonzero means that all objects of the type are guaranteed by the + language or front-end to be properly aligned, so we can indicate that a MEM + of this type is aligned at least to the alignment of the type, even if it + doesn't appear that it is. We see this, for example, in object-oriented + languages where a tag field may show this is an object of a more-aligned + variant of the more generic type. + + In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME + freelist. */ +#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->base.nothrow_flag) + +/* Used in classes in C++. */ +#define TREE_PRIVATE(NODE) ((NODE)->base.private_flag) +/* Used in classes in C++. */ +#define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag) + +/* True if reference type NODE is a C++ rvalue reference. */ +#define TYPE_REF_IS_RVALUE(NODE) \ + (REFERENCE_TYPE_CHECK (NODE)->base.private_flag) + +/* Nonzero in a _DECL if the use of the name is defined as a + deprecated feature by __attribute__((deprecated)). */ +#define TREE_DEPRECATED(NODE) \ + ((NODE)->base.deprecated_flag) + +/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose + uses are to be substituted for uses of the TREE_CHAINed identifier. */ +#define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \ + (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag) + +/* In fixed-point types, means a saturating type. */ +#define TYPE_SATURATING(NODE) ((NODE)->base.saturating_flag) + +/* Nonzero in an expression, a decl, or a constant node if the node is + the result of a successful constant-folding. */ +#define EXPR_FOLDED(NODE) ((NODE)->base.expr_folded_flag) + +/* These flags are available for each language front end to use internally. */ +#define TREE_LANG_FLAG_0(NODE) ((NODE)->base.lang_flag_0) +#define TREE_LANG_FLAG_1(NODE) ((NODE)->base.lang_flag_1) +#define TREE_LANG_FLAG_2(NODE) ((NODE)->base.lang_flag_2) +#define TREE_LANG_FLAG_3(NODE) ((NODE)->base.lang_flag_3) +#define TREE_LANG_FLAG_4(NODE) ((NODE)->base.lang_flag_4) +#define TREE_LANG_FLAG_5(NODE) ((NODE)->base.lang_flag_5) +#define TREE_LANG_FLAG_6(NODE) ((NODE)->base.lang_flag_6) + +/* Define additional fields and accessors for nodes representing constants. */ + +/* In an INTEGER_CST node. These two together make a 2-word integer. + If the data type is signed, the value is sign-extended to 2 words + even though not all of them may really be in use. + In an unsigned constant shorter than 2 words, the extra bits are 0. */ +#define TREE_INT_CST(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst) +#define TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low) +#define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high) + +#define INT_CST_LT(A, B) \ + (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \ + || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \ + && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) + +#define INT_CST_LT_UNSIGNED(A, B) \ + (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ + < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ + || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ + == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ + && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) + +struct GTY(()) tree_int_cst { + struct tree_common common; + double_int int_cst; +}; + +/* In a REAL_CST node. struct real_value is an opaque entity, with + manipulators defined in real.h. We don't want tree.h depending on + real.h and transitively on tm.h. */ +struct real_value; + +#define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr) +#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE)) + +struct GTY(()) tree_real_cst { + struct tree_common common; + struct real_value * real_cst_ptr; +}; + +/* In a FIXED_CST node. */ +struct fixed_value; + +#define TREE_FIXED_CST_PTR(NODE) \ + (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr) +#define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE)) + +struct GTY(()) tree_fixed_cst { + struct tree_common common; + struct fixed_value * fixed_cst_ptr; +}; + +/* In a STRING_CST */ +#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length) +#define TREE_STRING_POINTER(NODE) \ + ((const char *)(STRING_CST_CHECK (NODE)->string.str)) + +struct GTY(()) tree_string { + struct tree_common common; + int length; + char str[1]; +}; + +/* In a COMPLEX_CST node. */ +#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real) +#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag) + +struct GTY(()) tree_complex { + struct tree_common common; + tree real; + tree imag; +}; + +/* In a VECTOR_CST node. */ +#define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements) + +struct GTY(()) tree_vector { + struct tree_common common; + tree elements; +}; + +#include "symtab.h" + +/* Define fields and accessors for some special-purpose tree nodes. */ + +#define IDENTIFIER_LENGTH(NODE) \ + (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len) +#define IDENTIFIER_POINTER(NODE) \ + ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str) +#define IDENTIFIER_HASH_VALUE(NODE) \ + (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value) + +/* Translate a hash table identifier pointer to a tree_identifier + pointer, and vice versa. */ + +#define HT_IDENT_TO_GCC_IDENT(NODE) \ + ((tree) ((char *) (NODE) - sizeof (struct tree_common))) +#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id) + +struct GTY(()) tree_identifier { + struct tree_common common; + struct ht_identifier id; +}; + +/* In a TREE_LIST node. */ +#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose) +#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value) + +struct GTY(()) tree_list { + struct tree_common common; + tree purpose; + tree value; +}; + +/* In a TREE_VEC node. */ +#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length) +#define TREE_VEC_END(NODE) \ + ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length])) + +#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I) + +struct GTY(()) tree_vec { + struct tree_common common; + int length; + tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1]; +}; + +/* In a CONSTRUCTOR node. */ +#define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts) +#define CONSTRUCTOR_ELT(NODE,IDX) \ + (VEC_index (constructor_elt, CONSTRUCTOR_ELTS (NODE), IDX)) +#define CONSTRUCTOR_NELTS(NODE) \ + (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (NODE))) + +/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the + value of each element (stored within VAL). IX must be a scratch variable + of unsigned integer type. */ +#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \ + for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \ + ? false \ + : ((VAL = VEC_index (constructor_elt, V, IX)->value), \ + true); \ + (IX)++) + +/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both + the value of each element (stored within VAL) and its index (stored + within INDEX). IX must be a scratch variable of unsigned integer type. */ +#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \ + for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \ + ? false \ + : (((void) (VAL = VEC_index (constructor_elt, V, IX)->value)), \ + (INDEX = VEC_index (constructor_elt, V, IX)->index), \ + true); \ + (IX)++) + +/* Append a new constructor element to V, with the specified INDEX and VAL. */ +#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \ + do { \ + constructor_elt *_ce___ = VEC_safe_push (constructor_elt, gc, V, NULL); \ + _ce___->index = INDEX; \ + _ce___->value = VALUE; \ + } while (0) + +/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for + constructor output purposes. */ +#define CONSTRUCTOR_BITFIELD_P(NODE) \ + (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) && DECL_MODE (NODE) != BLKmode) + +/* A single element of a CONSTRUCTOR. VALUE holds the actual value of the + element. INDEX can optionally design the position of VALUE: in arrays, + it is the index where VALUE has to be placed; in structures, it is the + FIELD_DECL of the member. */ +typedef struct GTY(()) constructor_elt_d { + tree index; + tree value; +} constructor_elt; + +DEF_VEC_O(constructor_elt); +DEF_VEC_ALLOC_O(constructor_elt,gc); + +struct GTY(()) tree_constructor { + struct tree_common common; + VEC(constructor_elt,gc) *elts; +}; + +/* Define fields and accessors for some nodes that represent expressions. */ + +/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */ +#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \ + && VOID_TYPE_P (TREE_TYPE (NODE)) \ + && integer_zerop (TREE_OPERAND (NODE, 0))) + +/* In ordinary expression nodes. */ +#define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE) +#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I) + +/* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand + length. Its value includes the length operand itself; that is, + the minimum valid length is 1. + Note that we have to bypass the use of TREE_OPERAND to access + that field to avoid infinite recursion in expanding the macros. */ +#define VL_EXP_OPERAND_LENGTH(NODE) \ + ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0])) + +/* Nonzero if is_gimple_debug() may possibly hold. */ +#define MAY_HAVE_DEBUG_STMTS (flag_var_tracking_assignments) + +/* In a LOOP_EXPR node. */ +#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0) + +/* The source location of this expression. Non-tree_exp nodes such as + decls and constants can be shared among multiple locations, so + return nothing. */ +#define EXPR_LOCATION(NODE) \ + (EXPR_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION) +#define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS) +#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION) +#define EXPR_LOC_OR_HERE(NODE) (EXPR_HAS_LOCATION (NODE) ? (NODE)->exp.locus : input_location) +#define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus) +#define EXPR_LINENO(NODE) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus) + +/* True if a tree is an expression or statement that can have a + location. */ +#define CAN_HAVE_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE)) + +extern void protected_set_expr_location (tree, location_t); + +/* In a TARGET_EXPR node. */ +#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0) +#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1) +#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2) + +/* DECL_EXPR accessor. This gives access to the DECL associated with + the given declaration statement. */ +#define DECL_EXPR_DECL(NODE) TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0) + +#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0) + +/* COMPOUND_LITERAL_EXPR accessors. */ +#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE) \ + TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0) +#define COMPOUND_LITERAL_EXPR_DECL(NODE) \ + DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE)) + +/* SWITCH_EXPR accessors. These give access to the condition, body and + original condition type (before any compiler conversions) + of the switch statement, respectively. */ +#define SWITCH_COND(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0) +#define SWITCH_BODY(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1) +#define SWITCH_LABELS(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2) + +/* CASE_LABEL_EXPR accessors. These give access to the high and low values + of a case label, respectively. */ +#define CASE_LOW(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0) +#define CASE_HIGH(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1) +#define CASE_LABEL(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2) + +/* The operands of a TARGET_MEM_REF. Operands 0 and 1 have to match + corresponding MEM_REF operands. */ +#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0)) +#define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1)) +#define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2)) +#define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3)) +#define TMR_INDEX2(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4)) + +/* The operands of a BIND_EXPR. */ +#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0)) +#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1)) +#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2)) + +/* GOTO_EXPR accessor. This gives access to the label associated with + a goto statement. */ +#define GOTO_DESTINATION(NODE) TREE_OPERAND ((NODE), 0) + +/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the + instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and + ASM_CLOBBERS represent the outputs, inputs, and clobbers for the + statement. */ +#define ASM_STRING(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0) +#define ASM_OUTPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1) +#define ASM_INPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2) +#define ASM_CLOBBERS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3) +#define ASM_LABELS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4) +/* Nonzero if we want to create an ASM_INPUT instead of an + ASM_OPERAND with no operands. */ +#define ASM_INPUT_P(NODE) (ASM_EXPR_CHECK (NODE)->base.static_flag) +#define ASM_VOLATILE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.public_flag) + +/* COND_EXPR accessors. */ +#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0)) +#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1)) +#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2)) + +/* Accessors for the chains of recurrences. */ +#define CHREC_VAR(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0) +#define CHREC_LEFT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1) +#define CHREC_RIGHT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 2) +#define CHREC_VARIABLE(NODE) TREE_INT_CST_LOW (CHREC_VAR (NODE)) + +/* LABEL_EXPR accessor. This gives access to the label associated with + the given label expression. */ +#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0) + +/* VDEF_EXPR accessors are specified in tree-flow.h, along with the other + accessors for SSA operands. */ + +/* CATCH_EXPR accessors. */ +#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0) +#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1) + +/* EH_FILTER_EXPR accessors. */ +#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0) +#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1) + +/* OBJ_TYPE_REF accessors. */ +#define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0) +#define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1) +#define OBJ_TYPE_REF_TOKEN(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2) + +/* ASSERT_EXPR accessors. */ +#define ASSERT_EXPR_VAR(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0) +#define ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1) + +/* CALL_EXPR accessors. + */ +#define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1) +#define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2) +#define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3) +#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3) + +/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE. + We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if + the argument count is zero when checking is enabled. Instead, do + the pointer arithmetic to advance past the 3 fixed operands in a + CALL_EXPR. That produces a valid pointer to just past the end of the + operand array, even if it's not valid to dereference it. */ +#define CALL_EXPR_ARGP(NODE) \ + (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3) + +/* OpenMP directive and clause accessors. */ + +#define OMP_BODY(NODE) \ + TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_CRITICAL), 0) +#define OMP_CLAUSES(NODE) \ + TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_SINGLE), 1) + +#define OMP_PARALLEL_BODY(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0) +#define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1) + +#define OMP_TASK_BODY(NODE) TREE_OPERAND (OMP_TASK_CHECK (NODE), 0) +#define OMP_TASK_CLAUSES(NODE) TREE_OPERAND (OMP_TASK_CHECK (NODE), 1) + +#define OMP_TASKREG_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK) +#define OMP_TASKREG_BODY(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0) +#define OMP_TASKREG_CLAUSES(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1) + +#define OMP_FOR_BODY(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 0) +#define OMP_FOR_CLAUSES(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 1) +#define OMP_FOR_INIT(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 2) +#define OMP_FOR_COND(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 3) +#define OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 4) +#define OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 5) + +#define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0) +#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1) + +#define OMP_SECTION_BODY(NODE) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0) + +#define OMP_SINGLE_BODY(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0) +#define OMP_SINGLE_CLAUSES(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1) + +#define OMP_MASTER_BODY(NODE) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0) + +#define OMP_ORDERED_BODY(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0) + +#define OMP_CRITICAL_BODY(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0) +#define OMP_CRITICAL_NAME(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1) + +#define OMP_CLAUSE_CHAIN(NODE) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE)) +#define OMP_CLAUSE_DECL(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \ + OMP_CLAUSE_PRIVATE, \ + OMP_CLAUSE_COPYPRIVATE), 0) +#define OMP_CLAUSE_HAS_LOCATION(NODE) \ + ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus != UNKNOWN_LOCATION) +#define OMP_CLAUSE_LOCATION(NODE) (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus + +/* True on an OMP_SECTION statement that was the last lexical member. + This status is meaningful in the implementation of lastprivate. */ +#define OMP_SECTION_LAST(NODE) \ + (OMP_SECTION_CHECK (NODE)->base.private_flag) + +/* True on an OMP_PARALLEL statement if it represents an explicit + combined parallel work-sharing constructs. */ +#define OMP_PARALLEL_COMBINED(NODE) \ + (OMP_PARALLEL_CHECK (NODE)->base.private_flag) + +/* True on a PRIVATE clause if its decl is kept around for debugging + information only and its DECL_VALUE_EXPR is supposed to point + to what it has been remapped to. */ +#define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \ + (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag) + +/* True on a PRIVATE clause if ctor needs access to outer region's + variable. */ +#define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE) \ + TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)) + +/* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same + decl is present in the chain. */ +#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \ + (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag) +#define OMP_CLAUSE_LASTPRIVATE_STMT(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \ + OMP_CLAUSE_LASTPRIVATE),\ + 1) +#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE) \ + (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init + +#define OMP_CLAUSE_IF_EXPR(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0) +#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0) +#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0) + +#define OMP_CLAUSE_COLLAPSE_EXPR(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0) +#define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1) +#define OMP_CLAUSE_COLLAPSE_COUNT(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2) + +#define OMP_CLAUSE_REDUCTION_CODE(NODE) \ + (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->omp_clause.subcode.reduction_code) +#define OMP_CLAUSE_REDUCTION_INIT(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 1) +#define OMP_CLAUSE_REDUCTION_MERGE(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 2) +#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE) \ + (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init +#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE) \ + (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge +#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \ + OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3) + +enum omp_clause_schedule_kind +{ + OMP_CLAUSE_SCHEDULE_STATIC, + OMP_CLAUSE_SCHEDULE_DYNAMIC, + OMP_CLAUSE_SCHEDULE_GUIDED, + OMP_CLAUSE_SCHEDULE_AUTO, + OMP_CLAUSE_SCHEDULE_RUNTIME +}; + +#define OMP_CLAUSE_SCHEDULE_KIND(NODE) \ + (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind) + +enum omp_clause_default_kind +{ + OMP_CLAUSE_DEFAULT_UNSPECIFIED, + OMP_CLAUSE_DEFAULT_SHARED, + OMP_CLAUSE_DEFAULT_NONE, + OMP_CLAUSE_DEFAULT_PRIVATE, + OMP_CLAUSE_DEFAULT_FIRSTPRIVATE +}; + +#define OMP_CLAUSE_DEFAULT_KIND(NODE) \ + (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind) + +struct GTY(()) tree_exp { + struct tree_common common; + location_t locus; + tree block; + tree GTY ((special ("tree_exp"), + desc ("TREE_CODE ((tree) &%0)"))) + operands[1]; +}; + +/* SSA_NAME accessors. */ + +/* Returns the variable being referenced. Once released, this is the + only field that can be relied upon. */ +#define SSA_NAME_VAR(NODE) SSA_NAME_CHECK (NODE)->ssa_name.var + +/* Returns the statement which defines this SSA name. */ +#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->ssa_name.def_stmt + +/* Returns the SSA version number of this SSA name. Note that in + tree SSA, version numbers are not per variable and may be recycled. */ +#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->ssa_name.version + +/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are + never output, so we can safely use the ASM_WRITTEN_FLAG for this + status bit. */ +#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \ + SSA_NAME_CHECK (NODE)->base.asm_written_flag + +/* Nonzero if this SSA_NAME expression is currently on the free list of + SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing + has no meaning for an SSA_NAME. */ +#define SSA_NAME_IN_FREE_LIST(NODE) \ + SSA_NAME_CHECK (NODE)->base.nothrow_flag + +/* Nonzero if this SSA_NAME is the default definition for the + underlying symbol. A default SSA name is created for symbol S if + the very first reference to S in the function is a read operation. + Default definitions are always created by an empty statement and + belong to no basic block. */ +#define SSA_NAME_IS_DEFAULT_DEF(NODE) \ + SSA_NAME_CHECK (NODE)->base.default_def_flag + +/* Attributes for SSA_NAMEs for pointer-type variables. */ +#define SSA_NAME_PTR_INFO(N) \ + SSA_NAME_CHECK (N)->ssa_name.ptr_info + +/* Defined in tree-flow.h. */ +struct ptr_info_def; + +/* Immediate use linking structure. This structure is used for maintaining + a doubly linked list of uses of an SSA_NAME. */ +typedef struct GTY(()) ssa_use_operand_d { + struct ssa_use_operand_d* GTY((skip(""))) prev; + struct ssa_use_operand_d* GTY((skip(""))) next; + /* Immediate uses for a given SSA name are maintained as a cyclic + list. To recognize the root of this list, the location field + needs to point to the original SSA name. Since statements and + SSA names are of different data types, we need this union. See + the explanation in struct immediate_use_iterator_d. */ + union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc; + tree *GTY((skip(""))) use; +} ssa_use_operand_t; + +/* Return the immediate_use information for an SSA_NAME. */ +#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses + +struct GTY(()) tree_ssa_name { + struct tree_common common; + + /* _DECL wrapped by this SSA name. */ + tree var; + + /* Statement that defines this SSA name. */ + gimple def_stmt; + + /* SSA version number. */ + unsigned int version; + + /* Pointer attributes used for alias analysis. */ + struct ptr_info_def *ptr_info; + + /* Immediate uses list for this SSA_NAME. */ + struct ssa_use_operand_d imm_uses; +}; + +struct GTY(()) phi_arg_d { + /* imm_use MUST be the first element in struct because we do some + pointer arithmetic with it. See phi_arg_index_from_use. */ + struct ssa_use_operand_d imm_use; + tree def; + location_t locus; +}; + + +#define OMP_CLAUSE_CODE(NODE) \ + (OMP_CLAUSE_CHECK (NODE))->omp_clause.code + +#define OMP_CLAUSE_SET_CODE(NODE, CODE) \ + ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE)) + +#define OMP_CLAUSE_CODE(NODE) \ + (OMP_CLAUSE_CHECK (NODE))->omp_clause.code + +#define OMP_CLAUSE_OPERAND(NODE, I) \ + OMP_CLAUSE_ELT_CHECK (NODE, I) + +struct GTY(()) tree_omp_clause { + struct tree_common common; + location_t locus; + enum omp_clause_code code; + union omp_clause_subcode { + enum omp_clause_default_kind default_kind; + enum omp_clause_schedule_kind schedule_kind; + enum tree_code reduction_code; + } GTY ((skip)) subcode; + + /* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's + usage. */ + gimple_seq gimple_reduction_init; + gimple_seq gimple_reduction_merge; + + tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1]; +}; + + +/* In a BLOCK node. */ +#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars) +#define BLOCK_NONLOCALIZED_VARS(NODE) \ + (BLOCK_CHECK (NODE)->block.nonlocalized_vars) +#define BLOCK_NUM_NONLOCALIZED_VARS(NODE) \ + VEC_length (tree, BLOCK_NONLOCALIZED_VARS (NODE)) +#define BLOCK_NONLOCALIZED_VAR(NODE,N) \ + VEC_index (tree, BLOCK_NONLOCALIZED_VARS (NODE), N) +#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks) +#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext) +/* Note: when changing this, make sure to find the places + that use chainon or nreverse. */ +#define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE)) +#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin) +#define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag) + +/* An index number for this block. These values are not guaranteed to + be unique across functions -- whether or not they are depends on + the debugging output format in use. */ +#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num) + +/* If block reordering splits a lexical block into discontiguous + address ranges, we'll make a copy of the original block. + + Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN. + In that case, we have one source block that has been replicated + (through inlining or unrolling) into many logical blocks, and that + these logical blocks have different physical variables in them. + + In this case, we have one logical block split into several + non-contiguous address ranges. Most debug formats can't actually + represent this idea directly, so we fake it by creating multiple + logical blocks with the same variables in them. However, for those + that do support non-contiguous regions, these allow the original + logical block to be reconstructed, along with the set of address + ranges. + + One of the logical block fragments is arbitrarily chosen to be + the ORIGIN. The other fragments will point to the origin via + BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer + be null. The list of fragments will be chained through + BLOCK_FRAGMENT_CHAIN from the origin. */ + +#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin) +#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain) + +/* For an inlined function, this gives the location where it was called + from. This is only set in the top level block, which corresponds to the + inlined function scope. This is used in the debug output routines. */ + +#define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus) + +struct GTY(()) tree_block { + struct tree_common common; + + unsigned abstract_flag : 1; + unsigned block_num : 31; + + location_t locus; + + tree vars; + VEC(tree,gc) *nonlocalized_vars; + + tree subblocks; + tree supercontext; + tree abstract_origin; + tree fragment_origin; + tree fragment_chain; +}; + +/* Define fields and accessors for nodes representing data types. */ + +/* See tree.def for documentation of the use of these fields. + Look at the documentation of the various ..._TYPE tree codes. + + Note that the type.values, type.minval, and type.maxval fields are + overloaded and used for different macros in different kinds of types. + Each macro must check to ensure the tree node is of the proper kind of + type. Note also that some of the front-ends also overload these fields, + so they must be checked as well. */ + +#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid) +#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size) +#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit) +#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values) +#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values) +#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values) +#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values) +#define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval) +#define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval) +#define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values) +#define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval) +#define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval) +#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to) +#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to) +#define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval) +#define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval) +#define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval) +#define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval) +#define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision) +#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name) +#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant) +#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant) +#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context) +#define TYPE_MAXVAL(NODE) (TYPE_CHECK (NODE)->type.maxval) +#define TYPE_MINVAL(NODE) (TYPE_CHECK (NODE)->type.minval) + +/* Vector types need to check target flags to determine type. */ +extern enum machine_mode vector_type_mode (const_tree); +#define TYPE_MODE(NODE) \ + (TREE_CODE (TYPE_CHECK (NODE)) == VECTOR_TYPE \ + ? vector_type_mode (NODE) : (NODE)->type.mode) +#define SET_TYPE_MODE(NODE, MODE) \ + (TYPE_CHECK (NODE)->type.mode = (MODE)) + +/* The "canonical" type for this type node, which is used by frontends to + compare the type for equality with another type. If two types are + equal (based on the semantics of the language), then they will have + equivalent TYPE_CANONICAL entries. + + As a special case, if TYPE_CANONICAL is NULL_TREE, and thus + TYPE_STRUCTURAL_EQUALITY_P is true, then it cannot + be used for comparison against other types. Instead, the type is + said to require structural equality checks, described in + TYPE_STRUCTURAL_EQUALITY_P. + + For unqualified aggregate and function types the middle-end relies on + TYPE_CANONICAL to tell whether two variables can be assigned + to each other without a conversion. The middle-end also makes sure + to assign the same alias-sets to the type partition with equal + TYPE_CANONICAL of their unqualified variants. */ +#define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type.canonical) +/* Indicates that the type node requires structural equality + checks. The compiler will need to look at the composition of the + type to determine whether it is equal to another type, rather than + just comparing canonical type pointers. For instance, we would need + to look at the return and parameter types of a FUNCTION_TYPE + node. */ +#define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE) +/* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the + type node requires structural equality. */ +#define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE) + +#define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific) +#define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE))) +#define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE))) + +/* For record and union types, information about this type, as a base type + for itself. */ +#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo) + +/* For non record and union types, used in a language-dependent way. */ +#define TYPE_LANG_SLOT_1(NODE) (NOT_RECORD_OR_UNION_CHECK(NODE)->type.binfo) + +/* The (language-specific) typed-based alias set for this type. + Objects whose TYPE_ALIAS_SETs are different cannot alias each + other. If the TYPE_ALIAS_SET is -1, no alias set has yet been + assigned to this type. If the TYPE_ALIAS_SET is 0, objects of this + type can alias objects of any type. */ +#define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type.alias_set) + +/* Nonzero iff the typed-based alias set for this type has been + calculated. */ +#define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1) + +/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply + to this type. */ +#define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type.attributes) + +/* The alignment necessary for objects of this type. + The value is an int, measured in bits. */ +#define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align) + +/* 1 if the alignment for this type was requested by "aligned" attribute, + 0 if it is the default for this type. */ +#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->common.base.user_align) + +/* The alignment for NODE, in bytes. */ +#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT) + +/* If your language allows you to declare types, and you want debug info + for them, then you need to generate corresponding TYPE_DECL nodes. + These "stub" TYPE_DECL nodes have no name, and simply point at the + type node. You then set the TYPE_STUB_DECL field of the type node + to point back at the TYPE_DECL node. This allows the debug routines + to know that the two nodes represent the same type, so that we only + get one debug info record for them. */ +#define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE) + +/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type + has BLKmode only because it lacks the alignment requirement for + its size. */ +#define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag) + +/* In an INTEGER_TYPE, it means the type represents a size. We use + this both for validity checking and to permit optimizations that + are unsafe for other types. Note that the C `size_t' type should + *not* have this flag set. The `size_t' type is simply a typedef + for an ordinary integer type that happens to be the type of an + expression returned by `sizeof'; `size_t' has no special + properties. Expressions whose type have TYPE_IS_SIZETYPE set are + always actual sizes. */ +#define TYPE_IS_SIZETYPE(NODE) \ + (INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag) + +/* Nonzero in a type considered volatile as a whole. */ +#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->base.volatile_flag) + +/* Means this type is const-qualified. */ +#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->base.readonly_flag) + +/* If nonzero, this type is `restrict'-qualified, in the C sense of + the term. */ +#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag) + +/* If nonzero, type's name shouldn't be emitted into debug info. */ +#define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.nameless_flag) + +/* The address space the type is in. */ +#define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.address_space) + +/* There is a TYPE_QUAL value for each type qualifier. They can be + combined by bitwise-or to form the complete set of qualifiers for a + type. */ + +#define TYPE_UNQUALIFIED 0x0 +#define TYPE_QUAL_CONST 0x1 +#define TYPE_QUAL_VOLATILE 0x2 +#define TYPE_QUAL_RESTRICT 0x4 + +/* Encode/decode the named memory support as part of the qualifier. If more + than 8 qualifiers are added, these macros need to be adjusted. */ +#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8) +#define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF) + +/* Return all qualifiers except for the address space qualifiers. */ +#define CLEAR_QUAL_ADDR_SPACE(X) ((X) & ~0xFF00) + +/* Only keep the address space out of the qualifiers and discard the other + qualifiers. */ +#define KEEP_QUAL_ADDR_SPACE(X) ((X) & 0xFF00) + +/* The set of type qualifiers for this type. */ +#define TYPE_QUALS(NODE) \ + ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \ + | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \ + | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT) \ + | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))) + +/* The same as TYPE_QUALS without the address space qualifications. */ +#define TYPE_QUALS_NO_ADDR_SPACE(NODE) \ + ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \ + | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \ + | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)) + +/* These flags are available for each language front end to use internally. */ +#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0) +#define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type.lang_flag_1) +#define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type.lang_flag_2) +#define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type.lang_flag_3) +#define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type.lang_flag_4) +#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5) +#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6) + +/* Used to keep track of visited nodes in tree traversals. This is set to + 0 by copy_node and make_node. */ +#define TREE_VISITED(NODE) ((NODE)->base.visited) + +/* If set in an ARRAY_TYPE, indicates a string type (for languages + that distinguish string from array of char). + If set in a INTEGER_TYPE, indicates a character type. */ +#define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag) + +/* If non-NULL, this is an upper bound of the size (in bytes) of an + object of the given ARRAY_TYPE. This allows temporaries to be + allocated. */ +#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \ + (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type.maxval) + +/* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */ +#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \ + (((unsigned HOST_WIDE_INT) 1) \ + << VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision) + +/* Set precision to n when we have 2^n sub-parts of the vector. */ +#define SET_TYPE_VECTOR_SUBPARTS(VECTOR_TYPE, X) \ + (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision = exact_log2 (X)) + +/* Nonzero in a VECTOR_TYPE if the frontends should not emit warnings + about missing conversions to other vector types of the same size. */ +#define TYPE_VECTOR_OPAQUE(NODE) \ + (VECTOR_TYPE_CHECK (NODE)->base.default_def_flag) + +/* Indicates that objects of this type must be initialized by calling a + function when they are created. */ +#define TYPE_NEEDS_CONSTRUCTING(NODE) \ + (TYPE_CHECK (NODE)->type.needs_constructing_flag) + +/* Indicates that a UNION_TYPE object should be passed the same way that + the first union alternative would be passed, or that a RECORD_TYPE + object should be passed the same way that the first (and only) member + would be passed. */ +#define TYPE_TRANSPARENT_AGGR(NODE) \ + (RECORD_OR_UNION_CHECK (NODE)->type.transparent_aggr_flag) + +/* For an ARRAY_TYPE, indicates that it is not permitted to take the + address of a component of the type. This is the counterpart of + DECL_NONADDRESSABLE_P for arrays, see the definition of this flag. */ +#define TYPE_NONALIASED_COMPONENT(NODE) \ + (ARRAY_TYPE_CHECK (NODE)->type.transparent_aggr_flag) + +/* Indicated that objects of this type should be laid out in as + compact a way as possible. */ +#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->common.base.packed_flag) + +/* Used by type_contains_placeholder_p to avoid recomputation. + Values are: 0 (unknown), 1 (false), 2 (true). Never access + this field directly. */ +#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \ + (TYPE_CHECK (NODE)->type.contains_placeholder_bits) + +/* The debug output functions use the symtab union field to store + information specific to the debugging format. The different debug + output hooks store different types in the union field. These three + macros are used to access different fields in the union. The debug + hooks are responsible for consistently using only a specific + macro. */ + +/* Symtab field as an integer. Used by stabs generator in dbxout.c to + hold the type's number in the generated stabs. */ +#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address) + +/* Symtab field as a string. Used by COFF generator in sdbout.c to + hold struct/union type tag names. */ +#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer) + +/* Symtab field as a pointer to a DWARF DIE. Used by DWARF generator + in dwarf2out.c to point to the DIE generated for the type. */ +#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die) + +/* The garbage collector needs to know the interpretation of the + symtab field. These constants represent the different types in the + union. */ + +#define TYPE_SYMTAB_IS_ADDRESS (0) +#define TYPE_SYMTAB_IS_POINTER (1) +#define TYPE_SYMTAB_IS_DIE (2) + +struct die_struct; + +struct GTY(()) tree_type { + struct tree_common common; + tree values; + tree size; + tree size_unit; + tree attributes; + unsigned int uid; + + unsigned int precision : 10; + unsigned no_force_blk_flag : 1; + unsigned needs_constructing_flag : 1; + unsigned transparent_aggr_flag : 1; + unsigned restrict_flag : 1; + unsigned contains_placeholder_bits : 2; + + ENUM_BITFIELD(machine_mode) mode : 8; + + unsigned string_flag : 1; + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; + + unsigned int align; + alias_set_type alias_set; + tree pointer_to; + tree reference_to; + union tree_type_symtab { + int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address; + const char * GTY ((tag ("TYPE_SYMTAB_IS_POINTER"))) pointer; + struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die; + } GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab; + tree name; + tree minval; + tree maxval; + tree next_variant; + tree main_variant; + tree binfo; + tree context; + tree canonical; + /* Points to a structure whose details depend on the language in use. */ + struct lang_type *lang_specific; +}; + +/* Define accessor macros for information about type inheritance + and basetypes. + + A "basetype" means a particular usage of a data type for inheritance + in another type. Each such basetype usage has its own "binfo" + object to describe it. The binfo object is a TREE_VEC node. + + Inheritance is represented by the binfo nodes allocated for a + given type. For example, given types C and D, such that D is + inherited by C, 3 binfo nodes will be allocated: one for describing + the binfo properties of C, similarly one for D, and one for + describing the binfo properties of D as a base type for C. + Thus, given a pointer to class C, one can get a pointer to the binfo + of D acting as a basetype for C by looking at C's binfo's basetypes. */ + +/* BINFO specific flags. */ + +/* Nonzero means that the derivation chain is via a `virtual' declaration. */ +#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag) + +/* Flags for language dependent use. */ +#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0(TREE_BINFO_CHECK(NODE)) +#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1(TREE_BINFO_CHECK(NODE)) +#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2(TREE_BINFO_CHECK(NODE)) +#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3(TREE_BINFO_CHECK(NODE)) +#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4(TREE_BINFO_CHECK(NODE)) +#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5(TREE_BINFO_CHECK(NODE)) +#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6(TREE_BINFO_CHECK(NODE)) + +/* The actual data type node being inherited in this basetype. */ +#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE)) + +/* The offset where this basetype appears in its containing type. + BINFO_OFFSET slot holds the offset (in bytes) + from the base of the complete object to the base of the part of the + object that is allocated on behalf of this `type'. + This is always 0 except when there is multiple inheritance. */ + +#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset) +#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE))) + +/* The virtual function table belonging to this basetype. Virtual + function tables provide a mechanism for run-time method dispatching. + The entries of a virtual function table are language-dependent. */ + +#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable) + +/* The virtual functions in the virtual function table. This is + a TREE_LIST that is used as an initial approximation for building + a virtual function table for this basetype. */ +#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals) + +/* A vector of binfos for the direct basetypes inherited by this + basetype. + + If this basetype describes type D as inherited in C, and if the + basetypes of D are E and F, then this vector contains binfos for + inheritance of E and F by C. */ +#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK(NODE)->binfo.base_binfos) + +/* The number of basetypes for NODE. */ +#define BINFO_N_BASE_BINFOS(NODE) (VEC_length (tree, BINFO_BASE_BINFOS (NODE))) + +/* Accessor macro to get to the Nth base binfo of this binfo. */ +#define BINFO_BASE_BINFO(NODE,N) \ + (VEC_index (tree, BINFO_BASE_BINFOS (NODE), (N))) +#define BINFO_BASE_ITERATE(NODE,N,B) \ + (VEC_iterate (tree, BINFO_BASE_BINFOS (NODE), (N), (B))) +#define BINFO_BASE_APPEND(NODE,T) \ + (VEC_quick_push (tree, BINFO_BASE_BINFOS (NODE), (T))) + +/* For a BINFO record describing a virtual base class, i.e., one where + TREE_VIA_VIRTUAL is set, this field assists in locating the virtual + base. The actual contents are language-dependent. In the C++ + front-end this field is an INTEGER_CST giving an offset into the + vtable where the offset to the virtual base can be found. */ +#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field) + +/* Indicates the accesses this binfo has to its bases. The values are + access_public_node, access_protected_node or access_private_node. + If this array is not present, public access is implied. */ +#define BINFO_BASE_ACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses) + +#define BINFO_BASE_ACCESS(NODE,N) \ + VEC_index (tree, BINFO_BASE_ACCESSES (NODE), (N)) +#define BINFO_BASE_ACCESS_APPEND(NODE,T) \ + VEC_quick_push (tree, BINFO_BASE_ACCESSES (NODE), (T)) + +/* The index in the VTT where this subobject's sub-VTT can be found. + NULL_TREE if there is no sub-VTT. */ +#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_subvtt) + +/* The index in the VTT where the vptr for this subobject can be + found. NULL_TREE if there is no secondary vptr in the VTT. */ +#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr) + +/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base + inheriting this base for non-virtual bases. For virtual bases it + points either to the binfo for which this is a primary binfo, or to + the binfo of the most derived type. */ +#define BINFO_INHERITANCE_CHAIN(NODE) \ + (TREE_BINFO_CHECK(NODE)->binfo.inheritance) + +struct GTY (()) tree_binfo { + struct tree_common common; + + tree offset; + tree vtable; + tree virtuals; + tree vptr_field; + VEC(tree,gc) *base_accesses; + tree inheritance; + + tree vtt_subvtt; + tree vtt_vptr; + + VEC(tree,none) base_binfos; +}; + + +/* Define fields and accessors for nodes representing declared names. */ + +/* Nonzero if DECL represents a variable for the SSA passes. */ +#define SSA_VAR_P(DECL) \ + (TREE_CODE (DECL) == VAR_DECL \ + || TREE_CODE (DECL) == PARM_DECL \ + || TREE_CODE (DECL) == RESULT_DECL \ + || (TREE_CODE (DECL) == SSA_NAME \ + && (TREE_CODE (SSA_NAME_VAR (DECL)) == VAR_DECL \ + || TREE_CODE (SSA_NAME_VAR (DECL)) == PARM_DECL \ + || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL))) + + + + +/* Enumerate visibility settings. */ +#ifndef SYMBOL_VISIBILITY_DEFINED +#define SYMBOL_VISIBILITY_DEFINED +enum symbol_visibility +{ + VISIBILITY_DEFAULT, + VISIBILITY_PROTECTED, + VISIBILITY_HIDDEN, + VISIBILITY_INTERNAL +}; +#endif + +struct function; + +#define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE))) + +/* This is the name of the object as written by the user. + It is an IDENTIFIER_NODE. */ +#define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name) + +/* Every ..._DECL node gets a unique number. */ +#define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid) + +/* DEBUG_EXPR_DECLs get negative UID numbers, to catch erroneous + uses. */ +#define DEBUG_TEMP_UID(NODE) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL))) + +/* Every ..._DECL node gets a unique number that stays the same even + when the decl is copied by the inliner once it is set. */ +#define DECL_PT_UID(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \ + ? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid) +/* Initialize the ..._DECL node pt-uid to the decls uid. */ +#define SET_DECL_PT_UID(NODE, UID) \ + (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID)) +/* Whether the ..._DECL node pt-uid has been initialized and thus needs to + be preserved when copyin the decl. */ +#define DECL_PT_UID_SET_P(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u) + +/* These two fields describe where in the source code the declaration + was. If the declaration appears in several places (as for a C + function that is declared first and then defined later), this + information should refer to the definition. */ +#define DECL_SOURCE_LOCATION(NODE) \ + (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus) +#define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE)) +#define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE)) +#define DECL_IS_BUILTIN(DECL) \ + (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION) + +/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or + QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL, + PARM_DECL, FUNCTION_DECL, LABEL_DECL, RESULT_DECL, and CONST_DECL + nodes, this points to either the FUNCTION_DECL for the containing + function, the RECORD_TYPE or UNION_TYPE for the containing type, or + NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file + scope". */ +#define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context) +#define DECL_FIELD_CONTEXT(NODE) \ + (FIELD_DECL_CHECK (NODE)->decl_minimal.context) + +/* If nonzero, decl's name shouldn't be emitted into debug info. */ +#define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.nameless_flag) + +struct GTY(()) tree_decl_minimal { + struct tree_common common; + location_t locus; + unsigned int uid; + tree name; + tree context; +}; + + +/* For any sort of a ..._DECL node, this points to the original (abstract) + decl node which this decl is an inlined/cloned instance of, or else it + is NULL indicating that this decl is not an instance of some other decl. + + The C front-end also uses this in a nested declaration of an inline + function, to point back to the definition. */ +#define DECL_ABSTRACT_ORIGIN(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin) + +/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract + origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */ +#define DECL_ORIGIN(NODE) \ + (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE)) + +/* Nonzero for any sort of ..._DECL node means this decl node represents an + inline instance of some original (abstract) decl from an inline function; + suppress any warnings about shadowing some other variable. FUNCTION_DECL + nodes can also have their abstract origin set to themselves. */ +#define DECL_FROM_INLINE(NODE) \ + (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \ + && DECL_ABSTRACT_ORIGIN (NODE) != (NODE)) + +/* In a DECL this is the field where attributes are stored. */ +#define DECL_ATTRIBUTES(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.attributes) + +/* For a FUNCTION_DECL, holds the tree of BINDINGs. + For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK. + For a VAR_DECL, holds the initial value. + For a PARM_DECL, used for DECL_ARG_TYPE--default + values for parameters are encoded in the type of the function, + not in the PARM_DECL slot. + For a FIELD_DECL, this is used for enumeration values and the C + frontend uses it for temporarily storing bitwidth of bitfields. + + ??? Need to figure out some way to check this isn't a PARM_DECL. */ +#define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial) + +/* Holds the size of the datum, in bits, as a tree expression. + Need not be constant. */ +#define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size) +/* Likewise for the size in bytes. */ +#define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit) +/* Holds the alignment required for the datum, in bits. */ +#define DECL_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align) +/* The alignment of NODE, in bytes. */ +#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT) +/* Set if the alignment of this DECL has been set by the user, for + example with an 'aligned' attribute. */ +#define DECL_USER_ALIGN(NODE) \ + (DECL_COMMON_CHECK (NODE)->common.base.user_align) +/* Holds the machine mode corresponding to the declaration of a variable or + field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a + FIELD_DECL. */ +#define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode) + +/* For FUNCTION_DECL, if it is built-in, this identifies which built-in + operation it is. Note, however, that this field is overloaded, with + DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be + checked before any access to the former. */ +#define DECL_FUNCTION_CODE(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code) +#define DECL_DEBUG_EXPR_IS_FROM(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.debug_expr_is_from) + +#define DECL_FUNCTION_PERSONALITY(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.personality) + +/* Nonzero for a given ..._DECL node means that the name of this node should + be ignored for symbolic debug purposes. For a TYPE_DECL, this means that + the associated type should be ignored. For a FUNCTION_DECL, the body of + the function should also be ignored. */ +#define DECL_IGNORED_P(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag) + +/* Nonzero for a given ..._DECL node means that this node represents an + "abstract instance" of the given declaration (e.g. in the original + declaration of an inline function). When generating symbolic debugging + information, we mustn't try to generate any address information for nodes + marked as "abstract instances" because we don't actually generate + any code or allocate any data space for such instances. */ +#define DECL_ABSTRACT(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag) + +/* Language-specific decl information. */ +#define DECL_LANG_SPECIFIC(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific) + +/* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference: + do not allocate storage, and refer to a definition elsewhere. Note that + this does not necessarily imply the entity represented by NODE + has no program source-level definition in this translation unit. For + example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and + DECL_EXTERNAL may be true simultaneously; that can be the case for + a C99 "extern inline" function. */ +#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1) + +/* Nonzero in a ..._DECL means this variable is ref'd from a nested function. + For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes. + + For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted. + + Also set in some languages for variables, etc., outside the normal + lexical scope, such as class instance variables. */ +#define DECL_NONLOCAL(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag) + +/* Used in VAR_DECLs to indicate that the variable is a vtable. + Used in FIELD_DECLs for vtable pointers. + Used in FUNCTION_DECLs to indicate that the function is virtual. */ +#define DECL_VIRTUAL_P(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag) + +/* Used to indicate that this DECL represents a compiler-generated entity. */ +#define DECL_ARTIFICIAL(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag) + +/* Additional flags for language-specific uses. */ +#define DECL_LANG_FLAG_0(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0) +#define DECL_LANG_FLAG_1(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1) +#define DECL_LANG_FLAG_2(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2) +#define DECL_LANG_FLAG_3(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3) +#define DECL_LANG_FLAG_4(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4) +#define DECL_LANG_FLAG_5(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5) +#define DECL_LANG_FLAG_6(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6) +#define DECL_LANG_FLAG_7(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7) +#define DECL_LANG_FLAG_8(NODE) \ + (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8) + +/* Nonzero for a scope which is equal to file scope. */ +#define SCOPE_FILE_SCOPE_P(EXP) \ + (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL) +/* Nonzero for a decl which is at file scope. */ +#define DECL_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP)) +/* Nonzero for a type which is at file scope. */ +#define TYPE_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP)) + +/* Nonzero for a decl that is decorated using attribute used. + This indicates to compiler tools that this decl needs to be preserved. */ +#define DECL_PRESERVE_P(DECL) \ + DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag + +/* For function local variables of COMPLEX and VECTOR types, + indicates that the variable is not aliased, and that all + modifications to the variable have been adjusted so that + they are killing assignments. Thus the variable may now + be treated as a GIMPLE register, and use real instead of + virtual ops in SSA form. */ +#define DECL_GIMPLE_REG_P(DECL) \ + DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag + +struct GTY(()) tree_decl_common { + struct tree_decl_minimal common; + tree size; + + ENUM_BITFIELD(machine_mode) mode : 8; + + unsigned nonlocal_flag : 1; + unsigned virtual_flag : 1; + unsigned ignored_flag : 1; + unsigned abstract_flag : 1; + unsigned artificial_flag : 1; + unsigned preserve_flag: 1; + unsigned debug_expr_is_from : 1; + + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; + unsigned lang_flag_7 : 1; + unsigned lang_flag_8 : 1; + + /* In LABEL_DECL, this is DECL_ERROR_ISSUED. + In VAR_DECL and PARM_DECL, this is DECL_REGISTER. */ + unsigned decl_flag_0 : 1; + /* In FIELD_DECL, this is DECL_BIT_FIELD + In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL. + In TYPE_DECL, this is TYPE_DECL_SUPPRESS_DEBUG. */ + unsigned decl_flag_1 : 1; + /* In FIELD_DECL, this is DECL_NONADDRESSABLE_P + In VAR_DECL, PARM_DECL and RESULT_DECL, this is + DECL_HAS_VALUE_EXPR_P. */ + unsigned decl_flag_2 : 1; + /* Logically, these two would go in a theoretical base shared by var and + parm decl. */ + unsigned gimple_reg_flag : 1; + /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE. */ + unsigned decl_by_reference_flag : 1; + /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_RESTRICTED_P. */ + unsigned decl_restricted_flag : 1; + + /* In VAR_DECL and PARM_DECL set when the decl has been used except for + being set. */ + unsigned decl_read_flag : 1; + + /* In VAR_DECL or RESULT_DECL set when significant code movement precludes + attempting to share the stack slot with some other variable. */ + unsigned decl_nonshareable_flag : 1; + + /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */ + unsigned int off_align : 8; + + /* 24-bits unused. */ + + /* DECL_ALIGN. It should have the same size as TYPE_ALIGN. */ + unsigned int align; + + /* UID for points-to sets, stable over copying from inlining. */ + unsigned int pt_uid; + + tree size_unit; + tree initial; + tree attributes; + tree abstract_origin; + + /* Points to a structure whose details depend on the language in use. */ + struct lang_decl *lang_specific; +}; + +extern tree decl_value_expr_lookup (tree); +extern void decl_value_expr_insert (tree, tree); + +/* In a VAR_DECL or PARM_DECL, the location at which the value may be found, + if transformations have made this more complicated than evaluating the + decl itself. This should only be used for debugging; once this field has + been set, the decl itself may not legitimately appear in the function. */ +#define DECL_HAS_VALUE_EXPR_P(NODE) \ + (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \ + ->decl_common.decl_flag_2) +#define DECL_VALUE_EXPR(NODE) \ + (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE))) +#define SET_DECL_VALUE_EXPR(NODE, VAL) \ + (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL)) + +/* Holds the RTL expression for the value of a variable or function. + This value can be evaluated lazily for functions, variables with + static storage duration, and labels. */ +#define DECL_RTL(NODE) \ + (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl \ + ? (NODE)->decl_with_rtl.rtl \ + : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl)) + +/* Set the DECL_RTL for NODE to RTL. */ +#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL) + +/* Returns nonzero if NODE is a tree node that can contain RTL. */ +#define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL)) + +/* Returns nonzero if the DECL_RTL for NODE has already been set. */ +#define DECL_RTL_SET_P(NODE) \ + (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL) + +/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for + NODE1, it will not be set for NODE2; this is a lazy copy. */ +#define COPY_DECL_RTL(NODE1, NODE2) \ + (DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl \ + = DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl) + +/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */ +#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL) + +/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */ +#define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0) + +struct GTY(()) tree_decl_with_rtl { + struct tree_decl_common common; + rtx rtl; +}; + +/* In a FIELD_DECL, this is the field position, counting in bytes, of the + DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning + of the structure. */ +#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset) + +/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the + field from DECL_FIELD_OFFSET. This field may be nonzero even for fields + that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the + natural alignment of the field's type). */ +#define DECL_FIELD_BIT_OFFSET(NODE) \ + (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset) + +/* In a FIELD_DECL, this indicates whether the field was a bit-field and + if so, the type that was originally specified for it. + TREE_TYPE may have been modified (in finish_struct). */ +#define DECL_BIT_FIELD_TYPE(NODE) \ + (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type) + +/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which + if nonzero, indicates that the field occupies the type. */ +#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier) + +/* For FIELD_DECLs, off_align holds the number of low-order bits of + DECL_FIELD_OFFSET which are known to be always zero. + DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET + has. */ +#define DECL_OFFSET_ALIGN(NODE) \ + (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.off_align) + +/* Specify that DECL_ALIGN(NODE) is a multiple of X. */ +#define SET_DECL_OFFSET_ALIGN(NODE, X) \ + (FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1) + +/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in + which this FIELD_DECL is defined. This information is needed when + writing debugging information about vfield and vbase decls for C++. */ +#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext) + +/* In a FIELD_DECL, indicates this field should be bit-packed. */ +#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->common.base.packed_flag) + +/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed + specially. */ +#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1) + +/* Used in a FIELD_DECL to indicate that we cannot form the address of + this component. This makes it possible for Type-Based Alias Analysis + to disambiguate accesses to this field with indirect accesses using + the field's type: + + struct S { int i; } s; + int *p; + + If the flag is set on 'i', TBAA computes that s.i and *p never conflict. + + From the implementation's viewpoint, the alias set of the type of the + field 'i' (int) will not be recorded as a subset of that of the type of + 's' (struct S) in record_component_aliases. The counterpart is that + accesses to s.i must not be given the alias set of the type of 'i' + (int) but instead directly that of the type of 's' (struct S). */ +#define DECL_NONADDRESSABLE_P(NODE) \ + (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2) + +struct GTY(()) tree_field_decl { + struct tree_decl_common common; + + tree offset; + tree bit_field_type; + tree qualifier; + tree bit_offset; + tree fcontext; +}; + +/* A numeric unique identifier for a LABEL_DECL. The UID allocation is + dense, unique within any one function, and may be used to index arrays. + If the value is -1, then no UID has been assigned. */ +#define LABEL_DECL_UID(NODE) \ + (LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid) + +/* In a LABEL_DECL, the EH region number for which the label is the + post_landing_pad. */ +#define EH_LANDING_PAD_NR(NODE) \ + (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr) + +/* In LABEL_DECL nodes, nonzero means that an error message about + jumping into such a binding contour has been printed for this label. */ +#define DECL_ERROR_ISSUED(NODE) \ + (LABEL_DECL_CHECK (NODE)->decl_common.decl_flag_0) + +struct GTY(()) tree_label_decl { + struct tree_decl_with_rtl common; + int label_decl_uid; + int eh_landing_pad_nr; +}; + +struct var_ann_d; +struct GTY(()) tree_result_decl { + struct tree_decl_with_rtl common; + struct var_ann_d *ann; +}; + +struct GTY(()) tree_const_decl { + struct tree_decl_with_rtl common; +}; + +/* For a PARM_DECL, records the data type used to pass the argument, + which may be different from the type seen in the program. */ +#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial) + +/* For PARM_DECL, holds an RTL for the stack slot or register + where the data was actually passed. */ +#define DECL_INCOMING_RTL(NODE) \ + (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl) + +struct GTY(()) tree_parm_decl { + struct tree_decl_with_rtl common; + rtx incoming_rtl; + struct var_ann_d *ann; +}; + + +/* Nonzero for a given ..._DECL node means that no warnings should be + generated just because this node is unused. */ +#define DECL_IN_SYSTEM_HEADER(NODE) \ + (in_system_header_at (DECL_SOURCE_LOCATION (NODE))) + +/* Used to indicate that the linkage status of this DECL is not yet known, + so it should not be output now. */ +#define DECL_DEFER_OUTPUT(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output) + +/* In a VAR_DECL that's static, + nonzero if the space is in the text section. */ +#define DECL_IN_TEXT_SECTION(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section) + +/* In a VAR_DECL that's static, + nonzero if it belongs to the global constant pool. */ +#define DECL_IN_CONSTANT_POOL(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool) + +/* Nonzero for a given ..._DECL node means that this node should be + put in .common, if possible. If a DECL_INITIAL is given, and it + is not error_mark_node, then the decl cannot be put in .common. */ +#define DECL_COMMON(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag) + +/* In a VAR_DECL, nonzero if the decl is a register variable with + an explicit asm specification. */ +#define DECL_HARD_REGISTER(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register) + + /* Used to indicate that this DECL has weak linkage. */ +#define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag) + +/* Used to indicate that the DECL is a dllimport. */ +#define DECL_DLLIMPORT_P(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag) + +/* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need + not be put out unless it is needed in this translation unit. + Entities like this are shared across translation units (like weak + entities), but are guaranteed to be generated by any translation + unit that needs them, and therefore need not be put out anywhere + where they are not needed. DECL_COMDAT is just a hint to the + back-end; it is up to front-ends which set this flag to ensure + that there will never be any harm, other than bloat, in putting out + something which is DECL_COMDAT. */ +#define DECL_COMDAT(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag) + +#define DECL_COMDAT_GROUP(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_group) + +/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in + multiple translation units should be merged. */ +#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE) + +/* The name of the object as the assembler will see it (but before any + translations made by ASM_OUTPUT_LABELREF). Often this is the same + as DECL_NAME. It is an IDENTIFIER_NODE. */ +#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE) + +/* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME. + This is true of all DECL nodes except FIELD_DECL. */ +#define HAS_DECL_ASSEMBLER_NAME_P(NODE) \ + (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS)) + +/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero, + the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set + yet. */ +#define DECL_ASSEMBLER_NAME_SET_P(NODE) \ + (HAS_DECL_ASSEMBLER_NAME_P (NODE) \ + && DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != NULL_TREE) + +/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */ +#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME)) + +/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's + DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause + the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the + semantics of using this macro, are different than saying: + + SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1)) + + which will try to set the DECL_ASSEMBLER_NAME for DECL1. */ + +#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \ + (DECL_ASSEMBLER_NAME_SET_P (DECL1) \ + ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \ + DECL_ASSEMBLER_NAME (DECL1)) \ + : (void) 0) + +/* Records the section name in a section attribute. Used to pass + the name from decl_attributes to make_function_rtl and make_decl_rtl. */ +#define DECL_SECTION_NAME(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name) + +/* Nonzero in a decl means that the gimplifier has seen (or placed) + this variable in a BIND_EXPR. */ +#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr) + +/* Value of the decls's visibility attribute */ +#define DECL_VISIBILITY(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility) + +/* Nonzero means that the decl had its visibility specified rather than + being inferred. */ +#define DECL_VISIBILITY_SPECIFIED(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified) + +/* In a VAR_DECL, the model to use if the data should be allocated from + thread-local storage. */ +#define DECL_TLS_MODEL(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model) + +/* In a VAR_DECL, nonzero if the data should be allocated from + thread-local storage. */ +#define DECL_THREAD_LOCAL_P(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model >= TLS_MODEL_REAL) + +/* In a non-local VAR_DECL with static storage duration, true if the + variable has an initialization priority. If false, the variable + will be initialized at the DEFAULT_INIT_PRIORITY. */ +#define DECL_HAS_INIT_PRIORITY_P(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p) + +/* Specify whether the section name was set by user or by + compiler via -ffunction-sections. */ +#define DECL_HAS_IMPLICIT_SECTION_NAME_P(NODE) \ + (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.implicit_section_name_p) + +struct GTY(()) tree_decl_with_vis { + struct tree_decl_with_rtl common; + tree assembler_name; + tree section_name; + tree comdat_group; + + /* Belong to VAR_DECL exclusively. */ + unsigned defer_output : 1; + unsigned hard_register : 1; + unsigned thread_local : 1; + unsigned common_flag : 1; + unsigned in_text_section : 1; + unsigned in_constant_pool : 1; + unsigned dllimport_flag : 1; + /* Don't belong to VAR_DECL exclusively. */ + unsigned weak_flag : 1; + + unsigned seen_in_bind_expr : 1; + unsigned comdat_flag : 1; + ENUM_BITFIELD(symbol_visibility) visibility : 2; + unsigned visibility_specified : 1; + /* Belongs to VAR_DECL exclusively. */ + ENUM_BITFIELD(tls_model) tls_model : 3; + + /* Belong to FUNCTION_DECL exclusively. */ + unsigned init_priority_p : 1; + /* Used by C++ only. Might become a generic decl flag. */ + unsigned shadowed_for_var_p : 1; + /* When SECTION_NAME is implied by -ffunsection-section. */ + unsigned implicit_section_name_p : 1; + /* 13 unused bits. */ +}; + +extern tree decl_debug_expr_lookup (tree); +extern void decl_debug_expr_insert (tree, tree); +/* For VAR_DECL, this is set to either an expression that it was split + from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of + subexpressions that it was split into. */ +#define DECL_DEBUG_EXPR(NODE) \ + (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE))) + +#define SET_DECL_DEBUG_EXPR(NODE, VAL) \ + (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL)) + +/* An initialization priority. */ +typedef unsigned short priority_type; + +extern priority_type decl_init_priority_lookup (tree); +extern priority_type decl_fini_priority_lookup (tree); +extern void decl_init_priority_insert (tree, priority_type); +extern void decl_fini_priority_insert (tree, priority_type); + +/* For a VAR_DECL or FUNCTION_DECL the initialization priority of + NODE. */ +#define DECL_INIT_PRIORITY(NODE) \ + (decl_init_priority_lookup (NODE)) +/* Set the initialization priority for NODE to VAL. */ +#define SET_DECL_INIT_PRIORITY(NODE, VAL) \ + (decl_init_priority_insert (NODE, VAL)) + +/* For a FUNCTION_DECL the finalization priority of NODE. */ +#define DECL_FINI_PRIORITY(NODE) \ + (decl_fini_priority_lookup (NODE)) +/* Set the finalization priority for NODE to VAL. */ +#define SET_DECL_FINI_PRIORITY(NODE, VAL) \ + (decl_fini_priority_insert (NODE, VAL)) + +/* The initialization priority for entities for which no explicit + initialization priority has been specified. */ +#define DEFAULT_INIT_PRIORITY 65535 + +/* The maximum allowed initialization priority. */ +#define MAX_INIT_PRIORITY 65535 + +/* The largest priority value reserved for use by system runtime + libraries. */ +#define MAX_RESERVED_INIT_PRIORITY 100 + +#define DECL_VAR_ANN_PTR(NODE) \ + (TREE_CODE (NODE) == VAR_DECL ? &(NODE)->var_decl.ann \ + : TREE_CODE (NODE) == PARM_DECL ? &(NODE)->parm_decl.ann \ + : TREE_CODE (NODE) == RESULT_DECL ? &(NODE)->result_decl.ann \ + : NULL) + +struct GTY(()) tree_var_decl { + struct tree_decl_with_vis common; + struct var_ann_d *ann; +}; + + +/* This field is used to reference anything in decl.result and is meant only + for use by the garbage collector. */ +#define DECL_RESULT_FLD(NODE) \ + (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result) + +/* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways. + Before the struct containing the FUNCTION_DECL is laid out, + DECL_VINDEX may point to a FUNCTION_DECL in a base class which + is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual + function. When the class is laid out, this pointer is changed + to an INTEGER_CST node which is suitable for use as an index + into the virtual function table. + C++ also uses this field in namespaces, hence the DECL_NON_COMMON_CHECK. */ +#define DECL_VINDEX(NODE) \ + (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex) + +struct GTY(()) + tree_decl_non_common { + struct tree_decl_with_vis common; + /* C++ uses this in namespaces. */ + tree saved_tree; + /* C++ uses this in templates. */ + tree arguments; + /* Almost all FE's use this. */ + tree result; + /* C++ uses this in namespaces. */ + tree vindex; +}; + +/* In FUNCTION_DECL, holds the decl for the return value. */ +#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result) + +/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */ +#define DECL_UNINLINABLE(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable) + +/* In a FUNCTION_DECL, the saved representation of the body of the + entire function. */ +#define DECL_SAVED_TREE(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->decl_non_common.saved_tree) + +/* Nonzero in a FUNCTION_DECL means this function should be treated + as if it were a malloc, meaning it returns a pointer that is + not an alias. */ +#define DECL_IS_MALLOC(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag) + +/* Nonzero in a FUNCTION_DECL means this function should be treated as + C++ operator new, meaning that it returns a pointer for which we + should not use type based aliasing. */ +#define DECL_IS_OPERATOR_NEW(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.operator_new_flag) + +/* Nonzero in a FUNCTION_DECL means this function may return more + than once. */ +#define DECL_IS_RETURNS_TWICE(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag) + +/* Nonzero in a FUNCTION_DECL means this function should be treated + as "pure" function (like const function, but may read global memory). */ +#define DECL_PURE_P(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag) + +/* Nonzero only if one of TREE_READONLY or DECL_PURE_P is nonzero AND + the const or pure function may not terminate. When this is nonzero + for a const or pure function, it can be dealt with by cse passes + but cannot be removed by dce passes since you are not allowed to + change an infinite looping program into one that terminates without + error. */ +#define DECL_LOOPING_CONST_OR_PURE_P(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag) + +/* Nonzero in a FUNCTION_DECL means this function should be treated + as "novops" function (function that does not read global memory, + but may have arbitrary side effects). */ +#define DECL_IS_NOVOPS(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag) + +/* Used in FUNCTION_DECLs to indicate that they should be run automatically + at the beginning or end of execution. */ +#define DECL_STATIC_CONSTRUCTOR(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag) + +#define DECL_STATIC_DESTRUCTOR(NODE) \ +(FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag) + +/* Used in FUNCTION_DECLs to indicate that function entry and exit should + be instrumented with calls to support routines. */ +#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit) + +/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be + disabled in this function. */ +#define DECL_NO_LIMIT_STACK(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack) + +/* In a FUNCTION_DECL indicates that a static chain is needed. */ +#define DECL_STATIC_CHAIN(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.regdecl_flag) + +/* Nonzero for a decl that cgraph has decided should be inlined into + at least one call site. It is not meaningful to look at this + directly; always use cgraph_function_possibly_inlined_p. */ +#define DECL_POSSIBLY_INLINED(DECL) \ + FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined + +/* Nonzero in a FUNCTION_DECL means that this function was declared inline, + such as via the `inline' keyword in C/C++. This flag controls the linkage + semantics of 'inline' */ +#define DECL_DECLARED_INLINE_P(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag) + +/* Nonzero in a FUNCTION_DECL means this function should not get + -Winline warnings. */ +#define DECL_NO_INLINE_WARNING_P(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag) + +/* Nonzero in a FUNCTION_DECL that should be always inlined by the inliner + disregarding size and cost heuristics. This is equivalent to using + the always_inline attribute without the required diagnostics if the + function cannot be inlined. */ +#define DECL_DISREGARD_INLINE_LIMITS(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits) + +/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function") + that describes the status of this function. */ +#define DECL_STRUCT_FUNCTION(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.f) + +/* In a FUNCTION_DECL, nonzero means a built in function. */ +#define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN) + +/* For a builtin function, identify which part of the compiler defined it. */ +#define DECL_BUILT_IN_CLASS(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class) + +/* In FUNCTION_DECL, a chain of ..._DECL nodes. + VAR_DECL and PARM_DECL reserve the arguments slot for language-specific + uses. */ +#define DECL_ARGUMENTS(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments) +#define DECL_ARGUMENT_FLD(NODE) \ + (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments) + +/* In FUNCTION_DECL, the function specific target options to use when compiling + this function. */ +#define DECL_FUNCTION_SPECIFIC_TARGET(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target) + +/* In FUNCTION_DECL, the function specific optimization options to use when + compiling this function. */ +#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization) + +/* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the + arguments/result/saved_tree fields by front ends. It was either inherit + FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL, + which seemed a bit strange. */ + +struct GTY(()) tree_function_decl { + struct tree_decl_non_common common; + + struct function *f; + + /* The personality function. Used for stack unwinding. */ + tree personality; + + /* Function specific options that are used by this function. */ + tree function_specific_target; /* target options */ + tree function_specific_optimization; /* optimization options */ + + /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is + DECL_FUNCTION_CODE. Otherwise unused. + ??? The bitfield needs to be able to hold all target function + codes as well. */ + ENUM_BITFIELD(built_in_function) function_code : 11; + ENUM_BITFIELD(built_in_class) built_in_class : 2; + + unsigned static_ctor_flag : 1; + unsigned static_dtor_flag : 1; + unsigned uninlinable : 1; + + unsigned possibly_inlined : 1; + unsigned novops_flag : 1; + unsigned returns_twice_flag : 1; + unsigned malloc_flag : 1; + unsigned operator_new_flag : 1; + unsigned declared_inline_flag : 1; + unsigned regdecl_flag : 1; + + unsigned no_inline_warning_flag : 1; + unsigned no_instrument_function_entry_exit : 1; + unsigned no_limit_stack : 1; + unsigned disregard_inline_limits : 1; + unsigned pure_flag : 1; + unsigned looping_const_or_pure_flag : 1; + + + /* 3 bits left */ +}; + +/* The source language of the translation-unit. */ +#define TRANSLATION_UNIT_LANGUAGE(NODE) \ + (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language) + +/* TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL. */ + +struct GTY(()) tree_translation_unit_decl { + struct tree_decl_common common; + /* Source language of this translation unit. Used for DWARF output. */ + const char * GTY((skip(""))) language; + /* TODO: Non-optimization used to build this translation unit. */ + /* TODO: Root of a partial DWARF tree for global types and decls. */ +}; + +/* A vector of all translation-units. */ +extern GTY (()) VEC(tree,gc) *all_translation_units; + +/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */ +#define DECL_ORIGINAL_TYPE(NODE) \ + (TYPE_DECL_CHECK (NODE)->decl_non_common.result) + +/* In a TYPE_DECL nonzero means the detail info about this type is not dumped + into stabs. Instead it will generate cross reference ('x') of names. + This uses the same flag as DECL_EXTERNAL. */ +#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \ + (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1) + +/* Getter of the imported declaration associated to the + IMPORTED_DECL node. */ +#define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \ +(DECL_INITIAL (IMPORTED_DECL_CHECK (NODE))) + +struct GTY(()) tree_type_decl { + struct tree_decl_non_common common; + +}; + +/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE. + To reduce overhead, the nodes containing the statements are not trees. + This avoids the overhead of tree_common on all linked list elements. + + Use the interface in tree-iterator.h to access this node. */ + +#define STATEMENT_LIST_HEAD(NODE) \ + (STATEMENT_LIST_CHECK (NODE)->stmt_list.head) +#define STATEMENT_LIST_TAIL(NODE) \ + (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail) + +struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node + { + struct tree_statement_list_node *prev; + struct tree_statement_list_node *next; + tree stmt; +}; + +struct GTY(()) tree_statement_list + { + struct tree_common common; + struct tree_statement_list_node *head; + struct tree_statement_list_node *tail; +}; + + +/* Optimization options used by a function. */ + +struct GTY(()) tree_optimization_option { + struct tree_common common; + + /* The optimization options used by the user. */ + struct cl_optimization opts; +}; + +#define TREE_OPTIMIZATION(NODE) \ + (&OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts) + +/* Return a tree node that encapsulates the current optimization options. */ +extern tree build_optimization_node (void); + +/* Target options used by a function. */ + +struct GTY(()) tree_target_option { + struct tree_common common; + + /* The optimization options used by the user. */ + struct cl_target_option opts; +}; + +#define TREE_TARGET_OPTION(NODE) \ + (&TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts) + +/* Return a tree node that encapsulates the current target options. */ +extern tree build_target_option_node (void); + + +/* Define the overall contents of a tree node. + It may be any of the structures declared above + for various types of node. */ + +union GTY ((ptr_alias (union lang_tree_node), + desc ("tree_node_structure (&%h)"), variable_size)) tree_node { + struct tree_base GTY ((tag ("TS_BASE"))) base; + struct tree_common GTY ((tag ("TS_COMMON"))) common; + struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst; + struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst; + struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst; + struct tree_vector GTY ((tag ("TS_VECTOR"))) vector; + struct tree_string GTY ((tag ("TS_STRING"))) string; + struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex; + struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier; + struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal; + struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common; + struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl; + struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common; + struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl; + struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis; + struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl; + struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl; + struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl; + struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl; + struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl; + struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl; + struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl; + struct tree_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL"))) + translation_unit_decl; + struct tree_type GTY ((tag ("TS_TYPE"))) type; + struct tree_list GTY ((tag ("TS_LIST"))) list; + struct tree_vec GTY ((tag ("TS_VEC"))) vec; + struct tree_exp GTY ((tag ("TS_EXP"))) exp; + struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name; + struct tree_block GTY ((tag ("TS_BLOCK"))) block; + struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo; + struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list; + struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor; + struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause; + struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization; + struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option; +}; + +/* Standard named or nameless data types of the C compiler. */ + +enum tree_index +{ + TI_ERROR_MARK, + TI_INTQI_TYPE, + TI_INTHI_TYPE, + TI_INTSI_TYPE, + TI_INTDI_TYPE, + TI_INTTI_TYPE, + + TI_UINTQI_TYPE, + TI_UINTHI_TYPE, + TI_UINTSI_TYPE, + TI_UINTDI_TYPE, + TI_UINTTI_TYPE, + + TI_UINT32_TYPE, + TI_UINT64_TYPE, + + TI_INTEGER_ZERO, + TI_INTEGER_ONE, + TI_INTEGER_THREE, + TI_INTEGER_MINUS_ONE, + TI_NULL_POINTER, + + TI_SIZE_ZERO, + TI_SIZE_ONE, + + TI_BITSIZE_ZERO, + TI_BITSIZE_ONE, + TI_BITSIZE_UNIT, + + TI_PUBLIC, + TI_PROTECTED, + TI_PRIVATE, + + TI_BOOLEAN_FALSE, + TI_BOOLEAN_TRUE, + + TI_COMPLEX_INTEGER_TYPE, + TI_COMPLEX_FLOAT_TYPE, + TI_COMPLEX_DOUBLE_TYPE, + TI_COMPLEX_LONG_DOUBLE_TYPE, + + TI_FLOAT_TYPE, + TI_DOUBLE_TYPE, + TI_LONG_DOUBLE_TYPE, + + TI_FLOAT_PTR_TYPE, + TI_DOUBLE_PTR_TYPE, + TI_LONG_DOUBLE_PTR_TYPE, + TI_INTEGER_PTR_TYPE, + + TI_VOID_TYPE, + TI_PTR_TYPE, + TI_CONST_PTR_TYPE, + TI_SIZE_TYPE, + TI_PID_TYPE, + TI_PTRDIFF_TYPE, + TI_VA_LIST_TYPE, + TI_VA_LIST_GPR_COUNTER_FIELD, + TI_VA_LIST_FPR_COUNTER_FIELD, + TI_BOOLEAN_TYPE, + TI_FILEPTR_TYPE, + + TI_DFLOAT32_TYPE, + TI_DFLOAT64_TYPE, + TI_DFLOAT128_TYPE, + TI_DFLOAT32_PTR_TYPE, + TI_DFLOAT64_PTR_TYPE, + TI_DFLOAT128_PTR_TYPE, + + TI_VOID_LIST_NODE, + + TI_MAIN_IDENTIFIER, + + TI_SAT_SFRACT_TYPE, + TI_SAT_FRACT_TYPE, + TI_SAT_LFRACT_TYPE, + TI_SAT_LLFRACT_TYPE, + TI_SAT_USFRACT_TYPE, + TI_SAT_UFRACT_TYPE, + TI_SAT_ULFRACT_TYPE, + TI_SAT_ULLFRACT_TYPE, + TI_SFRACT_TYPE, + TI_FRACT_TYPE, + TI_LFRACT_TYPE, + TI_LLFRACT_TYPE, + TI_USFRACT_TYPE, + TI_UFRACT_TYPE, + TI_ULFRACT_TYPE, + TI_ULLFRACT_TYPE, + TI_SAT_SACCUM_TYPE, + TI_SAT_ACCUM_TYPE, + TI_SAT_LACCUM_TYPE, + TI_SAT_LLACCUM_TYPE, + TI_SAT_USACCUM_TYPE, + TI_SAT_UACCUM_TYPE, + TI_SAT_ULACCUM_TYPE, + TI_SAT_ULLACCUM_TYPE, + TI_SACCUM_TYPE, + TI_ACCUM_TYPE, + TI_LACCUM_TYPE, + TI_LLACCUM_TYPE, + TI_USACCUM_TYPE, + TI_UACCUM_TYPE, + TI_ULACCUM_TYPE, + TI_ULLACCUM_TYPE, + TI_QQ_TYPE, + TI_HQ_TYPE, + TI_SQ_TYPE, + TI_DQ_TYPE, + TI_TQ_TYPE, + TI_UQQ_TYPE, + TI_UHQ_TYPE, + TI_USQ_TYPE, + TI_UDQ_TYPE, + TI_UTQ_TYPE, + TI_SAT_QQ_TYPE, + TI_SAT_HQ_TYPE, + TI_SAT_SQ_TYPE, + TI_SAT_DQ_TYPE, + TI_SAT_TQ_TYPE, + TI_SAT_UQQ_TYPE, + TI_SAT_UHQ_TYPE, + TI_SAT_USQ_TYPE, + TI_SAT_UDQ_TYPE, + TI_SAT_UTQ_TYPE, + TI_HA_TYPE, + TI_SA_TYPE, + TI_DA_TYPE, + TI_TA_TYPE, + TI_UHA_TYPE, + TI_USA_TYPE, + TI_UDA_TYPE, + TI_UTA_TYPE, + TI_SAT_HA_TYPE, + TI_SAT_SA_TYPE, + TI_SAT_DA_TYPE, + TI_SAT_TA_TYPE, + TI_SAT_UHA_TYPE, + TI_SAT_USA_TYPE, + TI_SAT_UDA_TYPE, + TI_SAT_UTA_TYPE, + + TI_OPTIMIZATION_DEFAULT, + TI_OPTIMIZATION_CURRENT, + TI_TARGET_OPTION_DEFAULT, + TI_TARGET_OPTION_CURRENT, + TI_CURRENT_TARGET_PRAGMA, + TI_CURRENT_OPTIMIZE_PRAGMA, + + TI_MAX +}; + +extern GTY(()) tree global_trees[TI_MAX]; + +#define error_mark_node global_trees[TI_ERROR_MARK] + +#define intQI_type_node global_trees[TI_INTQI_TYPE] +#define intHI_type_node global_trees[TI_INTHI_TYPE] +#define intSI_type_node global_trees[TI_INTSI_TYPE] +#define intDI_type_node global_trees[TI_INTDI_TYPE] +#define intTI_type_node global_trees[TI_INTTI_TYPE] + +#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE] +#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE] +#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE] +#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE] +#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE] + +#define uint32_type_node global_trees[TI_UINT32_TYPE] +#define uint64_type_node global_trees[TI_UINT64_TYPE] + +#define integer_zero_node global_trees[TI_INTEGER_ZERO] +#define integer_one_node global_trees[TI_INTEGER_ONE] +#define integer_three_node global_trees[TI_INTEGER_THREE] +#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE] +#define size_zero_node global_trees[TI_SIZE_ZERO] +#define size_one_node global_trees[TI_SIZE_ONE] +#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO] +#define bitsize_one_node global_trees[TI_BITSIZE_ONE] +#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT] + +/* Base access nodes. */ +#define access_public_node global_trees[TI_PUBLIC] +#define access_protected_node global_trees[TI_PROTECTED] +#define access_private_node global_trees[TI_PRIVATE] + +#define null_pointer_node global_trees[TI_NULL_POINTER] + +#define float_type_node global_trees[TI_FLOAT_TYPE] +#define double_type_node global_trees[TI_DOUBLE_TYPE] +#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE] + +#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE] +#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE] +#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE] +#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE] + +#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE] +#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE] +#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE] +#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE] + +#define void_type_node global_trees[TI_VOID_TYPE] +/* The C type `void *'. */ +#define ptr_type_node global_trees[TI_PTR_TYPE] +/* The C type `const void *'. */ +#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE] +/* The C type `size_t'. */ +#define size_type_node global_trees[TI_SIZE_TYPE] +#define pid_type_node global_trees[TI_PID_TYPE] +#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE] +#define va_list_type_node global_trees[TI_VA_LIST_TYPE] +#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD] +#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD] +/* The C type `FILE *'. */ +#define fileptr_type_node global_trees[TI_FILEPTR_TYPE] + +#define boolean_type_node global_trees[TI_BOOLEAN_TYPE] +#define boolean_false_node global_trees[TI_BOOLEAN_FALSE] +#define boolean_true_node global_trees[TI_BOOLEAN_TRUE] + +/* The decimal floating point types. */ +#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE] +#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE] +#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE] +#define dfloat32_ptr_type_node global_trees[TI_DFLOAT32_PTR_TYPE] +#define dfloat64_ptr_type_node global_trees[TI_DFLOAT64_PTR_TYPE] +#define dfloat128_ptr_type_node global_trees[TI_DFLOAT128_PTR_TYPE] + +/* The fixed-point types. */ +#define sat_short_fract_type_node global_trees[TI_SAT_SFRACT_TYPE] +#define sat_fract_type_node global_trees[TI_SAT_FRACT_TYPE] +#define sat_long_fract_type_node global_trees[TI_SAT_LFRACT_TYPE] +#define sat_long_long_fract_type_node global_trees[TI_SAT_LLFRACT_TYPE] +#define sat_unsigned_short_fract_type_node \ + global_trees[TI_SAT_USFRACT_TYPE] +#define sat_unsigned_fract_type_node global_trees[TI_SAT_UFRACT_TYPE] +#define sat_unsigned_long_fract_type_node \ + global_trees[TI_SAT_ULFRACT_TYPE] +#define sat_unsigned_long_long_fract_type_node \ + global_trees[TI_SAT_ULLFRACT_TYPE] +#define short_fract_type_node global_trees[TI_SFRACT_TYPE] +#define fract_type_node global_trees[TI_FRACT_TYPE] +#define long_fract_type_node global_trees[TI_LFRACT_TYPE] +#define long_long_fract_type_node global_trees[TI_LLFRACT_TYPE] +#define unsigned_short_fract_type_node global_trees[TI_USFRACT_TYPE] +#define unsigned_fract_type_node global_trees[TI_UFRACT_TYPE] +#define unsigned_long_fract_type_node global_trees[TI_ULFRACT_TYPE] +#define unsigned_long_long_fract_type_node \ + global_trees[TI_ULLFRACT_TYPE] +#define sat_short_accum_type_node global_trees[TI_SAT_SACCUM_TYPE] +#define sat_accum_type_node global_trees[TI_SAT_ACCUM_TYPE] +#define sat_long_accum_type_node global_trees[TI_SAT_LACCUM_TYPE] +#define sat_long_long_accum_type_node global_trees[TI_SAT_LLACCUM_TYPE] +#define sat_unsigned_short_accum_type_node \ + global_trees[TI_SAT_USACCUM_TYPE] +#define sat_unsigned_accum_type_node global_trees[TI_SAT_UACCUM_TYPE] +#define sat_unsigned_long_accum_type_node \ + global_trees[TI_SAT_ULACCUM_TYPE] +#define sat_unsigned_long_long_accum_type_node \ + global_trees[TI_SAT_ULLACCUM_TYPE] +#define short_accum_type_node global_trees[TI_SACCUM_TYPE] +#define accum_type_node global_trees[TI_ACCUM_TYPE] +#define long_accum_type_node global_trees[TI_LACCUM_TYPE] +#define long_long_accum_type_node global_trees[TI_LLACCUM_TYPE] +#define unsigned_short_accum_type_node global_trees[TI_USACCUM_TYPE] +#define unsigned_accum_type_node global_trees[TI_UACCUM_TYPE] +#define unsigned_long_accum_type_node global_trees[TI_ULACCUM_TYPE] +#define unsigned_long_long_accum_type_node \ + global_trees[TI_ULLACCUM_TYPE] +#define qq_type_node global_trees[TI_QQ_TYPE] +#define hq_type_node global_trees[TI_HQ_TYPE] +#define sq_type_node global_trees[TI_SQ_TYPE] +#define dq_type_node global_trees[TI_DQ_TYPE] +#define tq_type_node global_trees[TI_TQ_TYPE] +#define uqq_type_node global_trees[TI_UQQ_TYPE] +#define uhq_type_node global_trees[TI_UHQ_TYPE] +#define usq_type_node global_trees[TI_USQ_TYPE] +#define udq_type_node global_trees[TI_UDQ_TYPE] +#define utq_type_node global_trees[TI_UTQ_TYPE] +#define sat_qq_type_node global_trees[TI_SAT_QQ_TYPE] +#define sat_hq_type_node global_trees[TI_SAT_HQ_TYPE] +#define sat_sq_type_node global_trees[TI_SAT_SQ_TYPE] +#define sat_dq_type_node global_trees[TI_SAT_DQ_TYPE] +#define sat_tq_type_node global_trees[TI_SAT_TQ_TYPE] +#define sat_uqq_type_node global_trees[TI_SAT_UQQ_TYPE] +#define sat_uhq_type_node global_trees[TI_SAT_UHQ_TYPE] +#define sat_usq_type_node global_trees[TI_SAT_USQ_TYPE] +#define sat_udq_type_node global_trees[TI_SAT_UDQ_TYPE] +#define sat_utq_type_node global_trees[TI_SAT_UTQ_TYPE] +#define ha_type_node global_trees[TI_HA_TYPE] +#define sa_type_node global_trees[TI_SA_TYPE] +#define da_type_node global_trees[TI_DA_TYPE] +#define ta_type_node global_trees[TI_TA_TYPE] +#define uha_type_node global_trees[TI_UHA_TYPE] +#define usa_type_node global_trees[TI_USA_TYPE] +#define uda_type_node global_trees[TI_UDA_TYPE] +#define uta_type_node global_trees[TI_UTA_TYPE] +#define sat_ha_type_node global_trees[TI_SAT_HA_TYPE] +#define sat_sa_type_node global_trees[TI_SAT_SA_TYPE] +#define sat_da_type_node global_trees[TI_SAT_DA_TYPE] +#define sat_ta_type_node global_trees[TI_SAT_TA_TYPE] +#define sat_uha_type_node global_trees[TI_SAT_UHA_TYPE] +#define sat_usa_type_node global_trees[TI_SAT_USA_TYPE] +#define sat_uda_type_node global_trees[TI_SAT_UDA_TYPE] +#define sat_uta_type_node global_trees[TI_SAT_UTA_TYPE] + +/* The node that should be placed at the end of a parameter list to + indicate that the function does not take a variable number of + arguments. The TREE_VALUE will be void_type_node and there will be + no TREE_CHAIN. Language-independent code should not assume + anything else about this node. */ +#define void_list_node global_trees[TI_VOID_LIST_NODE] + +#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER] +#define MAIN_NAME_P(NODE) \ + (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node) + +/* Optimization options (OPTIMIZATION_NODE) to use for default and current + functions. */ +#define optimization_default_node global_trees[TI_OPTIMIZATION_DEFAULT] +#define optimization_current_node global_trees[TI_OPTIMIZATION_CURRENT] + +/* Default/current target options (TARGET_OPTION_NODE). */ +#define target_option_default_node global_trees[TI_TARGET_OPTION_DEFAULT] +#define target_option_current_node global_trees[TI_TARGET_OPTION_CURRENT] + +/* Default tree list option(), optimize() pragmas to be linked into the + attribute list. */ +#define current_target_pragma global_trees[TI_CURRENT_TARGET_PRAGMA] +#define current_optimize_pragma global_trees[TI_CURRENT_OPTIMIZE_PRAGMA] + +/* An enumeration of the standard C integer types. These must be + ordered so that shorter types appear before longer ones, and so + that signed types appear before unsigned ones, for the correct + functioning of interpret_integer() in c-lex.c. */ +enum integer_type_kind +{ + itk_char, + itk_signed_char, + itk_unsigned_char, + itk_short, + itk_unsigned_short, + itk_int, + itk_unsigned_int, + itk_long, + itk_unsigned_long, + itk_long_long, + itk_unsigned_long_long, + itk_int128, + itk_unsigned_int128, + itk_none +}; + +typedef enum integer_type_kind integer_type_kind; + +/* The standard C integer types. Use integer_type_kind to index into + this array. */ +extern GTY(()) tree integer_types[itk_none]; + +#define char_type_node integer_types[itk_char] +#define signed_char_type_node integer_types[itk_signed_char] +#define unsigned_char_type_node integer_types[itk_unsigned_char] +#define short_integer_type_node integer_types[itk_short] +#define short_unsigned_type_node integer_types[itk_unsigned_short] +#define integer_type_node integer_types[itk_int] +#define unsigned_type_node integer_types[itk_unsigned_int] +#define long_integer_type_node integer_types[itk_long] +#define long_unsigned_type_node integer_types[itk_unsigned_long] +#define long_long_integer_type_node integer_types[itk_long_long] +#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long] +#define int128_integer_type_node integer_types[itk_int128] +#define int128_unsigned_type_node integer_types[itk_unsigned_int128] + +/* A pointer-to-function member type looks like: + + struct { + __P __pfn; + ptrdiff_t __delta; + }; + + If __pfn is NULL, it is a NULL pointer-to-member-function. + + (Because the vtable is always the first thing in the object, we + don't need its offset.) If the function is virtual, then PFN is + one plus twice the index into the vtable; otherwise, it is just a + pointer to the function. + + Unfortunately, using the lowest bit of PFN doesn't work in + architectures that don't impose alignment requirements on function + addresses, or that use the lowest bit to tell one ISA from another, + for example. For such architectures, we use the lowest bit of + DELTA instead of the lowest bit of the PFN, and DELTA will be + multiplied by 2. */ + +enum ptrmemfunc_vbit_where_t +{ + ptrmemfunc_vbit_in_pfn, + ptrmemfunc_vbit_in_delta +}; + +#define NULL_TREE (tree) NULL + +extern tree decl_assembler_name (tree); +extern bool decl_assembler_name_equal (tree decl, const_tree asmname); +extern hashval_t decl_assembler_name_hash (const_tree asmname); + +/* Compute the number of bytes occupied by 'node'. This routine only + looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */ + +extern size_t tree_size (const_tree); + +/* Compute the number of bytes occupied by a tree with code CODE. This + function cannot be used for TREE_VEC codes, which are of variable + length. */ +extern size_t tree_code_size (enum tree_code); + +/* Lowest level primitive for allocating a node. + The TREE_CODE is the only argument. Contents are initialized + to zero except for a few of the common fields. */ + +extern tree make_node_stat (enum tree_code MEM_STAT_DECL); +#define make_node(t) make_node_stat (t MEM_STAT_INFO) + +/* Make a copy of a node, with all the same contents. */ + +extern tree copy_node_stat (tree MEM_STAT_DECL); +#define copy_node(t) copy_node_stat (t MEM_STAT_INFO) + +/* Make a copy of a chain of TREE_LIST nodes. */ + +extern tree copy_list (tree); + +/* Make a BINFO. */ +extern tree make_tree_binfo_stat (unsigned MEM_STAT_DECL); +#define make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO) + +/* Make a TREE_VEC. */ + +extern tree make_tree_vec_stat (int MEM_STAT_DECL); +#define make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO) + +/* Return the (unique) IDENTIFIER_NODE node for a given name. + The name is supplied as a char *. */ + +extern tree get_identifier (const char *); + +#if GCC_VERSION >= 3000 +#define get_identifier(str) \ + (__builtin_constant_p (str) \ + ? get_identifier_with_length ((str), strlen (str)) \ + : get_identifier (str)) +#endif + + +/* Identical to get_identifier, except that the length is assumed + known. */ + +extern tree get_identifier_with_length (const char *, size_t); + +/* If an identifier with the name TEXT (a null-terminated string) has + previously been referred to, return that node; otherwise return + NULL_TREE. */ + +extern tree maybe_get_identifier (const char *); + +/* Construct various types of nodes. */ + +extern tree build_nt (enum tree_code, ...); +extern tree build_nt_call_vec (tree, VEC(tree,gc) *); + +extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL); +#define build0(c,t) build0_stat (c,t MEM_STAT_INFO) +extern tree build1_stat (enum tree_code, tree, tree MEM_STAT_DECL); +#define build1(c,t1,t2) build1_stat (c,t1,t2 MEM_STAT_INFO) +extern tree build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL); +#define build2(c,t1,t2,t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO) +extern tree build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL); +#define build3(c,t1,t2,t3,t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO) +extern tree build4_stat (enum tree_code, tree, tree, tree, tree, + tree MEM_STAT_DECL); +#define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO) +extern tree build5_stat (enum tree_code, tree, tree, tree, tree, tree, + tree MEM_STAT_DECL); +#define build5(c,t1,t2,t3,t4,t5,t6) build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO) +extern tree build6_stat (enum tree_code, tree, tree, tree, tree, tree, + tree, tree MEM_STAT_DECL); +#define build6(c,t1,t2,t3,t4,t5,t6,t7) \ + build6_stat (c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO) + +/* _loc versions of build[1-6]. */ + +static inline tree +build1_stat_loc (location_t loc, enum tree_code code, tree type, + tree arg1 MEM_STAT_DECL) +{ + tree t = build1_stat (code, type, arg1 PASS_MEM_STAT); + if (CAN_HAVE_LOCATION_P (t)) + SET_EXPR_LOCATION (t, loc); + return t; +} +#define build1_loc(l,c,t1,t2) build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO) + +static inline tree +build2_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, + tree arg1 MEM_STAT_DECL) +{ + tree t = build2_stat (code, type, arg0, arg1 PASS_MEM_STAT); + if (CAN_HAVE_LOCATION_P (t)) + SET_EXPR_LOCATION (t, loc); + return t; +} +#define build2_loc(l,c,t1,t2,t3) build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO) + +static inline tree +build3_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, + tree arg1, tree arg2 MEM_STAT_DECL) +{ + tree t = build3_stat (code, type, arg0, arg1, arg2 PASS_MEM_STAT); + if (CAN_HAVE_LOCATION_P (t)) + SET_EXPR_LOCATION (t, loc); + return t; +} +#define build3_loc(l,c,t1,t2,t3,t4) \ + build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO) + +static inline tree +build4_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, + tree arg1, tree arg2, tree arg3 MEM_STAT_DECL) +{ + tree t = build4_stat (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT); + if (CAN_HAVE_LOCATION_P (t)) + SET_EXPR_LOCATION (t, loc); + return t; +} +#define build4_loc(l,c,t1,t2,t3,t4,t5) \ + build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO) + +static inline tree +build5_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, + tree arg1, tree arg2, tree arg3, tree arg4 MEM_STAT_DECL) +{ + tree t = build5_stat (code, type, arg0, arg1, arg2, arg3, + arg4 PASS_MEM_STAT); + if (CAN_HAVE_LOCATION_P (t)) + SET_EXPR_LOCATION (t, loc); + return t; +} +#define build5_loc(l,c,t1,t2,t3,t4,t5,t6) \ + build5_stat_loc (l,c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO) + +static inline tree +build6_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, + tree arg1, tree arg2, tree arg3, tree arg4, + tree arg5 MEM_STAT_DECL) +{ + tree t = build6_stat (code, type, arg0, arg1, arg2, arg3, arg4, + arg5 PASS_MEM_STAT); + if (CAN_HAVE_LOCATION_P (t)) + SET_EXPR_LOCATION (t, loc); + return t; +} +#define build6_loc(l,c,t1,t2,t3,t4,t5,t6,t7) \ + build6_stat_loc (l,c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO) + +extern tree build_var_debug_value_stat (tree, tree MEM_STAT_DECL); +#define build_var_debug_value(t1,t2) \ + build_var_debug_value_stat (t1,t2 MEM_STAT_INFO) + +/* Constructs double_int from tree CST. */ + +static inline double_int +tree_to_double_int (const_tree cst) +{ + return TREE_INT_CST (cst); +} + +extern tree double_int_to_tree (tree, double_int); +extern bool double_int_fits_to_tree_p (const_tree, double_int); +extern tree force_fit_type_double (tree, double_int, int, bool); + +/* Create an INT_CST node with a CST value zero extended. */ + +static inline tree +build_int_cstu (tree type, unsigned HOST_WIDE_INT cst) +{ + return double_int_to_tree (type, uhwi_to_double_int (cst)); +} + +extern tree build_int_cst (tree, HOST_WIDE_INT); +extern tree build_int_cst_type (tree, HOST_WIDE_INT); +extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT); +extern tree build_vector (tree, tree); +extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *); +extern tree build_vector_from_val (tree, tree); +extern tree build_constructor (tree, VEC(constructor_elt,gc) *); +extern tree build_constructor_single (tree, tree, tree); +extern tree build_constructor_from_list (tree, tree); +extern tree build_real_from_int_cst (tree, const_tree); +extern tree build_complex (tree, tree, tree); +extern tree build_one_cst (tree); +extern tree build_zero_cst (tree); +extern tree build_string (int, const char *); +extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL); +#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO) +extern tree build_tree_list_vec_stat (const VEC(tree,gc) * MEM_STAT_DECL); +#define build_tree_list_vec(v) build_tree_list_vec_stat (v MEM_STAT_INFO) +extern tree build_decl_stat (location_t, enum tree_code, + tree, tree MEM_STAT_DECL); +extern tree build_fn_decl (const char *, tree); +#define build_decl(l,c,t,q) build_decl_stat (l,c,t,q MEM_STAT_INFO) +extern tree build_translation_unit_decl (tree); +extern tree build_block (tree, tree, tree, tree); +extern tree build_empty_stmt (location_t); +extern tree build_omp_clause (location_t, enum omp_clause_code); + +extern tree build_vl_exp_stat (enum tree_code, int MEM_STAT_DECL); +#define build_vl_exp(c,n) build_vl_exp_stat (c,n MEM_STAT_INFO) + +extern tree build_call_nary (tree, tree, int, ...); +extern tree build_call_valist (tree, tree, int, va_list); +#define build_call_array(T1,T2,N,T3)\ + build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3) +extern tree build_call_array_loc (location_t, tree, tree, int, const tree *); +extern tree build_call_vec (tree, tree, VEC(tree,gc) *); + +/* Construct various nodes representing data types. */ + +extern tree make_signed_type (int); +extern tree make_unsigned_type (int); +extern tree signed_or_unsigned_type_for (int, tree); +extern tree signed_type_for (tree); +extern tree unsigned_type_for (tree); +extern void initialize_sizetypes (void); +extern void set_sizetype (tree); +extern void fixup_unsigned_type (tree); +extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool); +extern tree build_pointer_type (tree); +extern tree build_reference_type_for_mode (tree, enum machine_mode, bool); +extern tree build_reference_type (tree); +extern tree build_vector_type_for_mode (tree, enum machine_mode); +extern tree build_vector_type (tree innertype, int nunits); +extern tree build_opaque_vector_type (tree innertype, int nunits); +extern tree build_type_no_quals (tree); +extern tree build_index_type (tree); +extern tree build_array_type (tree, tree); +extern tree build_nonshared_array_type (tree, tree); +extern tree build_function_type (tree, tree); +extern tree build_function_type_list (tree, ...); +extern tree build_function_type_skip_args (tree, bitmap); +extern tree build_function_decl_skip_args (tree, bitmap); +extern tree build_varargs_function_type_list (tree, ...); +extern tree build_method_type_directly (tree, tree, tree); +extern tree build_method_type (tree, tree); +extern tree build_offset_type (tree, tree); +extern tree build_complex_type (tree); +extern tree array_type_nelts (const_tree); +extern bool in_array_bounds_p (tree); +extern bool range_in_array_bounds_p (tree); + +extern tree value_member (tree, tree); +extern tree purpose_member (const_tree, tree); +extern bool vec_member (const_tree, VEC(tree,gc) *); +extern tree chain_index (int, tree); + +extern int attribute_list_equal (const_tree, const_tree); +extern int attribute_list_contained (const_tree, const_tree); +extern int tree_int_cst_equal (const_tree, const_tree); +extern int tree_int_cst_lt (const_tree, const_tree); +extern int tree_int_cst_compare (const_tree, const_tree); +extern int host_integerp (const_tree, int) +#ifndef ENABLE_TREE_CHECKING + ATTRIBUTE_PURE /* host_integerp is pure only when checking is disabled. */ +#endif + ; +extern HOST_WIDE_INT tree_low_cst (const_tree, int); +#if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003) +extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT +tree_low_cst (const_tree t, int pos) +{ + gcc_assert (host_integerp (t, pos)); + return TREE_INT_CST_LOW (t); +} +#endif +extern int tree_int_cst_msb (const_tree); +extern int tree_int_cst_sgn (const_tree); +extern int tree_int_cst_sign_bit (const_tree); +extern unsigned int tree_int_cst_min_precision (tree, bool); +extern bool tree_expr_nonnegative_p (tree); +extern bool tree_expr_nonnegative_warnv_p (tree, bool *); +extern bool may_negate_without_overflow_p (const_tree); +extern tree strip_array_types (tree); +extern tree excess_precision_type (tree); + +/* Construct various nodes representing fract or accum data types. */ + +extern tree make_fract_type (int, int, int); +extern tree make_accum_type (int, int, int); + +#define make_signed_fract_type(P) make_fract_type (P, 0, 0) +#define make_unsigned_fract_type(P) make_fract_type (P, 1, 0) +#define make_sat_signed_fract_type(P) make_fract_type (P, 0, 1) +#define make_sat_unsigned_fract_type(P) make_fract_type (P, 1, 1) +#define make_signed_accum_type(P) make_accum_type (P, 0, 0) +#define make_unsigned_accum_type(P) make_accum_type (P, 1, 0) +#define make_sat_signed_accum_type(P) make_accum_type (P, 0, 1) +#define make_sat_unsigned_accum_type(P) make_accum_type (P, 1, 1) + +#define make_or_reuse_signed_fract_type(P) \ + make_or_reuse_fract_type (P, 0, 0) +#define make_or_reuse_unsigned_fract_type(P) \ + make_or_reuse_fract_type (P, 1, 0) +#define make_or_reuse_sat_signed_fract_type(P) \ + make_or_reuse_fract_type (P, 0, 1) +#define make_or_reuse_sat_unsigned_fract_type(P) \ + make_or_reuse_fract_type (P, 1, 1) +#define make_or_reuse_signed_accum_type(P) \ + make_or_reuse_accum_type (P, 0, 0) +#define make_or_reuse_unsigned_accum_type(P) \ + make_or_reuse_accum_type (P, 1, 0) +#define make_or_reuse_sat_signed_accum_type(P) \ + make_or_reuse_accum_type (P, 0, 1) +#define make_or_reuse_sat_unsigned_accum_type(P) \ + make_or_reuse_accum_type (P, 1, 1) + +/* From expmed.c. Since rtl.h is included after tree.h, we can't + put the prototype here. Rtl.h does declare the prototype if + tree.h had been included. */ + +extern tree make_tree (tree, rtx); + +/* Return a type like TTYPE except that its TYPE_ATTRIBUTES + is ATTRIBUTE. + + Such modified types already made are recorded so that duplicates + are not made. */ + +extern tree build_type_attribute_variant (tree, tree); +extern tree build_decl_attribute_variant (tree, tree); +extern tree build_type_attribute_qual_variant (tree, tree, int); + +/* Structure describing an attribute and a function to handle it. */ +struct attribute_spec +{ + /* The name of the attribute (without any leading or trailing __), + or NULL to mark the end of a table of attributes. */ + const char *const name; + /* The minimum length of the list of arguments of the attribute. */ + const int min_length; + /* The maximum length of the list of arguments of the attribute + (-1 for no maximum). */ + const int max_length; + /* Whether this attribute requires a DECL. If it does, it will be passed + from types of DECLs, function return types and array element types to + the DECLs, function types and array types respectively; but when + applied to a type in any other circumstances, it will be ignored with + a warning. (If greater control is desired for a given attribute, + this should be false, and the flags argument to the handler may be + used to gain greater control in that case.) */ + const bool decl_required; + /* Whether this attribute requires a type. If it does, it will be passed + from a DECL to the type of that DECL. */ + const bool type_required; + /* Whether this attribute requires a function (or method) type. If it does, + it will be passed from a function pointer type to the target type, + and from a function return type (which is not itself a function + pointer type) to the function type. */ + const bool function_type_required; + /* Function to handle this attribute. NODE points to the node to which + the attribute is to be applied. If a DECL, it should be modified in + place; if a TYPE, a copy should be created. NAME is the name of the + attribute (possibly with leading or trailing __). ARGS is the TREE_LIST + of the arguments (which may be NULL). FLAGS gives further information + about the context of the attribute. Afterwards, the attributes will + be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate, + unless *NO_ADD_ATTRS is set to true (which should be done on error, + as well as in any other cases when the attributes should not be added + to the DECL or TYPE). Depending on FLAGS, any attributes to be + applied to another type or DECL later may be returned; + otherwise the return value should be NULL_TREE. This pointer may be + NULL if no special handling is required beyond the checks implied + by the rest of this structure. */ + tree (*const handler) (tree *node, tree name, tree args, + int flags, bool *no_add_attrs); +}; + +/* Flags that may be passed in the third argument of decl_attributes, and + to handler functions for attributes. */ +enum attribute_flags +{ + /* The type passed in is the type of a DECL, and any attributes that + should be passed in again to be applied to the DECL rather than the + type should be returned. */ + ATTR_FLAG_DECL_NEXT = 1, + /* The type passed in is a function return type, and any attributes that + should be passed in again to be applied to the function type rather + than the return type should be returned. */ + ATTR_FLAG_FUNCTION_NEXT = 2, + /* The type passed in is an array element type, and any attributes that + should be passed in again to be applied to the array type rather + than the element type should be returned. */ + ATTR_FLAG_ARRAY_NEXT = 4, + /* The type passed in is a structure, union or enumeration type being + created, and should be modified in place. */ + ATTR_FLAG_TYPE_IN_PLACE = 8, + /* The attributes are being applied by default to a library function whose + name indicates known behavior, and should be silently ignored if they + are not in fact compatible with the function type. */ + ATTR_FLAG_BUILT_IN = 16 +}; + +/* Default versions of target-overridable functions. */ + +extern tree merge_decl_attributes (tree, tree); +extern tree merge_type_attributes (tree, tree); + +/* Given a tree node and a string, return nonzero if the tree node is + a valid attribute name for the string. */ + +extern int is_attribute_p (const char *, const_tree); + +/* Given an attribute name and a list of attributes, return the list element + of the attribute or NULL_TREE if not found. */ + +extern tree lookup_attribute (const char *, tree); + +/* Remove any instances of attribute ATTR_NAME in LIST and return the + modified list. */ + +extern tree remove_attribute (const char *, tree); + +/* Given two attributes lists, return a list of their union. */ + +extern tree merge_attributes (tree, tree); + +#if TARGET_DLLIMPORT_DECL_ATTRIBUTES +/* Given two Windows decl attributes lists, possibly including + dllimport, return a list of their union . */ +extern tree merge_dllimport_decl_attributes (tree, tree); + +/* Handle a "dllimport" or "dllexport" attribute. */ +extern tree handle_dll_attribute (tree *, tree, tree, int, bool *); +#endif + +/* Check whether CAND is suitable to be returned from get_qualified_type + (BASE, TYPE_QUALS). */ + +extern bool check_qualified_type (const_tree, const_tree, int); + +/* Return a version of the TYPE, qualified as indicated by the + TYPE_QUALS, if one exists. If no qualified version exists yet, + return NULL_TREE. */ + +extern tree get_qualified_type (tree, int); + +/* Like get_qualified_type, but creates the type if it does not + exist. This function never returns NULL_TREE. */ + +extern tree build_qualified_type (tree, int); + +/* Create a variant of type T with alignment ALIGN. */ + +extern tree build_aligned_type (tree, unsigned int); + +/* Like build_qualified_type, but only deals with the `const' and + `volatile' qualifiers. This interface is retained for backwards + compatibility with the various front-ends; new code should use + build_qualified_type instead. */ + +#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \ + build_qualified_type ((TYPE), \ + ((CONST_P) ? TYPE_QUAL_CONST : 0) \ + | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0)) + +/* Make a copy of a type node. */ + +extern tree build_distinct_type_copy (tree); +extern tree build_variant_type_copy (tree); + +/* Finish up a builtin RECORD_TYPE. Give it a name and provide its + fields. Optionally specify an alignment, and then lay it out. */ + +extern void finish_builtin_struct (tree, const char *, + tree, tree); + +/* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT, + TYPE_ALIGN and TYPE_MODE fields. If called more than once on one + node, does nothing except for the first time. */ + +extern void layout_type (tree); + +/* These functions allow a front-end to perform a manual layout of a + RECORD_TYPE. (For instance, if the placement of subsequent fields + depends on the placement of fields so far.) Begin by calling + start_record_layout. Then, call place_field for each of the + fields. Then, call finish_record_layout. See layout_type for the + default way in which these functions are used. */ + +typedef struct record_layout_info_s +{ + /* The RECORD_TYPE that we are laying out. */ + tree t; + /* The offset into the record so far, in bytes, not including bits in + BITPOS. */ + tree offset; + /* The last known alignment of SIZE. */ + unsigned int offset_align; + /* The bit position within the last OFFSET_ALIGN bits, in bits. */ + tree bitpos; + /* The alignment of the record so far, in bits. */ + unsigned int record_align; + /* The alignment of the record so far, ignoring #pragma pack and + __attribute__ ((packed)), in bits. */ + unsigned int unpacked_align; + /* The previous field layed out. */ + tree prev_field; + /* The static variables (i.e., class variables, as opposed to + instance variables) encountered in T. */ + VEC(tree,gc) *pending_statics; + /* Bits remaining in the current alignment group */ + int remaining_in_alignment; + /* True if we've seen a packed field that didn't have normal + alignment anyway. */ + int packed_maybe_necessary; +} *record_layout_info; + +extern record_layout_info start_record_layout (tree); +extern tree bit_from_pos (tree, tree); +extern tree byte_from_pos (tree, tree); +extern void pos_from_bit (tree *, tree *, unsigned int, tree); +extern void normalize_offset (tree *, tree *, unsigned int); +extern tree rli_size_unit_so_far (record_layout_info); +extern tree rli_size_so_far (record_layout_info); +extern void normalize_rli (record_layout_info); +extern void place_field (record_layout_info, tree); +extern void compute_record_mode (tree); +extern void finish_record_layout (record_layout_info, int); + +/* Given a hashcode and a ..._TYPE node (for which the hashcode was made), + return a canonicalized ..._TYPE node, so that duplicates are not made. + How the hash code is computed is up to the caller, as long as any two + callers that could hash identical-looking type nodes agree. */ + +extern tree type_hash_canon (unsigned int, tree); + +/* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node, + calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE + fields. Call this only once for any given decl node. + + Second argument is the boundary that this field can be assumed to + be starting at (in bits). Zero means it can be assumed aligned + on any boundary that may be needed. */ + +extern void layout_decl (tree, unsigned); + +/* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of + a previous call to layout_decl and calls it again. */ + +extern void relayout_decl (tree); + +/* Return the mode for data of a given size SIZE and mode class CLASS. + If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE. + The value is BLKmode if no other mode is found. This is like + mode_for_size, but is passed a tree. */ + +extern enum machine_mode mode_for_size_tree (const_tree, enum mode_class, int); + +/* Return an expr equal to X but certainly not valid as an lvalue. */ + +#define non_lvalue(T) non_lvalue_loc (UNKNOWN_LOCATION, T) +extern tree non_lvalue_loc (location_t, tree); + +extern tree convert (tree, tree); +extern unsigned int expr_align (const_tree); +extern tree expr_first (tree); +extern tree expr_last (tree); +extern tree size_in_bytes (const_tree); +extern HOST_WIDE_INT int_size_in_bytes (const_tree); +extern HOST_WIDE_INT max_int_size_in_bytes (const_tree); +extern tree tree_expr_size (const_tree); +extern tree bit_position (const_tree); +extern HOST_WIDE_INT int_bit_position (const_tree); +extern tree byte_position (const_tree); +extern HOST_WIDE_INT int_byte_position (const_tree); + +/* Define data structures, macros, and functions for handling sizes + and the various types used to represent sizes. */ + +enum size_type_kind +{ + SIZETYPE, /* Normal representation of sizes in bytes. */ + SSIZETYPE, /* Signed representation of sizes in bytes. */ + BITSIZETYPE, /* Normal representation of sizes in bits. */ + SBITSIZETYPE, /* Signed representation of sizes in bits. */ + TYPE_KIND_LAST}; + +extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST]; + +#define sizetype sizetype_tab[(int) SIZETYPE] +#define bitsizetype sizetype_tab[(int) BITSIZETYPE] +#define ssizetype sizetype_tab[(int) SSIZETYPE] +#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE] + +extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind); +#define size_binop(CODE,T1,T2)\ + size_binop_loc (UNKNOWN_LOCATION, CODE, T1, T2) +extern tree size_binop_loc (location_t, enum tree_code, tree, tree); +#define size_diffop(T1,T2)\ + size_diffop_loc (UNKNOWN_LOCATION, T1, T2) +extern tree size_diffop_loc (location_t, tree, tree); + +#define size_int(L) size_int_kind (L, SIZETYPE) +#define ssize_int(L) size_int_kind (L, SSIZETYPE) +#define bitsize_int(L) size_int_kind (L, BITSIZETYPE) +#define sbitsize_int(L) size_int_kind (L, SBITSIZETYPE) + +#define round_up(T,N) round_up_loc (UNKNOWN_LOCATION, T, N) +extern tree round_up_loc (location_t, tree, int); +#define round_down(T,N) round_down_loc (UNKNOWN_LOCATION, T, N) +extern tree round_down_loc (location_t, tree, int); +extern VEC(tree,gc) *get_pending_sizes (void); +extern void put_pending_size (tree); +extern void put_pending_sizes (VEC(tree,gc) *); +extern void finalize_size_functions (void); + +/* Type for sizes of data-type. */ + +#define BITS_PER_UNIT_LOG \ + ((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \ + + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \ + + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256)) + +/* If nonzero, an upper limit on alignment of structure fields, in bits, */ +extern unsigned int maximum_field_alignment; + +/* Concatenate two lists (chains of TREE_LIST nodes) X and Y + by making the last node in X point to Y. + Returns X, except if X is 0 returns Y. */ + +extern tree chainon (tree, tree); + +/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */ + +extern tree tree_cons_stat (tree, tree, tree MEM_STAT_DECL); +#define tree_cons(t,q,w) tree_cons_stat (t,q,w MEM_STAT_INFO) + +/* Return the last tree node in a chain. */ + +extern tree tree_last (tree); + +/* Reverse the order of elements in a chain, and return the new head. */ + +extern tree nreverse (tree); + +/* Returns the length of a chain of nodes + (number of chain pointers to follow before reaching a null pointer). */ + +extern int list_length (const_tree); + +/* Returns the number of FIELD_DECLs in a type. */ + +extern int fields_length (const_tree); + +/* Returns the first FIELD_DECL in a type. */ + +extern tree first_field (const_tree); + +/* Given an initializer INIT, return TRUE if INIT is zero or some + aggregate of zeros. Otherwise return FALSE. */ + +extern bool initializer_zerop (const_tree); + +/* Given a CONSTRUCTOR CTOR, return the element values as a vector. */ + +extern VEC(tree,gc) *ctor_to_vec (tree); + +/* Examine CTOR to discover: + * how many scalar fields are set to nonzero values, + and place it in *P_NZ_ELTS; + * how many scalar fields in total are in CTOR, + and place it in *P_ELT_COUNT. + * if a type is a union, and the initializer from the constructor + is not the largest element in the union, then set *p_must_clear. + + Return whether or not CTOR is a valid static constant initializer, the same + as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0". */ + +extern bool categorize_ctor_elements (const_tree, HOST_WIDE_INT *, HOST_WIDE_INT *, + bool *); + +extern HOST_WIDE_INT count_type_elements (const_tree, bool); + +/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */ + +extern int integer_zerop (const_tree); + +/* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */ + +extern int integer_onep (const_tree); + +/* integer_all_onesp (tree x) is nonzero if X is an integer constant + all of whose significant bits are 1. */ + +extern int integer_all_onesp (const_tree); + +/* integer_pow2p (tree x) is nonzero is X is an integer constant with + exactly one bit 1. */ + +extern int integer_pow2p (const_tree); + +/* integer_nonzerop (tree x) is nonzero if X is an integer constant + with a nonzero value. */ + +extern int integer_nonzerop (const_tree); + +extern bool cst_and_fits_in_hwi (const_tree); +extern tree num_ending_zeros (const_tree); + +/* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of + value 0. */ + +extern int fixed_zerop (const_tree); + +/* staticp (tree x) is nonzero if X is a reference to data allocated + at a fixed address in memory. Returns the outermost data. */ + +extern tree staticp (tree); + +/* save_expr (EXP) returns an expression equivalent to EXP + but it can be used multiple times within context CTX + and only evaluate EXP once. */ + +extern tree save_expr (tree); + +/* Look inside EXPR and into any simple arithmetic operations. Return + the innermost non-arithmetic node. */ + +extern tree skip_simple_arithmetic (tree); + +/* Return which tree structure is used by T. */ + +enum tree_node_structure_enum tree_node_structure (const_tree); + +/* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a + size or offset that depends on a field within a record. */ + +extern bool contains_placeholder_p (const_tree); + +/* This macro calls the above function but short-circuits the common + case of a constant to save time. Also check for null. */ + +#define CONTAINS_PLACEHOLDER_P(EXP) \ + ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP)) + +/* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR + directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and + field positions. */ + +extern bool type_contains_placeholder_p (tree); + +/* Given a tree EXP, find all occurences of references to fields + in a PLACEHOLDER_EXPR and place them in vector REFS without + duplicates. Also record VAR_DECLs and CONST_DECLs. Note that + we assume here that EXP contains only arithmetic expressions + or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their + argument list. */ + +extern void find_placeholder_in_expr (tree, VEC (tree, heap) **); + +/* This macro calls the above function but short-circuits the common + case of a constant to save time and also checks for NULL. */ + +#define FIND_PLACEHOLDER_IN_EXPR(EXP, V) \ +do { \ + if((EXP) && !TREE_CONSTANT (EXP)) \ + find_placeholder_in_expr (EXP, V); \ +} while (0) + +/* Given a tree EXP, a FIELD_DECL F, and a replacement value R, + return a tree with all occurrences of references to F in a + PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and + CONST_DECLs. Note that we assume here that EXP contains only + arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs + occurring only in their argument list. */ + +extern tree substitute_in_expr (tree, tree, tree); + +/* This macro calls the above function but short-circuits the common + case of a constant to save time and also checks for NULL. */ + +#define SUBSTITUTE_IN_EXPR(EXP, F, R) \ + ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R)) + +/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement + for it within OBJ, a tree that is an object or a chain of references. */ + +extern tree substitute_placeholder_in_expr (tree, tree); + +/* This macro calls the above function but short-circuits the common + case of a constant to save time and also checks for NULL. */ + +#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \ + ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \ + : substitute_placeholder_in_expr (EXP, OBJ)) + +/* variable_size (EXP) is like save_expr (EXP) except that it + is for the special case of something that is part of a + variable size for a data type. It makes special arrangements + to compute the value at the right time when the data type + belongs to a function parameter. */ + +extern tree variable_size (tree); + +/* stabilize_reference (EXP) returns a reference equivalent to EXP + but it can be used multiple times + and only evaluate the subexpressions once. */ + +extern tree stabilize_reference (tree); + +/* Subroutine of stabilize_reference; this is called for subtrees of + references. Any expression with side-effects must be put in a SAVE_EXPR + to ensure that it is only evaluated once. */ + +extern tree stabilize_reference_1 (tree); + +/* Return EXP, stripped of any conversions to wider types + in such a way that the result of converting to type FOR_TYPE + is the same as if EXP were converted to FOR_TYPE. + If FOR_TYPE is 0, it signifies EXP's type. */ + +extern tree get_unwidened (tree, tree); + +/* Return OP or a simpler expression for a narrower value + which can be sign-extended or zero-extended to give back OP. + Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended + or 0 if the value should be sign-extended. */ + +extern tree get_narrower (tree, int *); + +/* Return true if T is an expression that get_inner_reference handles. */ + +static inline bool +handled_component_p (const_tree t) +{ + switch (TREE_CODE (t)) + { + case BIT_FIELD_REF: + case COMPONENT_REF: + case ARRAY_REF: + case ARRAY_RANGE_REF: + case VIEW_CONVERT_EXPR: + case REALPART_EXPR: + case IMAGPART_EXPR: + return true; + + default: + return false; + } +} + +/* Given an expression EXP that is a handled_component_p, + look for the ultimate containing object, which is returned and specify + the access position and size. */ + +extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *, + tree *, enum machine_mode *, int *, int *, + bool); + +/* Given an expression EXP that may be a COMPONENT_REF, an ARRAY_REF or an + ARRAY_RANGE_REF, look for whether EXP or any nested component-refs within + EXP is marked as PACKED. */ + +extern bool contains_packed_reference (const_tree exp); + +/* Return a tree of sizetype representing the size, in bytes, of the element + of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ + +extern tree array_ref_element_size (tree); + +/* Return a tree representing the lower bound of the array mentioned in + EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ + +extern tree array_ref_low_bound (tree); + +/* Return a tree representing the upper bound of the array mentioned in + EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ + +extern tree array_ref_up_bound (tree); + +/* Return a tree representing the offset, in bytes, of the field referenced + by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */ + +extern tree component_ref_field_offset (tree); + +/* Given a DECL or TYPE, return the scope in which it was declared, or + NUL_TREE if there is no containing scope. */ + +extern tree get_containing_scope (const_tree); + +/* Return the FUNCTION_DECL which provides this _DECL with its context, + or zero if none. */ +extern tree decl_function_context (const_tree); + +/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides + this _DECL with its context, or zero if none. */ +extern tree decl_type_context (const_tree); + +/* Return 1 if EXPR is the real constant zero. */ +extern int real_zerop (const_tree); + +/* Declare commonly used variables for tree structure. */ + +/* Nonzero means lvalues are limited to those valid in pedantic ANSI C. + Zero means allow extended lvalues. */ + +extern int pedantic_lvalues; + +/* Points to the FUNCTION_DECL of the function whose body we are reading. */ + +extern GTY(()) tree current_function_decl; + +/* Nonzero means a FUNC_BEGIN label was emitted. */ +extern GTY(()) const char * current_function_func_begin_label; + +/* Iterator for going through the function arguments. */ +typedef struct { + tree next; /* TREE_LIST pointing to the next argument */ +} function_args_iterator; + +/* Initialize the iterator I with arguments from function FNDECL */ + +static inline void +function_args_iter_init (function_args_iterator *i, const_tree fntype) +{ + i->next = TYPE_ARG_TYPES (fntype); +} + +/* Return a pointer that holds the next argument if there are more arguments to + handle, otherwise return NULL. */ + +static inline tree * +function_args_iter_cond_ptr (function_args_iterator *i) +{ + return (i->next) ? &TREE_VALUE (i->next) : NULL; +} + +/* Return the next argument if there are more arguments to handle, otherwise + return NULL. */ + +static inline tree +function_args_iter_cond (function_args_iterator *i) +{ + return (i->next) ? TREE_VALUE (i->next) : NULL_TREE; +} + +/* Advance to the next argument. */ +static inline void +function_args_iter_next (function_args_iterator *i) +{ + gcc_assert (i->next != NULL_TREE); + i->next = TREE_CHAIN (i->next); +} + +/* We set BLOCK_SOURCE_LOCATION only to inlined function entry points. */ + +static inline bool +inlined_function_outer_scope_p (const_tree block) +{ + return BLOCK_SOURCE_LOCATION (block) != UNKNOWN_LOCATION; +} + +/* Loop over all function arguments of FNTYPE. In each iteration, PTR is set + to point to the next tree element. ITER is an instance of + function_args_iterator used to iterate the arguments. */ +#define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER) \ + for (function_args_iter_init (&(ITER), (FNTYPE)); \ + (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL; \ + function_args_iter_next (&(ITER))) + +/* Loop over all function arguments of FNTYPE. In each iteration, TREE is set + to the next tree element. ITER is an instance of function_args_iterator + used to iterate the arguments. */ +#define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER) \ + for (function_args_iter_init (&(ITER), (FNTYPE)); \ + (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE; \ + function_args_iter_next (&(ITER))) + + + +/* In tree.c */ +extern unsigned crc32_string (unsigned, const char *); +extern unsigned crc32_byte (unsigned, char); +extern void clean_symbol_name (char *); +extern tree get_file_function_name (const char *); +extern tree get_callee_fndecl (const_tree); +extern int type_num_arguments (const_tree); +extern bool associative_tree_code (enum tree_code); +extern bool commutative_tree_code (enum tree_code); +extern bool commutative_ternary_tree_code (enum tree_code); +extern tree upper_bound_in_type (tree, tree); +extern tree lower_bound_in_type (tree, tree); +extern int operand_equal_for_phi_arg_p (const_tree, const_tree); +extern tree call_expr_arg (tree, int); +extern tree *call_expr_argp (tree, int); +extern tree create_artificial_label (location_t); +extern const char *get_name (tree); +extern bool stdarg_p (const_tree); +extern bool prototype_p (tree); +extern bool is_typedef_decl (tree x); +extern bool typedef_variant_p (tree); +extern bool auto_var_in_fn_p (const_tree, const_tree); +extern tree build_low_bits_mask (tree, unsigned); +extern tree tree_strip_nop_conversions (tree); +extern tree tree_strip_sign_nop_conversions (tree); +extern tree lhd_gcc_personality (void); +extern void assign_assembler_name_if_neeeded (tree); +extern void warn_deprecated_use (tree, tree); + + +/* In cgraph.c */ +extern void change_decl_assembler_name (tree, tree); + +/* In gimplify.c */ +extern tree unshare_expr (tree); + +/* In stmt.c */ + +extern void expand_expr_stmt (tree); +extern int warn_if_unused_value (const_tree, location_t); +extern void expand_label (tree); +extern void expand_goto (tree); + +extern rtx expand_stack_save (void); +extern void expand_stack_restore (tree); +extern void expand_return (tree); + +/* In tree-eh.c */ +extern void using_eh_for_cleanups (void); + +/* In fold-const.c */ + +/* Non-zero if we are folding constants inside an initializer; zero + otherwise. */ +extern int folding_initializer; + +/* Convert between trees and native memory representation. */ +extern int native_encode_expr (const_tree, unsigned char *, int); +extern tree native_interpret_expr (tree, const unsigned char *, int); + +/* Fold constants as much as possible in an expression. + Returns the simplified expression. + Acts only on the top level of the expression; + if the argument itself cannot be simplified, its + subexpressions are not changed. */ + +extern tree fold (tree); +#define fold_unary(CODE,T1,T2)\ + fold_unary_loc (UNKNOWN_LOCATION, CODE, T1, T2) +extern tree fold_unary_loc (location_t, enum tree_code, tree, tree); +#define fold_unary_ignore_overflow(CODE,T1,T2)\ + fold_unary_ignore_overflow_loc (UNKNOWN_LOCATION, CODE, T1, T2) +extern tree fold_unary_ignore_overflow_loc (location_t, enum tree_code, tree, tree); +#define fold_binary(CODE,T1,T2,T3)\ + fold_binary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3) +extern tree fold_binary_loc (location_t, enum tree_code, tree, tree, tree); +#define fold_ternary(CODE,T1,T2,T3,T4)\ + fold_ternary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3, T4) +extern tree fold_ternary_loc (location_t, enum tree_code, tree, tree, tree, tree); +#define fold_build1(c,t1,t2)\ + fold_build1_stat_loc (UNKNOWN_LOCATION, c, t1, t2 MEM_STAT_INFO) +#define fold_build1_loc(l,c,t1,t2)\ + fold_build1_stat_loc (l, c, t1, t2 MEM_STAT_INFO) +extern tree fold_build1_stat_loc (location_t, enum tree_code, tree, + tree MEM_STAT_DECL); +#define fold_build2(c,t1,t2,t3)\ + fold_build2_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3 MEM_STAT_INFO) +#define fold_build2_loc(l,c,t1,t2,t3)\ + fold_build2_stat_loc (l, c, t1, t2, t3 MEM_STAT_INFO) +extern tree fold_build2_stat_loc (location_t, enum tree_code, tree, tree, + tree MEM_STAT_DECL); +#define fold_build3(c,t1,t2,t3,t4)\ + fold_build3_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3, t4 MEM_STAT_INFO) +#define fold_build3_loc(l,c,t1,t2,t3,t4)\ + fold_build3_stat_loc (l, c, t1, t2, t3, t4 MEM_STAT_INFO) +extern tree fold_build3_stat_loc (location_t, enum tree_code, tree, tree, tree, + tree MEM_STAT_DECL); +extern tree fold_build1_initializer_loc (location_t, enum tree_code, tree, tree); +extern tree fold_build2_initializer_loc (location_t, enum tree_code, tree, tree, tree); +extern tree fold_build3_initializer_loc (location_t, enum tree_code, tree, tree, tree, tree); +#define fold_build_call_array(T1,T2,N,T4)\ + fold_build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T4) +extern tree fold_build_call_array_loc (location_t, tree, tree, int, tree *); +#define fold_build_call_array_initializer(T1,T2,N,T4)\ + fold_build_call_array_initializer_loc (UNKNOWN_LOCATION, T1, T2, N, T4) +extern tree fold_build_call_array_initializer_loc (location_t, tree, tree, int, tree *); +extern bool fold_convertible_p (const_tree, const_tree); +#define fold_convert(T1,T2)\ + fold_convert_loc(UNKNOWN_LOCATION, T1, T2) +extern tree fold_convert_loc (location_t, tree, tree); +extern tree fold_single_bit_test (location_t, enum tree_code, tree, tree, tree); +extern tree fold_ignored_result (tree); +extern tree fold_abs_const (tree, tree); +extern tree fold_indirect_ref_1 (location_t, tree, tree); +extern void fold_defer_overflow_warnings (void); +extern void fold_undefer_overflow_warnings (bool, const_gimple, int); +extern void fold_undefer_and_ignore_overflow_warnings (void); +extern bool fold_deferring_overflow_warnings_p (void); +extern tree fold_fma (location_t, tree, tree, tree, tree); + +enum operand_equal_flag +{ + OEP_ONLY_CONST = 1, + OEP_PURE_SAME = 2, + OEP_ALLOW_NULL = 4, /* Allow NULL operands to be passed in and compared. */ + OEP_ALLOW_NO_TYPE = 8 /* Allow operands both of which don't have a type + to be compared. */ +}; + +extern int operand_equal_p (const_tree, const_tree, unsigned int); +extern int multiple_of_p (tree, const_tree, const_tree); +#define omit_one_operand(T1,T2,T3)\ + omit_one_operand_loc (UNKNOWN_LOCATION, T1, T2, T3) +extern tree omit_one_operand_loc (location_t, tree, tree, tree); +#define omit_two_operands(T1,T2,T3,T4)\ + omit_two_operands_loc (UNKNOWN_LOCATION, T1, T2, T3, T4) +extern tree omit_two_operands_loc (location_t, tree, tree, tree, tree); +#define invert_truthvalue(T)\ + invert_truthvalue_loc(UNKNOWN_LOCATION, T) +extern tree invert_truthvalue_loc (location_t, tree); +extern tree fold_truth_not_expr (location_t, tree); +extern tree fold_unary_to_constant (enum tree_code, tree, tree); +extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree); +extern tree fold_read_from_constant_string (tree); +extern tree int_const_binop (enum tree_code, const_tree, const_tree, int); +#define build_fold_addr_expr(T)\ + build_fold_addr_expr_loc (UNKNOWN_LOCATION, (T)) +extern tree build_fold_addr_expr_loc (location_t, tree); +#define build_fold_addr_expr_with_type(T,TYPE)\ + build_fold_addr_expr_with_type_loc (UNKNOWN_LOCATION, (T), TYPE) +extern tree build_fold_addr_expr_with_type_loc (location_t, tree, tree); +extern tree fold_build_cleanup_point_expr (tree type, tree expr); +extern tree fold_strip_sign_ops (tree); +#define build_fold_indirect_ref(T)\ + build_fold_indirect_ref_loc (UNKNOWN_LOCATION, T) +extern tree build_fold_indirect_ref_loc (location_t, tree); +#define fold_indirect_ref(T)\ + fold_indirect_ref_loc (UNKNOWN_LOCATION, T) +extern tree fold_indirect_ref_loc (location_t, tree); +extern tree build_simple_mem_ref_loc (location_t, tree); +#define build_simple_mem_ref(T)\ + build_simple_mem_ref_loc (UNKNOWN_LOCATION, T) +extern double_int mem_ref_offset (const_tree); +extern tree reference_alias_ptr_type (const_tree); +extern tree constant_boolean_node (int, tree); +extern tree div_if_zero_remainder (enum tree_code, const_tree, const_tree); + +extern bool tree_swap_operands_p (const_tree, const_tree, bool); +extern enum tree_code swap_tree_comparison (enum tree_code); + +extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *); +extern enum tree_code invert_tree_comparison (enum tree_code, bool); + +extern bool tree_expr_nonzero_p (tree); +extern bool tree_unary_nonzero_warnv_p (enum tree_code, tree, tree, bool *); +extern bool tree_binary_nonzero_warnv_p (enum tree_code, tree, tree, tree op1, + bool *); +extern bool tree_single_nonzero_warnv_p (tree, bool *); +extern bool tree_unary_nonnegative_warnv_p (enum tree_code, tree, tree, bool *); +extern bool tree_binary_nonnegative_warnv_p (enum tree_code, tree, tree, tree, + bool *); +extern bool tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p); +extern bool tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p); +extern bool tree_call_nonnegative_warnv_p (tree, tree, tree, tree, bool *); + +extern bool tree_expr_nonzero_warnv_p (tree, bool *); + +extern bool fold_real_zero_addition_p (const_tree, const_tree, int); +extern tree combine_comparisons (location_t, enum tree_code, enum tree_code, + enum tree_code, tree, tree, tree); +extern void debug_fold_checksum (const_tree); + +/* Return nonzero if CODE is a tree code that represents a truth value. */ +static inline bool +truth_value_p (enum tree_code code) +{ + return (TREE_CODE_CLASS (code) == tcc_comparison + || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR + || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR + || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR); +} + + +/* In builtins.c */ +extern bool avoid_folding_inline_builtin (tree); +extern tree fold_call_expr (location_t, tree, bool); +extern tree fold_builtin_fputs (location_t, tree, tree, bool, bool, tree); +extern tree fold_builtin_strcpy (location_t, tree, tree, tree, tree); +extern tree fold_builtin_strncpy (location_t, tree, tree, tree, tree, tree); +extern tree fold_builtin_memory_chk (location_t, tree, tree, tree, tree, tree, tree, bool, + enum built_in_function); +extern tree fold_builtin_stxcpy_chk (location_t, tree, tree, tree, tree, tree, bool, + enum built_in_function); +extern tree fold_builtin_strncpy_chk (location_t, tree, tree, tree, tree, tree); +extern tree fold_builtin_snprintf_chk (location_t, tree, tree, enum built_in_function); +extern bool fold_builtin_next_arg (tree, bool); +extern enum built_in_function builtin_mathfn_code (const_tree); +extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *); +extern tree build_call_expr_loc_array (location_t, tree, int, tree *); +extern tree build_call_expr_loc_vec (location_t, tree, VEC(tree,gc) *); +extern tree build_call_expr_loc (location_t, tree, int, ...); +extern tree build_call_expr (tree, int, ...); +extern tree mathfn_built_in (tree, enum built_in_function fn); +extern tree c_strlen (tree, int); +extern tree std_gimplify_va_arg_expr (tree, tree, gimple_seq *, gimple_seq *); +extern tree build_va_arg_indirect_ref (tree); +extern tree build_string_literal (int, const char *); +extern bool validate_arglist (const_tree, ...); +extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode); +extern bool can_trust_pointer_alignment (void); +extern unsigned int get_pointer_alignment (tree, unsigned int); +extern bool is_builtin_name (const char *); +extern bool is_builtin_fn (tree); +extern unsigned int get_object_alignment (tree, unsigned int); +extern tree fold_call_stmt (gimple, bool); +extern tree gimple_fold_builtin_snprintf_chk (gimple, tree, enum built_in_function); +extern tree make_range (tree, int *, tree *, tree *, bool *); +extern tree build_range_check (location_t, tree, tree, int, tree, tree); +extern bool merge_ranges (int *, tree *, tree *, int, tree, tree, int, + tree, tree); +extern void set_builtin_user_assembler_name (tree decl, const char *asmspec); +extern bool is_simple_builtin (tree); +extern bool is_inexpensive_builtin (tree); + +/* In convert.c */ +extern tree strip_float_extensions (tree); + +/* In tree.c */ +extern int really_constant_p (const_tree); +extern bool decl_address_invariant_p (const_tree); +extern bool decl_address_ip_invariant_p (const_tree); +extern bool int_fits_type_p (const_tree, const_tree); +#ifndef GENERATOR_FILE +extern void get_type_static_bounds (const_tree, mpz_t, mpz_t); +#endif +extern bool variably_modified_type_p (tree, tree); +extern int tree_log2 (const_tree); +extern int tree_floor_log2 (const_tree); +extern int simple_cst_equal (const_tree, const_tree); +extern hashval_t iterative_hash_expr (const_tree, hashval_t); +extern hashval_t iterative_hash_exprs_commutative (const_tree, + const_tree, hashval_t); +extern hashval_t iterative_hash_host_wide_int (HOST_WIDE_INT, hashval_t); +extern hashval_t iterative_hash_hashval_t (hashval_t, hashval_t); +extern hashval_t iterative_hash_host_wide_int (HOST_WIDE_INT, hashval_t); +extern int compare_tree_int (const_tree, unsigned HOST_WIDE_INT); +extern int type_list_equal (const_tree, const_tree); +extern int chain_member (const_tree, const_tree); +extern tree type_hash_lookup (unsigned int, tree); +extern void type_hash_add (unsigned int, tree); +extern int simple_cst_list_equal (const_tree, const_tree); +extern void dump_tree_statistics (void); +extern void recompute_tree_invariant_for_addr_expr (tree); +extern bool needs_to_live_in_memory (const_tree); +extern tree reconstruct_complex_type (tree, tree); + +extern int real_onep (const_tree); +extern int real_twop (const_tree); +extern int real_minus_onep (const_tree); +extern void init_ttree (void); +extern void build_common_tree_nodes (bool); +extern void build_common_tree_nodes_2 (int); +extern void build_common_builtin_nodes (void); +extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int); +extern tree build_range_type (tree, tree, tree); +extern tree build_nonshared_range_type (tree, tree, tree); +extern bool subrange_type_for_debug_p (const_tree, tree *, tree *); +extern HOST_WIDE_INT int_cst_value (const_tree); +extern HOST_WIDEST_INT widest_int_cst_value (const_tree); + +extern bool fields_compatible_p (const_tree, const_tree); +extern tree find_compatible_field (tree, tree); + +extern tree *tree_block (tree); +extern location_t *block_nonartificial_location (tree); +extern location_t tree_nonartificial_location (tree); + +extern tree block_ultimate_origin (const_tree); + +extern tree get_binfo_at_offset (tree, HOST_WIDE_INT, tree); + +/* In tree-nested.c */ +extern tree build_addr (tree, tree); + +/* In function.c */ +extern void expand_main_function (void); +extern void expand_function_end (void); +extern void expand_function_start (tree); +extern void stack_protect_prologue (void); +extern void stack_protect_epilogue (void); +extern void init_dummy_function_start (void); +extern void expand_dummy_function_end (void); +extern unsigned int init_function_for_compilation (void); +extern void allocate_struct_function (tree, bool); +extern void push_struct_function (tree fndecl); +extern void init_function_start (tree); +extern bool use_register_for_decl (const_tree); +extern void generate_setjmp_warnings (void); +extern void init_temp_slots (void); +extern void free_temp_slots (void); +extern void pop_temp_slots (void); +extern void push_temp_slots (void); +extern void preserve_temp_slots (rtx); +extern int aggregate_value_p (const_tree, const_tree); +extern void push_function_context (void); +extern void pop_function_context (void); +extern gimple_seq gimplify_parameters (void); + +/* In print-rtl.c */ +#ifdef BUFSIZ +extern void print_rtl (FILE *, const_rtx); +#endif + +/* In print-tree.c */ +extern void debug_tree (tree); +extern void debug_vec_tree (VEC(tree,gc) *); +#ifdef BUFSIZ +extern void dump_addr (FILE*, const char *, const void *); +extern void print_node (FILE *, const char *, tree, int); +extern void print_vec_tree (FILE *, const char *, VEC(tree,gc) *, int); +extern void print_node_brief (FILE *, const char *, const_tree, int); +extern void indent_to (FILE *, int); +#endif + +/* In tree-inline.c: */ +extern bool debug_find_tree (tree, tree); +/* This is in tree-inline.c since the routine uses + data structures from the inliner. */ +extern tree unsave_expr_now (tree); +extern tree build_duplicate_type (tree); + +/* In calls.c */ + +/* Nonzero if this is a call to a function whose return value depends + solely on its arguments, has no side effects, and does not read + global memory. This corresponds to TREE_READONLY for function + decls. */ +#define ECF_CONST (1 << 0) +/* Nonzero if this is a call to "pure" function (like const function, + but may read memory. This corresponds to DECL_PURE_P for function + decls. */ +#define ECF_PURE (1 << 1) +/* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no + infinite loop. This corresponds to DECL_LOOPING_CONST_OR_PURE_P + for function decls.*/ +#define ECF_LOOPING_CONST_OR_PURE (1 << 2) +/* Nonzero if this call will never return. */ +#define ECF_NORETURN (1 << 3) +/* Nonzero if this is a call to malloc or a related function. */ +#define ECF_MALLOC (1 << 4) +/* Nonzero if it is plausible that this is a call to alloca. */ +#define ECF_MAY_BE_ALLOCA (1 << 5) +/* Nonzero if this is a call to a function that won't throw an exception. */ +#define ECF_NOTHROW (1 << 6) +/* Nonzero if this is a call to setjmp or a related function. */ +#define ECF_RETURNS_TWICE (1 << 7) +/* Nonzero if this call replaces the current stack frame. */ +#define ECF_SIBCALL (1 << 8) +/* Function does not read or write memory (but may have side effects, so + it does not necessarily fit ECF_CONST). */ +#define ECF_NOVOPS (1 << 9) +/* The function does not lead to calls within current function unit. */ +#define ECF_LEAF (1 << 10) + +extern int flags_from_decl_or_type (const_tree); +extern int call_expr_flags (const_tree); + +/* Call argument flags. */ + +/* Nonzero if the argument is not dereferenced recursively, thus only + directly reachable memory is read or written. */ +#define EAF_DIRECT (1 << 0) +/* Nonzero if memory reached by the argument is not clobbered. */ +#define EAF_NOCLOBBER (1 << 1) +/* Nonzero if the argument does not escape. */ +#define EAF_NOESCAPE (1 << 2) +/* Nonzero if the argument is not used by the function. */ +#define EAF_UNUSED (1 << 3) + +/* Call return flags. */ + +/* Mask for the argument number that is returned. Lower two bits of + the return flags, encodes argument slots zero to three. */ +#define ERF_RETURN_ARG_MASK (3) +/* Nonzero if the return value is equal to the argument number + flags & ERF_RETURN_ARG_MASK. */ +#define ERF_RETURNS_ARG (1 << 2) +/* Nonzero if the return value does not alias with anything. Functions + with the malloc attribute have this set on their return value. */ +#define ERF_NOALIAS (1 << 3) + +extern int setjmp_call_p (const_tree); +extern bool gimple_alloca_call_p (const_gimple); +extern bool alloca_call_p (const_tree); +extern bool must_pass_in_stack_var_size (enum machine_mode, const_tree); +extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, const_tree); + +/* In attribs.c. */ + +extern const struct attribute_spec *lookup_attribute_spec (const_tree); + +/* Process the attributes listed in ATTRIBUTES and install them in *NODE, + which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, + it should be modified in place; if a TYPE, a copy should be created + unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further + information, in the form of a bitwise OR of flags in enum attribute_flags + from tree.h. Depending on these flags, some attributes may be + returned to be applied at a later stage (for example, to apply + a decl attribute to the declaration rather than to its type). */ +extern tree decl_attributes (tree *, tree, int); + +/* Return true if the given identifier tree is the name of a lock attribute + that takes arguments. */ +extern bool is_lock_attribute_with_args (const_tree); + +/* Extract and return all lock attributes from the given attribute list. */ +extern tree extract_lock_attributes (tree); + +/* In integrate.c */ +extern void set_decl_abstract_flags (tree, int); +extern void set_decl_origin_self (tree); + +/* In stor-layout.c */ +extern void set_min_and_max_values_for_integral_type (tree, int, bool); +extern void fixup_signed_type (tree); +extern void internal_reference_types (void); +extern unsigned int update_alignment_for_field (record_layout_info, tree, + unsigned int); +/* varasm.c */ +extern tree tree_output_constant_def (tree); +extern void make_decl_rtl (tree); +extern rtx make_decl_rtl_for_debug (tree); +extern void make_decl_one_only (tree, tree); +extern int supports_one_only (void); +extern void resolve_unique_section (tree, int, int); +extern void mark_referenced (tree); +extern void mark_decl_referenced (tree); +extern void notice_global_symbol (tree); +extern void set_user_assembler_name (tree, const char *); +extern void process_pending_assemble_externals (void); +extern void finish_aliases_1 (void); +extern void finish_aliases_2 (void); +extern void remove_unreachable_alias_pairs (void); +extern bool decl_replaceable_p (tree); +extern bool decl_binds_to_current_def_p (tree); + +/* Derived type for use by compute_visible_aliases and callers. A symbol + alias set is a pointer set into which we enter IDENTIFIER_NODES bearing + the canonicalised assembler-level symbol names corresponding to decls + and their aliases. */ +typedef struct pointer_set_t symbol_alias_set_t; + +extern void symbol_alias_set_destroy (symbol_alias_set_t *); +extern int symbol_alias_set_contains (const symbol_alias_set_t *, tree); +extern symbol_alias_set_t * propagate_aliases_backward (bool (*) + (tree, tree, void *), + void *); + +/* In stmt.c */ +extern void expand_computed_goto (tree); +extern bool parse_output_constraint (const char **, int, int, int, + bool *, bool *, bool *); +extern bool parse_input_constraint (const char **, int, int, int, int, + const char * const *, bool *, bool *); +extern void expand_asm_stmt (gimple); +extern tree resolve_asm_operand_names (tree, tree, tree, tree); +extern bool expand_switch_using_bit_tests_p (tree, tree, unsigned int, + unsigned int); +extern void expand_case (gimple); +extern void expand_decl (tree); +#ifdef HARD_CONST +/* Silly ifdef to avoid having all includers depend on hard-reg-set.h. */ +extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *); +#endif + + +/* In dwarf2out.c */ +/* Interface of the DWARF2 unwind info support. */ + +/* Generate a new label for the CFI info to refer to. */ + +extern char *dwarf2out_cfi_label (bool); + +/* Entry point to update the canonical frame address (CFA). */ + +extern void dwarf2out_def_cfa (const char *, unsigned, HOST_WIDE_INT); + +/* Add the CFI for saving a register window. */ + +extern void dwarf2out_window_save (const char *); + +/* Entry point for saving a register to the stack. */ + +extern void dwarf2out_reg_save (const char *, unsigned, HOST_WIDE_INT); + +/* Entry point for saving the return address in the stack. */ + +extern void dwarf2out_return_save (const char *, HOST_WIDE_INT); + +/* Entry point for saving the return address in a register. */ + +extern void dwarf2out_return_reg (const char *, unsigned); + +/* Entry point for saving the first register into the second. */ + +extern void dwarf2out_reg_save_reg (const char *, rtx, rtx); + +/* In tree-inline.c */ + +/* The type of a set of already-visited pointers. Functions for creating + and manipulating it are declared in pointer-set.h */ +struct pointer_set_t; + +/* The type of a callback function for walking over tree structure. */ + +typedef tree (*walk_tree_fn) (tree *, int *, void *); + +/* The type of a callback function that represents a custom walk_tree. */ + +typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *), + void *, struct pointer_set_t*); + +extern tree walk_tree_1 (tree*, walk_tree_fn, void*, struct pointer_set_t*, + walk_tree_lh); +extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*, + walk_tree_lh); +#define walk_tree(a,b,c,d) \ + walk_tree_1 (a, b, c, d, NULL) +#define walk_tree_without_duplicates(a,b,c) \ + walk_tree_without_duplicates_1 (a, b, c, NULL) + +/* In emit-rtl.c */ +/* Assign the RTX to declaration. */ + +extern void set_decl_rtl (tree, rtx); +extern void set_decl_incoming_rtl (tree, rtx, bool); + +/* Enum and arrays used for tree allocation stats. + Keep in sync with tree.c:tree_node_kind_names. */ +typedef enum +{ + d_kind, + t_kind, + b_kind, + s_kind, + r_kind, + e_kind, + c_kind, + id_kind, + vec_kind, + binfo_kind, + ssa_name_kind, + constr_kind, + x_kind, + lang_decl, + lang_type, + omp_clause_kind, + all_kinds +} tree_node_kind; + +extern int tree_node_counts[]; +extern int tree_node_sizes[]; + +/* True if we are in gimple form and the actions of the folders need to + be restricted. False if we are not in gimple form and folding is not + restricted to creating gimple expressions. */ +extern bool in_gimple_form; + +/* In gimple.c. */ +extern tree get_base_address (tree t); +extern void mark_addressable (tree); + +/* In tree.c. */ + +struct GTY(()) tree_map_base { + tree from; +}; + +extern int tree_map_base_eq (const void *, const void *); +extern unsigned int tree_map_base_hash (const void *); +extern int tree_map_base_marked_p (const void *); +extern bool list_equal_p (const_tree, const_tree); + +/* Map from a tree to another tree. */ + +struct GTY(()) tree_map { + struct tree_map_base base; + unsigned int hash; + tree to; +}; + +#define tree_map_eq tree_map_base_eq +extern unsigned int tree_map_hash (const void *); +#define tree_map_marked_p tree_map_base_marked_p + +/* Map from a decl tree to another tree. */ + +struct GTY(()) tree_decl_map { + struct tree_map_base base; + tree to; +}; + +#define tree_decl_map_eq tree_map_base_eq +extern unsigned int tree_decl_map_hash (const void *); +#define tree_decl_map_marked_p tree_map_base_marked_p + +/* Map from a tree to an int. */ + +struct GTY(()) tree_int_map { + struct tree_map_base base; + unsigned int to; +}; + +#define tree_int_map_eq tree_map_base_eq +#define tree_int_map_hash tree_map_base_hash +#define tree_int_map_marked_p tree_map_base_marked_p + +/* Map from a tree to initialization/finalization priorities. */ + +struct GTY(()) tree_priority_map { + struct tree_map_base base; + priority_type init; + priority_type fini; +}; + +#define tree_priority_map_eq tree_map_base_eq +#define tree_priority_map_hash tree_map_base_hash +#define tree_priority_map_marked_p tree_map_base_marked_p + +/* In tree-ssa.c */ + +tree target_for_debug_bind (tree); + +/* In tree-ssa-address.c. */ +extern tree tree_mem_ref_addr (tree, tree); +extern void copy_mem_ref_info (tree, tree); + +/* In tree-vrp.c */ +extern bool ssa_name_nonnegative_p (const_tree); + +/* In tree-object-size.c. */ +extern void init_object_sizes (void); +extern void fini_object_sizes (void); +extern unsigned HOST_WIDE_INT compute_builtin_object_size (tree, int); + +/* In expr.c. */ +extern unsigned HOST_WIDE_INT highest_pow2_factor (const_tree); +extern tree build_personality_function (const char *); + +/* In tree-inline.c. */ + +void init_inline_once (void); + +/* Compute the number of operands in an expression node NODE. For + tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself, + otherwise it is looked up from the node's code. */ +static inline int +tree_operand_length (const_tree node) +{ + if (VL_EXP_CLASS_P (node)) + return VL_EXP_OPERAND_LENGTH (node); + else + return TREE_CODE_LENGTH (TREE_CODE (node)); +} + +/* Abstract iterators for CALL_EXPRs. These static inline definitions + have to go towards the end of tree.h so that union tree_node is fully + defined by this point. */ + +/* Structure containing iterator state. */ +typedef struct call_expr_arg_iterator_d { + tree t; /* the call_expr */ + int n; /* argument count */ + int i; /* next argument index */ +} call_expr_arg_iterator; + +typedef struct const_call_expr_arg_iterator_d { + const_tree t; /* the call_expr */ + int n; /* argument count */ + int i; /* next argument index */ +} const_call_expr_arg_iterator; + +/* Initialize the abstract argument list iterator object ITER with the + arguments from CALL_EXPR node EXP. */ +static inline void +init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter) +{ + iter->t = exp; + iter->n = call_expr_nargs (exp); + iter->i = 0; +} + +static inline void +init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter) +{ + iter->t = exp; + iter->n = call_expr_nargs (exp); + iter->i = 0; +} + +/* Return the next argument from abstract argument list iterator object ITER, + and advance its state. Return NULL_TREE if there are no more arguments. */ +static inline tree +next_call_expr_arg (call_expr_arg_iterator *iter) +{ + tree result; + if (iter->i >= iter->n) + return NULL_TREE; + result = CALL_EXPR_ARG (iter->t, iter->i); + iter->i++; + return result; +} + +static inline const_tree +next_const_call_expr_arg (const_call_expr_arg_iterator *iter) +{ + const_tree result; + if (iter->i >= iter->n) + return NULL_TREE; + result = CALL_EXPR_ARG (iter->t, iter->i); + iter->i++; + return result; +} + +/* Initialize the abstract argument list iterator object ITER, then advance + past and return the first argument. Useful in for expressions, e.g. + for (arg = first_call_expr_arg (exp, &iter); arg; + arg = next_call_expr_arg (&iter)) */ +static inline tree +first_call_expr_arg (tree exp, call_expr_arg_iterator *iter) +{ + init_call_expr_arg_iterator (exp, iter); + return next_call_expr_arg (iter); +} + +static inline const_tree +first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter) +{ + init_const_call_expr_arg_iterator (exp, iter); + return next_const_call_expr_arg (iter); +} + +/* Test whether there are more arguments in abstract argument list iterator + ITER, without changing its state. */ +static inline bool +more_call_expr_args_p (const call_expr_arg_iterator *iter) +{ + return (iter->i < iter->n); +} + +static inline bool +more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter) +{ + return (iter->i < iter->n); +} + +/* Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER + (of type call_expr_arg_iterator) to hold the iteration state. */ +#define FOR_EACH_CALL_EXPR_ARG(arg, iter, call) \ + for ((arg) = first_call_expr_arg ((call), &(iter)); (arg); \ + (arg) = next_call_expr_arg (&(iter))) + +#define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call) \ + for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg); \ + (arg) = next_const_call_expr_arg (&(iter))) + +/* Return true if tree node T is a language-specific node. */ +static inline bool +is_lang_specific (tree t) +{ + return TREE_CODE (t) == LANG_TYPE || TREE_CODE (t) >= NUM_TREE_CODES; +} + +/* In gimple-low.c. */ +extern bool block_may_fallthru (const_tree); + +#endif /* GCC_TREE_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/treestruct.def b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/treestruct.def new file mode 100644 index 0000000..baea46a --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/treestruct.def @@ -0,0 +1,67 @@ +/* This file contains the definitions for the tree structure + enumeration used in GCC. + +Copyright (C) 2005, 2007, 2008, 2010 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/>. */ + +/* The format of this file is + + DEFTREESTRUCT(enumeration value, printable name). + + Each enumeration value should correspond with a single member of + union tree_node. + + These enumerator values are used in order to distinguish members of + union tree_node for garbage collection purposes, as well as + specifying what structures contain what other structures in the + tree_contains_struct array. */ +DEFTREESTRUCT(TS_BASE, "base") +DEFTREESTRUCT(TS_COMMON, "common") +DEFTREESTRUCT(TS_INT_CST, "integer cst") +DEFTREESTRUCT(TS_REAL_CST, "real cst") +DEFTREESTRUCT(TS_FIXED_CST, "fixed cst") +DEFTREESTRUCT(TS_VECTOR, "vector") +DEFTREESTRUCT(TS_STRING, "string") +DEFTREESTRUCT(TS_COMPLEX, "complex") +DEFTREESTRUCT(TS_IDENTIFIER, "identifier") +DEFTREESTRUCT(TS_DECL_MINIMAL, "decl minimal") +DEFTREESTRUCT(TS_DECL_COMMON, "decl common") +DEFTREESTRUCT(TS_DECL_WRTL, "decl with RTL") +DEFTREESTRUCT(TS_DECL_NON_COMMON, "decl non-common") +DEFTREESTRUCT(TS_DECL_WITH_VIS, "decl with visibility") +DEFTREESTRUCT(TS_FIELD_DECL, "field decl") +DEFTREESTRUCT(TS_VAR_DECL, "var decl") +DEFTREESTRUCT(TS_PARM_DECL, "parm decl") +DEFTREESTRUCT(TS_LABEL_DECL, "label decl") +DEFTREESTRUCT(TS_RESULT_DECL, "result decl") +DEFTREESTRUCT(TS_CONST_DECL, "const decl") +DEFTREESTRUCT(TS_TYPE_DECL, "label decl") +DEFTREESTRUCT(TS_FUNCTION_DECL, "function decl") +DEFTREESTRUCT(TS_TRANSLATION_UNIT_DECL, "translation-unit decl") +DEFTREESTRUCT(TS_TYPE, "type") +DEFTREESTRUCT(TS_LIST, "list") +DEFTREESTRUCT(TS_VEC, "vec") +DEFTREESTRUCT(TS_EXP, "exp") +DEFTREESTRUCT(TS_SSA_NAME, "ssa name") +DEFTREESTRUCT(TS_BLOCK, "block") +DEFTREESTRUCT(TS_BINFO, "binfo") +DEFTREESTRUCT(TS_STATEMENT_LIST, "statement list") +DEFTREESTRUCT(TS_CONSTRUCTOR, "constructor") +DEFTREESTRUCT(TS_OMP_CLAUSE, "omp clause") +DEFTREESTRUCT(TS_OPTIMIZATION, "optimization options") +DEFTREESTRUCT(TS_TARGET_OPTION, "target options") diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vec.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vec.h new file mode 100644 index 0000000..bc55592 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vec.h @@ -0,0 +1,1394 @@ +/* Vector API for GNU compiler. + Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. + Contributed by Nathan Sidwell <nathan@codesourcery.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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/>. */ + +#ifndef GCC_VEC_H +#define GCC_VEC_H + +#include "statistics.h" /* For MEM_STAT_DECL. */ + +/* The macros here implement a set of templated vector types and + associated interfaces. These templates are implemented with + macros, as we're not in C++ land. The interface functions are + typesafe and use static inline functions, sometimes backed by + out-of-line generic functions. The vectors are designed to + interoperate with the GTY machinery. + + Because of the different behavior of structure objects, scalar + objects and of pointers, there are three flavors, one for each of + these variants. Both the structure object and pointer variants + pass pointers to objects around -- in the former case the pointers + are stored into the vector and in the latter case the pointers are + dereferenced and the objects copied into the vector. The scalar + object variant is suitable for int-like objects, and the vector + elements are returned by value. + + There are both 'index' and 'iterate' accessors. The iterator + returns a boolean iteration condition and updates the iteration + variable passed by reference. Because the iterator will be + inlined, the address-of can be optimized away. + + The vectors are implemented using the trailing array idiom, thus + they are not resizeable without changing the address of the vector + object itself. This means you cannot have variables or fields of + vector type -- always use a pointer to a vector. The one exception + is the final field of a structure, which could be a vector type. + You will have to use the embedded_size & embedded_init calls to + create such objects, and they will probably not be resizeable (so + don't use the 'safe' allocation variants). The trailing array + idiom is used (rather than a pointer to an array of data), because, + if we allow NULL to also represent an empty vector, empty vectors + occupy minimal space in the structure containing them. + + Each operation that increases the number of active elements is + available in 'quick' and 'safe' variants. The former presumes that + there is sufficient allocated space for the operation to succeed + (it dies if there is not). The latter will reallocate the + vector, if needed. Reallocation causes an exponential increase in + vector size. If you know you will be adding N elements, it would + be more efficient to use the reserve operation before adding the + elements with the 'quick' operation. This will ensure there are at + least as many elements as you ask for, it will exponentially + increase if there are too few spare slots. If you want reserve a + specific number of slots, but do not want the exponential increase + (for instance, you know this is the last allocation), use the + reserve_exact operation. You can also create a vector of a + specific size from the get go. + + You should prefer the push and pop operations, as they append and + remove from the end of the vector. If you need to remove several + items in one go, use the truncate operation. The insert and remove + operations allow you to change elements in the middle of the + vector. There are two remove operations, one which preserves the + element ordering 'ordered_remove', and one which does not + 'unordered_remove'. The latter function copies the end element + into the removed slot, rather than invoke a memmove operation. The + 'lower_bound' function will determine where to place an item in the + array using insert that will maintain sorted order. + + When a vector type is defined, first a non-memory managed version + is created. You can then define either or both garbage collected + and heap allocated versions. The allocation mechanism is specified + when the type is defined, and is therefore part of the type. If + you need both gc'd and heap allocated versions, you still must have + *exactly* one definition of the common non-memory managed base vector. + + If you need to directly manipulate a vector, then the 'address' + accessor will return the address of the start of the vector. Also + the 'space' predicate will tell you whether there is spare capacity + in the vector. You will not normally need to use these two functions. + + Vector types are defined using a DEF_VEC_{O,P,I}(TYPEDEF) macro, to + get the non-memory allocation version, and then a + DEF_VEC_ALLOC_{O,P,I}(TYPEDEF,ALLOC) macro to get memory managed + vectors. Variables of vector type are declared using a + VEC(TYPEDEF,ALLOC) macro. The ALLOC argument specifies the + allocation strategy, and can be either 'gc' or 'heap' for garbage + collected and heap allocated respectively. It can be 'none' to get + a vector that must be explicitly allocated (for instance as a + trailing array of another structure). The characters O, P and I + indicate whether TYPEDEF is a pointer (P), object (O) or integral + (I) type. Be careful to pick the correct one, as you'll get an + awkward and inefficient API if you use the wrong one. There is a + check, which results in a compile-time warning, for the P and I + versions, but there is no check for the O versions, as that is not + possible in plain C. Due to the way GTY works, you must annotate + any structures you wish to insert or reference from a vector with a + GTY(()) tag. You need to do this even if you never declare the GC + allocated variants. + + An example of their use would be, + + DEF_VEC_P(tree); // non-managed tree vector. + DEF_VEC_ALLOC_P(tree,gc); // gc'd vector of tree pointers. This must + // appear at file scope. + + struct my_struct { + VEC(tree,gc) *v; // A (pointer to) a vector of tree pointers. + }; + + struct my_struct *s; + + if (VEC_length(tree,s->v)) { we have some contents } + VEC_safe_push(tree,gc,s->v,decl); // append some decl onto the end + for (ix = 0; VEC_iterate(tree,s->v,ix,elt); ix++) + { do something with elt } + +*/ + +/* Macros to invoke API calls. A single macro works for both pointer + and object vectors, but the argument and return types might well be + different. In each macro, T is the typedef of the vector elements, + and A is the allocation strategy. The allocation strategy is only + present when it is required. Some of these macros pass the vector, + V, by reference (by taking its address), this is noted in the + descriptions. */ + +/* Length of vector + unsigned VEC_T_length(const VEC(T) *v); + + Return the number of active elements in V. V can be NULL, in which + case zero is returned. */ + +#define VEC_length(T,V) (VEC_OP(T,base,length)(VEC_BASE(V))) + + +/* Check if vector is empty + int VEC_T_empty(const VEC(T) *v); + + Return nonzero if V is an empty vector (or V is NULL), zero otherwise. */ + +#define VEC_empty(T,V) (VEC_length (T,V) == 0) + + +/* Get the final element of the vector. + T VEC_T_last(VEC(T) *v); // Integer + T VEC_T_last(VEC(T) *v); // Pointer + T *VEC_T_last(VEC(T) *v); // Object + + Return the final element. V must not be empty. */ + +#define VEC_last(T,V) (VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_INFO)) + +/* Index into vector + T VEC_T_index(VEC(T) *v, unsigned ix); // Integer + T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer + T *VEC_T_index(VEC(T) *v, unsigned ix); // Object + + Return the IX'th element. If IX must be in the domain of V. */ + +#define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_INFO)) + +/* Iterate over vector + int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Integer + int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Pointer + int VEC_T_iterate(VEC(T) *v, unsigned ix, T *&ptr); // Object + + Return iteration condition and update PTR to point to the IX'th + element. At the end of iteration, sets PTR to NULL. Use this to + iterate over the elements of a vector as follows, + + for (ix = 0; VEC_iterate(T,v,ix,ptr); ix++) + continue; */ + +#define VEC_iterate(T,V,I,P) (VEC_OP(T,base,iterate)(VEC_BASE(V),I,&(P))) + +/* Convenience macro for forward iteration. */ + +#define FOR_EACH_VEC_ELT(T, V, I, P) \ + for (I = 0; VEC_iterate (T, (V), (I), (P)); ++(I)) + +/* Convenience macro for reverse iteration. */ + +#define FOR_EACH_VEC_ELT_REVERSE(T,V,I,P) \ + for (I = VEC_length (T, (V)) - 1; \ + VEC_iterate (T, (V), (I), (P)); \ + (I)--) + +/* Allocate new vector. + VEC(T,A) *VEC_T_A_alloc(int reserve); + + Allocate a new vector with space for RESERVE objects. If RESERVE + is zero, NO vector is created. */ + +#define VEC_alloc(T,A,N) (VEC_OP(T,A,alloc)(N MEM_STAT_INFO)) + +/* Free a vector. + void VEC_T_A_free(VEC(T,A) *&); + + Free a vector and set it to NULL. */ + +#define VEC_free(T,A,V) (VEC_OP(T,A,free)(&V)) + +/* Use these to determine the required size and initialization of a + vector embedded within another structure (as the final member). + + size_t VEC_T_embedded_size(int reserve); + void VEC_T_embedded_init(VEC(T) *v, int reserve); + + These allow the caller to perform the memory allocation. */ + +#define VEC_embedded_size(T,N) (VEC_OP(T,base,embedded_size)(N)) +#define VEC_embedded_init(T,O,N) (VEC_OP(T,base,embedded_init)(VEC_BASE(O),N)) + +/* Copy a vector. + VEC(T,A) *VEC_T_A_copy(VEC(T) *); + + Copy the live elements of a vector into a new vector. The new and + old vectors need not be allocated by the same mechanism. */ + +#define VEC_copy(T,A,V) (VEC_OP(T,A,copy)(VEC_BASE(V) MEM_STAT_INFO)) + +/* Determine if a vector has additional capacity. + + int VEC_T_space (VEC(T) *v,int reserve) + + If V has space for RESERVE additional entries, return nonzero. You + usually only need to use this if you are doing your own vector + reallocation, for instance on an embedded vector. This returns + nonzero in exactly the same circumstances that VEC_T_reserve + will. */ + +#define VEC_space(T,V,R) \ + (VEC_OP(T,base,space)(VEC_BASE(V),R VEC_CHECK_INFO)) + +/* Reserve space. + int VEC_T_A_reserve(VEC(T,A) *&v, int reserve); + + Ensure that V has at least RESERVE slots available. This will + create additional headroom. Note this can cause V to be + reallocated. Returns nonzero iff reallocation actually + occurred. */ + +#define VEC_reserve(T,A,V,R) \ + (VEC_OP(T,A,reserve)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Reserve space exactly. + int VEC_T_A_reserve_exact(VEC(T,A) *&v, int reserve); + + Ensure that V has at least RESERVE slots available. This will not + create additional headroom. Note this can cause V to be + reallocated. Returns nonzero iff reallocation actually + occurred. */ + +#define VEC_reserve_exact(T,A,V,R) \ + (VEC_OP(T,A,reserve_exact)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Copy elements with no reallocation + void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Integer + void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Pointer + void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Object + + Copy the elements in SRC to the end of DST as if by memcpy. DST and + SRC need not be allocated with the same mechanism, although they most + often will be. DST is assumed to have sufficient headroom + available. */ + +#define VEC_splice(T,DST,SRC) \ + (VEC_OP(T,base,splice)(VEC_BASE(DST), VEC_BASE(SRC) VEC_CHECK_INFO)) + +/* Copy elements with reallocation + void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Integer + void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Pointer + void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Object + + Copy the elements in SRC to the end of DST as if by memcpy. DST and + SRC need not be allocated with the same mechanism, although they most + often will be. DST need not have sufficient headroom and will be + reallocated if needed. */ + +#define VEC_safe_splice(T,A,DST,SRC) \ + (VEC_OP(T,A,safe_splice)(&(DST), VEC_BASE(SRC) VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Push object with no reallocation + T *VEC_T_quick_push (VEC(T) *v, T obj); // Integer + T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer + T *VEC_T_quick_push (VEC(T) *v, T *obj); // Object + + Push a new element onto the end, returns a pointer to the slot + filled in. For object vectors, the new value can be NULL, in which + case NO initialization is performed. There must + be sufficient space in the vector. */ + +#define VEC_quick_push(T,V,O) \ + (VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO)) + +/* Push object with reallocation + T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Integer + T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Pointer + T *VEC_T_A_safe_push (VEC(T,A) *&v, T *obj); // Object + + Push a new element onto the end, returns a pointer to the slot + filled in. For object vectors, the new value can be NULL, in which + case NO initialization is performed. Reallocates V, if needed. */ + +#define VEC_safe_push(T,A,V,O) \ + (VEC_OP(T,A,safe_push)(&(V),O VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Pop element off end + T VEC_T_pop (VEC(T) *v); // Integer + T VEC_T_pop (VEC(T) *v); // Pointer + void VEC_T_pop (VEC(T) *v); // Object + + Pop the last element off the end. Returns the element popped, for + pointer vectors. */ + +#define VEC_pop(T,V) (VEC_OP(T,base,pop)(VEC_BASE(V) VEC_CHECK_INFO)) + +/* Truncate to specific length + void VEC_T_truncate (VEC(T) *v, unsigned len); + + Set the length as specified. The new length must be less than or + equal to the current length. This is an O(1) operation. */ + +#define VEC_truncate(T,V,I) \ + (VEC_OP(T,base,truncate)(VEC_BASE(V),I VEC_CHECK_INFO)) + +/* Grow to a specific length. + void VEC_T_A_safe_grow (VEC(T,A) *&v, int len); + + Grow the vector to a specific length. The LEN must be as + long or longer than the current length. The new elements are + uninitialized. */ + +#define VEC_safe_grow(T,A,V,I) \ + (VEC_OP(T,A,safe_grow)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Grow to a specific length. + void VEC_T_A_safe_grow_cleared (VEC(T,A) *&v, int len); + + Grow the vector to a specific length. The LEN must be as + long or longer than the current length. The new elements are + initialized to zero. */ + +#define VEC_safe_grow_cleared(T,A,V,I) \ + (VEC_OP(T,A,safe_grow_cleared)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Replace element + T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Integer + T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Pointer + T *VEC_T_replace (VEC(T) *v, unsigned ix, T *val); // Object + + Replace the IXth element of V with a new value, VAL. For pointer + vectors returns the original value. For object vectors returns a + pointer to the new value. For object vectors the new value can be + NULL, in which case no overwriting of the slot is actually + performed. */ + +#define VEC_replace(T,V,I,O) \ + (VEC_OP(T,base,replace)(VEC_BASE(V),I,O VEC_CHECK_INFO)) + +/* Insert object with no reallocation + T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer + T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer + T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T *val); // Object + + Insert an element, VAL, at the IXth position of V. Return a pointer + to the slot created. For vectors of object, the new value can be + NULL, in which case no initialization of the inserted slot takes + place. There must be sufficient space. */ + +#define VEC_quick_insert(T,V,I,O) \ + (VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO)) + +/* Insert object with reallocation + T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Integer + T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Pointer + T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T *val); // Object + + Insert an element, VAL, at the IXth position of V. Return a pointer + to the slot created. For vectors of object, the new value can be + NULL, in which case no initialization of the inserted slot takes + place. Reallocate V, if necessary. */ + +#define VEC_safe_insert(T,A,V,I,O) \ + (VEC_OP(T,A,safe_insert)(&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO)) + +/* Remove element retaining order + T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer + T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer + void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Object + + Remove an element from the IXth position of V. Ordering of + remaining elements is preserved. For pointer vectors returns the + removed object. This is an O(N) operation due to a memmove. */ + +#define VEC_ordered_remove(T,V,I) \ + (VEC_OP(T,base,ordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO)) + +/* Remove element destroying order + T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer + T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer + void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Object + + Remove an element from the IXth position of V. Ordering of + remaining elements is destroyed. For pointer vectors returns the + removed object. This is an O(1) operation. */ + +#define VEC_unordered_remove(T,V,I) \ + (VEC_OP(T,base,unordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO)) + +/* Remove a block of elements + void VEC_T_block_remove (VEC(T) *v, unsigned ix, unsigned len); + + Remove LEN elements starting at the IXth. Ordering is retained. + This is an O(N) operation due to memmove. */ + +#define VEC_block_remove(T,V,I,L) \ + (VEC_OP(T,base,block_remove)(VEC_BASE(V),I,L VEC_CHECK_INFO)) + +/* Get the address of the array of elements + T *VEC_T_address (VEC(T) v) + + If you need to directly manipulate the array (for instance, you + want to feed it to qsort), use this accessor. */ + +#define VEC_address(T,V) (VEC_OP(T,base,address)(VEC_BASE(V))) + +/* Conveniently sort the contents of the vector with qsort. + void VEC_qsort (VEC(T) *v, int (*cmp_func)(const void *, const void *)) */ + +#define VEC_qsort(T,V,CMP) qsort(VEC_address (T,V), VEC_length(T,V), \ + sizeof (T), CMP) + +/* Find the first index in the vector not less than the object. + unsigned VEC_T_lower_bound (VEC(T) *v, const T val, + bool (*lessthan) (const T, const T)); // Integer + unsigned VEC_T_lower_bound (VEC(T) *v, const T val, + bool (*lessthan) (const T, const T)); // Pointer + unsigned VEC_T_lower_bound (VEC(T) *v, const T *val, + bool (*lessthan) (const T*, const T*)); // Object + + Find the first position in which VAL could be inserted without + changing the ordering of V. LESSTHAN is a function that returns + true if the first argument is strictly less than the second. */ + +#define VEC_lower_bound(T,V,O,LT) \ + (VEC_OP(T,base,lower_bound)(VEC_BASE(V),O,LT VEC_CHECK_INFO)) + +/* Reallocate an array of elements with prefix. */ +extern void *vec_gc_p_reserve (void *, int MEM_STAT_DECL); +extern void *vec_gc_p_reserve_exact (void *, int MEM_STAT_DECL); +extern void *vec_gc_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); +extern void *vec_gc_o_reserve_exact (void *, int, size_t, size_t + MEM_STAT_DECL); +extern void ggc_free (void *); +#define vec_gc_free(V) ggc_free (V) +extern void *vec_heap_p_reserve (void *, int MEM_STAT_DECL); +extern void *vec_heap_p_reserve_exact (void *, int MEM_STAT_DECL); +extern void *vec_heap_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); +extern void *vec_heap_o_reserve_exact (void *, int, size_t, size_t + MEM_STAT_DECL); +extern void dump_vec_loc_statistics (void); +#ifdef GATHER_STATISTICS +void vec_heap_free (void *); +#else +/* Avoid problems with frontends that #define free(x). */ +#define vec_heap_free(V) (free) (V) +#endif + +#if ENABLE_CHECKING +#define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__ +#define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_ +#define VEC_CHECK_PASS ,file_,line_,function_ + +#define VEC_ASSERT(EXPR,OP,T,A) \ + (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0)) + +extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL) + ATTRIBUTE_NORETURN; +#define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS) +#else +#define VEC_CHECK_INFO +#define VEC_CHECK_DECL +#define VEC_CHECK_PASS +#define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR) +#endif + +/* Note: gengtype has hardwired knowledge of the expansions of the + VEC, DEF_VEC_*, and DEF_VEC_ALLOC_* macros. If you change the + expansions of these macros you may need to change gengtype too. */ + +#define VEC(T,A) VEC_##T##_##A +#define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP + +/* Base of vector type, not user visible. */ +#define VEC_T(T,B) \ +typedef struct VEC(T,B) \ +{ \ + unsigned num; \ + unsigned alloc; \ + T vec[1]; \ +} VEC(T,B) + +#define VEC_T_GTY(T,B) \ +typedef struct GTY(()) VEC(T,B) \ +{ \ + unsigned num; \ + unsigned alloc; \ + T GTY ((length ("%h.num"))) vec[1]; \ +} VEC(T,B) + +/* Derived vector type, user visible. */ +#define VEC_TA_GTY(T,B,A,GTY) \ +typedef struct GTY VEC(T,A) \ +{ \ + VEC(T,B) base; \ +} VEC(T,A) + +#define VEC_TA(T,B,A) \ +typedef struct VEC(T,A) \ +{ \ + VEC(T,B) base; \ +} VEC(T,A) + +/* Convert to base type. */ +#define VEC_BASE(P) ((P) ? &(P)->base : 0) + +/* Vector of integer-like object. */ +#define DEF_VEC_I(T) \ +static inline void VEC_OP (T,must_be,integral_type) (void) \ +{ \ + (void)~(T)0; \ +} \ + \ +VEC_T(T,base); \ +VEC_TA(T,base,none); \ +DEF_VEC_FUNC_P(T) \ +struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_I(T,A) \ +VEC_TA(T,base,A); \ +DEF_VEC_ALLOC_FUNC_I(T,A) \ +DEF_VEC_NONALLOC_FUNCS_I(T,A) \ +struct vec_swallow_trailing_semi + +/* Vector of pointer to object. */ +#define DEF_VEC_P(T) \ +static inline void VEC_OP (T,must_be,pointer_type) (void) \ +{ \ + (void)((T)1 == (void *)1); \ +} \ + \ +VEC_T_GTY(T,base); \ +VEC_TA(T,base,none); \ +DEF_VEC_FUNC_P(T) \ +struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_P(T,A) \ +VEC_TA(T,base,A); \ +DEF_VEC_ALLOC_FUNC_P(T,A) \ +DEF_VEC_NONALLOC_FUNCS_P(T,A) \ +struct vec_swallow_trailing_semi + +#define DEF_VEC_FUNC_P(T) \ +static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ +{ \ + return vec_ ? vec_->num : 0; \ +} \ + \ +static inline T VEC_OP (T,base,last) \ + (const VEC(T,base) *vec_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_ && vec_->num, "last", T, base); \ + \ + return vec_->vec[vec_->num - 1]; \ +} \ + \ +static inline T VEC_OP (T,base,index) \ + (const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \ + \ + return vec_->vec[ix_]; \ +} \ + \ +static inline int VEC_OP (T,base,iterate) \ + (const VEC(T,base) *vec_, unsigned ix_, T *ptr) \ +{ \ + if (vec_ && ix_ < vec_->num) \ + { \ + *ptr = vec_->vec[ix_]; \ + return 1; \ + } \ + else \ + { \ + *ptr = (T) 0; \ + return 0; \ + } \ +} \ + \ +static inline size_t VEC_OP (T,base,embedded_size) \ + (int alloc_) \ +{ \ + return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \ +} \ + \ +static inline void VEC_OP (T,base,embedded_init) \ + (VEC(T,base) *vec_, int alloc_) \ +{ \ + vec_->num = 0; \ + vec_->alloc = alloc_; \ +} \ + \ +static inline int VEC_OP (T,base,space) \ + (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (alloc_ >= 0, "space", T, base); \ + return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \ +} \ + \ +static inline void VEC_OP(T,base,splice) \ + (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \ +{ \ + if (src_) \ + { \ + unsigned len_ = src_->num; \ + VEC_ASSERT (dst_->num + len_ <= dst_->alloc, "splice", T, base); \ + \ + memcpy (&dst_->vec[dst_->num], &src_->vec[0], len_ * sizeof (T)); \ + dst_->num += len_; \ + } \ +} \ + \ +static inline T *VEC_OP (T,base,quick_push) \ + (VEC(T,base) *vec_, T obj_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \ + slot_ = &vec_->vec[vec_->num++]; \ + *slot_ = obj_; \ + \ + return slot_; \ +} \ + \ +static inline T VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ +{ \ + T obj_; \ + \ + VEC_ASSERT (vec_->num, "pop", T, base); \ + obj_ = vec_->vec[--vec_->num]; \ + \ + return obj_; \ +} \ + \ +static inline void VEC_OP (T,base,truncate) \ + (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \ + if (vec_) \ + vec_->num = size_; \ +} \ + \ +static inline T VEC_OP (T,base,replace) \ + (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \ +{ \ + T old_obj_; \ + \ + VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \ + old_obj_ = vec_->vec[ix_]; \ + vec_->vec[ix_] = obj_; \ + \ + return old_obj_; \ +} \ + \ +static inline T *VEC_OP (T,base,quick_insert) \ + (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \ + VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \ + slot_ = &vec_->vec[ix_]; \ + memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \ + *slot_ = obj_; \ + \ + return slot_; \ +} \ + \ +static inline T VEC_OP (T,base,ordered_remove) \ + (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + T obj_; \ + \ + VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \ + slot_ = &vec_->vec[ix_]; \ + obj_ = *slot_; \ + memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \ + \ + return obj_; \ +} \ + \ +static inline T VEC_OP (T,base,unordered_remove) \ + (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + T obj_; \ + \ + VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \ + slot_ = &vec_->vec[ix_]; \ + obj_ = *slot_; \ + *slot_ = vec_->vec[--vec_->num]; \ + \ + return obj_; \ +} \ + \ +static inline void VEC_OP (T,base,block_remove) \ + (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \ + slot_ = &vec_->vec[ix_]; \ + vec_->num -= len_; \ + memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \ +} \ + \ +static inline T *VEC_OP (T,base,address) \ + (VEC(T,base) *vec_) \ +{ \ + return vec_ ? vec_->vec : 0; \ +} \ + \ +static inline unsigned VEC_OP (T,base,lower_bound) \ + (VEC(T,base) *vec_, const T obj_, \ + bool (*lessthan_)(const T, const T) VEC_CHECK_DECL) \ +{ \ + unsigned int len_ = VEC_OP (T,base, length) (vec_); \ + unsigned int half_, middle_; \ + unsigned int first_ = 0; \ + while (len_ > 0) \ + { \ + T middle_elem_; \ + half_ = len_ >> 1; \ + middle_ = first_; \ + middle_ += half_; \ + middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \ + if (lessthan_ (middle_elem_, obj_)) \ + { \ + first_ = middle_; \ + ++first_; \ + len_ = len_ - half_ - 1; \ + } \ + else \ + len_ = half_; \ + } \ + return first_; \ +} + +#define DEF_VEC_ALLOC_FUNC_P(T,A) \ +static inline VEC(T,A) *VEC_OP (T,A,alloc) \ + (int alloc_ MEM_STAT_DECL) \ +{ \ + return (VEC(T,A) *) vec_##A##_p_reserve_exact (NULL, alloc_ \ + PASS_MEM_STAT); \ +} + + +#define DEF_VEC_NONALLOC_FUNCS_P(T,A) \ +static inline void VEC_OP (T,A,free) \ + (VEC(T,A) **vec_) \ +{ \ + if (*vec_) \ + vec_##A##_free (*vec_); \ + *vec_ = NULL; \ +} \ + \ +static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ +{ \ + size_t len_ = vec_ ? vec_->num : 0; \ + VEC (T,A) *new_vec_ = NULL; \ + \ + if (len_) \ + { \ + new_vec_ = (VEC (T,A) *)(vec_##A##_p_reserve_exact \ + (NULL, len_ PASS_MEM_STAT)); \ + \ + new_vec_->base.num = len_; \ + memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ + } \ + return new_vec_; \ +} \ + \ +static inline int VEC_OP (T,A,reserve) \ + (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ + VEC_CHECK_PASS); \ + \ + if (extend) \ + *vec_ = (VEC(T,A) *) vec_##A##_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \ + \ + return extend; \ +} \ + \ +static inline int VEC_OP (T,A,reserve_exact) \ + (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ + VEC_CHECK_PASS); \ + \ + if (extend) \ + *vec_ = (VEC(T,A) *) vec_##A##_p_reserve_exact (*vec_, alloc_ \ + PASS_MEM_STAT); \ + \ + return extend; \ +} \ + \ +static inline void VEC_OP (T,A,safe_grow) \ + (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_ASSERT (size_ >= 0 \ + && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ + "grow", T, A); \ + VEC_OP (T,A,reserve_exact) (vec_, \ + size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \ + VEC_CHECK_PASS PASS_MEM_STAT); \ + VEC_BASE (*vec_)->num = size_; \ +} \ + \ +static inline void VEC_OP (T,A,safe_grow_cleared) \ + (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ + VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ + memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ + sizeof (T) * (size_ - oldsize)); \ +} \ + \ +static inline void VEC_OP(T,A,safe_splice) \ + (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + if (src_) \ + { \ + VEC_OP (T,A,reserve_exact) (dst_, src_->num \ + VEC_CHECK_PASS MEM_STAT_INFO); \ + \ + VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ + VEC_CHECK_PASS); \ + } \ +} \ + \ +static inline T *VEC_OP (T,A,safe_push) \ + (VEC(T,A) **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ + \ + return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ +} \ + \ +static inline T *VEC_OP (T,A,safe_insert) \ + (VEC(T,A) **vec_, unsigned ix_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ + \ + return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ + VEC_CHECK_PASS); \ +} + +/* Vector of object. */ +#define DEF_VEC_O(T) \ +VEC_T_GTY(T,base); \ +VEC_TA(T,base,none); \ +DEF_VEC_FUNC_O(T) \ +struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_O(T,A) \ +VEC_TA(T,base,A); \ +DEF_VEC_ALLOC_FUNC_O(T,A) \ +DEF_VEC_NONALLOC_FUNCS_O(T,A) \ +struct vec_swallow_trailing_semi + +#define DEF_VEC_FUNC_O(T) \ +static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ +{ \ + return vec_ ? vec_->num : 0; \ +} \ + \ +static inline T *VEC_OP (T,base,last) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_ && vec_->num, "last", T, base); \ + \ + return &vec_->vec[vec_->num - 1]; \ +} \ + \ +static inline T *VEC_OP (T,base,index) \ + (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \ + \ + return &vec_->vec[ix_]; \ +} \ + \ +static inline int VEC_OP (T,base,iterate) \ + (VEC(T,base) *vec_, unsigned ix_, T **ptr) \ +{ \ + if (vec_ && ix_ < vec_->num) \ + { \ + *ptr = &vec_->vec[ix_]; \ + return 1; \ + } \ + else \ + { \ + *ptr = 0; \ + return 0; \ + } \ +} \ + \ +static inline size_t VEC_OP (T,base,embedded_size) \ + (int alloc_) \ +{ \ + return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \ +} \ + \ +static inline void VEC_OP (T,base,embedded_init) \ + (VEC(T,base) *vec_, int alloc_) \ +{ \ + vec_->num = 0; \ + vec_->alloc = alloc_; \ +} \ + \ +static inline int VEC_OP (T,base,space) \ + (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (alloc_ >= 0, "space", T, base); \ + return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \ +} \ + \ +static inline void VEC_OP(T,base,splice) \ + (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \ +{ \ + if (src_) \ + { \ + unsigned len_ = src_->num; \ + VEC_ASSERT (dst_->num + len_ <= dst_->alloc, "splice", T, base); \ + \ + memcpy (&dst_->vec[dst_->num], &src_->vec[0], len_ * sizeof (T)); \ + dst_->num += len_; \ + } \ +} \ + \ +static inline T *VEC_OP (T,base,quick_push) \ + (VEC(T,base) *vec_, const T *obj_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \ + slot_ = &vec_->vec[vec_->num++]; \ + if (obj_) \ + *slot_ = *obj_; \ + \ + return slot_; \ +} \ + \ +static inline void VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_->num, "pop", T, base); \ + --vec_->num; \ +} \ + \ +static inline void VEC_OP (T,base,truncate) \ + (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \ + if (vec_) \ + vec_->num = size_; \ +} \ + \ +static inline T *VEC_OP (T,base,replace) \ + (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \ + slot_ = &vec_->vec[ix_]; \ + if (obj_) \ + *slot_ = *obj_; \ + \ + return slot_; \ +} \ + \ +static inline T *VEC_OP (T,base,quick_insert) \ + (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \ + VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \ + slot_ = &vec_->vec[ix_]; \ + memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \ + if (obj_) \ + *slot_ = *obj_; \ + \ + return slot_; \ +} \ + \ +static inline void VEC_OP (T,base,ordered_remove) \ + (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \ + slot_ = &vec_->vec[ix_]; \ + memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \ +} \ + \ +static inline void VEC_OP (T,base,unordered_remove) \ + (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ +{ \ + VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \ + vec_->vec[ix_] = vec_->vec[--vec_->num]; \ +} \ + \ +static inline void VEC_OP (T,base,block_remove) \ + (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \ +{ \ + T *slot_; \ + \ + VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \ + slot_ = &vec_->vec[ix_]; \ + vec_->num -= len_; \ + memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \ +} \ + \ +static inline T *VEC_OP (T,base,address) \ + (VEC(T,base) *vec_) \ +{ \ + return vec_ ? vec_->vec : 0; \ +} \ + \ +static inline unsigned VEC_OP (T,base,lower_bound) \ + (VEC(T,base) *vec_, const T *obj_, \ + bool (*lessthan_)(const T *, const T *) VEC_CHECK_DECL) \ +{ \ + unsigned int len_ = VEC_OP (T, base, length) (vec_); \ + unsigned int half_, middle_; \ + unsigned int first_ = 0; \ + while (len_ > 0) \ + { \ + T *middle_elem_; \ + half_ = len_ >> 1; \ + middle_ = first_; \ + middle_ += half_; \ + middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \ + if (lessthan_ (middle_elem_, obj_)) \ + { \ + first_ = middle_; \ + ++first_; \ + len_ = len_ - half_ - 1; \ + } \ + else \ + len_ = half_; \ + } \ + return first_; \ +} + +#define DEF_VEC_ALLOC_FUNC_O(T,A) \ +static inline VEC(T,A) *VEC_OP (T,A,alloc) \ + (int alloc_ MEM_STAT_DECL) \ +{ \ + return (VEC(T,A) *) vec_##A##_o_reserve_exact (NULL, alloc_, \ + offsetof (VEC(T,A),base.vec), \ + sizeof (T) \ + PASS_MEM_STAT); \ +} + +#define DEF_VEC_NONALLOC_FUNCS_O(T,A) \ +static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ +{ \ + size_t len_ = vec_ ? vec_->num : 0; \ + VEC (T,A) *new_vec_ = NULL; \ + \ + if (len_) \ + { \ + new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \ + (NULL, len_, \ + offsetof (VEC(T,A),base.vec), sizeof (T) \ + PASS_MEM_STAT)); \ + \ + new_vec_->base.num = len_; \ + memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ + } \ + return new_vec_; \ +} \ + \ +static inline void VEC_OP (T,A,free) \ + (VEC(T,A) **vec_) \ +{ \ + if (*vec_) \ + vec_##A##_free (*vec_); \ + *vec_ = NULL; \ +} \ + \ +static inline int VEC_OP (T,A,reserve) \ + (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ + VEC_CHECK_PASS); \ + \ + if (extend) \ + *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \ + offsetof (VEC(T,A),base.vec),\ + sizeof (T) \ + PASS_MEM_STAT); \ + \ + return extend; \ +} \ + \ +static inline int VEC_OP (T,A,reserve_exact) \ + (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ + VEC_CHECK_PASS); \ + \ + if (extend) \ + *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \ + (*vec_, alloc_, \ + offsetof (VEC(T,A),base.vec), \ + sizeof (T) PASS_MEM_STAT); \ + \ + return extend; \ +} \ + \ +static inline void VEC_OP (T,A,safe_grow) \ + (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_ASSERT (size_ >= 0 \ + && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ + "grow", T, A); \ + VEC_OP (T,A,reserve_exact) (vec_, \ + size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \ + VEC_CHECK_PASS PASS_MEM_STAT); \ + VEC_BASE (*vec_)->num = size_; \ +} \ + \ +static inline void VEC_OP (T,A,safe_grow_cleared) \ + (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ + VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ + memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ + sizeof (T) * (size_ - oldsize)); \ +} \ + \ +static inline void VEC_OP(T,A,safe_splice) \ + (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + if (src_) \ + { \ + VEC_OP (T,A,reserve_exact) (dst_, src_->num \ + VEC_CHECK_PASS MEM_STAT_INFO); \ + \ + VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ + VEC_CHECK_PASS); \ + } \ +} \ + \ +static inline T *VEC_OP (T,A,safe_push) \ + (VEC(T,A) **vec_, const T *obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ + \ + return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ +} \ + \ +static inline T *VEC_OP (T,A,safe_insert) \ + (VEC(T,A) **vec_, unsigned ix_, const T *obj_ \ + VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ + \ + return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ + VEC_CHECK_PASS); \ +} + +#define DEF_VEC_ALLOC_FUNC_I(T,A) \ +static inline VEC(T,A) *VEC_OP (T,A,alloc) \ + (int alloc_ MEM_STAT_DECL) \ +{ \ + return (VEC(T,A) *) vec_##A##_o_reserve_exact \ + (NULL, alloc_, offsetof (VEC(T,A),base.vec), \ + sizeof (T) PASS_MEM_STAT); \ +} + +#define DEF_VEC_NONALLOC_FUNCS_I(T,A) \ +static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ +{ \ + size_t len_ = vec_ ? vec_->num : 0; \ + VEC (T,A) *new_vec_ = NULL; \ + \ + if (len_) \ + { \ + new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \ + (NULL, len_, \ + offsetof (VEC(T,A),base.vec), sizeof (T) \ + PASS_MEM_STAT)); \ + \ + new_vec_->base.num = len_; \ + memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ + } \ + return new_vec_; \ +} \ + \ +static inline void VEC_OP (T,A,free) \ + (VEC(T,A) **vec_) \ +{ \ + if (*vec_) \ + vec_##A##_free (*vec_); \ + *vec_ = NULL; \ +} \ + \ +static inline int VEC_OP (T,A,reserve) \ + (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ + VEC_CHECK_PASS); \ + \ + if (extend) \ + *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \ + offsetof (VEC(T,A),base.vec),\ + sizeof (T) \ + PASS_MEM_STAT); \ + \ + return extend; \ +} \ + \ +static inline int VEC_OP (T,A,reserve_exact) \ + (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ + VEC_CHECK_PASS); \ + \ + if (extend) \ + *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \ + (*vec_, alloc_, offsetof (VEC(T,A),base.vec), \ + sizeof (T) PASS_MEM_STAT); \ + \ + return extend; \ +} \ + \ +static inline void VEC_OP (T,A,safe_grow) \ + (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_ASSERT (size_ >= 0 \ + && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ + "grow", T, A); \ + VEC_OP (T,A,reserve_exact) (vec_, \ + size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \ + VEC_CHECK_PASS PASS_MEM_STAT); \ + VEC_BASE (*vec_)->num = size_; \ +} \ + \ +static inline void VEC_OP (T,A,safe_grow_cleared) \ + (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ + VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ + memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ + sizeof (T) * (size_ - oldsize)); \ +} \ + \ +static inline void VEC_OP(T,A,safe_splice) \ + (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + if (src_) \ + { \ + VEC_OP (T,A,reserve_exact) (dst_, src_->num \ + VEC_CHECK_PASS MEM_STAT_INFO); \ + \ + VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ + VEC_CHECK_PASS); \ + } \ +} \ + \ +static inline T *VEC_OP (T,A,safe_push) \ + (VEC(T,A) **vec_, const T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ + \ + return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ +} \ + \ +static inline T *VEC_OP (T,A,safe_insert) \ + (VEC(T,A) **vec_, unsigned ix_, const T obj_ \ + VEC_CHECK_DECL MEM_STAT_DECL) \ +{ \ + VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ + \ + return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ + VEC_CHECK_PASS); \ +} + +/* We support a vector which starts out with space on the stack and + switches to heap space when forced to reallocate. This works a + little differently. Instead of DEF_VEC_ALLOC_P(TYPE, heap|gc), use + DEF_VEC_ALLOC_P_STACK(TYPE). This uses alloca to get the initial + space; because alloca can not be usefully called in an inline + function, and because a macro can not define a macro, you must then + write a #define for each type: + + #define VEC_{TYPE}_stack_alloc(alloc) \ + VEC_stack_alloc({TYPE}, alloc) + + This is really a hack and perhaps can be made better. Note that + this macro will wind up evaluating the ALLOC parameter twice. + + Only the initial allocation will be made using alloca, so pass a + reasonable estimate that doesn't use too much stack space; don't + pass zero. Don't return a VEC(TYPE,stack) vector from the function + which allocated it. */ + +extern void *vec_stack_p_reserve (void *, int MEM_STAT_DECL); +extern void *vec_stack_p_reserve_exact (void *, int MEM_STAT_DECL); +extern void *vec_stack_p_reserve_exact_1 (int, void *); +extern void *vec_stack_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); +extern void *vec_stack_o_reserve_exact (void *, int, size_t, size_t + MEM_STAT_DECL); +extern void vec_stack_free (void *); + +#ifdef GATHER_STATISTICS +#define VEC_stack_alloc(T,alloc,name,line,function) \ + (VEC_OP (T,stack,alloc1) \ + (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc)))) +#else +#define VEC_stack_alloc(T,alloc) \ + (VEC_OP (T,stack,alloc1) \ + (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc)))) +#endif + +#define DEF_VEC_ALLOC_P_STACK(T) \ +VEC_TA(T,base,stack); \ +DEF_VEC_ALLOC_FUNC_P_STACK(T) \ +DEF_VEC_NONALLOC_FUNCS_P(T,stack) \ +struct vec_swallow_trailing_semi + +#define DEF_VEC_ALLOC_FUNC_P_STACK(T) \ +static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ + (int alloc_, VEC(T,stack)* space) \ +{ \ + return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ +} + +#define DEF_VEC_ALLOC_O_STACK(T) \ +VEC_TA(T,base,stack); \ +DEF_VEC_ALLOC_FUNC_O_STACK(T) \ +DEF_VEC_NONALLOC_FUNCS_O(T,stack) \ +struct vec_swallow_trailing_semi + +#define DEF_VEC_ALLOC_FUNC_O_STACK(T) \ +static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ + (int alloc_, VEC(T,stack)* space) \ +{ \ + return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ +} + +#define DEF_VEC_ALLOC_I_STACK(T) \ +VEC_TA(T,base,stack); \ +DEF_VEC_ALLOC_FUNC_I_STACK(T) \ +DEF_VEC_NONALLOC_FUNCS_I(T,stack) \ +struct vec_swallow_trailing_semi + +#define DEF_VEC_ALLOC_FUNC_I_STACK(T) \ +static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ + (int alloc_, VEC(T,stack)* space) \ +{ \ + return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ +} + +#endif /* GCC_VEC_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vecir.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vecir.h new file mode 100644 index 0000000..97e7b78 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vecir.h @@ -0,0 +1,52 @@ +/* VEC types for basic types of the intermediate representations. + Copyright (C) 2010 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/>. */ + +#ifndef GCC_VECIR_H +#define GCC_VECIR_H + +#ifndef GCC_CORETYPES_H +#error "vecir.h must be included after coretypes.h" +#endif + +/* A varray of trees. */ +DEF_VEC_P(tree); +DEF_VEC_ALLOC_P(tree,gc); +DEF_VEC_ALLOC_P(tree,heap); + +/* A varray of gimple statements. */ +DEF_VEC_P(gimple); +DEF_VEC_ALLOC_P(gimple,heap); +DEF_VEC_ALLOC_P(gimple,gc); + +/* A varray of pointers to gimple statements. */ +typedef gimple *gimple_p; +DEF_VEC_P(gimple_p); +DEF_VEC_ALLOC_P(gimple_p,heap); + +/* A varray gimple statement sequences. */ +DEF_VEC_P(gimple_seq); +DEF_VEC_ALLOC_P(gimple_seq,gc); +DEF_VEC_ALLOC_P(gimple_seq,heap); + +/* A varray of RTX objects. */ +DEF_VEC_P(rtx); +DEF_VEC_ALLOC_P(rtx,heap); +DEF_VEC_ALLOC_P(rtx,gc); + +#endif /* GCC_VECIR_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vecprim.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vecprim.h new file mode 100644 index 0000000..e9ccc52 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/vecprim.h @@ -0,0 +1,37 @@ +/* VEC types for primitive types + Copyright (C) 2006, 2007, 2008 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/>. */ + +#ifndef GCC_VECPRIM_H +#define GCC_VECPRIM_H + +DEF_VEC_I(char); +DEF_VEC_ALLOC_I(char,heap); + +typedef unsigned char uchar; +DEF_VEC_I(uchar); +DEF_VEC_ALLOC_I(uchar,heap); +DEF_VEC_ALLOC_I(uchar,gc); + +DEF_VEC_I(int); +DEF_VEC_ALLOC_I(int,heap); + +DEF_VEC_I(unsigned); +DEF_VEC_ALLOC_I(unsigned,heap); + +#endif /* GCC_VECPRIM_H */ diff --git a/lib/gcc/arm-eabi/4.6.x-google/plugin/include/version.h b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/version.h new file mode 100644 index 0000000..8891903 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/plugin/include/version.h @@ -0,0 +1,6 @@ +#ifndef GCC_VERSION_H +#define GCC_VERSION_H +extern const char version_string[]; +extern const char pkgversion_string[]; +extern const char bug_report_url[]; +#endif /* ! GCC_VERSION_H */ |