CbC/CbC_gcc: gcc/tree-ssa-loop-ivopts.c comparison

comparison gcc/tree-ssa-loop-ivopts.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Induction variable optimizations.
-Copyright (C) 2003-2017 Free Software Foundation, Inc.
+Copyright (C) 2003-2018 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 /* Types of uses.  */
 enum use_type
 {
 USE_NONLINEAR_EXPR,	/* Use in a nonlinear expression.  */
-USE_ADDRESS,		/* Use in an address.  */
+USE_REF_ADDRESS,	/* Use is an address for an explicit memory
+			   reference.  */
+USE_PTR_ADDRESS,	/* Use is a pointer argument to a function in
+			   cases where the expansion of the function
+			   will turn the argument into a normal address.  */
 USE_COMPARE		/* Use is a compare.  */
 };
 /* Cost of a computation.  */
 struct comp_cost
 struct iv_use
 {
 unsigned id;		/* The id of the use.  */
 unsigned group_id;	/* The group id the use belongs to.  */
 enum use_type type;	/* Type of the use.  */
+tree mem_type;	/* The memory type to use when testing whether an
+			   address is legitimate, and what the address's
+			   cost is.  */
 struct iv *iv;	/* The induction variable it is based on.  */
 gimple *stmt;		/* Statement in that it occurs.  */
 tree *op_p;		/* The place where it occurs.  */
 tree addr_base;	/* Base address with const offset stripped.  */
-unsigned HOST_WIDE_INT addr_offset;
+poly_uint64_pod addr_offset;
 			/* Const offset stripped from base address.  */
 };
 /* Group of uses.  */
 struct iv_group
 {
 static inline hashval_t hash (const iv_inv_expr_ent *);
 static inline bool equal (const iv_inv_expr_ent *, const iv_inv_expr_ent *);
 };
+/* Return true if uses of type TYPE represent some form of address.  */
+inline bool
+address_p (use_type type)
+{
+return type == USE_REF_ADDRESS || type == USE_PTR_ADDRESS;
+}
 /* Hash function for loop invariant expressions.  */
 inline hashval_t
 iv_inv_expr_hasher::hash (const iv_inv_expr_ent *expr)
 {
 {
 group = data->vgroups[i];
 fprintf (file, "Group %d:\n", group->id);
 if (group->type == USE_NONLINEAR_EXPR)
 	fprintf (file, "  Type:\tGENERIC\n");
-else if (group->type == USE_ADDRESS)
+else if (group->type == USE_REF_ADDRESS)
-	fprintf (file, "  Type:\tADDRESS\n");
+	fprintf (file, "  Type:\tREFERENCE ADDRESS\n");
+else if (group->type == USE_PTR_ADDRESS)
+	fprintf (file, "  Type:\tPOINTER ARGUMENT ADDRESS\n");
 else
 	{
 	  gcc_assert (group->type == USE_COMPARE);
 	  fprintf (file, "  Type:\tCOMPARE\n");
 	}
 if (!expr)
 return false;
 code = TREE_CODE (expr);
 codeclass = TREE_CODE_CLASS (code);
+if (code == CALL_EXPR)
+{
+tree arg;
+call_expr_arg_iterator iter;
+FOR_EACH_CALL_EXPR_ARG (arg, iter, expr)
+	if (contains_abnormal_ssa_name_p (arg))
+	  return true;
+return false;
+}
 if (code == SSA_NAME)
 return SSA_NAME_OCCURS_IN_ABNORMAL_PHI (expr) != 0;
 if (code == INTEGER_CST
 case MINUS_EXPR:
 /* Pointer addition is done solely using POINTER_PLUS_EXPR.  */
 gcc_unreachable ();
 default:
+if (POLY_INT_CST_P (expr))
+	return NULL_TREE;
 return fold_convert (ptr_type_node, expr);
 }
 }
 /* Return true if address expression with non-DECL_P operand appears
 return false;
 /* If STMT could throw, then do not consider STMT as defining a GIV.
 While this will suppress optimizations, we can not safely delete this
 GIV and associated statements, even if it appears it is not used.  */
-if (stmt_could_throw_p (stmt))
+if (stmt_could_throw_p (cfun, stmt))
 return false;
 return true;
 }
 return true;
 }
 /* Records a use of TYPE at *USE_P in STMT whose value is IV in GROUP.
 For address type use, ADDR_BASE is the stripped IV base, ADDR_OFFSET
-is the const offset stripped from IV base; for other types use, both
+is the const offset stripped from IV base and MEM_TYPE is the type
-are zero by default.  */
+of the memory being addressed.  For uses of other types, ADDR_BASE
+and ADDR_OFFSET are zero by default and MEM_TYPE is NULL_TREE.  */
 static struct iv_use *
 record_use (struct iv_group *group, tree *use_p, struct iv *iv,
-	    gimple *stmt, enum use_type type, tree addr_base,
+	    gimple *stmt, enum use_type type, tree mem_type,
-	    unsigned HOST_WIDE_INT addr_offset)
+	    tree addr_base, poly_uint64 addr_offset)
 {
 struct iv_use *use = XCNEW (struct iv_use);
 use->id = group->vuses.length ();
 use->group_id = group->id;
 use->type = type;
+use->mem_type = mem_type;
 use->iv = iv;
 use->stmt = stmt;
 use->op_p = use_p;
 use->addr_base = addr_base;
 use->addr_offset = addr_offset;
 data->vgroups.safe_push (group);
 return group;
 }
 /* Record a use of TYPE at *USE_P in STMT whose value is IV in a group.
-New group will be created if there is no existing group for the use.  */
+New group will be created if there is no existing group for the use.
+MEM_TYPE is the type of memory being addressed, or NULL if this
+isn't an address reference.  */
 static struct iv_use *
 record_group_use (struct ivopts_data *data, tree *use_p,
-		  struct iv *iv, gimple *stmt, enum use_type type)
+		  struct iv *iv, gimple *stmt, enum use_type type,
+		  tree mem_type)
 {
 tree addr_base = NULL;
 struct iv_group *group = NULL;
-unsigned HOST_WIDE_INT addr_offset = 0;
+poly_uint64 addr_offset = 0;
 /* Record non address type use in a new group.  */
-if (type == USE_ADDRESS && iv->base_object)
+if (address_p (type))
 {
 unsigned int i;
 addr_base = strip_offset (iv->base, &addr_offset);
 for (i = 0; i < data->vgroups.length (); i++)
 	{
 	  struct iv_use *use;
 	  group = data->vgroups[i];
 	  use = group->vuses[0];
-	  if (use->type != USE_ADDRESS || !use->iv->base_object)
+	  if (!address_p (use->type))
 	    continue;
 	  /* Check if it has the same stripped base and step.  */
 	  if (operand_equal_p (iv->base_object, use->iv->base_object, 0)
 	      && operand_equal_p (iv->step, use->iv->step, 0)
 }
 if (!group)
 group = record_group (data, type);
-return record_use (group, use_p, iv, stmt, type, addr_base, addr_offset);
+return record_use (group, use_p, iv, stmt, type, mem_type,
+		     addr_base, addr_offset);
 }
 /* Checks whether the use OP is interesting and if so, records it.  */
 static struct iv_use *
 }
 stmt = SSA_NAME_DEF_STMT (op);
 gcc_assert (gimple_code (stmt) == GIMPLE_PHI || is_gimple_assign (stmt));
-use = record_group_use (data, NULL, iv, stmt, USE_NONLINEAR_EXPR);
+use = record_group_use (data, NULL, iv, stmt, USE_NONLINEAR_EXPR, NULL_TREE);
 iv->nonlin_use = use;
 return use;
 }
 /* Indicate how compare type iv_use can be handled.  */
 find_interesting_uses_op (data, *var_p);
 find_interesting_uses_op (data, *bound_p);
 return;
 }
-record_group_use (data, var_p, var_iv, stmt, USE_COMPARE);
+record_group_use (data, var_p, var_iv, stmt, USE_COMPARE, NULL_TREE);
 /* Record compare type iv_use for iv on the other side of comparison.  */
 if (ret == COMP_IV_EXPR_2)
-record_group_use (data, bound_p, bound_iv, stmt, USE_COMPARE);
+record_group_use (data, bound_p, bound_iv, stmt, USE_COMPARE, NULL_TREE);
 }
 /* Returns the outermost loop EXPR is obviously invariant in
 relative to the loop LOOP, i.e. if all its operands are defined
 outside of the returned loop.  Returns NULL if EXPR is not
 	return false;
 *mul = wi::sext (wi::divmod_trunc (p0, p1, SIGNED, &res), precision);
 return res == 0;
 default:
+if (POLY_INT_CST_P (top)
+	  && POLY_INT_CST_P (bot)
+	  && constant_multiple_p (wi::to_poly_widest (top),
+				  wi::to_poly_widest (bot), mul))
+	return true;
 return false;
 }
 }
 /* Return true if memory reference REF with step STEP may be unaligned.  */
 civ = alloc_iv (data, base, step);
 /* Fail if base object of this memory reference is unknown.  */
 if (civ->base_object == NULL_TREE)
 goto fail;
-record_group_use (data, op_p, civ, stmt, USE_ADDRESS);
+record_group_use (data, op_p, civ, stmt, USE_REF_ADDRESS, TREE_TYPE (*op_p));
 return;
 fail:
 for_each_index (op_p, idx_record_use, data);
 }
 FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_USE)
 {
 op = USE_FROM_PTR (use_p);
 record_invariant (data, op, false);
 }
+}
+/* CALL calls an internal function.  If operand *OP_P will become an
+address when the call is expanded, return the type of the memory
+being addressed, otherwise return null.  */
+static tree
+get_mem_type_for_internal_fn (gcall *call, tree *op_p)
+{
+switch (gimple_call_internal_fn (call))
+{
+case IFN_MASK_LOAD:
+if (op_p == gimple_call_arg_ptr (call, 0))
+	return TREE_TYPE (gimple_call_lhs (call));
+return NULL_TREE;
+case IFN_MASK_STORE:
+if (op_p == gimple_call_arg_ptr (call, 0))
+	return TREE_TYPE (gimple_call_arg (call, 3));
+return NULL_TREE;
+default:
+return NULL_TREE;
+}
+}
+/* IV is a (non-address) iv that describes operand *OP_P of STMT.
+Return true if the operand will become an address when STMT
+is expanded and record the associated address use if so.  */
+static bool
+find_address_like_use (struct ivopts_data *data, gimple *stmt, tree *op_p,
+		       struct iv *iv)
+{
+/* Fail if base object of this memory reference is unknown.  */
+if (iv->base_object == NULL_TREE)
+return false;
+tree mem_type = NULL_TREE;
+if (gcall *call = dyn_cast <gcall *> (stmt))
+if (gimple_call_internal_p (call))
+mem_type = get_mem_type_for_internal_fn (call, op_p);
+if (mem_type)
+{
+iv = alloc_iv (data, iv->base, iv->step);
+record_group_use (data, op_p, iv, stmt, USE_PTR_ADDRESS, mem_type);
+return true;
+}
+return false;
 }
 /* Finds interesting uses of induction variables in the statement STMT.  */
 static void
 iv = get_iv (data, op);
 if (!iv)
 	continue;
-find_interesting_uses_op (data, op);
+if (!find_address_like_use (data, stmt, use_p->use, iv))
+	find_interesting_uses_op (data, op);
 }
 }
 /* Finds interesting uses of induction variables outside of loops
 on loop exit edge EXIT.  */
 mode for memory reference represented by USE.  */
 static GTY (()) vec<rtx, va_gc> *addr_list;
 static bool
-addr_offset_valid_p (struct iv_use *use, HOST_WIDE_INT offset)
+addr_offset_valid_p (struct iv_use *use, poly_int64 offset)
 {
 rtx reg, addr;
 unsigned list_index;
 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (use->iv->base));
-machine_mode addr_mode, mem_mode = TYPE_MODE (TREE_TYPE (*use->op_p));
+machine_mode addr_mode, mem_mode = TYPE_MODE (use->mem_type);
 list_index = (unsigned) as * MAX_MACHINE_MODE + (unsigned) mem_mode;
 if (list_index >= vec_safe_length (addr_list))
 vec_safe_grow_cleared (addr_list, list_index + MAX_MACHINE_MODE);
 group_compare_offset (const void *a, const void *b)
 {
 const struct iv_use *const *u1 = (const struct iv_use *const *) a;
 const struct iv_use *const *u2 = (const struct iv_use *const *) b;
-if ((*u1)->addr_offset != (*u2)->addr_offset)
+return compare_sizes_for_sort ((*u1)->addr_offset, (*u2)->addr_offset);
-return (*u1)->addr_offset < (*u2)->addr_offset ? -1 : 1;
-else
-return 0;
 }
 /* Check if small groups should be split.  Return true if no group
 contains more than two uses with distinct addr_offsets.  Return
 false otherwise.  We want to split such groups because:
 {
 group = data->vgroups[i];
 if (group->vuses.length () == 1)
 	continue;
-gcc_assert (group->type == USE_ADDRESS);
+gcc_assert (address_p (group->type));
 if (group->vuses.length () == 2)
 	{
-	  if (group->vuses[0]->addr_offset > group->vuses[1]->addr_offset)
+	  if (compare_sizes_for_sort (group->vuses[0]->addr_offset,
+				      group->vuses[1]->addr_offset) > 0)
 	    std::swap (group->vuses[0], group->vuses[1]);
 	}
 else
 	group->vuses.qsort (group_compare_offset);
 	continue;
 distinct = 1;
 for (pre = group->vuses[0], j = 1; j < group->vuses.length (); j++)
 	{
-	  if (group->vuses[j]->addr_offset != pre->addr_offset)
+	  if (maybe_ne (group->vuses[j]->addr_offset, pre->addr_offset))
 	    {
 	      pre = group->vuses[j];
 	      distinct++;
 	    }
 use->id = 0;
 use->group_id = group->id;
 if (group->vuses.length () == 1)
 	continue;
-gcc_assert (group->type == USE_ADDRESS);
+gcc_assert (address_p (use->type));
 for (j = 1; j < group->vuses.length ();)
 	{
 	  struct iv_use *next = group->vuses[j];
-	  HOST_WIDE_INT offset = next->addr_offset - use->addr_offset;
+	  poly_int64 offset = next->addr_offset - use->addr_offset;
 	  /* Split group if aksed to, or the offset against the first
 	     use can't fit in offset part of addressing mode.  IV uses
 	     having the same offset are still kept in one group.  */
-	  if (offset != 0 &&
+	  if (maybe_ne (offset, 0)
-	      (split_p || !addr_offset_valid_p (use, offset)))
+	      && (split_p || !addr_offset_valid_p (use, offset)))
 	    {
 	      if (!new_group)
 		new_group = record_group (data, group->type);
 	      group->vuses.ordered_remove (j);
 	      new_group->vuses.safe_push (next);
 is true, assume we are inside an address.  If TOP_COMPREF is true, assume
 we are at the top-level of the processed address.  */
 static tree
 strip_offset_1 (tree expr, bool inside_addr, bool top_compref,
-		HOST_WIDE_INT *offset)
+		poly_int64 *offset)
 {
 tree op0 = NULL_TREE, op1 = NULL_TREE, tmp, step;
 enum tree_code code;
 tree type, orig_type = TREE_TYPE (expr);
-HOST_WIDE_INT off0, off1, st;
+poly_int64 off0, off1;
+HOST_WIDE_INT st;
 tree orig_expr = expr;
 STRIP_NOPS (expr);
 type = TREE_TYPE (expr);
 code = TREE_CODE (expr);
 *offset = 0;
 switch (code)
 {
-case INTEGER_CST:
-if (!cst_and_fits_in_hwi (expr)
-	  || integer_zerop (expr))
-	return orig_expr;
-*offset = int_cst_value (expr);
-return build_int_cst (orig_type, 0);
 case POINTER_PLUS_EXPR:
 case PLUS_EXPR:
 case MINUS_EXPR:
 op0 = TREE_OPERAND (expr, 0);
 op1 = TREE_OPERAND (expr, 1);
 /* ???  Offset operand?  */
 inside_addr = false;
 break;
 default:
+if (ptrdiff_tree_p (expr, offset) && maybe_ne (*offset, 0))
+	return build_int_cst (orig_type, 0);
 return orig_expr;
 }
 /* Default handling of expressions for that we want to recurse into
 the first operand.  */
 }
 /* Strips constant offsets from EXPR and stores them to OFFSET.  */
 tree
-strip_offset (tree expr, unsigned HOST_WIDE_INT *offset)
+strip_offset (tree expr, poly_uint64_pod *offset)
 {
-HOST_WIDE_INT off;
+poly_int64 off;
 tree core = strip_offset_1 (expr, false, false, &off);
 *offset = off;
 return core;
 }
 static iv_inv_expr_ent *
 get_loop_invariant_expr (struct ivopts_data *data, tree inv_expr)
 {
 STRIP_NOPS (inv_expr);
-if (TREE_CODE (inv_expr) == INTEGER_CST || TREE_CODE (inv_expr) == SSA_NAME)
+if (poly_int_tree_p (inv_expr)
+|| TREE_CODE (inv_expr) == SSA_NAME)
 return NULL;
 /* Don't strip constant part away as we used to.  */
 /* Stores EXPR in DATA->inv_expr_tab, return pointer to iv_inv_expr_ent.  */
 	}
 cand->important = important;
 cand->incremented_at = incremented_at;
 data->vcands.safe_push (cand);
-if (TREE_CODE (step) != INTEGER_CST)
+if (!poly_int_tree_p (step))
 	{
 	  find_inv_vars (data, &step, &cand->inv_vars);
 	  iv_inv_expr_ent *inv_expr = get_loop_invariant_expr (data, step);
 	  /* Share bitmap between inv_vars and inv_exprs for cand.  */
 ones, we must ensure that it is incremented once per iteration.
 It must not be in an inner nested loop, or one side of an if
 statement.  */
 if (use_bb->loop_father != data->current_loop
 || !dominated_by_p (CDI_DOMINATORS, data->current_loop->latch, use_bb)
-|| stmt_can_throw_internal (use->stmt)
+|| stmt_can_throw_internal (cfun, use->stmt)
 || !cst_and_fits_in_hwi (step))
 return;
 cstepi = int_cst_value (step);
-mem_mode = TYPE_MODE (TREE_TYPE (*use->op_p));
+mem_mode = TYPE_MODE (use->mem_type);
 if (((USE_LOAD_PRE_INCREMENT (mem_mode)
 	|| USE_STORE_PRE_INCREMENT (mem_mode))
-&& GET_MODE_SIZE (mem_mode) == cstepi)
+&& known_eq (GET_MODE_SIZE (mem_mode), cstepi))
 || ((USE_LOAD_PRE_DECREMENT (mem_mode)
 	   || USE_STORE_PRE_DECREMENT (mem_mode))
-	  && GET_MODE_SIZE (mem_mode) == -cstepi))
+	  && known_eq (GET_MODE_SIZE (mem_mode), -cstepi)))
 {
 enum tree_code code = MINUS_EXPR;
 tree new_base;
 tree new_step = step;
 add_candidate_1 (data, new_base, step, important, IP_BEFORE_USE, use,
 		       use->stmt);
 }
 if (((USE_LOAD_POST_INCREMENT (mem_mode)
 	|| USE_STORE_POST_INCREMENT (mem_mode))
-&& GET_MODE_SIZE (mem_mode) == cstepi)
+&& known_eq (GET_MODE_SIZE (mem_mode), cstepi))
 || ((USE_LOAD_POST_DECREMENT (mem_mode)
 	   || USE_STORE_POST_DECREMENT (mem_mode))
-	  && GET_MODE_SIZE (mem_mode) == -cstepi))
+	  && known_eq (GET_MODE_SIZE (mem_mode), -cstepi)))
 {
 add_candidate_1 (data, base, step, important, IP_AFTER_USE, use,
 		       use->stmt);
 }
 }
 /* Adds candidates based on the value of USE's iv.  */
 static void
 add_iv_candidate_for_use (struct ivopts_data *data, struct iv_use *use)
 {
-unsigned HOST_WIDE_INT offset;
+poly_uint64 offset;
 tree base;
 tree basetype;
 struct iv *iv = use->iv;
 add_candidate (data, iv->base, iv->step, false, use);
 record_common_cand (data, build_int_cst (basetype, 0), iv->step, use);
 /* Record common candidate with constant offset stripped in base.
 Like the use itself, we also add candidate directly for it.  */
 base = strip_offset (iv->base, &offset);
-if (offset || base != iv->base)
+if (maybe_ne (offset, 0U) || base != iv->base)
 {
 record_common_cand (data, base, iv->step, use);
 add_candidate (data, base, iv->step, false, use);
 }
 base = TREE_OPERAND (base, 1);
 step = fold_convert (sizetype, step);
 record_common_cand (data, base, step, use);
 /* Also record common candidate with offset stripped.  */
 base = strip_offset (base, &offset);
-if (offset)
+if (maybe_ne (offset, 0U))
 	record_common_cand (data, base, step, use);
 }
 /* At last, add auto-incremental candidates.  Make such variables
 important since other iv uses with same base object may be based
 on it.  */
-if (use != NULL && use->type == USE_ADDRESS)
+if (use != NULL && address_p (use->type))
 add_autoinc_candidates (data, iv->base, iv->step, true, use);
 }
 /* Adds candidates based on the uses.  */
 /* If the conversion is not noop, perform it.  */
 if (TYPE_PRECISION (utype) < TYPE_PRECISION (ctype))
 {
 if (cand->orig_iv != NULL && CONVERT_EXPR_P (cbase)
-	  && (CONVERT_EXPR_P (cstep) || TREE_CODE (cstep) == INTEGER_CST))
+	  && (CONVERT_EXPR_P (cstep) || poly_int_tree_p (cstep)))
 	{
 	  tree inner_base, inner_step, inner_type;
 	  inner_base = TREE_OPERAND (cbase, 0);
 	  if (CONVERT_EXPR_P (cstep))
 	    inner_step = TREE_OPERAND (cstep, 0);
 get_use_type (struct iv_use *use)
 {
 tree base_type = TREE_TYPE (use->iv->base);
 tree type;
-if (use->type == USE_ADDRESS)
+if (use->type == USE_REF_ADDRESS)
 {
 /* The base_type may be a void pointer.  Create a pointer type based on
 	 the mem_ref instead.  */
 type = build_pointer_type (TREE_TYPE (*use->op_p));
 gcc_assert (TYPE_ADDR_SPACE (TREE_TYPE (type))
 if (SSA_VAR_P (expr))
 return no_cost;
 if (is_gimple_min_invariant (expr))
 {
-if (TREE_CODE (expr) == INTEGER_CST)
+if (poly_int_tree_p (expr))
 	return comp_cost (integer_cost [speed], 0);
 if (TREE_CODE (expr) == ADDR_EXPR)
 	{
 	  tree obj = TREE_OPERAND (expr, 0);
 {
 unsigned costs[AINC_NONE];
 };
 static comp_cost
-get_address_cost_ainc (HOST_WIDE_INT ainc_step, HOST_WIDE_INT ainc_offset,
+get_address_cost_ainc (poly_int64 ainc_step, poly_int64 ainc_offset,
 		       machine_mode addr_mode, machine_mode mem_mode,
 		       addr_space_t as, bool speed)
 {
 if (!USE_LOAD_PRE_DECREMENT (mem_mode)
 && !USE_STORE_PRE_DECREMENT (mem_mode)
 	      = address_cost (addr, mem_mode, as, speed);
 	}
 ainc_cost_data_list[idx] = data;
 }
-HOST_WIDE_INT msize = GET_MODE_SIZE (mem_mode);
+poly_int64 msize = GET_MODE_SIZE (mem_mode);
-if (ainc_offset == 0 && msize == ainc_step)
+if (known_eq (ainc_offset, 0) && known_eq (msize, ainc_step))
 return comp_cost (data->costs[AINC_POST_INC], 0);
-if (ainc_offset == 0 && msize == -ainc_step)
+if (known_eq (ainc_offset, 0) && known_eq (msize, -ainc_step))
 return comp_cost (data->costs[AINC_POST_DEC], 0);
-if (ainc_offset == msize && msize == ainc_step)
+if (known_eq (ainc_offset, msize) && known_eq (msize, ainc_step))
 return comp_cost (data->costs[AINC_PRE_INC], 0);
-if (ainc_offset == -msize && msize == -ainc_step)
+if (known_eq (ainc_offset, -msize) && known_eq (msize, -ainc_step))
 return comp_cost (data->costs[AINC_PRE_DEC], 0);
 return infinite_cost;
 }
 tree comp_inv = NULL_TREE, type = aff_var->type;
 comp_cost var_cost = no_cost, cost = no_cost;
 struct mem_address parts = {NULL_TREE, integer_one_node,
 			      NULL_TREE, NULL_TREE, NULL_TREE};
 machine_mode addr_mode = TYPE_MODE (type);
-machine_mode mem_mode = TYPE_MODE (TREE_TYPE (*use->op_p));
+machine_mode mem_mode = TYPE_MODE (use->mem_type);
 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (use->iv->base));
+/* Only true if ratio != 1.  */
+bool ok_with_ratio_p = false;
+bool ok_without_ratio_p = false;
 if (!aff_combination_const_p (aff_inv))
 {
 parts.index = integer_one_node;
 /* Addressing mode "base + index".  */
-if (valid_mem_ref_p (mem_mode, as, &parts))
+ok_without_ratio_p = valid_mem_ref_p (mem_mode, as, &parts);
+if (ratio != 1)
 	{
 	  parts.step = wide_int_to_tree (type, ratio);
 	  /* Addressing mode "base + index << scale".  */
-	  if (ratio != 1 && !valid_mem_ref_p (mem_mode, as, &parts))
+	  ok_with_ratio_p = valid_mem_ref_p (mem_mode, as, &parts);
+	  if (!ok_with_ratio_p)
 	    parts.step = NULL_TREE;
+	}
-	  if (aff_inv->offset != 0)
+if (ok_with_ratio_p || ok_without_ratio_p)
+	{
+	  if (maybe_ne (aff_inv->offset, 0))
 	    {
 	      parts.offset = wide_int_to_tree (sizetype, aff_inv->offset);
 	      /* Addressing mode "base + index [<< scale] + offset".  */
 	      if (!valid_mem_ref_p (mem_mode, as, &parts))
 		parts.offset = NULL_TREE;
 else
 	parts.index = NULL_TREE;
 }
 else
 {
-if (can_autoinc && ratio == 1 && cst_and_fits_in_hwi (cand->iv->step))
+poly_int64 ainc_step;
-	{
+if (can_autoinc
-	  HOST_WIDE_INT ainc_step = int_cst_value (cand->iv->step);
+	  && ratio == 1
-	  HOST_WIDE_INT ainc_offset = (aff_inv->offset).to_shwi ();
+	  && ptrdiff_tree_p (cand->iv->step, &ainc_step))
+	{
+	  poly_int64 ainc_offset = (aff_inv->offset).force_shwi ();
 	  if (stmt_after_increment (data->current_loop, cand, use->stmt))
 	    ainc_offset += ainc_step;
 	  cost = get_address_cost_ainc (ainc_step, ainc_offset,
 					addr_mode, mem_mode, as, speed);
 gcc_assert (memory_address_addr_space_p (mem_mode, addr, as));
 cost += address_cost (addr, mem_mode, as, speed);
 if (parts.symbol != NULL_TREE)
 cost.complexity += 1;
-if (parts.step != NULL_TREE && !integer_onep (parts.step))
+/* Don't increase the complexity of adding a scaled index if it's
+the only kind of index that the target allows.  */
+if (parts.step != NULL_TREE && ok_without_ratio_p)
 cost.complexity += 1;
 if (parts.base != NULL_TREE && parts.index != NULL_TREE)
 cost.complexity += 1;
 if (parts.offset != NULL_TREE && !integer_zerop (parts.offset))
 cost.complexity += 1;
 expected cost more accurate.  */
 static comp_cost
 get_scaled_computation_cost_at (ivopts_data *data, gimple *at, comp_cost cost)
 {
-int loop_freq = data->current_loop->header->frequency;
+int loop_freq = data->current_loop->header->count.to_frequency (cfun);
-int bb_freq = gimple_bb (at)->frequency;
+int bb_freq = gimple_bb (at)->count.to_frequency (cfun);
 if (loop_freq != 0)
 {
 gcc_assert (cost.scratch <= cost.cost);
 int scaled_cost
 	 = cost.scratch + (cost.cost - cost.scratch) * bb_freq / loop_freq;
 tree_to_aff_combination (fold_convert (nit_type, b), nit_type, &tmpb);
 aff_combination_scale (&nit, -1);
 aff_combination_scale (&tmpa, -1);
 aff_combination_add (&tmpb, &tmpa);
 aff_combination_add (&tmpb, &nit);
-if (tmpb.n != 0 || tmpb.offset != 1)
+if (tmpb.n != 0 || maybe_ne (tmpb.offset, 1))
 return false;
 /* Finally, check that CAND->IV->BASE - CAND->IV->STEP * A does not
 overflow.  */
 offset = fold_build2 (MULT_EXPR, TREE_TYPE (cand->iv->step),
 switch (group->type)
 {
 case USE_NONLINEAR_EXPR:
 return determine_group_iv_cost_generic (data, group, cand);
-case USE_ADDRESS:
+case USE_REF_ADDRESS:
+case USE_PTR_ADDRESS:
 return determine_group_iv_cost_address (data, group, cand);
 case USE_COMPARE:
 return determine_group_iv_cost_cond (data, group, cand);
 static bool
 autoinc_possible_for_pair (struct ivopts_data *data, struct iv_use *use,
 			   struct iv_cand *cand)
 {
-if (use->type != USE_ADDRESS)
+if (!address_p (use->type))
 return false;
 bool can_autoinc = false;
 get_computation_cost (data, use, cand, true, NULL, &can_autoinc, NULL);
 return can_autoinc;
 unshare_aff_combination (&aff_inv);
 unshare_aff_combination (&aff_var);
 /* Prefer CSE opportunity than loop invariant by adding offset at last
 so that iv_uses have different offsets can be CSEed.  */
-widest_int offset = aff_inv.offset;
+poly_widest_int offset = aff_inv.offset;
 aff_inv.offset = 0;
 gimple_seq stmt_list = NULL, seq = NULL;
 tree comp_op1 = aff_combination_to_tree (&aff_inv);
 tree comp_op2 = aff_combination_to_tree (&aff_var);
 gsi_move_before (&gsi_iv, &gsi);
 cand->pos = IP_BEFORE_USE;
 cand->incremented_at = use->stmt;
 }
+/* Return the alias pointer type that should be used for a MEM_REF
+associated with USE, which has type USE_PTR_ADDRESS.  */
+static tree
+get_alias_ptr_type_for_ptr_address (iv_use *use)
+{
+gcall *call = as_a <gcall *> (use->stmt);
+switch (gimple_call_internal_fn (call))
+{
+case IFN_MASK_LOAD:
+case IFN_MASK_STORE:
+/* The second argument contains the correct alias type.  */
+gcc_assert (use->op_p = gimple_call_arg_ptr (call, 0));
+return TREE_TYPE (gimple_call_arg (call, 1));
+default:
+gcc_unreachable ();
+}
+}
 /* Rewrites USE (address that is an iv) using candidate CAND.  */
 static void
 rewrite_use_address (struct ivopts_data *data,
 of the use -- but these will use pointer types, so they are recognized
 by the create_mem_ref heuristics anyway.  */
 tree iv = var_at_stmt (data->current_loop, cand, use->stmt);
 tree base_hint = (cand->iv->base_object) ? iv : NULL_TREE;
 gimple_stmt_iterator bsi = gsi_for_stmt (use->stmt);
-tree type = TREE_TYPE (*use->op_p);
+tree type = use->mem_type;
-unsigned int align = get_object_alignment (*use->op_p);
+tree alias_ptr_type;
-if (align != TYPE_ALIGN (type))
+if (use->type == USE_PTR_ADDRESS)
-type = build_aligned_type (type, align);
+alias_ptr_type = get_alias_ptr_type_for_ptr_address (use);
+else
-tree ref = create_mem_ref (&bsi, type, &aff,
+{
-			     reference_alias_ptr_type (*use->op_p),
+gcc_assert (type == TREE_TYPE (*use->op_p));
+unsigned int align = get_object_alignment (*use->op_p);
+if (align != TYPE_ALIGN (type))
+	type = build_aligned_type (type, align);
+alias_ptr_type = reference_alias_ptr_type (*use->op_p);
+}
+tree ref = create_mem_ref (&bsi, type, &aff, alias_ptr_type,
 			     iv, base_hint, data->speed);
-copy_ref_info (ref, *use->op_p);
+if (use->type == USE_PTR_ADDRESS)
+{
+ref = fold_build1 (ADDR_EXPR, build_pointer_type (use->mem_type), ref);
+ref = fold_convert (get_use_type (use), ref);
+ref = force_gimple_operand_gsi (&bsi, ref, true, NULL_TREE,
+				      true, GSI_SAME_STMT);
+}
+else
+copy_ref_info (ref, *use->op_p);
 *use->op_p = ref;
 }
 /* Rewrites USE (the condition such that one of the arguments is an iv) using
 candidate CAND.  */
 	    {
 	      rewrite_use_nonlinear_expr (data, group->vuses[j], cand);
 	      update_stmt (group->vuses[j]->stmt);
 	    }
 	}
-else if (group->type == USE_ADDRESS)
+else if (address_p (group->type))
 	{
 	  for (j = 0; j < group->vuses.length (); j++)
 	    {
 	      rewrite_use_address (data, group->vuses[j], cand);
 	      update_stmt (group->vuses[j]->stmt);
 	{
 	  bitmap_set_bit (toremove, SSA_NAME_VERSION (info->iv->ssa_name));
 	  tree def = info->iv->ssa_name;
-	  if (MAY_HAVE_DEBUG_STMTS && SSA_NAME_DEF_STMT (def))
+	  if (MAY_HAVE_DEBUG_BIND_STMTS && SSA_NAME_DEF_STMT (def))
 	    {
 	      imm_use_iterator imm_iter;
 	      use_operand_p use_p;
 	      gimple *stmt;
 	      int count = 0;
 edge exit = single_dom_exit (loop);
 basic_block *body;
 gcc_assert (!data->niters);
 data->current_loop = loop;
-data->loop_loc = find_loop_location (loop);
+data->loop_loc = find_loop_location (loop).get_location_t ();
 data->speed = optimize_loop_for_speed_p (loop);
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "Processing loop %d", loop->num);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-loop-ivopts.c @ 131:84e7813d76e9