From 2a3ebafa45c591f2c37dcc249816c71c7930245b Mon Sep 17 00:00:00 2001 From: rguenth Date: Fri, 22 May 2009 20:41:31 +0000 Subject: [PATCH] 2009-05-22 Richard Guenther PR middle-end/38964 * alias.c (write_dependence_p): Do not use TBAA for answering anti-dependence or output-dependence. * tree-ssa-structalias.c (set_uids_in_ptset): Remove TBAA pruning code. (emit_pointer_definition): Remove. (emit_alias_warning): Likewise. (find_what_var_points_to): Remove TBAA pruning code. (find_what_p_points_to): Likewise. Do not warn about strict-aliasing violations. (compute_points_to_sets): Remove code computing the set of dereferenced pointers. * tree-data-ref.c (dr_may_alias_p): Properly use the split oracle for querying anti and output dependencies. * tree-ssa-alias.c (refs_may_alias_p_1): Add argument specifying if TBAA may be applied. (refs_anti_dependent_p): New function. (refs_output_dependent_p): Likewise. * tree-ssa-alias.h (refs_anti_dependent_p): Declare. (refs_output_dependent_p): Likewise. * doc/tree-ssa.texi (Memory model): New section. testsuite/ * g++.dg/warn/Wstrict-aliasing-float-ref-int-obj.C: XFAIL. * gcc.dg/Wstrict-aliasing-converted-assigned.c: Likewise. * gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c: Likewise. * doc/c-tree.texi (CHANGE_DYNAMIC_TYPE_EXPR): Remove. * doc/gimple.texi (GIMPLE_CHANGE_DYNAMIC_TYPE): Remove. * cfgexpand.c (expand_gimple_basic_block): Do not handle GIMPLE_CHANGE_DYNAMIC_TYPE or CHANGE_DYNAMIC_TYPE_EXPR. * expr.c (expand_expr_real_1): Likewise. * gimple-low.c (lower_stmt): Likewise. * gimple-pretty-print.c (dump_gimple_stmt): Likewise. (dump_gimple_cdt): Remove. * gimple.c (gss_for_code): Do not handle GIMPLE_CHANGE_DYNAMIC_TYPE. (gimple_size): Likewise. (walk_gimple_op): Likewise. (is_gimple_stmt): Likewise. (walk_stmt_load_store_addr_ops): Likewise. (gimple_build_cdt): Remove. * gimple.def (GIMPLE_CHANGE_DYNAMIC_TYPE): Remove. * gimple.h (gimple_cdt_new_type): Remove. (gimple_cdt_new_type_ptr): Likewise. (gimple_cdt_set_new_type): Likewise. (gimple_cdt_location): Likewise. (gimple_cdt_location_ptr): Likewise. (gimple_cdt_set_location): Likewise. * gimplify.c (gimplify_expr): Do not handle CHANGE_DYNAMIC_TYPE_EXPR. * tree-cfg.c (remove_useless_stmts_1): Do not handle GIMPLE_CHANGE_DYNAMIC_TYPE. (verify_types_in_gimple_stmt): Likewise. * tree-inline.c (estimate_num_insns): Likewise. (expand_call_inline): Do not copy DECL_NO_TBAA_P. (copy_decl_to_var): Likewise. (copy_result_decl_to_var): Likewise. * tree-pretty-print.c (dump_generic_node): Do not handle CHANGE_DYNAMIC_TYPE_EXPR. * tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Likewise. * tree-ssa-operands.c (get_expr_operands): Likewise. * tree-ssa-structalias.c (struct variable_info): Remove no_tbaa_pruning member. (new_var_info): Do not set it based on DECL_NO_TBAA_P. (unify_nodes): Do not copy it. (find_func_aliases): Do not handle GIMPLE_CHANGE_DYNAMIC_TYPE. (dump_solution_for_var): Do not dump no_tbaa_pruning state. (set_uids_in_ptset): Do not check it. (find_what_var_points_to): Likewise. (compute_tbaa_pruning): Remove. (compute_points_to_sets): Do not call it. * tree.c (walk_tree_1): Do not handle CHANGE_DYNAMIC_TYPE_EXPR. * tree.def (CHANGE_DYNAMIC_TYPE_EXPR): Remove. * tree.h (CHANGE_DYNAMIC_TYPE_NEW_TYPE): Remove. (CHANGE_DYNAMIC_TYPE_LOCATION): Likewise. (DECL_NO_TBAA_P): Likewise. (struct tree_decl_common): Move no_tbaa_flag to unused flags section. * omp-low.c (copy_var_decl): Do not copy DECL_NO_TBAA_P. (expand_omp_atomic_pipeline): Do not set it. * print-tree.c (print_node): Do not dump it. * tree-ssa-copyrename.c (copy_rename_partition_coalesce): Remove redundant check. cp/ * init.c (avoid_placement_new_aliasing): Remove. (build_new_1): Do not call it. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@147805 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 78 +++++ gcc/alias.c | 3 - gcc/cfgexpand.c | 2 +- gcc/cp/ChangeLog | 6 + gcc/cp/init.c | 61 +--- gcc/doc/c-tree.texi | 8 - gcc/doc/gimple.texi | 43 +-- gcc/doc/tree-ssa.texi | 29 ++ gcc/expr.c | 7 - gcc/gimple-low.c | 1 - gcc/gimple-pretty-print.c | 25 -- gcc/gimple.c | 31 +- gcc/gimple.def | 11 - gcc/gimple.h | 63 ---- gcc/gimplify.c | 13 - gcc/omp-low.c | 2 - gcc/print-tree.c | 2 - gcc/testsuite/ChangeLog | 7 + .../warn/Wstrict-aliasing-float-ref-int-obj.C | 4 +- .../gcc.dg/Wstrict-aliasing-converted-assigned.c | 4 +- .../gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c | 6 +- gcc/tree-cfg.c | 16 - gcc/tree-data-ref.c | 12 +- gcc/tree-inline.c | 10 - gcc/tree-pretty-print.c | 11 - gcc/tree-ssa-alias.c | 49 ++- gcc/tree-ssa-alias.h | 2 + gcc/tree-ssa-copyrename.c | 14 - gcc/tree-ssa-dce.c | 1 - gcc/tree-ssa-operands.c | 3 - gcc/tree-ssa-structalias.c | 359 +-------------------- gcc/tree.c | 4 - gcc/tree.def | 9 - gcc/tree.h | 15 +- 34 files changed, 198 insertions(+), 713 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 45778026483..32c00a6102d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,81 @@ +2009-05-22 Richard Guenther + + PR middle-end/38964 + * alias.c (write_dependence_p): Do not use TBAA for answering + anti-dependence or output-dependence. + * tree-ssa-structalias.c (set_uids_in_ptset): Remove TBAA pruning + code. + (emit_pointer_definition): Remove. + (emit_alias_warning): Likewise. + (find_what_var_points_to): Remove TBAA pruning code. + (find_what_p_points_to): Likewise. Do not warn about strict-aliasing + violations. + (compute_points_to_sets): Remove code computing the set of + dereferenced pointers. + * tree-data-ref.c (dr_may_alias_p): Properly use the split + oracle for querying anti and output dependencies. + * tree-ssa-alias.c (refs_may_alias_p_1): Add argument specifying + if TBAA may be applied. + (refs_anti_dependent_p): New function. + (refs_output_dependent_p): Likewise. + * tree-ssa-alias.h (refs_anti_dependent_p): Declare. + (refs_output_dependent_p): Likewise. + * doc/tree-ssa.texi (Memory model): New section. + * doc/c-tree.texi (CHANGE_DYNAMIC_TYPE_EXPR): Remove. + * doc/gimple.texi (GIMPLE_CHANGE_DYNAMIC_TYPE): Remove. + * cfgexpand.c (expand_gimple_basic_block): Do not handle + GIMPLE_CHANGE_DYNAMIC_TYPE or CHANGE_DYNAMIC_TYPE_EXPR. + * expr.c (expand_expr_real_1): Likewise. + * gimple-low.c (lower_stmt): Likewise. + * gimple-pretty-print.c (dump_gimple_stmt): Likewise. + (dump_gimple_cdt): Remove. + * gimple.c (gss_for_code): Do not handle GIMPLE_CHANGE_DYNAMIC_TYPE. + (gimple_size): Likewise. + (walk_gimple_op): Likewise. + (is_gimple_stmt): Likewise. + (walk_stmt_load_store_addr_ops): Likewise. + (gimple_build_cdt): Remove. + * gimple.def (GIMPLE_CHANGE_DYNAMIC_TYPE): Remove. + * gimple.h (gimple_cdt_new_type): Remove. + (gimple_cdt_new_type_ptr): Likewise. + (gimple_cdt_set_new_type): Likewise. + (gimple_cdt_location): Likewise. + (gimple_cdt_location_ptr): Likewise. + (gimple_cdt_set_location): Likewise. + * gimplify.c (gimplify_expr): Do not handle CHANGE_DYNAMIC_TYPE_EXPR. + * tree-cfg.c (remove_useless_stmts_1): Do not handle + GIMPLE_CHANGE_DYNAMIC_TYPE. + (verify_types_in_gimple_stmt): Likewise. + * tree-inline.c (estimate_num_insns): Likewise. + (expand_call_inline): Do not copy DECL_NO_TBAA_P. + (copy_decl_to_var): Likewise. + (copy_result_decl_to_var): Likewise. + * tree-pretty-print.c (dump_generic_node): Do not handle + CHANGE_DYNAMIC_TYPE_EXPR. + * tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Likewise. + * tree-ssa-operands.c (get_expr_operands): Likewise. + * tree-ssa-structalias.c (struct variable_info): Remove + no_tbaa_pruning member. + (new_var_info): Do not set it based on DECL_NO_TBAA_P. + (unify_nodes): Do not copy it. + (find_func_aliases): Do not handle GIMPLE_CHANGE_DYNAMIC_TYPE. + (dump_solution_for_var): Do not dump no_tbaa_pruning state. + (set_uids_in_ptset): Do not check it. + (find_what_var_points_to): Likewise. + (compute_tbaa_pruning): Remove. + (compute_points_to_sets): Do not call it. + * tree.c (walk_tree_1): Do not handle CHANGE_DYNAMIC_TYPE_EXPR. + * tree.def (CHANGE_DYNAMIC_TYPE_EXPR): Remove. + * tree.h (CHANGE_DYNAMIC_TYPE_NEW_TYPE): Remove. + (CHANGE_DYNAMIC_TYPE_LOCATION): Likewise. + (DECL_NO_TBAA_P): Likewise. + (struct tree_decl_common): Move no_tbaa_flag to unused flags section. + * omp-low.c (copy_var_decl): Do not copy DECL_NO_TBAA_P. + (expand_omp_atomic_pipeline): Do not set it. + * print-tree.c (print_node): Do not dump it. + * tree-ssa-copyrename.c (copy_rename_partition_coalesce): Remove + redundant check. + 2009-05-22 Vladimir Makarov PR target/39856 diff --git a/gcc/alias.c b/gcc/alias.c index 18d5b747cb0..4d42778a644 100644 --- a/gcc/alias.c +++ b/gcc/alias.c @@ -2373,9 +2373,6 @@ write_dependence_p (const_rtx mem, const_rtx x, int writep) || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER) return 1; - if (DIFFERENT_ALIAS_SETS_P (x, mem)) - return 0; - /* A read from read-only memory can't conflict with read-write memory. */ if (!writep && MEM_READONLY_P (mem)) return 0; diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index ab9464fdcb5..65a13de8a3d 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -2100,7 +2100,7 @@ expand_gimple_basic_block (basic_block bb) return new_bb; } } - else if (gimple_code (stmt) != GIMPLE_CHANGE_DYNAMIC_TYPE) + else { def_operand_p def_p; tree stmt_tree; diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index c876a17c23b..aeab9a15803 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,9 @@ +2009-05-22 Richard Guenther + + PR middle-end/38964 + * init.c (avoid_placement_new_aliasing): Remove. + (build_new_1): Do not call it. + 2009-05-22 Mark Mitchell * decl2.c (decl_needed_p): Consider dllexport'd functions needed. diff --git a/gcc/cp/init.c b/gcc/cp/init.c index fd0d587b81f..25cfd52fcdf 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -1742,55 +1742,6 @@ build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts, return new_expr; } -/* Make sure that there are no aliasing issues with T, a placement new - expression applied to PLACEMENT, by recording the change in dynamic - type. If placement new is inlined, as it is with libstdc++, and if - the type of the placement new differs from the type of the - placement location itself, then alias analysis may think it is OK - to interchange writes to the location from before the placement new - and from after the placement new. We have to prevent type-based - alias analysis from applying. PLACEMENT may be NULL, which means - that we couldn't capture it in a temporary variable, in which case - we use a memory clobber. */ - -static tree -avoid_placement_new_aliasing (tree t, tree placement) -{ - tree type_change; - - if (processing_template_decl) - return t; - - /* If we are not using type based aliasing, we don't have to do - anything. */ - if (!flag_strict_aliasing) - return t; - - /* If we have a pointer and a location, record the change in dynamic - type. Otherwise we need a general memory clobber. */ - if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE - && placement != NULL_TREE - && TREE_CODE (TREE_TYPE (placement)) == POINTER_TYPE) - type_change = build_stmt (CHANGE_DYNAMIC_TYPE_EXPR, - TREE_TYPE (t), - placement); - else - { - /* Build a memory clobber. */ - type_change = build_stmt (ASM_EXPR, - build_string (0, ""), - NULL_TREE, - NULL_TREE, - tree_cons (NULL_TREE, - build_string (6, "memory"), - NULL_TREE)); - - ASM_VOLATILE_P (type_change) = 1; - } - - return build2 (COMPOUND_EXPR, TREE_TYPE (t), type_change, t); -} - /* Generate code for a new-expression, including calling the "operator new" function, initializing the object, and, if an exception occurs during construction, cleaning up. The arguments are as for @@ -1826,7 +1777,6 @@ build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts, beginning of the storage allocated for an array-new expression in order to store the number of elements. */ tree cookie_size = NULL_TREE; - bool have_placement; tree placement_first; tree placement_expr = NULL_TREE; /* True if the function we are calling is a placement allocation @@ -1894,7 +1844,6 @@ build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts, /* If PLACEMENT is a single simple pointer type not passed by reference, prepare to capture it in a temporary variable. Do this now, since PLACEMENT will change in the calls below. */ - have_placement = !VEC_empty (tree, *placement); placement_first = NULL_TREE; if (VEC_length (tree, *placement) == 1 && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0))) @@ -2026,12 +1975,7 @@ build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts, /* In the simple case, we can stop now. */ pointer_type = build_pointer_type (type); if (!cookie_size && !is_initialized) - { - rval = build_nop (pointer_type, alloc_call); - if (have_placement) - rval = avoid_placement_new_aliasing (rval, placement_expr); - return rval; - } + return build_nop (pointer_type, alloc_call); /* Store the result of the allocation call in a variable so that we can use it more than once. */ @@ -2307,9 +2251,6 @@ build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts, /* A new-expression is never an lvalue. */ gcc_assert (!lvalue_p (rval)); - if (have_placement) - rval = avoid_placement_new_aliasing (rval, placement_expr); - return rval; } diff --git a/gcc/doc/c-tree.texi b/gcc/doc/c-tree.texi index 117b700ec08..35498583ccd 100644 --- a/gcc/doc/c-tree.texi +++ b/gcc/doc/c-tree.texi @@ -1995,7 +1995,6 @@ This macro returns the attributes on the type @var{type}. @tindex TARGET_EXPR @tindex AGGR_INIT_EXPR @tindex VA_ARG_EXPR -@tindex CHANGE_DYNAMIC_TYPE_EXPR @tindex OMP_PARALLEL @tindex OMP_FOR @tindex OMP_SECTIONS @@ -2708,13 +2707,6 @@ mechanism. It represents expressions like @code{va_arg (ap, type)}. Its @code{TREE_TYPE} yields the tree representation for @code{type} and its sole argument yields the representation for @code{ap}. -@item CHANGE_DYNAMIC_TYPE_EXPR -Indicates the special aliasing required by C++ placement new. It has -two operands: a type and a location. It means that the dynamic type -of the location is changing to be the specified type. The alias -analysis code takes this into account when doing type based alias -analysis. - @item OMP_PARALLEL Represents @code{#pragma omp parallel [clause1 @dots{} clauseN]}. It diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi index cc1e8903fdb..a78c52dcafc 100644 --- a/gcc/doc/gimple.texi +++ b/gcc/doc/gimple.texi @@ -332,14 +332,13 @@ union gimple_statement_d The following table briefly describes the GIMPLE instruction set. -@multitable {@code{GIMPLE_CHANGE_DYNAMIC_TYPE}} {High GIMPLE} {Low GIMPLE} +@multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE} @item Instruction @tab High GIMPLE @tab Low GIMPLE @item @code{GIMPLE_ASM} @tab x @tab x @item @code{GIMPLE_ASSIGN} @tab x @tab x @item @code{GIMPLE_BIND} @tab x @tab @item @code{GIMPLE_CALL} @tab x @tab x @item @code{GIMPLE_CATCH} @tab x @tab -@item @code{GIMPLE_CHANGE_DYNAMIC_TYPE} @tab x @tab x @item @code{GIMPLE_COND} @tab x @tab x @item @code{GIMPLE_EH_FILTER} @tab x @tab @item @code{GIMPLE_GOTO} @tab x @tab x @@ -885,7 +884,6 @@ Return a deep copy of statement @code{STMT}. * @code{GIMPLE_BIND}:: * @code{GIMPLE_CALL}:: * @code{GIMPLE_CATCH}:: -* @code{GIMPLE_CHANGE_DYNAMIC_TYPE}:: * @code{GIMPLE_COND}:: * @code{GIMPLE_EH_FILTER}:: * @code{GIMPLE_LABEL}:: @@ -1295,45 +1293,6 @@ Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}. Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}. @end deftypefn -@node @code{GIMPLE_CHANGE_DYNAMIC_TYPE} -@subsection @code{GIMPLE_CHANGE_DYNAMIC_TYPE} -@cindex @code{GIMPLE_CHANGE_DYNAMIC_TYPE} - -@deftypefn {GIMPLE function} gimple gimple_build_cdt (tree type, tree ptr) -Build a @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement. @code{TYPE} is the new -type for the location @code{PTR}. -@end deftypefn - -@deftypefn {GIMPLE function} tree gimple_cdt_new_type (gimple g) -Return the new type set by @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement -@code{G}. -@end deftypefn - -@deftypefn {GIMPLE function} tree *gimple_cdt_new_type_ptr (gimple g) -Return a pointer to the new type set by -@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. -@end deftypefn - -@deftypefn {GIMPLE function} void gimple_cdt_set_new_type (gimple g, tree new_type) -Set @code{NEW_TYPE} to be the type returned by -@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. -@end deftypefn - -@deftypefn {GIMPLE function} tree gimple_cdt_location (gimple g) -Return the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE} -statement @code{G}. -@end deftypefn - -@deftypefn {GIMPLE function} tree *gimple_cdt_location_ptr (gimple g) -Return a pointer to the location affected by -@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. -@end deftypefn - -@deftypefn {GIMPLE function} void gimple_cdt_set_location (gimple g, tree ptr) -Set @code{PTR} to be the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE} -statement @code{G}. -@end deftypefn - @node @code{GIMPLE_COND} @subsection @code{GIMPLE_COND} diff --git a/gcc/doc/tree-ssa.texi b/gcc/doc/tree-ssa.texi index 1442ce6f5b5..ebb85a05769 100644 --- a/gcc/doc/tree-ssa.texi +++ b/gcc/doc/tree-ssa.texi @@ -41,6 +41,7 @@ passes for GIMPLE@. * SSA Operands:: SSA names referenced by GIMPLE statements. * SSA:: Static Single Assignment representation. * Alias analysis:: Representing aliased loads and stores. +* Memory model:: Memory model used by the middle-end. @end menu @node Annotations @@ -892,3 +893,31 @@ providing its aliasing VDEF. The walk stops if asked to. @end enumerate + +@node Memory model +@section Memory model +@cindex memory model + +The memory model used by the middle-end models that of the C/C++ +languages. The middle-end has the notion of an effective type +of a memory region which is used for type-based alias analysis. + +The following is a refinement of ISO C99 6.5/6, clarifying the block copy case +to follow common sense and extending the concept of a dynamic effective +type to objects with a declared type as required for C++. + +@smallexample +The effective type of an object for an access to its stored value is +the declared type of the object or the effective type determined by +a previous store to it. If a value is stored into an object through +an lvalue having a type that is not a character type, then the +type of the lvalue becomes the effective type of the object for that +access and for subsequent accesses that do not modify the stored value. +If a value is copied into an object using @code{memcpy} or @code{memmove}, +or is copied as an array of character type, then the effective type +of the modified object for that access and for subsequent accesses that +do not modify the value is undetermined. For all other accesses to an +object, the effective type of the object is simply the type of the +lvalue used for the access. +@end smallexample + diff --git a/gcc/expr.c b/gcc/expr.c index 73fde710d80..c2524f2ead5 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -9298,13 +9298,6 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, /* Lowered by gimplify.c. */ gcc_unreachable (); - case CHANGE_DYNAMIC_TYPE_EXPR: - /* This is ignored at the RTL level. The tree level set - DECL_POINTER_ALIAS_SET of any variable to be 0, which is - overkill for the RTL layer but is all that we can - represent. */ - return const0_rtx; - case EXC_PTR_EXPR: return get_exception_pointer (); diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c index 02a1ce63549..42bf9b11ea9 100644 --- a/gcc/gimple-low.c +++ b/gcc/gimple-low.c @@ -368,7 +368,6 @@ lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data) case GIMPLE_PREDICT: case GIMPLE_LABEL: case GIMPLE_SWITCH: - case GIMPLE_CHANGE_DYNAMIC_TYPE: case GIMPLE_OMP_FOR: case GIMPLE_OMP_SECTIONS: case GIMPLE_OMP_SECTIONS_SWITCH: diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c index 163acf9c065..ec366f86f42 100644 --- a/gcc/gimple-pretty-print.c +++ b/gcc/gimple-pretty-print.c @@ -1324,27 +1324,6 @@ dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc, } } -/* Dump a GIMPLE_CHANGE_DYNAMIC_TYPE statement GS. BUFFER, SPC and - FLAGS are as in dump_gimple_stmt. */ - -static void -dump_gimple_cdt (pretty_printer *buffer, gimple gs, int spc, int flags) -{ - if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, - gimple_cdt_new_type (gs), gimple_cdt_location (gs)); - else - { - pp_string (buffer, "<<>>"); - } -} - /* Dump all the memory operands for statement GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */ @@ -1508,10 +1487,6 @@ dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags) dump_gimple_omp_critical (buffer, gs, spc, flags); break; - case GIMPLE_CHANGE_DYNAMIC_TYPE: - dump_gimple_cdt (buffer, gs, spc, flags); - break; - case GIMPLE_CATCH: dump_gimple_catch (buffer, gs, spc, flags); break; diff --git a/gcc/gimple.c b/gcc/gimple.c index d81c3f35551..703236691f7 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -102,7 +102,6 @@ gss_for_code (enum gimple_code code) case GIMPLE_COND: case GIMPLE_GOTO: case GIMPLE_LABEL: - case GIMPLE_CHANGE_DYNAMIC_TYPE: case GIMPLE_SWITCH: return GSS_WITH_OPS; case GIMPLE_ASM: return GSS_ASM; case GIMPLE_BIND: return GSS_BIND; @@ -190,8 +189,6 @@ gimple_size (enum gimple_code code) return sizeof (struct gimple_statement_omp_atomic_store); case GIMPLE_WITH_CLEANUP_EXPR: return sizeof (struct gimple_statement_wce); - case GIMPLE_CHANGE_DYNAMIC_TYPE: - return sizeof (struct gimple_statement_with_ops); case GIMPLE_PREDICT: return sizeof (struct gimple_statement_base); default: @@ -1042,20 +1039,6 @@ gimple_build_omp_single (gimple_seq body, tree clauses) } -/* Build a GIMPLE_CHANGE_DYNAMIC_TYPE statement. TYPE is the new type - for the location PTR. */ - -gimple -gimple_build_cdt (tree type, tree ptr) -{ - gimple p = gimple_build_with_ops (GIMPLE_CHANGE_DYNAMIC_TYPE, ERROR_MARK, 2); - gimple_cdt_set_new_type (p, type); - gimple_cdt_set_location (p, ptr); - - return p; -} - - /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */ gimple @@ -1460,16 +1443,6 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op, return ret; break; - case GIMPLE_CHANGE_DYNAMIC_TYPE: - ret = walk_tree (gimple_cdt_location_ptr (stmt), callback_op, wi, pset); - if (ret) - return ret; - - ret = walk_tree (gimple_cdt_new_type_ptr (stmt), callback_op, wi, pset); - if (ret) - return ret; - break; - case GIMPLE_ASM: ret = walk_gimple_asm (stmt, callback_op, wi); if (ret) @@ -2749,7 +2722,6 @@ is_gimple_stmt (tree t) case TRY_FINALLY_EXPR: case EH_FILTER_EXPR: case CATCH_EXPR: - case CHANGE_DYNAMIC_TYPE_EXPR: case ASM_EXPR: case RESX_EXPR: case STATEMENT_LIST: @@ -3254,8 +3226,7 @@ walk_stmt_load_store_addr_ops (gimple stmt, void *data, } else if (visit_addr && (is_gimple_assign (stmt) - || gimple_code (stmt) == GIMPLE_COND - || gimple_code (stmt) == GIMPLE_CHANGE_DYNAMIC_TYPE)) + || gimple_code (stmt) == GIMPLE_COND)) { for (i = 0; i < gimple_num_ops (stmt); ++i) if (gimple_op (stmt, i) diff --git a/gcc/gimple.def b/gcc/gimple.def index 26aa719f660..cee6753d200 100644 --- a/gcc/gimple.def +++ b/gcc/gimple.def @@ -78,17 +78,6 @@ DEFGSCODE(GIMPLE_LABEL, "gimple_label", struct gimple_statement_with_ops) They must be CASE_LABEL_EXPR nodes. */ DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", struct gimple_statement_with_ops) -/* GIMPLE_CHANGE_DYNAMIC_TYPE indicates a change in the dynamic type - of a memory location. This has no value and generates no - executable code. It is only used for type based alias analysis. - This is generated by C++ placement new and it's a direct - translation from CHANGE_DYNAMIC_TYPE_EXPR. The first operand - (gimple_cdt_new_type) is the new type. The second operand - (gimple_cdt_location) is the location (pointer) whose type is being - changed. */ -DEFGSCODE(GIMPLE_CHANGE_DYNAMIC_TYPE, "gimple_change_dynamic_type", - struct gimple_statement_with_ops) - /* IMPORTANT. Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN. diff --git a/gcc/gimple.h b/gcc/gimple.h index ffcf9aa95ae..b16fb545028 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -4106,69 +4106,6 @@ gimple_nop_p (const_gimple g) } -/* Return the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS. */ - -static inline tree -gimple_cdt_new_type (gimple gs) -{ - GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE); - return gimple_op (gs, 1); -} - -/* Return a pointer to the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE - statement GS. */ - -static inline tree * -gimple_cdt_new_type_ptr (gimple gs) -{ - GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE); - return gimple_op_ptr (gs, 1); -} - -/* Set NEW_TYPE to be the type returned by GIMPLE_CHANGE_DYNAMIC_TYPE - statement GS. */ - -static inline void -gimple_cdt_set_new_type (gimple gs, tree new_type) -{ - GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE); - gcc_assert (TREE_CODE_CLASS (TREE_CODE (new_type)) == tcc_type); - gimple_set_op (gs, 1, new_type); -} - - -/* Return the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS. */ - -static inline tree -gimple_cdt_location (gimple gs) -{ - GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE); - return gimple_op (gs, 0); -} - - -/* Return a pointer to the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE - statement GS. */ - -static inline tree * -gimple_cdt_location_ptr (gimple gs) -{ - GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE); - return gimple_op_ptr (gs, 0); -} - - -/* Set PTR to be the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE - statement GS. */ - -static inline void -gimple_cdt_set_location (gimple gs, tree ptr) -{ - GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE); - gimple_set_op (gs, 0, ptr); -} - - /* Return the predictor of GIMPLE_PREDICT statement GS. */ static inline enum br_predictor diff --git a/gcc/gimplify.c b/gcc/gimplify.c index d734a0fdf08..073fda0005b 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -6856,19 +6856,6 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, break; } - case CHANGE_DYNAMIC_TYPE_EXPR: - { - gimple cdt; - - ret = gimplify_expr (&CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p), - pre_p, post_p, is_gimple_reg, fb_lvalue); - cdt = gimple_build_cdt (CHANGE_DYNAMIC_TYPE_NEW_TYPE (*expr_p), - CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p)); - gimplify_seq_add_stmt (pre_p, cdt); - ret = GS_ALL_DONE; - } - break; - case OBJ_TYPE_REF: { enum gimplify_status r0, r1; diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 5a25e95c33a..1a4aea9b37b 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -812,7 +812,6 @@ copy_var_decl (tree var, tree name, tree type) TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (var); TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (var); DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (var); - DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (var); DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (var); DECL_IGNORED_P (copy) = DECL_IGNORED_P (var); DECL_CONTEXT (copy) = DECL_CONTEXT (var); @@ -5010,7 +5009,6 @@ expand_omp_atomic_pipeline (basic_block load_bb, basic_block store_bb, false, NULL_TREE, true, GSI_SAME_STMT); stmt = gimple_build_assign (iaddr, iaddr_val); gsi_insert_before (&si, stmt, GSI_SAME_STMT); - DECL_NO_TBAA_P (iaddr) = 1; DECL_POINTER_ALIAS_SET (iaddr) = 0; loadedi = create_tmp_var (itype, NULL); if (gimple_in_ssa_p (cfun)) diff --git a/gcc/print-tree.c b/gcc/print-tree.c index 0d352642157..969c6ea4ba7 100644 --- a/gcc/print-tree.c +++ b/gcc/print-tree.c @@ -425,8 +425,6 @@ print_node (FILE *file, const char *prefix, tree node, int indent) fputs (" virtual", file); if (DECL_PRESERVE_P (node)) fputs (" preserve", file); - if (DECL_NO_TBAA_P (node)) - fputs (" no-tbaa", file); if (DECL_LANG_FLAG_0 (node)) fputs (" decl_0", file); if (DECL_LANG_FLAG_1 (node)) diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 7d38e47fd68..ed045442dd3 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,10 @@ +2009-05-22 Richard Guenther + + PR middle-end/38964 + * g++.dg/warn/Wstrict-aliasing-float-ref-int-obj.C: XFAIL. + * gcc.dg/Wstrict-aliasing-converted-assigned.c: Likewise. + * gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c: Likewise. + 2009-05-22 Mark Mitchell * gcc.dg/dll-6.c: New test. diff --git a/gcc/testsuite/g++.dg/warn/Wstrict-aliasing-float-ref-int-obj.C b/gcc/testsuite/g++.dg/warn/Wstrict-aliasing-float-ref-int-obj.C index d88ed4314b3..8b82874f51d 100644 --- a/gcc/testsuite/g++.dg/warn/Wstrict-aliasing-float-ref-int-obj.C +++ b/gcc/testsuite/g++.dg/warn/Wstrict-aliasing-float-ref-int-obj.C @@ -4,8 +4,8 @@ int foo() { int x; - float& q = reinterpret_cast (x); /* { dg-message "initialized" } */ - q = 1.0; /* { dg-warning "does break strict-aliasing" } */ + float& q = reinterpret_cast (x); /* { dg-message "initialized" "" { xfail *-*-* } } */ + q = 1.0; /* { dg-warning "does break strict-aliasing" "" { xfail *-*-* } } */ return x; } diff --git a/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c b/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c index 1fef7947c9b..b77373d56bd 100644 --- a/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c +++ b/gcc/testsuite/gcc.dg/Wstrict-aliasing-converted-assigned.c @@ -9,5 +9,5 @@ int foo() return i; } -/* { dg-message "does break strict-aliasing" "" { target { *-*-* && lp64 } } 8 } */ -/* { dg-message "initialized" "" { target { *-*-* && lp64 } } 8 } */ +/* { dg-message "does break strict-aliasing" "" { target { *-*-* && lp64 } xfail *-*-* } 8 } */ +/* { dg-message "initialized" "" { target { *-*-* && lp64 } xfail *-*-* } 8 } */ diff --git a/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c b/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c index fccc178d224..b90fb76c28b 100644 --- a/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c +++ b/gcc/testsuite/gcc.dg/Wstrict-aliasing-float-ptr-int-obj.c @@ -11,12 +11,12 @@ int foo() { float* r; if (flag) { - q = (float*) &x; /* { dg-message "initialized" } */ + q = (float*) &x; /* { dg-message "initialized" "" { xfail *-*-* } } */ } else { - q = (float*) &y; /* { dg-message "initialized" } */ + q = (float*) &y; /* { dg-message "initialized" "" { xfail *-*-* } } */ } - *q = 1.0; /* { dg-warning "does break strict-aliasing" } */ + *q = 1.0; /* { dg-warning "does break strict-aliasing" "" { xfail *-*-* } } */ return x; diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 68d6f5b1c13..17cee626cb8 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -2045,18 +2045,6 @@ remove_useless_stmts_1 (gimple_stmt_iterator *gsi, struct rus_data *data) } break; - case GIMPLE_CHANGE_DYNAMIC_TYPE: - /* If we do not optimize remove GIMPLE_CHANGE_DYNAMIC_TYPE as - expansion is confused about them and we only remove them - during alias computation otherwise. */ - if (!optimize) - { - data->last_was_goto = false; - gsi_remove (gsi, false); - break; - } - /* Fallthru. */ - default: data->last_was_goto = false; gsi_next (gsi); @@ -4038,10 +4026,6 @@ verify_types_in_gimple_stmt (gimple stmt) case GIMPLE_ASM: return false; - case GIMPLE_CHANGE_DYNAMIC_TYPE: - return (!is_gimple_val (gimple_cdt_location (stmt)) - || !POINTER_TYPE_P (TREE_TYPE (gimple_cdt_location (stmt)))); - case GIMPLE_PHI: return verify_gimple_phi (stmt); diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index de2ad5f921b..583d2c0fd9e 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -1223,7 +1223,17 @@ dr_may_alias_p (const struct data_reference *a, const struct data_reference *b) return false; /* Query the alias oracle. */ - if (!refs_may_alias_p (DR_REF (a), DR_REF (b))) + if (!DR_IS_READ (a) && !DR_IS_READ (b)) + { + if (!refs_output_dependent_p (DR_REF (a), DR_REF (b))) + return false; + } + else if (DR_IS_READ (a) && !DR_IS_READ (b)) + { + if (!refs_anti_dependent_p (DR_REF (a), DR_REF (b))) + return false; + } + else if (!refs_may_alias_p (DR_REF (a), DR_REF (b))) return false; if (!addr_a || !addr_b) diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 78cb716d7ad..1b53288bca3 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -3072,7 +3072,6 @@ estimate_num_insns (gimple stmt, eni_weights *weights) case GIMPLE_NOP: case GIMPLE_PHI: case GIMPLE_RETURN: - case GIMPLE_CHANGE_DYNAMIC_TYPE: case GIMPLE_PREDICT: return 0; @@ -3429,13 +3428,6 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) /* Declare the return variable for the function. */ retvar = declare_return_variable (id, return_slot, modify_dest, &use_retvar); - if (DECL_IS_OPERATOR_NEW (fn)) - { - gcc_assert (TREE_CODE (retvar) == VAR_DECL - && POINTER_TYPE_P (TREE_TYPE (retvar))); - DECL_NO_TBAA_P (retvar) = 1; - } - /* Add local vars in this inlined callee to caller. */ t_step = id->src_cfun->local_decls; for (; t_step; t_step = TREE_CHAIN (t_step)) @@ -4192,7 +4184,6 @@ copy_decl_to_var (tree decl, copy_body_data *id) TREE_READONLY (copy) = TREE_READONLY (decl); TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); - DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl); return copy_decl_for_dup_finish (id, decl, copy); } @@ -4219,7 +4210,6 @@ copy_result_decl_to_var (tree decl, copy_body_data *id) { TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); - DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl); } return copy_decl_for_dup_finish (id, decl, copy); diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index d9d31eee79b..af734c118ab 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -1544,17 +1544,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, is_expr = false; break; - case CHANGE_DYNAMIC_TYPE_EXPR: - pp_string (buffer, "<<>>"); - is_expr = false; - break; - case LABEL_EXPR: op0 = TREE_OPERAND (node, 0); /* If this is for break or continue, don't bother printing it. */ diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c index 8982280fb2c..ef360ea87d5 100644 --- a/gcc/tree-ssa-alias.c +++ b/gcc/tree-ssa-alias.c @@ -155,10 +155,13 @@ ptr_deref_may_alias_global_p (tree ptr) if (!pi) return true; + /* ??? This does not use TBAA to prune globals ptr may not access. */ return pt_solution_includes_global (&pi->pt); } -/* Return true if dereferencing PTR may alias DECL. */ +/* Return true if dereferencing PTR may alias DECL. + The caller is responsible for applying TBAA to see if PTR + may access DECL at all. */ static bool ptr_deref_may_alias_decl_p (tree ptr, tree decl) @@ -190,7 +193,9 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl) return pt_solution_includes (&pi->pt, decl); } -/* Return true if dereferenced PTR1 and PTR2 may alias. */ +/* Return true if dereferenced PTR1 and PTR2 may alias. + The caller is responsible for applying TBAA to see if accesses + through PTR1 and PTR2 may conflict at all. */ static bool ptr_derefs_may_alias_p (tree ptr1, tree ptr2) @@ -222,6 +227,8 @@ ptr_derefs_may_alias_p (tree ptr1, tree ptr2) if (!pi1 || !pi2) return true; + /* ??? This does not use TBAA to prune decls from the intersection + that not both pointers may access. */ return pt_solutions_intersect (&pi1->pt, &pi2->pt); } @@ -653,13 +660,14 @@ indirect_refs_may_alias_p (tree ref1, tree ptr1, /* Return true, if the two memory references REF1 and REF2 may alias. */ static bool -refs_may_alias_p_1 (tree ref1, tree ref2) +refs_may_alias_p_1 (tree ref1, tree ref2, bool tbaa_p) { tree base1, base2; HOST_WIDE_INT offset1 = 0, offset2 = 0; HOST_WIDE_INT size1 = -1, size2 = -1; HOST_WIDE_INT max_size1 = -1, max_size2 = -1; bool var1_p, var2_p, ind1_p, ind2_p; + alias_set_type set; gcc_assert ((SSA_VAR_P (ref1) || handled_component_p (ref1) @@ -694,7 +702,8 @@ refs_may_alias_p_1 (tree ref1, tree ref2) base2, offset2, max_size2); /* First defer to TBAA if possible. */ - if (flag_strict_aliasing + if (tbaa_p + && flag_strict_aliasing && !alias_sets_conflict_p (get_alias_set (ref1), get_alias_set (ref2))) return false; @@ -708,21 +717,22 @@ refs_may_alias_p_1 (tree ref1, tree ref2) /* Dispatch to the pointer-vs-decl or pointer-vs-pointer disambiguators. */ ind1_p = INDIRECT_REF_P (base1); ind2_p = INDIRECT_REF_P (base2); + set = tbaa_p ? -1 : 0; if (var1_p && ind2_p) return indirect_ref_may_alias_decl_p (ref2, TREE_OPERAND (base2, 0), - offset2, max_size2, -1, + offset2, max_size2, set, ref1, base1, - offset1, max_size1, -1); + offset1, max_size1, set); else if (ind1_p && var2_p) return indirect_ref_may_alias_decl_p (ref1, TREE_OPERAND (base1, 0), - offset1, max_size1, -1, + offset1, max_size1, set, ref2, base2, - offset2, max_size2, -1); + offset2, max_size2, set); else if (ind1_p && ind2_p) return indirect_refs_may_alias_p (ref1, TREE_OPERAND (base1, 0), - offset1, max_size1, -1, + offset1, max_size1, set, ref2, TREE_OPERAND (base2, 0), - offset2, max_size2, -1); + offset2, max_size2, set); gcc_unreachable (); } @@ -730,7 +740,7 @@ refs_may_alias_p_1 (tree ref1, tree ref2) bool refs_may_alias_p (tree ref1, tree ref2) { - bool res = refs_may_alias_p_1 (ref1, ref2); + bool res = refs_may_alias_p_1 (ref1, ref2, true); if (res) ++alias_stats.refs_may_alias_p_may_alias; else @@ -738,6 +748,23 @@ refs_may_alias_p (tree ref1, tree ref2) return res; } +/* Returns true if there is a anti-dependence for the STORE that + executes after the LOAD. */ + +bool +refs_anti_dependent_p (tree load, tree store) +{ + return refs_may_alias_p_1 (load, store, false); +} + +/* Returns true if there is a output dependence for the stores + STORE1 and STORE2. */ + +bool +refs_output_dependent_p (tree store1, tree store2) +{ + return refs_may_alias_p_1 (store1, store2, false); +} /* If the call CALL may use the memory reference REF return true, otherwise return false. */ diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h index 5f951ae1625..a7ffcaa683c 100644 --- a/gcc/tree-ssa-alias.h +++ b/gcc/tree-ssa-alias.h @@ -78,6 +78,8 @@ struct GTY(()) pt_solution extern enum escape_type is_escape_site (gimple); extern bool ptr_deref_may_alias_global_p (tree); extern bool refs_may_alias_p (tree, tree); +extern bool refs_anti_dependent_p (tree, tree); +extern bool refs_output_dependent_p (tree, tree); extern bool ref_maybe_used_by_stmt_p (gimple, tree); extern bool stmt_may_clobber_ref_p (gimple, tree); extern void *walk_non_aliased_vuses (tree, tree, diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c index 0ac02bab04c..ed221c2f3e0 100644 --- a/gcc/tree-ssa-copyrename.c +++ b/gcc/tree-ssa-copyrename.c @@ -233,20 +233,6 @@ copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug) return false; } - /* Don't coalesce if the aliasing sets of the types are different. */ - if (POINTER_TYPE_P (TREE_TYPE (root1)) - && POINTER_TYPE_P (TREE_TYPE (root2)) - && ((get_alias_set (TREE_TYPE (TREE_TYPE (root1))) - != get_alias_set (TREE_TYPE (TREE_TYPE (root2)))) - || (DECL_P (root1) && DECL_P (root2) - && DECL_NO_TBAA_P (root1) != DECL_NO_TBAA_P (root2)))) - { - if (debug) - fprintf (debug, " : 2 different aliasing sets. No coalesce.\n"); - return false; - } - - /* Merge the two partitions. */ p3 = partition_union (map->var_partition, p1, p2); diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c index 0c205710425..38f313daa7d 100644 --- a/gcc/tree-ssa-dce.c +++ b/gcc/tree-ssa-dce.c @@ -295,7 +295,6 @@ mark_stmt_if_obviously_necessary (gimple stmt, bool aggressive) case GIMPLE_ASM: case GIMPLE_RESX: case GIMPLE_RETURN: - case GIMPLE_CHANGE_DYNAMIC_TYPE: mark_stmt_necessary (stmt, true); return; diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index 7d588f8eb96..0f8912421a1 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -1009,9 +1009,6 @@ get_expr_operands (gimple stmt, tree *expr_p, int flags) return; } - case CHANGE_DYNAMIC_TYPE_EXPR: - gcc_unreachable (); - case FUNCTION_DECL: case LABEL_DECL: case CONST_DECL: diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index a27afbf3c88..aa944364e48 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -226,10 +226,6 @@ struct variable_info /* True if this is a heap variable. */ unsigned int is_heap_var:1; - /* True if we may not use TBAA to prune references to this - variable. This is used for C++ placement new. */ - unsigned int no_tbaa_pruning : 1; - /* True if this field may contain pointers. */ unsigned int may_have_pointers : 1; @@ -360,7 +356,6 @@ static varinfo_t new_var_info (tree t, unsigned int id, const char *name) { varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool); - tree var; ret->id = id; ret->name = name; @@ -371,12 +366,6 @@ new_var_info (tree t, unsigned int id, const char *name) ret->is_unknown_size_var = false; ret->is_full_var = false; ret->may_have_pointers = true; - var = t; - if (TREE_CODE (var) == SSA_NAME) - var = SSA_NAME_VAR (var); - ret->no_tbaa_pruning = (DECL_P (var) - && POINTER_TYPE_P (TREE_TYPE (var)) - && DECL_NO_TBAA_P (var)); ret->solution = BITMAP_ALLOC (&pta_obstack); ret->oldsolution = BITMAP_ALLOC (&oldpta_obstack); ret->next = NULL; @@ -1425,9 +1414,6 @@ unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from, merge_graph_nodes (graph, to, from); merge_node_constraints (graph, to, from); - if (get_varinfo (from)->no_tbaa_pruning) - get_varinfo (to)->no_tbaa_pruning = true; - /* Mark TO as changed if FROM was changed. If TO was already marked as changed, decrease the changed count. */ @@ -3725,14 +3711,6 @@ find_func_aliases (gimple origt) } } } - else if (gimple_code (t) == GIMPLE_CHANGE_DYNAMIC_TYPE) - { - unsigned int j; - - get_constraint_for (gimple_cdt_location (t), &lhsc); - for (j = 0; VEC_iterate (ce_s, lhsc, j, c); ++j) - get_varinfo (c->var)->no_tbaa_pruning = true; - } stmt_escape_type = is_escape_site (t); if (stmt_escape_type == ESCAPE_STORED_IN_GLOBAL) @@ -4444,10 +4422,7 @@ dump_solution_for_var (FILE *file, unsigned int var) { fprintf (file, "%s ", get_varinfo (i)->name); } - fprintf (file, "}"); - if (vi->no_tbaa_pruning) - fprintf (file, " no-tbaa-pruning"); - fprintf (file, "\n"); + fprintf (file, "}\n"); } } @@ -4628,19 +4603,13 @@ shared_bitmap_add (bitmap pt_vars) } -/* Set bits in INTO corresponding to the variable uids in solution set FROM. - If MEM_ALIAS_SET is not zero, we also use type based alias analysis to - prune the points-to sets with this alias-set. - Returns the number of pruned variables and updates the vars_contains_global - member of *PT . */ +/* Set bits in INTO corresponding to the variable uids in solution set FROM. */ -static unsigned -set_uids_in_ptset (bitmap into, bitmap from, - alias_set_type mem_alias_set, struct pt_solution *pt) +static void +set_uids_in_ptset (bitmap into, bitmap from, struct pt_solution *pt) { unsigned int i; bitmap_iterator bi; - unsigned pruned = 0; EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi) { @@ -4655,22 +4624,6 @@ set_uids_in_ptset (bitmap into, bitmap from, || TREE_CODE (vi->decl) == PARM_DECL || TREE_CODE (vi->decl) == RESULT_DECL) { - /* Don't type prune artificial vars or points-to sets - for pointers that have not been dereferenced or with - type-based pruning disabled. */ - if (!vi->is_artificial_var - && !vi->no_tbaa_pruning - && mem_alias_set != 0) - { - alias_set_type var_alias_set = get_alias_set (vi->decl); - if (mem_alias_set != var_alias_set - && !alias_set_subset_of (mem_alias_set, var_alias_set)) - { - ++pruned; - continue; - } - } - /* Add the decl to the points-to set. Note that the points-to set contains global variables. */ bitmap_set_bit (into, DECL_UID (vi->decl)); @@ -4678,113 +4631,21 @@ set_uids_in_ptset (bitmap into, bitmap from, pt->vars_contains_global = true; } } - - return pruned; } static bool have_alias_info = false; -/* Emit a note for the pointer initialization point DEF. */ +/* Compute the points-to solution *PT for the variable VI. */ static void -emit_pointer_definition (tree ptr, bitmap visited) +find_what_var_points_to (varinfo_t vi, struct pt_solution *pt) { - gimple def = SSA_NAME_DEF_STMT (ptr); - if (gimple_code (def) == GIMPLE_PHI) - { - use_operand_p argp; - ssa_op_iter oi; - - FOR_EACH_PHI_ARG (argp, def, oi, SSA_OP_USE) - { - tree arg = USE_FROM_PTR (argp); - if (TREE_CODE (arg) == SSA_NAME) - { - if (bitmap_set_bit (visited, SSA_NAME_VERSION (arg))) - emit_pointer_definition (arg, visited); - } - else - inform (0, "initialized from %qE", arg); - } - } - else if (!gimple_nop_p (def)) - inform (gimple_location (def), "initialized from here"); -} - -/* Emit a strict aliasing warning for dereferencing the pointer PTR. */ - -static void -emit_alias_warning (tree ptr) -{ - gimple use; - imm_use_iterator ui; - bool warned = false; - - FOR_EACH_IMM_USE_STMT (use, ui, ptr) - { - tree deref = NULL_TREE; - - if (gimple_has_lhs (use)) - { - tree lhs = get_base_address (gimple_get_lhs (use)); - if (lhs - && INDIRECT_REF_P (lhs) - && TREE_OPERAND (lhs, 0) == ptr) - deref = lhs; - } - if (gimple_assign_single_p (use)) - { - tree rhs = get_base_address (gimple_assign_rhs1 (use)); - if (rhs - && INDIRECT_REF_P (rhs) - && TREE_OPERAND (rhs, 0) == ptr) - deref = rhs; - } - else if (is_gimple_call (use)) - { - unsigned i; - for (i = 0; i < gimple_call_num_args (use); ++i) - { - tree op = get_base_address (gimple_call_arg (use, i)); - if (op - && INDIRECT_REF_P (op) - && TREE_OPERAND (op, 0) == ptr) - deref = op; - } - } - if (deref - && !TREE_NO_WARNING (deref)) - { - TREE_NO_WARNING (deref) = 1; - warned |= warning_at (gimple_location (use), OPT_Wstrict_aliasing, - "dereferencing pointer %qD does break " - "strict-aliasing rules", SSA_NAME_VAR (ptr)); - } - } - if (warned) - { - bitmap visited = BITMAP_ALLOC (NULL); - emit_pointer_definition (ptr, visited); - BITMAP_FREE (visited); - } -} - -/* Compute the points-to solution *PT for the variable VI. - Prunes the points-to set based on TBAA rules if DO_TBAA_PRUNING - is true. Returns the number of TBAA pruned variables from the - points-to set. */ - -static unsigned int -find_what_var_points_to (varinfo_t vi, struct pt_solution *pt, - bool do_tbaa_pruning) -{ - unsigned int i, pruned; + unsigned int i; bitmap_iterator bi; bitmap finished_solution; bitmap result; tree ptr = vi->decl; - alias_set_type mem_alias_set; memset (pt, 0, sizeof (struct pt_solution)); @@ -4821,7 +4682,7 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt, /* Instead of doing extra work, simply do not create elaborate points-to information for pt_anything pointers. */ if (pt->anything) - return 0; + return; /* Share the final set of variables when possible. */ finished_solution = BITMAP_GGC_ALLOC (); @@ -4830,15 +4691,7 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt, if (TREE_CODE (ptr) == SSA_NAME) ptr = SSA_NAME_VAR (ptr); - /* If the pointer decl is marked that no TBAA is to be applied, - do not do tbaa pruning. */ - if (!do_tbaa_pruning - || DECL_NO_TBAA_P (ptr)) - mem_alias_set = 0; - else - mem_alias_set = get_deref_alias_set (ptr); - pruned = set_uids_in_ptset (finished_solution, vi->solution, - mem_alias_set, pt); + set_uids_in_ptset (finished_solution, vi->solution, pt); result = shared_bitmap_lookup (finished_solution); if (!result) { @@ -4850,18 +4703,14 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt, pt->vars = result; bitmap_clear (finished_solution); } - - return pruned; } -/* Given a pointer variable P, fill in its points-to set. Apply - type-based pruning if IS_DEREFERENCED is true. */ +/* Given a pointer variable P, fill in its points-to set. */ static void -find_what_p_points_to (tree p, bool is_dereferenced) +find_what_p_points_to (tree p) { struct ptr_info_def *pi; - unsigned int pruned; tree lookup_p = p; varinfo_t vi; @@ -4877,23 +4726,7 @@ find_what_p_points_to (tree p, bool is_dereferenced) return; pi = get_ptr_info (p); - pruned = find_what_var_points_to (vi, &pi->pt, is_dereferenced); - - if (!(pi->pt.anything || pi->pt.nonlocal || pi->pt.escaped) - && bitmap_empty_p (pi->pt.vars) - && pruned > 0 - && is_dereferenced - && warn_strict_aliasing > 0 - && !SSA_NAME_IS_DEFAULT_DEF (p)) - { - if (dump_file && dump_flags & TDF_DETAILS) - { - fprintf (dump_file, "alias warning for "); - print_generic_expr (dump_file, p, 0); - fprintf (dump_file, "\n"); - } - emit_alias_warning (p); - } + find_what_var_points_to (vi, &pi->pt); } @@ -5372,139 +5205,6 @@ remove_preds_and_fake_succs (constraint_graph_t graph) bitmap_obstack_release (&predbitmap_obstack); } -/* Compute the set of variables we can't TBAA prune. */ - -static void -compute_tbaa_pruning (void) -{ - unsigned int size = VEC_length (varinfo_t, varmap); - unsigned int i; - bool any; - - changed_count = 0; - changed = sbitmap_alloc (size); - sbitmap_zero (changed); - - /* Mark all initial no_tbaa_pruning nodes as changed. */ - any = false; - for (i = 0; i < size; ++i) - { - varinfo_t ivi = get_varinfo (i); - - if (find (i) == i && ivi->no_tbaa_pruning) - { - any = true; - if ((graph->succs[i] && !bitmap_empty_p (graph->succs[i])) - || VEC_length (constraint_t, graph->complex[i]) > 0) - { - SET_BIT (changed, i); - ++changed_count; - } - } - } - - while (changed_count > 0) - { - struct topo_info *ti = init_topo_info (); - ++stats.iterations; - - compute_topo_order (graph, ti); - - while (VEC_length (unsigned, ti->topo_order) != 0) - { - bitmap_iterator bi; - - i = VEC_pop (unsigned, ti->topo_order); - - /* If this variable is not a representative, skip it. */ - if (find (i) != i) - continue; - - /* If the node has changed, we need to process the complex - constraints and outgoing edges again. */ - if (TEST_BIT (changed, i)) - { - unsigned int j; - constraint_t c; - VEC(constraint_t,heap) *complex = graph->complex[i]; - - RESET_BIT (changed, i); - --changed_count; - - /* Process the complex copy constraints. */ - for (j = 0; VEC_iterate (constraint_t, complex, j, c); ++j) - { - if (c->lhs.type == SCALAR && c->rhs.type == SCALAR) - { - varinfo_t lhsvi = get_varinfo (find (c->lhs.var)); - - if (!lhsvi->no_tbaa_pruning) - { - lhsvi->no_tbaa_pruning = true; - if (!TEST_BIT (changed, lhsvi->id)) - { - SET_BIT (changed, lhsvi->id); - ++changed_count; - } - } - } - } - - /* Propagate to all successors. */ - EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i], 0, j, bi) - { - unsigned int to = find (j); - varinfo_t tovi = get_varinfo (to); - - /* Don't propagate to ourselves. */ - if (to == i) - continue; - - if (!tovi->no_tbaa_pruning) - { - tovi->no_tbaa_pruning = true; - if (!TEST_BIT (changed, to)) - { - SET_BIT (changed, to); - ++changed_count; - } - } - } - } - } - - free_topo_info (ti); - } - - sbitmap_free (changed); - - if (any) - { - for (i = 0; i < size; ++i) - { - varinfo_t ivi = get_varinfo (i); - varinfo_t ivip = get_varinfo (find (i)); - - if (ivip->no_tbaa_pruning) - { - tree var = ivi->decl; - - if (TREE_CODE (var) == SSA_NAME) - var = SSA_NAME_VAR (var); - - if (POINTER_TYPE_P (TREE_TYPE (var))) - { - DECL_NO_TBAA_P (var) = 1; - - /* Tell the RTL layer that this pointer can alias - anything. */ - DECL_POINTER_ALIAS_SET (var) = 0; - } - } - } - } -} - /* Initialize the heapvar for statement mapping. */ static void @@ -5534,7 +5234,6 @@ compute_points_to_sets (void) struct scc_info *si; basic_block bb; unsigned i; - sbitmap dereferenced_ptrs; timevar_push (TV_TREE_PTA); @@ -5543,11 +5242,6 @@ compute_points_to_sets (void) intra_create_variable_infos (); - /* A bitmap of SSA_NAME pointers that are dereferenced. This is - used to track which points-to sets may be TBAA pruned. */ - dereferenced_ptrs = sbitmap_alloc (num_ssa_names); - sbitmap_zero (dereferenced_ptrs); - /* Now walk all statements and derive aliases. */ FOR_EACH_BB (bb) { @@ -5564,31 +5258,11 @@ compute_points_to_sets (void) for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { gimple stmt = gsi_stmt (gsi); - use_operand_p use_p; - ssa_op_iter iter; - - /* Mark dereferenced pointers. This is used by TBAA pruning - of the points-to sets and the alias warning machinery. */ - FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE) - { - unsigned num_uses, num_loads, num_stores; - tree op = USE_FROM_PTR (use_p); - - if (!POINTER_TYPE_P (TREE_TYPE (op))) - continue; - - /* Determine whether OP is a dereferenced pointer. */ - count_uses_and_derefs (op, stmt, - &num_uses, &num_loads, &num_stores); - if (num_loads + num_stores > 0) - SET_BIT (dereferenced_ptrs, SSA_NAME_VERSION (op)); - } find_func_aliases (stmt); } } - if (dump_file) { fprintf (dump_file, "Points-to analysis\n\nConstraints:\n\n"); @@ -5642,15 +5316,13 @@ compute_points_to_sets (void) solve_graph (graph); - compute_tbaa_pruning (); - if (dump_file) dump_sa_points_to_info (dump_file); /* Compute the points-to sets for ESCAPED and CALLUSED used for call-clobber analysis. */ - find_what_var_points_to (var_escaped, &cfun->gimple_df->escaped, false); - find_what_var_points_to (var_callused, &cfun->gimple_df->callused, false); + find_what_var_points_to (var_escaped, &cfun->gimple_df->escaped); + find_what_var_points_to (var_callused, &cfun->gimple_df->callused); /* Make sure the ESCAPED solution (which is used as placeholder in other solutions) does not reference itself. This simplifies @@ -5663,9 +5335,8 @@ compute_points_to_sets (void) tree ptr = ssa_name (i); if (ptr && POINTER_TYPE_P (TREE_TYPE (ptr))) - find_what_p_points_to (ptr, TEST_BIT (dereferenced_ptrs, i)); + find_what_p_points_to (ptr); } - sbitmap_free (dereferenced_ptrs); timevar_pop (TV_TREE_PTA); diff --git a/gcc/tree.c b/gcc/tree.c index ce339a58292..2231b448950 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -8961,10 +8961,6 @@ walk_tree_1 (tree *tp, walk_tree_fn func, void *data, WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len)); } - case CHANGE_DYNAMIC_TYPE_EXPR: - WALK_SUBTREE (CHANGE_DYNAMIC_TYPE_NEW_TYPE (*tp)); - WALK_SUBTREE_TAIL (CHANGE_DYNAMIC_TYPE_LOCATION (*tp)); - case DECL_EXPR: /* If this is a TYPE_DECL, walk into the fields of the type that it's defining. We only want to walk into these fields of a type in this diff --git a/gcc/tree.def b/gcc/tree.def index 41a9e908cab..b4828ad9478 100644 --- a/gcc/tree.def +++ b/gcc/tree.def @@ -913,15 +913,6 @@ DEFTREECODE (CATCH_EXPR, "catch_expr", tcc_statement, 2) expanding. */ DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", tcc_statement, 2) -/* Indicates a change in the dynamic type of a memory location. This - has no value and generates no executable code. It is only used for - type based alias analysis. This is generated by C++ placement new. - CHANGE_DYNAMIC_TYPE_NEW_TYPE, the first operand, is the new type. - CHANGE_DYNAMIC_TYPE_LOCATION, the second operand, is the location - whose type is being changed. */ -DEFTREECODE (CHANGE_DYNAMIC_TYPE_EXPR, "change_dynamic_type_expr", - tcc_statement, 2) - /* Node used for describing a property that is known at compile time. */ DEFTREECODE (SCEV_KNOWN, "scev_known", tcc_expression, 0) diff --git a/gcc/tree.h b/gcc/tree.h index cdabb3ece37..0adf75d9530 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1648,12 +1648,6 @@ extern void protected_set_expr_location (tree, location_t); #define EH_FILTER_MUST_NOT_THROW(NODE) \ (EH_FILTER_EXPR_CHECK (NODE)->base.static_flag) -/* CHANGE_DYNAMIC_TYPE_EXPR accessors. */ -#define CHANGE_DYNAMIC_TYPE_NEW_TYPE(NODE) \ - TREE_OPERAND (CHANGE_DYNAMIC_TYPE_EXPR_CHECK (NODE), 0) -#define CHANGE_DYNAMIC_TYPE_LOCATION(NODE) \ - TREE_OPERAND (CHANGE_DYNAMIC_TYPE_EXPR_CHECK (NODE), 1) - /* OBJ_TYPE_REF accessors. */ #define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0) #define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1) @@ -2605,11 +2599,6 @@ struct GTY(()) tree_decl_minimal { #define DECL_GIMPLE_REG_P(DECL) \ DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag -/* For a DECL with pointer type, this is set if Type Based Alias - Analysis should not be applied to this DECL. */ -#define DECL_NO_TBAA_P(DECL) \ - DECL_COMMON_CHECK (DECL)->decl_common.no_tbaa_flag - struct GTY(()) tree_decl_common { struct tree_decl_minimal common; tree size; @@ -2649,12 +2638,10 @@ struct GTY(()) tree_decl_common { /* Logically, these two would go in a theoretical base shared by var and parm decl. */ unsigned gimple_reg_flag : 1; - /* In a DECL with pointer type, set if no TBAA should be done. */ - unsigned no_tbaa_flag : 1; /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE. */ unsigned decl_by_reference_flag : 1; /* Padding so that 'off_align' can be on a 32-bit boundary. */ - unsigned decl_common_unused : 1; + unsigned decl_common_unused : 2; /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */ unsigned int off_align : 8; -- 2.11.0