CbC/CbC_gcc: gcc/tree-ssa-math-opts.c comparison

comparison gcc/tree-ssa-math-opts.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
 /* Global, SSA-based optimizations using mathematical identities.
-Copyright (C) 2005-2018 Free Software Foundation, Inc.
+Copyright (C) 2005-2020 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
 #include "stor-layout.h"
 #include "tree-cfg.h"
 #include "tree-dfa.h"
 #include "tree-ssa.h"
 #include "builtins.h"
-#include "params.h"
 #include "internal-fn.h"
 #include "case-cfn-macros.h"
 #include "optabs-libfuncs.h"
 #include "tree-eh.h"
 #include "targhooks.h"
 	 && gimple_assign_rhs_code (use_stmt) == RDIV_EXPR
 	 && gimple_assign_rhs2 (use_stmt) == def
 	 /* Do not recognize x / x as valid division, as we are getting
 	    confused later by replacing all immediate uses x in such
 	    a stmt.  */
-	 && gimple_assign_rhs1 (use_stmt) != def;
+	 && gimple_assign_rhs1 (use_stmt) != def
+	 && !stmt_can_throw_internal (cfun, use_stmt);
 }
 /* Return TRUE if USE_STMT is a multiplication of DEF by A.  */
 static inline bool
 is_mult_by (gimple *use_stmt, tree def, tree a)
 static inline bool
 is_division_by_square (gimple *use_stmt, tree def)
 {
 if (gimple_code (use_stmt) == GIMPLE_ASSIGN
 && gimple_assign_rhs_code (use_stmt) == RDIV_EXPR
-&& gimple_assign_rhs1 (use_stmt) != gimple_assign_rhs2 (use_stmt))
+&& gimple_assign_rhs1 (use_stmt) != gimple_assign_rhs2 (use_stmt)
+&& !stmt_can_throw_internal (cfun, use_stmt))
 {
 tree denominator = gimple_assign_rhs2 (use_stmt);
 if (TREE_CODE (denominator) == SSA_NAME)
-	{
+	return is_square_of (SSA_NAME_DEF_STMT (denominator), def);
-	  return is_square_of (SSA_NAME_DEF_STMT (denominator), def);
-	}
 }
 return 0;
 }
 /* Walk the subset of the dominator tree rooted at OCC, setting the
 	{
 	  fprintf (dump_file, "Replacing original division\n");
 	  print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);
 	  fprintf (dump_file, "with new division\n");
 	}
-gimple_assign_set_lhs (stmt, sqr_ssa_name);
+stmt
-gimple_assign_set_rhs2 (stmt, a);
+	= gimple_build_assign (sqr_ssa_name, gimple_assign_rhs_code (stmt),
+			       gimple_assign_rhs1 (stmt), a);
+gsi_insert_before (def_gsi, stmt, GSI_SAME_STMT);
+gsi_remove (def_gsi, true);
+*def_gsi = gsi_for_stmt (stmt);
 fold_stmt_inplace (def_gsi);
 update_stmt (stmt);
 if (dump_file)
 	print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);
 gcc_assert (orig_sqrt_ssa_name);
 gcc_assert (sqr_ssa_name);
 gimple *new_stmt
 	= gimple_build_assign (x, MULT_EXPR,
-				orig_sqrt_ssa_name, sqr_ssa_name);
+			       orig_sqrt_ssa_name, sqr_ssa_name);
 gsi_insert_after (def_gsi, new_stmt, GSI_NEW_STMT);
 update_stmt (stmt);
 }
 else if (delete_div)
 {
 /* Remove the original division.  */
 gimple_stmt_iterator gsi2 = gsi_for_stmt (stmt);
 gsi_remove (&gsi2, true);
 release_defs (stmt);
 }
+else
+release_ssa_name (x);
 }
 /* Look for floating-point divisions among DEF's uses, and try to
 replace them by multiplications with the reciprocal.  Add
 as many statements computing the reciprocal as needed.
 /* Square reciprocals were counted twice above.  */
 square_recip_count /= 2;
 /* If it is more profitable to optimize 1 / x, don't optimize 1 / (x * x).  */
 if (sqrt_recip_count > square_recip_count)
-return;
+goto out;
 /* Do the expensive part only if we can hope to optimize something.  */
 if (count + square_recip_count >= threshold && count >= 1)
 {
 gimple *use_stmt;
 		}
 	    }
 	}
 }
+out:
 for (occ = occ_head; occ; )
 occ = free_bb (occ);
 occ_head = NULL;
 }
 	    {
 	      execute_cse_reciprocals_1 (&gsi, def);
 	      stmt = gsi_stmt (gsi);
 	      if (flag_unsafe_math_optimizations
 		  && is_gimple_assign (stmt)
+		  && gimple_assign_lhs (stmt) == def
 		  && !stmt_can_throw_internal (cfun, stmt)
 		  && gimple_assign_rhs_code (stmt) == RDIV_EXPR)
 		optimize_recip_sqrt (&gsi, def);
 	    }
 	}
 		      if (ifn == IFN_LAST)
 			stmt2 = gimple_build_call_vec (fndecl, args);
 		      else
 			stmt2 = gimple_build_call_internal_vec (ifn, args);
 		      gimple_call_set_lhs (stmt2, arg1);
-		      if (gimple_vdef (call))
+		      gimple_move_vops (stmt2, call);
-			{
-			  gimple_set_vdef (stmt2, gimple_vdef (call));
-			  SSA_NAME_DEF_STMT (gimple_vdef (stmt2)) = stmt2;
-			}
 		      gimple_call_set_nothrow (stmt2,
 					       gimple_call_nothrow_p (call));
-		      gimple_set_vuse (stmt2, gimple_vuse (call));
 		      gimple_stmt_iterator gsi2 = gsi_for_stmt (call);
 		      gsi_replace (&gsi2, stmt2, true);
 		    }
 		  else
 		    {
 && hw_sqrt_exists
 && (speed_p || real_equal (&c, &dconst1_4))
 && !HONOR_SIGNED_ZEROS (mode))
 {
 unsigned int max_depth = speed_p
-				? PARAM_VALUE (PARAM_MAX_POW_SQRT_DEPTH)
+				? param_max_pow_sqrt_depth
 				: 2;
 tree expand_with_sqrts
 	= expand_pow_as_sqrts (gsi, loc, arg0, arg1, max_depth);
 gimple_call_set_nothrow (fma_stmt, !stmt_can_throw_internal (cfun,
 								   use_stmt));
 gsi_replace (&gsi, fma_stmt, true);
 /* Follow all SSA edges so that we generate FMS, FNMA and FNMS
 	 regardless of where the negation occurs.  */
+gimple *orig_stmt = gsi_stmt (gsi);
 if (fold_stmt (&gsi, follow_all_ssa_edges))
-	update_stmt (gsi_stmt (gsi));
+	{
+	  if (maybe_clean_or_replace_eh_stmt (orig_stmt, gsi_stmt (gsi)))
+	    gcc_unreachable ();
+	  update_stmt (gsi_stmt (gsi));
+	}
 if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file, "Generated FMA ");
 	  print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, TDF_NONE);
 }
 /* Combine the multiplication at MUL_STMT with operands MULOP1 and MULOP2
 with uses in additions and subtractions to form fused multiply-add
 operations.  Returns true if successful and MUL_STMT should be removed.
+If MUL_COND is nonnull, the multiplication in MUL_STMT is conditional
+on MUL_COND, otherwise it is unconditional.
 If STATE indicates that we are deferring FMA transformation, that means
 that we do not produce FMAs for basic blocks which look like:
 <bb 6>
 and if we later discover an FMA candidate that is not part of such a chain,
 we go back and perform all deferred past candidates.  */
 static bool
 convert_mult_to_fma (gimple *mul_stmt, tree op1, tree op2,
-		     fma_deferring_state *state)
+		     fma_deferring_state *state, tree mul_cond = NULL_TREE)
 {
 tree mul_result = gimple_get_lhs (mul_stmt);
 tree type = TREE_TYPE (mul_result);
 gimple *use_stmt, *neguse_stmt;
 use_operand_p use_p;
 return false;
 bool check_defer
 = (state->m_deferring_p
 && (tree_to_shwi (TYPE_SIZE (type))
-	   <= PARAM_VALUE (PARAM_AVOID_FMA_MAX_BITS)));
+	   <= param_avoid_fma_max_bits));
 bool defer = check_defer;
+bool seen_negate_p = false;
 /* Make sure that the multiplication statement becomes dead after
 the transformation, thus that all uses are transformed to FMAs.
 This means we assume that an FMA operation has the same cost
 as an addition.  */
 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, mul_result)
 	  && gimple_assign_rhs_code (use_stmt) == NEGATE_EXPR)
 	{
 	  ssa_op_iter iter;
 	  use_operand_p usep;
+	  /* If (due to earlier missed optimizations) we have two
+	     negates of the same value, treat them as equivalent
+	     to a single negate with multiple uses.  */
+	  if (seen_negate_p)
+	    return false;
 	  result = gimple_assign_lhs (use_stmt);
 	  /* Make sure the negate statement becomes dead with this
 	     single transformation.  */
 	  if (!single_imm_use (gimple_assign_lhs (use_stmt),
 	  /* Re-validate.  */
 	  use_stmt = neguse_stmt;
 	  if (gimple_bb (use_stmt) != gimple_bb (mul_stmt))
 	    return false;
-	  negate_p = true;
+	  negate_p = seen_negate_p = true;
 	}
 tree cond, else_value, ops[3];
 tree_code code;
 if (!can_interpret_as_conditional_op_p (use_stmt, &cond, &code, ops,
 	  break;
 	default:
 	  /* FMA can only be formed from PLUS and MINUS.  */
 	  return false;
 	}
+if (mul_cond && cond != mul_cond)
+	return false;
 if (cond)
 	{
 	  if (cond == result || else_value == result)
 	    return false;
 void
 math_opts_dom_walker::after_dom_children (basic_block bb)
 {
 gimple_stmt_iterator gsi;
-fma_deferring_state fma_state (PARAM_VALUE (PARAM_AVOID_FMA_MAX_BITS) > 0);
+fma_deferring_state fma_state (param_avoid_fma_max_bits > 0);
 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
 {
 gimple *stmt = gsi_stmt (gsi);
 enum tree_code code;
 	    default:;
 	    }
 	}
 else if (is_gimple_call (stmt))
 	{
-	  tree fndecl = gimple_call_fndecl (stmt);
+	  switch (gimple_call_combined_fn (stmt))
-	  if (fndecl && gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
 	    {
-	      switch (DECL_FUNCTION_CODE (fndecl))
+	    CASE_CFN_POW:
+	      if (gimple_call_lhs (stmt)
+		  && TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST
+		  && real_equal (&TREE_REAL_CST (gimple_call_arg (stmt, 1)),
+				 &dconst2)
+		  && convert_mult_to_fma (stmt,
+					  gimple_call_arg (stmt, 0),
+					  gimple_call_arg (stmt, 0),
+					  &fma_state))
 		{
-		case BUILT_IN_POWF:
+		  unlink_stmt_vdef (stmt);
-		case BUILT_IN_POW:
+		  if (gsi_remove (&gsi, true)
-		case BUILT_IN_POWL:
+		      && gimple_purge_dead_eh_edges (bb))
-		  if (gimple_call_lhs (stmt)
+		    *m_cfg_changed_p = true;
-		      && TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST
+		  release_defs (stmt);
-		      && real_equal
+		  continue;
-		      (&TREE_REAL_CST (gimple_call_arg (stmt, 1)),
-		       &dconst2)
-		      && convert_mult_to_fma (stmt,
-					      gimple_call_arg (stmt, 0),
-					      gimple_call_arg (stmt, 0),
-					      &fma_state))
-		    {
-		      unlink_stmt_vdef (stmt);
-		      if (gsi_remove (&gsi, true)
-			  && gimple_purge_dead_eh_edges (bb))
-			*m_cfg_changed_p = true;
-		      release_defs (stmt);
-		      continue;
-		    }
-		  break;
-		default:;
 		}
+	      break;
+	    case CFN_COND_MUL:
+	      if (convert_mult_to_fma (stmt,
+				       gimple_call_arg (stmt, 1),
+				       gimple_call_arg (stmt, 2),
+				       &fma_state,
+				       gimple_call_arg (stmt, 0)))
+		{
+		  gsi_remove (&gsi, true);
+		  release_defs (stmt);
+		  continue;
+		}
+	      break;
+	    case CFN_LAST:
+	      cancel_fma_deferring (&fma_state);
+	      break;
+	    default:
+	      break;
 	    }
-	  else
-	    cancel_fma_deferring (&fma_state);
 	}
 gsi_next (&gsi);
 }
 if (fma_state.m_deferring_p
 && fma_state.m_initial_phi)
 {
 bool cfg_changed = false;
 memset (&widen_mul_stats, 0, sizeof (widen_mul_stats));
 calculate_dominance_info (CDI_DOMINATORS);
-renumber_gimple_stmt_uids ();
+renumber_gimple_stmt_uids (cfun);
 math_opts_dom_walker (&cfg_changed).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
 statistics_counter_event (fun, "widening multiplications inserted",
 			    widen_mul_stats.widen_mults_inserted);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-math-opts.c @ 145:1830386684a0