static void fini_copy_prop (void) { unsigned i; /* Set the final copy-of value for each variable by traversing the copy-of chains. */ for (i = 1; i < num_ssa_names; i++) { tree var = ssa_name (i); if (!var || !copy_of[i].value || copy_of[i].value == var) continue; /* In theory the points-to solution of all members of the copy chain is their intersection. For now we do not bother to compute this but only make sure we do not lose points-to information completely by setting the points-to solution of the representative to the first solution we find if it doesn't have one already. */ if (copy_of[i].value != var && TREE_CODE (copy_of[i].value) == SSA_NAME && POINTER_TYPE_P (TREE_TYPE (var)) && SSA_NAME_PTR_INFO (var) && !SSA_NAME_PTR_INFO (copy_of[i].value)) duplicate_ssa_name_ptr_info (copy_of[i].value, SSA_NAME_PTR_INFO (var)); } /* Don't do DCE if we have loops. That's the simplest way to not destroy the scev cache. */ substitute_and_fold (get_value, NULL, !current_loops); free (copy_of); }
void copy_ref_info (tree new_ref, tree old_ref) { tree new_ptr_base = NULL_TREE; gcc_assert (TREE_CODE (new_ref) == MEM_REF || TREE_CODE (new_ref) == TARGET_MEM_REF); TREE_SIDE_EFFECTS (new_ref) = TREE_SIDE_EFFECTS (old_ref); TREE_THIS_VOLATILE (new_ref) = TREE_THIS_VOLATILE (old_ref); new_ptr_base = TREE_OPERAND (new_ref, 0); /* We can transfer points-to information from an old pointer or decl base to the new one. */ if (new_ptr_base && TREE_CODE (new_ptr_base) == SSA_NAME && !SSA_NAME_PTR_INFO (new_ptr_base)) { tree base = get_base_address (old_ref); if (!base) ; else if ((TREE_CODE (base) == MEM_REF || TREE_CODE (base) == TARGET_MEM_REF) && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME && SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0))) { struct ptr_info_def *new_pi; unsigned int align, misalign; duplicate_ssa_name_ptr_info (new_ptr_base, SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0))); new_pi = SSA_NAME_PTR_INFO (new_ptr_base); /* We have to be careful about transferring alignment information. */ if (get_ptr_info_alignment (new_pi, &align, &misalign) && TREE_CODE (old_ref) == MEM_REF && !(TREE_CODE (new_ref) == TARGET_MEM_REF && (TMR_INDEX2 (new_ref) || (TMR_STEP (new_ref) && (TREE_INT_CST_LOW (TMR_STEP (new_ref)) < align))))) { unsigned int inc = (mem_ref_offset (old_ref) - mem_ref_offset (new_ref)).low; adjust_ptr_info_misalignment (new_pi, inc); } else mark_ptr_info_alignment_unknown (new_pi); } else if (TREE_CODE (base) == VAR_DECL || TREE_CODE (base) == PARM_DECL || TREE_CODE (base) == RESULT_DECL) { struct ptr_info_def *pi = get_ptr_info (new_ptr_base); pt_solution_set_var (&pi->pt, base); } } }
tree duplicate_ssa_name_fn (struct function *fn, tree name, gimple stmt) { tree new_name = copy_ssa_name_fn (fn, name, stmt); struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name); if (old_ptr_info) duplicate_ssa_name_ptr_info (new_name, old_ptr_info); return new_name; }
tree duplicate_ssa_name (tree name, gimple stmt) { tree new_name = make_ssa_name (SSA_NAME_VAR (name), stmt); struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name); if (old_ptr_info) duplicate_ssa_name_ptr_info (new_name, old_ptr_info); return new_name; }
tree duplicate_ssa_name_fn (struct function *fn, tree name, gimple stmt) { tree new_name = copy_ssa_name_fn (fn, name, stmt); if (POINTER_TYPE_P (TREE_TYPE (name))) { struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name); if (old_ptr_info) duplicate_ssa_name_ptr_info (new_name, old_ptr_info); } else { struct range_info_def *old_range_info = SSA_NAME_RANGE_INFO (name); if (old_range_info) duplicate_ssa_name_range_info (new_name, old_range_info); } return new_name; }
static void fini_copy_prop (void) { size_t i; prop_value_t *tmp; /* Set the final copy-of value for each variable by traversing the copy-of chains. */ tmp = XCNEWVEC (prop_value_t, num_ssa_names); for (i = 1; i < num_ssa_names; i++) { tree var = ssa_name (i); if (!var || !copy_of[i].value || copy_of[i].value == var) continue; tmp[i].value = get_last_copy_of (var); /* In theory the points-to solution of all members of the copy chain is their intersection. For now we do not bother to compute this but only make sure we do not lose points-to information completely by setting the points-to solution of the representative to the first solution we find if it doesn't have one already. */ if (tmp[i].value != var && POINTER_TYPE_P (TREE_TYPE (var)) && SSA_NAME_PTR_INFO (var) && !SSA_NAME_PTR_INFO (tmp[i].value)) duplicate_ssa_name_ptr_info (tmp[i].value, SSA_NAME_PTR_INFO (var)); } substitute_and_fold (tmp, false); free (cached_last_copy_of); free (copy_of); free (tmp); }
static bool fini_copy_prop (void) { unsigned i; /* Set the final copy-of value for each variable by traversing the copy-of chains. */ for (i = 1; i < num_ssa_names; i++) { tree var = ssa_name (i); if (!var || !copy_of[i].value || copy_of[i].value == var) continue; /* In theory the points-to solution of all members of the copy chain is their intersection. For now we do not bother to compute this but only make sure we do not lose points-to information completely by setting the points-to solution of the representative to the first solution we find if it doesn't have one already. */ if (copy_of[i].value != var && TREE_CODE (copy_of[i].value) == SSA_NAME) { basic_block copy_of_bb = gimple_bb (SSA_NAME_DEF_STMT (copy_of[i].value)); basic_block var_bb = gimple_bb (SSA_NAME_DEF_STMT (var)); if (POINTER_TYPE_P (TREE_TYPE (var)) && SSA_NAME_PTR_INFO (var) && !SSA_NAME_PTR_INFO (copy_of[i].value)) { duplicate_ssa_name_ptr_info (copy_of[i].value, SSA_NAME_PTR_INFO (var)); /* Points-to information is cfg insensitive, but alignment info might be cfg sensitive, if it e.g. is derived from VRP derived non-zero bits. So, do not copy alignment info if the two SSA_NAMEs aren't defined in the same basic block. */ if (var_bb != copy_of_bb) mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (copy_of[i].value)); } else if (!POINTER_TYPE_P (TREE_TYPE (var)) && SSA_NAME_RANGE_INFO (var) && !SSA_NAME_RANGE_INFO (copy_of[i].value) && var_bb == copy_of_bb) duplicate_ssa_name_range_info (copy_of[i].value, SSA_NAME_RANGE_TYPE (var), SSA_NAME_RANGE_INFO (var)); } } bool changed = substitute_and_fold (get_value, NULL, true); if (changed) { free_numbers_of_iterations_estimates (); if (scev_initialized_p ()) scev_reset (); } free (copy_of); return changed; }