CbC/CbC_gcc: gcc/tree-sra.c comparison

comparison gcc/tree-sra.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
 /* Scalar Replacement of Aggregates (SRA) converts some structure
 references into scalar references, exposing them to the scalar
 optimizers.
-Copyright (C) 2008-2017 Free Software Foundation, Inc.
+Copyright (C) 2008-2018 Free Software Foundation, Inc.
 Contributed by Martin Jambor <mjambor@suse.cz>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "gimple-walk.h"
 #include "tree-cfg.h"
 #include "tree-dfa.h"
 #include "tree-ssa.h"
 #include "symbol-summary.h"
+#include "ipa-param-manipulation.h"
 #include "ipa-prop.h"
 #include "params.h"
 #include "dbgcnt.h"
 #include "tree-inline.h"
 #include "ipa-fnsummary.h"
 static struct access *
 create_access (tree expr, gimple *stmt, bool write)
 {
 struct access *access;
+poly_int64 poffset, psize, pmax_size;
 HOST_WIDE_INT offset, size, max_size;
 tree base = expr;
 bool reverse, ptr, unscalarizable_region = false;
-base = get_ref_base_and_extent (expr, &offset, &size, &max_size, &reverse);
+base = get_ref_base_and_extent (expr, &poffset, &psize, &pmax_size,
+				  &reverse);
+if (!poffset.is_constant (&offset)
+|| !psize.is_constant (&size)
+|| !pmax_size.is_constant (&max_size))
+{
+disqualify_candidate (base, "Encountered a polynomial-sized access.");
+return NULL;
+}
 if (sra_mode == SRA_MODE_EARLY_IPA
 && TREE_CODE (base) == MEM_REF)
 {
 base = get_ssa_base_param (TREE_OPERAND (base, 0));
 }
 return false;
 }
+/* Return true if REF contains a VIEW_CONVERT_EXPR or a MEM_REF that performs
+type conversion or a COMPONENT_REF with a bit-field field declaration.  */
+static bool
+contains_vce_or_bfcref_p (const_tree ref)
+{
+while (handled_component_p (ref))
+{
+if (TREE_CODE (ref) == VIEW_CONVERT_EXPR
+	  || (TREE_CODE (ref) == COMPONENT_REF
+	      && DECL_BIT_FIELD (TREE_OPERAND (ref, 1))))
+	return true;
+ref = TREE_OPERAND (ref, 0);
+}
+if (TREE_CODE (ref) != MEM_REF
+|| TREE_CODE (TREE_OPERAND (ref, 0)) != ADDR_EXPR)
+return false;
+tree mem = TREE_OPERAND (TREE_OPERAND (ref, 0), 0);
+if (TYPE_MAIN_VARIANT (TREE_TYPE (ref))
+!= TYPE_MAIN_VARIANT (TREE_TYPE (mem)))
+return true;
+return false;
+}
 /* Search the given tree for a declaration by skipping handled components and
 exclude it from the candidates.  */
 static void
 disqualify_base_of_expr (tree t, const char *reason)
 if (racc)
 {
 racc->grp_assignment_read = 1;
 if (should_scalarize_away_bitmap && !gimple_has_volatile_ops (stmt)
 	  && !is_gimple_reg_type (racc->type))
-	bitmap_set_bit (should_scalarize_away_bitmap, DECL_UID (racc->base));
+	{
+	  if (contains_vce_or_bfcref_p (rhs))
+	    bitmap_set_bit (cannot_scalarize_away_bitmap,
+			    DECL_UID (racc->base));
+	  else
+	    bitmap_set_bit (should_scalarize_away_bitmap,
+			    DECL_UID (racc->base));
+	}
 if (storage_order_barrier_p (lhs))
 	racc->grp_unscalarizable_region = 1;
 }
 if (lacc && racc
 	{
 	  gimple *stmt = gsi_stmt (gsi);
 	  tree t;
 	  unsigned i;
-	  if (final_bbs && stmt_can_throw_external (stmt))
+	  if (final_bbs && stmt_can_throw_external (cfun, stmt))
 	    bitmap_set_bit (final_bbs, bb->index);
 	  switch (gimple_code (stmt))
 	    {
 	    case GIMPLE_RETURN:
 	      t = gimple_return_retval (as_a <greturn *> (stmt));
 		  tree dest = gimple_call_fndecl (stmt);
 		  int flags = gimple_call_flags (stmt);
 		  if (dest)
 		    {
-		      if (DECL_BUILT_IN_CLASS (dest) == BUILT_IN_NORMAL
+		      if (fndecl_built_in_p (dest, BUILT_IN_APPLY_ARGS))
-			  && DECL_FUNCTION_CODE (dest) == BUILT_IN_APPLY_ARGS)
 			encountered_apply_args = true;
 		      if (recursive_call_p (current_function_decl, dest))
 			{
 			  encountered_recursive_call = true;
 			  if (!callsite_arguments_match_p (stmt))
 be non-NULL and is used to insert new statements either before or below
 the current one as specified by INSERT_AFTER.  This function is not capable
 of handling bitfields.  */
 tree
-build_ref_for_offset (location_t loc, tree base, HOST_WIDE_INT offset,
+build_ref_for_offset (location_t loc, tree base, poly_int64 offset,
 		      bool reverse, tree exp_type, gimple_stmt_iterator *gsi,
 		      bool insert_after)
 {
 tree prev_base = base;
 tree off;
 tree mem_ref;
-HOST_WIDE_INT base_offset;
+poly_int64 base_offset;
 unsigned HOST_WIDE_INT misalign;
 unsigned int align;
 /* Preserve address-space information.  */
 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (base));
 if (as != TYPE_ADDR_SPACE (exp_type))
 exp_type = build_qualified_type (exp_type,
 				     TYPE_QUALS (exp_type)
 				     | ENCODE_QUAL_ADDR_SPACE (as));
-gcc_checking_assert (offset % BITS_PER_UNIT == 0);
+poly_int64 byte_offset = exact_div (offset, BITS_PER_UNIT);
 get_object_alignment_1 (base, &align, &misalign);
 base = get_addr_base_and_unit_offset (base, &base_offset);
 /* get_addr_base_and_unit_offset returns NULL for references with a variable
 offset such as array[var_index].  */
 if (insert_after)
 	gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
 else
 	gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
-off = build_int_cst (reference_alias_ptr_type (prev_base),
+off = build_int_cst (reference_alias_ptr_type (prev_base), byte_offset);
-			   offset / BITS_PER_UNIT);
 base = tmp;
 }
 else if (TREE_CODE (base) == MEM_REF)
 {
 off = build_int_cst (TREE_TYPE (TREE_OPERAND (base, 1)),
-			   base_offset + offset / BITS_PER_UNIT);
+			   base_offset + byte_offset);
 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1), off);
 base = unshare_expr (TREE_OPERAND (base, 0));
 }
 else
 {
 off = build_int_cst (reference_alias_ptr_type (prev_base),
-			   base_offset + offset / BITS_PER_UNIT);
+			   base_offset + byte_offset);
 base = build_fold_addr_expr (unshare_expr (base));
 }
-misalign = (misalign + offset) & (align - 1);
+unsigned int align_bound = known_alignment (misalign + offset);
-if (misalign != 0)
+if (align_bound != 0)
-align = least_bit_hwi (misalign);
+align = MIN (align, align_bound);
 if (align != TYPE_ALIGN (exp_type))
 exp_type = build_aligned_type (exp_type, align);
 mem_ref = fold_build2_loc (loc, MEM_REF, exp_type, base, off);
 REF_REVERSE_STORAGE_ORDER (mem_ref) = reverse;
 static tree
 build_debug_ref_for_model (location_t loc, tree base, HOST_WIDE_INT offset,
 			   struct access *model)
 {
-HOST_WIDE_INT base_offset;
+poly_int64 base_offset;
 tree off;
 if (TREE_CODE (model->expr) == COMPONENT_REF
 && DECL_BIT_FIELD (TREE_OPERAND (model->expr, 1)))
 return NULL_TREE;
 			    DECL_UID (root->base)))
 	{
 	  gcc_checking_assert (!root->grp_scalar_read
 			       && !root->grp_assignment_read);
 	  sth_created = true;
-	  if (MAY_HAVE_DEBUG_STMTS)
+	  if (MAY_HAVE_DEBUG_BIND_STMTS)
 	    {
 	      root->grp_to_be_debug_replaced = 1;
 	      root->replacement_decl = create_access_replacement (root);
 	    }
 	}
 return it or NULL if it cannot be found.  */
 static struct access *
 get_access_for_expr (tree expr)
 {
-HOST_WIDE_INT offset, size, max_size;
+poly_int64 poffset, psize, pmax_size;
+HOST_WIDE_INT offset, max_size;
 tree base;
 bool reverse;
 /* FIXME: This should not be necessary but Ada produces V_C_Es with a type of
 a different size than the size of its argument and we need the latter
 one.  */
 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
 expr = TREE_OPERAND (expr, 0);
-base = get_ref_base_and_extent (expr, &offset, &size, &max_size, &reverse);
+base = get_ref_base_and_extent (expr, &poffset, &psize, &pmax_size,
-if (max_size == -1 || !DECL_P (base))
+				  &reverse);
+if (!known_size_p (pmax_size)
+|| !pmax_size.is_constant (&max_size)
+|| !poffset.is_constant (&offset)
+|| !DECL_P (base))
 return NULL;
 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (base)))
 return NULL;
 gcc_checking_assert (!racc->grp_to_be_replaced
 		       && !racc->grp_to_be_debug_replaced);
 if (!racc->replacement_decl)
 racc->replacement_decl = create_access_replacement (racc);
 return get_or_create_ssa_default_def (cfun, racc->replacement_decl);
-}
-/* Return true if REF has an VIEW_CONVERT_EXPR or a COMPONENT_REF with a
-bit-field field declaration somewhere in it.  */
-static inline bool
-contains_vce_or_bfcref_p (const_tree ref)
-{
-while (handled_component_p (ref))
-{
-if (TREE_CODE (ref) == VIEW_CONVERT_EXPR
-	  || (TREE_CODE (ref) == COMPONENT_REF
-	      && DECL_BIT_FIELD (TREE_OPERAND (ref, 1))))
-	return true;
-ref = TREE_OPERAND (ref, 0);
-}
-return false;
 }
 /* Examine both sides of the assignment statement pointed to by STMT, replace
 them with a scalare replacement if there is one and generate copying of
 replacements if scalarized aggregates have been used in the assignment.  GSI
 static struct access *
 splice_param_accesses (tree parm, bool *ro_grp)
 {
 int i, j, access_count, group_count;
-int agg_size, total_size = 0;
+int total_size = 0;
 struct access *access, *res, **prev_acc_ptr = &res;
 vec<access_p> *access_vec;
 access_vec = get_base_access_vector (parm);
 if (!access_vec)
 prev_acc_ptr = &access->next_grp;
 total_size += access->size;
 i = j;
 }
-if (POINTER_TYPE_P (TREE_TYPE (parm)))
-agg_size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))));
-else
-agg_size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (parm)));
-if (total_size >= agg_size)
-return NULL;
 gcc_assert (group_count > 0);
 return res;
 }
 /* Decide whether parameters with representative accesses given by REPR should
 be reduced into components.  */
 static int
 decide_one_param_reduction (struct access *repr)
 {
-int total_size, cur_parm_size, agg_size, new_param_count, parm_size_limit;
+HOST_WIDE_INT total_size, cur_parm_size;
 bool by_ref;
 tree parm;
 parm = repr->base;
 cur_parm_size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (parm)));
 gcc_assert (cur_parm_size > 0);
 if (POINTER_TYPE_P (TREE_TYPE (parm)))
-{
+by_ref = true;
-by_ref = true;
-agg_size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))));
-}
 else
-{
+by_ref = false;
-by_ref = false;
-agg_size = cur_parm_size;
-}
 if (dump_file)
 {
 struct access *acc;
 fprintf (dump_file, "Evaluating PARAM group sizes for ");
 for (acc = repr; acc; acc = acc->next_grp)
 	dump_access (dump_file, acc, true);
 }
 total_size = 0;
-new_param_count = 0;
+int new_param_count = 0;
 for (; repr; repr = repr->next_grp)
 {
 gcc_assert (parm == repr->base);
 new_param_count++;
 }
 gcc_assert (new_param_count > 0);
-if (optimize_function_for_size_p (cfun))
+if (!by_ref)
-parm_size_limit = cur_parm_size;
+{
+if (total_size >= cur_parm_size)
+	return 0;
+}
 else
-parm_size_limit = (PARAM_VALUE (PARAM_IPA_SRA_PTR_GROWTH_FACTOR)
+{
-* cur_parm_size);
+int parm_num_limit;
+if (optimize_function_for_size_p (cfun))
-if (total_size < agg_size
+	parm_num_limit = 1;
-&& total_size <= parm_size_limit)
+else
-{
+	parm_num_limit = PARAM_VALUE (PARAM_IPA_SRA_PTR_GROWTH_FACTOR);
-if (dump_file)
-	fprintf (dump_file, "    ....will be split into %i components\n",
+if (new_param_count > parm_num_limit
-		 new_param_count);
+	  || total_size > (parm_num_limit * cur_parm_size))
-return new_param_count;
+	return 0;
 }
-else
-return 0;
+if (dump_file)
+fprintf (dump_file, "    ....will be split into %i components\n",
+	     new_param_count);
+return new_param_count;
 }
 /* The order of the following enums is important, we need to do extra work for
 UNUSED_PARAMS, BY_VAL_ACCESSES and UNMODIF_BY_REF_ACCESSES.  */
 enum ipa_splicing_result { NO_GOOD_ACCESS, UNUSED_PARAMS, BY_VAL_ACCESSES,
 pop_cfun ();
 }
 for (cs = node->callers; cs; cs = cs->next_caller)
-if (bitmap_set_bit (recomputed_callers, cs->caller->uid)
+if (bitmap_set_bit (recomputed_callers, cs->caller->get_uid ())
 	&& gimple_in_ssa_p (DECL_STRUCT_FUNCTION (cs->caller->decl)))
 compute_fn_summary (cs->caller, true);
 BITMAP_FREE (recomputed_callers);
 return true;
 	  tree arg = gimple_call_arg (call_stmt, i);
 	  if (is_gimple_reg (arg))
 	      continue;
 	  tree offset;
-	  HOST_WIDE_INT bitsize, bitpos;
+	  poly_int64 bitsize, bitpos;
 	  machine_mode mode;
 	  int unsignedp, reversep, volatilep = 0;
 	  get_inner_reference (arg, &bitsize, &bitpos, &offset, &mode,
 			       &unsignedp, &reversep, &volatilep);
-	  if (bitpos % BITS_PER_UNIT)
+	  if (!multiple_p (bitpos, BITS_PER_UNIT))
 	    {
 	      iscc->bad_arg_alignment = true;
 	      return true;
 	    }
 	}
 	fprintf (dump_file, "Function is a virtual method.\n");
 return false;
 }
 if ((DECL_ONE_ONLY (node->decl) || DECL_EXTERNAL (node->decl))
+&& ipa_fn_summaries->get (node)
 && ipa_fn_summaries->get (node)->size >= MAX_INLINE_INSNS_AUTO)
 {
 if (dump_file)
 	fprintf (dump_file, "Function too big to be made truly local.\n");
 return false;

Mercurial > hg > CbC > CbC_gcc

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