CbC/CbC_gcc: gcc/gimple-ssa-strength-reduction.c comparison

comparison gcc/gimple-ssa-strength-reduction.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Straight-line strength reduction.
-Copyright (C) 2012-2018 Free Software Foundation, Inc.
+Copyright (C) 2012-2020 Free Software Foundation, Inc.
 Contributed by Bill Schmidt, IBM <wschmidt@linux.ibm.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "gimplify-me.h"
 #include "stor-layout.h"
 #include "cfgloop.h"
 #include "tree-cfg.h"
 #include "domwalk.h"
-#include "params.h"
 #include "tree-ssa-address.h"
 #include "tree-affine.h"
 #include "tree-eh.h"
 #include "builtins.h"
 CAND_ADD,
 CAND_REF,
 CAND_PHI
 };
-struct slsr_cand_d
+class slsr_cand_d
 {
+public:
 /* The candidate statement S1.  */
 gimple *cand_stmt;
 /* The base expression B:  often an SSA name, but not always.  */
 tree base_expr;
 /* We sometimes have to cache a phi basis with a phi candidate to
 avoid processing it twice.  Valid only if visited==1.  */
 tree cached_basis;
 };
-typedef struct slsr_cand_d slsr_cand, *slsr_cand_t;
+typedef class slsr_cand_d slsr_cand, *slsr_cand_t;
-typedef const struct slsr_cand_d *const_slsr_cand_t;
+typedef const class slsr_cand_d *const_slsr_cand_t;
 /* Pointers to candidates are chained together as part of a mapping
 from base expressions to the candidates that use them.  */
 struct cand_chain_d
 When we are not going to generate address arithmetic we treat
 increments that differ only in sign as the same, allowing sharing
 of the cost of initializers.  The absolute value of the increment
 is stored in the incr_info.  */
-struct incr_info_d
+class incr_info_d
 {
+public:
 /* The increment that relates a candidate to its basis.  */
 widest_int incr;
 /* How many times the increment occurs in the candidate tree.  */
 unsigned count;
 /* If the initializer was found to already exist, this is the block
 where it was found.  */
 basic_block init_bb;
 };
-typedef struct incr_info_d incr_info, *incr_info_t;
+typedef class incr_info_d incr_info, *incr_info_t;
 /* Candidates are maintained in a vector.  If candidate X dominates
 candidate Y, then X appears before Y in the vector; but the
 converse does not necessarily hold.  */
 static vec<slsr_cand_t> cand_vec;
 /* Produce a pointer to the IDX'th candidate in the candidate vector.  */
 static slsr_cand_t
 lookup_cand (cand_idx idx)
 {
-return cand_vec[idx - 1];
+return cand_vec[idx];
 }
 /* Helper for hashing a candidate chain header.  */
 struct cand_chain_hasher : nofree_ptr_hash <cand_chain>
 cand_chain_t chain;
 slsr_cand_t basis = NULL;
 // Limit potential of N^2 behavior for long candidate chains.
 int iters = 0;
-int max_iters = PARAM_VALUE (PARAM_MAX_SLSR_CANDIDATE_SCAN);
+int max_iters = param_max_slsr_candidate_scan;
 mapping_key.base_expr = base_expr;
 chain = base_cand_map->find (&mapping_key);
 for (; chain && iters < max_iters; chain = chain->next, ++iters)
 c->stride = stride;
 c->index = index;
 c->cand_type = ctype;
 c->stride_type = stype;
 c->kind = kind;
-c->cand_num = cand_vec.length () + 1;
+c->cand_num = cand_vec.length ();
 c->next_interp = 0;
 c->first_interp = c->cand_num;
 c->dependent = 0;
 c->sibling = 0;
 c->def_phi = kind == CAND_MULT ? find_phi_def (base) : 0;
 slsr_process_phi (gphi *phi, bool speed)
 {
 unsigned i;
 tree arg0_base = NULL_TREE, base_type;
 slsr_cand_t c;
-struct loop *cand_loop = gimple_bb (phi)->loop_father;
+class loop *cand_loop = gimple_bb (phi)->loop_father;
 unsigned savings = 0;
 /* A CAND_PHI requires each of its arguments to have the same
 derived base name.  (See the module header commentary for a
 definition of derived base names.)  Furthermore, all feeding
 	  /* X = B + (i * S), S is integer one.  */
 	  *pbase = base_cand->base_expr;
 	  return base_cand->index;
 	}
-if (base_cand->next_interp)
+base_cand = lookup_cand (base_cand->next_interp);
-	base_cand = lookup_cand (base_cand->next_interp);
-else
-	base_cand = NULL;
 }
 return 0;
 }
 	  if (has_single_use (base_in))
 	    savings = (base_cand->dead_savings
 		       + stmt_cost (base_cand->cand_stmt, speed));
 	}
-if (base_cand->next_interp)
+base_cand = lookup_cand (base_cand->next_interp);
-	base_cand = lookup_cand (base_cand->next_interp);
-else
-	base_cand = NULL;
 }
 if (!base)
 {
 /* No interpretations had anything useful to propagate, so
 	  if (has_single_use (base_in))
 	    savings = (base_cand->dead_savings
 		       + stmt_cost (base_cand->cand_stmt, speed));
 	}
-if (base_cand->next_interp)
+base_cand = lookup_cand (base_cand->next_interp);
-	base_cand = lookup_cand (base_cand->next_interp);
-else
-	base_cand = NULL;
 }
 if (!base)
 {
 /* No interpretations had anything useful to propagate, so
 	 is the stride and RHS2 is the base expression.  */
 c2 = create_mul_ssa_cand (gs, rhs2, rhs1, speed);
 c->next_interp = c2->cand_num;
 c2->first_interp = c->cand_num;
 }
-else if (TREE_CODE (rhs2) == INTEGER_CST)
+else if (TREE_CODE (rhs2) == INTEGER_CST && !integer_zerop (rhs2))
 {
 /* Record an interpretation for the multiply-immediate.  */
 c = create_mul_imm_cand (gs, rhs1, rhs2, speed);
 /* Add the interpretation to the statement-candidate mapping.  */
 	  if (has_single_use (addend_in))
 	    savings = (addend_cand->dead_savings
 		       + stmt_cost (addend_cand->cand_stmt, speed));
 	}
-if (addend_cand->next_interp)
+addend_cand = lookup_cand (addend_cand->next_interp);
-	addend_cand = lookup_cand (addend_cand->next_interp);
-else
-	addend_cand = NULL;
 }
 while (base_cand && !base && base_cand->kind != CAND_PHI)
 {
 if (base_cand->kind == CAND_ADD
 		  stype = subtrahend_cand->cand_type;
 		  if (has_single_use (addend_in))
 		    savings = (subtrahend_cand->dead_savings
 			       + stmt_cost (subtrahend_cand->cand_stmt, speed));
 		}
-	      if (subtrahend_cand->next_interp)
+	      subtrahend_cand = lookup_cand (subtrahend_cand->next_interp);
-		subtrahend_cand = lookup_cand (subtrahend_cand->next_interp);
-	      else
-		subtrahend_cand = NULL;
 	    }
 	}
-if (base_cand->next_interp)
+base_cand = lookup_cand (base_cand->next_interp);
-	base_cand = lookup_cand (base_cand->next_interp);
-else
-	base_cand = NULL;
 }
 if (!base)
 {
 /* No interpretations had anything useful to propagate, so
 	  if (has_single_use (base_in))
 	    savings = (base_cand->dead_savings
 		       + stmt_cost (base_cand->cand_stmt, speed));
 	}
-if (base_cand->next_interp)
+base_cand = lookup_cand (base_cand->next_interp);
-	base_cand = lookup_cand (base_cand->next_interp);
-else
-	base_cand = NULL;
 }
 if (!base)
 {
 /* No interpretations had anything useful to propagate, so
 	    first_cand = c;
 	  if (first_cand != c)
 	    c->first_interp = first_cand->cand_num;
-	  if (base_cand->next_interp)
+	  base_cand = lookup_cand (base_cand->next_interp);
-	    base_cand = lookup_cand (base_cand->next_interp);
-	  else
-	    base_cand = NULL;
 	}
 }
 else
 {
 /* If nothing is known about the RHS, create fresh CAND_ADD and
 	    first_cand = c;
 	  if (first_cand != c)
 	    c->first_interp = first_cand->cand_num;
-	  if (base_cand->next_interp)
+	  base_cand = lookup_cand (base_cand->next_interp);
-	    base_cand = lookup_cand (base_cand->next_interp);
-	  else
-	    base_cand = NULL;
 	}
 }
 else
 {
 /* If nothing is known about the RHS, create fresh CAND_ADD and
 slsr_cand_t c;
 fprintf (dump_file, "\nStrength reduction candidate vector:\n\n");
 FOR_EACH_VEC_ELT (cand_vec, i, c)
-dump_candidate (c);
+if (c != NULL)
+dump_candidate (c);
 }
 /* Callback used to dump the candidate chains hash table.  */
 int
 copy_ref_info (mem_ref, *expr);
 *expr = mem_ref;
 update_stmt (c->cand_stmt);
 }
+/* Return true if CAND_REF candidate C is a valid memory reference.  */
+static bool
+valid_mem_ref_cand_p (slsr_cand_t c)
+{
+if (TREE_CODE (TREE_OPERAND (c->stride, 1)) != INTEGER_CST)
+return false;
+struct mem_address addr
+= { NULL_TREE, c->base_expr, TREE_OPERAND (c->stride, 0),
+	TREE_OPERAND (c->stride, 1), wide_int_to_tree (sizetype, c->index) };
+return
+valid_mem_ref_p (TYPE_MODE (c->cand_type), TYPE_ADDR_SPACE (c->cand_type),
+		     &addr);
+}
 /* Replace CAND_REF candidate C, each sibling of candidate C, and each
 dependent of candidate C with an equivalent strength-reduced data
 reference.  */
 static void
 replace_refs (slsr_cand_t c)
 {
+/* Replacing a chain of only 2 candidates which are valid memory references
+is generally counter-productive because you cannot recoup the additional
+calculation added in front of them.  */
+if (c->basis == 0
+&& c->dependent
+&& !lookup_cand (c->dependent)->dependent
+&& valid_mem_ref_cand_p (c)
+&& valid_mem_ref_cand_p (lookup_cand (c->dependent)))
+return;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fputs ("Replacing reference: ", dump_file);
 print_gimple_stmt (dump_file, c->cand_stmt, 0);
 }
 gimple_set_location (copy_stmt, gimple_location (c->cand_stmt));
 gsi_replace (&gsi, copy_stmt, false);
 while (cc)
 	{
 	  cc->cand_stmt = copy_stmt;
-	  cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL;
+	  cc = lookup_cand (cc->next_interp);
 	}
 if (dump_file && (dump_flags & TDF_DETAILS))
 	stmt_to_print = copy_stmt;
 }
 else
 	  gimple_assign_set_rhs_with_ops (&gsi, code, basis_name, bump_tree);
 	  update_stmt (gsi_stmt (gsi));
 	  while (cc)
 	    {
 	      cc->cand_stmt = gsi_stmt (gsi);
-	      cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL;
+	      cc = lookup_cand (cc->next_interp);
 	    }
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    stmt_to_print = gsi_stmt (gsi);
 	}
 }
 gimple_assign_set_rhs_with_ops (&gsi, new_code, new_rhs1, new_rhs2);
 update_stmt (gsi_stmt (gsi));
 while (cc)
 	{
 	  cc->cand_stmt = gsi_stmt (gsi);
-	  cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL;
+	  cc = lookup_cand (cc->next_interp);
 	}
 if (dump_file && (dump_flags & TDF_DETAILS))
 	return gsi_stmt (gsi);
 }
 	  gimple_assign_set_rhs_with_ops (&gsi, MINUS_EXPR, basis_name, rhs2);
 	  update_stmt (gsi_stmt (gsi));
 	  while (cc)
 	    {
 	      cc->cand_stmt = gsi_stmt (gsi);
-	      cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL;
+	      cc = lookup_cand (cc->next_interp);
 	    }
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    stmt_to_print = gsi_stmt (gsi);
 	}
 	  gimple_set_location (copy_stmt, gimple_location (c->cand_stmt));
 	  gsi_replace (&gsi, copy_stmt, false);
 	  while (cc)
 	    {
 	      cc->cand_stmt = copy_stmt;
-	      cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL;
+	      cc = lookup_cand (cc->next_interp);
 	    }
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    stmt_to_print = copy_stmt;
 	}
 	  gimple_set_location (cast_stmt, gimple_location (c->cand_stmt));
 	  gsi_replace (&gsi, cast_stmt, false);
 	  while (cc)
 	    {
 	      cc->cand_stmt = cast_stmt;
-	      cc = cc->next_interp ? lookup_cand (cc->next_interp) : NULL;
+	      cc = lookup_cand (cc->next_interp);
 	    }
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    stmt_to_print = cast_stmt;
 	}
 slsr_cand_t c;
 /* Each candidate that has a null basis and a non-null
 dependent is the root of a tree of related statements.
 Analyze each tree to determine a subset of those
-statements that can be replaced with maximum benefit.  */
+statements that can be replaced with maximum benefit.
-FOR_EACH_VEC_ELT (cand_vec, i, c)
+Note the first NULL element is skipped.  */
+FOR_EACH_VEC_ELT_FROM (cand_vec, i, c, 1)
 {
 slsr_cand_t first_dep;
 if (c->basis != 0 || c->dependent == 0)
 	continue;
 pass_strength_reduction::execute (function *fun)
 {
 /* Create the obstack where candidates will reside.  */
 gcc_obstack_init (&cand_obstack);
-/* Allocate the candidate vector.  */
+/* Allocate the candidate vector and initialize the first NULL element.  */
 cand_vec.create (128);
+cand_vec.safe_push (NULL);
 /* Allocate the mapping from statements to candidate indices.  */
 stmt_cand_map = new hash_map<gimple *, slsr_cand_t>;
 /* Create the obstack where candidate chains will reside.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple-ssa-strength-reduction.c @ 145:1830386684a0