CbC/CbC_gcc: gcc/gimple.c comparison

comparison gcc/gimple.c @ 69:1b10fe6932e1

merge 69

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 07:53:12 +0900
parents	5b5b9ea5b220 f6334be47118
children	b81903832de2

comparison

equal deleted inserted replaced

-:b362627d71ba
+:1b10fe6932e1
 /* Gimple IR support functions.
-Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 Contributed by Aldy Hernandez <aldyh@redhat.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "tree.h"
 #include "ggc.h"
 #include "hard-reg-set.h"
 #include "basic-block.h"
 #include "gimple.h"
-#include "toplev.h"
 #include "diagnostic.h"
 #include "tree-flow.h"
 #include "value-prof.h"
 #include "flags.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 #endif
 #include "alias.h"
 #include "demangle.h"
+#include "langhooks.h"
 /* Global type table.  FIXME lto, it should be possible to re-use some
 of the type hashing routines in tree.c (type_hash_canon, type_hash_lookup,
 etc), but those assume that types were built with the various
 build_*_type routines which is not the case with the streamer.  */
-static htab_t gimple_types;
+static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node)))
-static struct pointer_map_t *type_hash_cache;
+htab_t gimple_types;
+static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node)))
-/* Global type comparison cache.  */
+htab_t gimple_canonical_types;
+static GTY((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
+htab_t type_hash_cache;
+static GTY((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
+htab_t canonical_type_hash_cache;
+/* Global type comparison cache.  This is by TYPE_UID for space efficiency
+and thus cannot use and does not need GC.  */
 static htab_t gtc_visited;
 static struct obstack gtc_ob;
 /* All the tuples have their operand vector (if present) at the very bottom
 of the structure.  Therefore, the offset required to find the
 gimple_alloc_counts[(int) kind]++;
 gimple_alloc_sizes[(int) kind] += size;
 }
 #endif
-stmt = (gimple) ggc_alloc_cleared_stat (size PASS_MEM_STAT);
+stmt = ggc_alloc_cleared_gimple_statement_d_stat (size PASS_MEM_STAT);
 gimple_set_code (stmt, code);
 gimple_set_num_ops (stmt, num_ops);
 /* Do not call gimple_set_modified here as it has other side
 effects and this tuple is still not completely built.  */
 if (retval)
 gimple_return_set_retval (s, retval);
 return s;
 }
+/* Reset alias information on call S.  */
+void
+gimple_call_reset_alias_info (gimple s)
+{
+if (gimple_call_flags (s) & ECF_CONST)
+memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
+else
+pt_solution_reset (gimple_call_use_set (s));
+if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
+memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
+else
+pt_solution_reset (gimple_call_clobber_set (s));
+}
 /* Helper for gimple_build_call, gimple_build_call_vec and
 gimple_build_call_from_tree.  Build the basic components of a
 GIMPLE_CALL statement to function FN with NARGS arguments.  */
 static inline gimple
 {
 gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
 if (TREE_CODE (fn) == FUNCTION_DECL)
 fn = build_fold_addr_expr (fn);
 gimple_set_op (s, 1, fn);
+gimple_call_reset_alias_info (s);
 return s;
 }
 /* Build a GIMPLE_CALL statement to function FN with the arguments
 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
 #ifndef noCbC
 gimple_call_set_cbc_goto (call, CALL_EXPR_CbC_GOTO (t));
 #endif
+gimple_call_set_nothrow (call, TREE_NOTHROW (t));
 gimple_set_no_warning (call, TREE_NO_WARNING (t));
 return call;
 }
 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
-*OP1_P and *OP2_P respectively.  */
+*OP1_P, *OP2_P and *OP3_P respectively.  */
 void
-extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
+extract_ops_from_tree_1 (tree expr, enum tree_code *subcode_p, tree *op1_p,
-tree *op2_p)
+			 tree *op2_p, tree *op3_p)
 {
 enum gimple_rhs_class grhs_class;
 *subcode_p = TREE_CODE (expr);
 grhs_class = get_gimple_rhs_class (*subcode_p);
-if (grhs_class == GIMPLE_BINARY_RHS)
+if (grhs_class == GIMPLE_TERNARY_RHS)
 {
 *op1_p = TREE_OPERAND (expr, 0);
 *op2_p = TREE_OPERAND (expr, 1);
+*op3_p = TREE_OPERAND (expr, 2);
+}
+else if (grhs_class == GIMPLE_BINARY_RHS)
+{
+*op1_p = TREE_OPERAND (expr, 0);
+*op2_p = TREE_OPERAND (expr, 1);
+*op3_p = NULL_TREE;
 }
 else if (grhs_class == GIMPLE_UNARY_RHS)
 {
 *op1_p = TREE_OPERAND (expr, 0);
 *op2_p = NULL_TREE;
+*op3_p = NULL_TREE;
 }
 else if (grhs_class == GIMPLE_SINGLE_RHS)
 {
 *op1_p = expr;
 *op2_p = NULL_TREE;
+*op3_p = NULL_TREE;
 }
 else
 gcc_unreachable ();
 }
 gimple
 gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
 {
 enum tree_code subcode;
-tree op1, op2;
+tree op1, op2, op3;
-extract_ops_from_tree (rhs, &subcode, &op1, &op2);
+extract_ops_from_tree_1 (rhs, &subcode, &op1, &op2, &op3);
-return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2
+return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2, op3
-PASS_MEM_STAT);
+					    PASS_MEM_STAT);
 }
 /* Build a GIMPLE_ASSIGN statement with sub-code SUBCODE and operands
 OP1 and OP2.  If OP2 is NULL then SUBCODE must be of class
 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS.  */
 gimple
 gimple_build_assign_with_ops_stat (enum tree_code subcode, tree lhs, tree op1,
-tree op2 MEM_STAT_DECL)
+tree op2, tree op3 MEM_STAT_DECL)
 {
 unsigned num_ops;
 gimple p;
 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
 gimple_assign_set_rhs1 (p, op1);
 if (op2)
 {
 gcc_assert (num_ops > 2);
 gimple_assign_set_rhs2 (p, op2);
+}
+if (op3)
+{
+gcc_assert (num_ops > 3);
+gimple_assign_set_rhs3 (p, op3);
 }
 return p;
 }
 void
 gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
 tree *lhs_p, tree *rhs_p)
 {
-location_t loc = EXPR_LOCATION (cond);
 gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
 || TREE_CODE (cond) == TRUTH_NOT_EXPR
 || is_gimple_min_invariant (cond)
 || SSA_VAR_P (cond));
 /* Canonicalize conditionals of the form 'if (!VAL)'.  */
 if (*code_p == TRUTH_NOT_EXPR)
 {
 *code_p = EQ_EXPR;
 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
-*rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
+*rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
 }
 /* Canonicalize conditionals of the form 'if (VAL)'  */
 else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
 {
 *code_p = NE_EXPR;
 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
-*rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
+*rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
 }
 }
 /* Build a GIMPLE_COND statement from the conditional expression tree
 /* Build a GIMPLE_EH_MUST_NOT_THROW statement.  */
 gimple
 gimple_build_eh_must_not_throw (tree decl)
 {
-gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 1);
+gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
 gimple_eh_must_not_throw_set_fndecl (p, decl);
 gimple p = gimple_alloc (GIMPLE_OMP_FOR, 0);
 if (body)
 gimple_omp_set_body (p, body);
 gimple_omp_for_set_clauses (p, clauses);
 p->gimple_omp_for.collapse = collapse;
-p->gimple_omp_for.iter = GGC_CNEWVEC (struct gimple_omp_for_iter, collapse);
+p->gimple_omp_for.iter
+= ggc_alloc_cleared_vec_gimple_omp_for_iter (collapse);
 if (pre_body)
 gimple_omp_for_set_pre_body (p, pre_body);
 return p;
 }
 gcc_assert (gimple_seq_cache != seq);
 memset (seq, 0, sizeof (*seq));
 }
 else
 {
-seq = (gimple_seq) ggc_alloc_cleared (sizeof (*seq));
+seq = ggc_alloc_cleared_gimple_seq_d ();
 #ifdef GATHER_STATISTICS
 gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
 gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
 #endif
 }
 operands are not scanned.
 The return value is that returned by the last call to walk_tree, or
 NULL_TREE if no CALLBACK_OP is specified.  */
-inline tree
+tree
 walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
 struct walk_stmt_info *wi)
 {
 struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
 unsigned i;
 tree ret = NULL_TREE;
 switch (gimple_code (stmt))
 {
 case GIMPLE_ASSIGN:
-/* Walk the RHS operands.  A formal temporary LHS may use a
+/* Walk the RHS operands.  If the LHS is of a non-renamable type or
-COMPONENT_REF RHS.  */
+is a register variable, we may use a COMPONENT_REF on the RHS.  */
 if (wi)
-wi->val_only = !is_gimple_reg (gimple_assign_lhs (stmt))
+	{
-|| !gimple_assign_single_p (stmt);
+	  tree lhs = gimple_assign_lhs (stmt);
+	  wi->val_only
+	    = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
+	      || !gimple_assign_single_p (stmt);
+	}
 for (i = 1; i < gimple_num_ops (stmt); i++)
 {
 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
 pset);
 }
 break;
 case GIMPLE_CALL:
 if (wi)
-wi->is_lhs = false;
+	{
+	  wi->is_lhs = false;
+	  wi->val_only = true;
+	}
 ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
 if (ret)
 return ret;
 ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
 if (ret)
 return ret;
 for (i = 0; i < gimple_call_num_args (stmt); i++)
-{
+	{
-ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
+	  if (wi)
-pset);
+	    wi->val_only = is_gimple_reg_type (gimple_call_arg (stmt, i));
-if (ret)
+	  ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
-return ret;
+			   pset);
-}
+	  if (ret)
+	    return ret;
+	}
+if (gimple_call_lhs (stmt))
+	{
+	  if (wi)
+	    {
+	      wi->is_lhs = true;
+	      wi->val_only = is_gimple_reg_type (gimple_call_lhs (stmt));
+	    }
+	  ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
+	  if (ret)
+	    return ret;
+	}
 if (wi)
-wi->is_lhs = true;
+	{
+	  wi->is_lhs = false;
-ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
+	  wi->val_only = true;
-if (ret)
+	}
-return ret;
-if (wi)
-wi->is_lhs = false;
 break;
 case GIMPLE_CATCH:
 ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
 pset);
 else
 fn->gimple_body = seq;
 }
-/* Return the body of GIMPLE statements for function FN.  */
+/* Return the body of GIMPLE statements for function FN.  After the
+CFG pass, the function body doesn't exist anymore because it has
+been split up into basic blocks.  In this case, it returns
+NULL.  */
 gimple_seq
 gimple_body (tree fndecl)
 {
 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
 flags = flags_from_decl_or_type (TREE_TYPE (t));
 else
 flags = 0;
 }
+if (stmt->gsbase.subcode & GF_CALL_NOTHROW)
+flags |= ECF_NOTHROW;
 return flags;
+}
+/* Detects argument flags for argument number ARG on call STMT.  */
+int
+gimple_call_arg_flags (const_gimple stmt, unsigned arg)
+{
+tree type = TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt)));
+tree attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
+if (!attr)
+return 0;
+attr = TREE_VALUE (TREE_VALUE (attr));
+if (1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
+return 0;
+switch (TREE_STRING_POINTER (attr)[1 + arg])
+{
+case 'x':
+case 'X':
+return EAF_UNUSED;
+case 'R':
+return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
+case 'r':
+return EAF_NOCLOBBER | EAF_NOESCAPE;
+case 'W':
+return EAF_DIRECT | EAF_NOESCAPE;
+case 'w':
+return EAF_NOESCAPE;
+case '.':
+default:
+return 0;
+}
+}
+/* Detects return flags for the call STMT.  */
+int
+gimple_call_return_flags (const_gimple stmt)
+{
+tree type;
+tree attr = NULL_TREE;
+if (gimple_call_flags (stmt) & ECF_MALLOC)
+return ERF_NOALIAS;
+type = TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt)));
+attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
+if (!attr)
+return 0;
+attr = TREE_VALUE (TREE_VALUE (attr));
+if (TREE_STRING_LENGTH (attr) < 1)
+return 0;
+switch (TREE_STRING_POINTER (attr)[0])
+{
+case '1':
+case '2':
+case '3':
+case '4':
+return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
+case 'm':
+return ERF_NOALIAS;
+case '.':
+default:
+return 0;
+}
 }
 /* Return true if GS is a copy assignment.  */
 bool
 gimple_assign_copy_p (gimple gs)
 {
-return gimple_code (gs) == GIMPLE_ASSIGN
+return (gimple_assign_single_p (gs)
-&& get_gimple_rhs_class (gimple_assign_rhs_code (gs))
+	  && is_gimple_val (gimple_op (gs, 1)));
-== GIMPLE_SINGLE_RHS
-&& is_gimple_val (gimple_op (gs, 1));
 }
 /* Return true if GS is a SSA_NAME copy assignment.  */
 bool
 gimple_assign_ssa_name_copy_p (gimple gs)
 {
-return (gimple_code (gs) == GIMPLE_ASSIGN
+return (gimple_assign_single_p (gs)
-&& (get_gimple_rhs_class (gimple_assign_rhs_code (gs))
+	  && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
-== GIMPLE_SINGLE_RHS)
+	  && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
-&& TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
+}
-&& TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
-}
-/* Return true if GS is an assignment with a singleton RHS, i.e.,
-there is no operator associated with the assignment itself.
-Unlike gimple_assign_copy_p, this predicate returns true for
-any RHS operand, including those that perform an operation
-and do not have the semantics of a copy, such as COND_EXPR.  */
-bool
-gimple_assign_single_p (gimple gs)
-{
-return (gimple_code (gs) == GIMPLE_ASSIGN
-&& get_gimple_rhs_class (gimple_assign_rhs_code (gs))
-== GIMPLE_SINGLE_RHS);
-}
 /* Return true if GS is an assignment with a unary RHS, but the
 operator has no effect on the assigned value.  The logic is adapted
 from STRIP_NOPS.  This predicate is intended to be used in tuplifying
 instances in which STRIP_NOPS was previously applied to the RHS of
 treatment of unary NOPs is appropriate.  */
 bool
 gimple_assign_unary_nop_p (gimple gs)
 {
-return (gimple_code (gs) == GIMPLE_ASSIGN
+return (is_gimple_assign (gs)
 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
 && gimple_assign_rhs1 (gs) != error_mark_node
 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
 VEC_replace (basic_block, label_to_block_map, uid, bb);
 }
 }
-/* Fold the expression computed by STMT.  If the expression can be
-folded, return the folded result, otherwise return NULL.  STMT is
-not modified.  */
-tree
-gimple_fold (const_gimple stmt)
-{
-location_t loc = gimple_location (stmt);
-switch (gimple_code (stmt))
-{
-case GIMPLE_COND:
-return fold_binary_loc (loc, gimple_cond_code (stmt),
-boolean_type_node,
-gimple_cond_lhs (stmt),
-gimple_cond_rhs (stmt));
-case GIMPLE_ASSIGN:
-switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
-{
-case GIMPLE_UNARY_RHS:
-return fold_unary_loc (loc, gimple_assign_rhs_code (stmt),
-TREE_TYPE (gimple_assign_lhs (stmt)),
-gimple_assign_rhs1 (stmt));
-case GIMPLE_BINARY_RHS:
-return fold_binary_loc (loc, gimple_assign_rhs_code (stmt),
-TREE_TYPE (gimple_assign_lhs (stmt)),
-gimple_assign_rhs1 (stmt),
-gimple_assign_rhs2 (stmt));
-case GIMPLE_SINGLE_RHS:
-return fold (gimple_assign_rhs1 (stmt));
-default:;
-}
-break;
-case GIMPLE_SWITCH:
-return gimple_switch_index (stmt);
-case GIMPLE_CALL:
-return NULL_TREE;
-default:
-break;
-}
-gcc_unreachable ();
-}
 /* Modify the RHS of the assignment pointed-to by GSI using the
 operands in the expression tree EXPR.
 NOTE: The statement pointed-to by GSI may be reallocated if it
 did not have enough operand slots.
 void
 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
 {
 enum tree_code subcode;
-tree op1, op2;
+tree op1, op2, op3;
-extract_ops_from_tree (expr, &subcode, &op1, &op2);
+extract_ops_from_tree_1 (expr, &subcode, &op1, &op2, &op3);
-gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2);
+gimple_assign_set_rhs_with_ops_1 (gsi, subcode, op1, op2, op3);
 }
 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
-operands OP1 and OP2.
+operands OP1, OP2 and OP3.
 NOTE: The statement pointed-to by GSI may be reallocated if it
 did not have enough operand slots.  */
 void
-gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
+gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code code,
-tree op1, tree op2)
+				  tree op1, tree op2, tree op3)
 {
 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
 gimple stmt = gsi_stmt (*gsi);
 /* If the new CODE needs more operands, allocate a new statement.  */
 gimple_set_num_ops (stmt, new_rhs_ops + 1);
 gimple_set_subcode (stmt, code);
 gimple_assign_set_rhs1 (stmt, op1);
 if (new_rhs_ops > 1)
 gimple_assign_set_rhs2 (stmt, op2);
+if (new_rhs_ops > 2)
+gimple_assign_set_rhs3 (stmt, op3);
 }
 /* Return the LHS of a statement that performs an assignment,
 either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
 {
 gimple_seq new_seq;
 tree t;
 switch (gimple_code (stmt))
-{
+	{
-case GIMPLE_BIND:
+	case GIMPLE_BIND:
-new_seq = gimple_seq_copy (gimple_bind_body (stmt));
+	  new_seq = gimple_seq_copy (gimple_bind_body (stmt));
-gimple_bind_set_body (copy, new_seq);
+	  gimple_bind_set_body (copy, new_seq);
-gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
+	  gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
-gimple_bind_set_block (copy, gimple_bind_block (stmt));
+	  gimple_bind_set_block (copy, gimple_bind_block (stmt));
-break;
+	  break;
-case GIMPLE_CATCH:
+	case GIMPLE_CATCH:
-new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
+	  new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
-gimple_catch_set_handler (copy, new_seq);
+	  gimple_catch_set_handler (copy, new_seq);
-t = unshare_expr (gimple_catch_types (stmt));
+	  t = unshare_expr (gimple_catch_types (stmt));
-gimple_catch_set_types (copy, t);
+	  gimple_catch_set_types (copy, t);
-break;
+	  break;
-case GIMPLE_EH_FILTER:
+	case GIMPLE_EH_FILTER:
-new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
+	  new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
-gimple_eh_filter_set_failure (copy, new_seq);
+	  gimple_eh_filter_set_failure (copy, new_seq);
-t = unshare_expr (gimple_eh_filter_types (stmt));
+	  t = unshare_expr (gimple_eh_filter_types (stmt));
-gimple_eh_filter_set_types (copy, t);
+	  gimple_eh_filter_set_types (copy, t);
-break;
+	  break;
-case GIMPLE_TRY:
+	case GIMPLE_TRY:
-new_seq = gimple_seq_copy (gimple_try_eval (stmt));
+	  new_seq = gimple_seq_copy (gimple_try_eval (stmt));
-gimple_try_set_eval (copy, new_seq);
+	  gimple_try_set_eval (copy, new_seq);
-new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
+	  new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
-gimple_try_set_cleanup (copy, new_seq);
+	  gimple_try_set_cleanup (copy, new_seq);
-break;
+	  break;
-case GIMPLE_OMP_FOR:
+	case GIMPLE_OMP_FOR:
-new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
+	  new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
-gimple_omp_for_set_pre_body (copy, new_seq);
+	  gimple_omp_for_set_pre_body (copy, new_seq);
-t = unshare_expr (gimple_omp_for_clauses (stmt));
+	  t = unshare_expr (gimple_omp_for_clauses (stmt));
-gimple_omp_for_set_clauses (copy, t);
+	  gimple_omp_for_set_clauses (copy, t);
-copy->gimple_omp_for.iter
+	  copy->gimple_omp_for.iter
-= GGC_NEWVEC (struct gimple_omp_for_iter,
+	    = ggc_alloc_vec_gimple_omp_for_iter
-gimple_omp_for_collapse (stmt));
+	    (gimple_omp_for_collapse (stmt));
-for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
+	  for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
-{
+	    {
-gimple_omp_for_set_cond (copy, i,
+	      gimple_omp_for_set_cond (copy, i,
-gimple_omp_for_cond (stmt, i));
+				       gimple_omp_for_cond (stmt, i));
-gimple_omp_for_set_index (copy, i,
+	      gimple_omp_for_set_index (copy, i,
-gimple_omp_for_index (stmt, i));
+					gimple_omp_for_index (stmt, i));
-t = unshare_expr (gimple_omp_for_initial (stmt, i));
+	      t = unshare_expr (gimple_omp_for_initial (stmt, i));
-gimple_omp_for_set_initial (copy, i, t);
+	      gimple_omp_for_set_initial (copy, i, t);
-t = unshare_expr (gimple_omp_for_final (stmt, i));
+	      t = unshare_expr (gimple_omp_for_final (stmt, i));
-gimple_omp_for_set_final (copy, i, t);
+	      gimple_omp_for_set_final (copy, i, t);
-t = unshare_expr (gimple_omp_for_incr (stmt, i));
+	      t = unshare_expr (gimple_omp_for_incr (stmt, i));
-gimple_omp_for_set_incr (copy, i, t);
+	      gimple_omp_for_set_incr (copy, i, t);
-}
+	    }
-goto copy_omp_body;
+	  goto copy_omp_body;
-case GIMPLE_OMP_PARALLEL:
+	case GIMPLE_OMP_PARALLEL:
-t = unshare_expr (gimple_omp_parallel_clauses (stmt));
+	  t = unshare_expr (gimple_omp_parallel_clauses (stmt));
-gimple_omp_parallel_set_clauses (copy, t);
+	  gimple_omp_parallel_set_clauses (copy, t);
-t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
+	  t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
-gimple_omp_parallel_set_child_fn (copy, t);
+	  gimple_omp_parallel_set_child_fn (copy, t);
-t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
+	  t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
-gimple_omp_parallel_set_data_arg (copy, t);
+	  gimple_omp_parallel_set_data_arg (copy, t);
-goto copy_omp_body;
+	  goto copy_omp_body;
-case GIMPLE_OMP_TASK:
+	case GIMPLE_OMP_TASK:
-t = unshare_expr (gimple_omp_task_clauses (stmt));
+	  t = unshare_expr (gimple_omp_task_clauses (stmt));
-gimple_omp_task_set_clauses (copy, t);
+	  gimple_omp_task_set_clauses (copy, t);
-t = unshare_expr (gimple_omp_task_child_fn (stmt));
+	  t = unshare_expr (gimple_omp_task_child_fn (stmt));
-gimple_omp_task_set_child_fn (copy, t);
+	  gimple_omp_task_set_child_fn (copy, t);
-t = unshare_expr (gimple_omp_task_data_arg (stmt));
+	  t = unshare_expr (gimple_omp_task_data_arg (stmt));
-gimple_omp_task_set_data_arg (copy, t);
+	  gimple_omp_task_set_data_arg (copy, t);
-t = unshare_expr (gimple_omp_task_copy_fn (stmt));
+	  t = unshare_expr (gimple_omp_task_copy_fn (stmt));
-gimple_omp_task_set_copy_fn (copy, t);
+	  gimple_omp_task_set_copy_fn (copy, t);
-t = unshare_expr (gimple_omp_task_arg_size (stmt));
+	  t = unshare_expr (gimple_omp_task_arg_size (stmt));
-gimple_omp_task_set_arg_size (copy, t);
+	  gimple_omp_task_set_arg_size (copy, t);
-t = unshare_expr (gimple_omp_task_arg_align (stmt));
+	  t = unshare_expr (gimple_omp_task_arg_align (stmt));
-gimple_omp_task_set_arg_align (copy, t);
+	  gimple_omp_task_set_arg_align (copy, t);
-goto copy_omp_body;
+	  goto copy_omp_body;
-case GIMPLE_OMP_CRITICAL:
+	case GIMPLE_OMP_CRITICAL:
-t = unshare_expr (gimple_omp_critical_name (stmt));
+	  t = unshare_expr (gimple_omp_critical_name (stmt));
-gimple_omp_critical_set_name (copy, t);
+	  gimple_omp_critical_set_name (copy, t);
-goto copy_omp_body;
+	  goto copy_omp_body;
-case GIMPLE_OMP_SECTIONS:
+	case GIMPLE_OMP_SECTIONS:
-t = unshare_expr (gimple_omp_sections_clauses (stmt));
+	  t = unshare_expr (gimple_omp_sections_clauses (stmt));
-gimple_omp_sections_set_clauses (copy, t);
+	  gimple_omp_sections_set_clauses (copy, t);
-t = unshare_expr (gimple_omp_sections_control (stmt));
+	  t = unshare_expr (gimple_omp_sections_control (stmt));
-gimple_omp_sections_set_control (copy, t);
+	  gimple_omp_sections_set_control (copy, t);
-/* FALLTHRU  */
+	  /* FALLTHRU  */
-case GIMPLE_OMP_SINGLE:
+	case GIMPLE_OMP_SINGLE:
-case GIMPLE_OMP_SECTION:
+	case GIMPLE_OMP_SECTION:
-case GIMPLE_OMP_MASTER:
+	case GIMPLE_OMP_MASTER:
-case GIMPLE_OMP_ORDERED:
+	case GIMPLE_OMP_ORDERED:
-copy_omp_body:
+	copy_omp_body:
-new_seq = gimple_seq_copy (gimple_omp_body (stmt));
+	  new_seq = gimple_seq_copy (gimple_omp_body (stmt));
-gimple_omp_set_body (copy, new_seq);
+	  gimple_omp_set_body (copy, new_seq);
-break;
+	  break;
-case GIMPLE_WITH_CLEANUP_EXPR:
+	case GIMPLE_WITH_CLEANUP_EXPR:
-new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
+	  new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
-gimple_wce_set_cleanup (copy, new_seq);
+	  gimple_wce_set_cleanup (copy, new_seq);
-break;
+	  break;
-default:
+	default:
-gcc_unreachable ();
+	  gcc_unreachable ();
-}
+	}
 }
 /* Make copy of operands.  */
 if (num_ops > 0)
 {
 }
 return false;
 }
 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
-Return true if S can trap.  If INCLUDE_LHS is true and S is a
+Return true if S can trap.  When INCLUDE_MEM is true, check whether
-GIMPLE_ASSIGN, the LHS of the assignment is also checked.
+the memory operations could trap.  When INCLUDE_STORES is true and
-Otherwise, only the RHS of the assignment is checked.  */
+S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.  */
-static bool
+bool
-gimple_could_trap_p_1 (gimple s, bool include_lhs)
+gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
 {
-unsigned i, start;
 tree t, div = NULL_TREE;
 enum tree_code op;
-start = (is_gimple_assign (s) && !include_lhs) ? 1 : 0;
+if (include_mem)
+{
-for (i = start; i < gimple_num_ops (s); i++)
+unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
-if (tree_could_trap_p (gimple_op (s, i)))
-return true;
+for (i = start; i < gimple_num_ops (s); i++)
+	if (tree_could_trap_p (gimple_op (s, i)))
+	  return true;
+}
 switch (gimple_code (s))
 {
 case GIMPLE_ASM:
 return gimple_asm_volatile_p (s);
 default:
 break;
 }
 return false;
+}
-}
 /* Return true if statement S can trap.  */
 bool
 gimple_could_trap_p (gimple s)
 {
-return gimple_could_trap_p_1 (s, true);
+return gimple_could_trap_p_1 (s, true, true);
 }
 /* Return true if RHS of a GIMPLE_ASSIGN S can trap.  */
 bool
 gimple_assign_rhs_could_trap_p (gimple s)
 {
 gcc_assert (is_gimple_assign (s));
-return gimple_could_trap_p_1 (s, false);
+return gimple_could_trap_p_1 (s, true, false);
 }
 /* Print debugging information for gimple stmts generated.  */
 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
 return 1;
 else if (rhs_class == GIMPLE_BINARY_RHS)
 return 2;
+else if (rhs_class == GIMPLE_TERNARY_RHS)
+return 3;
 else
 gcc_unreachable ();
 }
-#define DEFTREECODE(SYM, STRING, TYPE, NARGS)                   \
+#define DEFTREECODE(SYM, STRING, TYPE, NARGS)   			    \
-(unsigned char)                               \
+(unsigned char)							    \
-((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS                   \
+((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS				    \
-: ((TYPE) == tcc_binary                          \
+: ((TYPE) == tcc_binary						    \
-|| (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS              \
+|| (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS   		    \
-: ((TYPE) == tcc_constant                            \
+: ((TYPE) == tcc_constant						    \
-|| (TYPE) == tcc_declaration                      \
+|| (TYPE) == tcc_declaration					    \
-|| (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS               \
+|| (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS			    \
-: ((SYM) == TRUTH_AND_EXPR                           \
+: ((SYM) == TRUTH_AND_EXPR						    \
-|| (SYM) == TRUTH_OR_EXPR                         \
+|| (SYM) == TRUTH_OR_EXPR						    \
-|| (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS               \
+|| (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS			    \
-: (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS                 \
+: (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS				    \
-: ((SYM) == COND_EXPR                            \
+: ((SYM) == WIDEN_MULT_PLUS_EXPR					    \
-|| (SYM) == CONSTRUCTOR                           \
+|| (SYM) == WIDEN_MULT_MINUS_EXPR					    \
-|| (SYM) == OBJ_TYPE_REF                          \
+|| (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS			    \
-|| (SYM) == ASSERT_EXPR                           \
+: ((SYM) == COND_EXPR						    \
-|| (SYM) == ADDR_EXPR                         \
+|| (SYM) == CONSTRUCTOR						    \
-|| (SYM) == WITH_SIZE_EXPR                        \
+|| (SYM) == OBJ_TYPE_REF						    \
-|| (SYM) == SSA_NAME                          \
+|| (SYM) == ASSERT_EXPR						    \
-|| (SYM) == POLYNOMIAL_CHREC                      \
+|| (SYM) == ADDR_EXPR						    \
-|| (SYM) == DOT_PROD_EXPR                         \
+|| (SYM) == WITH_SIZE_EXPR					    \
-|| (SYM) == VEC_COND_EXPR                         \
+|| (SYM) == SSA_NAME						    \
-|| (SYM) == REALIGN_LOAD_EXPR) ? GIMPLE_SINGLE_RHS            \
+|| (SYM) == POLYNOMIAL_CHREC					    \
+|| (SYM) == DOT_PROD_EXPR						    \
+|| (SYM) == VEC_COND_EXPR						    \
+|| (SYM) == REALIGN_LOAD_EXPR) ? GIMPLE_SINGLE_RHS		    \
 : GIMPLE_INVALID_RHS),
 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
 const unsigned char gimple_rhs_class_table[] = {
 #include "all-tree.def"
 #undef END_OF_BASE_TREE_CODES
 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi.  */
 /* Validation of GIMPLE expressions.  */
-/* Return true if OP is an acceptable tree node to be used as a GIMPLE
-operand.  */
-bool
-is_gimple_operand (const_tree op)
-{
-return op && get_gimple_rhs_class (TREE_CODE (op)) == GIMPLE_SINGLE_RHS;
-}
 /* Returns true iff T is a valid RHS for an assignment to a renamed
 user -- or front-end generated artificial -- variable.  */
 bool
 /*  Return true if T is something whose address can be taken.  */
 bool
 is_gimple_addressable (tree t)
 {
-return (is_gimple_id (t) || handled_component_p (t) || INDIRECT_REF_P (t));
+return (is_gimple_id (t) || handled_component_p (t)
+	  || TREE_CODE (t) == MEM_REF);
 }
 /* Return true if T is a valid gimple constant.  */
 bool
 return false;
 op = TREE_OPERAND (op, 0);
 }
-if (CONSTANT_CLASS_P (op) || INDIRECT_REF_P (op))
+if (CONSTANT_CLASS_P (op) || TREE_CODE (op) == MEM_REF)
 return true;
 switch (TREE_CODE (op))
 {
 case PARM_DECL:
 if (TREE_CODE (t) != ADDR_EXPR)
 return false;
 op = strip_invariant_refs (TREE_OPERAND (t, 0));
+if (!op)
-return op && (CONSTANT_CLASS_P (op) || decl_address_invariant_p (op));
+return false;
+if (TREE_CODE (op) == MEM_REF)
+{
+const_tree op0 = TREE_OPERAND (op, 0);
+return (TREE_CODE (op0) == ADDR_EXPR
+	      && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
+		  || decl_address_invariant_p (TREE_OPERAND (op0, 0))));
+}
+return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
 }
 /* Return true if T is a gimple invariant address at IPA level
 (so addresses of variables on stack are not allowed).  */
 bool
 is_gimple_min_lval (tree t)
 {
 if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
 return false;
-return (is_gimple_id (t) || TREE_CODE (t) == INDIRECT_REF);
+return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF);
-}
-/* Return true if T is a typecast operation.  */
-bool
-is_gimple_cast (tree t)
-{
-return (CONVERT_EXPR_P (t)
-|| TREE_CODE (t) == FIX_TRUNC_EXPR);
 }
 /* Return true if T is a valid function operand of a CALL_EXPR.  */
 bool
 is_gimple_call_addr (tree t)
 {
 return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
+}
+/* Return true if T is a valid address operand of a MEM_REF.  */
+bool
+is_gimple_mem_ref_addr (tree t)
+{
+return (is_gimple_reg (t)
+	  || TREE_CODE (t) == INTEGER_CST
+	  || (TREE_CODE (t) == ADDR_EXPR
+	      && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0))
+		  || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
 }
 /* If T makes a function call, return the corresponding CALL_EXPR operand.
 Otherwise, return NULL_TREE.  */
 get_base_address (tree t)
 {
 while (handled_component_p (t))
 t = TREE_OPERAND (t, 0);
-if (SSA_VAR_P (t)
+if ((TREE_CODE (t) == MEM_REF
+|| TREE_CODE (t) == TARGET_MEM_REF)
+&& TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
+t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
+if (TREE_CODE (t) == SSA_NAME
+|| DECL_P (t)
 || TREE_CODE (t) == STRING_CST
 || TREE_CODE (t) == CONSTRUCTOR
-|| INDIRECT_REF_P (t))
+|| INDIRECT_REF_P (t)
+|| TREE_CODE (t) == MEM_REF
+|| TREE_CODE (t) == TARGET_MEM_REF)
 return t;
 else
 return NULL_TREE;
 }
 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
 gimple_set_block (new_stmt, gimple_block (stmt));
 if (gimple_has_location (stmt))
 gimple_set_location (new_stmt, gimple_location (stmt));
+gimple_call_copy_flags (new_stmt, stmt);
-/* Carry all the flags to the new GIMPLE_CALL.  */
 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
-gimple_call_set_tail (new_stmt, gimple_call_tail_p (stmt));
-gimple_call_set_cannot_inline (new_stmt, gimple_call_cannot_inline_p (stmt));
-gimple_call_set_return_slot_opt (new_stmt, gimple_call_return_slot_opt_p (stmt));
-gimple_call_set_from_thunk (new_stmt, gimple_call_from_thunk_p (stmt));
-gimple_call_set_va_arg_pack (new_stmt, gimple_call_va_arg_pack_p (stmt));
 #ifndef noCbC
 gimple_call_set_cbc_goto (new_stmt, gimple_call_cbc_goto_p (stmt));
 #endif
 gimple_set_modified (new_stmt, true);
 return new_stmt;
 }
-static hashval_t gimple_type_hash (const void *);
+static hashval_t gimple_type_hash_1 (const void *, enum gtc_mode);
 /* Structure used to maintain a cache of some type pairs compared by
 gimple_types_compatible_p when comparing aggregate types.  There are
-four possible values for SAME_P:
+three possible values for SAME_P:
--2: The pair (T1, T2) has just been inserted in the table.
+	-2: The pair (T1, T2) has just been inserted in the table.
--1: The pair (T1, T2) is currently being compared.
+	 0: T1 and T2 are different types.
-0: T1 and T2 are different types.
+	 1: T1 and T2 are the same type.
-1: T1 and T2 are the same type.
+The two elements in the SAME_P array are indexed by the comparison
-This table is only used when comparing aggregate types to avoid
+mode gtc_mode.  */
-infinite recursion due to self-referential types.  */
 struct type_pair_d
 {
 unsigned int uid1;
 unsigned int uid2;
-int same_p;
+signed char same_p[2];
 };
 typedef struct type_pair_d *type_pair_t;
+DEF_VEC_P(type_pair_t);
+DEF_VEC_ALLOC_P(type_pair_t,heap);
 /* Return a hash value for the type pair pointed-to by P.  */
 static hashval_t
 type_pair_hash (const void *p)
 else
 {
 p = XOBNEW (ob_p, struct type_pair_d);
 p->uid1 = TYPE_UID (t1);
 p->uid2 = TYPE_UID (t2);
-p->same_p = -2;
+p->same_p[0] = -2;
+p->same_p[1] = -2;
 *slot = (void *) p;
 }
 return p;
 }
+/* Per pointer state for the SCC finding.  The on_sccstack flag
+is not strictly required, it is true when there is no hash value
+recorded for the type and false otherwise.  But querying that
+is slower.  */
+struct sccs
+{
+unsigned int dfsnum;
+unsigned int low;
+bool on_sccstack;
+union {
+hashval_t hash;
+signed char same_p;
+} u;
+};
+static unsigned int next_dfs_num;
+static unsigned int gtc_next_dfs_num;
+/* GIMPLE type merging cache.  A direct-mapped cache based on TYPE_UID.  */
+typedef struct GTY(()) gimple_type_leader_entry_s {
+tree type;
+tree leader;
+} gimple_type_leader_entry;
+#define GIMPLE_TYPE_LEADER_SIZE 16381
+static GTY((length("GIMPLE_TYPE_LEADER_SIZE"))) gimple_type_leader_entry
+*gimple_type_leader;
+/* Lookup an existing leader for T and return it or NULL_TREE, if
+there is none in the cache.  */
+static tree
+gimple_lookup_type_leader (tree t)
+{
+gimple_type_leader_entry *leader;
+if (!gimple_type_leader)
+return NULL_TREE;
+leader = &gimple_type_leader[TYPE_UID (t) % GIMPLE_TYPE_LEADER_SIZE];
+if (leader->type != t)
+return NULL_TREE;
+return leader->leader;
+}
 /* Return true if T1 and T2 have the same name.  If FOR_COMPLETION_P is
 true then if any type has no name return false, otherwise return
 true if both types have no names.  */
 return true;
 return false;
 }
-/* Return true if the field decls F1 and F2 are at the same offset.  */
+/* Return true if the field decls F1 and F2 are at the same offset.
+This is intended to be used on GIMPLE types only.  In order to
+compare GENERIC types, use fields_compatible_p instead.  */
 bool
-compare_field_offset (tree f1, tree f2)
+gimple_compare_field_offset (tree f1, tree f2)
 {
 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
-return (operand_equal_p (DECL_FIELD_OFFSET (f1),
+{
-DECL_FIELD_OFFSET (f2), 0)
+tree offset1 = DECL_FIELD_OFFSET (f1);
-&& tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
+tree offset2 = DECL_FIELD_OFFSET (f2);
-DECL_FIELD_BIT_OFFSET (f2)));
+return ((offset1 == offset2
+	       /* Once gimplification is done, self-referential offsets are
+		  instantiated as operand #2 of the COMPONENT_REF built for
+		  each access and reset.  Therefore, they are not relevant
+		  anymore and fields are interchangeable provided that they
+		  represent the same access.  */
+	       || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
+		   && TREE_CODE (offset2) == PLACEHOLDER_EXPR
+		   && (DECL_SIZE (f1) == DECL_SIZE (f2)
+		       || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
+			   && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
+		       || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
+		   && DECL_ALIGN (f1) == DECL_ALIGN (f2))
+	       || operand_equal_p (offset1, offset2, 0))
+	      && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
+				     DECL_FIELD_BIT_OFFSET (f2)));
+}
 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
 should be, so handle differing ones specially by decomposing
 the offset into a byte and bit offset manually.  */
 if (host_integerp (DECL_FIELD_OFFSET (f1), 0)
 }
 return false;
 }
-/* Return 1 iff T1 and T2 are structurally identical.
+/* If the type T1 and the type T2 are a complete and an incomplete
-Otherwise, return 0.  */
+variant of the same type return true.  */
-static int
+static bool
-gimple_types_compatible_p (tree t1, tree t2)
+gimple_compatible_complete_and_incomplete_subtype_p (tree t1, tree t2)
 {
-type_pair_t p = NULL;
+/* If one pointer points to an incomplete type variant of
+the other pointed-to type they are the same.  */
+if (TREE_CODE (t1) == TREE_CODE (t2)
+&& RECORD_OR_UNION_TYPE_P (t1)
+&& (!COMPLETE_TYPE_P (t1)
+	  || !COMPLETE_TYPE_P (t2))
+&& TYPE_QUALS (t1) == TYPE_QUALS (t2)
+&& compare_type_names_p (TYPE_MAIN_VARIANT (t1),
+			       TYPE_MAIN_VARIANT (t2), true))
+return true;
+return false;
+}
+static bool
+gimple_types_compatible_p_1 (tree, tree, enum gtc_mode, type_pair_t,
+			     VEC(type_pair_t, heap) **,
+			     struct pointer_map_t *, struct obstack *);
+/* DFS visit the edge from the callers type pair with state *STATE to
+the pair T1, T2 while operating in FOR_MERGING_P mode.
+Update the merging status if it is not part of the SCC containing the
+callers pair and return it.
+SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.  */
+static bool
+gtc_visit (tree t1, tree t2, enum gtc_mode mode,
+	   struct sccs *state,
+	   VEC(type_pair_t, heap) **sccstack,
+	   struct pointer_map_t *sccstate,
+	   struct obstack *sccstate_obstack)
+{
+struct sccs *cstate = NULL;
+type_pair_t p;
+void **slot;
 /* Check first for the obvious case of pointer identity.  */
 if (t1 == t2)
-return 1;
+return true;
 /* Check that we have two types to compare.  */
 if (t1 == NULL_TREE || t2 == NULL_TREE)
-return 0;
+return false;
+/* If the types have been previously registered and found equal
+they still are.  */
+if (mode == GTC_MERGE)
+{
+tree leader1 = gimple_lookup_type_leader (t1);
+tree leader2 = gimple_lookup_type_leader (t2);
+if (leader1 == t2
+	  || t1 == leader2
+	  || (leader1 && leader1 == leader2))
+	return true;
+}
+else if (mode == GTC_DIAG)
+{
+if (TYPE_CANONICAL (t1)
+	  && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
+	return true;
+}
 /* Can't be the same type if the types don't have the same code.  */
 if (TREE_CODE (t1) != TREE_CODE (t2))
-return 0;
+return false;
 /* Can't be the same type if they have different CV qualifiers.  */
 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
-return 0;
+return false;
 /* Void types are always the same.  */
 if (TREE_CODE (t1) == VOID_TYPE)
-return 1;
+return true;
-/* For numerical types do some simple checks before doing three
+/* Do some simple checks before doing three hashtable queries.  */
-hashtable queries.  */
 if (INTEGRAL_TYPE_P (t1)
 || SCALAR_FLOAT_TYPE_P (t1)
 || FIXED_POINT_TYPE_P (t1)
 || TREE_CODE (t1) == VECTOR_TYPE
 || TREE_CODE (t1) == COMPLEX_TYPE
 || TREE_CODE (t1) == OFFSET_TYPE)
 {
 /* Can't be the same type if they have different alignment,
 sign, precision or mode.  */
 if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
-|| TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
+	  || TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
-|| TYPE_MODE (t1) != TYPE_MODE (t2)
+	  || TYPE_MODE (t1) != TYPE_MODE (t2)
-|| TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
+	  || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
-return 0;
+	return false;
 if (TREE_CODE (t1) == INTEGER_TYPE
-&& (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
+	  && (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
-|| TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
+	      || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
-return 0;
+	return false;
 /* That's all we need to check for float and fixed-point types.  */
 if (SCALAR_FLOAT_TYPE_P (t1)
-|| FIXED_POINT_TYPE_P (t1))
+	  || FIXED_POINT_TYPE_P (t1))
-return 1;
+	return true;
-/* Perform cheap tail-recursion for vector and complex types.  */
-if (TREE_CODE (t1) == VECTOR_TYPE
-|| TREE_CODE (t1) == COMPLEX_TYPE)
-return gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2));
 /* For integral types fall thru to more complex checks.  */
+}
+else if (AGGREGATE_TYPE_P (t1) || POINTER_TYPE_P (t1))
+{
+/* Can't be the same type if they have different alignment or mode.  */
+if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
+	  || TYPE_MODE (t1) != TYPE_MODE (t2))
+	return false;
 }
 /* If the hash values of t1 and t2 are different the types can't
 possibly be the same.  This helps keeping the type-pair hashtable
 small, only tracking comparisons for hash collisions.  */
-if (gimple_type_hash (t1) != gimple_type_hash (t2))
+if (gimple_type_hash_1 (t1, mode) != gimple_type_hash_1 (t2, mode))
-return 0;
+return false;
-/* If we've visited this type pair before (in the case of aggregates
+/* Allocate a new cache entry for this comparison.  */
-with self-referential types), and we made a decision, return it.  */
 p = lookup_type_pair (t1, t2, &gtc_visited, &gtc_ob);
-if (p->same_p == 0 || p->same_p == 1)
+if (p->same_p[mode] == 0 || p->same_p[mode] == 1)
 {
 /* We have already decided whether T1 and T2 are the
-same, return the cached result.  */
+	 same, return the cached result.  */
-return p->same_p == 1;
+return p->same_p[mode] == 1;
 }
-else if (p->same_p == -1)
-{
+if ((slot = pointer_map_contains (sccstate, p)) != NULL)
-/* We are currently comparing this pair of types, assume
+cstate = (struct sccs *)*slot;
-that they are the same and let the caller decide.  */
+/* Not yet visited.  DFS recurse.  */
-return 1;
+if (!cstate)
-}
+{
+gimple_types_compatible_p_1 (t1, t2, mode, p,
-gcc_assert (p->same_p == -2);
+				   sccstack, sccstate, sccstate_obstack);
+cstate = (struct sccs *)* pointer_map_contains (sccstate, p);
-/* Mark the (T1, T2) comparison in progress.  */
+state->low = MIN (state->low, cstate->low);
-p->same_p = -1;
+}
+/* If the type is still on the SCC stack adjust the parents low.  */
+if (cstate->dfsnum < state->dfsnum
+&& cstate->on_sccstack)
+state->low = MIN (cstate->dfsnum, state->low);
+/* Return the current lattice value.  We start with an equality
+assumption so types part of a SCC will be optimistically
+treated equal unless proven otherwise.  */
+return cstate->u.same_p;
+}
+/* Worker for gimple_types_compatible.
+SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.  */
+static bool
+gimple_types_compatible_p_1 (tree t1, tree t2, enum gtc_mode mode,
+			     type_pair_t p,
+			     VEC(type_pair_t, heap) **sccstack,
+			     struct pointer_map_t *sccstate,
+			     struct obstack *sccstate_obstack)
+{
+struct sccs *state;
+gcc_assert (p->same_p[mode] == -2);
+state = XOBNEW (sccstate_obstack, struct sccs);
+*pointer_map_insert (sccstate, p) = state;
+VEC_safe_push (type_pair_t, heap, *sccstack, p);
+state->dfsnum = gtc_next_dfs_num++;
+state->low = state->dfsnum;
+state->on_sccstack = true;
+/* Start with an equality assumption.  As we DFS recurse into child
+SCCs this assumption may get revisited.  */
+state->u.same_p = 1;
 /* If their attributes are not the same they can't be the same type.  */
 if (!attribute_list_equal (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)))
 goto different_types;
 /* Do type-specific comparisons.  */
 switch (TREE_CODE (t1))
 {
+case VECTOR_TYPE:
+case COMPLEX_TYPE:
+if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2), mode,
+		      state, sccstack, sccstate, sccstate_obstack))
+	goto different_types;
+goto same_types;
 case ARRAY_TYPE:
 /* Array types are the same if the element types are the same and
-the number of elements are the same.  */
+	 the number of elements are the same.  */
-if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
+if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2), mode,
-|| TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
+		      state, sccstack, sccstate, sccstate_obstack)
-|| TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
+	  || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
-goto different_types;
+	  || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
+	goto different_types;
 else
-{
+	{
-tree i1 = TYPE_DOMAIN (t1);
+	  tree i1 = TYPE_DOMAIN (t1);
-tree i2 = TYPE_DOMAIN (t2);
+	  tree i2 = TYPE_DOMAIN (t2);
-/* For an incomplete external array, the type domain can be
+	  /* For an incomplete external array, the type domain can be
-NULL_TREE.  Check this condition also.  */
+	     NULL_TREE.  Check this condition also.  */
-if (i1 == NULL_TREE && i2 == NULL_TREE)
+	  if (i1 == NULL_TREE && i2 == NULL_TREE)
-goto same_types;
+	    goto same_types;
-else if (i1 == NULL_TREE || i2 == NULL_TREE)
+	  else if (i1 == NULL_TREE || i2 == NULL_TREE)
-goto different_types;
+	    goto different_types;
-/* If for a complete array type the possibly gimplified sizes
+	  /* If for a complete array type the possibly gimplified sizes
-are different the types are different.  */
+	     are different the types are different.  */
-else if (((TYPE_SIZE (i1) != NULL) ^ (TYPE_SIZE (i2) != NULL))
+	  else if (((TYPE_SIZE (i1) != NULL) ^ (TYPE_SIZE (i2) != NULL))
-|| (TYPE_SIZE (i1)
+		   || (TYPE_SIZE (i1)
-&& TYPE_SIZE (i2)
+		       && TYPE_SIZE (i2)
-&& !operand_equal_p (TYPE_SIZE (i1), TYPE_SIZE (i2), 0)))
+		       && !operand_equal_p (TYPE_SIZE (i1), TYPE_SIZE (i2), 0)))
-goto different_types;
+	    goto different_types;
-else
+	  else
-{
+	    {
-tree min1 = TYPE_MIN_VALUE (i1);
+	      tree min1 = TYPE_MIN_VALUE (i1);
-tree min2 = TYPE_MIN_VALUE (i2);
+	      tree min2 = TYPE_MIN_VALUE (i2);
-tree max1 = TYPE_MAX_VALUE (i1);
+	      tree max1 = TYPE_MAX_VALUE (i1);
-tree max2 = TYPE_MAX_VALUE (i2);
+	      tree max2 = TYPE_MAX_VALUE (i2);
-/* The minimum/maximum values have to be the same.  */
+	      /* The minimum/maximum values have to be the same.  */
-if ((min1 == min2
+	      if ((min1 == min2
-|| (min1 && min2 && operand_equal_p (min1, min2, 0)))
+		   || (min1 && min2
-&& (max1 == max2
+		       && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
-|| (max1 && max2 && operand_equal_p (max1, max2, 0))))
+			    && TREE_CODE (min2) == PLACEHOLDER_EXPR)
-goto same_types;
+		           || operand_equal_p (min1, min2, 0))))
-else
+		  && (max1 == max2
-goto different_types;
+		      || (max1 && max2
-}
+			  && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
-}
+			       && TREE_CODE (max2) == PLACEHOLDER_EXPR)
+			      || operand_equal_p (max1, max2, 0)))))
+		goto same_types;
+	      else
+		goto different_types;
+	    }
+	}
 case METHOD_TYPE:
 /* Method types should belong to the same class.  */
-if (!gimple_types_compatible_p (TYPE_METHOD_BASETYPE (t1),
+if (!gtc_visit (TYPE_METHOD_BASETYPE (t1), TYPE_METHOD_BASETYPE (t2),
-TYPE_METHOD_BASETYPE (t2)))
+		      mode, state, sccstack, sccstate, sccstate_obstack))
-goto different_types;
+	goto different_types;
 /* Fallthru  */
 case FUNCTION_TYPE:
 /* Function types are the same if the return type and arguments types
-are the same.  */
+	 are the same.  */
-if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
+if ((mode != GTC_DIAG
-goto different_types;
+	   || !gimple_compatible_complete_and_incomplete_subtype_p
+	         (TREE_TYPE (t1), TREE_TYPE (t2)))
+	  && !gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2), mode,
+			 state, sccstack, sccstate, sccstate_obstack))
+	goto different_types;
+if (!targetm.comp_type_attributes (t1, t2))
+	goto different_types;
+if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
+	goto same_types;
 else
-{
+	{
-if (!targetm.comp_type_attributes (t1, t2))
+	  tree parms1, parms2;
-goto different_types;
+	  for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
-if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
+	       parms1 && parms2;
-goto same_types;
+	       parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
-else
+	    {
-{
+	      if ((mode == GTC_MERGE
-tree parms1, parms2;
+		   || !gimple_compatible_complete_and_incomplete_subtype_p
+		         (TREE_VALUE (parms1), TREE_VALUE (parms2)))
-for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
+		  && !gtc_visit (TREE_VALUE (parms1), TREE_VALUE (parms2), mode,
-parms1 && parms2;
+				 state, sccstack, sccstate, sccstate_obstack))
-parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
+		goto different_types;
-{
+	    }
-if (!gimple_types_compatible_p (TREE_VALUE (parms1),
-TREE_VALUE (parms2)))
+	  if (parms1 || parms2)
-goto different_types;
+	    goto different_types;
-}
+	  goto same_types;
-if (parms1 || parms2)
+	}
-goto different_types;
-goto same_types;
-}
-}
 case OFFSET_TYPE:
 {
-if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
+	if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2), mode,
-|| !gimple_types_compatible_p (TYPE_OFFSET_BASETYPE (t1),
+			state, sccstack, sccstate, sccstate_obstack)
-TYPE_OFFSET_BASETYPE (t2)))
+	    || !gtc_visit (TYPE_OFFSET_BASETYPE (t1),
-goto different_types;
+			   TYPE_OFFSET_BASETYPE (t2), mode,
+			   state, sccstack, sccstate, sccstate_obstack))
-goto same_types;
+	  goto different_types;
+	goto same_types;
 }
 case POINTER_TYPE:
 case REFERENCE_TYPE:
 {
-/* If the two pointers have different ref-all attributes,
+	/* If the two pointers have different ref-all attributes,
-they can't be the same type.  */
+	   they can't be the same type.  */
-if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
+	if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
-goto different_types;
+	  goto different_types;
-/* If one pointer points to an incomplete type variant of
+	/* If one pointer points to an incomplete type variant of
-the other pointed-to type they are the same.  */
+	   the other pointed-to type they are the same.  */
-if (TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2))
+	if (mode == GTC_DIAG
-&& RECORD_OR_UNION_TYPE_P (TREE_TYPE (t1))
+	    && gimple_compatible_complete_and_incomplete_subtype_p
-&& (!COMPLETE_TYPE_P (TREE_TYPE (t1))
+	         (TREE_TYPE (t1), TREE_TYPE (t2)))
-|| !COMPLETE_TYPE_P (TREE_TYPE (t2)))
+	  goto same_types;
-&& compare_type_names_p (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
-TYPE_MAIN_VARIANT (TREE_TYPE (t2)), true))
+	/* Otherwise, pointer and reference types are the same if the
-{
+	   pointed-to types are the same.  */
-/* Replace the pointed-to incomplete type with the
+	if (gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2), mode,
-complete one.  */
+		       state, sccstack, sccstate, sccstate_obstack))
-if (COMPLETE_TYPE_P (TREE_TYPE (t2)))
+	  goto same_types;
-TREE_TYPE (t1) = TREE_TYPE (t2);
-else
+	goto different_types;
-TREE_TYPE (t2) = TREE_TYPE (t1);
-goto same_types;
 }
-/* Otherwise, pointer and reference types are the same if the
+case NULLPTR_TYPE:
-pointed-to types are the same.  */
+/* There is only one decltype(nullptr).  */
-if (gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
 goto same_types;
-goto different_types;
-}
 case INTEGER_TYPE:
 case BOOLEAN_TYPE:
 {
 tree min1 = TYPE_MIN_VALUE (t1);
 case RECORD_TYPE:
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 {
-tree f1, f2;
+	tree f1, f2;
-/* If one type requires structural equality checks and the
+	/* The struct tags shall compare equal.  */
-other doesn't, do not merge the types.  */
+	if (mode == GTC_MERGE
-if (TYPE_STRUCTURAL_EQUALITY_P (t1)
+	    && !compare_type_names_p (TYPE_MAIN_VARIANT (t1),
-!= TYPE_STRUCTURAL_EQUALITY_P (t2))
+				      TYPE_MAIN_VARIANT (t2), false))
-goto different_types;
+	  goto different_types;
-/* The struct tags shall compare equal.  */
+	/* For aggregate types, all the fields must be the same.  */
-if (!compare_type_names_p (TYPE_MAIN_VARIANT (t1),
+	for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
-TYPE_MAIN_VARIANT (t2), false))
+	     f1 && f2;
-goto different_types;
+	     f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
+	  {
-/* For aggregate types, all the fields must be the same.  */
+	    /* The fields must have the same name, offset and type.  */
-for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
+	    if ((mode == GTC_MERGE
-f1 && f2;
+		 && DECL_NAME (f1) != DECL_NAME (f2))
-f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
+		|| DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
-{
+		|| !gimple_compare_field_offset (f1, f2)
-/* The fields must have the same name, offset and type.  */
+		|| !gtc_visit (TREE_TYPE (f1), TREE_TYPE (f2), mode,
-if (DECL_NAME (f1) != DECL_NAME (f2)
+			       state, sccstack, sccstate, sccstate_obstack))
-|| DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
+	      goto different_types;
-|| !compare_field_offset (f1, f2)
+	  }
-|| !gimple_types_compatible_p (TREE_TYPE (f1),
-TREE_TYPE (f2)))
+	/* If one aggregate has more fields than the other, they
-goto different_types;
+	   are not the same.  */
-}
+	if (f1 || f2)
+	  goto different_types;
-/* If one aggregate has more fields than the other, they
-are not the same.  */
+	goto same_types;
-if (f1 || f2)
-goto different_types;
-goto same_types;
 }
 default:
 gcc_unreachable ();
 }
 /* Common exit path for types that are not compatible.  */
 different_types:
-p->same_p = 0;
+state->u.same_p = 0;
-return 0;
+goto pop;
 /* Common exit path for types that are compatible.  */
 same_types:
-p->same_p = 1;
+gcc_assert (state->u.same_p == 1);
-return 1;
-}
+pop:
+if (state->low == state->dfsnum)
+{
+type_pair_t x;
-/* Per pointer state for the SCC finding.  The on_sccstack flag
+/* Pop off the SCC and set its cache values to the final
-is not strictly required, it is true when there is no hash value
+comparison result.  */
-recorded for the type and false otherwise.  But querying that
+do
-is slower.  */
+	{
+	  struct sccs *cstate;
-struct sccs
+	  x = VEC_pop (type_pair_t, *sccstack);
-{
+	  cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
-unsigned int dfsnum;
+	  cstate->on_sccstack = false;
-unsigned int low;
+	  x->same_p[mode] = state->u.same_p;
-bool on_sccstack;
+	}
-hashval_t hash;
+while (x != p);
-};
+}
-static unsigned int next_dfs_num;
+return state->u.same_p;
+}
+/* Return true iff T1 and T2 are structurally identical.  When
+FOR_MERGING_P is true the an incomplete type and a complete type
+are considered different, otherwise they are considered compatible.  */
+bool
+gimple_types_compatible_p (tree t1, tree t2, enum gtc_mode mode)
+{
+VEC(type_pair_t, heap) *sccstack = NULL;
+struct pointer_map_t *sccstate;
+struct obstack sccstate_obstack;
+type_pair_t p = NULL;
+bool res;
+/* Before starting to set up the SCC machinery handle simple cases.  */
+/* Check first for the obvious case of pointer identity.  */
+if (t1 == t2)
+return true;
+/* Check that we have two types to compare.  */
+if (t1 == NULL_TREE || t2 == NULL_TREE)
+return false;
+/* If the types have been previously registered and found equal
+they still are.  */
+if (mode == GTC_MERGE)
+{
+tree leader1 = gimple_lookup_type_leader (t1);
+tree leader2 = gimple_lookup_type_leader (t2);
+if (leader1 == t2
+	  || t1 == leader2
+	  || (leader1 && leader1 == leader2))
+	return true;
+}
+else if (mode == GTC_DIAG)
+{
+if (TYPE_CANONICAL (t1)
+	  && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
+	return true;
+}
+/* Can't be the same type if the types don't have the same code.  */
+if (TREE_CODE (t1) != TREE_CODE (t2))
+return false;
+/* Can't be the same type if they have different CV qualifiers.  */
+if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
+return false;
+/* Void types are always the same.  */
+if (TREE_CODE (t1) == VOID_TYPE)
+return true;
+/* Do some simple checks before doing three hashtable queries.  */
+if (INTEGRAL_TYPE_P (t1)
+|| SCALAR_FLOAT_TYPE_P (t1)
+|| FIXED_POINT_TYPE_P (t1)
+|| TREE_CODE (t1) == VECTOR_TYPE
+|| TREE_CODE (t1) == COMPLEX_TYPE
+|| TREE_CODE (t1) == OFFSET_TYPE)
+{
+/* Can't be the same type if they have different alignment,
+	 sign, precision or mode.  */
+if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
+	  || TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
+	  || TYPE_MODE (t1) != TYPE_MODE (t2)
+	  || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
+	return false;
+if (TREE_CODE (t1) == INTEGER_TYPE
+	  && (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
+	      || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
+	return false;
+/* That's all we need to check for float and fixed-point types.  */
+if (SCALAR_FLOAT_TYPE_P (t1)
+	  || FIXED_POINT_TYPE_P (t1))
+	return true;
+/* For integral types fall thru to more complex checks.  */
+}
+else if (AGGREGATE_TYPE_P (t1) || POINTER_TYPE_P (t1))
+{
+/* Can't be the same type if they have different alignment or mode.  */
+if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
+	  || TYPE_MODE (t1) != TYPE_MODE (t2))
+	return false;
+}
+/* If the hash values of t1 and t2 are different the types can't
+possibly be the same.  This helps keeping the type-pair hashtable
+small, only tracking comparisons for hash collisions.  */
+if (gimple_type_hash_1 (t1, mode) != gimple_type_hash_1 (t2, mode))
+return false;
+/* If we've visited this type pair before (in the case of aggregates
+with self-referential types), and we made a decision, return it.  */
+p = lookup_type_pair (t1, t2, &gtc_visited, &gtc_ob);
+if (p->same_p[mode] == 0 || p->same_p[mode] == 1)
+{
+/* We have already decided whether T1 and T2 are the
+	 same, return the cached result.  */
+return p->same_p[mode] == 1;
+}
+/* Now set up the SCC machinery for the comparison.  */
+gtc_next_dfs_num = 1;
+sccstate = pointer_map_create ();
+gcc_obstack_init (&sccstate_obstack);
+res = gimple_types_compatible_p_1 (t1, t2, mode, p,
+				     &sccstack, sccstate, &sccstate_obstack);
+VEC_free (type_pair_t, heap, sccstack);
+pointer_map_destroy (sccstate);
+obstack_free (&sccstate_obstack, NULL);
+return res;
+}
 static hashval_t
 iterative_hash_gimple_type (tree, hashval_t, VEC(tree, heap) **,
-struct pointer_map_t *, struct obstack *);
+			    struct pointer_map_t *, struct obstack *,
+			    enum gtc_mode);
 /* DFS visit the edge from the callers type with state *STATE to T.
 Update the callers type hash V with the hash for T if it is not part
 of the SCC containing the callers type and return it.
 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.  */
 static hashval_t
 visit (tree t, struct sccs *state, hashval_t v,
 VEC (tree, heap) **sccstack,
 struct pointer_map_t *sccstate,
-struct obstack *sccstate_obstack)
+struct obstack *sccstate_obstack, enum gtc_mode mode)
 {
 struct sccs *cstate = NULL;
+struct tree_int_map m;
 void **slot;
 /* If there is a hash value recorded for this type then it can't
 possibly be part of our parent SCC.  Simply mix in its hash.  */
-if ((slot = pointer_map_contains (type_hash_cache, t)))
+m.base.from = t;
-return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, v);
+if ((slot = htab_find_slot (mode == GTC_MERGE
+			      ? type_hash_cache : canonical_type_hash_cache,
+			      &m, NO_INSERT))
+&& *slot)
+return iterative_hash_hashval_t (((struct tree_int_map *) *slot)->to, v);
 if ((slot = pointer_map_contains (sccstate, t)) != NULL)
 cstate = (struct sccs *)*slot;
 if (!cstate)
 {
 hashval_t tem;
 /* Not yet visited.  DFS recurse.  */
 tem = iterative_hash_gimple_type (t, v,
-sccstack, sccstate, sccstate_obstack);
+					sccstack, sccstate, sccstate_obstack,
+					mode);
 if (!cstate)
 cstate = (struct sccs *)* pointer_map_contains (sccstate, t);
 state->low = MIN (state->low, cstate->low);
 /* If the type is no longer on the SCC stack and thus is not part
 of the parents SCC mix in its hash value.  Otherwise we will
 all.  To make this work we have to delay setting the hash
 values of the SCC until it is complete.  */
 static hashval_t
 iterative_hash_gimple_type (tree type, hashval_t val,
-VEC(tree, heap) **sccstack,
+			    VEC(tree, heap) **sccstack,
-struct pointer_map_t *sccstate,
+			    struct pointer_map_t *sccstate,
-struct obstack *sccstate_obstack)
+			    struct obstack *sccstate_obstack,
+			    enum gtc_mode mode)
 {
 hashval_t v;
 void **slot;
 struct sccs *state;
-#ifdef ENABLE_CHECKING
+/* Not visited during this DFS walk.  */
-/* Not visited during this DFS walk nor during previous walks.  */
+gcc_checking_assert (!pointer_map_contains (sccstate, type));
-gcc_assert (!pointer_map_contains (type_hash_cache, type)
-&& !pointer_map_contains (sccstate, type));
-#endif
 state = XOBNEW (sccstate_obstack, struct sccs);
 *pointer_map_insert (sccstate, type) = state;
 VEC_safe_push (tree, heap, *sccstack, type);
 state->dfsnum = next_dfs_num++;
 pointed to but do not recurse into possibly incomplete types to
 avoid hash differences for complete vs. incomplete types.  */
 if (POINTER_TYPE_P (type))
 {
 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
-{
+	{
-v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
+	  v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
-v = iterative_hash_name
+	  v = iterative_hash_name
-(TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v);
+		(TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v);
-}
+	}
 else
-v = visit (TREE_TYPE (type), state, v,
+	v = visit (TREE_TYPE (type), state, v,
-sccstack, sccstate, sccstate_obstack);
+		   sccstack, sccstate, sccstate_obstack, mode);
 }
 /* For integer types hash the types min/max values and the string flag.  */
 if (TREE_CODE (type) == INTEGER_TYPE)
 {
-v = iterative_hash_expr (TYPE_MIN_VALUE (type), v);
+/* OMP lowering can introduce error_mark_node in place of
-v = iterative_hash_expr (TYPE_MAX_VALUE (type), v);
+	 random local decls in types.  */
+if (TYPE_MIN_VALUE (type) != error_mark_node)
+	v = iterative_hash_expr (TYPE_MIN_VALUE (type), v);
+if (TYPE_MAX_VALUE (type) != error_mark_node)
+	v = iterative_hash_expr (TYPE_MAX_VALUE (type), v);
 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
 }
 /* For array types hash their domain and the string flag.  */
 if (TREE_CODE (type) == ARRAY_TYPE
 && TYPE_DOMAIN (type))
 {
 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
 v = visit (TYPE_DOMAIN (type), state, v,
-sccstack, sccstate, sccstate_obstack);
+		 sccstack, sccstate, sccstate_obstack, mode);
 }
 /* Recurse for aggregates with a single element type.  */
 if (TREE_CODE (type) == ARRAY_TYPE
 || TREE_CODE (type) == COMPLEX_TYPE
 || TREE_CODE (type) == VECTOR_TYPE)
 v = visit (TREE_TYPE (type), state, v,
-sccstack, sccstate, sccstate_obstack);
+	       sccstack, sccstate, sccstate_obstack, mode);
 /* Incorporate function return and argument types.  */
 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
 {
 unsigned na;
 tree p;
 /* For method types also incorporate their parent class.  */
 if (TREE_CODE (type) == METHOD_TYPE)
-v = visit (TYPE_METHOD_BASETYPE (type), state, v,
+	v = visit (TYPE_METHOD_BASETYPE (type), state, v,
-sccstack, sccstate, sccstate_obstack);
+		   sccstack, sccstate, sccstate_obstack, mode);
-v = visit (TREE_TYPE (type), state, v,
+/* For result types allow mismatch in completeness.  */
-sccstack, sccstate, sccstate_obstack);
+if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
+	{
+	  v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
+	  v = iterative_hash_name
+		(TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v);
+	}
+else
+	v = visit (TREE_TYPE (type), state, v,
+		   sccstack, sccstate, sccstate_obstack, mode);
 for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
-{
+	{
-v = visit (TREE_VALUE (p), state, v,
+	  /* For argument types allow mismatch in completeness.  */
-sccstack, sccstate, sccstate_obstack);
+	  if (RECORD_OR_UNION_TYPE_P (TREE_VALUE (p)))
-na++;
+	    {
-}
+	      v = iterative_hash_hashval_t (TREE_CODE (TREE_VALUE (p)), v);
+	      v = iterative_hash_name
+		    (TYPE_NAME (TYPE_MAIN_VARIANT (TREE_VALUE (p))), v);
+	    }
+	  else
+	    v = visit (TREE_VALUE (p), state, v,
+		       sccstack, sccstate, sccstate_obstack, mode);
+	  na++;
+	}
 v = iterative_hash_hashval_t (na, v);
 }
 if (TREE_CODE (type) == RECORD_TYPE
 || TREE_CODE (type) == QUAL_UNION_TYPE)
 {
 unsigned nf;
 tree f;
-v = iterative_hash_name (TYPE_NAME (TYPE_MAIN_VARIANT (type)), v);
+if (mode == GTC_MERGE)
+	v = iterative_hash_name (TYPE_NAME (TYPE_MAIN_VARIANT (type)), v);
 for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
-{
+	{
-v = iterative_hash_name (DECL_NAME (f), v);
+	  if (mode == GTC_MERGE)
-v = visit (TREE_TYPE (f), state, v,
+	    v = iterative_hash_name (DECL_NAME (f), v);
-sccstack, sccstate, sccstate_obstack);
+	  v = visit (TREE_TYPE (f), state, v,
-nf++;
+		     sccstack, sccstate, sccstate_obstack, mode);
-}
+	  nf++;
+	}
 v = iterative_hash_hashval_t (nf, v);
 }
 /* Record hash for us.  */
-state->hash = v;
+state->u.hash = v;
 /* See if we found an SCC.  */
 if (state->low == state->dfsnum)
 {
 tree x;
 /* Pop off the SCC and set its hash values.  */
 do
-{
+	{
-struct sccs *cstate;
+	  struct sccs *cstate;
-x = VEC_pop (tree, *sccstack);
+	  struct tree_int_map *m = ggc_alloc_cleared_tree_int_map ();
-gcc_assert (!pointer_map_contains (type_hash_cache, x));
+	  x = VEC_pop (tree, *sccstack);
-cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
+	  cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
-cstate->on_sccstack = false;
+	  cstate->on_sccstack = false;
-slot = pointer_map_insert (type_hash_cache, x);
+	  m->base.from = x;
-*slot = (void *) (size_t) cstate->hash;
+	  m->to = cstate->u.hash;
-}
+	  slot = htab_find_slot (mode == GTC_MERGE
+				 ? type_hash_cache : canonical_type_hash_cache,
+				 m, INSERT);
+	  gcc_assert (!*slot);
+	  *slot = (void *) m;
+	}
 while (x != type);
 }
 return iterative_hash_hashval_t (v, val);
 }
 This function should produce the same hash value for two compatible
 types according to gimple_types_compatible_p.  */
 static hashval_t
-gimple_type_hash (const void *p)
+gimple_type_hash_1 (const void *p, enum gtc_mode mode)
 {
 const_tree t = (const_tree) p;
 VEC(tree, heap) *sccstack = NULL;
 struct pointer_map_t *sccstate;
 struct obstack sccstate_obstack;
 hashval_t val;
 void **slot;
+struct tree_int_map m;
-if (type_hash_cache == NULL)
-type_hash_cache = pointer_map_create ();
+if (mode == GTC_MERGE
+&& type_hash_cache == NULL)
-if ((slot = pointer_map_contains (type_hash_cache, p)) != NULL)
+type_hash_cache = htab_create_ggc (512, tree_int_map_hash,
-return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, 0);
+				       tree_int_map_eq, NULL);
+else if (mode == GTC_DIAG
+	   && canonical_type_hash_cache == NULL)
+canonical_type_hash_cache = htab_create_ggc (512, tree_int_map_hash,
+						 tree_int_map_eq, NULL);
+m.base.from = CONST_CAST_TREE (t);
+if ((slot = htab_find_slot (mode == GTC_MERGE
+			      ? type_hash_cache : canonical_type_hash_cache,
+			      &m, NO_INSERT))
+&& *slot)
+return iterative_hash_hashval_t (((struct tree_int_map *) *slot)->to, 0);
 /* Perform a DFS walk and pre-hash all reachable types.  */
 next_dfs_num = 1;
 sccstate = pointer_map_create ();
 gcc_obstack_init (&sccstate_obstack);
 val = iterative_hash_gimple_type (CONST_CAST_TREE (t), 0,
-&sccstack, sccstate, &sccstate_obstack);
+				    &sccstack, sccstate, &sccstate_obstack,
+				    mode);
 VEC_free (tree, heap, sccstack);
 pointer_map_destroy (sccstate);
 obstack_free (&sccstate_obstack, NULL);
 return val;
 }
+static hashval_t
+gimple_type_hash (const void *p)
+{
+return gimple_type_hash_1 (p, GTC_MERGE);
+}
+static hashval_t
+gimple_canonical_type_hash (const void *p)
+{
+return gimple_type_hash_1 (p, GTC_DIAG);
+}
 /* Returns nonzero if P1 and P2 are equal.  */
 static int
 gimple_type_eq (const void *p1, const void *p2)
 {
 const_tree t1 = (const_tree) p1;
 const_tree t2 = (const_tree) p2;
-return gimple_types_compatible_p (CONST_CAST_TREE (t1), CONST_CAST_TREE (t2));
+return gimple_types_compatible_p (CONST_CAST_TREE (t1),
+				    CONST_CAST_TREE (t2), GTC_MERGE);
 }
 /* Register type T in the global type table gimple_types.
 If another type T', compatible with T, already existed in
 tree
 gimple_register_type (tree t)
 {
 void **slot;
+gimple_type_leader_entry *leader;
+tree mv_leader = NULL_TREE;
 gcc_assert (TYPE_P (t));
+if (!gimple_type_leader)
+gimple_type_leader = ggc_alloc_cleared_vec_gimple_type_leader_entry_s
+				(GIMPLE_TYPE_LEADER_SIZE);
+/* If we registered this type before return the cached result.  */
+leader = &gimple_type_leader[TYPE_UID (t) % GIMPLE_TYPE_LEADER_SIZE];
+if (leader->type == t)
+return leader->leader;
 /* Always register the main variant first.  This is important so we
 pick up the non-typedef variants as canonical, otherwise we'll end
 up taking typedef ids for structure tags during comparison.  */
 if (TYPE_MAIN_VARIANT (t) != t)
-gimple_register_type (TYPE_MAIN_VARIANT (t));
+mv_leader = gimple_register_type (TYPE_MAIN_VARIANT (t));
 if (gimple_types == NULL)
-gimple_types = htab_create (16381, gimple_type_hash, gimple_type_eq, 0);
+gimple_types = htab_create_ggc (16381, gimple_type_hash, gimple_type_eq, 0);
 slot = htab_find_slot (gimple_types, t, INSERT);
 if (*slot
 && *(tree *)slot != t)
 {
 TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
 }
 TYPE_NEXT_REF_TO (t) = NULL_TREE;
 }
+leader->type = t;
+leader->leader = new_type;
 t = new_type;
 }
 else
-*slot = (void *) t;
+{
+leader->type = t;
+leader->leader = t;
+/* We're the type leader.  Make our TYPE_MAIN_VARIANT valid.  */
+if (TYPE_MAIN_VARIANT (t) != t
+	  && TYPE_MAIN_VARIANT (t) != mv_leader)
+	{
+	  /* Remove us from our main variant list as we are not the variant
+	     leader and the variant leader will change.  */
+	  tree tem = TYPE_MAIN_VARIANT (t);
+	  while (tem && TYPE_NEXT_VARIANT (tem) != t)
+	    tem = TYPE_NEXT_VARIANT (tem);
+	  if (tem)
+	    TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
+	  TYPE_NEXT_VARIANT (t) = NULL_TREE;
+	  /* Adjust our main variant.  Linking us into its variant list
+	     will happen at fixup time.  */
+	  TYPE_MAIN_VARIANT (t) = mv_leader;
+	}
+*slot = (void *) t;
+}
+return t;
+}
+/* Returns nonzero if P1 and P2 are equal.  */
+static int
+gimple_canonical_type_eq (const void *p1, const void *p2)
+{
+const_tree t1 = (const_tree) p1;
+const_tree t2 = (const_tree) p2;
+return gimple_types_compatible_p (CONST_CAST_TREE (t1),
+				    CONST_CAST_TREE (t2), GTC_DIAG);
+}
+/* Register type T in the global type table gimple_types.
+If another type T', compatible with T, already existed in
+gimple_types then return T', otherwise return T.  This is used by
+LTO to merge identical types read from different TUs.  */
+tree
+gimple_register_canonical_type (tree t)
+{
+void **slot;
+tree orig_t = t;
+gcc_assert (TYPE_P (t));
+if (TYPE_CANONICAL (t))
+return TYPE_CANONICAL (t);
+/* Always register the type itself first so that if it turns out
+to be the canonical type it will be the one we merge to as well.  */
+t = gimple_register_type (t);
+/* Always register the main variant first.  This is important so we
+pick up the non-typedef variants as canonical, otherwise we'll end
+up taking typedef ids for structure tags during comparison.  */
+if (TYPE_MAIN_VARIANT (t) != t)
+gimple_register_canonical_type (TYPE_MAIN_VARIANT (t));
+if (gimple_canonical_types == NULL)
+gimple_canonical_types = htab_create_ggc (16381, gimple_canonical_type_hash,
+					      gimple_canonical_type_eq, 0);
+slot = htab_find_slot (gimple_canonical_types, t, INSERT);
+if (*slot
+&& *(tree *)slot != t)
+{
+tree new_type = (tree) *((tree *) slot);
+TYPE_CANONICAL (t) = new_type;
+t = new_type;
+}
+else
+{
+TYPE_CANONICAL (t) = t;
+*slot = (void *) t;
+}
+/* Also cache the canonical type in the non-leaders.  */
+TYPE_CANONICAL (orig_t) = t;
 return t;
 }
 (long) gimple_types->searches,
 (long) gimple_types->collisions,
 htab_collisions (gimple_types));
 else
 fprintf (stderr, "GIMPLE type table is empty\n");
+if (type_hash_cache)
+fprintf (stderr, "GIMPLE type hash table: size %ld, %ld elements, "
+	     "%ld searches, %ld collisions (ratio: %f)\n",
+	     (long) htab_size (type_hash_cache),
+	     (long) htab_elements (type_hash_cache),
+	     (long) type_hash_cache->searches,
+	     (long) type_hash_cache->collisions,
+	     htab_collisions (type_hash_cache));
+else
+fprintf (stderr, "GIMPLE type hash table is empty\n");
+if (gimple_canonical_types)
+fprintf (stderr, "GIMPLE canonical type table: size %ld, %ld elements, "
+	     "%ld searches, %ld collisions (ratio: %f)\n",
+	     (long) htab_size (gimple_canonical_types),
+	     (long) htab_elements (gimple_canonical_types),
+	     (long) gimple_canonical_types->searches,
+	     (long) gimple_canonical_types->collisions,
+	     htab_collisions (gimple_canonical_types));
+else
+fprintf (stderr, "GIMPLE canonical type table is empty\n");
+if (canonical_type_hash_cache)
+fprintf (stderr, "GIMPLE canonical type hash table: size %ld, %ld elements, "
+	     "%ld searches, %ld collisions (ratio: %f)\n",
+	     (long) htab_size (canonical_type_hash_cache),
+	     (long) htab_elements (canonical_type_hash_cache),
+	     (long) canonical_type_hash_cache->searches,
+	     (long) canonical_type_hash_cache->collisions,
+	     htab_collisions (canonical_type_hash_cache));
+else
+fprintf (stderr, "GIMPLE canonical type hash table is empty\n");
 if (gtc_visited)
 fprintf (stderr, "GIMPLE type comparison table: size %ld, %ld "
 "elements, %ld searches, %ld collisions (ratio: %f)\n",
 (long) htab_size (gtc_visited),
 (long) htab_elements (gtc_visited),
 if (gimple_types)
 {
 htab_delete (gimple_types);
 gimple_types = NULL;
 }
+if (gimple_canonical_types)
+{
+htab_delete (gimple_canonical_types);
+gimple_canonical_types = NULL;
+}
 if (type_hash_cache)
 {
-pointer_map_destroy (type_hash_cache);
+htab_delete (type_hash_cache);
 type_hash_cache = NULL;
+}
+if (canonical_type_hash_cache)
+{
+htab_delete (canonical_type_hash_cache);
+canonical_type_hash_cache = NULL;
 }
 if (gtc_visited)
 {
 htab_delete (gtc_visited);
 obstack_free (&gtc_ob, NULL);
 gtc_visited = NULL;
 }
+gimple_type_leader = NULL;
 }
 /* Return a type the same as TYPE except unsigned or
 signed according to UNSIGNEDP.  */
 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 if (type1 == long_long_integer_type_node
 || type1 == long_long_unsigned_type_node)
 return unsignedp
 ? long_long_unsigned_type_node
-: long_long_integer_type_node;
+	   : long_long_integer_type_node;
+if (int128_integer_type_node && (type1 == int128_integer_type_node || type1 == int128_unsigned_type_node))
+return unsignedp
+? int128_unsigned_type_node
+	   : int128_integer_type_node;
 #if HOST_BITS_PER_WIDE_INT >= 64
 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
 #endif
 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 if (TYPE_OK (long_integer_type_node))
 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 if (TYPE_OK (long_long_integer_type_node))
 return (unsignedp
-? long_long_unsigned_type_node
+	    ? long_long_unsigned_type_node
-: long_long_integer_type_node);
+	    : long_long_integer_type_node);
+if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
+return (unsignedp
+	    ? int128_unsigned_type_node
+	    : int128_integer_type_node);
 #if HOST_BITS_PER_WIDE_INT >= 64
 if (TYPE_OK (intTI_type_node))
 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
 #endif
 /* t1 == t can happen for boolean nodes which are always unsigned.  */
 if (t1 != t)
 return get_alias_set (t1);
 }
-else if (POINTER_TYPE_P (t))
-{
-/* From the common C and C++ langhook implementation:
-Unfortunately, there is no canonical form of a pointer type.
-In particular, if we have `typedef int I', then `int *', and
-`I *' are different types.  So, we have to pick a canonical
-representative.  We do this below.
-Technically, this approach is actually more conservative that
-it needs to be.  In particular, `const int *' and `int *'
-should be in different alias sets, according to the C and C++
-standard, since their types are not the same, and so,
-technically, an `int **' and `const int **' cannot point at
-the same thing.
-But, the standard is wrong.  In particular, this code is
-legal C++:
-int *ip;
-int **ipp = &ip;
-const int* const* cipp = ipp;
-And, it doesn't make sense for that to be legal unless you
-can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
-the pointed-to types.  This issue has been reported to the
-C++ committee.  */
-/* In addition to the above canonicalization issue with LTO
-we should also canonicalize `T (*)[]' to `T *' avoiding
-alias issues with pointer-to element types and pointer-to
-array types.
-Likewise we need to deal with the situation of incomplete
-pointed-to types and make `*(struct X **)&a' and
-`*(struct X {} **)&a' alias.  Otherwise we will have to
-guarantee that all pointer-to incomplete type variants
-will be replaced by pointer-to complete type variants if
-they are available.
-With LTO the convenient situation of using `void *' to
-access and store any pointer type will also become
-more apparent (and `void *' is just another pointer-to
-incomplete type).  Assigning alias-set zero to `void *'
-and all pointer-to incomplete types is a not appealing
-solution.  Assigning an effective alias-set zero only
-affecting pointers might be - by recording proper subset
-relationships of all pointer alias-sets.
-Pointer-to function types are another grey area which
-needs caution.  Globbing them all into one alias-set
-or the above effective zero set would work.  */
-/* For now just assign the same alias-set to all pointers.
-That's simple and avoids all the above problems.  */
-if (t != ptr_type_node)
-return get_alias_set (ptr_type_node);
-}
 return -1;
 }
 {
 *walk_subtrees = 0;
 return NULL_TREE;
 }
-if (INDIRECT_REF_P (*tp) && TREE_OPERAND (*tp, 0) == count_p->ptr)
+if (TREE_CODE (*tp) == MEM_REF && TREE_OPERAND (*tp, 0) == count_p->ptr)
 {
 if (wi_p->is_lhs)
 count_p->num_stores++;
 else
 count_p->num_loads++;
 {
 while (handled_component_p (op))
 op = TREE_OPERAND (op, 0);
 if (DECL_P (op)
 || INDIRECT_REF_P (op)
+|| TREE_CODE (op) == MEM_REF
 || TREE_CODE (op) == TARGET_MEM_REF)
 return op;
 return NULL_TREE;
 }
 }
 rhs = gimple_assign_rhs1 (stmt);
 while (handled_component_p (rhs))
 rhs = TREE_OPERAND (rhs, 0);
 if (visit_addr)
-{
+	{
-if (TREE_CODE (rhs) == ADDR_EXPR)
+	  if (TREE_CODE (rhs) == ADDR_EXPR)
-ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
+	    ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
-else if (TREE_CODE (rhs) == TARGET_MEM_REF
+	  else if (TREE_CODE (rhs) == TARGET_MEM_REF
-&& TMR_BASE (rhs) != NULL_TREE
+		   && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
-&& TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
+	    ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), data);
-ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), data);
+	  else if (TREE_CODE (rhs) == OBJ_TYPE_REF
-else if (TREE_CODE (rhs) == OBJ_TYPE_REF
+		   && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
-&& TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
+	    ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
-ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
+						   0), data);
-0), data);
 lhs = gimple_assign_lhs (stmt);
-if (TREE_CODE (lhs) == TARGET_MEM_REF
+	  if (TREE_CODE (lhs) == TARGET_MEM_REF
-&& TMR_BASE (lhs) != NULL_TREE
 && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), data);
 }
 if (visit_load)
 {
 static bool
 gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED,
 tree addr, void *data)
 {
 bitmap addresses_taken = (bitmap)data;
-while (handled_component_p (addr))
+addr = get_base_address (addr);
-addr = TREE_OPERAND (addr, 0);
+if (addr
-if (DECL_P (addr))
+&& DECL_P (addr))
 {
 bitmap_set_bit (addresses_taken, DECL_UID (addr));
 return true;
 }
 return false;
 /* Return a printable name for symbol DECL.  */
 const char *
 gimple_decl_printable_name (tree decl, int verbosity)
 {
-gcc_assert (decl && DECL_NAME (decl));
+if (!DECL_NAME (decl))
+return NULL;
 if (DECL_ASSEMBLER_NAME_SET_P (decl))
 {
 const char *str, *mangled_str;
 int dmgl_opts = DMGL_NO_OPTS;
 }
 return IDENTIFIER_POINTER (DECL_NAME (decl));
 }
+/* Return true when STMT is builtins call to CODE.  */
-/* Fold a OBJ_TYPE_REF expression to the address of a function.
-KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  Adapted
+bool
-from cp_fold_obj_type_ref, but it tolerates types with no binfo
+gimple_call_builtin_p (gimple stmt, enum built_in_function code)
-data.  */
+{
-tree
-gimple_fold_obj_type_ref (tree ref, tree known_type)
-{
-HOST_WIDE_INT index;
-HOST_WIDE_INT i;
-tree v;
 tree fndecl;
+return (is_gimple_call (stmt)
-if (TYPE_BINFO (known_type) == NULL_TREE)
+	  && (fndecl = gimple_call_fndecl (stmt)) != NULL
-return NULL_TREE;
+	  && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+	  && DECL_FUNCTION_CODE (fndecl) == code);
-v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
-index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
-i = 0;
-while (i != index)
-{
-i += (TARGET_VTABLE_USES_DESCRIPTORS
-? TARGET_VTABLE_USES_DESCRIPTORS : 1);
-v = TREE_CHAIN (v);
-}
-fndecl = TREE_VALUE (v);
-#ifdef ENABLE_CHECKING
-gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
-DECL_VINDEX (fndecl)));
-#endif
-cgraph_node (fndecl)->local.vtable_method = true;
-return build_fold_addr_expr (fndecl);
 }
 #include "gt-gimple.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.c @ 69:1b10fe6932e1