CbC/CbC_gcc: gcc/tree-ssa-ccp.c comparison

comparison gcc/tree-ssa-ccp.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
 /* Conditional constant propagation pass for the GNU compiler.
-Copyright (C) 2000-2017 Free Software Foundation, Inc.
+Copyright (C) 2000-2018 Free Software Foundation, Inc.
 Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
 Adapted to GIMPLE trees by Diego Novillo <dnovillo@redhat.com>
 This file is part of GCC.
 #include "tree-cfg.h"
 #include "tree-ssa-propagate.h"
 #include "dbgcnt.h"
 #include "params.h"
 #include "builtins.h"
-#include "tree-chkp.h"
 #include "cfgloop.h"
 #include "stor-layout.h"
 #include "optabs-query.h"
 #include "tree-ssa-ccp.h"
 #include "tree-dfa.h"
 #include "diagnostic-core.h"
 #include "stringpool.h"
 #include "attribs.h"
+#include "tree-vector-builder.h"
 /* Possible lattice values.  */
 typedef enum
 {
 UNINITIALIZED,
 /* Mask that applies to the propagated value during CCP.  For X
 with a CONSTANT lattice value X & ~mask == value & ~mask.  The
 zero bits in the mask cover constant values.  The ones mean no
 information.  */
 widest_int mask;
+};
+class ccp_propagate : public ssa_propagation_engine
+{
+public:
+enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE;
+enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE;
 };
 /* Array of propagated constant values.  After propagation,
 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I).  If
 the constant is held in an SSA name representing a memory store
 doing the store).  */
 static ccp_prop_value_t *const_val;
 static unsigned n_const_val;
 static void canonicalize_value (ccp_prop_value_t *);
-static bool ccp_fold_stmt (gimple_stmt_iterator *);
 static void ccp_lattice_meet (ccp_prop_value_t *, ccp_prop_value_t *);
 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX.  */
 static void
 	return true;
 }
 else if (VECTOR_FLOAT_TYPE_P (type)
 	   && !HONOR_NANS (type))
 {
-for (unsigned i = 0; i < VECTOR_CST_NELTS (old_val.value); ++i)
+unsigned int count
+	= tree_vector_builder::binary_encoded_nelts (old_val.value,
+						     new_val.value);
+for (unsigned int i = 0; i < count; ++i)
 	if (!REAL_VALUE_ISNAN
-	       (TREE_REAL_CST (VECTOR_CST_ELT (old_val.value, i)))
+	       (TREE_REAL_CST (VECTOR_CST_ENCODED_ELT (old_val.value, i)))
-	    && !operand_equal_p (VECTOR_CST_ELT (old_val.value, i),
+	    && !operand_equal_p (VECTOR_CST_ENCODED_ELT (old_val.value, i),
-				 VECTOR_CST_ELT (new_val.value, i), 0))
+				 VECTOR_CST_ENCODED_ELT (new_val.value, i), 0))
 	  return false;
 return true;
 }
 else if (COMPLEX_FLOAT_TYPE_P (type)
 	   && !HONOR_NANS (type))
 if (is_gimple_call (stmt))
 {
 tree fndecl, fntype = gimple_call_fntype (stmt);
 if (!gimple_call_lhs (stmt)
 	  || ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
-	      && !DECL_BUILT_IN (fndecl)
+	      && !fndecl_built_in_p (fndecl)
 	      && !lookup_attribute ("assume_aligned",
 				    TYPE_ATTRIBUTES (fntype))
 	      && !lookup_attribute ("alloc_align",
 				    TYPE_ATTRIBUTES (fntype))))
 	return true;
 const_val[i].value = NULL_TREE;
 }
 }
 }
+/* We want to provide our own GET_VALUE and FOLD_STMT virtual methods.  */
+class ccp_folder : public substitute_and_fold_engine
+{
+public:
+tree get_value (tree) FINAL OVERRIDE;
+bool fold_stmt (gimple_stmt_iterator *) FINAL OVERRIDE;
+};
+/* This method just wraps GET_CONSTANT_VALUE for now.  Over time
+naked calls to GET_CONSTANT_VALUE should be eliminated in favor
+of calling member functions.  */
+tree
+ccp_folder::get_value (tree op)
+{
+return get_constant_value (op);
+}
 /* Do final substitution of propagated values, cleanup the flowgraph and
 free allocated storage.  If NONZERO_P, record nonzero bits.
 Return TRUE when something was optimized.  */
 	  set_nonzero_bits (name, nonzero_bits);
 	}
 }
 /* Perform substitutions based on the known constant values.  */
-something_changed = substitute_and_fold (get_constant_value, ccp_fold_stmt);
+class ccp_folder ccp_folder;
+something_changed = ccp_folder.substitute_and_fold ();
 free (const_val);
 const_val = NULL;
-return something_changed;;
+return something_changed;
 }
 /* Compute the meet operator between *VAL1 and *VAL2.  Store the result
 in VAL1.
 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
 lattice values to determine PHI_NODE's lattice value.  The value of a
 PHI node is determined calling ccp_lattice_meet with all the arguments
 of the PHI node that are incoming via executable edges.  */
-static enum ssa_prop_result
+enum ssa_prop_result
-ccp_visit_phi_node (gphi *phi)
+ccp_propagate::visit_phi (gphi *phi)
 {
 unsigned i;
 ccp_prop_value_t new_val;
 if (dump_file && (dump_flags & TDF_DETAILS))
 edge e = gimple_phi_arg_edge (phi, i);
 if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file,
-	      "\n    Argument #%d (%d -> %d %sexecutable)\n",
+	      "\tArgument #%d (%d -> %d %sexecutable)\n",
 	      i, e->src->index, e->dest->index,
 	      (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
 	}
 /* If the incoming edge is executable, Compute the meet operator for
 					     visited);
 }
 else if (gimple_assign_ssa_name_copy_p (stmt))
 insert_clobber_before_stack_restore (gimple_assign_lhs (stmt), var,
 					   visited);
-else if (chkp_gimple_call_builtin_p (stmt, BUILT_IN_CHKP_BNDRET))
-continue;
 else
 gcc_assert (is_gimple_debug (stmt));
 }
 /* Advance the iterator to the previous non-debug gimple statement in the same
 }
 /* Fold the stmt at *GSI with CCP specific information that propagating
 and regular folding does not catch.  */
-static bool
+bool
-ccp_fold_stmt (gimple_stmt_iterator *gsi)
+ccp_folder::fold_stmt (gimple_stmt_iterator *gsi)
 {
 gimple *stmt = gsi_stmt (*gsi);
 switch (gimple_code (stmt))
 {
 If STMT is a conditional branch and we can determine its truth
 value, set *TAKEN_EDGE_P accordingly.  If STMT produces a varying
 value, return SSA_PROP_VARYING.  */
-static enum ssa_prop_result
+enum ssa_prop_result
-ccp_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
+ccp_propagate::visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
 {
 tree def;
 ssa_op_iter iter;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 unsigned int todo = 0;
 calculate_dominance_info (CDI_DOMINATORS);
 ccp_initialize ();
-ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
+class ccp_propagate ccp_propagate;
+ccp_propagate.ssa_propagate ();
 if (ccp_finalize (nonzero_p || flag_ipa_bit_cp))
 {
 todo = (TODO_cleanup_cfg | TODO_update_ssa);
 /* ccp_finalize does not preserve loop-closed ssa.  */
 if (gimple_code (stmt) != GIMPLE_CALL)
 	continue;
 callee = gimple_call_fndecl (stmt);
 if (!callee
-	  || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
+	  || !fndecl_built_in_p (callee, BUILT_IN_NORMAL)
 	  /* All regular builtins are ok, just obviously not alloca.  */
 	  || ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (callee)))
 	return NULL_TREE;
 if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE)
 {
 gimple *stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
 if (is_gimple_call (stack_save))
 	{
 	  callee = gimple_call_fndecl (stack_save);
-	  if (callee
+	  if (callee && fndecl_built_in_p (callee, BUILT_IN_STACK_SAVE))
-	      && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
-	      && DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_SAVE)
 	    {
 	      gimple_stmt_iterator stack_save_gsi;
 	      tree rhs;
 	      stack_save_gsi = gsi_for_stmt (stack_save);
 				    bit, flag);
 gimple_call_set_lhs (g, new_lhs);
 gimple_set_location (g, gimple_location (call));
 gimple_set_vuse (g, gimple_vuse (call));
 gimple_set_vdef (g, gimple_vdef (call));
-bool throws = stmt_can_throw_internal (call);
+bool throws = stmt_can_throw_internal (cfun, call);
 gimple_call_set_nothrow (as_a <gcall *> (g),
 			   gimple_call_nothrow_p (as_a <gcall *> (call)));
 SSA_NAME_DEF_STMT (gimple_vdef (call)) = g;
 gimple_stmt_iterator gsi = *gsip;
 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
 if (vuse == NULL)
 return;
 gimple *defstmt = SSA_NAME_DEF_STMT (vuse);
 tree src2 = NULL_TREE, len2 = NULL_TREE;
-HOST_WIDE_INT offset, offset2;
+poly_int64 offset, offset2;
 tree val = integer_zero_node;
 if (gimple_store_p (defstmt)
 && gimple_assign_single_p (defstmt)
 && TREE_CODE (gimple_assign_rhs1 (defstmt)) == CONSTRUCTOR
 && !gimple_clobber_p (defstmt))
 if (len2 == NULL_TREE)
 len2 = (TREE_CODE (src2) == COMPONENT_REF
 	    ? DECL_SIZE_UNIT (TREE_OPERAND (src2, 1))
 	    : TYPE_SIZE_UNIT (TREE_TYPE (src2)));
 if (len == NULL_TREE
-|| TREE_CODE (len) != INTEGER_CST
+|| !poly_int_tree_p (len)
 || len2 == NULL_TREE
-|| TREE_CODE (len2) != INTEGER_CST)
+|| !poly_int_tree_p (len2))
 return;
 src = get_addr_base_and_unit_offset (src, &offset);
 src2 = get_addr_base_and_unit_offset (src2, &offset2);
 if (src == NULL_TREE
 || src2 == NULL_TREE
-|| offset < offset2)
+|| maybe_lt (offset, offset2))
 return;
 if (!operand_equal_p (src, src2, 0))
 return;
 /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
 Make sure that
 [ src + offset, src + offset + len - 1 ] is a subset of that.  */
-if (wi::to_offset (len) + (offset - offset2) > wi::to_offset (len2))
+if (maybe_gt (wi::to_poly_offset (len) + (offset - offset2),
+		wi::to_poly_offset (len2)))
 return;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "Simplified\n  ");
 	      gsi_next (&i);
 	      continue;
 	    }
 	  callee = gimple_call_fndecl (stmt);
-	  if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
+	  if (!callee || !fndecl_built_in_p (callee, BUILT_IN_NORMAL))
 	    {
 	      gsi_next (&i);
 	      continue;
 	    }
 	      gsi_next (&i);
 	      continue;
 	    }
 	  callee = gimple_call_fndecl (stmt);
 	  if (!callee
-|| DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
+	      || !fndecl_built_in_p (callee, fcode))
-	      || DECL_FUNCTION_CODE (callee) == fcode)
 	    gsi_next (&i);
 	}
 }
 /* Delete unreachable blocks.  */
 		      if (!bitmap_empty_p (nonnullargs)
 			  && !bitmap_bit_p (nonnullargs, i))
 			continue;
 		      location_t loc = gimple_location (stmt);
+		      auto_diagnostic_group d;
 		      if (warning_at (loc, OPT_Wnonnull,
-				      "argument %u null where non-null "
+				      "%Gargument %u null where non-null "
-				      "expected", i + 1))
+				      "expected", stmt, i + 1))
 			{
 			  tree fndecl = gimple_call_fndecl (stmt);
 			  if (fndecl && DECL_IS_BUILTIN (fndecl))
 			    inform (loc, "in a call to built-in function %qD",
 				    fndecl);

Mercurial > hg > CbC > CbC_gcc

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