CbC/CbC_gcc: gcc/tree.c comparison

comparison gcc/tree.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	58ad6c70ea60
children	326d9e06c2e3 b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* Language-independent node constructors for parse phase of GNU compiler.
 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 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
 #include "ggc.h"
 #include "hashtab.h"
 #include "output.h"
 #include "target.h"
 #include "langhooks.h"
+#include "tree-inline.h"
 #include "tree-iterator.h"
 #include "basic-block.h"
 #include "tree-flow.h"
 #include "params.h"
 #include "pointer-set.h"
 #include "fixed-value.h"
+#include "tree-pass.h"
+#include "langhooks-def.h"
+#include "diagnostic.h"
+#include "cgraph.h"
+#include "timevar.h"
+#include "except.h"
+#include "debug.h"
+#include "intl.h"
 /* Tree code classes.  */
 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
 #define END_OF_BASE_TREE_CODES tcc_exceptional,
 /* Unique id for next decl created.  */
 static GTY(()) int next_decl_uid;
 /* Unique id for next type created.  */
 static GTY(()) int next_type_uid = 1;
+/* Unique id for next debug decl created.  Use negative numbers,
+to catch erroneous uses.  */
+static GTY(()) int next_debug_decl_uid;
 /* Since we cannot rehash a type after it is in the table, we have to
 keep the hash code.  */
-struct type_hash GTY(())
+struct GTY(()) type_hash {
-{
 unsigned long hash;
 tree type;
 };
 /* Initial size of the hash table (rounded to next prime).  */
 htab_t cl_option_hash_table;
 /* General tree->tree mapping  structure for use in hash tables.  */
 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 htab_t debug_expr_for_decl;
 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 htab_t value_expr_for_decl;
 static GTY ((if_marked ("tree_priority_map_marked_p"),
 	     param_is (struct tree_priority_map)))
 htab_t init_priority_for_decl;
-static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
-htab_t restrict_base_for_decl;
 static void set_type_quals (tree, int);
 static int type_hash_eq (const void *, const void *);
 static hashval_t type_hash_hash (const void *);
 static hashval_t int_cst_hash_hash (const void *);
 "ordered",
 "default",
 "collapse",
 "untied"
 };
-/* Init tree.c.  */
+/* Return the tree node structure used by tree code CODE.  */
-void
-init_ttree (void)
+static inline enum tree_node_structure_enum
-{
+tree_node_structure_for_code (enum tree_code code)
-/* Initialize the hash table of types.  */
-type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
-				     type_hash_eq, 0);
-debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
-					 tree_map_eq, 0);
-value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
-					 tree_map_eq, 0);
-init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
-					    tree_priority_map_eq, 0);
-restrict_base_for_decl = htab_create_ggc (256, tree_map_hash,
-					    tree_map_eq, 0);
-int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
-					int_cst_hash_eq, NULL);
-int_cst_node = make_node (INTEGER_CST);
-cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
-					  cl_option_hash_eq, NULL);
-cl_optimization_node = make_node (OPTIMIZATION_NODE);
-cl_target_option_node = make_node (TARGET_OPTION_NODE);
-tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON] = 1;
-tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON] = 1;
-tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON] = 1;
-tree_contains_struct[CONST_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[VAR_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[PARM_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[RESULT_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[TYPE_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[LABEL_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[FIELD_DECL][TS_DECL_COMMON] = 1;
-tree_contains_struct[CONST_DECL][TS_DECL_WRTL] = 1;
-tree_contains_struct[VAR_DECL][TS_DECL_WRTL] = 1;
-tree_contains_struct[PARM_DECL][TS_DECL_WRTL] = 1;
-tree_contains_struct[RESULT_DECL][TS_DECL_WRTL] = 1;
-tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL] = 1;
-tree_contains_struct[LABEL_DECL][TS_DECL_WRTL] = 1;
-tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[NAME_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[SYMBOL_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[MEMORY_PARTITION_TAG][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[NAME_MEMORY_TAG][TS_MEMORY_TAG] = 1;
-tree_contains_struct[SYMBOL_MEMORY_TAG][TS_MEMORY_TAG] = 1;
-tree_contains_struct[MEMORY_PARTITION_TAG][TS_MEMORY_TAG] = 1;
-tree_contains_struct[MEMORY_PARTITION_TAG][TS_MEMORY_PARTITION_TAG] = 1;
-tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS] = 1;
-tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS] = 1;
-tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS] = 1;
-tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS] = 1;
-tree_contains_struct[VAR_DECL][TS_VAR_DECL] = 1;
-tree_contains_struct[FIELD_DECL][TS_FIELD_DECL] = 1;
-tree_contains_struct[PARM_DECL][TS_PARM_DECL] = 1;
-tree_contains_struct[LABEL_DECL][TS_LABEL_DECL] = 1;
-tree_contains_struct[RESULT_DECL][TS_RESULT_DECL] = 1;
-tree_contains_struct[CONST_DECL][TS_CONST_DECL] = 1;
-tree_contains_struct[TYPE_DECL][TS_TYPE_DECL] = 1;
-tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL] = 1;
-tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL] = 1;
-tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON] = 1;
-lang_hooks.init_ts ();
-}
-/* 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.  */
-tree
-decl_assembler_name (tree decl)
-{
-if (!DECL_ASSEMBLER_NAME_SET_P (decl))
-lang_hooks.set_decl_assembler_name (decl);
-return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
-}
-/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
-bool
-decl_assembler_name_equal (tree decl, const_tree asmname)
-{
-tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
-const char *decl_str;
-const char *asmname_str;
-bool test = false;
-if (decl_asmname == asmname)
-return true;
-decl_str = IDENTIFIER_POINTER (decl_asmname);
-asmname_str = IDENTIFIER_POINTER (asmname);
-/* If the target assembler name was set by the user, things are trickier.
-We have a leading '*' to begin with.  After that, it's arguable what
-is the correct thing to do with -fleading-underscore.  Arguably, we've
-historically been doing the wrong thing in assemble_alias by always
-printing the leading underscore.  Since we're not changing that, make
-sure user_label_prefix follows the '*' before matching.  */
-if (decl_str[0] == '*')
-{
-size_t ulp_len = strlen (user_label_prefix);
-decl_str ++;
-if (ulp_len == 0)
-	test = true;
-else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
-	decl_str += ulp_len, test=true;
-else
-	decl_str --;
-}
-if (asmname_str[0] == '*')
-{
-size_t ulp_len = strlen (user_label_prefix);
-asmname_str ++;
-if (ulp_len == 0)
-	test = true;
-else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
-	asmname_str += ulp_len, test=true;
-else
-	asmname_str --;
-}
-if (!test)
-return false;
-return strcmp (decl_str, asmname_str) == 0;
-}
-/* Hash asmnames ignoring the user specified marks.  */
-hashval_t
-decl_assembler_name_hash (const_tree asmname)
-{
-if (IDENTIFIER_POINTER (asmname)[0] == '*')
-{
-const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
-size_t ulp_len = strlen (user_label_prefix);
-if (ulp_len == 0)
-	;
-else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
-	decl_str += ulp_len;
-return htab_hash_string (decl_str);
-}
-return htab_hash_string (IDENTIFIER_POINTER (asmname));
-}
-/* Compute the number of bytes occupied by a tree with code CODE.
-This function cannot be used for nodes that have variable sizes,
-including TREE_VEC, STRING_CST, and CALL_EXPR.  */
-size_t
-tree_code_size (enum tree_code code)
 {
 switch (TREE_CODE_CLASS (code))
 {
-case tcc_declaration:  /* A decl node */
-{
-	switch (code)
-	  {
-	  case FIELD_DECL:
-	    return sizeof (struct tree_field_decl);
-	  case PARM_DECL:
-	    return sizeof (struct tree_parm_decl);
-	  case VAR_DECL:
-	    return sizeof (struct tree_var_decl);
-	  case LABEL_DECL:
-	    return sizeof (struct tree_label_decl);
-	  case RESULT_DECL:
-	    return sizeof (struct tree_result_decl);
-	  case CONST_DECL:
-	    return sizeof (struct tree_const_decl);
-	  case TYPE_DECL:
-	    return sizeof (struct tree_type_decl);
-	  case FUNCTION_DECL:
-	    return sizeof (struct tree_function_decl);
-	  case NAME_MEMORY_TAG:
-	  case SYMBOL_MEMORY_TAG:
-	    return sizeof (struct tree_memory_tag);
-	  case MEMORY_PARTITION_TAG:
-	    return sizeof (struct tree_memory_partition_tag);
-	  default:
-	    return sizeof (struct tree_decl_non_common);
-	  }
-}
-case tcc_type:  /* a type node */
-return sizeof (struct tree_type);
-case tcc_reference:   /* a reference */
-case tcc_expression:  /* an expression */
-case tcc_statement:   /* an expression with side effects */
-case tcc_comparison:  /* a comparison expression */
-case tcc_unary:       /* a unary arithmetic expression */
-case tcc_binary:      /* a binary arithmetic expression */
-return (sizeof (struct tree_exp)
-	      + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
-case tcc_constant:  /* a constant */
-switch (code)
-	{
-	case INTEGER_CST:	return sizeof (struct tree_int_cst);
-	case REAL_CST:		return sizeof (struct tree_real_cst);
-	case FIXED_CST:		return sizeof (struct tree_fixed_cst);
-	case COMPLEX_CST:	return sizeof (struct tree_complex);
-	case VECTOR_CST:	return sizeof (struct tree_vector);
-	case STRING_CST:	gcc_unreachable ();
-	default:
-	  return lang_hooks.tree_size (code);
-	}
-case tcc_exceptional:  /* something random, like an identifier.  */
-switch (code)
-	{
-	case IDENTIFIER_NODE:	return lang_hooks.identifier_size;
-	case TREE_LIST:		return sizeof (struct tree_list);
-	case ERROR_MARK:
-	case PLACEHOLDER_EXPR:	return sizeof (struct tree_common);
-	case TREE_VEC:
-	case OMP_CLAUSE:	gcc_unreachable ();
-	case SSA_NAME:		return sizeof (struct tree_ssa_name);
-	case STATEMENT_LIST:	return sizeof (struct tree_statement_list);
-	case BLOCK:		return sizeof (struct tree_block);
-	case CONSTRUCTOR:	return sizeof (struct tree_constructor);
-	case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
-	case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
-	default:
-	  return lang_hooks.tree_size (code);
-	}
-default:
-gcc_unreachable ();
-}
-}
-/* Compute the number of bytes occupied by NODE.  This routine only
-looks at TREE_CODE, except for those nodes that have variable sizes.  */
-size_t
-tree_size (const_tree node)
-{
-const enum tree_code code = TREE_CODE (node);
-switch (code)
-{
-case TREE_BINFO:
-return (offsetof (struct tree_binfo, base_binfos)
-	      + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
-case TREE_VEC:
-return (sizeof (struct tree_vec)
-	      + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
-case STRING_CST:
-return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
-case OMP_CLAUSE:
-return (sizeof (struct tree_omp_clause)
-	      + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
-	        * sizeof (tree));
-default:
-if (TREE_CODE_CLASS (code) == tcc_vl_exp)
-	return (sizeof (struct tree_exp)
-		+ (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
-else
-	return tree_code_size (code);
-}
-}
-/* Return a newly allocated node of code CODE.  For decl and type
-nodes, some other fields are initialized.  The rest of the node is
-initialized to zero.  This function cannot be used for TREE_VEC or
-OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
-Achoo!  I got a code in the node.  */
-tree
-make_node_stat (enum tree_code code MEM_STAT_DECL)
-{
-tree t;
-enum tree_code_class type = TREE_CODE_CLASS (code);
-size_t length = tree_code_size (code);
-#ifdef GATHER_STATISTICS
-tree_node_kind kind;
-switch (type)
-{
-case tcc_declaration:  /* A decl node */
-kind = d_kind;
-break;
-case tcc_type:  /* a type node */
-kind = t_kind;
-break;
-case tcc_statement:  /* an expression with side effects */
-kind = s_kind;
-break;
-case tcc_reference:  /* a reference */
-kind = r_kind;
-break;
-case tcc_expression:  /* an expression */
-case tcc_comparison:  /* a comparison expression */
-case tcc_unary:  /* a unary arithmetic expression */
-case tcc_binary:  /* a binary arithmetic expression */
-kind = e_kind;
-break;
-case tcc_constant:  /* a constant */
-kind = c_kind;
-break;
-case tcc_exceptional:  /* something random, like an identifier.  */
-switch (code)
-	{
-	case IDENTIFIER_NODE:
-	  kind = id_kind;
-	  break;
-	case TREE_VEC:
-	  kind = vec_kind;
-	  break;
-	case TREE_BINFO:
-	  kind = binfo_kind;
-	  break;
-	case SSA_NAME:
-	  kind = ssa_name_kind;
-	  break;
-	case BLOCK:
-	  kind = b_kind;
-	  break;
-	case CONSTRUCTOR:
-	  kind = constr_kind;
-	  break;
-	default:
-	  kind = x_kind;
-	  break;
-	}
-break;
-default:
-gcc_unreachable ();
-}
-tree_node_counts[(int) kind]++;
-tree_node_sizes[(int) kind] += length;
-#endif
-if (code == IDENTIFIER_NODE)
-t = (tree) ggc_alloc_zone_pass_stat (length, &tree_id_zone);
-else
-t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
-memset (t, 0, length);
-TREE_SET_CODE (t, code);
-switch (type)
-{
-case tcc_statement:
-TREE_SIDE_EFFECTS (t) = 1;
-break;
-case tcc_declaration:
-if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
-	{
-	  if (code == FUNCTION_DECL)
-	    {
-	      DECL_ALIGN (t) = FUNCTION_BOUNDARY;
-	      DECL_MODE (t) = FUNCTION_MODE;
-	    }
-	  else
-	    DECL_ALIGN (t) = 1;
-	  /* We have not yet computed the alias set for this declaration.  */
-	  DECL_POINTER_ALIAS_SET (t) = -1;
-	}
-DECL_SOURCE_LOCATION (t) = input_location;
-DECL_UID (t) = next_decl_uid++;
-break;
-case tcc_type:
-TYPE_UID (t) = next_type_uid++;
-TYPE_ALIGN (t) = BITS_PER_UNIT;
-TYPE_USER_ALIGN (t) = 0;
-TYPE_MAIN_VARIANT (t) = t;
-TYPE_CANONICAL (t) = t;
-/* Default to no attributes for type, but let target change that.  */
-TYPE_ATTRIBUTES (t) = NULL_TREE;
-targetm.set_default_type_attributes (t);
-/* We have not yet computed the alias set for this type.  */
-TYPE_ALIAS_SET (t) = -1;
-break;
-case tcc_constant:
-TREE_CONSTANT (t) = 1;
-break;
-case tcc_expression:
-switch (code)
-	{
-	case INIT_EXPR:
-	case MODIFY_EXPR:
-	case VA_ARG_EXPR:
-	case PREDECREMENT_EXPR:
-	case PREINCREMENT_EXPR:
-	case POSTDECREMENT_EXPR:
-	case POSTINCREMENT_EXPR:
-	  /* All of these have side-effects, no matter what their
-	     operands are.  */
-	  TREE_SIDE_EFFECTS (t) = 1;
-	  break;
-	default:
-	  break;
-	}
-break;
-default:
-/* Other classes need no special treatment.  */
-break;
-}
-return t;
-}
-/* Return a new node with the same contents as NODE except that its
-TREE_CHAIN is zero and it has a fresh uid.  */
-tree
-copy_node_stat (tree node MEM_STAT_DECL)
-{
-tree t;
-enum tree_code code = TREE_CODE (node);
-size_t length;
-gcc_assert (code != STATEMENT_LIST);
-length = tree_size (node);
-t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
-memcpy (t, node, length);
-TREE_CHAIN (t) = 0;
-TREE_ASM_WRITTEN (t) = 0;
-TREE_VISITED (t) = 0;
-t->base.ann = 0;
-if (TREE_CODE_CLASS (code) == tcc_declaration)
-{
-DECL_UID (t) = next_decl_uid++;
-if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
-	  && DECL_HAS_VALUE_EXPR_P (node))
-	{
-	  SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
-	  DECL_HAS_VALUE_EXPR_P (t) = 1;
-	}
-if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
-	{
-	  SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
-	  DECL_HAS_INIT_PRIORITY_P (t) = 1;
-	}
-if (TREE_CODE (node) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (node))
-	{
-	  SET_DECL_RESTRICT_BASE (t, DECL_GET_RESTRICT_BASE (node));
-	  DECL_BASED_ON_RESTRICT_P (t) = 1;
-	}
-}
-else if (TREE_CODE_CLASS (code) == tcc_type)
-{
-TYPE_UID (t) = next_type_uid++;
-/* The following is so that the debug code for
-	 the copy is different from the original type.
-	 The two statements usually duplicate each other
-	 (because they clear fields of the same union),
-	 but the optimizer should catch that.  */
-TYPE_SYMTAB_POINTER (t) = 0;
-TYPE_SYMTAB_ADDRESS (t) = 0;
-/* Do not copy the values cache.  */
-if (TYPE_CACHED_VALUES_P(t))
-	{
-	  TYPE_CACHED_VALUES_P (t) = 0;
-	  TYPE_CACHED_VALUES (t) = NULL_TREE;
-	}
-}
-return t;
-}
-/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
-For example, this can copy a list made of TREE_LIST nodes.  */
-tree
-copy_list (tree list)
-{
-tree head;
-tree prev, next;
-if (list == 0)
-return 0;
-head = prev = copy_node (list);
-next = TREE_CHAIN (list);
-while (next)
-{
-TREE_CHAIN (prev) = copy_node (next);
-prev = TREE_CHAIN (prev);
-next = TREE_CHAIN (next);
-}
-return head;
-}
-/* Create an INT_CST node with a LOW value sign extended.  */
-tree
-build_int_cst (tree type, HOST_WIDE_INT low)
-{
-/* Support legacy code.  */
-if (!type)
-type = integer_type_node;
-return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
-}
-/* Create an INT_CST node with a LOW value zero extended.  */
-tree
-build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
-{
-return build_int_cst_wide (type, low, 0);
-}
-/* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
-if it is negative.  This function is similar to build_int_cst, but
-the extra bits outside of the type precision are cleared.  Constants
-with these extra bits may confuse the fold so that it detects overflows
-even in cases when they do not occur, and in general should be avoided.
-We cannot however make this a default behavior of build_int_cst without
-more intrusive changes, since there are parts of gcc that rely on the extra
-precision of the integer constants.  */
-tree
-build_int_cst_type (tree type, HOST_WIDE_INT low)
-{
-unsigned HOST_WIDE_INT low1;
-HOST_WIDE_INT hi;
-gcc_assert (type);
-fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
-return build_int_cst_wide (type, low1, hi);
-}
-/* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
-and sign extended according to the value range of TYPE.  */
-tree
-build_int_cst_wide_type (tree type,
-			 unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
-{
-fit_double_type (low, high, &low, &high, type);
-return build_int_cst_wide (type, low, high);
-}
-/* These are the hash table functions for the hash table of INTEGER_CST
-nodes of a sizetype.  */
-/* Return the hash code code X, an INTEGER_CST.  */
-static hashval_t
-int_cst_hash_hash (const void *x)
-{
-const_tree const t = (const_tree) x;
-return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
-	  ^ htab_hash_pointer (TREE_TYPE (t)));
-}
-/* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
-is the same as that given by *Y, which is the same.  */
-static int
-int_cst_hash_eq (const void *x, const void *y)
-{
-const_tree const xt = (const_tree) x;
-const_tree const yt = (const_tree) y;
-return (TREE_TYPE (xt) == TREE_TYPE (yt)
-	  && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
-	  && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
-}
-/* Create an INT_CST node of TYPE and value HI:LOW.
-The returned node is always shared.  For small integers we use a
-per-type vector cache, for larger ones we use a single hash table.  */
-tree
-build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
-{
-tree t;
-int ix = -1;
-int limit = 0;
-gcc_assert (type);
-switch (TREE_CODE (type))
-{
-case POINTER_TYPE:
-case REFERENCE_TYPE:
-/* Cache NULL pointer.  */
-if (!hi && !low)
-	{
-	  limit = 1;
-	  ix = 0;
-	}
-break;
-case BOOLEAN_TYPE:
-/* Cache false or true.  */
-limit = 2;
-if (!hi && low < 2)
-	ix = low;
-break;
-case INTEGER_TYPE:
-case OFFSET_TYPE:
-if (TYPE_UNSIGNED (type))
-	{
-	  /* Cache 0..N */
-	  limit = INTEGER_SHARE_LIMIT;
-	  if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
-	    ix = low;
-	}
-else
-	{
-	  /* Cache -1..N */
-	  limit = INTEGER_SHARE_LIMIT + 1;
-	  if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
-	    ix = low + 1;
-	  else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
-	    ix = 0;
-	}
-break;
-case ENUMERAL_TYPE:
-break;
-default:
-gcc_unreachable ();
-}
-if (ix >= 0)
-{
-/* Look for it in the type's vector of small shared ints.  */
-if (!TYPE_CACHED_VALUES_P (type))
-	{
-	  TYPE_CACHED_VALUES_P (type) = 1;
-	  TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
-	}
-t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
-if (t)
-	{
-	  /* Make sure no one is clobbering the shared constant.  */
-	  gcc_assert (TREE_TYPE (t) == type);
-	  gcc_assert (TREE_INT_CST_LOW (t) == low);
-	  gcc_assert (TREE_INT_CST_HIGH (t) == hi);
-	}
-else
-	{
-	  /* Create a new shared int.  */
-	  t = make_node (INTEGER_CST);
-	  TREE_INT_CST_LOW (t) = low;
-	  TREE_INT_CST_HIGH (t) = hi;
-	  TREE_TYPE (t) = type;
-	  TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
-	}
-}
-else
-{
-/* Use the cache of larger shared ints.  */
-void **slot;
-TREE_INT_CST_LOW (int_cst_node) = low;
-TREE_INT_CST_HIGH (int_cst_node) = hi;
-TREE_TYPE (int_cst_node) = type;
-slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
-t = (tree) *slot;
-if (!t)
-	{
-	  /* Insert this one into the hash table.  */
-	  t = int_cst_node;
-	  *slot = t;
-	  /* Make a new node for next time round.  */
-	  int_cst_node = make_node (INTEGER_CST);
-	}
-}
-return t;
-}
-/* Builds an integer constant in TYPE such that lowest BITS bits are ones
-and the rest are zeros.  */
-tree
-build_low_bits_mask (tree type, unsigned bits)
-{
-unsigned HOST_WIDE_INT low;
-HOST_WIDE_INT high;
-unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
-gcc_assert (bits <= TYPE_PRECISION (type));
-if (bits == TYPE_PRECISION (type)
-&& !TYPE_UNSIGNED (type))
-{
-/* Sign extended all-ones mask.  */
-low = all_ones;
-high = -1;
-}
-else if (bits <= HOST_BITS_PER_WIDE_INT)
-{
-low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
-high = 0;
-}
-else
-{
-bits -= HOST_BITS_PER_WIDE_INT;
-low = all_ones;
-high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
-}
-return build_int_cst_wide (type, low, high);
-}
-/* Checks that X is integer constant that can be expressed in (unsigned)
-HOST_WIDE_INT without loss of precision.  */
-bool
-cst_and_fits_in_hwi (const_tree x)
-{
-if (TREE_CODE (x) != INTEGER_CST)
-return false;
-if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
-return false;
-return (TREE_INT_CST_HIGH (x) == 0
-	  || TREE_INT_CST_HIGH (x) == -1);
-}
-/* Return a new VECTOR_CST node whose type is TYPE and whose values
-are in a list pointed to by VALS.  */
-tree
-build_vector (tree type, tree vals)
-{
-tree v = make_node (VECTOR_CST);
-int over = 0;
-tree link;
-TREE_VECTOR_CST_ELTS (v) = vals;
-TREE_TYPE (v) = type;
-/* Iterate through elements and check for overflow.  */
-for (link = vals; link; link = TREE_CHAIN (link))
-{
-tree value = TREE_VALUE (link);
-/* Don't crash if we get an address constant.  */
-if (!CONSTANT_CLASS_P (value))
-	continue;
-over |= TREE_OVERFLOW (value);
-}
-TREE_OVERFLOW (v) = over;
-return v;
-}
-/* Return a new VECTOR_CST node whose type is TYPE and whose values
-are extracted from V, a vector of CONSTRUCTOR_ELT.  */
-tree
-build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
-{
-tree list = NULL_TREE;
-unsigned HOST_WIDE_INT idx;
-tree value;
-FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
-list = tree_cons (NULL_TREE, value, list);
-return build_vector (type, nreverse (list));
-}
-/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
-are in the VEC pointed to by VALS.  */
-tree
-build_constructor (tree type, VEC(constructor_elt,gc) *vals)
-{
-tree c = make_node (CONSTRUCTOR);
-TREE_TYPE (c) = type;
-CONSTRUCTOR_ELTS (c) = vals;
-return c;
-}
-/* Build a CONSTRUCTOR node made of a single initializer, with the specified
-INDEX and VALUE.  */
-tree
-build_constructor_single (tree type, tree index, tree value)
-{
-VEC(constructor_elt,gc) *v;
-constructor_elt *elt;
-tree t;
-v = VEC_alloc (constructor_elt, gc, 1);
-elt = VEC_quick_push (constructor_elt, v, NULL);
-elt->index = index;
-elt->value = value;
-t = build_constructor (type, v);
-TREE_CONSTANT (t) = TREE_CONSTANT (value);
-return t;
-}
-/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
-are in a list pointed to by VALS.  */
-tree
-build_constructor_from_list (tree type, tree vals)
-{
-tree t, val;
-VEC(constructor_elt,gc) *v = NULL;
-bool constant_p = true;
-if (vals)
-{
-v = VEC_alloc (constructor_elt, gc, list_length (vals));
-for (t = vals; t; t = TREE_CHAIN (t))
-	{
-	  constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
-	  val = TREE_VALUE (t);
-	  elt->index = TREE_PURPOSE (t);
-	  elt->value = val;
-	  if (!TREE_CONSTANT (val))
-	    constant_p = false;
-	}
-}
-t = build_constructor (type, v);
-TREE_CONSTANT (t) = constant_p;
-return t;
-}
-/* Return a new FIXED_CST node whose type is TYPE and value is F.  */
-tree
-build_fixed (tree type, FIXED_VALUE_TYPE f)
-{
-tree v;
-FIXED_VALUE_TYPE *fp;
-v = make_node (FIXED_CST);
-fp = GGC_NEW (FIXED_VALUE_TYPE);
-memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
-TREE_TYPE (v) = type;
-TREE_FIXED_CST_PTR (v) = fp;
-return v;
-}
-/* Return a new REAL_CST node whose type is TYPE and value is D.  */
-tree
-build_real (tree type, REAL_VALUE_TYPE d)
-{
-tree v;
-REAL_VALUE_TYPE *dp;
-int overflow = 0;
-/* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
-Consider doing it via real_convert now.  */
-v = make_node (REAL_CST);
-dp = GGC_NEW (REAL_VALUE_TYPE);
-memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
-TREE_TYPE (v) = type;
-TREE_REAL_CST_PTR (v) = dp;
-TREE_OVERFLOW (v) = overflow;
-return v;
-}
-/* Return a new REAL_CST node whose type is TYPE
-and whose value is the integer value of the INTEGER_CST node I.  */
-REAL_VALUE_TYPE
-real_value_from_int_cst (const_tree type, const_tree i)
-{
-REAL_VALUE_TYPE d;
-/* Clear all bits of the real value type so that we can later do
-bitwise comparisons to see if two values are the same.  */
-memset (&d, 0, sizeof d);
-real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
-		     TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
-		     TYPE_UNSIGNED (TREE_TYPE (i)));
-return d;
-}
-/* Given a tree representing an integer constant I, return a tree
-representing the same value as a floating-point constant of type TYPE.  */
-tree
-build_real_from_int_cst (tree type, const_tree i)
-{
-tree v;
-int overflow = TREE_OVERFLOW (i);
-v = build_real (type, real_value_from_int_cst (type, i));
-TREE_OVERFLOW (v) |= overflow;
-return v;
-}
-/* Return a newly constructed STRING_CST node whose value is
-the LEN characters at STR.
-The TREE_TYPE is not initialized.  */
-tree
-build_string (int len, const char *str)
-{
-tree s;
-size_t length;
-/* Do not waste bytes provided by padding of struct tree_string.  */
-length = len + offsetof (struct tree_string, str) + 1;
-#ifdef GATHER_STATISTICS
-tree_node_counts[(int) c_kind]++;
-tree_node_sizes[(int) c_kind] += length;
-#endif
-s = ggc_alloc_tree (length);
-memset (s, 0, sizeof (struct tree_common));
-TREE_SET_CODE (s, STRING_CST);
-TREE_CONSTANT (s) = 1;
-TREE_STRING_LENGTH (s) = len;
-memcpy (s->string.str, str, len);
-s->string.str[len] = '\0';
-return s;
-}
-/* Return a newly constructed COMPLEX_CST node whose value is
-specified by the real and imaginary parts REAL and IMAG.
-Both REAL and IMAG should be constant nodes.  TYPE, if specified,
-will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
-tree
-build_complex (tree type, tree real, tree imag)
-{
-tree t = make_node (COMPLEX_CST);
-TREE_REALPART (t) = real;
-TREE_IMAGPART (t) = imag;
-TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
-TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
-return t;
-}
-/* Return a constant of arithmetic type TYPE which is the
-multiplicative identity of the set TYPE.  */
-tree
-build_one_cst (tree type)
-{
-switch (TREE_CODE (type))
-{
-case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
-case POINTER_TYPE: case REFERENCE_TYPE:
-case OFFSET_TYPE:
-return build_int_cst (type, 1);
-case REAL_TYPE:
-return build_real (type, dconst1);
-case FIXED_POINT_TYPE:
-/* We can only generate 1 for accum types.  */
-gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
-return build_fixed (type, FCONST1(TYPE_MODE (type)));
-case VECTOR_TYPE:
-{
-	tree scalar, cst;
-	int i;
-	scalar = build_one_cst (TREE_TYPE (type));
-	/* Create 'vect_cst_ = {cst,cst,...,cst}'  */
-	cst = NULL_TREE;
-	for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
-	  cst = tree_cons (NULL_TREE, scalar, cst);
-	return build_vector (type, cst);
-}
-case COMPLEX_TYPE:
-return build_complex (type,
-			    build_one_cst (TREE_TYPE (type)),
-			    fold_convert (TREE_TYPE (type), integer_zero_node));
-default:
-gcc_unreachable ();
-}
-}
-/* Build a BINFO with LEN language slots.  */
-tree
-make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
-{
-tree t;
-size_t length = (offsetof (struct tree_binfo, base_binfos)
-		   + VEC_embedded_size (tree, base_binfos));
-#ifdef GATHER_STATISTICS
-tree_node_counts[(int) binfo_kind]++;
-tree_node_sizes[(int) binfo_kind] += length;
-#endif
-t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
-memset (t, 0, offsetof (struct tree_binfo, base_binfos));
-TREE_SET_CODE (t, TREE_BINFO);
-VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
-return t;
-}
-/* Build a newly constructed TREE_VEC node of length LEN.  */
-tree
-make_tree_vec_stat (int len MEM_STAT_DECL)
-{
-tree t;
-int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
-#ifdef GATHER_STATISTICS
-tree_node_counts[(int) vec_kind]++;
-tree_node_sizes[(int) vec_kind] += length;
-#endif
-t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
-memset (t, 0, length);
-TREE_SET_CODE (t, TREE_VEC);
-TREE_VEC_LENGTH (t) = len;
-return t;
-}
-/* Return 1 if EXPR is the integer constant zero or a complex constant
-of zero.  */
-int
-integer_zerop (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == INTEGER_CST
-	   && TREE_INT_CST_LOW (expr) == 0
-	   && TREE_INT_CST_HIGH (expr) == 0)
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && integer_zerop (TREE_REALPART (expr))
-	      && integer_zerop (TREE_IMAGPART (expr))));
-}
-/* Return 1 if EXPR is the integer constant one or the corresponding
-complex constant.  */
-int
-integer_onep (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == INTEGER_CST
-	   && TREE_INT_CST_LOW (expr) == 1
-	   && TREE_INT_CST_HIGH (expr) == 0)
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && integer_onep (TREE_REALPART (expr))
-	      && integer_zerop (TREE_IMAGPART (expr))));
-}
-/* Return 1 if EXPR is an integer containing all 1's in as much precision as
-it contains.  Likewise for the corresponding complex constant.  */
-int
-integer_all_onesp (const_tree expr)
-{
-int prec;
-int uns;
-STRIP_NOPS (expr);
-if (TREE_CODE (expr) == COMPLEX_CST
-&& integer_all_onesp (TREE_REALPART (expr))
-&& integer_zerop (TREE_IMAGPART (expr)))
-return 1;
-else if (TREE_CODE (expr) != INTEGER_CST)
-return 0;
-uns = TYPE_UNSIGNED (TREE_TYPE (expr));
-if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
-&& TREE_INT_CST_HIGH (expr) == -1)
-return 1;
-if (!uns)
-return 0;
-/* Note that using TYPE_PRECISION here is wrong.  We care about the
-actual bits, not the (arbitrary) range of the type.  */
-prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
-if (prec >= HOST_BITS_PER_WIDE_INT)
-{
-HOST_WIDE_INT high_value;
-int shift_amount;
-shift_amount = prec - HOST_BITS_PER_WIDE_INT;
-/* Can not handle precisions greater than twice the host int size.  */
-gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
-if (shift_amount == HOST_BITS_PER_WIDE_INT)
-	/* Shifting by the host word size is undefined according to the ANSI
-	   standard, so we must handle this as a special case.  */
-	high_value = -1;
-else
-	high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
-return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
-	      && TREE_INT_CST_HIGH (expr) == high_value);
-}
-else
-return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
-}
-/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
-one bit on).  */
-int
-integer_pow2p (const_tree expr)
-{
-int prec;
-HOST_WIDE_INT high, low;
-STRIP_NOPS (expr);
-if (TREE_CODE (expr) == COMPLEX_CST
-&& integer_pow2p (TREE_REALPART (expr))
-&& integer_zerop (TREE_IMAGPART (expr)))
-return 1;
-if (TREE_CODE (expr) != INTEGER_CST)
-return 0;
-prec = (POINTER_TYPE_P (TREE_TYPE (expr))
-	  ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
-high = TREE_INT_CST_HIGH (expr);
-low = TREE_INT_CST_LOW (expr);
-/* First clear all bits that are beyond the type's precision in case
-we've been sign extended.  */
-if (prec == 2 * HOST_BITS_PER_WIDE_INT)
-;
-else if (prec > HOST_BITS_PER_WIDE_INT)
-high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
-else
-{
-high = 0;
-if (prec < HOST_BITS_PER_WIDE_INT)
-	low &= ~((HOST_WIDE_INT) (-1) << prec);
-}
-if (high == 0 && low == 0)
-return 0;
-return ((high == 0 && (low & (low - 1)) == 0)
-	  || (low == 0 && (high & (high - 1)) == 0));
-}
-/* Return 1 if EXPR is an integer constant other than zero or a
-complex constant other than zero.  */
-int
-integer_nonzerop (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == INTEGER_CST
-	   && (TREE_INT_CST_LOW (expr) != 0
-	       || TREE_INT_CST_HIGH (expr) != 0))
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && (integer_nonzerop (TREE_REALPART (expr))
-		  || integer_nonzerop (TREE_IMAGPART (expr)))));
-}
-/* Return 1 if EXPR is the fixed-point constant zero.  */
-int
-fixed_zerop (const_tree expr)
-{
-return (TREE_CODE (expr) == FIXED_CST
-	  && double_int_zero_p (TREE_FIXED_CST (expr).data));
-}
-/* Return the power of two represented by a tree node known to be a
-power of two.  */
-int
-tree_log2 (const_tree expr)
-{
-int prec;
-HOST_WIDE_INT high, low;
-STRIP_NOPS (expr);
-if (TREE_CODE (expr) == COMPLEX_CST)
-return tree_log2 (TREE_REALPART (expr));
-prec = (POINTER_TYPE_P (TREE_TYPE (expr))
-	  ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
-high = TREE_INT_CST_HIGH (expr);
-low = TREE_INT_CST_LOW (expr);
-/* First clear all bits that are beyond the type's precision in case
-we've been sign extended.  */
-if (prec == 2 * HOST_BITS_PER_WIDE_INT)
-;
-else if (prec > HOST_BITS_PER_WIDE_INT)
-high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
-else
-{
-high = 0;
-if (prec < HOST_BITS_PER_WIDE_INT)
-	low &= ~((HOST_WIDE_INT) (-1) << prec);
-}
-return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
-	  : exact_log2 (low));
-}
-/* Similar, but return the largest integer Y such that 2 ** Y is less
-than or equal to EXPR.  */
-int
-tree_floor_log2 (const_tree expr)
-{
-int prec;
-HOST_WIDE_INT high, low;
-STRIP_NOPS (expr);
-if (TREE_CODE (expr) == COMPLEX_CST)
-return tree_log2 (TREE_REALPART (expr));
-prec = (POINTER_TYPE_P (TREE_TYPE (expr))
-	  ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
-high = TREE_INT_CST_HIGH (expr);
-low = TREE_INT_CST_LOW (expr);
-/* First clear all bits that are beyond the type's precision in case
-we've been sign extended.  Ignore if type's precision hasn't been set
-since what we are doing is setting it.  */
-if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
-;
-else if (prec > HOST_BITS_PER_WIDE_INT)
-high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
-else
-{
-high = 0;
-if (prec < HOST_BITS_PER_WIDE_INT)
-	low &= ~((HOST_WIDE_INT) (-1) << prec);
-}
-return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
-	  : floor_log2 (low));
-}
-/* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
-decimal float constants, so don't return 1 for them.  */
-int
-real_zerop (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == REAL_CST
-	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
-	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && real_zerop (TREE_REALPART (expr))
-	      && real_zerop (TREE_IMAGPART (expr))));
-}
-/* Return 1 if EXPR is the real constant one in real or complex form.
-Trailing zeroes matter for decimal float constants, so don't return
-1 for them.  */
-int
-real_onep (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == REAL_CST
-	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
-	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && real_onep (TREE_REALPART (expr))
-	      && real_zerop (TREE_IMAGPART (expr))));
-}
-/* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
-for decimal float constants, so don't return 1 for them.  */
-int
-real_twop (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == REAL_CST
-	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
-	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && real_twop (TREE_REALPART (expr))
-	      && real_zerop (TREE_IMAGPART (expr))));
-}
-/* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
-matter for decimal float constants, so don't return 1 for them.  */
-int
-real_minus_onep (const_tree expr)
-{
-STRIP_NOPS (expr);
-return ((TREE_CODE (expr) == REAL_CST
-	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
-	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
-	  || (TREE_CODE (expr) == COMPLEX_CST
-	      && real_minus_onep (TREE_REALPART (expr))
-	      && real_zerop (TREE_IMAGPART (expr))));
-}
-/* Nonzero if EXP is a constant or a cast of a constant.  */
-int
-really_constant_p (const_tree exp)
-{
-/* This is not quite the same as STRIP_NOPS.  It does more.  */
-while (CONVERT_EXPR_P (exp)
-	 || TREE_CODE (exp) == NON_LVALUE_EXPR)
-exp = TREE_OPERAND (exp, 0);
-return TREE_CONSTANT (exp);
-}
-/* Return first list element whose TREE_VALUE is ELEM.
-Return 0 if ELEM is not in LIST.  */
-tree
-value_member (tree elem, tree list)
-{
-while (list)
-{
-if (elem == TREE_VALUE (list))
-	return list;
-list = TREE_CHAIN (list);
-}
-return NULL_TREE;
-}
-/* Return first list element whose TREE_PURPOSE is ELEM.
-Return 0 if ELEM is not in LIST.  */
-tree
-purpose_member (const_tree elem, tree list)
-{
-while (list)
-{
-if (elem == TREE_PURPOSE (list))
-	return list;
-list = TREE_CHAIN (list);
-}
-return NULL_TREE;
-}
-/* Return nonzero if ELEM is part of the chain CHAIN.  */
-int
-chain_member (const_tree elem, const_tree chain)
-{
-while (chain)
-{
-if (elem == chain)
-	return 1;
-chain = TREE_CHAIN (chain);
-}
-return 0;
-}
-/* Return the length of a chain of nodes chained through TREE_CHAIN.
-We expect a null pointer to mark the end of the chain.
-This is the Lisp primitive `length'.  */
-int
-list_length (const_tree t)
-{
-const_tree p = t;
-#ifdef ENABLE_TREE_CHECKING
-const_tree q = t;
-#endif
-int len = 0;
-while (p)
-{
-p = TREE_CHAIN (p);
-#ifdef ENABLE_TREE_CHECKING
-if (len % 2)
-	q = TREE_CHAIN (q);
-gcc_assert (p != q);
-#endif
-len++;
-}
-return len;
-}
-/* Returns the number of FIELD_DECLs in TYPE.  */
-int
-fields_length (const_tree type)
-{
-tree t = TYPE_FIELDS (type);
-int count = 0;
-for (; t; t = TREE_CHAIN (t))
-if (TREE_CODE (t) == FIELD_DECL)
-++count;
-return count;
-}
-/* Concatenate two chains of nodes (chained through TREE_CHAIN)
-by modifying the last node in chain 1 to point to chain 2.
-This is the Lisp primitive `nconc'.  */
-tree
-chainon (tree op1, tree op2)
-{
-tree t1;
-if (!op1)
-return op2;
-if (!op2)
-return op1;
-for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
-continue;
-TREE_CHAIN (t1) = op2;
-#ifdef ENABLE_TREE_CHECKING
-{
-tree t2;
-for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
-gcc_assert (t2 != t1);
-}
-#endif
-return op1;
-}
-/* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
-tree
-tree_last (tree chain)
-{
-tree next;
-if (chain)
-while ((next = TREE_CHAIN (chain)))
-chain = next;
-return chain;
-}
-/* Reverse the order of elements in the chain T,
-and return the new head of the chain (old last element).  */
-tree
-nreverse (tree t)
-{
-tree prev = 0, decl, next;
-for (decl = t; decl; decl = next)
-{
-next = TREE_CHAIN (decl);
-TREE_CHAIN (decl) = prev;
-prev = decl;
-}
-return prev;
-}
-/* Return a newly created TREE_LIST node whose
-purpose and value fields are PARM and VALUE.  */
-tree
-build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
-{
-tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
-TREE_PURPOSE (t) = parm;
-TREE_VALUE (t) = value;
-return t;
-}
-/* Return a newly created TREE_LIST node whose
-purpose and value fields are PURPOSE and VALUE
-and whose TREE_CHAIN is CHAIN.  */
-tree
-tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
-{
-tree node;
-node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
-memset (node, 0, sizeof (struct tree_common));
-#ifdef GATHER_STATISTICS
-tree_node_counts[(int) x_kind]++;
-tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
-#endif
-TREE_SET_CODE (node, TREE_LIST);
-TREE_CHAIN (node) = chain;
-TREE_PURPOSE (node) = purpose;
-TREE_VALUE (node) = value;
-return node;
-}
-/* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
-tree
-ctor_to_list (tree ctor)
-{
-tree list = NULL_TREE;
-tree *p = &list;
-unsigned ix;
-tree purpose, val;
-FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
-{
-*p = build_tree_list (purpose, val);
-p = &TREE_CHAIN (*p);
-}
-return list;
-}
-/* Return the size nominally occupied by an object of type TYPE
-when it resides in memory.  The value is measured in units of bytes,
-and its data type is that normally used for type sizes
-(which is the first type created by make_signed_type or
-make_unsigned_type).  */
-tree
-size_in_bytes (const_tree type)
-{
-tree t;
-if (type == error_mark_node)
-return integer_zero_node;
-type = TYPE_MAIN_VARIANT (type);
-t = TYPE_SIZE_UNIT (type);
-if (t == 0)
-{
-lang_hooks.types.incomplete_type_error (NULL_TREE, type);
-return size_zero_node;
-}
-return t;
-}
-/* Return the size of TYPE (in bytes) as a wide integer
-or return -1 if the size can vary or is larger than an integer.  */
-HOST_WIDE_INT
-int_size_in_bytes (const_tree type)
-{
-tree t;
-if (type == error_mark_node)
-return 0;
-type = TYPE_MAIN_VARIANT (type);
-t = TYPE_SIZE_UNIT (type);
-if (t == 0
-|| TREE_CODE (t) != INTEGER_CST
-|| TREE_INT_CST_HIGH (t) != 0
-/* If the result would appear negative, it's too big to represent.  */
-|| (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
-return -1;
-return TREE_INT_CST_LOW (t);
-}
-/* Return the maximum size of TYPE (in bytes) as a wide integer
-or return -1 if the size can vary or is larger than an integer.  */
-HOST_WIDE_INT
-max_int_size_in_bytes (const_tree type)
-{
-HOST_WIDE_INT size = -1;
-tree size_tree;
-/* If this is an array type, check for a possible MAX_SIZE attached.  */
-if (TREE_CODE (type) == ARRAY_TYPE)
-{
-size_tree = TYPE_ARRAY_MAX_SIZE (type);
-if (size_tree && host_integerp (size_tree, 1))
-	size = tree_low_cst (size_tree, 1);
-}
-/* If we still haven't been able to get a size, see if the language
-can compute a maximum size.  */
-if (size == -1)
-{
-size_tree = lang_hooks.types.max_size (type);
-if (size_tree && host_integerp (size_tree, 1))
-	size = tree_low_cst (size_tree, 1);
-}
-return size;
-}
-/* Return the bit position of FIELD, in bits from the start of the record.
-This is a tree of type bitsizetype.  */
-tree
-bit_position (const_tree field)
-{
-return bit_from_pos (DECL_FIELD_OFFSET (field),
-		       DECL_FIELD_BIT_OFFSET (field));
-}
-/* Likewise, but return as an integer.  It must be representable in
-that way (since it could be a signed value, we don't have the
-option of returning -1 like int_size_in_byte can.  */
-HOST_WIDE_INT
-int_bit_position (const_tree field)
-{
-return tree_low_cst (bit_position (field), 0);
-}
-/* Return the byte position of FIELD, in bytes from the start of the record.
-This is a tree of type sizetype.  */
-tree
-byte_position (const_tree field)
-{
-return byte_from_pos (DECL_FIELD_OFFSET (field),
-			DECL_FIELD_BIT_OFFSET (field));
-}
-/* Likewise, but return as an integer.  It must be representable in
-that way (since it could be a signed value, we don't have the
-option of returning -1 like int_size_in_byte can.  */
-HOST_WIDE_INT
-int_byte_position (const_tree field)
-{
-return tree_low_cst (byte_position (field), 0);
-}
-/* Return the strictest alignment, in bits, that T is known to have.  */
-unsigned int
-expr_align (const_tree t)
-{
-unsigned int align0, align1;
-switch (TREE_CODE (t))
-{
-CASE_CONVERT:  case NON_LVALUE_EXPR:
-/* If we have conversions, we know that the alignment of the
-	 object must meet each of the alignments of the types.  */
-align0 = expr_align (TREE_OPERAND (t, 0));
-align1 = TYPE_ALIGN (TREE_TYPE (t));
-return MAX (align0, align1);
-case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
-case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
-case CLEANUP_POINT_EXPR:
-/* These don't change the alignment of an object.  */
-return expr_align (TREE_OPERAND (t, 0));
-case COND_EXPR:
-/* The best we can do is say that the alignment is the least aligned
-	 of the two arms.  */
-align0 = expr_align (TREE_OPERAND (t, 1));
-align1 = expr_align (TREE_OPERAND (t, 2));
-return MIN (align0, align1);
-/* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
-	 meaningfully, it's always 1.  */
-case LABEL_DECL:     case CONST_DECL:
-case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
-case FUNCTION_DECL:
-gcc_assert (DECL_ALIGN (t) != 0);
-return DECL_ALIGN (t);
-default:
-break;
-}
-/* Otherwise take the alignment from that of the type.  */
-return TYPE_ALIGN (TREE_TYPE (t));
-}
-/* Return, as a tree node, the number of elements for TYPE (which is an
-ARRAY_TYPE) minus one. This counts only elements of the top array.  */
-tree
-array_type_nelts (const_tree type)
-{
-tree index_type, min, max;
-/* If they did it with unspecified bounds, then we should have already
-given an error about it before we got here.  */
-if (! TYPE_DOMAIN (type))
-return error_mark_node;
-index_type = TYPE_DOMAIN (type);
-min = TYPE_MIN_VALUE (index_type);
-max = TYPE_MAX_VALUE (index_type);
-return (integer_zerop (min)
-	  ? max
-	  : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
-}
-/* If arg is static -- a reference to an object in static storage -- then
-return the object.  This is not the same as the C meaning of `static'.
-If arg isn't static, return NULL.  */
-tree
-staticp (tree arg)
-{
-switch (TREE_CODE (arg))
-{
-case FUNCTION_DECL:
-/* Nested functions are static, even though taking their address will
-	 involve a trampoline as we unnest the nested function and create
-	 the trampoline on the tree level.  */
-return arg;
-case VAR_DECL:
-return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
-	      && ! DECL_THREAD_LOCAL_P (arg)
-	      && ! DECL_DLLIMPORT_P (arg)
-	      ? arg : NULL);
-case CONST_DECL:
-return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
-	      ? arg : NULL);
-case CONSTRUCTOR:
-return TREE_STATIC (arg) ? arg : NULL;
-case LABEL_DECL:
-case STRING_CST:
-return arg;
-case COMPONENT_REF:
-/* If the thing being referenced is not a field, then it is
-	 something language specific.  */
-if (TREE_CODE (TREE_OPERAND (arg, 1)) != FIELD_DECL)
-	return (*lang_hooks.staticp) (arg);
-/* If we are referencing a bitfield, we can't evaluate an
-	 ADDR_EXPR at compile time and so it isn't a constant.  */
-if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
-	return NULL;
-return staticp (TREE_OPERAND (arg, 0));
-case BIT_FIELD_REF:
-return NULL;
-case MISALIGNED_INDIRECT_REF:
-case ALIGN_INDIRECT_REF:
-case INDIRECT_REF:
-return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
-case ARRAY_REF:
-case ARRAY_RANGE_REF:
-if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
-	  && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
-	return staticp (TREE_OPERAND (arg, 0));
-else
-	return false;
-default:
-if ((unsigned int) TREE_CODE (arg)
-	  >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
-	return lang_hooks.staticp (arg);
-else
-	return NULL;
-}
-}
-/* Return whether OP is a DECL whose address is function-invariant.  */
-bool
-decl_address_invariant_p (const_tree op)
-{
-/* The conditions below are slightly less strict than the one in
-staticp.  */
-switch (TREE_CODE (op))
-{
-case PARM_DECL:
-case RESULT_DECL:
-case LABEL_DECL:
-case FUNCTION_DECL:
-return true;
-case VAR_DECL:
-if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
-&& !DECL_DLLIMPORT_P (op))
-|| DECL_THREAD_LOCAL_P (op)
-|| DECL_CONTEXT (op) == current_function_decl
-|| decl_function_context (op) == current_function_decl)
-return true;
-break;
-case CONST_DECL:
-if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
-|| decl_function_context (op) == current_function_decl)
-return true;
-break;
-default:
-break;
-}
-return false;
-}
-/* Return whether OP is a DECL whose address is interprocedural-invariant.  */
-bool
-decl_address_ip_invariant_p (const_tree op)
-{
-/* The conditions below are slightly less strict than the one in
-staticp.  */
-switch (TREE_CODE (op))
-{
-case LABEL_DECL:
-case FUNCTION_DECL:
-case STRING_CST:
-return true;
-case VAR_DECL:
-if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
-&& !DECL_DLLIMPORT_P (op))
-|| DECL_THREAD_LOCAL_P (op))
-return true;
-break;
-case CONST_DECL:
-if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
-return true;
-break;
-default:
-break;
-}
-return false;
-}
-/* Return true if T is function-invariant (internal function, does
-not handle arithmetic; that's handled in skip_simple_arithmetic and
-tree_invariant_p).  */
-static bool tree_invariant_p (tree t);
-static bool
-tree_invariant_p_1 (tree t)
-{
-tree op;
-if (TREE_CONSTANT (t)
-|| (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
-return true;
-switch (TREE_CODE (t))
-{
-case SAVE_EXPR:
-return true;
-case ADDR_EXPR:
-op = TREE_OPERAND (t, 0);
-while (handled_component_p (op))
-	{
-	  switch (TREE_CODE (op))
-	    {
-	    case ARRAY_REF:
-	    case ARRAY_RANGE_REF:
-	      if (!tree_invariant_p (TREE_OPERAND (op, 1))
-		  || TREE_OPERAND (op, 2) != NULL_TREE
-		  || TREE_OPERAND (op, 3) != NULL_TREE)
-		return false;
-	      break;
-	    case COMPONENT_REF:
-	      if (TREE_OPERAND (op, 2) != NULL_TREE)
-		return false;
-	      break;
-	    default:;
-	    }
-	  op = TREE_OPERAND (op, 0);
-	}
-return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
-default:
-break;
-}
-return false;
-}
-/* Return true if T is function-invariant.  */
-static bool
-tree_invariant_p (tree t)
-{
-tree inner = skip_simple_arithmetic (t);
-return tree_invariant_p_1 (inner);
-}
-/* Wrap a SAVE_EXPR around EXPR, if appropriate.
-Do this to any expression which may be used in more than one place,
-but must be evaluated only once.
-Normally, expand_expr would reevaluate the expression each time.
-Calling save_expr produces something that is evaluated and recorded
-the first time expand_expr is called on it.  Subsequent calls to
-expand_expr just reuse the recorded value.
-The call to expand_expr that generates code that actually computes
-the value is the first call *at compile time*.  Subsequent calls
-*at compile time* generate code to use the saved value.
-This produces correct result provided that *at run time* control
-always flows through the insns made by the first expand_expr
-before reaching the other places where the save_expr was evaluated.
-You, the caller of save_expr, must make sure this is so.
-Constants, and certain read-only nodes, are returned with no
-SAVE_EXPR because that is safe.  Expressions containing placeholders
-are not touched; see tree.def for an explanation of what these
-are used for.  */
-tree
-save_expr (tree expr)
-{
-tree t = fold (expr);
-tree inner;
-/* If the tree evaluates to a constant, then we don't want to hide that
-fact (i.e. this allows further folding, and direct checks for constants).
-However, a read-only object that has side effects cannot be bypassed.
-Since it is no problem to reevaluate literals, we just return the
-literal node.  */
-inner = skip_simple_arithmetic (t);
-if (TREE_CODE (inner) == ERROR_MARK)
-return inner;
-if (tree_invariant_p_1 (inner))
-return t;
-/* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
-it means that the size or offset of some field of an object depends on
-the value within another field.
-Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
-and some variable since it would then need to be both evaluated once and
-evaluated more than once.  Front-ends must assure this case cannot
-happen by surrounding any such subexpressions in their own SAVE_EXPR
-and forcing evaluation at the proper time.  */
-if (contains_placeholder_p (inner))
-return t;
-t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
-/* This expression might be placed ahead of a jump to ensure that the
-value was computed on both sides of the jump.  So make sure it isn't
-eliminated as dead.  */
-TREE_SIDE_EFFECTS (t) = 1;
-return t;
-}
-/* Look inside EXPR and into any simple arithmetic operations.  Return
-the innermost non-arithmetic node.  */
-tree
-skip_simple_arithmetic (tree expr)
-{
-tree inner;
-/* We don't care about whether this can be used as an lvalue in this
-context.  */
-while (TREE_CODE (expr) == NON_LVALUE_EXPR)
-expr = TREE_OPERAND (expr, 0);
-/* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
-a constant, it will be more efficient to not make another SAVE_EXPR since
-it will allow better simplification and GCSE will be able to merge the
-computations if they actually occur.  */
-inner = expr;
-while (1)
-{
-if (UNARY_CLASS_P (inner))
-	inner = TREE_OPERAND (inner, 0);
-else if (BINARY_CLASS_P (inner))
-	{
-	  if (tree_invariant_p (TREE_OPERAND (inner, 1)))
-	    inner = TREE_OPERAND (inner, 0);
-	  else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
-	    inner = TREE_OPERAND (inner, 1);
-	  else
-	    break;
-	}
-else
-	break;
-}
-return inner;
-}
-/* Return which tree structure is used by T.  */
-enum tree_node_structure_enum
-tree_node_structure (const_tree t)
-{
-const enum tree_code code = TREE_CODE (t);
-switch (TREE_CODE_CLASS (code))
-{
 case tcc_declaration:
 {
 	switch (code)
 	  {
 	  case FIELD_DECL:
 	    return TS_VAR_DECL;
 	  case LABEL_DECL:
 	    return TS_LABEL_DECL;
 	  case RESULT_DECL:
 	    return TS_RESULT_DECL;
+	  case DEBUG_EXPR_DECL:
+	    return TS_DECL_WRTL;
 	  case CONST_DECL:
 	    return TS_CONST_DECL;
 	  case TYPE_DECL:
 	    return TS_TYPE_DECL;
 	  case FUNCTION_DECL:
 	    return TS_FUNCTION_DECL;
-	  case SYMBOL_MEMORY_TAG:
-	  case NAME_MEMORY_TAG:
-	  case MEMORY_PARTITION_TAG:
-	    return TS_MEMORY_TAG;
 	  default:
 	    return TS_DECL_NON_COMMON;
 	  }
 }
 case tcc_type:
 default:
 gcc_unreachable ();
 }
 }
+/* Initialize tree_contains_struct to describe the hierarchy of tree
+nodes.  */
+static void
+initialize_tree_contains_struct (void)
+{
+unsigned i;
+#define MARK_TS_BASE(C)					\
+do {							\
+tree_contains_struct[C][TS_BASE] = 1;		\
+} while (0)
+#define MARK_TS_COMMON(C)				\
+do {							\
+MARK_TS_BASE (C);					\
+tree_contains_struct[C][TS_COMMON] = 1;		\
+} while (0)
+#define MARK_TS_DECL_MINIMAL(C)				\
+do {							\
+MARK_TS_COMMON (C);					\
+tree_contains_struct[C][TS_DECL_MINIMAL] = 1;	\
+} while (0)
+#define MARK_TS_DECL_COMMON(C)				\
+do {							\
+MARK_TS_DECL_MINIMAL (C);				\
+tree_contains_struct[C][TS_DECL_COMMON] = 1;	\
+} while (0)
+#define MARK_TS_DECL_WRTL(C)				\
+do {							\
+MARK_TS_DECL_COMMON (C);				\
+tree_contains_struct[C][TS_DECL_WRTL] = 1;		\
+} while (0)
+#define MARK_TS_DECL_WITH_VIS(C)			\
+do {							\
+MARK_TS_DECL_WRTL (C);				\
+tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;	\
+} while (0)
+#define MARK_TS_DECL_NON_COMMON(C)			\
+do {							\
+MARK_TS_DECL_WITH_VIS (C);				\
+tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;	\
+} while (0)
+for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
+{
+enum tree_code code;
+enum tree_node_structure_enum ts_code;
+code = (enum tree_code) i;
+ts_code = tree_node_structure_for_code (code);
+/* Mark the TS structure itself.  */
+tree_contains_struct[code][ts_code] = 1;
+/* Mark all the structures that TS is derived from.  */
+switch (ts_code)
+	{
+	case TS_COMMON:
+	  MARK_TS_BASE (code);
+	  break;
+	case TS_INT_CST:
+	case TS_REAL_CST:
+	case TS_FIXED_CST:
+	case TS_VECTOR:
+	case TS_STRING:
+	case TS_COMPLEX:
+	case TS_IDENTIFIER:
+	case TS_DECL_MINIMAL:
+	case TS_TYPE:
+	case TS_LIST:
+	case TS_VEC:
+	case TS_EXP:
+	case TS_SSA_NAME:
+	case TS_BLOCK:
+	case TS_BINFO:
+	case TS_STATEMENT_LIST:
+	case TS_CONSTRUCTOR:
+	case TS_OMP_CLAUSE:
+	case TS_OPTIMIZATION:
+	case TS_TARGET_OPTION:
+	  MARK_TS_COMMON (code);
+	  break;
+	case TS_DECL_COMMON:
+	  MARK_TS_DECL_MINIMAL (code);
+	  break;
+	case TS_DECL_WRTL:
+	  MARK_TS_DECL_COMMON (code);
+	  break;
+	case TS_DECL_NON_COMMON:
+	  MARK_TS_DECL_WITH_VIS (code);
+	  break;
+	case TS_DECL_WITH_VIS:
+	case TS_PARM_DECL:
+	case TS_LABEL_DECL:
+	case TS_RESULT_DECL:
+	case TS_CONST_DECL:
+	  MARK_TS_DECL_WRTL (code);
+	  break;
+	case TS_FIELD_DECL:
+	  MARK_TS_DECL_COMMON (code);
+	  break;
+	case TS_VAR_DECL:
+	  MARK_TS_DECL_WITH_VIS (code);
+	  break;
+	case TS_TYPE_DECL:
+	case TS_FUNCTION_DECL:
+	  MARK_TS_DECL_NON_COMMON (code);
+	  break;
+	default:
+	  gcc_unreachable ();
+	}
+}
+/* Basic consistency checks for attributes used in fold.  */
+gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
+gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON]);
+gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
+gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
+gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
+gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
+gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
+gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
+gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
+gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
+gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
+gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
+gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
+gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS]);
+gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
+gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
+gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
+gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
+gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
+gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
+gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
+gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
+gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
+gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
+#undef MARK_TS_BASE
+#undef MARK_TS_COMMON
+#undef MARK_TS_DECL_MINIMAL
+#undef MARK_TS_DECL_COMMON
+#undef MARK_TS_DECL_WRTL
+#undef MARK_TS_DECL_WITH_VIS
+#undef MARK_TS_DECL_NON_COMMON
+}
+/* Init tree.c.  */
+void
+init_ttree (void)
+{
+/* Initialize the hash table of types.  */
+type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
+				     type_hash_eq, 0);
+debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
+					 tree_map_eq, 0);
+value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
+					 tree_map_eq, 0);
+init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
+					    tree_priority_map_eq, 0);
+int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
+					int_cst_hash_eq, NULL);
+int_cst_node = make_node (INTEGER_CST);
+cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
+					  cl_option_hash_eq, NULL);
+cl_optimization_node = make_node (OPTIMIZATION_NODE);
+cl_target_option_node = make_node (TARGET_OPTION_NODE);
+/* Initialize the tree_contains_struct array.  */
+initialize_tree_contains_struct ();
+lang_hooks.init_ts ();
+}
+/* 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.  */
+tree
+decl_assembler_name (tree decl)
+{
+if (!DECL_ASSEMBLER_NAME_SET_P (decl))
+lang_hooks.set_decl_assembler_name (decl);
+return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
+}
+/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
+bool
+decl_assembler_name_equal (tree decl, const_tree asmname)
+{
+tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
+const char *decl_str;
+const char *asmname_str;
+bool test = false;
+if (decl_asmname == asmname)
+return true;
+decl_str = IDENTIFIER_POINTER (decl_asmname);
+asmname_str = IDENTIFIER_POINTER (asmname);
+/* If the target assembler name was set by the user, things are trickier.
+We have a leading '*' to begin with.  After that, it's arguable what
+is the correct thing to do with -fleading-underscore.  Arguably, we've
+historically been doing the wrong thing in assemble_alias by always
+printing the leading underscore.  Since we're not changing that, make
+sure user_label_prefix follows the '*' before matching.  */
+if (decl_str[0] == '*')
+{
+size_t ulp_len = strlen (user_label_prefix);
+decl_str ++;
+if (ulp_len == 0)
+	test = true;
+else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
+	decl_str += ulp_len, test=true;
+else
+	decl_str --;
+}
+if (asmname_str[0] == '*')
+{
+size_t ulp_len = strlen (user_label_prefix);
+asmname_str ++;
+if (ulp_len == 0)
+	test = true;
+else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
+	asmname_str += ulp_len, test=true;
+else
+	asmname_str --;
+}
+if (!test)
+return false;
+return strcmp (decl_str, asmname_str) == 0;
+}
+/* Hash asmnames ignoring the user specified marks.  */
+hashval_t
+decl_assembler_name_hash (const_tree asmname)
+{
+if (IDENTIFIER_POINTER (asmname)[0] == '*')
+{
+const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
+size_t ulp_len = strlen (user_label_prefix);
+if (ulp_len == 0)
+	;
+else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
+	decl_str += ulp_len;
+return htab_hash_string (decl_str);
+}
+return htab_hash_string (IDENTIFIER_POINTER (asmname));
+}
+/* Compute the number of bytes occupied by a tree with code CODE.
+This function cannot be used for nodes that have variable sizes,
+including TREE_VEC, STRING_CST, and CALL_EXPR.  */
+size_t
+tree_code_size (enum tree_code code)
+{
+switch (TREE_CODE_CLASS (code))
+{
+case tcc_declaration:  /* A decl node */
+{
+	switch (code)
+	  {
+	  case FIELD_DECL:
+	    return sizeof (struct tree_field_decl);
+	  case PARM_DECL:
+	    return sizeof (struct tree_parm_decl);
+	  case VAR_DECL:
+	    return sizeof (struct tree_var_decl);
+	  case LABEL_DECL:
+	    return sizeof (struct tree_label_decl);
+	  case RESULT_DECL:
+	    return sizeof (struct tree_result_decl);
+	  case CONST_DECL:
+	    return sizeof (struct tree_const_decl);
+	  case TYPE_DECL:
+	    return sizeof (struct tree_type_decl);
+	  case FUNCTION_DECL:
+	    return sizeof (struct tree_function_decl);
+	  case DEBUG_EXPR_DECL:
+	    return sizeof (struct tree_decl_with_rtl);
+	  default:
+	    return sizeof (struct tree_decl_non_common);
+	  }
+}
+case tcc_type:  /* a type node */
+return sizeof (struct tree_type);
+case tcc_reference:   /* a reference */
+case tcc_expression:  /* an expression */
+case tcc_statement:   /* an expression with side effects */
+case tcc_comparison:  /* a comparison expression */
+case tcc_unary:       /* a unary arithmetic expression */
+case tcc_binary:      /* a binary arithmetic expression */
+return (sizeof (struct tree_exp)
+	      + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
+case tcc_constant:  /* a constant */
+switch (code)
+	{
+	case INTEGER_CST:	return sizeof (struct tree_int_cst);
+	case REAL_CST:		return sizeof (struct tree_real_cst);
+	case FIXED_CST:		return sizeof (struct tree_fixed_cst);
+	case COMPLEX_CST:	return sizeof (struct tree_complex);
+	case VECTOR_CST:	return sizeof (struct tree_vector);
+	case STRING_CST:	gcc_unreachable ();
+	default:
+	  return lang_hooks.tree_size (code);
+	}
+case tcc_exceptional:  /* something random, like an identifier.  */
+switch (code)
+	{
+	case IDENTIFIER_NODE:	return lang_hooks.identifier_size;
+	case TREE_LIST:		return sizeof (struct tree_list);
+	case ERROR_MARK:
+	case PLACEHOLDER_EXPR:	return sizeof (struct tree_common);
+	case TREE_VEC:
+	case OMP_CLAUSE:	gcc_unreachable ();
+	case SSA_NAME:		return sizeof (struct tree_ssa_name);
+	case STATEMENT_LIST:	return sizeof (struct tree_statement_list);
+	case BLOCK:		return sizeof (struct tree_block);
+	case CONSTRUCTOR:	return sizeof (struct tree_constructor);
+	case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
+	case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
+	default:
+	  return lang_hooks.tree_size (code);
+	}
+default:
+gcc_unreachable ();
+}
+}
+/* Compute the number of bytes occupied by NODE.  This routine only
+looks at TREE_CODE, except for those nodes that have variable sizes.  */
+size_t
+tree_size (const_tree node)
+{
+const enum tree_code code = TREE_CODE (node);
+switch (code)
+{
+case TREE_BINFO:
+return (offsetof (struct tree_binfo, base_binfos)
+	      + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
+case TREE_VEC:
+return (sizeof (struct tree_vec)
+	      + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
+case STRING_CST:
+return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
+case OMP_CLAUSE:
+return (sizeof (struct tree_omp_clause)
+	      + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
+	        * sizeof (tree));
+default:
+if (TREE_CODE_CLASS (code) == tcc_vl_exp)
+	return (sizeof (struct tree_exp)
+		+ (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
+else
+	return tree_code_size (code);
+}
+}
+/* Return a newly allocated node of code CODE.  For decl and type
+nodes, some other fields are initialized.  The rest of the node is
+initialized to zero.  This function cannot be used for TREE_VEC or
+OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
+Achoo!  I got a code in the node.  */
+tree
+make_node_stat (enum tree_code code MEM_STAT_DECL)
+{
+tree t;
+enum tree_code_class type = TREE_CODE_CLASS (code);
+size_t length = tree_code_size (code);
+#ifdef GATHER_STATISTICS
+tree_node_kind kind;
+switch (type)
+{
+case tcc_declaration:  /* A decl node */
+kind = d_kind;
+break;
+case tcc_type:  /* a type node */
+kind = t_kind;
+break;
+case tcc_statement:  /* an expression with side effects */
+kind = s_kind;
+break;
+case tcc_reference:  /* a reference */
+kind = r_kind;
+break;
+case tcc_expression:  /* an expression */
+case tcc_comparison:  /* a comparison expression */
+case tcc_unary:  /* a unary arithmetic expression */
+case tcc_binary:  /* a binary arithmetic expression */
+kind = e_kind;
+break;
+case tcc_constant:  /* a constant */
+kind = c_kind;
+break;
+case tcc_exceptional:  /* something random, like an identifier.  */
+switch (code)
+	{
+	case IDENTIFIER_NODE:
+	  kind = id_kind;
+	  break;
+	case TREE_VEC:
+	  kind = vec_kind;
+	  break;
+	case TREE_BINFO:
+	  kind = binfo_kind;
+	  break;
+	case SSA_NAME:
+	  kind = ssa_name_kind;
+	  break;
+	case BLOCK:
+	  kind = b_kind;
+	  break;
+	case CONSTRUCTOR:
+	  kind = constr_kind;
+	  break;
+	default:
+	  kind = x_kind;
+	  break;
+	}
+break;
+default:
+gcc_unreachable ();
+}
+tree_node_counts[(int) kind]++;
+tree_node_sizes[(int) kind] += length;
+#endif
+if (code == IDENTIFIER_NODE)
+t = (tree) ggc_alloc_zone_pass_stat (length, &tree_id_zone);
+else
+t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
+memset (t, 0, length);
+TREE_SET_CODE (t, code);
+switch (type)
+{
+case tcc_statement:
+TREE_SIDE_EFFECTS (t) = 1;
+break;
+case tcc_declaration:
+if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
+	{
+	  if (code == FUNCTION_DECL)
+	    {
+	      DECL_ALIGN (t) = FUNCTION_BOUNDARY;
+	      DECL_MODE (t) = FUNCTION_MODE;
+	    }
+	  else
+	    DECL_ALIGN (t) = 1;
+	}
+DECL_SOURCE_LOCATION (t) = input_location;
+if (TREE_CODE (t) == DEBUG_EXPR_DECL)
+	DECL_UID (t) = --next_debug_decl_uid;
+else
+	DECL_UID (t) = next_decl_uid++;
+if (TREE_CODE (t) == LABEL_DECL)
+	LABEL_DECL_UID (t) = -1;
+break;
+case tcc_type:
+TYPE_UID (t) = next_type_uid++;
+TYPE_ALIGN (t) = BITS_PER_UNIT;
+TYPE_USER_ALIGN (t) = 0;
+TYPE_MAIN_VARIANT (t) = t;
+TYPE_CANONICAL (t) = t;
+/* Default to no attributes for type, but let target change that.  */
+TYPE_ATTRIBUTES (t) = NULL_TREE;
+targetm.set_default_type_attributes (t);
+/* We have not yet computed the alias set for this type.  */
+TYPE_ALIAS_SET (t) = -1;
+break;
+case tcc_constant:
+TREE_CONSTANT (t) = 1;
+break;
+case tcc_expression:
+switch (code)
+	{
+	case INIT_EXPR:
+	case MODIFY_EXPR:
+	case VA_ARG_EXPR:
+	case PREDECREMENT_EXPR:
+	case PREINCREMENT_EXPR:
+	case POSTDECREMENT_EXPR:
+	case POSTINCREMENT_EXPR:
+	  /* All of these have side-effects, no matter what their
+	     operands are.  */
+	  TREE_SIDE_EFFECTS (t) = 1;
+	  break;
+	default:
+	  break;
+	}
+break;
+default:
+/* Other classes need no special treatment.  */
+break;
+}
+return t;
+}
+/* Return a new node with the same contents as NODE except that its
+TREE_CHAIN is zero and it has a fresh uid.  */
+tree
+copy_node_stat (tree node MEM_STAT_DECL)
+{
+tree t;
+enum tree_code code = TREE_CODE (node);
+size_t length;
+gcc_assert (code != STATEMENT_LIST);
+length = tree_size (node);
+t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
+memcpy (t, node, length);
+TREE_CHAIN (t) = 0;
+TREE_ASM_WRITTEN (t) = 0;
+TREE_VISITED (t) = 0;
+if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
+*DECL_VAR_ANN_PTR (t) = 0;
+if (TREE_CODE_CLASS (code) == tcc_declaration)
+{
+if (code == DEBUG_EXPR_DECL)
+	DECL_UID (t) = --next_debug_decl_uid;
+else
+	DECL_UID (t) = next_decl_uid++;
+if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
+	  && DECL_HAS_VALUE_EXPR_P (node))
+	{
+	  SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
+	  DECL_HAS_VALUE_EXPR_P (t) = 1;
+	}
+if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
+	{
+	  SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
+	  DECL_HAS_INIT_PRIORITY_P (t) = 1;
+	}
+}
+else if (TREE_CODE_CLASS (code) == tcc_type)
+{
+TYPE_UID (t) = next_type_uid++;
+/* The following is so that the debug code for
+	 the copy is different from the original type.
+	 The two statements usually duplicate each other
+	 (because they clear fields of the same union),
+	 but the optimizer should catch that.  */
+TYPE_SYMTAB_POINTER (t) = 0;
+TYPE_SYMTAB_ADDRESS (t) = 0;
+/* Do not copy the values cache.  */
+if (TYPE_CACHED_VALUES_P(t))
+	{
+	  TYPE_CACHED_VALUES_P (t) = 0;
+	  TYPE_CACHED_VALUES (t) = NULL_TREE;
+	}
+}
+return t;
+}
+/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
+For example, this can copy a list made of TREE_LIST nodes.  */
+tree
+copy_list (tree list)
+{
+tree head;
+tree prev, next;
+if (list == 0)
+return 0;
+head = prev = copy_node (list);
+next = TREE_CHAIN (list);
+while (next)
+{
+TREE_CHAIN (prev) = copy_node (next);
+prev = TREE_CHAIN (prev);
+next = TREE_CHAIN (next);
+}
+return head;
+}
+/* Create an INT_CST node with a LOW value sign extended.  */
+tree
+build_int_cst (tree type, HOST_WIDE_INT low)
+{
+/* Support legacy code.  */
+if (!type)
+type = integer_type_node;
+return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
+}
+/* Create an INT_CST node with a LOW value zero extended.  */
+tree
+build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
+{
+return build_int_cst_wide (type, low, 0);
+}
+/* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
+if it is negative.  This function is similar to build_int_cst, but
+the extra bits outside of the type precision are cleared.  Constants
+with these extra bits may confuse the fold so that it detects overflows
+even in cases when they do not occur, and in general should be avoided.
+We cannot however make this a default behavior of build_int_cst without
+more intrusive changes, since there are parts of gcc that rely on the extra
+precision of the integer constants.  */
+tree
+build_int_cst_type (tree type, HOST_WIDE_INT low)
+{
+unsigned HOST_WIDE_INT low1;
+HOST_WIDE_INT hi;
+gcc_assert (type);
+fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
+return build_int_cst_wide (type, low1, hi);
+}
+/* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
+and sign extended according to the value range of TYPE.  */
+tree
+build_int_cst_wide_type (tree type,
+			 unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
+{
+fit_double_type (low, high, &low, &high, type);
+return build_int_cst_wide (type, low, high);
+}
+/* These are the hash table functions for the hash table of INTEGER_CST
+nodes of a sizetype.  */
+/* Return the hash code code X, an INTEGER_CST.  */
+static hashval_t
+int_cst_hash_hash (const void *x)
+{
+const_tree const t = (const_tree) x;
+return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
+	  ^ htab_hash_pointer (TREE_TYPE (t)));
+}
+/* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
+is the same as that given by *Y, which is the same.  */
+static int
+int_cst_hash_eq (const void *x, const void *y)
+{
+const_tree const xt = (const_tree) x;
+const_tree const yt = (const_tree) y;
+return (TREE_TYPE (xt) == TREE_TYPE (yt)
+	  && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
+	  && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
+}
+/* Create an INT_CST node of TYPE and value HI:LOW.
+The returned node is always shared.  For small integers we use a
+per-type vector cache, for larger ones we use a single hash table.  */
+tree
+build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
+{
+tree t;
+int ix = -1;
+int limit = 0;
+gcc_assert (type);
+switch (TREE_CODE (type))
+{
+case POINTER_TYPE:
+case REFERENCE_TYPE:
+/* Cache NULL pointer.  */
+if (!hi && !low)
+	{
+	  limit = 1;
+	  ix = 0;
+	}
+break;
+case BOOLEAN_TYPE:
+/* Cache false or true.  */
+limit = 2;
+if (!hi && low < 2)
+	ix = low;
+break;
+case INTEGER_TYPE:
+case OFFSET_TYPE:
+if (TYPE_UNSIGNED (type))
+	{
+	  /* Cache 0..N */
+	  limit = INTEGER_SHARE_LIMIT;
+	  if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
+	    ix = low;
+	}
+else
+	{
+	  /* Cache -1..N */
+	  limit = INTEGER_SHARE_LIMIT + 1;
+	  if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
+	    ix = low + 1;
+	  else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
+	    ix = 0;
+	}
+break;
+case ENUMERAL_TYPE:
+break;
+default:
+gcc_unreachable ();
+}
+if (ix >= 0)
+{
+/* Look for it in the type's vector of small shared ints.  */
+if (!TYPE_CACHED_VALUES_P (type))
+	{
+	  TYPE_CACHED_VALUES_P (type) = 1;
+	  TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
+	}
+t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
+if (t)
+	{
+	  /* Make sure no one is clobbering the shared constant.  */
+	  gcc_assert (TREE_TYPE (t) == type);
+	  gcc_assert (TREE_INT_CST_LOW (t) == low);
+	  gcc_assert (TREE_INT_CST_HIGH (t) == hi);
+	}
+else
+	{
+	  /* Create a new shared int.  */
+	  t = make_node (INTEGER_CST);
+	  TREE_INT_CST_LOW (t) = low;
+	  TREE_INT_CST_HIGH (t) = hi;
+	  TREE_TYPE (t) = type;
+	  TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
+	}
+}
+else
+{
+/* Use the cache of larger shared ints.  */
+void **slot;
+TREE_INT_CST_LOW (int_cst_node) = low;
+TREE_INT_CST_HIGH (int_cst_node) = hi;
+TREE_TYPE (int_cst_node) = type;
+slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
+t = (tree) *slot;
+if (!t)
+	{
+	  /* Insert this one into the hash table.  */
+	  t = int_cst_node;
+	  *slot = t;
+	  /* Make a new node for next time round.  */
+	  int_cst_node = make_node (INTEGER_CST);
+	}
+}
+return t;
+}
+/* Builds an integer constant in TYPE such that lowest BITS bits are ones
+and the rest are zeros.  */
+tree
+build_low_bits_mask (tree type, unsigned bits)
+{
+unsigned HOST_WIDE_INT low;
+HOST_WIDE_INT high;
+unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
+gcc_assert (bits <= TYPE_PRECISION (type));
+if (bits == TYPE_PRECISION (type)
+&& !TYPE_UNSIGNED (type))
+{
+/* Sign extended all-ones mask.  */
+low = all_ones;
+high = -1;
+}
+else if (bits <= HOST_BITS_PER_WIDE_INT)
+{
+low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
+high = 0;
+}
+else
+{
+bits -= HOST_BITS_PER_WIDE_INT;
+low = all_ones;
+high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
+}
+return build_int_cst_wide (type, low, high);
+}
+/* Checks that X is integer constant that can be expressed in (unsigned)
+HOST_WIDE_INT without loss of precision.  */
+bool
+cst_and_fits_in_hwi (const_tree x)
+{
+if (TREE_CODE (x) != INTEGER_CST)
+return false;
+if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
+return false;
+return (TREE_INT_CST_HIGH (x) == 0
+	  || TREE_INT_CST_HIGH (x) == -1);
+}
+/* Return a new VECTOR_CST node whose type is TYPE and whose values
+are in a list pointed to by VALS.  */
+tree
+build_vector (tree type, tree vals)
+{
+tree v = make_node (VECTOR_CST);
+int over = 0;
+tree link;
+TREE_VECTOR_CST_ELTS (v) = vals;
+TREE_TYPE (v) = type;
+/* Iterate through elements and check for overflow.  */
+for (link = vals; link; link = TREE_CHAIN (link))
+{
+tree value = TREE_VALUE (link);
+/* Don't crash if we get an address constant.  */
+if (!CONSTANT_CLASS_P (value))
+	continue;
+over |= TREE_OVERFLOW (value);
+}
+TREE_OVERFLOW (v) = over;
+return v;
+}
+/* Return a new VECTOR_CST node whose type is TYPE and whose values
+are extracted from V, a vector of CONSTRUCTOR_ELT.  */
+tree
+build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
+{
+tree list = NULL_TREE;
+unsigned HOST_WIDE_INT idx;
+tree value;
+FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
+list = tree_cons (NULL_TREE, value, list);
+return build_vector (type, nreverse (list));
+}
+/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
+are in the VEC pointed to by VALS.  */
+tree
+build_constructor (tree type, VEC(constructor_elt,gc) *vals)
+{
+tree c = make_node (CONSTRUCTOR);
+TREE_TYPE (c) = type;
+CONSTRUCTOR_ELTS (c) = vals;
+return c;
+}
+/* Build a CONSTRUCTOR node made of a single initializer, with the specified
+INDEX and VALUE.  */
+tree
+build_constructor_single (tree type, tree index, tree value)
+{
+VEC(constructor_elt,gc) *v;
+constructor_elt *elt;
+tree t;
+v = VEC_alloc (constructor_elt, gc, 1);
+elt = VEC_quick_push (constructor_elt, v, NULL);
+elt->index = index;
+elt->value = value;
+t = build_constructor (type, v);
+TREE_CONSTANT (t) = TREE_CONSTANT (value);
+return t;
+}
+/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
+are in a list pointed to by VALS.  */
+tree
+build_constructor_from_list (tree type, tree vals)
+{
+tree t, val;
+VEC(constructor_elt,gc) *v = NULL;
+bool constant_p = true;
+if (vals)
+{
+v = VEC_alloc (constructor_elt, gc, list_length (vals));
+for (t = vals; t; t = TREE_CHAIN (t))
+	{
+	  constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
+	  val = TREE_VALUE (t);
+	  elt->index = TREE_PURPOSE (t);
+	  elt->value = val;
+	  if (!TREE_CONSTANT (val))
+	    constant_p = false;
+	}
+}
+t = build_constructor (type, v);
+TREE_CONSTANT (t) = constant_p;
+return t;
+}
+/* Return a new FIXED_CST node whose type is TYPE and value is F.  */
+tree
+build_fixed (tree type, FIXED_VALUE_TYPE f)
+{
+tree v;
+FIXED_VALUE_TYPE *fp;
+v = make_node (FIXED_CST);
+fp = GGC_NEW (FIXED_VALUE_TYPE);
+memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
+TREE_TYPE (v) = type;
+TREE_FIXED_CST_PTR (v) = fp;
+return v;
+}
+/* Return a new REAL_CST node whose type is TYPE and value is D.  */
+tree
+build_real (tree type, REAL_VALUE_TYPE d)
+{
+tree v;
+REAL_VALUE_TYPE *dp;
+int overflow = 0;
+/* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
+Consider doing it via real_convert now.  */
+v = make_node (REAL_CST);
+dp = GGC_NEW (REAL_VALUE_TYPE);
+memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
+TREE_TYPE (v) = type;
+TREE_REAL_CST_PTR (v) = dp;
+TREE_OVERFLOW (v) = overflow;
+return v;
+}
+/* Return a new REAL_CST node whose type is TYPE
+and whose value is the integer value of the INTEGER_CST node I.  */
+REAL_VALUE_TYPE
+real_value_from_int_cst (const_tree type, const_tree i)
+{
+REAL_VALUE_TYPE d;
+/* Clear all bits of the real value type so that we can later do
+bitwise comparisons to see if two values are the same.  */
+memset (&d, 0, sizeof d);
+real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
+		     TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
+		     TYPE_UNSIGNED (TREE_TYPE (i)));
+return d;
+}
+/* Given a tree representing an integer constant I, return a tree
+representing the same value as a floating-point constant of type TYPE.  */
+tree
+build_real_from_int_cst (tree type, const_tree i)
+{
+tree v;
+int overflow = TREE_OVERFLOW (i);
+v = build_real (type, real_value_from_int_cst (type, i));
+TREE_OVERFLOW (v) |= overflow;
+return v;
+}
+/* Return a newly constructed STRING_CST node whose value is
+the LEN characters at STR.
+The TREE_TYPE is not initialized.  */
+tree
+build_string (int len, const char *str)
+{
+tree s;
+size_t length;
+/* Do not waste bytes provided by padding of struct tree_string.  */
+length = len + offsetof (struct tree_string, str) + 1;
+#ifdef GATHER_STATISTICS
+tree_node_counts[(int) c_kind]++;
+tree_node_sizes[(int) c_kind] += length;
+#endif
+s = ggc_alloc_tree (length);
+memset (s, 0, sizeof (struct tree_common));
+TREE_SET_CODE (s, STRING_CST);
+TREE_CONSTANT (s) = 1;
+TREE_STRING_LENGTH (s) = len;
+memcpy (s->string.str, str, len);
+s->string.str[len] = '\0';
+return s;
+}
+/* Return a newly constructed COMPLEX_CST node whose value is
+specified by the real and imaginary parts REAL and IMAG.
+Both REAL and IMAG should be constant nodes.  TYPE, if specified,
+will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
+tree
+build_complex (tree type, tree real, tree imag)
+{
+tree t = make_node (COMPLEX_CST);
+TREE_REALPART (t) = real;
+TREE_IMAGPART (t) = imag;
+TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
+TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
+return t;
+}
+/* Return a constant of arithmetic type TYPE which is the
+multiplicative identity of the set TYPE.  */
+tree
+build_one_cst (tree type)
+{
+switch (TREE_CODE (type))
+{
+case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
+case POINTER_TYPE: case REFERENCE_TYPE:
+case OFFSET_TYPE:
+return build_int_cst (type, 1);
+case REAL_TYPE:
+return build_real (type, dconst1);
+case FIXED_POINT_TYPE:
+/* We can only generate 1 for accum types.  */
+gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
+return build_fixed (type, FCONST1(TYPE_MODE (type)));
+case VECTOR_TYPE:
+{
+	tree scalar, cst;
+	int i;
+	scalar = build_one_cst (TREE_TYPE (type));
+	/* Create 'vect_cst_ = {cst,cst,...,cst}'  */
+	cst = NULL_TREE;
+	for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
+	  cst = tree_cons (NULL_TREE, scalar, cst);
+	return build_vector (type, cst);
+}
+case COMPLEX_TYPE:
+return build_complex (type,
+			    build_one_cst (TREE_TYPE (type)),
+			    fold_convert (TREE_TYPE (type), integer_zero_node));
+default:
+gcc_unreachable ();
+}
+}
+/* Build a BINFO with LEN language slots.  */
+tree
+make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
+{
+tree t;
+size_t length = (offsetof (struct tree_binfo, base_binfos)
+		   + VEC_embedded_size (tree, base_binfos));
+#ifdef GATHER_STATISTICS
+tree_node_counts[(int) binfo_kind]++;
+tree_node_sizes[(int) binfo_kind] += length;
+#endif
+t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
+memset (t, 0, offsetof (struct tree_binfo, base_binfos));
+TREE_SET_CODE (t, TREE_BINFO);
+VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
+return t;
+}
+/* Build a newly constructed TREE_VEC node of length LEN.  */
+tree
+make_tree_vec_stat (int len MEM_STAT_DECL)
+{
+tree t;
+int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
+#ifdef GATHER_STATISTICS
+tree_node_counts[(int) vec_kind]++;
+tree_node_sizes[(int) vec_kind] += length;
+#endif
+t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
+memset (t, 0, length);
+TREE_SET_CODE (t, TREE_VEC);
+TREE_VEC_LENGTH (t) = len;
+return t;
+}
+/* Return 1 if EXPR is the integer constant zero or a complex constant
+of zero.  */
+int
+integer_zerop (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == INTEGER_CST
+	   && TREE_INT_CST_LOW (expr) == 0
+	   && TREE_INT_CST_HIGH (expr) == 0)
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && integer_zerop (TREE_REALPART (expr))
+	      && integer_zerop (TREE_IMAGPART (expr))));
+}
+/* Return 1 if EXPR is the integer constant one or the corresponding
+complex constant.  */
+int
+integer_onep (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == INTEGER_CST
+	   && TREE_INT_CST_LOW (expr) == 1
+	   && TREE_INT_CST_HIGH (expr) == 0)
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && integer_onep (TREE_REALPART (expr))
+	      && integer_zerop (TREE_IMAGPART (expr))));
+}
+/* Return 1 if EXPR is an integer containing all 1's in as much precision as
+it contains.  Likewise for the corresponding complex constant.  */
+int
+integer_all_onesp (const_tree expr)
+{
+int prec;
+int uns;
+STRIP_NOPS (expr);
+if (TREE_CODE (expr) == COMPLEX_CST
+&& integer_all_onesp (TREE_REALPART (expr))
+&& integer_zerop (TREE_IMAGPART (expr)))
+return 1;
+else if (TREE_CODE (expr) != INTEGER_CST)
+return 0;
+uns = TYPE_UNSIGNED (TREE_TYPE (expr));
+if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
+&& TREE_INT_CST_HIGH (expr) == -1)
+return 1;
+if (!uns)
+return 0;
+/* Note that using TYPE_PRECISION here is wrong.  We care about the
+actual bits, not the (arbitrary) range of the type.  */
+prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
+if (prec >= HOST_BITS_PER_WIDE_INT)
+{
+HOST_WIDE_INT high_value;
+int shift_amount;
+shift_amount = prec - HOST_BITS_PER_WIDE_INT;
+/* Can not handle precisions greater than twice the host int size.  */
+gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
+if (shift_amount == HOST_BITS_PER_WIDE_INT)
+	/* Shifting by the host word size is undefined according to the ANSI
+	   standard, so we must handle this as a special case.  */
+	high_value = -1;
+else
+	high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
+return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
+	      && TREE_INT_CST_HIGH (expr) == high_value);
+}
+else
+return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
+}
+/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
+one bit on).  */
+int
+integer_pow2p (const_tree expr)
+{
+int prec;
+HOST_WIDE_INT high, low;
+STRIP_NOPS (expr);
+if (TREE_CODE (expr) == COMPLEX_CST
+&& integer_pow2p (TREE_REALPART (expr))
+&& integer_zerop (TREE_IMAGPART (expr)))
+return 1;
+if (TREE_CODE (expr) != INTEGER_CST)
+return 0;
+prec = TYPE_PRECISION (TREE_TYPE (expr));
+high = TREE_INT_CST_HIGH (expr);
+low = TREE_INT_CST_LOW (expr);
+/* First clear all bits that are beyond the type's precision in case
+we've been sign extended.  */
+if (prec == 2 * HOST_BITS_PER_WIDE_INT)
+;
+else if (prec > HOST_BITS_PER_WIDE_INT)
+high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
+else
+{
+high = 0;
+if (prec < HOST_BITS_PER_WIDE_INT)
+	low &= ~((HOST_WIDE_INT) (-1) << prec);
+}
+if (high == 0 && low == 0)
+return 0;
+return ((high == 0 && (low & (low - 1)) == 0)
+	  || (low == 0 && (high & (high - 1)) == 0));
+}
+/* Return 1 if EXPR is an integer constant other than zero or a
+complex constant other than zero.  */
+int
+integer_nonzerop (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == INTEGER_CST
+	   && (TREE_INT_CST_LOW (expr) != 0
+	       || TREE_INT_CST_HIGH (expr) != 0))
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && (integer_nonzerop (TREE_REALPART (expr))
+		  || integer_nonzerop (TREE_IMAGPART (expr)))));
+}
+/* Return 1 if EXPR is the fixed-point constant zero.  */
+int
+fixed_zerop (const_tree expr)
+{
+return (TREE_CODE (expr) == FIXED_CST
+	  && double_int_zero_p (TREE_FIXED_CST (expr).data));
+}
+/* Return the power of two represented by a tree node known to be a
+power of two.  */
+int
+tree_log2 (const_tree expr)
+{
+int prec;
+HOST_WIDE_INT high, low;
+STRIP_NOPS (expr);
+if (TREE_CODE (expr) == COMPLEX_CST)
+return tree_log2 (TREE_REALPART (expr));
+prec = TYPE_PRECISION (TREE_TYPE (expr));
+high = TREE_INT_CST_HIGH (expr);
+low = TREE_INT_CST_LOW (expr);
+/* First clear all bits that are beyond the type's precision in case
+we've been sign extended.  */
+if (prec == 2 * HOST_BITS_PER_WIDE_INT)
+;
+else if (prec > HOST_BITS_PER_WIDE_INT)
+high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
+else
+{
+high = 0;
+if (prec < HOST_BITS_PER_WIDE_INT)
+	low &= ~((HOST_WIDE_INT) (-1) << prec);
+}
+return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
+	  : exact_log2 (low));
+}
+/* Similar, but return the largest integer Y such that 2 ** Y is less
+than or equal to EXPR.  */
+int
+tree_floor_log2 (const_tree expr)
+{
+int prec;
+HOST_WIDE_INT high, low;
+STRIP_NOPS (expr);
+if (TREE_CODE (expr) == COMPLEX_CST)
+return tree_log2 (TREE_REALPART (expr));
+prec = TYPE_PRECISION (TREE_TYPE (expr));
+high = TREE_INT_CST_HIGH (expr);
+low = TREE_INT_CST_LOW (expr);
+/* First clear all bits that are beyond the type's precision in case
+we've been sign extended.  Ignore if type's precision hasn't been set
+since what we are doing is setting it.  */
+if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
+;
+else if (prec > HOST_BITS_PER_WIDE_INT)
+high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
+else
+{
+high = 0;
+if (prec < HOST_BITS_PER_WIDE_INT)
+	low &= ~((HOST_WIDE_INT) (-1) << prec);
+}
+return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
+	  : floor_log2 (low));
+}
+/* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
+decimal float constants, so don't return 1 for them.  */
+int
+real_zerop (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == REAL_CST
+	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
+	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && real_zerop (TREE_REALPART (expr))
+	      && real_zerop (TREE_IMAGPART (expr))));
+}
+/* Return 1 if EXPR is the real constant one in real or complex form.
+Trailing zeroes matter for decimal float constants, so don't return
+1 for them.  */
+int
+real_onep (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == REAL_CST
+	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
+	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && real_onep (TREE_REALPART (expr))
+	      && real_zerop (TREE_IMAGPART (expr))));
+}
+/* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
+for decimal float constants, so don't return 1 for them.  */
+int
+real_twop (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == REAL_CST
+	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
+	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && real_twop (TREE_REALPART (expr))
+	      && real_zerop (TREE_IMAGPART (expr))));
+}
+/* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
+matter for decimal float constants, so don't return 1 for them.  */
+int
+real_minus_onep (const_tree expr)
+{
+STRIP_NOPS (expr);
+return ((TREE_CODE (expr) == REAL_CST
+	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
+	   && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
+	  || (TREE_CODE (expr) == COMPLEX_CST
+	      && real_minus_onep (TREE_REALPART (expr))
+	      && real_zerop (TREE_IMAGPART (expr))));
+}
+/* Nonzero if EXP is a constant or a cast of a constant.  */
+int
+really_constant_p (const_tree exp)
+{
+/* This is not quite the same as STRIP_NOPS.  It does more.  */
+while (CONVERT_EXPR_P (exp)
+	 || TREE_CODE (exp) == NON_LVALUE_EXPR)
+exp = TREE_OPERAND (exp, 0);
+return TREE_CONSTANT (exp);
+}
+/* Return first list element whose TREE_VALUE is ELEM.
+Return 0 if ELEM is not in LIST.  */
+tree
+value_member (tree elem, tree list)
+{
+while (list)
+{
+if (elem == TREE_VALUE (list))
+	return list;
+list = TREE_CHAIN (list);
+}
+return NULL_TREE;
+}
+/* Return first list element whose TREE_PURPOSE is ELEM.
+Return 0 if ELEM is not in LIST.  */
+tree
+purpose_member (const_tree elem, tree list)
+{
+while (list)
+{
+if (elem == TREE_PURPOSE (list))
+	return list;
+list = TREE_CHAIN (list);
+}
+return NULL_TREE;
+}
+/* Returns element number IDX (zero-origin) of chain CHAIN, or
+NULL_TREE.  */
+tree
+chain_index (int idx, tree chain)
+{
+for (; chain && idx > 0; --idx)
+chain = TREE_CHAIN (chain);
+return chain;
+}
+/* Return nonzero if ELEM is part of the chain CHAIN.  */
+int
+chain_member (const_tree elem, const_tree chain)
+{
+while (chain)
+{
+if (elem == chain)
+	return 1;
+chain = TREE_CHAIN (chain);
+}
+return 0;
+}
+/* Return the length of a chain of nodes chained through TREE_CHAIN.
+We expect a null pointer to mark the end of the chain.
+This is the Lisp primitive `length'.  */
+int
+list_length (const_tree t)
+{
+const_tree p = t;
+#ifdef ENABLE_TREE_CHECKING
+const_tree q = t;
+#endif
+int len = 0;
+while (p)
+{
+p = TREE_CHAIN (p);
+#ifdef ENABLE_TREE_CHECKING
+if (len % 2)
+	q = TREE_CHAIN (q);
+gcc_assert (p != q);
+#endif
+len++;
+}
+return len;
+}
+/* Returns the number of FIELD_DECLs in TYPE.  */
+int
+fields_length (const_tree type)
+{
+tree t = TYPE_FIELDS (type);
+int count = 0;
+for (; t; t = TREE_CHAIN (t))
+if (TREE_CODE (t) == FIELD_DECL)
+++count;
+return count;
+}
+/* Concatenate two chains of nodes (chained through TREE_CHAIN)
+by modifying the last node in chain 1 to point to chain 2.
+This is the Lisp primitive `nconc'.  */
+tree
+chainon (tree op1, tree op2)
+{
+tree t1;
+if (!op1)
+return op2;
+if (!op2)
+return op1;
+for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
+continue;
+TREE_CHAIN (t1) = op2;
+#ifdef ENABLE_TREE_CHECKING
+{
+tree t2;
+for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
+gcc_assert (t2 != t1);
+}
+#endif
+return op1;
+}
+/* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
+tree
+tree_last (tree chain)
+{
+tree next;
+if (chain)
+while ((next = TREE_CHAIN (chain)))
+chain = next;
+return chain;
+}
+/* Reverse the order of elements in the chain T,
+and return the new head of the chain (old last element).  */
+tree
+nreverse (tree t)
+{
+tree prev = 0, decl, next;
+for (decl = t; decl; decl = next)
+{
+next = TREE_CHAIN (decl);
+TREE_CHAIN (decl) = prev;
+prev = decl;
+}
+return prev;
+}
+/* Return a newly created TREE_LIST node whose
+purpose and value fields are PARM and VALUE.  */
+tree
+build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
+{
+tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
+TREE_PURPOSE (t) = parm;
+TREE_VALUE (t) = value;
+return t;
+}
+/* Build a chain of TREE_LIST nodes from a vector.  */
+tree
+build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
+{
+tree ret = NULL_TREE;
+tree *pp = &ret;
+unsigned int i;
+tree t;
+for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
+{
+*pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
+pp = &TREE_CHAIN (*pp);
+}
+return ret;
+}
+/* Return a newly created TREE_LIST node whose
+purpose and value fields are PURPOSE and VALUE
+and whose TREE_CHAIN is CHAIN.  */
+tree
+tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
+{
+tree node;
+node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
+memset (node, 0, sizeof (struct tree_common));
+#ifdef GATHER_STATISTICS
+tree_node_counts[(int) x_kind]++;
+tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
+#endif
+TREE_SET_CODE (node, TREE_LIST);
+TREE_CHAIN (node) = chain;
+TREE_PURPOSE (node) = purpose;
+TREE_VALUE (node) = value;
+return node;
+}
+/* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
+tree
+ctor_to_list (tree ctor)
+{
+tree list = NULL_TREE;
+tree *p = &list;
+unsigned ix;
+tree purpose, val;
+FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
+{
+*p = build_tree_list (purpose, val);
+p = &TREE_CHAIN (*p);
+}
+return list;
+}
+/* Return the values of the elements of a CONSTRUCTOR as a vector of
+trees.  */
+VEC(tree,gc) *
+ctor_to_vec (tree ctor)
+{
+VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
+unsigned int ix;
+tree val;
+FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
+VEC_quick_push (tree, vec, val);
+return vec;
+}
+/* Return the size nominally occupied by an object of type TYPE
+when it resides in memory.  The value is measured in units of bytes,
+and its data type is that normally used for type sizes
+(which is the first type created by make_signed_type or
+make_unsigned_type).  */
+tree
+size_in_bytes (const_tree type)
+{
+tree t;
+if (type == error_mark_node)
+return integer_zero_node;
+type = TYPE_MAIN_VARIANT (type);
+t = TYPE_SIZE_UNIT (type);
+if (t == 0)
+{
+lang_hooks.types.incomplete_type_error (NULL_TREE, type);
+return size_zero_node;
+}
+return t;
+}
+/* Return the size of TYPE (in bytes) as a wide integer
+or return -1 if the size can vary or is larger than an integer.  */
+HOST_WIDE_INT
+int_size_in_bytes (const_tree type)
+{
+tree t;
+if (type == error_mark_node)
+return 0;
+type = TYPE_MAIN_VARIANT (type);
+t = TYPE_SIZE_UNIT (type);
+if (t == 0
+|| TREE_CODE (t) != INTEGER_CST
+|| TREE_INT_CST_HIGH (t) != 0
+/* If the result would appear negative, it's too big to represent.  */
+|| (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
+return -1;
+return TREE_INT_CST_LOW (t);
+}
+/* Return the maximum size of TYPE (in bytes) as a wide integer
+or return -1 if the size can vary or is larger than an integer.  */
+HOST_WIDE_INT
+max_int_size_in_bytes (const_tree type)
+{
+HOST_WIDE_INT size = -1;
+tree size_tree;
+/* If this is an array type, check for a possible MAX_SIZE attached.  */
+if (TREE_CODE (type) == ARRAY_TYPE)
+{
+size_tree = TYPE_ARRAY_MAX_SIZE (type);
+if (size_tree && host_integerp (size_tree, 1))
+	size = tree_low_cst (size_tree, 1);
+}
+/* If we still haven't been able to get a size, see if the language
+can compute a maximum size.  */
+if (size == -1)
+{
+size_tree = lang_hooks.types.max_size (type);
+if (size_tree && host_integerp (size_tree, 1))
+	size = tree_low_cst (size_tree, 1);
+}
+return size;
+}
+/* Returns a tree for the size of EXP in bytes.  */
+tree
+tree_expr_size (const_tree exp)
+{
+if (DECL_P (exp)
+&& DECL_SIZE_UNIT (exp) != 0)
+return DECL_SIZE_UNIT (exp);
+else
+return size_in_bytes (TREE_TYPE (exp));
+}
+/* Return the bit position of FIELD, in bits from the start of the record.
+This is a tree of type bitsizetype.  */
+tree
+bit_position (const_tree field)
+{
+return bit_from_pos (DECL_FIELD_OFFSET (field),
+		       DECL_FIELD_BIT_OFFSET (field));
+}
+/* Likewise, but return as an integer.  It must be representable in
+that way (since it could be a signed value, we don't have the
+option of returning -1 like int_size_in_byte can.  */
+HOST_WIDE_INT
+int_bit_position (const_tree field)
+{
+return tree_low_cst (bit_position (field), 0);
+}
+/* Return the byte position of FIELD, in bytes from the start of the record.
+This is a tree of type sizetype.  */
+tree
+byte_position (const_tree field)
+{
+return byte_from_pos (DECL_FIELD_OFFSET (field),
+			DECL_FIELD_BIT_OFFSET (field));
+}
+/* Likewise, but return as an integer.  It must be representable in
+that way (since it could be a signed value, we don't have the
+option of returning -1 like int_size_in_byte can.  */
+HOST_WIDE_INT
+int_byte_position (const_tree field)
+{
+return tree_low_cst (byte_position (field), 0);
+}
+/* Return the strictest alignment, in bits, that T is known to have.  */
+unsigned int
+expr_align (const_tree t)
+{
+unsigned int align0, align1;
+switch (TREE_CODE (t))
+{
+CASE_CONVERT:  case NON_LVALUE_EXPR:
+/* If we have conversions, we know that the alignment of the
+	 object must meet each of the alignments of the types.  */
+align0 = expr_align (TREE_OPERAND (t, 0));
+align1 = TYPE_ALIGN (TREE_TYPE (t));
+return MAX (align0, align1);
+case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
+case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
+case CLEANUP_POINT_EXPR:
+/* These don't change the alignment of an object.  */
+return expr_align (TREE_OPERAND (t, 0));
+case COND_EXPR:
+/* The best we can do is say that the alignment is the least aligned
+	 of the two arms.  */
+align0 = expr_align (TREE_OPERAND (t, 1));
+align1 = expr_align (TREE_OPERAND (t, 2));
+return MIN (align0, align1);
+/* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
+	 meaningfully, it's always 1.  */
+case LABEL_DECL:     case CONST_DECL:
+case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
+case FUNCTION_DECL:
+gcc_assert (DECL_ALIGN (t) != 0);
+return DECL_ALIGN (t);
+default:
+break;
+}
+/* Otherwise take the alignment from that of the type.  */
+return TYPE_ALIGN (TREE_TYPE (t));
+}
+/* Return, as a tree node, the number of elements for TYPE (which is an
+ARRAY_TYPE) minus one. This counts only elements of the top array.  */
+tree
+array_type_nelts (const_tree type)
+{
+tree index_type, min, max;
+/* If they did it with unspecified bounds, then we should have already
+given an error about it before we got here.  */
+if (! TYPE_DOMAIN (type))
+return error_mark_node;
+index_type = TYPE_DOMAIN (type);
+min = TYPE_MIN_VALUE (index_type);
+max = TYPE_MAX_VALUE (index_type);
+return (integer_zerop (min)
+	  ? max
+	  : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
+}
+/* If arg is static -- a reference to an object in static storage -- then
+return the object.  This is not the same as the C meaning of `static'.
+If arg isn't static, return NULL.  */
+tree
+staticp (tree arg)
+{
+switch (TREE_CODE (arg))
+{
+case FUNCTION_DECL:
+/* Nested functions are static, even though taking their address will
+	 involve a trampoline as we unnest the nested function and create
+	 the trampoline on the tree level.  */
+return arg;
+case VAR_DECL:
+return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
+	      && ! DECL_THREAD_LOCAL_P (arg)
+	      && ! DECL_DLLIMPORT_P (arg)
+	      ? arg : NULL);
+case CONST_DECL:
+return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
+	      ? arg : NULL);
+case CONSTRUCTOR:
+return TREE_STATIC (arg) ? arg : NULL;
+case LABEL_DECL:
+case STRING_CST:
+return arg;
+case COMPONENT_REF:
+/* If the thing being referenced is not a field, then it is
+	 something language specific.  */
+gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
+/* If we are referencing a bitfield, we can't evaluate an
+	 ADDR_EXPR at compile time and so it isn't a constant.  */
+if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
+	return NULL;
+return staticp (TREE_OPERAND (arg, 0));
+case BIT_FIELD_REF:
+return NULL;
+case MISALIGNED_INDIRECT_REF:
+case ALIGN_INDIRECT_REF:
+case INDIRECT_REF:
+return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
+case ARRAY_REF:
+case ARRAY_RANGE_REF:
+if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
+	  && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
+	return staticp (TREE_OPERAND (arg, 0));
+else
+	return NULL;
+case COMPOUND_LITERAL_EXPR:
+return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
+default:
+return NULL;
+}
+}
+/* Return whether OP is a DECL whose address is function-invariant.  */
+bool
+decl_address_invariant_p (const_tree op)
+{
+/* The conditions below are slightly less strict than the one in
+staticp.  */
+switch (TREE_CODE (op))
+{
+case PARM_DECL:
+case RESULT_DECL:
+case LABEL_DECL:
+case FUNCTION_DECL:
+return true;
+case VAR_DECL:
+if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
+&& !DECL_DLLIMPORT_P (op))
+|| DECL_THREAD_LOCAL_P (op)
+|| DECL_CONTEXT (op) == current_function_decl
+|| decl_function_context (op) == current_function_decl)
+return true;
+break;
+case CONST_DECL:
+if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
+|| decl_function_context (op) == current_function_decl)
+return true;
+break;
+default:
+break;
+}
+return false;
+}
+/* Return whether OP is a DECL whose address is interprocedural-invariant.  */
+bool
+decl_address_ip_invariant_p (const_tree op)
+{
+/* The conditions below are slightly less strict than the one in
+staticp.  */
+switch (TREE_CODE (op))
+{
+case LABEL_DECL:
+case FUNCTION_DECL:
+case STRING_CST:
+return true;
+case VAR_DECL:
+if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
+&& !DECL_DLLIMPORT_P (op))
+|| DECL_THREAD_LOCAL_P (op))
+return true;
+break;
+case CONST_DECL:
+if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
+return true;
+break;
+default:
+break;
+}
+return false;
+}
+/* Return true if T is function-invariant (internal function, does
+not handle arithmetic; that's handled in skip_simple_arithmetic and
+tree_invariant_p).  */
+static bool tree_invariant_p (tree t);
+static bool
+tree_invariant_p_1 (tree t)
+{
+tree op;
+if (TREE_CONSTANT (t)
+|| (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
+return true;
+switch (TREE_CODE (t))
+{
+case SAVE_EXPR:
+return true;
+case ADDR_EXPR:
+op = TREE_OPERAND (t, 0);
+while (handled_component_p (op))
+	{
+	  switch (TREE_CODE (op))
+	    {
+	    case ARRAY_REF:
+	    case ARRAY_RANGE_REF:
+	      if (!tree_invariant_p (TREE_OPERAND (op, 1))
+		  || TREE_OPERAND (op, 2) != NULL_TREE
+		  || TREE_OPERAND (op, 3) != NULL_TREE)
+		return false;
+	      break;
+	    case COMPONENT_REF:
+	      if (TREE_OPERAND (op, 2) != NULL_TREE)
+		return false;
+	      break;
+	    default:;
+	    }
+	  op = TREE_OPERAND (op, 0);
+	}
+return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
+default:
+break;
+}
+return false;
+}
+/* Return true if T is function-invariant.  */
+static bool
+tree_invariant_p (tree t)
+{
+tree inner = skip_simple_arithmetic (t);
+return tree_invariant_p_1 (inner);
+}
+/* Wrap a SAVE_EXPR around EXPR, if appropriate.
+Do this to any expression which may be used in more than one place,
+but must be evaluated only once.
+Normally, expand_expr would reevaluate the expression each time.
+Calling save_expr produces something that is evaluated and recorded
+the first time expand_expr is called on it.  Subsequent calls to
+expand_expr just reuse the recorded value.
+The call to expand_expr that generates code that actually computes
+the value is the first call *at compile time*.  Subsequent calls
+*at compile time* generate code to use the saved value.
+This produces correct result provided that *at run time* control
+always flows through the insns made by the first expand_expr
+before reaching the other places where the save_expr was evaluated.
+You, the caller of save_expr, must make sure this is so.
+Constants, and certain read-only nodes, are returned with no
+SAVE_EXPR because that is safe.  Expressions containing placeholders
+are not touched; see tree.def for an explanation of what these
+are used for.  */
+tree
+save_expr (tree expr)
+{
+tree t = fold (expr);
+tree inner;
+/* If the tree evaluates to a constant, then we don't want to hide that
+fact (i.e. this allows further folding, and direct checks for constants).
+However, a read-only object that has side effects cannot be bypassed.
+Since it is no problem to reevaluate literals, we just return the
+literal node.  */
+inner = skip_simple_arithmetic (t);
+if (TREE_CODE (inner) == ERROR_MARK)
+return inner;
+if (tree_invariant_p_1 (inner))
+return t;
+/* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
+it means that the size or offset of some field of an object depends on
+the value within another field.
+Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
+and some variable since it would then need to be both evaluated once and
+evaluated more than once.  Front-ends must assure this case cannot
+happen by surrounding any such subexpressions in their own SAVE_EXPR
+and forcing evaluation at the proper time.  */
+if (contains_placeholder_p (inner))
+return t;
+t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
+SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
+/* This expression might be placed ahead of a jump to ensure that the
+value was computed on both sides of the jump.  So make sure it isn't
+eliminated as dead.  */
+TREE_SIDE_EFFECTS (t) = 1;
+return t;
+}
+/* Look inside EXPR and into any simple arithmetic operations.  Return
+the innermost non-arithmetic node.  */
+tree
+skip_simple_arithmetic (tree expr)
+{
+tree inner;
+/* We don't care about whether this can be used as an lvalue in this
+context.  */
+while (TREE_CODE (expr) == NON_LVALUE_EXPR)
+expr = TREE_OPERAND (expr, 0);
+/* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
+a constant, it will be more efficient to not make another SAVE_EXPR since
+it will allow better simplification and GCSE will be able to merge the
+computations if they actually occur.  */
+inner = expr;
+while (1)
+{
+if (UNARY_CLASS_P (inner))
+	inner = TREE_OPERAND (inner, 0);
+else if (BINARY_CLASS_P (inner))
+	{
+	  if (tree_invariant_p (TREE_OPERAND (inner, 1)))
+	    inner = TREE_OPERAND (inner, 0);
+	  else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
+	    inner = TREE_OPERAND (inner, 1);
+	  else
+	    break;
+	}
+else
+	break;
+}
+return inner;
+}
+/* Return which tree structure is used by T.  */
+enum tree_node_structure_enum
+tree_node_structure (const_tree t)
+{
+const enum tree_code code = TREE_CODE (t);
+return tree_node_structure_for_code (code);
+}
+/* Set various status flags when building a CALL_EXPR object T.  */
+static void
+process_call_operands (tree t)
+{
+bool side_effects = TREE_SIDE_EFFECTS (t);
+bool read_only = false;
+int i = call_expr_flags (t);
+/* Calls have side-effects, except those to const or pure functions.  */
+if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
+side_effects = true;
+/* Propagate TREE_READONLY of arguments for const functions.  */
+if (i & ECF_CONST)
+read_only = true;
+if (!side_effects || read_only)
+for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
+{
+	tree op = TREE_OPERAND (t, i);
+	if (op && TREE_SIDE_EFFECTS (op))
+	  side_effects = true;
+	if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
+	  read_only = false;
+}
+TREE_SIDE_EFFECTS (t) = side_effects;
+TREE_READONLY (t) = read_only;
+}
 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
 or offset that depends on a field within a record.  */
 bool
 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
 return result;
 }
-/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
+/* Push tree EXP onto vector QUEUE if it is not already present.  */
-return a tree with all occurrences of references to F in a
-PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
+static void
-contains only arithmetic expressions or a CALL_EXPR with a
+push_without_duplicates (tree exp, VEC (tree, heap) **queue)
-PLACEHOLDER_EXPR occurring only in its arglist.  */
+{
+unsigned int i;
-tree
+tree iter;
-substitute_in_expr (tree exp, tree f, tree r)
+for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
+if (simple_cst_equal (iter, exp) == 1)
+break;
+if (!iter)
+VEC_safe_push (tree, heap, *queue, exp);
+}
+/* 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.  */
+void
+find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
 {
 enum tree_code code = TREE_CODE (exp);
-tree op0, op1, op2, op3;
+tree inner;
-tree new_tree, inner;
+int i;
 /* We handle TREE_LIST and COMPONENT_REF separately.  */
 if (code == TREE_LIST)
 {
-op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
+FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
-op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
+FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
-if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
-	return exp;
-return tree_cons (TREE_PURPOSE (exp), op1, op0);
 }
 else if (code == COMPONENT_REF)
 {
-/* If this expression is getting a value from a PLACEHOLDER_EXPR
+for (inner = TREE_OPERAND (exp, 0);
-	and it is the right field, replace it with R.  */
+	   REFERENCE_CLASS_P (inner);
-for (inner = TREE_OPERAND (exp, 0);
+	   inner = TREE_OPERAND (inner, 0))
-	  REFERENCE_CLASS_P (inner);
+	;
-	  inner = TREE_OPERAND (inner, 0))
-;
+if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
-if (TREE_CODE (inner) == PLACEHOLDER_EXPR
+	push_without_duplicates (exp, refs);
-	 && TREE_OPERAND (exp, 1) == f)
+else
-return r;
+	FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
-/* If this expression hasn't been completed let, leave it alone.  */
-if (TREE_CODE (inner) == PLACEHOLDER_EXPR && TREE_TYPE (inner) == 0)
-return exp;
-op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
-if (op0 == TREE_OPERAND (exp, 0))
-return exp;
-new_tree = fold_build3 (COMPONENT_REF, TREE_TYPE (exp),
-			op0, TREE_OPERAND (exp, 1), NULL_TREE);
 }
 else
 switch (TREE_CODE_CLASS (code))
 {
 case tcc_constant:
+	break;
 case tcc_declaration:
-	return exp;
+	/* Variables allocated to static storage can stay.  */
+if (!TREE_STATIC (exp))
+	  push_without_duplicates (exp, refs);
+	break;
+case tcc_expression:
+	/* This is the pattern built in ada/make_aligning_type.  */
+	if (code == ADDR_EXPR
+	    && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
+	  {
+	    push_without_duplicates (exp, refs);
+	    break;
+	  }
+/* Fall through...  */
 case tcc_exceptional:
 case tcc_unary:
 case tcc_binary:
 case tcc_comparison:
+case tcc_reference:
+	for (i = 0; i < TREE_CODE_LENGTH (code); i++)
+	  FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
+	break;
+case tcc_vl_exp:
+	for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
+	  FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
+	break;
+default:
+	gcc_unreachable ();
+}
+}
+/* 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.  */
+tree
+substitute_in_expr (tree exp, tree f, tree r)
+{
+enum tree_code code = TREE_CODE (exp);
+tree op0, op1, op2, op3;
+tree new_tree;
+/* We handle TREE_LIST and COMPONENT_REF separately.  */
+if (code == TREE_LIST)
+{
+op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
+op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
+if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
+	return exp;
+return tree_cons (TREE_PURPOSE (exp), op1, op0);
+}
+else if (code == COMPONENT_REF)
+{
+tree inner;
+/* If this expression is getting a value from a PLACEHOLDER_EXPR
+	 and it is the right field, replace it with R.  */
+for (inner = TREE_OPERAND (exp, 0);
+	   REFERENCE_CLASS_P (inner);
+	   inner = TREE_OPERAND (inner, 0))
+	;
+/* The field.  */
+op1 = TREE_OPERAND (exp, 1);
+if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
+	return r;
+/* If this expression hasn't been completed let, leave it alone.  */
+if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
+	return exp;
+op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
+if (op0 == TREE_OPERAND (exp, 0))
+	return exp;
+new_tree
+	= fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
+}
+else
+switch (TREE_CODE_CLASS (code))
+{
+case tcc_constant:
+	return exp;
+case tcc_declaration:
+	if (exp == f)
+	  return r;
+	else
+	  return exp;
 case tcc_expression:
+	if (exp == f)
+	  return r;
+/* Fall through...  */
+case tcc_exceptional:
+case tcc_unary:
+case tcc_binary:
+case tcc_comparison:
 case tcc_reference:
 	switch (TREE_CODE_LENGTH (code))
 	  {
 	  case 0:
 	    return exp;
 	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
 		&& op2 == TREE_OPERAND (exp, 2)
 		&& op3 == TREE_OPERAND (exp, 3))
 	      return exp;
-	    new_tree = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
+	    new_tree
+	      = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
 	    break;
 	  default:
 	    gcc_unreachable ();
 	  }
 	break;
 case tcc_vl_exp:
 	{
-	  tree copy = NULL_TREE;
 	  int i;
+	  new_tree = NULL_TREE;
+	  /* If we are trying to replace F with a constant, inline back
+	     functions which do nothing else than computing a value from
+	     the arguments they are passed.  This makes it possible to
+	     fold partially or entirely the replacement expression.  */
+	  if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
+	    {
+	      tree t = maybe_inline_call_in_expr (exp);
+	      if (t)
+		return SUBSTITUTE_IN_EXPR (t, f, r);
+	    }
 	  for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
 	    {
 	      tree op = TREE_OPERAND (exp, i);
 	      tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
 	      if (new_op != op)
 		{
-		  if (!copy)
+		  if (!new_tree)
-		    copy = copy_node (exp);
+		    new_tree = copy_node (exp);
-		  TREE_OPERAND (copy, i) = new_op;
+		  TREE_OPERAND (new_tree, i) = new_op;
 		}
 	    }
-	  if (copy)
+	  if (new_tree)
-	    new_tree = fold (copy);
+	    {
+	      new_tree = fold (new_tree);
+	      if (TREE_CODE (new_tree) == CALL_EXPR)
+		process_call_operands (new_tree);
+	    }
 	  else
 	    return exp;
 	}
 	break;
 default:
 	gcc_unreachable ();
 }
-TREE_READONLY (new_tree) = TREE_READONLY (exp);
+TREE_READONLY (new_tree) |= TREE_READONLY (exp);
 return new_tree;
 }
 /* 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.  */
 tree
 substitute_placeholder_in_expr (tree exp, tree obj)
 {
 enum tree_code code = TREE_CODE (exp);
 tree op0, op1, op2, op3;
+tree new_tree;
 /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
 in the chain of OBJ.  */
 if (code == PLACEHOLDER_EXPR)
 {
 	  case 1:
 	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
 	    if (op0 == TREE_OPERAND (exp, 0))
 	      return exp;
-	    else
-	      return fold_build1 (code, TREE_TYPE (exp), op0);
+	    new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
+	    break;
 	  case 2:
 	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
 	    op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
 	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
 	      return exp;
-	    else
-	      return fold_build2 (code, TREE_TYPE (exp), op0, op1);
+	    new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
+	    break;
 	  case 3:
 	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
 	    op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
 	    op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
 	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
 		&& op2 == TREE_OPERAND (exp, 2))
 	      return exp;
-	    else
-	      return fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
+	    new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
+	    break;
 	  case 4:
 	    op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
 	    op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
 	    op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
 	    if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
 		&& op2 == TREE_OPERAND (exp, 2)
 		&& op3 == TREE_OPERAND (exp, 3))
 	      return exp;
-	    else
-	      return fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
+	    new_tree
+	      = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
+	    break;
 	  default:
 	    gcc_unreachable ();
 	  }
 	break;
 case tcc_vl_exp:
 	{
-	  tree copy = NULL_TREE;
 	  int i;
+	  new_tree = NULL_TREE;
 	  for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
 	    {
 	      tree op = TREE_OPERAND (exp, i);
 	      tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
 	      if (new_op != op)
 		{
-		  if (!copy)
+		  if (!new_tree)
-		    copy = copy_node (exp);
+		    new_tree = copy_node (exp);
-		  TREE_OPERAND (copy, i) = new_op;
+		  TREE_OPERAND (new_tree, i) = new_op;
 		}
 	    }
-	  if (copy)
+	  if (new_tree)
-	    return fold (copy);
+	    {
+	      new_tree = fold (new_tree);
+	      if (TREE_CODE (new_tree) == CALL_EXPR)
+		process_call_operands (new_tree);
+	    }
 	  else
 	    return exp;
 	}
+	break;
 default:
 	gcc_unreachable ();
 }
+TREE_READONLY (new_tree) |= TREE_READONLY (exp);
+return new_tree;
 }
 /* Stabilize a reference so that we can use it any number of times
 without causing its operands to be evaluated more than once.
 Returns the stabilized reference.  This works by means of save_expr,
 }
 return t;
 }
-#define PROCESS_ARG(N)			\
+#define PROCESS_ARG(N)				\
-do {					\
+do {						\
-TREE_OPERAND (t, N) = arg##N;	\
+TREE_OPERAND (t, N) = arg##N;		\
-if (arg##N &&!TYPE_P (arg##N))	\
+if (arg##N &&!TYPE_P (arg##N))		\
-{					\
+{						\
-if (TREE_SIDE_EFFECTS (arg##N))	\
+if (TREE_SIDE_EFFECTS (arg##N))		\
-	  side_effects = 1;		\
+	  side_effects = 1;			\
-if (!TREE_READONLY (arg##N))	\
+if (!TREE_READONLY (arg##N)		\
-	  read_only = 0;		\
+	    && !CONSTANT_CLASS_P (arg##N))	\
-if (!TREE_CONSTANT (arg##N))	\
+	  read_only = 0;			\
-	  constant = 0;			\
+if (!TREE_CONSTANT (arg##N))		\
-}					\
+	  constant = 0;				\
+}						\
 } while (0)
 tree
 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
 {
 gcc_assert (TREE_CODE_LENGTH (code) == 3);
 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
 t = make_node_stat (code PASS_MEM_STAT);
 TREE_TYPE (t) = tt;
+read_only = 1;
 /* As a special exception, if COND_EXPR has NULL branches, we
 assume that it is a gimple statement and always consider
 it to have side effects.  */
 if (code == COND_EXPR
 PROCESS_ARG(0);
 PROCESS_ARG(1);
 PROCESS_ARG(2);
+if (code == COND_EXPR)
+TREE_READONLY (t) = read_only;
 TREE_SIDE_EFFECTS (t) = side_effects;
 TREE_THIS_VOLATILE (t)
 = (TREE_CODE_CLASS (code) == tcc_reference
 && arg0 && TREE_THIS_VOLATILE (arg0));
 return t;
 }
 tree
-build7_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
+build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
-	     tree arg2, tree arg3, tree arg4, tree arg5,
+	     tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
-	     tree arg6 MEM_STAT_DECL)
 {
 bool constant, read_only, side_effects;
 tree t;
 gcc_assert (code == TARGET_MEM_REF);
 PROCESS_ARG(1);
 PROCESS_ARG(2);
 PROCESS_ARG(3);
 PROCESS_ARG(4);
 PROCESS_ARG(5);
-PROCESS_ARG(6);
 TREE_SIDE_EFFECTS (t) = side_effects;
 TREE_THIS_VOLATILE (t) = 0;
 return t;
 CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
 for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
 CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
 return t;
 }
+/* Similar to build_nt, but for creating a CALL_EXPR object with a
+tree VEC.  */
+tree
+build_nt_call_vec (tree fn, VEC(tree,gc) *args)
+{
+tree ret, t;
+unsigned int ix;
+ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
+CALL_EXPR_FN (ret) = fn;
+CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
+for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
+CALL_EXPR_ARG (ret, ix) = t;
+return ret;
+}
 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
 We do NOT enter this node in any sort of symbol table.
+LOC is the location of the decl.
 layout_decl is used to set up the decl's storage layout.
 Other slots are initialized to 0 or null pointers.  */
 tree
-build_decl_stat (enum tree_code code, tree name, tree type MEM_STAT_DECL)
+build_decl_stat (location_t loc, enum tree_code code, tree name,
+		 tree type MEM_STAT_DECL)
 {
 tree t;
 t = make_node_stat (code PASS_MEM_STAT);
+DECL_SOURCE_LOCATION (t) = loc;
 /*  if (type == error_mark_node)
 type = integer_type_node; */
 /* That is not done, deliberately, so that having error_mark_node
 as the type can suppress useless errors in the use of this variable.  */
 tree
 build_fn_decl (const char *name, tree type)
 {
 tree id = get_identifier (name);
-tree decl = build_decl (FUNCTION_DECL, id, type);
+tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
 DECL_EXTERNAL (decl) = 1;
 TREE_PUBLIC (decl) = 1;
 DECL_ARTIFICIAL (decl) = 1;
 TREE_NOTHROW (decl) = 1;
 expanded_location
 expand_location (source_location loc)
 {
 expanded_location xloc;
-if (loc == 0)
+if (loc <= BUILTINS_LOCATION)
 {
-xloc.file = NULL;
+xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>");
 xloc.line = 0;
 xloc.column = 0;
 xloc.sysp = 0;
 }
 else
 };
 return xloc;
 }
-/* Source location accessor functions.  */
+/* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
+LOC is the location to use in tree T.  */
 void
-set_expr_locus (tree node, source_location *loc)
+protected_set_expr_location (tree t, location_t loc)
-{
-if (loc == NULL)
-EXPR_CHECK (node)->exp.locus = UNKNOWN_LOCATION;
-else
-EXPR_CHECK (node)->exp.locus = *loc;
-}
-/* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
-LOC is the location to use in tree T.  */
-void protected_set_expr_location (tree t, location_t loc)
 {
 if (t && CAN_HAVE_LOCATION_P (t))
 SET_EXPR_LOCATION (t, loc);
 }
 mix (a, val, val2);
 return val2;
 }
-/* Produce good hash value combining PTR and VAL2.  */
-static inline hashval_t
-iterative_hash_pointer (const void *ptr, hashval_t val2)
-{
-if (sizeof (ptr) == sizeof (hashval_t))
-return iterative_hash_hashval_t ((size_t) ptr, val2);
-else
-{
-hashval_t a = (hashval_t) (size_t) ptr;
-/* Avoid warnings about shifting of more than the width of the type on
-hosts that won't execute this path.  */
-int zero = 0;
-hashval_t b = (hashval_t) ((size_t) ptr >> (sizeof (hashval_t) * 8 + zero));
-mix (a, b, val2);
-return val2;
-}
-}
 /* Produce good hash value combining VAL and VAL2.  */
-static inline hashval_t
+hashval_t
 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
 {
 if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
 return iterative_hash_hashval_t (val, val2);
 else
 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
 is ATTRIBUTE and its qualifiers are QUALS.
 Record such modified types already made so we don't make duplicates.  */
-static tree
+tree
 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
 {
 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
 {
 hashval_t hashcode = 0;
 {
 return build_type_attribute_qual_variant (ttype, attribute,
 					    TYPE_QUALS (ttype));
 }
+/* Reset all the fields in a binfo node BINFO.  We only keep
+BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
+static void
+free_lang_data_in_binfo (tree binfo)
+{
+unsigned i;
+tree t;
+gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
+BINFO_VTABLE (binfo) = NULL_TREE;
+BINFO_BASE_ACCESSES (binfo) = NULL;
+BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
+BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
+for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (binfo), i, t); i++)
+free_lang_data_in_binfo (t);
+}
+/* Reset all language specific information still present in TYPE.  */
+static void
+free_lang_data_in_type (tree type)
+{
+gcc_assert (TYPE_P (type));
+/* Give the FE a chance to remove its own data first.  */
+lang_hooks.free_lang_data (type);
+TREE_LANG_FLAG_0 (type) = 0;
+TREE_LANG_FLAG_1 (type) = 0;
+TREE_LANG_FLAG_2 (type) = 0;
+TREE_LANG_FLAG_3 (type) = 0;
+TREE_LANG_FLAG_4 (type) = 0;
+TREE_LANG_FLAG_5 (type) = 0;
+TREE_LANG_FLAG_6 (type) = 0;
+if (TREE_CODE (type) == FUNCTION_TYPE)
+{
+/* Remove the const and volatile qualifiers from arguments.  The
+	 C++ front end removes them, but the C front end does not,
+	 leading to false ODR violation errors when merging two
+	 instances of the same function signature compiled by
+	 different front ends.  */
+tree p;
+for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
+	{
+	  tree arg_type = TREE_VALUE (p);
+	  if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
+	    {
+	      int quals = TYPE_QUALS (arg_type)
+			  & ~TYPE_QUAL_CONST
+			  & ~TYPE_QUAL_VOLATILE;
+	      TREE_VALUE (p) = build_qualified_type (arg_type, quals);
+	      free_lang_data_in_type (TREE_VALUE (p));
+	    }
+	}
+}
+/* Remove members that are not actually FIELD_DECLs from the field
+list of an aggregate.  These occur in C++.  */
+if (RECORD_OR_UNION_TYPE_P (type))
+{
+tree prev, member;
+/* Note that TYPE_FIELDS can be shared across distinct
+	 TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
+	 to be removed, we cannot set its TREE_CHAIN to NULL.
+	 Otherwise, we would not be able to find all the other fields
+	 in the other instances of this TREE_TYPE.
+	 This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
+prev = NULL_TREE;
+member = TYPE_FIELDS (type);
+while (member)
+	{
+	  if (TREE_CODE (member) == FIELD_DECL)
+	    {
+	      if (prev)
+		TREE_CHAIN (prev) = member;
+	      else
+		TYPE_FIELDS (type) = member;
+	      prev = member;
+	    }
+	  member = TREE_CHAIN (member);
+	}
+if (prev)
+	TREE_CHAIN (prev) = NULL_TREE;
+else
+	TYPE_FIELDS (type) = NULL_TREE;
+TYPE_METHODS (type) = NULL_TREE;
+if (TYPE_BINFO (type))
+	free_lang_data_in_binfo (TYPE_BINFO (type));
+}
+else
+{
+/* For non-aggregate types, clear out the language slot (which
+	 overloads TYPE_BINFO).  */
+TYPE_LANG_SLOT_1 (type) = NULL_TREE;
+}
+TYPE_CONTEXT (type) = NULL_TREE;
+if (debug_info_level < DINFO_LEVEL_TERSE)
+TYPE_STUB_DECL (type) = NULL_TREE;
+}
+/* Return true if DECL may need an assembler name to be set.  */
+static inline bool
+need_assembler_name_p (tree decl)
+{
+/* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
+if (TREE_CODE (decl) != FUNCTION_DECL
+&& TREE_CODE (decl) != VAR_DECL)
+return false;
+/* If DECL already has its assembler name set, it does not need a
+new one.  */
+if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
+|| DECL_ASSEMBLER_NAME_SET_P (decl))
+return false;
+/* Abstract decls do not need an assembler name.  */
+if (DECL_ABSTRACT (decl))
+return false;
+/* For VAR_DECLs, only static, public and external symbols need an
+assembler name.  */
+if (TREE_CODE (decl) == VAR_DECL
+&& !TREE_STATIC (decl)
+&& !TREE_PUBLIC (decl)
+&& !DECL_EXTERNAL (decl))
+return false;
+if (TREE_CODE (decl) == FUNCTION_DECL)
+{
+/* Do not set assembler name on builtins.  Allow RTL expansion to
+	 decide whether to expand inline or via a regular call.  */
+if (DECL_BUILT_IN (decl)
+	  && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
+	return false;
+/* Functions represented in the callgraph need an assembler name.  */
+if (cgraph_get_node (decl) != NULL)
+	return true;
+/* Unused and not public functions don't need an assembler name.  */
+if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
+	return false;
+}
+return true;
+}
+/* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
+variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
+in BLOCK that is not in LOCALS is removed.  */
+static void
+free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
+{
+tree *tp, t;
+tp = &BLOCK_VARS (block);
+while (*tp)
+{
+if (!pointer_set_contains (locals, *tp))
+	*tp = TREE_CHAIN (*tp);
+else
+	tp = &TREE_CHAIN (*tp);
+}
+for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
+free_lang_data_in_block (fn, t, locals);
+}
+/* Reset all language specific information still present in symbol
+DECL.  */
+static void
+free_lang_data_in_decl (tree decl)
+{
+gcc_assert (DECL_P (decl));
+/* Give the FE a chance to remove its own data first.  */
+lang_hooks.free_lang_data (decl);
+TREE_LANG_FLAG_0 (decl) = 0;
+TREE_LANG_FLAG_1 (decl) = 0;
+TREE_LANG_FLAG_2 (decl) = 0;
+TREE_LANG_FLAG_3 (decl) = 0;
+TREE_LANG_FLAG_4 (decl) = 0;
+TREE_LANG_FLAG_5 (decl) = 0;
+TREE_LANG_FLAG_6 (decl) = 0;
+/* Identifiers need not have a type.  */
+if (DECL_NAME (decl))
+TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
+/* Ignore any intervening types, because we are going to clear their
+TYPE_CONTEXT fields.  */
+if (TREE_CODE (decl) != FIELD_DECL)
+DECL_CONTEXT (decl) = decl_function_context (decl);
+if (DECL_CONTEXT (decl)
+&& TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
+DECL_CONTEXT (decl) = NULL_TREE;
+if (TREE_CODE (decl) == VAR_DECL)
+{
+tree context = DECL_CONTEXT (decl);
+if (context)
+{
+	 enum tree_code code = TREE_CODE (context);
+	 if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
+	   {
+	     /* Do not clear the decl context here, that will promote
+	        all vars to global ones.  */
+	     DECL_INITIAL (decl) = NULL_TREE;
+	   }
+	 if (TREE_STATIC (decl))
+	   DECL_CONTEXT (decl) = NULL_TREE;
+}
+}
+/* ???  We could free non-constant DECL_SIZE, DECL_SIZE_UNIT
+and DECL_FIELD_OFFSET.  But it's cheap enough to not do
+that and refrain from adding workarounds to dwarf2out.c  */
+/* DECL_FCONTEXT is only used for debug info generation.  */
+if (TREE_CODE (decl) == FIELD_DECL
+&& debug_info_level < DINFO_LEVEL_TERSE)
+DECL_FCONTEXT (decl) = NULL_TREE;
+if (TREE_CODE (decl) == FUNCTION_DECL)
+{
+if (gimple_has_body_p (decl))
+	{
+	  tree t;
+	  struct pointer_set_t *locals;
+	  /* If DECL has a gimple body, then the context for its
+	     arguments must be DECL.  Otherwise, it doesn't really
+	     matter, as we will not be emitting any code for DECL.  In
+	     general, there may be other instances of DECL created by
+	     the front end and since PARM_DECLs are generally shared,
+	     their DECL_CONTEXT changes as the replicas of DECL are
+	     created.  The only time where DECL_CONTEXT is important
+	     is for the FUNCTION_DECLs that have a gimple body (since
+	     the PARM_DECL will be used in the function's body).  */
+	  for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
+	    DECL_CONTEXT (t) = decl;
+	  /* Collect all the symbols declared in DECL.  */
+	  locals = pointer_set_create ();
+	  t = DECL_STRUCT_FUNCTION (decl)->local_decls;
+	  for (; t; t = TREE_CHAIN (t))
+	    {
+	      pointer_set_insert (locals, TREE_VALUE (t));
+	      /* All the local symbols should have DECL as their
+		 context.  */
+	      DECL_CONTEXT (TREE_VALUE (t)) = decl;
+	    }
+	  /* Get rid of any decl not in local_decls.  */
+	  free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
+	  pointer_set_destroy (locals);
+	}
+/* DECL_SAVED_TREE holds the GENERIC representation for DECL.
+	 At this point, it is not needed anymore.  */
+DECL_SAVED_TREE (decl) = NULL_TREE;
+}
+else if (TREE_CODE (decl) == VAR_DECL)
+{
+tree expr = DECL_DEBUG_EXPR (decl);
+if (expr
+	  && TREE_CODE (expr) == VAR_DECL
+	  && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
+	SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
+if (DECL_EXTERNAL (decl)
+	  && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
+	DECL_INITIAL (decl) = NULL_TREE;
+}
+else if (TREE_CODE (decl) == TYPE_DECL)
+{
+DECL_INITIAL (decl) = NULL_TREE;
+/* DECL_CONTEXT is overloaded as DECL_FIELD_CONTEXT for
+	 FIELD_DECLs, which should be preserved.  Otherwise,
+	 we shouldn't be concerned with source-level lexical
+	 nesting beyond this point. */
+DECL_CONTEXT (decl) = NULL_TREE;
+}
+}
+/* Data used when collecting DECLs and TYPEs for language data removal.  */
+struct free_lang_data_d
+{
+/* Worklist to avoid excessive recursion.  */
+VEC(tree,heap) *worklist;
+/* Set of traversed objects.  Used to avoid duplicate visits.  */
+struct pointer_set_t *pset;
+/* Array of symbols to process with free_lang_data_in_decl.  */
+VEC(tree,heap) *decls;
+/* Array of types to process with free_lang_data_in_type.  */
+VEC(tree,heap) *types;
+};
+/* Save all language fields needed to generate proper debug information
+for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
+static void
+save_debug_info_for_decl (tree t)
+{
+/*struct saved_debug_info_d *sdi;*/
+gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
+/* FIXME.  Partial implementation for saving debug info removed.  */
+}
+/* Save all language fields needed to generate proper debug information
+for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
+static void
+save_debug_info_for_type (tree t)
+{
+/*struct saved_debug_info_d *sdi;*/
+gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
+/* FIXME.  Partial implementation for saving debug info removed.  */
+}
+/* Add type or decl T to one of the list of tree nodes that need their
+language data removed.  The lists are held inside FLD.  */
+static void
+add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
+{
+if (DECL_P (t))
+{
+VEC_safe_push (tree, heap, fld->decls, t);
+if (debug_info_level > DINFO_LEVEL_TERSE)
+	save_debug_info_for_decl (t);
+}
+else if (TYPE_P (t))
+{
+VEC_safe_push (tree, heap, fld->types, t);
+if (debug_info_level > DINFO_LEVEL_TERSE)
+	save_debug_info_for_type (t);
+}
+else
+gcc_unreachable ();
+}
+/* Push tree node T into FLD->WORKLIST.  */
+static inline void
+fld_worklist_push (tree t, struct free_lang_data_d *fld)
+{
+if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
+VEC_safe_push (tree, heap, fld->worklist, (t));
+}
+/* Operand callback helper for free_lang_data_in_node.  *TP is the
+subtree operand being considered.  */
+static tree
+find_decls_types_r (tree *tp, int *ws, void *data)
+{
+tree t = *tp;
+struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
+if (TREE_CODE (t) == TREE_LIST)
+return NULL_TREE;
+/* Language specific nodes will be removed, so there is no need
+to gather anything under them.  */
+if (is_lang_specific (t))
+{
+*ws = 0;
+return NULL_TREE;
+}
+if (DECL_P (t))
+{
+/* Note that walk_tree does not traverse every possible field in
+	 decls, so we have to do our own traversals here.  */
+add_tree_to_fld_list (t, fld);
+fld_worklist_push (DECL_NAME (t), fld);
+fld_worklist_push (DECL_CONTEXT (t), fld);
+fld_worklist_push (DECL_SIZE (t), fld);
+fld_worklist_push (DECL_SIZE_UNIT (t), fld);
+/* We are going to remove everything under DECL_INITIAL for
+	 TYPE_DECLs.  No point walking them.  */
+if (TREE_CODE (t) != TYPE_DECL)
+	fld_worklist_push (DECL_INITIAL (t), fld);
+fld_worklist_push (DECL_ATTRIBUTES (t), fld);
+fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
+if (TREE_CODE (t) == FUNCTION_DECL)
+	{
+	  fld_worklist_push (DECL_ARGUMENTS (t), fld);
+	  fld_worklist_push (DECL_RESULT (t), fld);
+	}
+else if (TREE_CODE (t) == TYPE_DECL)
+	{
+	  fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
+	  fld_worklist_push (DECL_VINDEX (t), fld);
+	}
+else if (TREE_CODE (t) == FIELD_DECL)
+	{
+	  fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
+	  fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
+	  fld_worklist_push (DECL_QUALIFIER (t), fld);
+	  fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
+	  fld_worklist_push (DECL_FCONTEXT (t), fld);
+	}
+else if (TREE_CODE (t) == VAR_DECL)
+	{
+	  fld_worklist_push (DECL_SECTION_NAME (t), fld);
+	  fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
+	}
+if (TREE_CODE (t) != FIELD_DECL)
+	fld_worklist_push (TREE_CHAIN (t), fld);
+*ws = 0;
+}
+else if (TYPE_P (t))
+{
+/* Note that walk_tree does not traverse every possible field in
+	 types, so we have to do our own traversals here.  */
+add_tree_to_fld_list (t, fld);
+if (!RECORD_OR_UNION_TYPE_P (t))
+	fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
+fld_worklist_push (TYPE_SIZE (t), fld);
+fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
+fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
+fld_worklist_push (TYPE_POINTER_TO (t), fld);
+fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
+fld_worklist_push (TYPE_NAME (t), fld);
+fld_worklist_push (TYPE_MINVAL (t), fld);
+if (!RECORD_OR_UNION_TYPE_P (t))
+	fld_worklist_push (TYPE_MAXVAL (t), fld);
+fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
+fld_worklist_push (TYPE_NEXT_VARIANT (t), fld);
+fld_worklist_push (TYPE_CONTEXT (t), fld);
+fld_worklist_push (TYPE_CANONICAL (t), fld);
+if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
+	{
+	  unsigned i;
+	  tree tem;
+	  for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
+				   i, tem); ++i)
+	    fld_worklist_push (TREE_TYPE (tem), fld);
+	  tem = BINFO_VIRTUALS (TYPE_BINFO (t));
+	  if (tem
+	      /* The Java FE overloads BINFO_VIRTUALS for its own purpose.  */
+	      && TREE_CODE (tem) == TREE_LIST)
+	    do
+	      {
+		fld_worklist_push (TREE_VALUE (tem), fld);
+		tem = TREE_CHAIN (tem);
+	      }
+	    while (tem);
+	}
+if (RECORD_OR_UNION_TYPE_P (t))
+	{
+	  tree tem;
+	  /* Push all TYPE_FIELDS - there can be interleaving interesting
+	     and non-interesting things.  */
+	  tem = TYPE_FIELDS (t);
+	  while (tem)
+	    {
+	      if (TREE_CODE (tem) == FIELD_DECL)
+		fld_worklist_push (tem, fld);
+	      tem = TREE_CHAIN (tem);
+	    }
+	}
+fld_worklist_push (TREE_CHAIN (t), fld);
+*ws = 0;
+}
+fld_worklist_push (TREE_TYPE (t), fld);
+return NULL_TREE;
+}
+/* Find decls and types in T.  */
+static void
+find_decls_types (tree t, struct free_lang_data_d *fld)
+{
+while (1)
+{
+if (!pointer_set_contains (fld->pset, t))
+	walk_tree (&t, find_decls_types_r, fld, fld->pset);
+if (VEC_empty (tree, fld->worklist))
+	break;
+t = VEC_pop (tree, fld->worklist);
+}
+}
+/* Translate all the types in LIST with the corresponding runtime
+types.  */
+static tree
+get_eh_types_for_runtime (tree list)
+{
+tree head, prev;
+if (list == NULL_TREE)
+return NULL_TREE;
+head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
+prev = head;
+list = TREE_CHAIN (list);
+while (list)
+{
+tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
+TREE_CHAIN (prev) = n;
+prev = TREE_CHAIN (prev);
+list = TREE_CHAIN (list);
+}
+return head;
+}
+/* Find decls and types referenced in EH region R and store them in
+FLD->DECLS and FLD->TYPES.  */
+static void
+find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
+{
+switch (r->type)
+{
+case ERT_CLEANUP:
+break;
+case ERT_TRY:
+{
+	eh_catch c;
+	/* The types referenced in each catch must first be changed to the
+	   EH types used at runtime.  This removes references to FE types
+	   in the region.  */
+	for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
+	  {
+	    c->type_list = get_eh_types_for_runtime (c->type_list);
+	    walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
+	  }
+}
+break;
+case ERT_ALLOWED_EXCEPTIONS:
+r->u.allowed.type_list
+	= get_eh_types_for_runtime (r->u.allowed.type_list);
+walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
+break;
+case ERT_MUST_NOT_THROW:
+walk_tree (&r->u.must_not_throw.failure_decl,
+		 find_decls_types_r, fld, fld->pset);
+break;
+}
+}
+/* Find decls and types referenced in cgraph node N and store them in
+FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
+look for *every* kind of DECL and TYPE node reachable from N,
+including those embedded inside types and decls (i.e,, TYPE_DECLs,
+NAMESPACE_DECLs, etc).  */
+static void
+find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
+{
+basic_block bb;
+struct function *fn;
+tree t;
+find_decls_types (n->decl, fld);
+if (!gimple_has_body_p (n->decl))
+return;
+gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
+fn = DECL_STRUCT_FUNCTION (n->decl);
+/* Traverse locals. */
+for (t = fn->local_decls; t; t = TREE_CHAIN (t))
+find_decls_types (TREE_VALUE (t), fld);
+/* Traverse EH regions in FN.  */
+{
+eh_region r;
+FOR_ALL_EH_REGION_FN (r, fn)
+find_decls_types_in_eh_region (r, fld);
+}
+/* Traverse every statement in FN.  */
+FOR_EACH_BB_FN (bb, fn)
+{
+gimple_stmt_iterator si;
+unsigned i;
+for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
+	{
+	  gimple phi = gsi_stmt (si);
+	  for (i = 0; i < gimple_phi_num_args (phi); i++)
+	    {
+	      tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
+	      find_decls_types (*arg_p, fld);
+	    }
+	}
+for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
+	{
+	  gimple stmt = gsi_stmt (si);
+	  for (i = 0; i < gimple_num_ops (stmt); i++)
+	    {
+	      tree arg = gimple_op (stmt, i);
+	      find_decls_types (arg, fld);
+	    }
+	}
+}
+}
+/* Find decls and types referenced in varpool node N and store them in
+FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
+look for *every* kind of DECL and TYPE node reachable from N,
+including those embedded inside types and decls (i.e,, TYPE_DECLs,
+NAMESPACE_DECLs, etc).  */
+static void
+find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
+{
+find_decls_types (v->decl, fld);
+}
+/* Free language specific information for every operand and expression
+in every node of the call graph.  This process operates in three stages:
+1- Every callgraph node and varpool node is traversed looking for
+decls and types embedded in them.  This is a more exhaustive
+search than that done by find_referenced_vars, because it will
+also collect individual fields, decls embedded in types, etc.
+2- All the decls found are sent to free_lang_data_in_decl.
+3- All the types found are sent to free_lang_data_in_type.
+The ordering between decls and types is important because
+free_lang_data_in_decl sets assembler names, which includes
+mangling.  So types cannot be freed up until assembler names have
+been set up.  */
+static void
+free_lang_data_in_cgraph (void)
+{
+struct cgraph_node *n;
+struct varpool_node *v;
+struct free_lang_data_d fld;
+tree t;
+unsigned i;
+alias_pair *p;
+/* Initialize sets and arrays to store referenced decls and types.  */
+fld.pset = pointer_set_create ();
+fld.worklist = NULL;
+fld.decls = VEC_alloc (tree, heap, 100);
+fld.types = VEC_alloc (tree, heap, 100);
+/* Find decls and types in the body of every function in the callgraph.  */
+for (n = cgraph_nodes; n; n = n->next)
+find_decls_types_in_node (n, &fld);
+for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
+find_decls_types (p->decl, &fld);
+/* Find decls and types in every varpool symbol.  */
+for (v = varpool_nodes_queue; v; v = v->next_needed)
+find_decls_types_in_var (v, &fld);
+/* Set the assembler name on every decl found.  We need to do this
+now because free_lang_data_in_decl will invalidate data needed
+for mangling.  This breaks mangling on interdependent decls.  */
+for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
+if (need_assembler_name_p (t))
+{
+	/* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
+	   diagnostics that use input_location to show locus
+	   information.  The problem here is that, at this point,
+	   input_location is generally anchored to the end of the file
+	   (since the parser is long gone), so we don't have a good
+	   position to pin it to.
+	   To alleviate this problem, this uses the location of T's
+	   declaration.  Examples of this are
+	   testsuite/g++.dg/template/cond2.C and
+	   testsuite/g++.dg/template/pr35240.C.  */
+	location_t saved_location = input_location;
+	input_location = DECL_SOURCE_LOCATION (t);
+	decl_assembler_name (t);
+	input_location = saved_location;
+}
+/* Traverse every decl found freeing its language data.  */
+for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
+free_lang_data_in_decl (t);
+/* Traverse every type found freeing its language data.  */
+for (i = 0; VEC_iterate (tree, fld.types, i, t); i++)
+free_lang_data_in_type (t);
+pointer_set_destroy (fld.pset);
+VEC_free (tree, heap, fld.worklist);
+VEC_free (tree, heap, fld.decls);
+VEC_free (tree, heap, fld.types);
+}
+/* Free resources that are used by FE but are not needed once they are done. */
+static unsigned
+free_lang_data (void)
+{
+unsigned i;
+/* If we are the LTO frontend we have freed lang-specific data already.  */
+if (in_lto_p
+|| !flag_generate_lto)
+return 0;
+/* Allocate and assign alias sets to the standard integer types
+while the slots are still in the way the frontends generated them.  */
+for (i = 0; i < itk_none; ++i)
+if (integer_types[i])
+TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
+/* Traverse the IL resetting language specific information for
+operands, expressions, etc.  */
+free_lang_data_in_cgraph ();
+/* Create gimple variants for common types.  */
+ptrdiff_type_node = integer_type_node;
+fileptr_type_node = ptr_type_node;
+if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
+|| (TYPE_MODE (boolean_type_node)
+	  != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
+|| TYPE_PRECISION (boolean_type_node) != 1
+|| !TYPE_UNSIGNED (boolean_type_node))
+{
+boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
+TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
+TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
+TYPE_PRECISION (boolean_type_node) = 1;
+boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
+boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
+}
+/* Unify char_type_node with its properly signed variant.  */
+if (TYPE_UNSIGNED (char_type_node))
+unsigned_char_type_node = char_type_node;
+else
+signed_char_type_node = char_type_node;
+/* Reset some langhooks.  Do not reset types_compatible_p, it may
+still be used indirectly via the get_alias_set langhook.  */
+lang_hooks.callgraph.analyze_expr = NULL;
+lang_hooks.dwarf_name = lhd_dwarf_name;
+lang_hooks.decl_printable_name = gimple_decl_printable_name;
+lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
+lang_hooks.fold_obj_type_ref = gimple_fold_obj_type_ref;
+/* Reset diagnostic machinery.  */
+diagnostic_starter (global_dc) = default_diagnostic_starter;
+diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
+diagnostic_format_decoder (global_dc) = default_tree_printer;
+return 0;
+}
+struct simple_ipa_opt_pass pass_ipa_free_lang_data =
+{
+{
+SIMPLE_IPA_PASS,
+"*free_lang_data",			/* name */
+NULL,					/* gate */
+free_lang_data,			/* execute */
+NULL,					/* sub */
+NULL,					/* next */
+0,					/* static_pass_number */
+TV_IPA_FREE_LANG_DATA,		/* tv_id */
+0,	                                /* properties_required */
+0,					/* properties_provided */
+0,					/* properties_destroyed */
+0,					/* todo_flags_start */
+TODO_ggc_collect			/* todo_flags_finish */
+}
+};
 /* Return nonzero if IDENT is a valid name for attribute ATTR,
 or zero if not.
 We try both `text' and `__text__', ATTR may be either one.  */
 /* ??? It might be a reasonable simplification to require ATTR to be only
 int ident_len;
 const char *p;
 if (TREE_CODE (ident) != IDENTIFIER_NODE)
 return 0;
 p = IDENTIFIER_POINTER (ident);
 ident_len = IDENTIFIER_LENGTH (ident);
 if (ident_len == attr_len
 && strcmp (attr, p) == 0)
 return 1;
 /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
 /* What we need to do here is remove from `old' dllimport if it doesn't
 appear in `new'.  dllimport behaves like extern: if a declaration is
 marked dllimport and a definition appears later, then the object
 is not dllimport'd.  We also remove a `new' dllimport if the old list
 contains dllexport:  dllexport always overrides dllimport, regardless
 of the order of declaration.  */
 if (!VAR_OR_FUNCTION_DECL_P (new_tree))
 delete_dllimport_p = 0;
 else if (DECL_DLLIMPORT_P (new_tree)
 	   && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
 {
 DECL_DLLIMPORT_P (new_tree) = 0;
 warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
 	      "dllimport ignored", new_tree);
 }
 else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
 	  if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
 	    DECL_DLLIMPORT_P (new_tree) = 1;
 	}
 /* Let an inline definition silently override the external reference,
 	 but otherwise warn about attribute inconsistency.  */
 else if (TREE_CODE (new_tree) == VAR_DECL
 	       || !DECL_DECLARED_INLINE_P (new_tree))
 	warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
 		  "previous dllimport ignored", new_tree);
 }
 else
 delete_dllimport_p = 0;
 a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
 if (delete_dllimport_p)
 {
 tree prev, t;
 const size_t attr_len = strlen ("dllimport");
 /* Scan the list for dllimport and delete it.  */
 for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
 	{
 	  if (is_attribute_with_length_p ("dllimport", attr_len,
 					  TREE_PURPOSE (t)))
 tree
 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
 		      bool *no_add_attrs)
 {
 tree node = *pnode;
+bool is_dllimport;
 /* These attributes may apply to structure and union types being created,
 but otherwise should pass to the declaration involved.  */
 if (!DECL_P (node))
 {
 	  if (!node)
 	    return NULL_TREE;
 	}
 else
 	{
-	  warning (OPT_Wattributes, "%qs attribute ignored",
+	  warning (OPT_Wattributes, "%qE attribute ignored",
-		   IDENTIFIER_POINTER (name));
+		   name);
 	  *no_add_attrs = true;
 	  return NULL_TREE;
 	}
 }
 if (TREE_CODE (node) != FUNCTION_DECL
 && TREE_CODE (node) != VAR_DECL
 && TREE_CODE (node) != TYPE_DECL)
 {
 *no_add_attrs = true;
-warning (OPT_Wattributes, "%qs attribute ignored",
+warning (OPT_Wattributes, "%qE attribute ignored",
-	       IDENTIFIER_POINTER (name));
+	       name);
 return NULL_TREE;
 }
 if (TREE_CODE (node) == TYPE_DECL
 && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
 && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
 {
 *no_add_attrs = true;
-warning (OPT_Wattributes, "%qs attribute ignored",
+warning (OPT_Wattributes, "%qE attribute ignored",
-	       IDENTIFIER_POINTER (name));
+	       name);
 return NULL_TREE;
 }
+is_dllimport = is_attribute_p ("dllimport", name);
 /* Report error on dllimport ambiguities seen now before they cause
 any damage.  */
-else if (is_attribute_p ("dllimport", name))
+if (is_dllimport)
 {
 /* Honor any target-specific overrides. */
 if (!targetm.valid_dllimport_attribute_p (node))
 	*no_add_attrs = true;
 else if (TREE_CODE (node) == FUNCTION_DECL
 	        && DECL_DECLARED_INLINE_P (node))
 	{
 	  warning (OPT_Wattributes, "inline function %q+D declared as "
 		  " dllimport: attribute ignored", node);
 	  *no_add_attrs = true;
 	}
 /* Like MS, treat definition of dllimported variables and
 	 non-inlined functions on declaration as syntax errors. */
 else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
 	}
 if (*no_add_attrs == false)
 DECL_DLLIMPORT_P (node) = 1;
 }
+else if (TREE_CODE (node) == FUNCTION_DECL
+	   && DECL_DECLARED_INLINE_P (node))
+/* An exported function, even if inline, must be emitted.  */
+DECL_EXTERNAL (node) = 0;
 /*  Report error if symbol is not accessible at global scope.  */
 if (!TREE_PUBLIC (node)
 && (TREE_CODE (node) == VAR_DECL
 	  || TREE_CODE (node) == FUNCTION_DECL))
 {
 error ("external linkage required for symbol %q+D because of "
-	     "%qs attribute", node, IDENTIFIER_POINTER (name));
+	     "%qE attribute", node, name);
 *no_add_attrs = true;
 }
 /* A dllexport'd entity must have default visibility so that other
 program units (shared libraries or the main executable) can see
 unit can be resolved by the dynamic linker.  */
 if (!*no_add_attrs)
 {
 if (DECL_VISIBILITY_SPECIFIED (node)
 	  && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
-	error ("%qs implies default visibility, but %qD has already "
+	error ("%qE implies default visibility, but %qD has already "
 	       "been declared with a different visibility",
-	       IDENTIFIER_POINTER (name), node);
+	       name, node);
 DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
 DECL_VISIBILITY_SPECIFIED (node) = 1;
 }
 return NULL_TREE;
 set_type_quals (tree type, int type_quals)
 {
 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
+TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
 }
 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
 bool
 	TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
 						   type_quals);
 else
 	/* T is its own canonical type. */
 	TYPE_CANONICAL (t) = t;
 }
 return t;
 }
 tree
 build_distinct_type_copy (tree type)
 {
 tree t = copy_node (type);
 TYPE_POINTER_TO (t) = 0;
 TYPE_REFERENCE_TO (t) = 0;
 /* Set the canonical type either to a new equivalence class, or
 propagate the need for structural equality checks. */
 t = build_distinct_type_copy (type);
 /* Since we're building a variant, assume that it is a non-semantic
 variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
 TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
 /* Add the new type to the chain of variants of TYPE.  */
 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
 TYPE_NEXT_VARIANT (m) = t;
 TYPE_MAIN_VARIANT (t) = m;
 struct tree_priority_map *h;
 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
 h = decl_priority_info (decl);
 h->init = priority;
 }
 /* Set the finalization priority for DECL to PRIORITY.  */
 void
 decl_fini_priority_insert (tree decl, priority_type priority)
 struct tree_priority_map *h;
 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 h = decl_priority_info (decl);
 h->fini = priority;
-}
-/* Look up a restrict qualified base decl for FROM.  */
-tree
-decl_restrict_base_lookup (tree from)
-{
-struct tree_map *h;
-struct tree_map in;
-in.base.from = from;
-h = (struct tree_map *) htab_find_with_hash (restrict_base_for_decl, &in,
-					       htab_hash_pointer (from));
-return h ? h->to : NULL_TREE;
-}
-/* Record the restrict qualified base TO for FROM.  */
-void
-decl_restrict_base_insert (tree from, tree to)
-{
-struct tree_map *h;
-void **loc;
-h = GGC_NEW (struct tree_map);
-h->hash = htab_hash_pointer (from);
-h->base.from = from;
-h->to = to;
-loc = htab_find_slot_with_hash (restrict_base_for_decl, h, h->hash, INSERT);
-*(struct tree_map **) loc = h;
 }
 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
 static void
 	   (long) htab_size (value_expr_for_decl),
 	   (long) htab_elements (value_expr_for_decl),
 	   htab_collisions (value_expr_for_decl));
 }
-/* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but
-don't print anything if the table is empty.  */
-static void
-print_restrict_base_statistics (void)
-{
-if (htab_elements (restrict_base_for_decl) != 0)
-fprintf (stderr,
-	     "RESTRICT_BASE    hash: size %ld, %ld elements, %f collisions\n",
-	     (long) htab_size (restrict_base_for_decl),
-	     (long) htab_elements (restrict_base_for_decl),
-	     htab_collisions (restrict_base_for_decl));
-}
 /* Lookup a debug expression for FROM, and return it if we find one.  */
 tree
 decl_debug_expr_lookup (tree from)
 {
 struct tree_map *h, in;
 in.base.from = from;
 h->hash = htab_hash_pointer (from);
 h->base.from = from;
 h->to = to;
 loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
 *(struct tree_map **) loc = h;
 }
 /* Lookup a value expression for FROM, and return it if we find one.  */
 tree
 decl_value_expr_lookup (tree from)
 {
 struct tree_map *h, in;
 in.base.from = from;
 || TREE_TYPE (a->type) != TREE_TYPE (b->type)
 || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
 				 TYPE_ATTRIBUTES (b->type))
 || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
 || TYPE_MODE (a->type) != TYPE_MODE (b->type)
 || (TREE_CODE (a->type) != COMPLEX_TYPE
 && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
 return 0;
 switch (TREE_CODE (a->type))
 {
 be represented in a single unsigned HOST_WIDE_INT.  */
 int
 host_integerp (const_tree t, int pos)
 {
+if (t == NULL_TREE)
+return 0;
 return (TREE_CODE (t) == INTEGER_CST
 	  && ((TREE_INT_CST_HIGH (t) == 0
 	       && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
 	      || (! pos && TREE_INT_CST_HIGH (t) == -1
 		  && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
 int i;
 enum tree_code code;
 char tclass;
 if (t == NULL_TREE)
-return iterative_hash_pointer (t, val);
+return iterative_hash_hashval_t (0, val);
 code = TREE_CODE (t);
 switch (code)
 {
 case VECTOR_CST:
 return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
 case SSA_NAME:
 /* we can just compare by pointer.  */
-return iterative_hash_pointer (t, val);
+return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
 case TREE_LIST:
 /* A list of expressions, for a CALL_EXPR or as the elements of a
 	 VECTOR_CST.  */
 for (; t; t = TREE_CHAIN (t))
 	    val = iterative_hash_expr (value, val);
 	  }
 	return val;
 }
 case FUNCTION_DECL:
-/* When referring to a built-in FUNCTION_DECL, use the
+/* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
-	 __builtin__ form.  Otherwise nodes that compare equal
+	 Otherwise nodes that compare equal according to operand_equal_p might
-	 according to operand_equal_p might get different
+	 get different hash codes.  However, don't do this for machine specific
-	 hash codes.  */
+	 or front end builtins, since the function code is overloaded in those
-if (DECL_BUILT_IN (t))
+	 cases.  */
+if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
+	  && built_in_decls[DECL_FUNCTION_CODE (t)])
 	{
-	  val = iterative_hash_pointer (built_in_decls[DECL_FUNCTION_CODE (t)],
+	  t = built_in_decls[DECL_FUNCTION_CODE (t)];
-				      val);
+	  code = TREE_CODE (t);
-	  return val;
 	}
-/* else FALL THROUGH */
+/* FALL THROUGH */
 default:
 tclass = TREE_CODE_CLASS (code);
 if (tclass == tcc_declaration)
 	{
 	  val = iterative_hash_host_wide_int (DECL_UID (t), val);
 	}
 else
 	{
 	  gcc_assert (IS_EXPR_CODE_CLASS (tclass));
 	  val = iterative_hash_object (code, val);
 	  /* Don't hash the type, that can lead to having nodes which
 	     compare equal according to operand_equal_p, but which
 	     have different hash codes.  */
 /* By default build pointers in ptr_mode.  */
 tree
 build_pointer_type (tree to_type)
 {
-return build_pointer_type_for_mode (to_type, ptr_mode, false);
+addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
+					      : TYPE_ADDR_SPACE (to_type);
+enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
+return build_pointer_type_for_mode (to_type, pointer_mode, false);
 }
 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
 tree
 TYPE_REFERENCE_TO (to_type) = t;
 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
 SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (TYPE_CANONICAL (to_type) != to_type)
 TYPE_CANONICAL (t)
 = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
 				       mode, can_alias_all);
 layout_type (t);
 in ptr_mode.  */
 tree
 build_reference_type (tree to_type)
 {
-return build_reference_type_for_mode (to_type, ptr_mode, false);
+addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
+					      : TYPE_ADDR_SPACE (to_type);
+enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
+return build_reference_type_for_mode (to_type, pointer_mode, false);
 }
 /* Build a type that is compatible with t but has no cv quals anywhere
 in its type, thus
 			    itype);
 else
 return itype;
 }
+/* Return true if the debug information for TYPE, a subtype, should be emitted
+as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
+high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
+debug info and doesn't reflect the source code.  */
+bool
+subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
+{
+tree base_type = TREE_TYPE (type), low, high;
+/* Subrange types have a base type which is an integral type.  */
+if (!INTEGRAL_TYPE_P (base_type))
+return false;
+/* Get the real bounds of the subtype.  */
+if (lang_hooks.types.get_subrange_bounds)
+lang_hooks.types.get_subrange_bounds (type, &low, &high);
+else
+{
+low = TYPE_MIN_VALUE (type);
+high = TYPE_MAX_VALUE (type);
+}
+/* If the type and its base type have the same representation and the same
+name, then the type is not a subrange but a copy of the base type.  */
+if ((TREE_CODE (base_type) == INTEGER_TYPE
+|| TREE_CODE (base_type) == BOOLEAN_TYPE)
+&& int_size_in_bytes (type) == int_size_in_bytes (base_type)
+&& tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
+&& tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
+{
+tree type_name = TYPE_NAME (type);
+tree base_type_name = TYPE_NAME (base_type);
+if (type_name && TREE_CODE (type_name) == TYPE_DECL)
+	type_name = DECL_NAME (type_name);
+if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
+	base_type_name = DECL_NAME (base_type_name);
+if (type_name == base_type_name)
+	return false;
+}
+if (lowval)
+*lowval = low;
+if (highval)
+*highval = high;
+return true;
+}
 /* Just like build_index_type, but takes lowval and highval instead
 of just highval (maxval).  */
 tree
 build_index_2_type (tree lowval, tree highval)
 }
 t = make_node (ARRAY_TYPE);
 TREE_TYPE (t) = elt_type;
 TYPE_DOMAIN (t) = index_type;
+TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
-if (index_type == 0)
+layout_type (t);
-{
-tree save = t;
+/* If the element type is incomplete at this point we get marked for
-hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
+structural equality.  Do not record these types in the canonical
-t = type_hash_canon (hashcode, t);
+type hashtable.  */
-if (save == t)
+if (TYPE_STRUCTURAL_EQUALITY_P (t))
-	layout_type (t);
+return t;
-if (TYPE_CANONICAL (t) == t)
-	{
-	  if (TYPE_STRUCTURAL_EQUALITY_P (elt_type))
-	    SET_TYPE_STRUCTURAL_EQUALITY (t);
-	  else if (TYPE_CANONICAL (elt_type) != elt_type)
-	    TYPE_CANONICAL (t)
-	      = build_array_type (TYPE_CANONICAL (elt_type), index_type);
-	}
-return t;
-}
 hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
-hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
+if (index_type)
+hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
 t = type_hash_canon (hashcode, t);
-if (!COMPLETE_TYPE_P (t))
-layout_type (t);
 if (TYPE_CANONICAL (t) == t)
 {
 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
-	  || TYPE_STRUCTURAL_EQUALITY_P (index_type))
+	  || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
 	SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (TYPE_CANONICAL (elt_type) != elt_type
-	       || TYPE_CANONICAL (index_type) != index_type)
+	       || (index_type && TYPE_CANONICAL (index_type) != index_type))
 	TYPE_CANONICAL (t)
 	  = build_array_type (TYPE_CANONICAL (elt_type),
-			      TYPE_CANONICAL (index_type));
+			      index_type ? TYPE_CANONICAL (index_type) : NULL);
 }
 return t;
 }
 return type;
 }
 /* Computes the canonical argument types from the argument type list
 ARGTYPES.
 Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
 on entry to this function, or if any of the ARGTYPES are
 structural.
 Returns a canonical argument list, which may be ARGTYPES when the
 canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
 true) or would not differ from ARGTYPES.  */
 static tree
 maybe_canonicalize_argtypes(tree argtypes,
 			    bool *any_structural_p,
 			    bool *any_noncanonical_p)
 {
 tree arg;
 bool any_noncanonical_argtypes_p = false;
 for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
 {
 if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
 	/* Fail gracefully by stating that the type is structural.  */
 	*any_structural_p = true;
 t = type_hash_canon (hashcode, t);
 /* Set up the canonical type. */
 any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
 any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
 canon_argtypes = maybe_canonicalize_argtypes (arg_types,
 						&any_structural_p,
 						&any_noncanonical_p);
 if (any_structural_p)
 SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (any_noncanonical_p)
 TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
 					      canon_argtypes);
 if (!COMPLETE_TYPE_P (t))
 layout_type (t);
 return t;
 }
 TYPE_NEXT_VARIANT (new_type) = NULL;
 }
 return new_type;
 }
 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
 linked by TREE_CHAIN directly.  It is caller responsibility to eliminate
 them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
 tree
 						&any_structural_p,
 						&any_noncanonical_p);
 if (any_structural_p)
 SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (any_noncanonical_p)
 TYPE_CANONICAL (t)
 = build_method_type_directly (TYPE_CANONICAL (basetype),
 				    TYPE_CANONICAL (rettype),
 				    canon_argtypes);
 if (!COMPLETE_TYPE_P (t))
 layout_type (t);
 if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
 	  || TYPE_STRUCTURAL_EQUALITY_P (type))
 	SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
 	       || TYPE_CANONICAL (type) != type)
 	TYPE_CANONICAL (t)
 	  = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
 			       TYPE_CANONICAL (type));
 }
 return t;
 if (TYPE_CANONICAL (t) == t)
 {
 if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
 	SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (TYPE_CANONICAL (component_type) != component_type)
 	TYPE_CANONICAL (t)
 	  = build_complex_type (TYPE_CANONICAL (component_type));
 }
 /* We need to create a name, since complex is a fundamental type.  */
 if (! TYPE_NAME (t))
 	name = "complex long long unsigned int";
 else
 	name = 0;
 if (name != 0)
-	TYPE_NAME (t) = build_decl (TYPE_DECL, get_identifier (name), t);
+	TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
+	    			    get_identifier (name), t);
 }
 return build_qualified_type (t, TYPE_QUALS (component_type));
+}
+/* If TYPE is a real or complex floating-point type and the target
+does not directly support arithmetic on TYPE then return the wider
+type to be used for arithmetic on TYPE.  Otherwise, return
+NULL_TREE.  */
+tree
+excess_precision_type (tree type)
+{
+if (flag_excess_precision != EXCESS_PRECISION_FAST)
+{
+int flt_eval_method = TARGET_FLT_EVAL_METHOD;
+switch (TREE_CODE (type))
+	{
+	case REAL_TYPE:
+	  switch (flt_eval_method)
+	    {
+	    case 1:
+	      if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
+		return double_type_node;
+	      break;
+	    case 2:
+	      if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
+		  || TYPE_MODE (type) == TYPE_MODE (double_type_node))
+		return long_double_type_node;
+	      break;
+	    default:
+	      gcc_unreachable ();
+	    }
+	  break;
+	case COMPLEX_TYPE:
+	  if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
+	    return NULL_TREE;
+	  switch (flt_eval_method)
+	    {
+	    case 1:
+	      if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
+		return complex_double_type_node;
+	      break;
+	    case 2:
+	      if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
+		  || (TYPE_MODE (TREE_TYPE (type))
+		      == TYPE_MODE (double_type_node)))
+		return complex_long_double_type_node;
+	      break;
+	    default:
+	      gcc_unreachable ();
+	    }
+	  break;
+	default:
+	  break;
+	}
+}
+return NULL_TREE;
 }
 /* Return OP, stripped of any conversions to wider types as much as is safe.
 Converting the value back to OP's type makes a value equivalent to OP.
 				TYPE_PRECISION (type));
 	  mpz_set_double_int (min, mn, false);
 	}
 }
 if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
 mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
 			TYPE_UNSIGNED (type));
 else
 {
 fprintf (stderr, "(No per-node statistics)\n");
 #endif
 print_type_hash_statistics ();
 print_debug_expr_statistics ();
 print_value_expr_statistics ();
-print_restrict_base_statistics ();
 lang_hooks.print_statistics ();
 }
 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
 buffer = tmp = (char *) alloca (length);
 length = 0;
 while ((code = va_arg (args, int)))
 	{
 	  const char *prefix = length ? " or " : "expected ";
 	  strcpy (tmp + length, prefix);
 	  length += strlen (prefix);
 	  strcpy (tmp + length, tree_code_name[code]);
 	  length += strlen (tree_code_name[code]);
 	}
 			 const char *function, enum tree_code c1,
 			 enum tree_code c2)
 {
 char *buffer;
 unsigned length = 0;
-enum tree_code c;
+unsigned int c;
 for (c = c1; c <= c2; ++c)
 length += 4 + strlen (tree_code_name[c]);
 length += strlen ("expected ");
 			       const char *function, enum omp_clause_code c1,
 			       enum omp_clause_code c2)
 {
 char *buffer;
 unsigned length = 0;
-enum omp_clause_code c;
+unsigned int c;
 for (c = c1; c <= c2; ++c)
 length += 4 + strlen (omp_clause_code_name[c]);
 length += strlen ("expected ");
 /* Similar to tree_class_check_failed, except that we check for
 whether CODE contains the tree structure identified by EN.  */
 void
 tree_contains_struct_check_failed (const_tree node,
 				   const enum tree_node_structure_enum en,
 				   const char *file, int line,
 				   const char *function)
 {
 internal_error
 ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
 TS_ENUM_NAME(en),
 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
 {
 tree t;
 hashval_t hashcode = 0;
-/* Build a main variant, based on the main variant of the inner type, then
-use it to build the variant we return.  */
-if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
-&& TYPE_MAIN_VARIANT (innertype) != innertype)
-return build_type_attribute_qual_variant (
-	    make_vector_type (TYPE_MAIN_VARIANT (innertype), nunits, mode),
-	    TYPE_ATTRIBUTES (innertype),
-	    TYPE_QUALS (innertype));
 t = make_node (VECTOR_TYPE);
 TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
 SET_TYPE_VECTOR_SUBPARTS (t, nunits);
 SET_TYPE_MODE (t, mode);
-TYPE_READONLY (t) = TYPE_READONLY (innertype);
-TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype);
 if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
 SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (TYPE_CANONICAL (innertype) != innertype
 	   || mode != VOIDmode)
 TYPE_CANONICAL (t)
 = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
 layout_type (t);
 {
 tree index = build_int_cst (NULL_TREE, nunits - 1);
-tree array = build_array_type (innertype, build_index_type (index));
+tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
+				   build_index_type (index));
 tree rt = make_node (RECORD_TYPE);
-TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
+TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
+				   get_identifier ("f"), array);
 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
 layout_type (rt);
 TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
 /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
 the representation type, and we want to find that die when looking up
 numbers equal.  */
 TYPE_UID (rt) = TYPE_UID (t);
 }
 hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
+hashcode = iterative_hash_host_wide_int (nunits, hashcode);
 hashcode = iterative_hash_host_wide_int (mode, hashcode);
-hashcode = iterative_hash_object (TYPE_HASH (innertype), hashcode);
+hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
-return type_hash_canon (hashcode, t);
+t = type_hash_canon (hashcode, t);
+/* We have built a main variant, based on the main variant of the
+inner type. Use it to build the variant we return.  */
+if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
+&& TREE_TYPE (t) != innertype)
+return build_type_attribute_qual_variant (t,
+					      TYPE_ATTRIBUTES (innertype),
+					      TYPE_QUALS (innertype));
+return t;
 }
 static tree
 make_or_reuse_type (unsigned size, int unsignedp)
 {
 uint32_type_node = build_nonstandard_integer_type (32, true);
 uint64_type_node = build_nonstandard_integer_type (64, true);
 /* Decimal float types. */
 dfloat32_type_node = make_node (REAL_TYPE);
 TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
 layout_type (dfloat32_type_node);
 SET_TYPE_MODE (dfloat32_type_node, SDmode);
 dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
 dfloat64_type_node = make_node (REAL_TYPE);
 layout_type (dfloat64_type_node);
 SET_TYPE_MODE (dfloat64_type_node, DDmode);
 dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
 dfloat128_type_node = make_node (REAL_TYPE);
 TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
 layout_type (dfloat128_type_node);
 SET_TYPE_MODE (dfloat128_type_node, TDmode);
 dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
 complex_integer_type_node = build_complex_type (integer_type_node);
 record type without a name.  This breaks name mangling.  So,
 don't copy record types and let c_common_nodes_and_builtins()
 declare the type to be __builtin_va_list.  */
 if (TREE_CODE (t) != RECORD_TYPE)
 t = build_variant_type_copy (t);
 va_list_type_node = t;
 }
 }
 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
 are relied upon by the tree optimizers and the middle-end.  */
 void
 build_common_builtin_nodes (void)
 {
-tree tmp, ftype;
+tree tmp, tmp2, ftype;
 if (built_in_decls[BUILT_IN_MEMCPY] == NULL
 || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
 {
 tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
 if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
 {
 tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
 ftype = build_function_type (ptr_type_node, tmp);
 local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
-			    "alloca", ECF_NOTHROW | ECF_MALLOC);
+			    "alloca",
+			    ECF_MALLOC | (flag_stack_check ? 0 : ECF_NOTHROW));
 }
 tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
 local_define_builtin ("__builtin_profile_func_enter", ftype,
 			BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
 local_define_builtin ("__builtin_profile_func_exit", ftype,
 			BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
+/* If there's a possibility that we might use the ARM EABI, build the
+alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
+if (targetm.arm_eabi_unwinder)
+{
+ftype = build_function_type (void_type_node, void_list_node);
+local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
+			    BUILT_IN_CXA_END_CLEANUP,
+			    "__cxa_end_cleanup", ECF_NORETURN);
+}
+tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
+ftype = build_function_type (void_type_node, tmp);
+local_define_builtin ("__builtin_unwind_resume", ftype,
+			BUILT_IN_UNWIND_RESUME,
+			(USING_SJLJ_EXCEPTIONS
+			 ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
+			ECF_NORETURN);
+/* The exception object and filter values from the runtime.  The argument
+must be zero before exception lowering, i.e. from the front end.  After
+exception lowering, it will be the region number for the exception
+landing pad.  These functions are PURE instead of CONST to prevent
+them from being hoisted past the exception edge that will initialize
+its value in the landing pad.  */
+tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
+ftype = build_function_type (ptr_type_node, tmp);
+local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
+			"__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW);
+tmp2 = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
+ftype = build_function_type (tmp2, tmp);
+local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
+			"__builtin_eh_filter", ECF_PURE | ECF_NOTHROW);
+tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
+tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
+ftype = build_function_type (void_type_node, tmp);
+local_define_builtin ("__builtin_eh_copy_values", ftype,
+			BUILT_IN_EH_COPY_VALUES,
+			"__builtin_eh_copy_values", ECF_NOTHROW);
 /* Complex multiplication and division.  These are handled as builtins
 rather than optabs because emit_library_call_value doesn't support
 complex.  Further, we can do slightly better with folding these
 beasties if the real and complex parts of the arguments are separate.  */
 {
-enum machine_mode mode;
+int mode;
 for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
 {
 	char mode_name_buf[4], *q;
 	const char *p;
 	enum built_in_function mcode, dcode;
 	tree type, inner_type;
-	type = lang_hooks.types.type_for_mode (mode, 0);
+	type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
 	if (type == NULL)
 	  continue;
 	inner_type = TREE_TYPE (type);
 	tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
 	tmp = tree_cons (NULL_TREE, inner_type, tmp);
 	tmp = tree_cons (NULL_TREE, inner_type, tmp);
 	tmp = tree_cons (NULL_TREE, inner_type, tmp);
 	ftype = build_function_type (type, tmp);
-mcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
+mcode = ((enum built_in_function)
-dcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
+		 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
+dcode = ((enum built_in_function)
+		 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
 for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
 	  *q = TOLOWER (*p);
 	*q = '\0';
 tree
 reconstruct_complex_type (tree type, tree bottom)
 {
 tree inner, outer;
 if (TREE_CODE (type) == POINTER_TYPE)
 {
 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
 					   TYPE_REF_CAN_ALIAS_ALL (type));
 else if (TREE_CODE (type) == METHOD_TYPE)
 {
 inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
 /* The build_method_type_directly() routine prepends 'this' to argument list,
 so we must compensate by getting rid of it.  */
 outer
 	= build_method_type_directly
 	    (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
 	     inner,
 	     TREE_CHAIN (TYPE_ARG_TYPES (type)));
 }
 else if (TREE_CODE (type) == OFFSET_TYPE)
 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
 }
 else
 return bottom;
-return build_qualified_type (outer, TYPE_QUALS (type));
+return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
+					    TYPE_QUALS (type));
 }
 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
 the inner type.  */
 tree
 build_vector_type (tree innertype, int nunits)
 {
 return make_vector_type (innertype, nunits, VOIDmode);
 }
+/* Similarly, but takes the inner type and number of units, which must be
-/* Build RESX_EXPR with given REGION_NUMBER.  */
+a power of two.  */
-tree
-build_resx (int region_number)
+tree
+build_opaque_vector_type (tree innertype, int nunits)
 {
 tree t;
-t = build1 (RESX_EXPR, void_type_node,
+innertype = build_distinct_type_copy (innertype);
-	      build_int_cst (NULL_TREE, region_number));
+t = make_vector_type (innertype, nunits, VOIDmode);
+TYPE_VECTOR_OPAQUE (t) = true;
 return t;
 }
 /* Given an initializer INIT, return TRUE if INIT is zero or some
 aggregate of zeros.  Otherwise return FALSE.  */
 bool
 initializer_zerop (const_tree init)
 default:
 return false;
 }
 }
-/* Build an empty statement.  */
+/* Build an empty statement at location LOC.  */
 tree
-build_empty_stmt (void)
+build_empty_stmt (location_t loc)
 {
-return build1 (NOP_EXPR, void_type_node, size_zero_node);
+tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
-}
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
-/* Build an OpenMP clause with code CODE.  */
-tree
+/* Build an OpenMP clause with code CODE.  LOC is the location of the
-build_omp_clause (enum omp_clause_code code)
+clause.  */
+tree
+build_omp_clause (location_t loc, enum omp_clause_code code)
 {
 tree t;
 int size, length;
 length = omp_clause_num_ops[code];
 t = GGC_NEWVAR (union tree_node, size);
 memset (t, 0, size);
 TREE_SET_CODE (t, OMP_CLAUSE);
 OMP_CLAUSE_SET_CODE (t, code);
+OMP_CLAUSE_LOCATION (t) = loc;
 #ifdef GATHER_STATISTICS
 tree_node_counts[(int) omp_clause_kind]++;
 tree_node_sizes[(int) omp_clause_kind] += size;
 #endif
 return t;
-}
-/* Set various status flags when building a CALL_EXPR object T.  */
-static void
-process_call_operands (tree t)
-{
-bool side_effects;
-side_effects = TREE_SIDE_EFFECTS (t);
-if (!side_effects)
-{
-int i, n;
-n = TREE_OPERAND_LENGTH (t);
-for (i = 1; i < n; i++)
-	{
-	  tree op = TREE_OPERAND (t, i);
-	  if (op && TREE_SIDE_EFFECTS (op))
-	    {
-	      side_effects = 1;
-	      break;
-	    }
-	}
-}
-if (!side_effects)
-{
-int i;
-/* Calls have side-effects, except those to const or
-	 pure functions.  */
-i = call_expr_flags (t);
-if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
-	side_effects = 1;
-}
-TREE_SIDE_EFFECTS (t) = side_effects;
 }
 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
 includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
 Except for the CODE and operand count field, other storage for the
 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
 FN and a null static chain slot.  NARGS is the number of call arguments
 which are specified as a tree array ARGS.  */
 tree
-build_call_array (tree return_type, tree fn, int nargs, tree *args)
+build_call_array_loc (location_t loc, tree return_type, tree fn,
+		      int nargs, const tree *args)
 {
 tree t;
 int i;
 t = build_vl_exp (CALL_EXPR, nargs + 3);
 CALL_EXPR_FN (t) = fn;
 CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
 for (i = 0; i < nargs; i++)
 CALL_EXPR_ARG (t, i) = args[i];
 process_call_operands (t);
+SET_EXPR_LOCATION (t, loc);
 return t;
+}
+/* Like build_call_array, but takes a VEC.  */
+tree
+build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
+{
+tree ret, t;
+unsigned int ix;
+ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
+TREE_TYPE (ret) = return_type;
+CALL_EXPR_FN (ret) = fn;
+CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
+for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
+CALL_EXPR_ARG (ret, ix) = t;
+process_call_operands (ret);
+return ret;
 }
 /* Returns true if it is possible to prove that the index of
 an array access REF (an ARRAY_REF expression) falls into the
 }
 return val;
 }
+/* Return value of a constant X and sign-extend it.  */
+HOST_WIDEST_INT
+widest_int_cst_value (const_tree x)
+{
+unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
+unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
+#if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
+gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
+val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
+	  << HOST_BITS_PER_WIDE_INT);
+#else
+/* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
+gcc_assert (TREE_INT_CST_HIGH (x) == 0
+	      || TREE_INT_CST_HIGH (x) == -1);
+#endif
+if (bits < HOST_BITS_PER_WIDEST_INT)
+{
+bool negative = ((val >> (bits - 1)) & 1) != 0;
+if (negative)
+	val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
+else
+	val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
+}
+return val;
+}
 /* If TYPE is an integral type, return an equivalent type which is
 unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
 return TYPE itself.  */
 tree
 signed_or_unsigned_type_for (int unsignedp, tree type)
 {
 tree t = type;
 if (POINTER_TYPE_P (type))
-t = size_type_node;
+{
+/* If the pointer points to the normal address space, use the
+	 size_type_node.  Otherwise use an appropriate size for the pointer
+	 based on the named address space it points to.  */
+if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
+	t = size_type_node;
+else
+	return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
+}
 if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
 return t;
 return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
 }
 /* Returns unsigned variant of TYPE.  */
 return 0;
 return operand_equal_p (arg0, arg1, 0);
 }
 /* Returns number of zeros at the end of binary representation of X.
 ??? Use ffs if available?  */
 tree
 num_ending_zeros (const_tree x)
 {
 	for (i = 0; i < len; ++i)
 	  WALK_SUBTREE (TREE_OPERAND (*tp, i));
 	WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
 }
-case CHANGE_DYNAMIC_TYPE_EXPR:
-WALK_SUBTREE (CHANGE_DYNAMIC_TYPE_NEW_TYPE (*tp));
-WALK_SUBTREE_TAIL (CHANGE_DYNAMIC_TYPE_LOCATION (*tp));
 case DECL_EXPR:
 /* If this is a TYPE_DECL, walk into the fields of the type that it's
 	 defining.  We only want to walk into these fields of a type in this
 	 case and not in the general case of a mere reference to the type.
 	 The criterion is as follows: if the field can be an expression, it
 	 must be walked only here.  This should be in keeping with the fields
 	 that are directly gimplified in gimplify_type_sizes in order for the
 	 mark/copy-if-shared/unmark machinery of the gimplifier to work with
 	 variable-sized types.
 	 Note that DECLs get walked as part of processing the BIND_EXPR.  */
 if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
 	{
 	  tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
 	  if (TREE_CODE (*type_p) == ERROR_MARK)
 	  result = walk_type_fields (*type_p, func, data, pset, lh);
 	  if (result)
 	    return result;
 	  /* If this is a record type, also walk the fields.  */
-	  if (TREE_CODE (*type_p) == RECORD_TYPE
+	  if (RECORD_OR_UNION_TYPE_P (*type_p))
-	      || TREE_CODE (*type_p) == UNION_TYPE
-	      || TREE_CODE (*type_p) == QUAL_UNION_TYPE)
 	    {
 	      tree field;
 	      for (field = TYPE_FIELDS (*type_p); field;
 		   field = TREE_CHAIN (field))
 arglist = tree_cons (NULL_TREE, CALL_EXPR_ARG (exp, i), arglist);
 return arglist;
 }
-/* Create a nameless artificial label and put it in the current function
+/* Create a nameless artificial label and put it in the current
-context.  Returns the newly created label.  */
+function context.  The label has a location of LOC.  Returns the
+newly created label.  */
-tree
-create_artificial_label (void)
+tree
-{
+create_artificial_label (location_t loc)
-tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
+{
+tree lab = build_decl (loc,
+			 LABEL_DECL, NULL_TREE, void_type_node);
 DECL_ARTIFICIAL (lab) = 1;
 DECL_IGNORED_P (lab) = 1;
 DECL_CONTEXT (lab) = current_function_decl;
 return lab;
 gcc_assert (fntype != NULL_TREE);
 t = TYPE_ARG_TYPES (fntype);
 return (t != NULL_TREE);
-}
-/* Return the number of arguments that a function has.  */
-int
-function_args_count (tree fntype)
-{
-function_args_iterator args_iter;
-tree t;
-int num = 0;
-if (fntype)
-{
-FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
-	{
-	  num++;
-	}
-}
-return num;
 }
 /* If BLOCK is inlined from an __attribute__((__artificial__))
 routine, return pointer to location from where it has been
 called.  */
 return ret_val;
 }
 }
+/* Return true if T1 and T2 are equivalent lists.  */
+bool
+list_equal_p (const_tree t1, const_tree t2)
+{
+for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
+if (TREE_VALUE (t1) != TREE_VALUE (t2))
+return false;
+return !t1 && !t2;
+}
+/* Return true iff conversion in EXP generates no instruction.  Mark
+it inline so that we fully inline into the stripping functions even
+though we have two uses of this function.  */
+static inline bool
+tree_nop_conversion (const_tree exp)
+{
+tree outer_type, inner_type;
+if (!CONVERT_EXPR_P (exp)
+&& TREE_CODE (exp) != NON_LVALUE_EXPR)
+return false;
+if (TREE_OPERAND (exp, 0) == error_mark_node)
+return false;
+outer_type = TREE_TYPE (exp);
+inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
+/* Use precision rather then machine mode when we can, which gives
+the correct answer even for submode (bit-field) types.  */
+if ((INTEGRAL_TYPE_P (outer_type)
+|| POINTER_TYPE_P (outer_type)
+|| TREE_CODE (outer_type) == OFFSET_TYPE)
+&& (INTEGRAL_TYPE_P (inner_type)
+	  || POINTER_TYPE_P (inner_type)
+	  || TREE_CODE (inner_type) == OFFSET_TYPE))
+return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
+/* Otherwise fall back on comparing machine modes (e.g. for
+aggregate types, floats).  */
+return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
+}
+/* Return true iff conversion in EXP generates no instruction.  Don't
+consider conversions changing the signedness.  */
+static bool
+tree_sign_nop_conversion (const_tree exp)
+{
+tree outer_type, inner_type;
+if (!tree_nop_conversion (exp))
+return false;
+outer_type = TREE_TYPE (exp);
+inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
+return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
+	  && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
+}
+/* Strip conversions from EXP according to tree_nop_conversion and
+return the resulting expression.  */
+tree
+tree_strip_nop_conversions (tree exp)
+{
+while (tree_nop_conversion (exp))
+exp = TREE_OPERAND (exp, 0);
+return exp;
+}
+/* Strip conversions from EXP according to tree_sign_nop_conversion
+and return the resulting expression.  */
+tree
+tree_strip_sign_nop_conversions (tree exp)
+{
+while (tree_sign_nop_conversion (exp))
+exp = TREE_OPERAND (exp, 0);
+return exp;
+}
+static GTY(()) tree gcc_eh_personality_decl;
+/* Return the GCC personality function decl.  */
+tree
+lhd_gcc_personality (void)
+{
+if (!gcc_eh_personality_decl)
+gcc_eh_personality_decl
+= build_personality_function (USING_SJLJ_EXCEPTIONS
+				    ? "__gcc_personality_sj0"
+				    : "__gcc_personality_v0");
+return gcc_eh_personality_decl;
+}
 #include "gt-tree.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree.c @ 55:77e2b8dfacca gcc-4.4.5