OSDN Git Service

Merge gimple-tuples-branch into mainline.
authoraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Tue, 5 Dec 2006 17:26:05 +0000 (17:26 +0000)
committeraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Tue, 5 Dec 2006 17:26:05 +0000 (17:26 +0000)
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@119546 138bc75d-0d04-0410-961f-82ee72b054a4

114 files changed:
gcc/ChangeLog
gcc/ada/ada-tree.h
gcc/ada/trans.c
gcc/builtins.c
gcc/c-decl.c
gcc/c-parser.c
gcc/c-pretty-print.c
gcc/c-typeck.c
gcc/cgraphunit.c
gcc/config/alpha/alpha.c
gcc/config/frv/frv.c
gcc/config/i386/i386.c
gcc/config/ia64/ia64.c
gcc/config/mips/mips.c
gcc/config/pa/pa.c
gcc/config/rs6000/rs6000.c
gcc/config/s390/s390.c
gcc/config/sh/sh.c
gcc/config/sparc/sparc.c
gcc/config/spu/spu.c
gcc/config/stormy16/stormy16.c
gcc/config/xtensa/xtensa.c
gcc/cp/ChangeLog
gcc/cp/cp-gimplify.c
gcc/cp/cp-tree.h
gcc/dwarf2out.c
gcc/expr.c
gcc/fold-const.c
gcc/fortran/f95-lang.c
gcc/fortran/resolve.c
gcc/fortran/trans-array.c
gcc/fortran/trans-array.h
gcc/fortran/trans-openmp.c
gcc/fortran/trans.c
gcc/fortran/trans.h
gcc/function.c
gcc/function.h
gcc/gimple-low.c
gcc/gimplify.c
gcc/ipa-cp.c
gcc/ipa-prop.c
gcc/ipa-pure-const.c
gcc/ipa-reference.c
gcc/ipa-type-escape.c
gcc/java/java-gimplify.c
gcc/java/java-tree.h
gcc/lambda-code.c
gcc/langhooks.c
gcc/omp-low.c
gcc/predict.c
gcc/print-tree.c
gcc/stmt.c
gcc/tree-cfg.c
gcc/tree-complex.c
gcc/tree-data-ref.c
gcc/tree-dfa.c
gcc/tree-dump.c
gcc/tree-eh.c
gcc/tree-flow-inline.h
gcc/tree-flow.h
gcc/tree-gimple.c
gcc/tree-if-conv.c
gcc/tree-inline.c
gcc/tree-into-ssa.c
gcc/tree-mudflap.c
gcc/tree-nested.c
gcc/tree-nrv.c
gcc/tree-object-size.c
gcc/tree-optimize.c
gcc/tree-outof-ssa.c
gcc/tree-pretty-print.c
gcc/tree-profile.c
gcc/tree-scalar-evolution.c
gcc/tree-sra.c
gcc/tree-ssa-alias.c
gcc/tree-ssa-ccp.c
gcc/tree-ssa-copy.c
gcc/tree-ssa-copyrename.c
gcc/tree-ssa-dce.c
gcc/tree-ssa-dom.c
gcc/tree-ssa-dse.c
gcc/tree-ssa-forwprop.c
gcc/tree-ssa-live.c
gcc/tree-ssa-loop-im.c
gcc/tree-ssa-loop-ivcanon.c
gcc/tree-ssa-loop-ivopts.c
gcc/tree-ssa-loop-manip.c
gcc/tree-ssa-loop-niter.c
gcc/tree-ssa-loop-prefetch.c
gcc/tree-ssa-math-opts.c
gcc/tree-ssa-operands.c
gcc/tree-ssa-phiopt.c
gcc/tree-ssa-pre.c
gcc/tree-ssa-propagate.c
gcc/tree-ssa-reassoc.c
gcc/tree-ssa-sink.c
gcc/tree-ssa-structalias.c
gcc/tree-ssa-threadedge.c
gcc/tree-ssa.c
gcc/tree-ssanames.c
gcc/tree-stdarg.c
gcc/tree-tailcall.c
gcc/tree-vect-analyze.c
gcc/tree-vect-generic.c
gcc/tree-vect-patterns.c
gcc/tree-vect-transform.c
gcc/tree-vectorizer.c
gcc/tree-vn.c
gcc/tree-vrp.c
gcc/tree.c
gcc/tree.def
gcc/tree.h
gcc/treestruct.def
gcc/value-prof.c

index 935e4bf..5d432ce 100644 (file)
@@ -1,3 +1,737 @@
+2006-12-05  Aldy Hernandez  <aldyh@redhat.com>
+
+       Merge from gimple-tuples-branch.
+
+       2006-12-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * config/s390/s390.c (s390_va_start): Replace MODIFY_EXPR with
+        GIMPLE_MODIFY_STMT.
+        (s390_gimplify_va_arg): Same.
+        * config/sparc/sparc.c (sparc_gimplify_va_arg): Same.
+        * config/sh/sh.c (sh_va_start): Same.
+        (sh_gimplify_va_arg_expr): Same.
+        * config/xtensa/xtensa.c (xtensa_va_start): Same.
+        (xtensa_gimplify_va_arg_expr): Same.
+        * config/ia64/ia64.c (ia64_gimplify_va_arg): Same.
+        * config/pa/pa.c (hppa_gimplify_va_arg_expr): Same.
+        * config/mips/mips.c (mips_va_start): Same.
+        (mips_gimplify_va_arg_expr): Same.
+
+       2006-12-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * Merge from mainline at revision 119445.
+
+       2006-12-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * config/spu/spu.c (spu_va_start): Change MODIFY_EXPR to
+        GIMPLE_MODIFY_STMT.
+        (spu_gimplify_va_arg_expr): Same.
+
+       2006-12-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * config/stormy16/stormy16.c (xstormy16_expand_builtin_va_start): 
+        Change uses of MODIFY_EXPR to GIMPLE_MODIFY_STMT.
+        (xstormy16_expand_builtin_va_arg): Same.
+
+       2006-12-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * config/frv/frv.c (frv_expand_builtin_va_start): Change MODIFY_EXPR
+        to GIMPLE_MODIFY_STMT.
+
+       2006-12-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * config/alpha/alpha.c (va_list_skip_additions): Change all
+       occurrences of MODIFY_EXPR to GIMPLE_MODIFY_STMT.
+        (alpha_va_start): Same.
+        (alpha_gimplify_va_arg_1): Same.
+        (alpha_gimplify_va_arg): Same.
+
+       2006-12-01  Aldy Hernandez  <aldyh@redhat.com>
+
+       * gimplify.c (gimplify_modify_expr): Remove FIXME comment.
+
+       2006-12-01  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree-ssa-loop-im.c: Rename all PROTECTED_TREE_OPERAND to
+        GENERIC_TREE_OPERAND, and all PROTECTED_TREE_TYPE to
+        GENERIC_TREE_TYPE.
+        * tree-complex.c: Same.
+        * tree-pretty-print.c: Same.
+        * tree.c: Same.
+        * tree.h: Same.
+        * builtins.c: Same.
+        * fold-const.c: Same.
+        * tree-ssa-dom.c: Same.
+        * tree-ssa-propagate.c: Same.
+        * tree-ssa-alias.c: Same.
+        * gimple-low.c: Same.
+        * dwarf2out.c: Same.
+        * c-pretty-print.c: Same.
+        * gimplify.c: Same.
+        * tree-inline.c: Same.
+        * tree-outof-ssa.c: Same.
+        * tree-ssa-structalias.c: Same.
+        * tree-ssa-reassoc.c: Same.
+        * stmt.c: Same.
+
+       2006-11-16  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree.c (build2_stat): Fix comment.
+
+       2006-11-13  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree-ssa-propagate.c (get_rhs): Use GIMPLE_MODIFY_STMT and
+        TREE_OPERAND when appropriate.
+
+       2006-11-04  Aldy Hernandez  <aldyh@redhat.com>
+
+        * java/java-tree.h (lang_tree_node): Handle gimple tuples.
+        (EXPR_WFL_EMIT_LINE_NOTE): Look inside base.
+        (EXPR_WFL_LINECOL): Use EXPR_LOCUS macro instead of exp.locus.
+        * java/java-gimplify.c (java_gimplify_expr): Comment on why we do
+        not handle GIMPLE_MODIFY_STMT in the switch statement.
+        (java_gimplify_modify_expr): Call build2 with GIMPLE_MODIFY_STMT.
+        (java_gimplify_new_array_init): Same.
+
+       2006-11-03  Aldy Hernandez  <aldyh@redhat.com>
+
+        * gimplify.c (gimplify_omp_for): Allow gimple statements.
+        * tree-outof-ssa.c (check_replaceable): Use PROTECTED_TREE_OPERAND.
+        * fold-const.c (fold_binary): Allow gimple statements.
+        (fold): Same.
+        * fortran/trans-array.c (gfc_conv_descriptor_data_set_internal):
+        Rename from gfc_conv_descriptor_data_set.
+        Call gfc_add_modify instead of gfc_add_modify_expr.
+        * fortran/trans-array.h (gfc_conv_descriptor_data_set_internal):
+        Rename from gfc_conv_descriptor_data_set.
+        (gfc_conv_descriptor_data_set): New macro.
+        (gfc_conv_descriptor_data_set_tuples): New macros.
+        * fortran/trans-openmp.c (gfc_omp_clause_default_ctor): Call
+        gfc_conv_descriptor_data_set_tuples.
+        * fortran/trans.c (gfc_add_modify): Rename from gfc_add_modify_expr.
+        Generate GIMPLE_MODIFY_STMT when appropriate.
+        * fortran/trans.h (gfc_add_modify): Rename from gfc_add_modify_expr.
+        (gfc_add_modify_expr): New macro.
+        (gfc_add_modify_stmt): New macro.
+        * fortran/f95-lang.c (lang_tree_node): Handle gimple statements.
+
+       2006-11-02  Aldy Hernandez  <aldyh@redhat.com>
+
+       * ada/ada-tree.h (lang_tree_node): Handle gimple tuples.
+       * ada/trans.c (gnat_gimplify_expr): Replace MODIFY_EXPR with
+       GIMPLE_MODIFY_STMT.
+
+       2006-11-01  Aldy Hernandez  <aldyh@redhat.com>
+
+       * Merge from mainline at revision 118200.
+
+       2006-10-09  Aldy Hernandez  <aldyh@redhat.com>
+
+       * tree-inline.c (copy_bb): Check for GIMPLE_MODIFY_STMT, and adjust
+       accordingly.
+
+       2006-10-09  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree.h (TREE_CHAIN, TREE_TYPE): Add versions for non GCC or not
+       enable checking.
+        Also, add __extension__ to GCC versions.
+        * tree-mudflap.c (mf_xform_derefs_1): Add parentheses around TREE_TYPE.
+        * tree-inline.c (copy_tree_r): Initialize chain to assuage the warning
+       patrol.
+
+       2006-10-05  Aldy Hernandez  <aldyh@redhat.com>
+
+       * tree-complex.c (expand_complex_libcall): Adjust for
+       GIMPLE_MODIFY_STMT.
+       (expand_complex_comparison): Same.
+       * tree-pretty-print.c (dump_generic_node): Is_expr should include
+       GIMPLE_STMT_P statements.
+       * value-prof.c (tree_divmod_fixed_value_transform): Adjust for
+       GIMPLE_MODIFY_STMT.
+       (tree_mod_pow2_value_transform): Same.
+       (tree_mod_subtract_transform): Same.
+       * tree.c (build2_stat): Check for gimplified function in cfun.
+       * tree.h (DECL_GIMPLIFIED): Delete.
+       (struct tree_function_decl): Remove gimplified_flag.
+       * omp-low.c (lower_omp_for): Adjust for GIMPLE_MODIFY_STMT.
+       * cp/cp-gimplify.c (cp_gimplify_expr): Adjust for GIMPLE_MODIFY_STMT.
+       (cxx_omp_clause_apply_fn): Adjust for GIMPLE_MODIFY_STMT.
+       (cxx_omp_clause_copy_ctor): Same.
+       (cxx_omp_clause_assign_op): Same.
+       * c-pretty-print.c (pp_c_conditional_expression): Same.
+       (pp_c_expression): Same.
+       * langhooks.c (lhd_omp_predetermined_sharing): Same.
+       * function.h (struct function): Add gimplified field.
+       * tree-if-conv.c (add_to_dst_predicate_list): Adjust for
+       GIMPLE_MODIFY_STMT.
+       (find_phi_replacement_condition): Same.
+       * gimplify.c (gimplify_modify_expr_to_memcpy): Same.
+       (gimplify_modify_expr_to_memset): Same.
+       (gimplify_init_ctor_eval_range): Same.
+       (gimplify_modify_expr_complex_part): Same.
+       (tree_to_gimple_tuple): Same.
+       (gimplify_modify_expr): Same.
+       (gimple_push_cleanup): Same.
+       (gimplify_omp_for): Same.
+       (gimplify_omp_atomic_pipeline): Same.
+       (gimplify_omp_atomic_mutex): Same.
+       (gimplify_expr): Same.
+       (gimplify_one_sizepos): Same.
+       (gimplify_function_tree): Same.
+       * tree-vect-patterns.c (vect_recog_dot_prod_pattern): Same.
+       (vect_recog_widen_sum_pattern): Same.
+       * tree-vect-transform.c (get_initial_def_for_reduction): Same.
+       (vect_create_epilog_for_reduction): Same.
+       (vectorizable_reduction): Same.
+
+       2006-09-28  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree-ssa-math-opts.c (replace_reciprocal): Use GIMPLE_STMT_OPERAND.
+        * tree-if-conv.c (if_convertible_gimple_modify_stmt_p): Same.
+        (ifc_temp_var): Same.
+        * tree-vect-analyze.c (vect_determine_vectorization_factor): Check
+       for gimple statements.
+        (vect_analyze_operations): Same.
+        (exist_non_indexing_operands_for_use_p): Use GIMPLE_STMT_OPERAND.
+        * gimplify.c (gimplify_return_expr): Handle gimple statements.
+        * lambda-code.c (can_put_in_inner_loop): Same.
+        (can_put_after_inner_loop): Same.
+        * tree-vect-transform.c (vect_create_addr_base_for_vector_ref): Same.
+        (vect_create_data_ref_ptr): Same.
+        (vect_init_vector): Same.
+        (vect_get_vec_def_for_operand): Same.
+        (vect_create_epilog_for_reduction): Same.
+        (vectorizable_reduction): Same.
+        (vectorizable_assignment): Same.
+        (vectorizable_operation): Same.
+        (vectorizable_load): Same.
+        (vectorizable_condition): Same.
+        * config/rs6000/rs6000.c (rs6000_va_start): Do not create MODIFY_EXPRs.
+        (rs6000_gimplify_va_arg): Same.
+
+       2006-09-25  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree-vrp.c (simplify_div_or_mod_using_ranges): Use
+        GIMPLE_STMT_OPERAND.
+        (simplify_abs_using_ranges): Same.
+        * tree-complex.c (expand_complex_operations_1): Use
+        PROTECTED_TREE_OPERAND.
+        * tree-ssa-loop-niter.c (simplify_replace_tree): Check for gimple
+        stmt.
+        (get_val_for): Use GIMPLE_STMT_OPERAND.
+        * tree-tailcall.c (adjust_accumulator_values): Same.
+        (adjust_return_value): Same.
+        * tree.c (walk_tree): Use IS_GIMPLE_STMT_CODE_CLASS on default
+        case.  Remove special case for tcc_gimple_stmt.
+        * tree.h (CAN_HAVE_LOCATION_P): New.
+        * tree-ssa-loop-ivopts.c (expr_invariant_in_loop_p): Check for
+        GIMPLE_STMT_P.
+        * tree-stdarg.c (va_list_counter_bump): Use GIMPLE_STMT_OPERAND.
+        * tree-ssa-dom.c (propagate_rhs_into_lhs): Same.
+        * tree-nrv.c (execute_return_slot_opt): Same.
+        * tree-ssa-alias.c (count_uses_and_derefs): Check for GIMPLE_STMT_P.
+        * tree-vn.c (set_value_handle): Same.
+        (get_value_handle): Same.
+        * c-decl.c (add_stmt): Use CAN_HAVE_LOCATION_P.
+        * tree-vectorizer.c (find_loop_location): Same.
+        * c-typeck.c (c_process_expr_stmt): Same.
+        (c_finish_stmt_expr): Same.
+        * gimplify.c (should_carry_locus_p): Same.
+        (tree_to_gimple_tuple): Delete definition and use of unecessary
+        variable save_tree_block.
+        * tree-ssa-pre.c (phi_translate): Check for GIMPLE_STMT_P.
+        (create_expression_by_pieces): Use GIMPLE_STMT_OPERAND.
+        (realify_fake_stores): Same.
+        * tree-ssa-forwprop.c (forward_propagate_addr_into_variable_arr):
+        Use TREE_OPERAND.
+        * tree-inline.c (copy_body_r): Check for EXPR_P and GIMPLE_STMT_P.
+        (copy_tree_r): Check for IS_GIMPLE_STMT_CODE_CLASS.
+        * tree-cfg.c (move_stmt_r): Use EXPR_P.  Check for GIMPLE_STMT_P.
+        * c-parser.c (c_parser_typeof_specifier): Use CAN_HAVE_LOCATION_P.
+        (c_parser_statement_after_labels): Same.
+        (c_parser_paren_condition): Same.
+        (c_parser_for_statement): Same.
+        (c_parser_omp_for_loop): Same.
+        * tree-ssa-reassoc.c (linearize_expr): Use GIMPLE_STMT_OPERAND.
+        (linearize_expr_tree): Same.
+        * dwarf2out.c (reference_to_unused): Check for GIMPLE_STMT_P.
+        * function.c (instantiate_expr): Same.
+
+       2006-09-22  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree.c (expr_location): Use GIMPLE_STMT_LOCUS.
+        (set_expr_location): Same.
+        (expr_locus): Same.
+        (set_expr_locus): Same.
+        (expr_filename): Same.
+        (expr_lineno): Same.
+        (tree_block): Use GIMPLE_STMT_BLOCK.
+        (protected_tree_operand): Use GIMPLE_STMT_OPERAND.
+        * tree.h (struct gimple_stmt): Remove prev and next.
+        (GIMPLE_STMT_OPERAND_CHECK): New.
+        (TREE_TO_GIMPLE_STMT): Delete.
+        (GIMPLE_STMT_TO_TREE): Delete.
+        (GIMPLE_STMT_OPERAND): Use union, not cast.
+        (GIMPLE_STMT_LOCUS): New.
+        (GIMPLE_STMT_BLOCK): New.
+        * gimplify.c (tree_to_gimple_tuple): Use union.  Do not cast
+        to tree_base.
+        * tree-cfg.c (verify_gimple_tuples_1): Call gcc_unreachable.
+
+       2006-09-21  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree-into-ssa.c (REGISTER_DEFS_IN_STMT): Change common.base
+        to base.
+        * tree-tailcall.c (adjust_return_value): Same.
+        * tree.c (tree_code_size): Remove GIMPLE_STATEMENT_LIST case.
+        (copy_node_stat): Change common.base to base.
+        (tree_node_structure): Return TS_GIMPLE_STATEMENT for tcc_gimple_stmt.
+        Remove GIMPLE_STATEMENT_LIST case.
+        * tree.h (struct gimple_stmt): Make operands of type tree.
+        (TREE_CODE, TREE_SET_CODE, TREE_ADDRESSABLE, CALL_EXPR_TAILCALL,
+        CASE_LOW_SEEN, TREE_STATIC, CLEANUP_EH_ONLY, CASE_HIGH_SEEN,
+        TREE_NO_WARNING, TREE_CONSTANT_OVERFLOW, TREE_SYMBOL_REFERENCED,
+        TYPE_REF_CAN_ALIAS_ALL, TREE_OVERFLOW, TREE_PUBLIC,
+        TYPE_CACHED_VALUES_P, TREE_SIDE_EFFECTS, FORCED_LABEL,
+        TREE_THIS_VOLATILE, TREE_THIS_NOTRAP, TREE_READONLY,
+        TREE_CONSTANT, TYPE_SIZES_GIMPLIFIED, DECL_UNSIGNED,
+        BIT_FIELD_REF_UNSIGNED, TYPE_UNSIGNED, TREE_ASM_WRITTEN, TREE_USED,
+        TREE_NOTHROW, CALL_EXPR_RETURN_SLOT_OPT, DECL_BY_REFERENCE,
+        CALL_FROM_THUNK_P, TYPE_ALIGN_OK, TREE_PRIVATE, TREE_PROTECTED,
+        TREE_DEPRECATED, IDENTIFIER_TRANSPARENT_ALIAS, TREE_INVARIANT,
+        TREE_LANG_FLAG_*, SSA_NAME_OCCURS_IN_ABNORMAL_PHI,
+        SSA_NAME_IN_FREE_LIST, TYPE_VOLATILE, TYPE_READONLY, BINFO_VIRTUAL_P):
+        Change common.base to base.
+        (GIMPLE_STATEMENT_LIST*): Remove.
+        (union tree_node): Add base.  Remove gimple_statement_list.
+        Remove pointer from gstmt.
+        * tree-ssa-propagate.c (set_rhs): Change common.base to base.
+        * treestruct.def: Add TS_BASE.  Remove TS_GIMPLE_STATEMENT_LIST.
+        * tree-vn.c (vn_compute): Change common.base to base.
+        * tree-eh.c (verify_eh_throw_stmt_node): Same.
+        * tree-flow-inline.h (var_ann): Same.
+        (function_ann): Same.
+        (stmt_ann): Same.
+        (mark_non_addressable): Same.
+        * gimplify.c (tree_to_gimple_tuple): Same.
+        * tree.def (DEFTREECODE): Remove GIMPLE_STATEMENT_LIST.
+        * tree-dfa.c (create_var_ann): Change common.base to base.
+        (create_function_ann): Same.
+        (create_stmt_ann): Same.
+        (create_tree_ann): Same.
+        (collect_dfa_stats_r): Same.
+        * tree-ssa-pre.c (NECESSARY): Change common.base to base.
+        * tree-ssa-dce.c (NECESSARY): Same.
+        * tree-ssa.c (delete_tree_ssa): Same.
+        * tree-optimize.c (execute_free_cfg_annotations): Same.
+        * tree-flow.h: Same.
+
+       2006-09-19  Aldy Hernandez  <aldyh@redhat.com>
+
+        * tree.c (tree_code_size): Handle GIMPLE_STATEMENT_LIST.
+        (tree_node_structure): Handle GIMPLE_STATEMENT_LIST and
+       GIMPLE_MODIFY_STMT.
+        * tree.h (struct gimple_stmt): Add prev and next fields.
+       (GIMPLE_STMT_TO_TREE): Cast, do not call GIMPLE_STMT_CHECK.
+       (GIMPLE_STATEMENT_LIST_HEAD): New.
+       (GIMPLE_STATEMENT_LIST_TAIL): New.
+       (struct gimple_statement_list): New.
+       (union tree_node): Add gimple_stmt_list and gstmt.
+        * treestruct.def: Add TS_GIMPLE_STATEMENT_LIST, TS_GIMPLE_STATEMENT.
+        * tree.def: Add GIMPLE_STATEMENT_LIST.
+
+       2006-09-06  Aldy Hernandez  <aldyh@redhat.com>
+
+       * tree-dump.c (dequeue_and_dump): Handle GIMPLE_MODIFY_STMT.
+       * tree-vrp.c (build_assert_expr_for): Change uses of
+       MODIFY_EXPR to GIMPLE_MODIFY_STMT and adjust accordingly.
+       (find_assert_locations): Same.
+       (remove_range_assertions): Same.
+       (stmt_interesting_for_vrp): Same.
+       (vrp_visit_assignment): Same.
+       (vrp_visit_stmt): Same.
+       (simplify_cond_using_ranges): Same.
+       * tree-into-ssa.c (REGISTER_DEFS_IN_THIS_STMT): Adjust for new
+       tree structure.
+       * tree-ssa-loop-im.c (movement_possibility): Change uses of
+       MODIFY_EXPR to GIMPLE_MODIFY_STMT and adjust accordingly.
+       (stmt_cost): Same.
+       (determine_invariantness_stmt): Same.
+       (schedule_sm): Same.
+       (gather_mem_refs_stmt): Same.
+       * tree-complex.c (init_dont_simulate_again): Same.
+       (complex_visit_stmt): Same.
+       (set_component_ssa_name): Same.
+       (expand_complex_move): Same.
+       (expand_complex_div_wide): Same.
+       (expand_complex_comparison): Same.
+       (expand_complex_operations_1): Same.
+       * tree-ssa-loop-niter.c (expand_simple_operations): Same.
+       (chain_of_csts_start): Same.
+       (infer_loop_bounds_from_undefined): Same.
+       * tree-pretty-print.c (dump_generic_node): Same.
+       (op_prio): Same.
+       (op_symbol_1): Same.
+       * tree-ssa-loop-manip.c (create_iv): Same.
+       * value-prof.c (tree_divmod_fixed_value): Same.
+       (tree_divmod_fixed_value_transform): Same.
+       (tree_mod_pow2): Same.
+       (tree_mod_pow2_value_transform): Same.
+       (tree_mod_subtract): Same.
+       (tree_mod_subtract_transform): Same.
+       (tree_divmod_values_to_profile): Same.
+       * tree-tailcall.c (process_assignment): Same.
+       (find_tail_calls): Same.
+       (adjust_accumulator_values): Same.
+       (adjust_return_value): Same.
+       (eliminate_tail_call): Same.
+       * tree.c (tree_code_size): Handle tcc_gimple_stmt.
+       (make_node_stat): Same.
+       (copy_node_stat): Handle gimple tuples.
+       (expr_align): Handle GIMPLE_MODIFY_STMT.  Abort on MODIFY_EXPR.
+       (tree_node_structure): Handle tcc_gimple_stmt.
+       (build2_stat): Abort on MODIFY_EXPR after gimplification.  Handle
+       tcc_gimple_stmt.
+       (build2_gimple_stat): New.
+       (expr_location): New.
+       (set_expr_location): New.
+       (expr_has_location): New.
+       (expr_locus): New.
+       (set_expr_locus): New.
+       (expr_filename): New.
+       (expr_lineno): New.
+       (walk_tree): Handle tcc_gimple_stmt.
+       (tree_block): New.
+       (protected_tree_operand): New.
+       (protected_tree_type): New.
+       (tree_code_kind): Add gimple statements.
+       * tree.h (tree_code_class): Add tcc_gimple_stmt.
+       (IS_GIMPLE_STMT_CODE_CLASS): New.
+       (struct tree_base): New.
+       (struct tree_common): Shrink.
+       (struct gimple_stmt): New.
+       (struct gimple_expr): New.
+       (TREE_SET_CODE, TREE_ADDRESSABLE, CALL_EXPR_TAILCALL,
+       CASE_LOW_SEEN, TREE_STATIC, CLEANUP_EH_ONLY, CASE_HIGH_SEEN,
+       TREE_NO_WARNING, TREE_CONSTANT_OVERFLOW, TREE_SYMBOL_REFERENCED,
+       TYPE_REF_CAN_ALIAS_ALL, TREE_OVERFLOW, TREE_PUBLIC,
+       TYPE_CACHED_VALUES_P, SAVE_EXPR_RESOLVED_P, TREE_SIDE_EFFECTS,
+       FORCED_LABEL, TREE_THIS_VOLATILE, TREE_THIS_NOTRAP, TREE_READONLY,
+       TREE_CONSTANT, TYPE_SIZES_GIMPLIFIED, DECL_UNSIGNED,
+       BIT_FIELD_REF_UNSIGNED, TYPE_UNSIGNED, TREE_ASM_WRITTEN,
+       TREE_USED, TREE_NOTHROW, CALL_EXPR_RETURN_SLOT_OPT,
+       DECL_BY_REFERENCE, CALL_FROM_THUNK_P, TYPE_ALIGN_OK,
+       TREE_PRIVATE, TREE_PROTECTED, TREE_DEPRECATED,
+       IDENTIFIER_TRANSPARENT_ALIAS, TREE_INVARIANT,
+       TREE_LANG_FLAG_[0-6], SSA_NAME_CHECK, SSA_NAME_IN_FREE_LIST,
+       TYPE_VOLATILE, TYPE_READONLY, TREE_VISITED, BINFO_VIRTUAL_P):
+       Adjust for new `common' layout.
+       (struct tree_function_decl): Add gimplified_flag.
+       (DECL_GIMPLIFIED): NEW.
+       (EXPR_LOCATION, SET_EXPR_LOCUS, EXPR_FILENAME, EXPR_LOCUS,
+       SET_EXPR_LOCUS, SET_EXPR_LOCATION, EXPR_LINENO,
+       EXPR_HAS_LOCATION): Call corresponding function.
+       (GIMPLE_STMT_CHECK): New.
+       (TREE_OPERAND_CHECK, TREE_TYPE, TREE_CHAIN): Abort on gimple tuples.
+       (TREE_BLOCK): Call tree_block.
+       (GIMPLE_STMT_P): New.
+       (GIMPLE_TUPLE_P): New.
+       (TREE_TO_GIMPLE_STMT): New.
+       (GIMPLE_STMT_TO_TREE): New.
+       (GIMPLE_STMT_OPERAND): New.
+       (GIMPLE_TUPLE_HAS_LOCUS_P): New.
+       (PROTECTED_TREE_OPERAND): New.
+       (PROTECTED_TREE_TYPE): New.
+       (build2_gimple_stat): Protoize.
+       (build2_gimple): New.
+       (expr_location): Protoize.
+       (set_expr_location): Protoize.
+       (expr_has_location): Protoize.
+       (expr_locus): Protoize.
+       (set_expr_locus): Protoize.
+       (expr_filename): Protoize.
+       (expr_lineno): Protoize.
+       (tree_block): Protoize.
+       (protected_tree_operand): Protoize.
+       (protected_tree_type): Protoize.
+       (enum tree_node_kind): Add gimple_stmt_kind.
+       * c-decl.c (union lang_tree_node): Tuples do not have a
+       TREE_CHAIN.
+       * ipa-cp.c (constant_val_insert): Change uses of MODIFY_EXPR to
+       GIMPLE_MODIFY_STMT and adjust accordingly.
+       * tree-scalar-evolution.c (follow_ssa_edge): Same.
+       (interpret_condition_phi): Same.
+       (pointer_used_p): Same.
+       (analyze_scalar_evolution_1): Same.
+       (scev_const_prop): Same.
+       (interpret_rhs_modify_stmt): Rename from
+       interpret_rhs_modify_expr.
+       * builtins.c (std_expand_builtin_va_start): Change uses of
+       MODIFY_EXPR to GIMPLE_MODIFY_STMT and adjust accordingly.
+       (std_gimplify_va_arg_expr): Same.
+       (expand_builtin_va_copy): Same.
+       (integer_valued_real_p): Same.
+       * fold-const.c (maybe_lvalue_p): Same.
+       (fold_unary): Same.
+       (tree_expr_nonnegative_p): Same.
+       (tree_expr_nonzero_p): Same.
+       * omp-low.c (extract_omp_for_data): Same.
+       (lower_rec_input_clauses): Same.
+       (lower_reduction_clauses): Same.
+       (lower_copyprivate_clauses): Same.
+       (lower_send_clauses): Same.
+       (lower_send_shared_vars): Same.
+       (expand_parallel_call): Same.
+       (expand_omp_parallel): Same.
+       (expand_omp_for_generic): Same.
+       (expand_omp_for_static_nochunk): Same.
+       (expand_omp_for_static_chunk): Same.
+       (expand_omp_sections): Same.
+       (lower_omp_single_copy): Same.
+       (lower_omp_parallel): Same.
+       * tree-ssa-dse.c (memory_address_same): Same.
+       (dse_optimize_stmt): Same.
+       * ipa-reference.c (scan_for_static_refs): Same.
+       * tree-gimple.c (is_gimple_reg_rhs): Same.
+       (get_call_expr_in): Same.
+       (recalculate_side_effects): Same.
+       * cgraphunit.c (cgraph_create_edges): Same.
+       * tree-ssa-copyrename.c (rename_ssa_copies): Same.
+       * tree-ssa-ccp.c (get_default_value): Same.
+       (likely_value): Same.
+       (visit_assignment): Same.
+       (ccp_visit_stmt): Same.
+       (get_maxval_strlen): Same.
+       (ccp_fold_builtin): Same.
+       * tree-ssa-loop-ivopts.c (find_givs_in_stmt_scev): Same.
+       (find_givs_in_stmt): Same.
+       (find_interesting_uses_op): Same.
+       (find_interesting_uses_stmt): Same.
+       (rewrite_use_nonlinear_expr): Same.
+       * ipa-pure-const.c (scan_function): Same.
+       * tree-stdarg.c (va_list_counter_bump): Same.
+       (check_all_va_list_escapes): Same.
+       (execute_optimize_stdarg): Same.
+       * tree-ssa-math-opts.c (compute_merit): Same.
+       (insert_reciprocals): Same.
+       (execute_cse_reciprocals): Same.
+       * tree-ssa-dom.c (initialize_hash_element): Same.
+       (simple_iv_increment_p): Same.
+       (record_equivalences_from_stmt): Same.
+       (optimize_stmt): Same.
+       (remove_stmt_or_phi): Same.
+       (get_rhs_or_phi_arg): Same.
+       (get_lhs_or_phi_result): Same.
+       (propagate_rhs_into_lhs): Same.
+       * tree-nrv.c (tree_nrv): Same.
+       (execute_return_slot_opt): Same.
+       * tree-ssa-propagate.c (get_rhs): Same.
+       (set_rhs): Same.
+       (stmt_makes_single_load): Same.
+       (stmt_makes_single_store): Same.
+       (replace_vuses_in): Same.
+       (fold_predicate_in): Same.
+       (substitute_and_fold): Same.
+       * tree-ssa-alias.c (compute_call_clobbered): Same.
+       (recalculate_used_alone): Same.
+       (count_uses_and_derefs): Same.
+       (is_escape_site): Same.
+       (find_used_portions): Same.
+       * gimple-low.c (lower_stmt): Same.
+       (block_may_fallthru): Same.
+       (lower_return_expr): Same.
+       * tree-ssa-sink.c (is_hidden_global_store): Same.
+       (statement_sink_location): Same.
+       * dwarf2out.c (loc_descriptor_from_tree_1): Same.
+       * expr.c (safe_from_p): Same.
+       (expand_expr_real): Same.
+       (expand_expr_real_1): Same.
+       * tree-ssa-loop-ivcanon.c (empty_loop_p): Same.
+       * predict.c (expr_expected_value): Same.
+       (strip_builtin_expect): Same.
+       (apply_return_prediction): Same.
+       (tree_bb_level_predictions): Same.
+       (tree_estimate_probability): Same.
+       * tree-vn.c (vn_compute): Same.
+       * tree-eh.c (add_stmt_to_eh_region_fn): Same.
+       (remove_stmt_from_eh_region_fn): Same.
+       (do_return_redirection): Same.
+       (honor_protect_cleanup_actions): Same.
+       (lower_try_finally_switch): Same.
+       (lower_eh_constructs_1): Same.
+       (tree_could_throw_p): Same.
+       (verify_eh_throw_stmt_node): Same.
+       * function.c (gimplify_parameters): Same.
+       * tree-vectorizer.c (vect_is_simple_use): Same.
+       (vect_is_simple_reduction): Same.
+       * ipa-type-escape.c (scan_for_refs): Same.
+       * tree-if-conv.c (tree_if_conversion): Same.
+       (tree_if_convert_stmt): Same.
+       (if_convertible_gimplify_modify_stmt_p): Rename from
+       if_convertible_modify_expr_p.
+       (if_convertible_stmt_p): Adjust for GIMPLE_MODIFY_STMT.
+       (ifc_temp_var): Same.
+       (replace_phi_with_cond_modify_stmt): Rename from
+       replace_phi_with_cond_modify_expr.
+       (process_phi_nodes): Call replace_phi_with_cond_modify_stmt.
+       * tree.def (DEFTREECODE): Add GIMPLE_MODIFY_STMT.
+       * tree-data-ref.c (find_data_references_in_loop): Adjust for
+       GIMPLE_MODIFY_STMT.
+       * tree-flow-inline.h (var_ann): Same.
+       (function_ann): Same.
+       (stmt_ann): Same.
+       (mark_non_addressable): Same.
+       * tree-vect-analyze.c (vect_determine_vectorization_factor): Same.
+       * gimplify.c (tree_to_gimple_tuple): New.
+       (build_stack_save_restore): Adjust for GIMPLE_MODIFY_STMT.
+       (gimplify_return_expr): Same.
+       (gimplify_decl_expr): Same.
+       (gimplify_self_mod_expr): Same.
+       (gimplify_cond_expr): Same.
+       (gimplify_init_constructor): Same.
+       (gimplify_modify_expr): Same.
+       (gimplify_expr): Same.
+       (gimplify_function_tree): Same.
+       (force_gimple_operand): Same.
+       * tree-ssa-phiopt.c (conditional_replacement): Same.
+       (minmax_replacement): Same.
+       (abs_replacement): Same.
+       * tree-dfa.c (create_var_ann): Same.
+       (create_function_ann): Same.
+       (create_stmt_ann): Same.
+       (create_tree_ann): Same.
+       (collect_dfa_stats_r): Same.
+       * tree-ssa-pre.c (find_or_generate_expression): Same.
+       (create_expression_by_pieces): Same.
+       (try_look_through_load): Same.
+       (insert_fake_stores): Same.
+       (realify_fake_stores): Same.
+       (compute_avail): Same.
+       (eliminate): Same.
+       (init_pre): Same.
+       (poolify_modify_stmt): Rename from poolify_modify_stmt.
+       Adjust for GIMPLE_MODIFY_STMT.
+       (NECESSARY): Adjust for new `common' layout.
+       * tree-ssa-live.c (build_tree_conflict_graph): Adjust for
+       GIMPLE_MODIFY_STMT.
+       * tree-sra.c (sra_walk_modify_stmt): Rename from
+       sra_walk_modify_expr.
+       (sra_walk_function): Adjust for GIMPLE_MODIFY_STMT.
+       (generate_copy_inout): Same.
+       (generate_element_copy): Same.
+       (generate_element_zero): Same.
+       (scalarize_copy): Same.
+       * tree-mudflap.c (mf_decl_cache_locals): Same.
+       (mf_build_check_statement_for): Same.
+       (mf_xform_derefs): Same.
+       * ipa-prop.c (ipa_method_modify_stmt): Same.
+       * print-tree.c (print_node): Handle gimple tuples.
+       Add case for tcc_gimple_stmt.
+       * tree-ssa-copy.c (stmt_may_generate_copy): Adjust for
+       GIMPLE_MODIFY_STMT.
+       (copy_prop_visit_assignment): Same.
+       (copy_prop_visit_stmt): Same.
+       (init_copy_prop): Same.
+       * tree-ssa-forwprop.c (ssa_name_defined_by_comparison_p): Same.
+       (forward_propagate_into_cond_1): Same.
+       (find_equivalent_equality_comparison): Same.
+       (tidy_after_forward_propagate_addr): Same.
+       (forward_propagate_addr_expr_1): Same.
+       (simplify_not_neg_expr): Same.
+       (simplify_switch_expr): Same.
+       * tree-ssa-dce.c (find_pdom): Same.
+       (mark_stmt_if_obviously_necessary): Same.
+       (NECESSARY): Adjust for new `common' layout.
+       * tree-flow.h: Same.
+       * tree-vect-patterns.c (widened_name_p): Adjust for
+       GIMPLE_MODIFY_STMT.
+       (vect_recog_dot_prod_pattern): Same.
+       (vect_recog_widen_sum_pattern): Same.
+       (vect_pattern_recog_1): Same.
+       * tree-nested.c (init_tmp_var): Same.
+       (save_tmp_var): Same.
+       (walk_stmts): Same.
+       (convert_call_expr): Same.
+       (finalize_nesting_tree_1): Same.
+       * tree-ssa.c (verify_ssa): Same.
+       (delete_tree_ssa): Same.
+       * lambda-code.c (lbv_to_gcc_expression): Same.
+       (lle_to_gcc_expression): Same.
+       (lambda_loopnest_to_gcc_loopnest): Same.
+       (can_put_in_inner_loop): Same.
+       (can_convert_to_perfect_nest): Same.
+       (perfect_nestify): Same.
+       * tree-ssa-loop-prefetch.c (gather_memory_references): Same.
+       * tree-inline.c (copy_body_r): Same.
+       (setup_one_parameter): Same.
+       (initialize_inlined_parameters): Same.
+       (estimate_num_insns_1): Same.
+       (expand_call_inline): Same.
+       (gimple_expand_calls_inline): Same.
+       (copy_tree_r): Same.
+       * tree-optimize.c (execute_free_cfg_annotations): Same.
+       * tree-vect-transform.c (vect_create_addr_base_for_vector_ref): Same.
+       (vect_align_data_ref): Same.
+       (vect_create_data_ref_ptr): Same.
+       (vect_init_vector): Same.
+       (vect_create_epilog_for_reduction): Same.
+       (vectorizable_reduction): Same.
+       (vectorizable_assignment): Same.
+       (vectorizable_operation): Same.
+       (vectorizable_store): Same.
+       (vectorizable_load): Same.
+       (vectorizable_live_operation): Same.
+       (vectorizable_condition): Same.
+       (vect_generate_tmps_on_preheader): Same.
+       (vect_create_cond_for_align_checks): Same.
+       * tree-object-size.c (collect_object_sizes_for): Same.
+       (check_for_plus_in_loops_1): Same.
+       (check_for_plus_in_loops): Same.
+       * tree-outof-ssa.c (insert_copy_on_edge): Same.
+       (replace_use_variable): Same.
+       (check_replaceable): Same.
+       (rewrite_trees): Same.
+       (identical_copies_p): Same.
+       (insert_backedge_copies): Same.
+       * tree-profile.c (tree_gen_edge_profiler): Same.
+       * tree-vect-generic.c (expand_vector_operations_1): Same.
+       * tree-ssa-structalias.c (update_alias_info): Same.
+       (find_func_aliases): Same.
+       * tree-cfg.c (factor_computed_gotos): Same.
+       (make_edges): Same.
+       (make_goto_expr_edges): Same.
+       (tree_merge_blocks): Same.
+       (remove_useless_stmts_cond): Same.
+       (remove_useless_stmts_1): Same.
+       (tree_find_edge_insert_loc): Same.
+       (verify_expr): Same.
+       (gimplify_val): Same.
+       (verify_gimple_tuples_1): New.
+       (verify_gimple_tuples): New.
+       (verify_stmts): Call verify_gimple_tuples.
+       * tree-ssa-reassoc.c (get_rank): Adjust for GIMPLE_MODIFY_STMT.
+       (get_unary_op): Same.
+       (linearize_expr): Same.
+       (get_single_immediate_use): Same.
+       (negate_value): Same.
+       (should_break_up_subtract): Same.
+       (break_up_subtract): Same.
+       (repropagate_negates): Same.
+       (break_up_subtract_bb): Same.
+       (reassociate_bb): Same.
+       * config/i386/i386.c (ix86_va_start): Same.
+       (ix86_gimplify_va_arg): Same.
+       * stmt.c (expand_expr_stmt): Same.
+       (warn_if_unused_value): Same.
+       (expand_return): Same.
+       * tree-ssanames.c (make_ssa_name): Same.
+       * tree-ssa-threadedge.c (lhs_of_dominating_assert): Same.
+       * tree-ssa-operands.c (finalize_ssa_defs): Same.
+       (add_virtual_operand): Same.
+       (get_expr_operands): Same.
+       (parse_ssa_operands): Same.
+       (get_modify_stmt_operands): Rename from get_modify_expr_operands.
+
 2006-12-05  H.J. Lu  <hongjiu.lu@intel.com>
 
        * config.host: Remove extra blank line.
index 0bc81e4..608f75e 100644 (file)
@@ -36,7 +36,8 @@ enum gnat_tree_code {
 /* Ada uses the lang_decl and lang_type fields to hold a tree.  */
 union lang_tree_node
   GTY((desc ("0"),
-       chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.t)")))
+       chain_next ("(GIMPLE_STMT_P (&%h.t) ? (union lang_tree_node *) 0 : (union lang_tree_node *)TREE_CHAIN (&%h.t))")))
+
 {
   union tree_node GTY((tag ("0"))) t;
 };
index 7b9c260..b19f2f5 100644 (file)
@@ -4840,7 +4840,7 @@ gnat_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p ATTRIBUTE_UNUSED)
               && TREE_CODE_CLASS (TREE_CODE (op)) != tcc_constant)
        {
          tree new_var = create_tmp_var (TREE_TYPE (op), "A");
-         tree mod = build2 (MODIFY_EXPR, TREE_TYPE (op), new_var, op);
+         tree mod = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (op), new_var, op);
 
          TREE_ADDRESSABLE (new_var) = 1;
 
index 0cfdb9a..fa7ed01 100644 (file)
@@ -4319,7 +4319,7 @@ std_expand_builtin_va_start (tree valist, rtx nextarg)
 {
   tree t;
 
-  t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist,
              make_tree (ptr_type_node, nextarg));
   TREE_SIDE_EFFECTS (t) = 1;
 
@@ -4390,12 +4390,12 @@ std_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
       && !integer_zerop (TYPE_SIZE (type)))
     {
       t = fold_convert (TREE_TYPE (valist), size_int (boundary - 1));
-      t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist_tmp,
                  build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t));
       gimplify_and_add (t, pre_p);
 
       t = fold_convert (TREE_TYPE (valist), size_int (-boundary));
-      t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist_tmp,
                  build2 (BIT_AND_EXPR, TREE_TYPE (valist), valist_tmp, t));
       gimplify_and_add (t, pre_p);
     }
@@ -4434,7 +4434,7 @@ std_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
   /* Compute new value for AP.  */
   t = fold_convert (TREE_TYPE (valist), rounded_size);
   t = build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t);
-  t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist, t);
   gimplify_and_add (t, pre_p);
 
   addr = fold_convert (build_pointer_type (type), addr);
@@ -4599,7 +4599,7 @@ expand_builtin_va_copy (tree arglist)
 
   if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
     {
-      t = build2 (MODIFY_EXPR, va_list_type_node, dst, src);
+      t = build2 (GIMPLE_MODIFY_STMT, va_list_type_node, dst, src);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
@@ -6738,9 +6738,9 @@ integer_valued_real_p (tree t)
       return integer_valued_real_p (TREE_OPERAND (t, 0));
 
     case COMPOUND_EXPR:
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case BIND_EXPR:
-      return integer_valued_real_p (TREE_OPERAND (t, 1));
+      return integer_valued_real_p (GENERIC_TREE_OPERAND (t, 1));
 
     case PLUS_EXPR:
     case MINUS_EXPR:
@@ -8096,7 +8096,7 @@ fold_builtin_memset (tree arglist, tree type, bool ignore)
     }
 
   ret = build_int_cst_type (TREE_TYPE (var), cval);
-  ret = build2 (MODIFY_EXPR, TREE_TYPE (var), var, ret);
+  ret = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (var), var, ret);
   if (ignore)
     return ret;
 
@@ -8251,7 +8251,7 @@ fold_builtin_memory_op (tree arglist, tree type, bool ignore, int endp)
        expr = fold_convert (TREE_TYPE (destvar), srcvar);
       else
        expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
-      expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
+      expr = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (destvar), destvar, expr);
     }
 
   if (ignore)
@@ -9474,7 +9474,7 @@ fold_builtin (tree fndecl, tree arglist, bool ignore)
   tree exp = fold_builtin_1 (fndecl, arglist, ignore);
   if (exp && !ignore)
     {
-      exp = build1 (NOP_EXPR, TREE_TYPE (exp), exp);
+      exp = build1 (NOP_EXPR, GENERIC_TREE_TYPE (exp), exp);
       TREE_NO_WARNING (exp) = 1;
     }
 
@@ -11704,9 +11704,11 @@ do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
                  && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
                {
                  /* Set the values. */
-                 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp, result_s);
+                 result_s = fold_build2 (GIMPLE_MODIFY_STMT, type, arg_sinp,
+                                         result_s);
                  TREE_SIDE_EFFECTS (result_s) = 1;
-                 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp, result_c);
+                 result_c = fold_build2 (GIMPLE_MODIFY_STMT, type, arg_cosp,
+                                         result_c);
                  TREE_SIDE_EFFECTS (result_c) = 1;
                  /* Combine the assignments into a compound expr.  */
                  result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
index bd737d1..c95f495 100644 (file)
@@ -256,7 +256,7 @@ extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
 
 union lang_tree_node
   GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
-       chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : (union lang_tree_node *) TREE_CHAIN (&%h.generic)")))
+       chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : (GIMPLE_TUPLE_P (&%h.generic) ? (union lang_tree_node *) 0 : (union lang_tree_node *) TREE_CHAIN (&%h.generic))")))
 {
   union tree_node GTY ((tag ("0"),
                        desc ("tree_node_structure (&%h)")))
@@ -434,7 +434,7 @@ add_stmt (tree t)
 {
   enum tree_code code = TREE_CODE (t);
 
-  if (EXPR_P (t) && code != LABEL_EXPR)
+  if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
     {
       if (!EXPR_HAS_LOCATION (t))
        SET_EXPR_LOCATION (t, input_location);
index c6be639..a54674f 100644 (file)
@@ -2172,7 +2172,7 @@ c_parser_typeof_specifier (c_parser *parser)
          if (DECL_P (e) || CONSTANT_CLASS_P (e))
            e = build1 (NOP_EXPR, void_type_node, e);
 
-         if (EXPR_P (e))
+         if (CAN_HAVE_LOCATION_P (e))
            SET_EXPR_LOCATION (e, input_location);
 
          add_stmt (e);
@@ -3817,7 +3817,7 @@ c_parser_statement_after_labels (c_parser *parser)
      (recursively) all of the component statements should already have
      line numbers assigned.  ??? Can we discard no-op statements
      earlier?  */
-  if (stmt && EXPR_P (stmt))
+  if (stmt && CAN_HAVE_LOCATION_P (stmt))
     SET_EXPR_LOCATION (stmt, loc);
 }
 
@@ -3836,7 +3836,7 @@ c_parser_paren_condition (c_parser *parser)
   loc = c_parser_peek_token (parser)->location;
   cond = c_objc_common_truthvalue_conversion
     (c_parser_expression_conv (parser).value);
-  if (EXPR_P (cond))
+  if (CAN_HAVE_LOCATION_P (cond))
     SET_EXPR_LOCATION (cond, loc);
   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
   return cond;
@@ -4073,7 +4073,7 @@ c_parser_for_statement (c_parser *parser)
        {
          tree ocond = c_parser_expression_conv (parser).value;
          cond = c_objc_common_truthvalue_conversion (ocond);
-         if (EXPR_P (cond))
+         if (CAN_HAVE_LOCATION_P (cond))
            SET_EXPR_LOCATION (cond, loc);
          c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
        }
@@ -7424,7 +7424,7 @@ c_parser_omp_for_loop (c_parser *parser)
     {
       cond = c_parser_expression_conv (parser).value;
       cond = c_objc_common_truthvalue_conversion (cond);
-      if (EXPR_P (cond))
+      if (CAN_HAVE_LOCATION_P (cond))
        SET_EXPR_LOCATION (cond, input_location);
     }
   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
index 5225ea3..56b2b47 100644 (file)
@@ -1795,13 +1795,15 @@ pp_c_conditional_expression (c_pretty_printer *pp, tree e)
 static void
 pp_c_assignment_expression (c_pretty_printer *pp, tree e)
 {
-  if (TREE_CODE (e) == MODIFY_EXPR || TREE_CODE (e) == INIT_EXPR)
+  if (TREE_CODE (e) == MODIFY_EXPR 
+      || TREE_CODE (e) == GIMPLE_MODIFY_STMT
+      || TREE_CODE (e) == INIT_EXPR)
     {
-      pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
+      pp_c_unary_expression (pp, GENERIC_TREE_OPERAND (e, 0));
       pp_c_whitespace (pp);
       pp_equal (pp);
       pp_space (pp);
-      pp_c_expression (pp, TREE_OPERAND (e, 1));
+      pp_c_expression (pp, GENERIC_TREE_OPERAND (e, 1));
     }
   else
     pp_c_conditional_expression (pp, e);
@@ -1942,6 +1944,7 @@ pp_c_expression (c_pretty_printer *pp, tree e)
       break;
 
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
       pp_assignment_expression (pp, e);
       break;
index 1b0e33a..ec14533 100644 (file)
@@ -7450,7 +7450,7 @@ c_process_expr_stmt (tree expr)
   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
 
-  if (EXPR_P (expr))
+  if (CAN_HAVE_LOCATION_P (expr))
     SET_EXPR_LOCATION (expr, input_location);
 
   return expr;
@@ -7587,7 +7587,7 @@ c_finish_stmt_expr (tree body)
     {
       /* Do not warn if the return value of a statement expression is
         unused.  */
-      if (EXPR_P (last))
+      if (CAN_HAVE_LOCATION_P (last))
        TREE_NO_WARNING (last) = 1;
       return last;
     }
index 1e76777..240ac85 100644 (file)
@@ -591,8 +591,8 @@ cgraph_create_edges (struct cgraph_node *node, tree body)
                                bb->loop_depth);
            walk_tree (&TREE_OPERAND (call, 1),
                       record_reference, node, visited_nodes);
-           if (TREE_CODE (stmt) == MODIFY_EXPR)
-             walk_tree (&TREE_OPERAND (stmt, 0),
+           if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
+             walk_tree (&GIMPLE_STMT_OPERAND (stmt, 0),
                         record_reference, node, visited_nodes);
          }
        else
index 88fed92..cf19dc0 100644 (file)
@@ -5921,11 +5921,11 @@ va_list_skip_additions (tree lhs)
       if (TREE_CODE (stmt) == PHI_NODE)
        return stmt;
 
-      if (TREE_CODE (stmt) != MODIFY_EXPR
-         || TREE_OPERAND (stmt, 0) != lhs)
+      if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT
+         || GIMPLE_STMT_OPERAND (stmt, 0) != lhs)
        return lhs;
 
-      rhs = TREE_OPERAND (stmt, 1);
+      rhs = GIMPLE_STMT_OPERAND (stmt, 1);
       if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
        rhs = TREE_OPERAND (rhs, 0);
 
@@ -6184,7 +6184,7 @@ alpha_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
     {
       nextarg = plus_constant (nextarg, offset);
       nextarg = plus_constant (nextarg, NUM_ARGS * UNITS_PER_WORD);
-      t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist,
                  make_tree (ptr_type_node, nextarg));
       TREE_SIDE_EFFECTS (t) = 1;
 
@@ -6203,12 +6203,13 @@ alpha_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
       t = make_tree (ptr_type_node, virtual_incoming_args_rtx);
       t = build2 (PLUS_EXPR, ptr_type_node, t,
                  build_int_cst (NULL_TREE, offset));
-      t = build2 (MODIFY_EXPR, TREE_TYPE (base_field), base_field, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (base_field), base_field, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
       t = build_int_cst (NULL_TREE, NUM_ARGS * UNITS_PER_WORD);
-      t = build2 (MODIFY_EXPR, TREE_TYPE (offset_field), offset_field, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (offset_field),
+                 offset_field, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
@@ -6224,7 +6225,7 @@ alpha_gimplify_va_arg_1 (tree type, tree base, tree offset, tree *pre_p)
   if (targetm.calls.must_pass_in_stack (TYPE_MODE (type), type))
     {
       t = build_int_cst (TREE_TYPE (offset), 6*8);
-      t = build2 (MODIFY_EXPR, TREE_TYPE (offset), offset,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (offset), offset,
                  build2 (MAX_EXPR, TREE_TYPE (offset), offset, t));
       gimplify_and_add (t, pre_p);
     }
@@ -6278,7 +6279,7 @@ alpha_gimplify_va_arg_1 (tree type, tree base, tree offset, tree *pre_p)
       t = size_binop (MULT_EXPR, t, size_int (8));
     }
   t = fold_convert (TREE_TYPE (offset), t);
-  t = build2 (MODIFY_EXPR, void_type_node, offset,
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, offset,
              build2 (PLUS_EXPR, TREE_TYPE (offset), offset, t));
   gimplify_and_add (t, pre_p);
 
@@ -6318,7 +6319,7 @@ alpha_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
   r = alpha_gimplify_va_arg_1 (type, base, offset, pre_p);
 
   /* Stuff the offset temporary back into its field.  */
-  t = build2 (MODIFY_EXPR, void_type_node, offset_field,
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, offset_field,
              fold_convert (TREE_TYPE (offset_field), offset));
   gimplify_and_add (t, pre_p);
 
index d7e0613..942f3c6 100644 (file)
@@ -2203,7 +2203,7 @@ frv_expand_builtin_va_start (tree valist, rtx nextarg)
       debug_rtx (nextarg);
     }
 
-  t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist,
              make_tree (ptr_type_node, nextarg));
   TREE_SIDE_EFFECTS (t) = 1;
 
index 40d96a0..dd715b4 100644 (file)
@@ -4522,7 +4522,7 @@ ix86_va_start (tree valist, rtx nextarg)
   if (cfun->va_list_gpr_size)
     {
       type = TREE_TYPE (gpr);
-      t = build2 (MODIFY_EXPR, type, gpr,
+      t = build2 (GIMPLE_MODIFY_STMT, type, gpr,
                  build_int_cst (type, n_gpr * 8));
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -4531,7 +4531,7 @@ ix86_va_start (tree valist, rtx nextarg)
   if (cfun->va_list_fpr_size)
     {
       type = TREE_TYPE (fpr);
-      t = build2 (MODIFY_EXPR, type, fpr,
+      t = build2 (GIMPLE_MODIFY_STMT, type, fpr,
                  build_int_cst (type, n_fpr * 16 + 8*REGPARM_MAX));
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -4543,7 +4543,7 @@ ix86_va_start (tree valist, rtx nextarg)
   if (words != 0)
     t = build2 (PLUS_EXPR, type, t,
                build_int_cst (type, words * UNITS_PER_WORD));
-  t = build2 (MODIFY_EXPR, type, ovf, t);
+  t = build2 (GIMPLE_MODIFY_STMT, type, ovf, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -4553,7 +4553,7 @@ ix86_va_start (tree valist, rtx nextarg)
         Prologue of the function save it right above stack frame.  */
       type = TREE_TYPE (sav);
       t = make_tree (type, frame_pointer_rtx);
-      t = build2 (MODIFY_EXPR, type, sav, t);
+      t = build2 (GIMPLE_MODIFY_STMT, type, sav, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
@@ -4690,7 +4690,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
          /* int_addr = gpr + sav; */
          t = fold_convert (ptr_type_node, gpr);
          t = build2 (PLUS_EXPR, ptr_type_node, sav, t);
-         t = build2 (MODIFY_EXPR, void_type_node, int_addr, t);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, int_addr, t);
          gimplify_and_add (t, pre_p);
        }
       if (needed_sseregs)
@@ -4698,7 +4698,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
          /* sse_addr = fpr + sav; */
          t = fold_convert (ptr_type_node, fpr);
          t = build2 (PLUS_EXPR, ptr_type_node, sav, t);
-         t = build2 (MODIFY_EXPR, void_type_node, sse_addr, t);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, sse_addr, t);
          gimplify_and_add (t, pre_p);
        }
       if (need_temp)
@@ -4708,7 +4708,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
 
          /* addr = &temp; */
          t = build1 (ADDR_EXPR, build_pointer_type (type), temp);
-         t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
          gimplify_and_add (t, pre_p);
 
          for (i = 0; i < XVECLEN (container, 0); i++)
@@ -4742,7 +4742,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
                                        size_int (INTVAL (XEXP (slot, 1)))));
              dest = build_va_arg_indirect_ref (dest_addr);
 
-             t = build2 (MODIFY_EXPR, void_type_node, dest, src);
+             t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dest, src);
              gimplify_and_add (t, pre_p);
            }
        }
@@ -4751,14 +4751,14 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
        {
          t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
                      build_int_cst (TREE_TYPE (gpr), needed_intregs * 8));
-         t = build2 (MODIFY_EXPR, TREE_TYPE (gpr), gpr, t);
+         t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gpr), gpr, t);
          gimplify_and_add (t, pre_p);
        }
       if (needed_sseregs)
        {
          t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
                      build_int_cst (TREE_TYPE (fpr), needed_sseregs * 16));
-         t = build2 (MODIFY_EXPR, TREE_TYPE (fpr), fpr, t);
+         t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (fpr), fpr, t);
          gimplify_and_add (t, pre_p);
        }
 
@@ -4785,12 +4785,12 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
     }
   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
 
-  t2 = build2 (MODIFY_EXPR, void_type_node, addr, t);
+  t2 = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
   gimplify_and_add (t2, pre_p);
 
   t = build2 (PLUS_EXPR, TREE_TYPE (t), t,
              build_int_cst (TREE_TYPE (t), rsize * UNITS_PER_WORD));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
   gimplify_and_add (t, pre_p);
 
   if (container)
index 53d90d2..8915a02 100644 (file)
@@ -4324,7 +4324,7 @@ ia64_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
                       build_int_cst (NULL_TREE, 2 * UNITS_PER_WORD - 1));
       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
                  build_int_cst (NULL_TREE, -2 * UNITS_PER_WORD));
-      t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (valist), valist, t);
       gimplify_and_add (t, pre_p);
     }
 
index 63c19ab..9b4746f 100644 (file)
@@ -4278,12 +4278,12 @@ mips_va_start (tree valist, rtx nextarg)
        t = build2 (PLUS_EXPR, TREE_TYPE (ovfl), t,
                    build_int_cst (NULL_TREE,
                                   cum->stack_words * UNITS_PER_WORD));
-      t = build2 (MODIFY_EXPR, TREE_TYPE (ovfl), ovfl, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovfl), ovfl, t);
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
       /* Emit code to initialize GTOP, the top of the GPR save area.  */
       t = make_tree (TREE_TYPE (gtop), virtual_incoming_args_rtx);
-      t = build2 (MODIFY_EXPR, TREE_TYPE (gtop), gtop, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gtop), gtop, t);
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
       /* Emit code to initialize FTOP, the top of the FPR save area.
@@ -4295,18 +4295,18 @@ mips_va_start (tree valist, rtx nextarg)
       if (fpr_offset)
        t = build2 (PLUS_EXPR, TREE_TYPE (ftop), t,
                    build_int_cst (NULL_TREE, -fpr_offset));
-      t = build2 (MODIFY_EXPR, TREE_TYPE (ftop), ftop, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ftop), ftop, t);
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
       /* Emit code to initialize GOFF, the offset from GTOP of the
         next GPR argument.  */
-      t = build2 (MODIFY_EXPR, TREE_TYPE (goff), goff,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (goff), goff,
                  build_int_cst (NULL_TREE, gpr_save_area_size));
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
       /* Likewise emit code to initialize FOFF, the offset from FTOP
         of the next FPR argument.  */
-      t = build2 (MODIFY_EXPR, TREE_TYPE (foff), foff,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (foff), foff,
                  build_int_cst (NULL_TREE, fpr_save_area_size));
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
@@ -4427,7 +4427,7 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
              /* [1] Emit code for: off &= -rsize.      */
              t = build2 (BIT_AND_EXPR, TREE_TYPE (off), off,
                          build_int_cst (NULL_TREE, -rsize));
-             t = build2 (MODIFY_EXPR, TREE_TYPE (off), off, t);
+             t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (off), off, t);
              gimplify_and_add (t, pre_p);
            }
          osize = rsize;
@@ -4466,7 +4466,7 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
          u = fold_convert (TREE_TYPE (ovfl),
                            build_int_cst (NULL_TREE, -osize));
          t = build2 (BIT_AND_EXPR, TREE_TYPE (ovfl), t, u);
-         align = build2 (MODIFY_EXPR, TREE_TYPE (ovfl), ovfl, t);
+         align = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovfl), ovfl, t);
        }
       else
        align = NULL;
index 7b274fd..26ada7e 100644 (file)
@@ -5891,7 +5891,7 @@ hppa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
       u = build_int_cst (valist_type, (size > 4 ? -8 : -4));
       t = build2 (BIT_AND_EXPR, valist_type, t, u);
 
-      t = build2 (MODIFY_EXPR, valist_type, valist, t);
+      t = build2 (GIMPLE_MODIFY_STMT, valist_type, valist, t);
 
       ofs = (8 - size) % 4;
       if (ofs != 0)
index 37e3002..08b3d01 100644 (file)
@@ -6013,7 +6013,7 @@ rs6000_va_start (tree valist, rtx nextarg)
 
   if (cfun->va_list_gpr_size)
     {
-      t = build2 (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gpr), gpr,
                  build_int_cst (NULL_TREE, n_gpr));
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -6021,7 +6021,7 @@ rs6000_va_start (tree valist, rtx nextarg)
 
   if (cfun->va_list_fpr_size)
     {
-      t = build2 (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (fpr), fpr,
                  build_int_cst (NULL_TREE, n_fpr));
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -6032,7 +6032,7 @@ rs6000_va_start (tree valist, rtx nextarg)
   if (words != 0)
     t = build2 (PLUS_EXPR, TREE_TYPE (ovf), t,
                build_int_cst (NULL_TREE, words * UNITS_PER_WORD));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -6049,7 +6049,7 @@ rs6000_va_start (tree valist, rtx nextarg)
   if (cfun->machine->varargs_save_offset)
     t = build2 (PLUS_EXPR, TREE_TYPE (sav), t,
                build_int_cst (NULL_TREE, cfun->machine->varargs_save_offset));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (sav), sav, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 }
@@ -6182,7 +6182,7 @@ rs6000_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
       u = build2 (MULT_EXPR, integer_type_node, u, size_int (sav_scale));
       t = build2 (PLUS_EXPR, ptr_type_node, t, u);
 
-      t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
       gimplify_and_add (t, pre_p);
 
       t = build1 (GOTO_EXPR, void_type_node, lab_over);
@@ -6195,7 +6195,7 @@ rs6000_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
        {
          /* Ensure that we don't find any more args in regs.
             Alignment has taken care of the n_reg == 2 gpr case.  */
-         t = build2 (MODIFY_EXPR, TREE_TYPE (reg), reg, size_int (8));
+         t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (reg), reg, size_int (8));
          gimplify_and_add (t, pre_p);
        }
     }
@@ -6212,11 +6212,11 @@ rs6000_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
     }
   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
 
-  u = build2 (MODIFY_EXPR, void_type_node, addr, t);
+  u = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
   gimplify_and_add (u, pre_p);
 
   t = build2 (PLUS_EXPR, TREE_TYPE (t), t, size_int (size));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
   gimplify_and_add (t, pre_p);
 
   if (lab_over)
index f7a1902..af449f8 100644 (file)
@@ -7931,7 +7931,7 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 
   if (cfun->va_list_gpr_size)
     {
-      t = build2 (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gpr), gpr,
                  build_int_cst (NULL_TREE, n_gpr));
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -7939,7 +7939,7 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 
   if (cfun->va_list_fpr_size)
     {
-      t = build2 (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (fpr), fpr,
                  build_int_cst (NULL_TREE, n_fpr));
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -7959,7 +7959,7 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 
       t = build2 (PLUS_EXPR, TREE_TYPE (ovf), t, build_int_cst (NULL_TREE, off));
 
-      t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
@@ -7972,7 +7972,7 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
       t = build2 (PLUS_EXPR, TREE_TYPE (sav), t,
                  build_int_cst (NULL_TREE, -RETURN_REGNUM * UNITS_PER_WORD));
   
-      t = build2 (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
+      t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (sav), sav, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
@@ -8105,7 +8105,7 @@ s390_gimplify_va_arg (tree valist, tree type, tree *pre_p,
              fold_convert (TREE_TYPE (reg), size_int (sav_scale)));
   t = build2 (PLUS_EXPR, ptr_type_node, t, fold_convert (ptr_type_node, u));
 
-  t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
   gimplify_and_add (t, pre_p);
 
   t = build1 (GOTO_EXPR, void_type_node, lab_over);
@@ -8124,12 +8124,12 @@ s390_gimplify_va_arg (tree valist, tree type, tree *pre_p,
 
   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
 
-  u = build2 (MODIFY_EXPR, void_type_node, addr, t);
+  u = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
   gimplify_and_add (u, pre_p);
 
   t = build2 (PLUS_EXPR, ptr_type_node, t, 
              fold_convert (ptr_type_node, size_int (size)));
-  t = build2 (MODIFY_EXPR, ptr_type_node, ovf, t);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, ovf, t);
   gimplify_and_add (t, pre_p);
 
   t = build1 (LABEL_EXPR, void_type_node, lab_over);
index 11766cb..f9de2a6 100644 (file)
@@ -7117,7 +7117,7 @@ sh_va_start (tree valist, rtx nextarg)
 
   /* Call __builtin_saveregs.  */
   u = make_tree (ptr_type_node, expand_builtin_saveregs ());
-  t = build2 (MODIFY_EXPR, ptr_type_node, next_fp, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_fp, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -7128,11 +7128,11 @@ sh_va_start (tree valist, rtx nextarg)
     nfp = 0;
   u = fold_build2 (PLUS_EXPR, ptr_type_node, u,
                   build_int_cst (NULL_TREE, UNITS_PER_WORD * nfp));
-  t = build2 (MODIFY_EXPR, ptr_type_node, next_fp_limit, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_fp_limit, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
-  t = build2 (MODIFY_EXPR, ptr_type_node, next_o, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_o, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -7143,12 +7143,12 @@ sh_va_start (tree valist, rtx nextarg)
     nint = 0;
   u = fold_build2 (PLUS_EXPR, ptr_type_node, u,
                   build_int_cst (NULL_TREE, UNITS_PER_WORD * nint));
-  t = build2 (MODIFY_EXPR, ptr_type_node, next_o_limit, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_o_limit, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
   u = make_tree (ptr_type_node, nextarg);
-  t = build2 (MODIFY_EXPR, ptr_type_node, next_stack, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_stack, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 }
@@ -7268,10 +7268,10 @@ sh_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
          bool is_double = size == 8 && TREE_CODE (eff_type) == REAL_TYPE;
 
          tmp = build1 (ADDR_EXPR, pptr_type_node, next_fp);
-         tmp = build2 (MODIFY_EXPR, void_type_node, addr, tmp);
+         tmp = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, tmp);
          gimplify_and_add (tmp, pre_p);
 
-         tmp = build2 (MODIFY_EXPR, ptr_type_node, next_fp_tmp, valist);
+         tmp = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_fp_tmp, valist);
          gimplify_and_add (tmp, pre_p);
          tmp = next_fp_limit;
          if (size > 4 && !is_double)
@@ -7290,7 +7290,8 @@ sh_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
              tmp = fold_convert (ptr_type_node, size_int (UNITS_PER_WORD));
              tmp = build2 (BIT_AND_EXPR, ptr_type_node, next_fp_tmp, tmp);
              tmp = build2 (PLUS_EXPR, ptr_type_node, next_fp_tmp, tmp);
-             tmp = build2 (MODIFY_EXPR, ptr_type_node, next_fp_tmp, tmp);
+             tmp = build2 (GIMPLE_MODIFY_STMT, ptr_type_node,
+                           next_fp_tmp, tmp);
              gimplify_and_add (tmp, pre_p);
            }
          if (is_double)
@@ -7323,12 +7324,12 @@ sh_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
          gimplify_and_add (tmp, pre_p);
 
          tmp = build1 (ADDR_EXPR, pptr_type_node, next_stack);
-         tmp = build2 (MODIFY_EXPR, void_type_node, addr, tmp);
+         tmp = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, tmp);
          gimplify_and_add (tmp, pre_p);
-         tmp = build2 (MODIFY_EXPR, ptr_type_node, next_fp_tmp, valist);
+         tmp = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, next_fp_tmp, valist);
          gimplify_and_add (tmp, pre_p);
 
-         tmp = build2 (MODIFY_EXPR, ptr_type_node, valist, next_fp_tmp);
+         tmp = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, valist, next_fp_tmp);
          gimplify_and_add (tmp, post_p);
          valist = next_fp_tmp;
        }
@@ -7343,7 +7344,7 @@ sh_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
          gimplify_and_add (tmp, pre_p);
 
          tmp = build1 (ADDR_EXPR, pptr_type_node, next_o);
-         tmp = build2 (MODIFY_EXPR, void_type_node, addr, tmp);
+         tmp = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, tmp);
          gimplify_and_add (tmp, pre_p);
 
          tmp = build1 (GOTO_EXPR, void_type_node, lab_over);
@@ -7354,12 +7355,13 @@ sh_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
 
          if (size > 4 && ! TARGET_SH4)
            {
-             tmp = build2 (MODIFY_EXPR, ptr_type_node, next_o, next_o_limit);
+             tmp = build2 (GIMPLE_MODIFY_STMT, ptr_type_node,
+                           next_o, next_o_limit);
              gimplify_and_add (tmp, pre_p);
            }
 
          tmp = build1 (ADDR_EXPR, pptr_type_node, next_stack);
-         tmp = build2 (MODIFY_EXPR, void_type_node, addr, tmp);
+         tmp = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, tmp);
          gimplify_and_add (tmp, pre_p);
        }
 
@@ -7376,7 +7378,7 @@ sh_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
   tmp = std_gimplify_va_arg_expr (valist, type, pre_p, NULL);
   if (result)
     {
-      tmp = build2 (MODIFY_EXPR, void_type_node, result, tmp);
+      tmp = build2 (GIMPLE_MODIFY_STMT, void_type_node, result, tmp);
       gimplify_and_add (tmp, pre_p);
 
       tmp = build1 (LABEL_EXPR, void_type_node, lab_over);
index b26b59b..75c7de7 100644 (file)
@@ -5716,7 +5716,7 @@ sparc_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
     addr = fold_convert (ptrtype, addr);
 
   incr = fold (build2 (PLUS_EXPR, ptr_type_node, incr, ssize_int (rsize)));
-  incr = build2 (MODIFY_EXPR, ptr_type_node, valist, incr);
+  incr = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, valist, incr);
   gimplify_and_add (incr, post_p);
 
   return build_va_arg_indirect_ref (addr);
index 07680b7..4aa8e38 100644 (file)
@@ -2801,7 +2801,7 @@ spu_va_start (tree valist, rtx nextarg)
   if (current_function_pretend_args_size > 0)
     t = build2 (PLUS_EXPR, TREE_TYPE (args), t,
                build_int_cst (integer_type_node, -STACK_POINTER_OFFSET));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (args), args, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (args), args, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -2811,7 +2811,7 @@ spu_va_start (tree valist, rtx nextarg)
              build_int_cst (integer_type_node,
                             (current_function_pretend_args_size
                              - STACK_POINTER_OFFSET)));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (skip), skip, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (skip), skip, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 }
@@ -2876,12 +2876,12 @@ spu_gimplify_va_arg_expr (tree valist, tree type, tree * pre_p,
                build2 (PLUS_EXPR, ptr_type_node, skip,
                        fold_convert (ptr_type_node, size_int (32))), args);
 
-  tmp = build2 (MODIFY_EXPR, ptr_type_node, addr, tmp);
+  tmp = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, addr, tmp);
   gimplify_and_add (tmp, pre_p);
 
   /* update VALIST.__args */
   tmp = build2 (PLUS_EXPR, ptr_type_node, addr, paddedsize);
-  tmp = build2 (MODIFY_EXPR, TREE_TYPE (args), args, tmp);
+  tmp = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (args), args, tmp);
   gimplify_and_add (tmp, pre_p);
 
   addr = fold_convert (build_pointer_type (type), addr);
index 04617f5..00b6e64 100644 (file)
@@ -1375,11 +1375,11 @@ xstormy16_expand_builtin_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
   t = make_tree (TREE_TYPE (base), virtual_incoming_args_rtx);
   t = build2 (PLUS_EXPR, TREE_TYPE (base), t, 
              build_int_cst (NULL_TREE, INCOMING_FRAME_SP_OFFSET));
-  t = build2 (MODIFY_EXPR, TREE_TYPE (base), base, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (base), base, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
-  t = build2 (MODIFY_EXPR, TREE_TYPE (count), count, 
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (count), count, 
              build_int_cst (NULL_TREE,
                             current_function_args_info * UNITS_PER_WORD));
   TREE_SIDE_EFFECTS (t) = 1;
@@ -1434,7 +1434,7 @@ xstormy16_expand_builtin_va_arg (tree valist, tree type, tree *pre_p,
   
       t = fold_convert (ptr_type_node, count_tmp);
       t = build2 (PLUS_EXPR, ptr_type_node, base, t);
-      t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
       gimplify_and_add (t, pre_p);
 
       t = build1 (GOTO_EXPR, void_type_node, lab_gotaddr);
@@ -1453,7 +1453,7 @@ xstormy16_expand_builtin_va_arg (tree valist, tree type, tree *pre_p,
       tree r, u;
 
       r = size_int (NUM_ARGUMENT_REGISTERS * UNITS_PER_WORD);
-      u = build2 (MODIFY_EXPR, void_type_node, count_tmp, r);
+      u = build2 (GIMPLE_MODIFY_STMT, void_type_node, count_tmp, r);
 
       t = fold_convert (TREE_TYPE (count), r);
       t = build2 (GE_EXPR, boolean_type_node, count_tmp, t);
@@ -1469,7 +1469,7 @@ xstormy16_expand_builtin_va_arg (tree valist, tree type, tree *pre_p,
              fold_convert (TREE_TYPE (count), size_tree));
   t = fold_convert (TREE_TYPE (base), fold (t));
   t = build2 (MINUS_EXPR, TREE_TYPE (base), base, t);
-  t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
   gimplify_and_add (t, pre_p);
 
   t = build1 (LABEL_EXPR, void_type_node, lab_gotaddr);
@@ -1477,7 +1477,7 @@ xstormy16_expand_builtin_va_arg (tree valist, tree type, tree *pre_p,
 
   t = fold_convert (TREE_TYPE (count), size_tree);
   t = build2 (PLUS_EXPR, TREE_TYPE (count), count_tmp, t);
-  t = build2 (MODIFY_EXPR, TREE_TYPE (count), count, t);
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (count), count, t);
   gimplify_and_add (t, pre_p);
   
   addr = fold_convert (build_pointer_type (type), addr);
index 011f63c..49a8992 100644 (file)
@@ -2102,7 +2102,7 @@ xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 
   /* Call __builtin_saveregs; save the result in __va_reg */
   u = make_tree (ptr_type_node, expand_builtin_saveregs ());
-  t = build2 (MODIFY_EXPR, ptr_type_node, reg, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, reg, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -2110,7 +2110,7 @@ xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
   u = make_tree (ptr_type_node, virtual_incoming_args_rtx);
   u = fold_build2 (PLUS_EXPR, ptr_type_node, u,
                   build_int_cst (NULL_TREE, -32));
-  t = build2 (MODIFY_EXPR, ptr_type_node, stk, u);
+  t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, stk, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -2120,7 +2120,7 @@ xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
   if (arg_words >= MAX_ARGS_IN_REGISTERS)
     arg_words += 2;
   u = build_int_cst (NULL_TREE, arg_words * UNITS_PER_WORD);
-  t = build2 (MODIFY_EXPR, integer_type_node, ndx, u);
+  t = build2 (GIMPLE_MODIFY_STMT, integer_type_node, ndx, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 }
@@ -2189,7 +2189,7 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
                  build_int_cst (NULL_TREE, align - 1));
       t = build2 (BIT_AND_EXPR, integer_type_node, t,
                  build_int_cst (NULL_TREE, -align));
-      t = build2 (MODIFY_EXPR, integer_type_node, orig_ndx, t);
+      t = build2 (GIMPLE_MODIFY_STMT, integer_type_node, orig_ndx, t);
       gimplify_and_add (t, pre_p);
     }
 
@@ -2200,7 +2200,7 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
 
   t = fold_convert (integer_type_node, va_size);
   t = build2 (PLUS_EXPR, integer_type_node, orig_ndx, t);
-  t = build2 (MODIFY_EXPR, integer_type_node, ndx, t);
+  t = build2 (GIMPLE_MODIFY_STMT, integer_type_node, ndx, t);
   gimplify_and_add (t, pre_p);
 
 
@@ -2225,7 +2225,7 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
                  NULL_TREE);
       gimplify_and_add (t, pre_p);
 
-      t = build2 (MODIFY_EXPR, void_type_node, array, reg);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, array, reg);
       gimplify_and_add (t, pre_p);
 
       t = build1 (GOTO_EXPR, void_type_node, lab_over);
@@ -2257,13 +2257,13 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
 
   t = size_binop (PLUS_EXPR, va_size, size_int (32));
   t = fold_convert (integer_type_node, t);
-  t = build2 (MODIFY_EXPR, integer_type_node, ndx, t);
+  t = build2 (GIMPLE_MODIFY_STMT, integer_type_node, ndx, t);
   gimplify_and_add (t, pre_p);
 
   t = build1 (LABEL_EXPR, void_type_node, lab_false2);
   gimplify_and_add (t, pre_p);
 
-  t = build2 (MODIFY_EXPR, void_type_node, array, stk);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, array, stk);
   gimplify_and_add (t, pre_p);
 
   if (lab_over)
index 31c87e2..8c57d4f 100644 (file)
@@ -1,3 +1,20 @@
+2006-12-05  Aldy Hernandez  <aldyh@redhat.com>
+
+       Merge from gimple-tuples-branch.
+       
+       2006-10-05  Aldy Hernandez  <aldyh@redhat.com>
+
+       * cp-gimplify.c (cp_gimplify_expr): Adjust for GIMPLE_MODIFY_STMT.
+       (cxx_omp_clause_apply_fn): Adjust for GIMPLE_MODIFY_STMT.
+       (cxx_omp_clause_copy_ctor): Same.
+       (cxx_omp_clause_assign_op): Same.
+
+       2006-09-28  Aldy Hernandez  <aldyh@redhat.com>
+
+        * cp-tree.h (union lang_tree_node): Gimple statements do not
+       have a TREE_CHAIN.
+       (TREE_INDIRECT_USING): Look in base.
+
 2006-12-04  Jan Hubicka  <jh@suse.cz>
 
        * cp-objcp-common.c (cp_expr_size): Return NULL in the case
index bdb2edf..b6ca617 100644 (file)
@@ -483,7 +483,7 @@ cp_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p)
       ret = GS_OK;
       break;
 
-      /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
+      /* We used to do this for GIMPLE_MODIFY_STMT as well, but that's unsafe; the
         LHS of an assignment might also be involved in the RHS, as in bug
         25979.  */
     case INIT_EXPR:
@@ -784,13 +784,13 @@ cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
       end1 = build2 (PLUS_EXPR, TREE_TYPE (start1), start1, end1);
 
       p1 = create_tmp_var (TREE_TYPE (start1), NULL);
-      t = build2 (MODIFY_EXPR, void_type_node, p1, start1);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, p1, start1);
       append_to_statement_list (t, &ret);
 
       if (arg2)
        {
          p2 = create_tmp_var (TREE_TYPE (start2), NULL);
-         t = build2 (MODIFY_EXPR, void_type_node, p2, start2);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, p2, start2);
          append_to_statement_list (t, &ret);
        }
 
@@ -812,14 +812,14 @@ cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
 
       t = fold_convert (TREE_TYPE (p1), TYPE_SIZE_UNIT (inner_type));
       t = build2 (PLUS_EXPR, TREE_TYPE (p1), p1, t);
-      t = build2 (MODIFY_EXPR, void_type_node, p1, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, p1, t);
       append_to_statement_list (t, &ret);
 
       if (arg2)
        {
          t = fold_convert (TREE_TYPE (p2), TYPE_SIZE_UNIT (inner_type));
          t = build2 (PLUS_EXPR, TREE_TYPE (p2), p2, t);
-         t = build2 (MODIFY_EXPR, void_type_node, p2, t);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, p2, t);
          append_to_statement_list (t, &ret);
        }
 
@@ -870,7 +870,7 @@ cxx_omp_clause_copy_ctor (tree clause, tree dst, tree src)
   if (info)
     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), dst, src);
   if (ret == NULL)
-    ret = build2 (MODIFY_EXPR, void_type_node, dst, src);
+    ret = build2 (GIMPLE_MODIFY_STMT, void_type_node, dst, src);
 
   return ret;
 }
@@ -886,7 +886,7 @@ cxx_omp_clause_assign_op (tree clause, tree dst, tree src)
   if (info)
     ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 2), dst, src);
   if (ret == NULL)
-    ret = build2 (MODIFY_EXPR, void_type_node, dst, src);
+    ret = build2 (GIMPLE_MODIFY_STMT, void_type_node, dst, src);
 
   return ret;
 }
index 0270eb3..ae250bf 100644 (file)
@@ -486,7 +486,7 @@ enum cp_tree_node_structure_enum {
 
 /* The resulting tree type.  */
 union lang_tree_node GTY((desc ("cp_tree_node_structure (&%h)"),
-       chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
+       chain_next ("(GIMPLE_STMT_P (&%h.generic) ? (union lang_tree_node *) 0 : (union lang_tree_node *)TREE_CHAIN (&%h.generic))")))
 {
   union tree_node GTY ((tag ("TS_CP_GENERIC"),
                        desc ("tree_node_structure (&%h)"))) generic;
@@ -2067,7 +2067,7 @@ struct lang_decl GTY(())
 
 /* In a TREE_LIST concatenating using directives, indicate indirect
    directives  */
-#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->common.lang_flag_0)
+#define TREE_INDIRECT_USING(NODE) (TREE_LIST_CHECK (NODE)->base.lang_flag_0)
 
 extern tree decl_shadowed_for_var_lookup (tree);
 extern void decl_shadowed_for_var_insert (tree, tree);
index e853b2f..9a4903b 100644 (file)
@@ -9266,8 +9266,9 @@ loc_descriptor_from_tree_1 (tree loc, int want_address)
     case NON_LVALUE_EXPR:
     case VIEW_CONVERT_EXPR:
     case SAVE_EXPR:
-    case MODIFY_EXPR:
-      return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
+    case GIMPLE_MODIFY_STMT:
+      return loc_descriptor_from_tree_1 (GENERIC_TREE_OPERAND (loc, 0),
+                                        want_address);
 
     case COMPONENT_REF:
     case BIT_FIELD_REF:
@@ -10040,7 +10041,7 @@ static tree
 reference_to_unused (tree * tp, int * walk_subtrees,
                     void * data ATTRIBUTE_UNUSED)
 {
-  if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
+  if (! EXPR_P (*tp) && ! GIMPLE_STMT_P (*tp) && ! CONSTANT_CLASS_P (*tp))
     *walk_subtrees = 0;
   
   if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
index 7182b57..05bb9b8 100644 (file)
@@ -6247,6 +6247,9 @@ safe_from_p (rtx x, tree exp, int top_p)
     case tcc_type:
       /* Should never get a type here.  */
       gcc_unreachable ();
+
+    case tcc_gimple_stmt:
+      gcc_unreachable ();
     }
 
   /* If we have an rtl, find any enclosed object.  Then see if we conflict
@@ -6667,7 +6670,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
 
   /* Handle ERROR_MARK before anybody tries to access its type.  */
   if (TREE_CODE (exp) == ERROR_MARK
-      || TREE_CODE (TREE_TYPE (exp)) == ERROR_MARK)
+      || (!GIMPLE_TUPLE_P (exp) && TREE_CODE (TREE_TYPE (exp)) == ERROR_MARK))
     {
       ret = CONST0_RTX (tmode);
       return ret ? ret : const0_rtx;
@@ -6737,7 +6740,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
                    enum expand_modifier modifier, rtx *alt_rtl)
 {
   rtx op0, op1, temp, decl_rtl;
-  tree type = TREE_TYPE (exp);
+  tree type;
   int unsignedp;
   enum machine_mode mode;
   enum tree_code code = TREE_CODE (exp);
@@ -6752,8 +6755,18 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
                                                                  type)   \
                                 : (expr))
 
-  mode = TYPE_MODE (type);
-  unsignedp = TYPE_UNSIGNED (type);
+  if (GIMPLE_STMT_P (exp))
+    {
+      type = void_type_node;
+      mode = VOIDmode;
+      unsignedp = 0;
+    }
+  else
+    {
+      type = TREE_TYPE (exp);
+      mode = TYPE_MODE (type);
+      unsignedp = TYPE_UNSIGNED (type);
+    }
   if (lang_hooks.reduce_bit_field_operations
       && TREE_CODE (type) == INTEGER_TYPE
       && GET_MODE_PRECISION (mode) > TYPE_PRECISION (type))
@@ -8563,10 +8576,10 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
        target = expand_vec_cond_expr (exp, target);
        return target;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
-       tree lhs = TREE_OPERAND (exp, 0);
-       tree rhs = TREE_OPERAND (exp, 1);
+       tree lhs = GIMPLE_STMT_OPERAND (exp, 0);
+       tree rhs = GIMPLE_STMT_OPERAND (exp, 1);
 
        gcc_assert (ignore);
 
index 93dee15..0908e28 100644 (file)
@@ -41,7 +41,11 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 
    force_fit_type takes a constant, an overflowable flag and prior
    overflow indicators.  It forces the value to fit the type and sets
-   TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW as appropriate.  */
+   TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW as appropriate.
+   
+   Note: Since the folders get called on non-gimple code as well as
+   gimple code, we need to handle GIMPLE tuples as well as their
+   corresponding tree equivalents.  */
 
 #include "config.h"
 #include "system.h"
@@ -2181,6 +2185,7 @@ maybe_lvalue_p (tree x)
   case WITH_CLEANUP_EXPR:
   case COMPOUND_EXPR:
   case MODIFY_EXPR:
+  case GIMPLE_MODIFY_STMT:
   case TARGET_EXPR:
   case COND_EXPR:
   case BIND_EXPR:
@@ -7474,15 +7479,17 @@ fold_unary (enum tree_code code, tree type, tree op0)
            return fold_convert (type, build_fold_addr_expr (base));
         }
 
-      if (TREE_CODE (op0) == MODIFY_EXPR
-         && TREE_CONSTANT (TREE_OPERAND (op0, 1))
+      if ((TREE_CODE (op0) == MODIFY_EXPR
+          || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
+         && TREE_CONSTANT (GENERIC_TREE_OPERAND (op0, 1))
          /* Detect assigning a bitfield.  */
-         && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
-              && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
+         && !(TREE_CODE (GENERIC_TREE_OPERAND (op0, 0)) == COMPONENT_REF
+              && DECL_BIT_FIELD
+              (TREE_OPERAND (GENERIC_TREE_OPERAND (op0, 0), 1))))
        {
          /* Don't leave an assignment inside a conversion
             unless assigning a bitfield.  */
-         tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
+         tem = fold_build1 (code, type, GENERIC_TREE_OPERAND (op0, 1));
          /* First do the assignment, then return converted constant.  */
          tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
          TREE_NO_WARNING (tem) = 1;
@@ -8461,7 +8468,8 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
   tree arg0, arg1, tem;
   tree t1 = NULL_TREE;
 
-  gcc_assert (IS_EXPR_CODE_CLASS (kind)
+  gcc_assert ((IS_EXPR_CODE_CLASS (kind)
+              || IS_GIMPLE_STMT_CODE_CLASS (kind))
              && TREE_CODE_LENGTH (code) == 2
              && op0 != NULL_TREE
              && op1 != NULL_TREE);
@@ -11673,7 +11681,8 @@ fold (tree expr)
   if (kind == tcc_constant)
     return t;
 
-  if (IS_EXPR_CODE_CLASS (kind))
+  if (IS_EXPR_CODE_CLASS (kind)
+      || IS_GIMPLE_STMT_CODE_CLASS (kind))
     {
       tree type = TREE_TYPE (t);
       tree op0, op1, op2;
@@ -12359,7 +12368,8 @@ tree_expr_nonnegative_p (tree t)
 
     case COMPOUND_EXPR:
     case MODIFY_EXPR:
-      return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
+    case GIMPLE_MODIFY_STMT:
+      return tree_expr_nonnegative_p (GENERIC_TREE_OPERAND (t, 1));
 
     case BIND_EXPR:
       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
@@ -12419,9 +12429,10 @@ tree_expr_nonnegative_p (tree t)
            else
              break;
          }
-       if (TREE_CODE (t) == MODIFY_EXPR
-           && TREE_OPERAND (t, 0) == temp)
-         return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
+       if ((TREE_CODE (t) == MODIFY_EXPR
+            || TREE_CODE (t) == GIMPLE_MODIFY_STMT)
+           && GENERIC_TREE_OPERAND (t, 0) == temp)
+         return tree_expr_nonnegative_p (GENERIC_TREE_OPERAND (t, 1));
 
        return false;
       }
@@ -12657,8 +12668,9 @@ tree_expr_nonzero_p (tree t)
 
     case COMPOUND_EXPR:
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case BIND_EXPR:
-      return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
+      return tree_expr_nonzero_p (GENERIC_TREE_OPERAND (t, 1));
 
     case SAVE_EXPR:
     case NON_LVALUE_EXPR:
index 52c0b5f..1151318 100644 (file)
@@ -62,7 +62,8 @@ GTY(())
 
 union lang_tree_node
 GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
-     chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
+     chain_next ("(GIMPLE_STMT_P (&%h.generic) ? (union lang_tree_node *) 0 : (union lang_tree_node *)TREE_CHAIN (&%h.generic))")))
+
 {
   union tree_node GTY((tag ("0"),
                       desc ("tree_node_structure (&%h)"))) generic;
index e31ecbd..8cbcac9 100644 (file)
@@ -5741,6 +5741,19 @@ resolve_fl_derived (gfc_symbol *sym)
       sym->ns->derived_types = dt_list;
     }
 
+  /* Add derived type to the derived type list.  */
+  for (dt_list = sym->ns->derived_types; dt_list; dt_list = dt_list->next)
+    if (sym == dt_list->derived)
+      break;
+
+  if (dt_list == NULL)
+    {
+      dt_list = gfc_get_dt_list ();
+      dt_list->next = sym->ns->derived_types;
+      dt_list->derived = sym;
+      sym->ns->derived_types = dt_list;
+    }
+
   return SUCCESS;
 }
 
index 991fa1c..0049ad5 100644 (file)
@@ -156,10 +156,18 @@ gfc_conv_descriptor_data_get (tree desc)
   return t;
 }
 
-/* This provides WRITE access to the data field.  */
+/* This provides WRITE access to the data field.
+
+   TUPLES_P is true if we are generating tuples.
+   
+   This function gets called through the following macros:
+     gfc_conv_descriptor_data_set
+     gfc_conv_descriptor_data_set_tuples.  */
 
 void
-gfc_conv_descriptor_data_set (stmtblock_t *block, tree desc, tree value)
+gfc_conv_descriptor_data_set_internal (stmtblock_t *block,
+                                      tree desc, tree value,
+                                      bool tuples_p)
 {
   tree field, type, t;
 
@@ -170,7 +178,7 @@ gfc_conv_descriptor_data_set (stmtblock_t *block, tree desc, tree value)
   gcc_assert (DATA_FIELD == 0);
 
   t = build3 (COMPONENT_REF, TREE_TYPE (field), desc, field, NULL_TREE);
-  gfc_add_modify_expr (block, t, fold_convert (TREE_TYPE (field), value));
+  gfc_add_modify (block, t, fold_convert (TREE_TYPE (field), value), tuples_p);
 }
 
 
index 3374c4c..38ad123 100644 (file)
@@ -118,7 +118,11 @@ tree gfc_conv_array_ubound (tree, int);
 
 /* Build expressions for accessing components of an array descriptor.  */
 tree gfc_conv_descriptor_data_get (tree);
-void gfc_conv_descriptor_data_set (stmtblock_t *, tree, tree);
+void gfc_conv_descriptor_data_set_internal (stmtblock_t *, tree, tree, bool);
+#define gfc_conv_descriptor_data_set(BLOCK, T1, T2)                    \
+  gfc_conv_descriptor_data_set_internal ((BLOCK), (T1), (T2), false)
+#define gfc_conv_descriptor_data_set_tuples(BLOCK, T1, T2)             \
+  gfc_conv_descriptor_data_set_internal ((BLOCK), (T1), (T2), true)
 tree gfc_conv_descriptor_data_addr (tree);
 tree gfc_conv_descriptor_offset (tree);
 tree gfc_conv_descriptor_dtype (tree);
index fa8be1d..8276316 100644 (file)
@@ -111,7 +111,7 @@ gfc_omp_clause_default_ctor (tree clause ATTRIBUTE_UNUSED, tree decl)
      "not currently allocated" allocation status.  */
   gfc_init_block (&block);
 
-  gfc_conv_descriptor_data_set (&block, decl, null_pointer_node);
+  gfc_conv_descriptor_data_set_tuples (&block, decl, null_pointer_node);
 
   return gfc_finish_block (&block);
 }
@@ -832,7 +832,7 @@ gfc_trans_omp_atomic (gfc_code *code)
          tree accum = gfc_create_var (TREE_TYPE (rse.expr), NULL);
          gfc_actual_arglist *arg;
 
-         gfc_add_modify_expr (&block, accum, rse.expr);
+         gfc_add_modify_stmt (&block, accum, rse.expr);
          for (arg = expr2->value.function.actual->next->next; arg;
               arg = arg->next)
            {
@@ -840,7 +840,7 @@ gfc_trans_omp_atomic (gfc_code *code)
              gfc_conv_expr (&rse, arg->expr);
              gfc_add_block_to_block (&block, &rse.pre);
              x = fold_build2 (op, TREE_TYPE (accum), accum, rse.expr);
-             gfc_add_modify_expr (&block, accum, x);
+             gfc_add_modify_stmt (&block, accum, x);
            }
 
          rse.expr = accum;
@@ -957,11 +957,11 @@ gfc_trans_omp_do (gfc_code *code, stmtblock_t *pblock,
   /* Loop body.  */
   if (simple)
     {
-      init = build2_v (MODIFY_EXPR, dovar, from);
+      init = build2_v (GIMPLE_MODIFY_STMT, dovar, from);
       cond = build2 (simple > 0 ? LE_EXPR : GE_EXPR, boolean_type_node,
                     dovar, to);
       incr = fold_build2 (PLUS_EXPR, type, dovar, step);
-      incr = fold_build2 (MODIFY_EXPR, type, dovar, incr);
+      incr = fold_build2 (GIMPLE_MODIFY_STMT, type, dovar, incr);
       if (pblock != &block)
        {
          pushlevel (0);
@@ -983,10 +983,10 @@ gfc_trans_omp_do (gfc_code *code, stmtblock_t *pblock,
       tmp = fold_build2 (TRUNC_DIV_EXPR, type, tmp, step);
       tmp = gfc_evaluate_now (tmp, pblock);
       count = gfc_create_var (type, "count");
-      init = build2_v (MODIFY_EXPR, count, build_int_cst (type, 0));
+      init = build2_v (GIMPLE_MODIFY_STMT, count, build_int_cst (type, 0));
       cond = build2 (LT_EXPR, boolean_type_node, count, tmp);
       incr = fold_build2 (PLUS_EXPR, type, count, build_int_cst (type, 1));
-      incr = fold_build2 (MODIFY_EXPR, type, count, incr);
+      incr = fold_build2 (GIMPLE_MODIFY_STMT, type, count, incr);
 
       if (pblock != &block)
        {
@@ -998,7 +998,7 @@ gfc_trans_omp_do (gfc_code *code, stmtblock_t *pblock,
       /* Initialize DOVAR.  */
       tmp = fold_build2 (MULT_EXPR, type, count, step);
       tmp = build2 (PLUS_EXPR, type, from, tmp);
-      gfc_add_modify_expr (&body, dovar, tmp);
+      gfc_add_modify_stmt (&body, dovar, tmp);
     }
 
   if (!dovar_found)
index 69a702e..3040319 100644 (file)
@@ -140,11 +140,13 @@ gfc_evaluate_now (tree expr, stmtblock_t * pblock)
 }
 
 
-/* Build a MODIFY_EXPR node and add it to a given statement block PBLOCK.
-   A MODIFY_EXPR is an assignment: LHS <- RHS.  */
+/* Build a MODIFY_EXPR (or GIMPLE_MODIFY_STMT) node and add it to a
+   given statement block PBLOCK.  A MODIFY_EXPR is an assignment:
+   LHS <- RHS.  */
 
 void
-gfc_add_modify_expr (stmtblock_t * pblock, tree lhs, tree rhs)
+gfc_add_modify (stmtblock_t * pblock, tree lhs, tree rhs,
+               bool tuples_p)
 {
   tree tmp;
 
@@ -157,7 +159,8 @@ gfc_add_modify_expr (stmtblock_t * pblock, tree lhs, tree rhs)
              || AGGREGATE_TYPE_P (TREE_TYPE (lhs)));
 #endif
 
-  tmp = fold_build2 (MODIFY_EXPR, void_type_node, lhs, rhs);
+  tmp = fold_build2 (tuples_p ? GIMPLE_MODIFY_STMT : MODIFY_EXPR,
+                    void_type_node, lhs, rhs);
   gfc_add_expr_to_block (pblock, tmp);
 }
 
index f471f09..ed96838 100644 (file)
@@ -334,8 +334,12 @@ void gfc_trans_vla_type_sizes (gfc_symbol *, stmtblock_t *);
 void gfc_add_expr_to_block (stmtblock_t *, tree);
 /* Add a block to the end of a block.  */
 void gfc_add_block_to_block (stmtblock_t *, stmtblock_t *);
-/* Add a MODIFY_EXPR to a block.  */
-void gfc_add_modify_expr (stmtblock_t *, tree, tree);
+/* Add a MODIFY_EXPR or a GIMPLE_MODIFY_STMT to a block.  */
+void gfc_add_modify (stmtblock_t *, tree, tree, bool);
+#define gfc_add_modify_expr(BLOCK, LHS, RHS) \
+       gfc_add_modify ((BLOCK), (LHS), (RHS), false)
+#define gfc_add_modify_stmt(BLOCK, LHS, RHS) \
+       gfc_add_modify ((BLOCK), (LHS), (RHS), true)
 
 /* Initialize a statement block.  */
 void gfc_init_block (stmtblock_t *);
index da93fa2..b61b900 100644 (file)
@@ -1609,7 +1609,7 @@ static tree
 instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
 {
   tree t = *tp;
-  if (! EXPR_P (t))
+  if (! EXPR_P (t) && ! GIMPLE_STMT_P (t))
     {
       *walk_subtrees = 0;
       if (DECL_P (t) && DECL_RTL_SET_P (t))
@@ -3227,11 +3227,11 @@ gimplify_parameters (void)
                  t = built_in_decls[BUILT_IN_ALLOCA];
                  t = build_function_call_expr (t, args);
                  t = fold_convert (ptr_type, t);
-                 t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+                 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
                  gimplify_and_add (t, &stmts);
                }
 
-             t = build2 (MODIFY_EXPR, void_type_node, local, parm);
+             t = build2 (GIMPLE_MODIFY_STMT, void_type_node, local, parm);
              gimplify_and_add (t, &stmts);
 
              SET_DECL_VALUE_EXPR (parm, local);
index 63d42dc..b37907c 100644 (file)
@@ -469,6 +469,11 @@ struct function GTY(())
   /* Number of units of floating point registers that need saving in stdarg
      function.  */
   unsigned int va_list_fpr_size : 8;
+
+  /* FIXME tuples: This bit is temporarily here to mark when a
+     function has been gimplified, so we can make sure we're not
+     creating non GIMPLE tuples after gimplification.  */
+  unsigned gimplified : 1;
 };
 
 /* If va_list_[gf]pr_size is set to this, it means we don't know how
index c6a0312..9c68447 100644 (file)
@@ -138,7 +138,7 @@ lower_function_body (void)
       arg = tree_cons (NULL, t, NULL);
       t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
       t = build_function_call_expr (t,arg);
-      x = build2 (MODIFY_EXPR, void_type_node, disp_var, t);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, disp_var, t);
 
       /* Build 'goto DISP_VAR;' and insert.  */
       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
@@ -254,9 +254,9 @@ lower_stmt (tree_stmt_iterator *tsi, struct lower_data *data)
     case OMP_CONTINUE:
       break;
 
-    case MODIFY_EXPR:
-      if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
-       stmt = TREE_OPERAND (stmt, 1);
+    case GIMPLE_MODIFY_STMT:
+      if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR)
+       stmt = GIMPLE_STMT_OPERAND (stmt, 1);
       else
        break;
       /* FALLTHRU */
@@ -436,9 +436,9 @@ block_may_fallthru (tree block)
       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
              && block_may_fallthru (TREE_OPERAND (stmt, 1)));
 
-    case MODIFY_EXPR:
-      if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
-       stmt = TREE_OPERAND (stmt, 1);
+    case GIMPLE_MODIFY_STMT:
+      if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR)
+       stmt = GIMPLE_STMT_OPERAND (stmt, 1);
       else
        return true;
       /* FALLTHRU */
@@ -560,15 +560,15 @@ lower_return_expr (tree_stmt_iterator *tsi, struct lower_data *data)
 
   /* Extract the value being returned.  */
   value = TREE_OPERAND (stmt, 0);
-  if (value && TREE_CODE (value) == MODIFY_EXPR)
-    value = TREE_OPERAND (value, 1);
+  if (value && TREE_CODE (value) == GIMPLE_MODIFY_STMT)
+    value = GIMPLE_STMT_OPERAND (value, 1);
 
   /* Match this up with an existing return statement that's been created.  */
   for (t = data->return_statements; t ; t = TREE_CHAIN (t))
     {
       tree tvalue = TREE_OPERAND (TREE_VALUE (t), 0);
-      if (tvalue && TREE_CODE (tvalue) == MODIFY_EXPR)
-       tvalue = TREE_OPERAND (tvalue, 1);
+      if (tvalue && TREE_CODE (tvalue) == GIMPLE_MODIFY_STMT)
+       tvalue = GIMPLE_STMT_OPERAND (tvalue, 1);
 
       if (value == tvalue)
        {
@@ -654,10 +654,10 @@ lower_builtin_setjmp (tree_stmt_iterator *tsi)
      passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver.  */
   FORCED_LABEL (next_label) = 1;
 
-  if (TREE_CODE (stmt) == MODIFY_EXPR)
+  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
     {
-      dest = TREE_OPERAND (stmt, 0);
-      stmt = TREE_OPERAND (stmt, 1);
+      dest = GIMPLE_STMT_OPERAND (stmt, 0);
+      stmt = GIMPLE_STMT_OPERAND (stmt, 1);
     }
   else
     dest = NULL_TREE;
@@ -665,7 +665,7 @@ lower_builtin_setjmp (tree_stmt_iterator *tsi)
   /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
   t = build_addr (next_label, current_function_decl);
   arg = tree_cons (NULL, t, NULL);
-  t = TREE_VALUE (TREE_OPERAND (stmt, 1));
+  t = TREE_VALUE (GENERIC_TREE_OPERAND (stmt, 1));
   arg = tree_cons (NULL, t, arg);
   t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
   t = build_function_call_expr (t, arg);
@@ -675,7 +675,7 @@ lower_builtin_setjmp (tree_stmt_iterator *tsi)
   /* Build 'DEST = 0' and insert.  */
   if (dest)
     {
-      t = build2 (MODIFY_EXPR, void_type_node, dest, integer_zero_node);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dest, integer_zero_node);
       SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
       tsi_link_before (tsi, t, TSI_SAME_STMT);
     }
@@ -699,7 +699,7 @@ lower_builtin_setjmp (tree_stmt_iterator *tsi)
   /* Build 'DEST = 1' and insert.  */
   if (dest)
     {
-      t = build2 (MODIFY_EXPR, void_type_node, dest, integer_one_node);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dest, integer_one_node);
       SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
       tsi_link_before (tsi, t, TSI_SAME_STMT);
     }
index ce91852..efe6b96 100644 (file)
@@ -769,7 +769,8 @@ should_carry_locus_p (tree stmt)
 static void
 annotate_one_with_locus (tree t, location_t locus)
 {
-  if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
+  if (CAN_HAVE_LOCATION_P (t)
+      && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
     SET_EXPR_LOCATION (t, locus);
 }
 
@@ -1040,7 +1041,7 @@ build_stack_save_restore (tree *save, tree *restore)
                                NULL_TREE);
   tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
 
-  *save = build2 (MODIFY_EXPR, ptr_type_node, tmp_var, save_call);
+  *save = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, tmp_var, save_call);
   *restore =
     build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
                              tree_cons (NULL_TREE, tmp_var, NULL_TREE));
@@ -1141,12 +1142,13 @@ gimplify_return_expr (tree stmt, tree *pre_p)
     result_decl = NULL_TREE;
   else
     {
-      result_decl = TREE_OPERAND (ret_expr, 0);
+      result_decl = GENERIC_TREE_OPERAND (ret_expr, 0);
       if (TREE_CODE (result_decl) == INDIRECT_REF)
        /* See through a return by reference.  */
        result_decl = TREE_OPERAND (result_decl, 0);
 
       gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
+                  || TREE_CODE (ret_expr) == GIMPLE_MODIFY_STMT
                   || TREE_CODE (ret_expr) == INIT_EXPR)
                  && TREE_CODE (result_decl) == RESULT_DECL);
     }
@@ -1177,10 +1179,10 @@ gimplify_return_expr (tree stmt, tree *pre_p)
       gimplify_ctxp->return_temp = result;
     }
 
-  /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
+  /* Smash the lhs of the GIMPLE_MODIFY_STMT to the temporary we plan to use.
      Then gimplify the whole thing.  */
   if (result != result_decl)
-    TREE_OPERAND (ret_expr, 0) = result;
+    GENERIC_TREE_OPERAND (ret_expr, 0) = result;
 
   gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
 
@@ -1189,7 +1191,8 @@ gimplify_return_expr (tree stmt, tree *pre_p)
   if (result == result_decl)
     ret_expr = result;
   else
-    ret_expr = build2 (MODIFY_EXPR, TREE_TYPE (result), result_decl, result);
+    ret_expr = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (result), result_decl,
+                      result);
   TREE_OPERAND (stmt, 0) = ret_expr;
 
   return GS_ALL_DONE;
@@ -1244,7 +1247,7 @@ gimplify_decl_expr (tree *stmt_p)
          t = built_in_decls[BUILT_IN_ALLOCA];
          t = build_function_call_expr (t, args);
          t = fold_convert (ptr_type, t);
-         t = build2 (MODIFY_EXPR, void_type_node, addr, t);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
 
          gimplify_and_add (t, stmt_p);
 
@@ -1943,7 +1946,7 @@ gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
     }
 
   t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
-  t1 = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
+  t1 = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (lvalue), lvalue, t1);
 
   if (postfix)
     {
@@ -2466,12 +2469,14 @@ gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback)
         if this branch is void; in C++ it can be, if it's a throw.  */
       if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
        TREE_OPERAND (expr, 1)
-         = build2 (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1));
+         = build2 (GIMPLE_MODIFY_STMT, void_type_node, tmp,
+                   TREE_OPERAND (expr, 1));
 
       /* Build the else clause, 't1 = b;'.  */
       if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
        TREE_OPERAND (expr, 2)
-         = build2 (MODIFY_EXPR, void_type_node, tmp2, TREE_OPERAND (expr, 2));
+         = build2 (GIMPLE_MODIFY_STMT, void_type_node, tmp2,
+                   TREE_OPERAND (expr, 2));
 
       TREE_TYPE (expr) = void_type_node;
       recalculate_side_effects (expr);
@@ -2551,8 +2556,8 @@ gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value)
 {
   tree args, t, to, to_ptr, from;
 
-  to = TREE_OPERAND (*expr_p, 0);
-  from = TREE_OPERAND (*expr_p, 1);
+  to = GENERIC_TREE_OPERAND (*expr_p, 0);
+  from = GENERIC_TREE_OPERAND (*expr_p, 1);
 
   args = tree_cons (NULL, size, NULL);
 
@@ -2583,7 +2588,7 @@ gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value)
 {
   tree args, t, to, to_ptr;
 
-  to = TREE_OPERAND (*expr_p, 0);
+  to = GENERIC_TREE_OPERAND (*expr_p, 0);
 
   args = tree_cons (NULL, size, NULL);
 
@@ -2746,7 +2751,8 @@ gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
   /* Create and initialize the index variable.  */
   var_type = TREE_TYPE (upper);
   var = create_tmp_var (var_type, NULL);
-  append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, lower), pre_p);
+  append_to_statement_list (build2 (GIMPLE_MODIFY_STMT, var_type, var, lower),
+                           pre_p);
 
   /* Add the loop entry label.  */
   append_to_statement_list (build1 (LABEL_EXPR,
@@ -2767,7 +2773,7 @@ gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
                             pre_p, cleared);
   else
-    append_to_statement_list (build2 (MODIFY_EXPR, TREE_TYPE (cref),
+    append_to_statement_list (build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (cref),
                                      cref, value),
                              pre_p);
 
@@ -2782,7 +2788,7 @@ gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
                    pre_p);
 
   /* Otherwise, increment the index var...  */
-  append_to_statement_list (build2 (MODIFY_EXPR, var_type, var,
+  append_to_statement_list (build2 (GIMPLE_MODIFY_STMT, var_type, var,
                                    build2 (PLUS_EXPR, var_type, var,
                                            fold_convert (var_type,
                                                          integer_one_node))),
@@ -2918,7 +2924,7 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p,
                           tree *post_p, bool want_value)
 {
   tree object;
-  tree ctor = TREE_OPERAND (*expr_p, 1);
+  tree ctor = GENERIC_TREE_OPERAND (*expr_p, 1);
   tree type = TREE_TYPE (ctor);
   enum gimplify_status ret;
   VEC(constructor_elt,gc) *elts;
@@ -2926,11 +2932,11 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p,
   if (TREE_CODE (ctor) != CONSTRUCTOR)
     return GS_UNHANDLED;
 
-  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+  ret = gimplify_expr (&GENERIC_TREE_OPERAND (*expr_p, 0), pre_p, post_p,
                       is_gimple_lvalue, fb_lvalue);
   if (ret == GS_ERROR)
     return ret;
-  object = TREE_OPERAND (*expr_p, 0);
+  object = GENERIC_TREE_OPERAND (*expr_p, 0);
 
   elts = CONSTRUCTOR_ELTS (ctor);
 
@@ -3056,7 +3062,7 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p,
                  }
                walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
 
-               TREE_OPERAND (*expr_p, 1) = new;
+               GENERIC_TREE_OPERAND (*expr_p, 1) = new;
 
                /* This is no longer an assignment of a CONSTRUCTOR, but
                   we still may have processing to do on the LHS.  So
@@ -3075,7 +3081,7 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p,
              preeval_data.lhs_base_decl = NULL;
            preeval_data.lhs_alias_set = get_alias_set (object);
 
-           gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
+           gimplify_init_ctor_preeval (&GENERIC_TREE_OPERAND (*expr_p, 1),
                                        pre_p, post_p, &preeval_data);
          }
 
@@ -3462,8 +3468,8 @@ gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
   enum tree_code code, ocode;
   tree lhs, rhs, new_rhs, other, realpart, imagpart;
 
-  lhs = TREE_OPERAND (*expr_p, 0);
-  rhs = TREE_OPERAND (*expr_p, 1);
+  lhs = GENERIC_TREE_OPERAND (*expr_p, 0);
+  rhs = GENERIC_TREE_OPERAND (*expr_p, 1);
   code = TREE_CODE (lhs);
   lhs = TREE_OPERAND (lhs, 0);
 
@@ -3479,8 +3485,8 @@ gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
   else
     new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
 
-  TREE_OPERAND (*expr_p, 0) = lhs;
-  TREE_OPERAND (*expr_p, 1) = new_rhs;
+  GENERIC_TREE_OPERAND (*expr_p, 0) = lhs;
+  GENERIC_TREE_OPERAND (*expr_p, 1) = new_rhs;
 
   if (want_value)
     {
@@ -3491,6 +3497,53 @@ gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
   return GS_ALL_DONE;
 }
 
+
+/* Destructively convert the TREE pointer in TP into a gimple tuple if
+   appropriate.  */
+
+static void
+tree_to_gimple_tuple (tree *tp)
+{
+
+  switch (TREE_CODE (*tp))
+    {
+    case GIMPLE_MODIFY_STMT:
+      return;
+    case MODIFY_EXPR:
+      {
+        struct gimple_stmt *gs;
+       tree lhs = TREE_OPERAND (*tp, 0);
+       bool def_stmt_self_p = false;
+
+       if (TREE_CODE (lhs) == SSA_NAME)
+         {
+           if (SSA_NAME_DEF_STMT (lhs) == *tp)
+             def_stmt_self_p = true;
+         }
+
+        gs = &make_node (GIMPLE_MODIFY_STMT)->gstmt;
+        gs->base = (*tp)->base;
+        /* The set to base above overwrites the CODE.  */
+        TREE_SET_CODE ((tree) gs, GIMPLE_MODIFY_STMT);
+
+        gs->locus = EXPR_LOCUS (*tp);
+        gs->operands[0] = TREE_OPERAND (*tp, 0);
+        gs->operands[1] = TREE_OPERAND (*tp, 1);
+        gs->block = TREE_BLOCK (*tp);
+        *tp = (tree)gs;
+
+       /* If we re-gimplify a set to an SSA_NAME, we must change the
+          SSA name's DEF_STMT link.  */
+       if (def_stmt_self_p)
+         SSA_NAME_DEF_STMT (GIMPLE_STMT_OPERAND (*tp, 0)) = *tp;
+
+        return;
+      }
+    default:
+      break;
+    }
+}
+
 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
 
       modify_expr
@@ -3509,11 +3562,12 @@ gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
 static enum gimplify_status
 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
 {
-  tree *from_p = &TREE_OPERAND (*expr_p, 1);
-  tree *to_p = &TREE_OPERAND (*expr_p, 0);
+  tree *from_p = &GENERIC_TREE_OPERAND (*expr_p, 1);
+  tree *to_p = &GENERIC_TREE_OPERAND (*expr_p, 0);
   enum gimplify_status ret = GS_UNHANDLED;
 
   gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
+             || TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT
              || TREE_CODE (*expr_p) == INIT_EXPR);
 
   /* For zero sized types only gimplify the left hand side and right hand side
@@ -3592,6 +3646,8 @@ gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
 
   if (want_value)
     {
+      tree_to_gimple_tuple (expr_p);
+
       append_to_statement_list (*expr_p, pre_p);
       *expr_p = *to_p;
       return GS_OK;
@@ -4182,9 +4238,9 @@ gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
       */
 
       tree flag = create_tmp_var (boolean_type_node, "cleanup");
-      tree ffalse = build2 (MODIFY_EXPR, void_type_node, flag,
+      tree ffalse = build2 (GIMPLE_MODIFY_STMT, void_type_node, flag,
                            boolean_false_node);
-      tree ftrue = build2 (MODIFY_EXPR, void_type_node, flag,
+      tree ftrue = build2 (GIMPLE_MODIFY_STMT, void_type_node, flag,
                           boolean_true_node);
       cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
       wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
@@ -4883,8 +4939,9 @@ gimplify_omp_for (tree *expr_p, tree *pre_p)
   gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, false, false);
 
   t = OMP_FOR_INIT (for_stmt);
-  gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
-  decl = TREE_OPERAND (t, 0);
+  gcc_assert (TREE_CODE (t) == MODIFY_EXPR
+             || TREE_CODE (t) == GIMPLE_MODIFY_STMT);
+  decl = GENERIC_TREE_OPERAND (t, 0);
   gcc_assert (DECL_P (decl));
   gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl)));
 
@@ -4894,16 +4951,21 @@ gimplify_omp_for (tree *expr_p, tree *pre_p)
   else
     omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
 
-  ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
+  ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
+                       &OMP_FOR_PRE_BODY (for_stmt),
                        NULL, is_gimple_val, fb_rvalue);
 
+  tree_to_gimple_tuple (&OMP_FOR_INIT (for_stmt));
+
   t = OMP_FOR_COND (for_stmt);
   gcc_assert (COMPARISON_CLASS_P (t));
-  gcc_assert (TREE_OPERAND (t, 0) == decl);
+  gcc_assert (GENERIC_TREE_OPERAND (t, 0) == decl);
 
-  ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
+  ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
+                       &OMP_FOR_PRE_BODY (for_stmt),
                        NULL, is_gimple_val, fb_rvalue);
 
+  tree_to_gimple_tuple (&OMP_FOR_INCR (for_stmt));
   t = OMP_FOR_INCR (for_stmt);
   switch (TREE_CODE (t))
     {
@@ -4917,13 +4979,13 @@ gimplify_omp_for (tree *expr_p, tree *pre_p)
       goto build_modify;
     build_modify:
       t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
-      t = build2 (MODIFY_EXPR, void_type_node, decl, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, decl, t);
       OMP_FOR_INCR (for_stmt) = t;
       break;
       
-    case MODIFY_EXPR:
-      gcc_assert (TREE_OPERAND (t, 0) == decl);
-      t = TREE_OPERAND (t, 1);
+    case GIMPLE_MODIFY_STMT:
+      gcc_assert (GIMPLE_STMT_OPERAND (t, 0) == decl);
+      t = GIMPLE_STMT_OPERAND (t, 1);
       switch (TREE_CODE (t))
        {
        case PLUS_EXPR:
@@ -5133,7 +5195,7 @@ gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
     return GS_ERROR;
 
   x = build_fold_indirect_ref (addr);
-  x = build2 (MODIFY_EXPR, void_type_node, oldval, x);
+  x = build2 (GIMPLE_MODIFY_STMT, void_type_node, oldval, x);
   gimplify_and_add (x, pre_p);
 
   /* For floating-point values, we'll need to view-convert them to integers
@@ -5151,7 +5213,7 @@ gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
       newival = create_tmp_var (itype, NULL);
 
       x = build1 (VIEW_CONVERT_EXPR, itype, oldval);
-      x = build2 (MODIFY_EXPR, void_type_node, oldival, x);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, oldival, x);
       gimplify_and_add (x, pre_p);
       iaddr = fold_convert (build_pointer_type (itype), addr);
     }
@@ -5162,17 +5224,17 @@ gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
   x = build1 (LABEL_EXPR, void_type_node, label);
   gimplify_and_add (x, pre_p);
 
-  x = build2 (MODIFY_EXPR, void_type_node, newval, rhs);
+  x = build2 (GIMPLE_MODIFY_STMT, void_type_node, newval, rhs);
   gimplify_and_add (x, pre_p);
 
   if (newval != newival)
     {
       x = build1 (VIEW_CONVERT_EXPR, itype, newval);
-      x = build2 (MODIFY_EXPR, void_type_node, newival, x);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, newival, x);
       gimplify_and_add (x, pre_p);
     }
 
-  x = build2 (MODIFY_EXPR, void_type_node, oldival2,
+  x = build2 (GIMPLE_MODIFY_STMT, void_type_node, oldival2,
              fold_convert (itype, oldival));
   gimplify_and_add (x, pre_p);
 
@@ -5182,14 +5244,14 @@ gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
   x = build_function_call_expr (cmpxchg, args);
   if (oldval == oldival)
     x = fold_convert (type, x);
-  x = build2 (MODIFY_EXPR, void_type_node, oldival, x);
+  x = build2 (GIMPLE_MODIFY_STMT, void_type_node, oldival, x);
   gimplify_and_add (x, pre_p);
 
   /* For floating point, be prepared for the loop backedge.  */
   if (oldval != oldival)
     {
       x = build1 (VIEW_CONVERT_EXPR, type, oldival);
-      x = build2 (MODIFY_EXPR, void_type_node, oldval, x);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, oldval, x);
       gimplify_and_add (x, pre_p);
     }
 
@@ -5227,7 +5289,7 @@ gimplify_omp_atomic_mutex (tree *expr_p, tree *pre_p, tree addr, tree rhs)
   gimplify_and_add (t, pre_p);
 
   t = build_fold_indirect_ref (addr);
-  t = build2 (MODIFY_EXPR, void_type_node, t, rhs);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, t, rhs);
   gimplify_and_add (t, pre_p);
   
   t = built_in_decls[BUILT_IN_GOMP_ATOMIC_END];
@@ -5362,7 +5424,8 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
 
       /* Die, die, die, my darling.  */
       if (save_expr == error_mark_node
-         || (TREE_TYPE (save_expr)
+         || (!GIMPLE_STMT_P (save_expr)
+             && TREE_TYPE (save_expr)
              && TREE_TYPE (save_expr) == error_mark_node))
        {
          ret = GS_ERROR;
@@ -5438,14 +5501,23 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
          break;
 
        case MODIFY_EXPR:
+       case GIMPLE_MODIFY_STMT:
        case INIT_EXPR:
          ret = gimplify_modify_expr (expr_p, pre_p, post_p,
                                      fallback != fb_none);
 
-         /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
-            useful.  */
-         if (*expr_p && TREE_CODE (*expr_p) == INIT_EXPR)
-           TREE_SET_CODE (*expr_p, MODIFY_EXPR);
+         if (*expr_p)
+           {
+             /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
+                useful.  */
+             if (TREE_CODE (*expr_p) == INIT_EXPR)
+               TREE_SET_CODE (*expr_p, MODIFY_EXPR);
+
+             /* Convert MODIFY_EXPR to GIMPLE_MODIFY_STMT.  */
+             if (TREE_CODE (*expr_p) == MODIFY_EXPR)
+               tree_to_gimple_tuple (expr_p);
+           }
+
          break;
 
        case TRUTH_ANDIF_EXPR:
@@ -5885,7 +5957,7 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
             given a TREE_ADDRESSABLE type.  */
          tree tmp = create_tmp_var_raw (type, "vol");
          gimple_add_tmp_var (tmp);
-         *expr_p = build2 (MODIFY_EXPR, type, tmp, *expr_p);
+         *expr_p = build2 (GIMPLE_MODIFY_STMT, type, tmp, *expr_p);
        }
       else
        /* We can't do anything useful with a volatile reference to
@@ -6117,7 +6189,7 @@ gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
 
       *expr_p = create_tmp_var (type, NULL);
       tmp = build1 (NOP_EXPR, type, expr);
-      tmp = build2 (MODIFY_EXPR, type, *expr_p, tmp);
+      tmp = build2 (GIMPLE_MODIFY_STMT, type, *expr_p, tmp);
       if (EXPR_HAS_LOCATION (expr))
        SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr));
       else
@@ -6340,10 +6412,10 @@ gimplify_function_tree (tree fndecl)
       DECL_SAVED_TREE (fndecl) = bind;
     }
 
+  cfun->gimplified = true;
   current_function_decl = oldfn;
   cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL;
 }
-
 \f
 /* Expands EXPR to list of gimple statements STMTS.  If SIMPLE is true,
    force the result to be either ssa_name or an invariant, otherwise
@@ -6368,7 +6440,7 @@ force_gimple_operand (tree expr, tree *stmts, bool simple, tree var)
   gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
 
   if (var)
-    expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
+    expr = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (var), var, expr);
 
   ret = gimplify_expr (&expr, stmts, NULL,
                       gimple_test_f, fb_rvalue);
index 3837bfd..305b1a5 100644 (file)
@@ -446,7 +446,7 @@ constant_val_insert (tree fn, tree parm1, tree val)
   edge e_step;
   edge_iterator ei;
 
-  init_stmt = build2 (MODIFY_EXPR, void_type_node, parm1, val);
+  init_stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, parm1, val);
   func = DECL_STRUCT_FUNCTION (fn);
   cfun = func;
   current_function_decl = fn;
index 58fe850..91eff19 100644 (file)
@@ -247,10 +247,10 @@ ipa_method_modify_stmt (struct cgraph_node *mt, tree stmt)
 
   switch (TREE_CODE (stmt))
     {
-    case MODIFY_EXPR:
-      if (TREE_CODE (TREE_OPERAND (stmt, 0)) == PARM_DECL)
+    case GIMPLE_MODIFY_STMT:
+      if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == PARM_DECL)
        {
-         i = ipa_method_tree_map (mt, TREE_OPERAND (stmt, 0));
+         i = ipa_method_tree_map (mt, GIMPLE_STMT_OPERAND (stmt, 0));
          if (i >= 0)
             ipa_method_modify_set (mt, i, true);
        }
index fdaff50..bd1d72b 100644 (file)
@@ -412,11 +412,11 @@ scan_function (tree *tp,
       *walk_subtrees = 0;
       break;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
        /* First look on the lhs and see what variable is stored to */
-       tree lhs = TREE_OPERAND (t, 0);
-       tree rhs = TREE_OPERAND (t, 1);
+       tree lhs = GIMPLE_STMT_OPERAND (t, 0);
+       tree rhs = GIMPLE_STMT_OPERAND (t, 1);
        check_lhs_var (local, lhs);
 
        /* For the purposes of figuring out what the cast affects */
index 077aa18..9780acf 100644 (file)
@@ -494,11 +494,11 @@ scan_for_static_refs (tree *tp,
       *walk_subtrees = 0;
       break;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
        /* First look on the lhs and see what variable is stored to */
-       tree lhs = TREE_OPERAND (t, 0);
-       tree rhs = TREE_OPERAND (t, 1);
+       tree lhs = GIMPLE_STMT_OPERAND (t, 0);
+       tree rhs = GIMPLE_STMT_OPERAND (t, 1);
        check_lhs_var (local, lhs);
 
        /* For the purposes of figuring out what the cast affects */
index b2ee148..0b0c19a 100644 (file)
@@ -1184,11 +1184,11 @@ scan_for_refs (tree *tp, int *walk_subtrees, void *data)
       *walk_subtrees = 0;
       break;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
        /* First look on the lhs and see what variable is stored to */
-       tree lhs = TREE_OPERAND (t, 0);
-       tree rhs = TREE_OPERAND (t, 1);
+       tree lhs = GIMPLE_STMT_OPERAND (t, 0);
+       tree rhs = GIMPLE_STMT_OPERAND (t, 1);
 
        check_lhs_var (lhs);
        check_cast (TREE_TYPE (lhs), rhs);
index 54900d3..76d299f 100644 (file)
@@ -120,6 +120,9 @@ java_gimplify_expr (tree *expr_p, tree *pre_p ATTRIBUTE_UNUSED,
       *expr_p = java_replace_reference (*expr_p, /* want_lvalue */ false);
       return GS_UNHANDLED;
 
+      /* We don't handle GIMPLE_MODIFY_STMT, as MODIFY_EXPRs with java
+         semantics should only be generated by the front-end, and never
+         by anything after gimplification.  */
     case MODIFY_EXPR:
       return java_gimplify_modify_expr (expr_p, pre_p, post_p);
 
@@ -326,7 +329,7 @@ java_gimplify_modify_expr (tree *modify_expr_p, tree *pre_p, tree *post_p)
     {
       tree new_lhs = java_replace_reference (lhs, /* want_lvalue */ true);
       tree new_rhs = build1 (NOP_EXPR, TREE_TYPE (new_lhs), rhs);
-      modify_expr = build2 (MODIFY_EXPR, TREE_TYPE (new_lhs),
+      modify_expr = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (new_lhs),
                            new_lhs, new_rhs);
       modify_expr = build1 (NOP_EXPR, lhs_type, modify_expr);
     }
@@ -424,7 +427,7 @@ java_gimplify_new_array_init (tree exp)
 
   tree array_ptr_type = build_pointer_type (array_type);
   tree tmp = create_tmp_var (array_ptr_type, "array");
-  tree body = build2 (MODIFY_EXPR, array_ptr_type, tmp,
+  tree body = build2 (GIMPLE_MODIFY_STMT, array_ptr_type, tmp,
                      build_new_array (element_type, length));
 
   int index = 0;
@@ -437,7 +440,7 @@ java_gimplify_new_array_init (tree exp)
       tree lhs = build3 (COMPONENT_REF, TREE_TYPE (data_field),    
                         build_java_indirect_ref (array_type, tmp, 0),
                         data_field, NULL_TREE);
-      tree assignment = build2 (MODIFY_EXPR, element_type,
+      tree assignment = build2 (GIMPLE_MODIFY_STMT, element_type,
                                build4 (ARRAY_REF, element_type, lhs,
                                        build_int_cst (NULL_TREE, index++),
                                        NULL_TREE, NULL_TREE),
index a064ab0..a7bfa38 100644 (file)
@@ -725,7 +725,8 @@ struct lang_identifier GTY(())
 /* The resulting tree type.  */
 union lang_tree_node 
   GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
-       chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
+       chain_next ("(GIMPLE_STMT_P (&%h.generic) ? (union lang_tree_node *) 0 : (union lang_tree_node *)TREE_CHAIN (&%h.generic))")))
+
 {
   union tree_node GTY ((tag ("0"), 
                        desc ("tree_node_structure (&%h)"))) 
@@ -1881,12 +1882,12 @@ enum
 
 /* In an EXPR_WITH_FILE_LOCATION node.  */
 #define EXPR_WFL_EMIT_LINE_NOTE(NODE) \
-  (EXPR_WITH_FILE_LOCATION_CHECK (NODE)->common.public_flag)
+  (EXPR_WITH_FILE_LOCATION_CHECK (NODE)->base.public_flag)
 #undef EXPR_WFL_NODE
 #define EXPR_WFL_NODE(NODE) \
   TREE_OPERAND (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 0)
 #ifdef USE_MAPPED_LOCATION
-#define EXPR_WFL_LINECOL(NODE) ((NODE)->exp.locus)
+#define EXPR_WFL_LINECOL(NODE) EXPR_LOCUS(NODE)
 #define EXPR_WFL_FILENAME(NODE) EXPR_FILENAME (NODE)
 #define EXPR_WFL_LINENO(NODE) EXPR_LINENO (NODE)
 extern tree build_expr_wfl (tree, source_location);
index f16937b..0eb3286 100644 (file)
@@ -1540,9 +1540,10 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
   add_referenced_var (resvar);
 
   /* Start at 0.  */
-  stmt = build2 (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
+  stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
+                integer_zero_node);
   name = make_ssa_name (resvar, stmt);
-  TREE_OPERAND (stmt, 0) = name;
+  GIMPLE_STMT_OPERAND (stmt, 0) = name;
   tsi = tsi_last (stmts);
   tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
@@ -1555,20 +1556,20 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
          
          /* newname = coefficient * induction_variable */
          coeffmult = build_int_cst (type, LBV_COEFFICIENTS (lbv)[i]);
-         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+         stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                         fold_build2 (MULT_EXPR, type, iv, coeffmult));
 
          newname = make_ssa_name (resvar, stmt);
-         TREE_OPERAND (stmt, 0) = newname;
+         GIMPLE_STMT_OPERAND (stmt, 0) = newname;
          fold_stmt (&stmt);
          tsi = tsi_last (stmts);
          tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
          /* name = name + newname */
-         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+         stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                         build2 (PLUS_EXPR, type, name, newname));
          name = make_ssa_name (resvar, stmt);
-         TREE_OPERAND (stmt, 0) = name;
+         GIMPLE_STMT_OPERAND (stmt, 0) = name;
          fold_stmt (&stmt);
          tsi = tsi_last (stmts);
          tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1580,10 +1581,10 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
   if (LBV_DENOMINATOR (lbv) != 1)
     {
       tree denominator = build_int_cst (type, LBV_DENOMINATOR (lbv));
-      stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+      stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                     build2 (CEIL_DIV_EXPR, type, name, denominator));
       name = make_ssa_name (resvar, stmt);
-      TREE_OPERAND (stmt, 0) = name;
+      GIMPLE_STMT_OPERAND (stmt, 0) = name;
       fold_stmt (&stmt);
       tsi = tsi_last (stmts);
       tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1631,9 +1632,10 @@ lle_to_gcc_expression (lambda_linear_expression lle,
   for (; lle != NULL; lle = LLE_NEXT (lle))
     {
       /* Start at name = 0.  */
-      stmt = build2 (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
+      stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
+                    integer_zero_node);
       name = make_ssa_name (resvar, stmt);
-      TREE_OPERAND (stmt, 0) = name;
+      GIMPLE_STMT_OPERAND (stmt, 0) = name;
       fold_stmt (&stmt);
       tsi = tsi_last (stmts);
       tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1662,18 +1664,18 @@ lle_to_gcc_expression (lambda_linear_expression lle,
                }
 
              /* newname = mult */
-             stmt = build2 (MODIFY_EXPR, void_type_node, resvar, mult);
+             stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar, mult);
              newname = make_ssa_name (resvar, stmt);
-             TREE_OPERAND (stmt, 0) = newname;
+             GIMPLE_STMT_OPERAND (stmt, 0) = newname;
              fold_stmt (&stmt);
              tsi = tsi_last (stmts);
              tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
              /* name = name + newname */
-             stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+             stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                             build2 (PLUS_EXPR, type, name, newname));
              name = make_ssa_name (resvar, stmt);
-             TREE_OPERAND (stmt, 0) = name;
+             GIMPLE_STMT_OPERAND (stmt, 0) = name;
              fold_stmt (&stmt);
              tsi = tsi_last (stmts);
              tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1703,18 +1705,18 @@ lle_to_gcc_expression (lambda_linear_expression lle,
                }
 
              /* newname = mult */
-             stmt = build2 (MODIFY_EXPR, void_type_node, resvar, mult);
+             stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar, mult);
              newname = make_ssa_name (resvar, stmt);
-             TREE_OPERAND (stmt, 0) = newname;
+             GIMPLE_STMT_OPERAND (stmt, 0) = newname;
              fold_stmt (&stmt);
              tsi = tsi_last (stmts);
              tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
              /* name = name + newname */
-             stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+             stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                             build2 (PLUS_EXPR, type, name, newname));
              name = make_ssa_name (resvar, stmt);
-             TREE_OPERAND (stmt, 0) = name;
+             GIMPLE_STMT_OPERAND (stmt, 0) = name;
              fold_stmt (&stmt);
              tsi = tsi_last (stmts);
              tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1725,11 +1727,11 @@ lle_to_gcc_expression (lambda_linear_expression lle,
          name = name + constant.  */
       if (LLE_CONSTANT (lle) != 0)
        {
-         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+         stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                         build2 (PLUS_EXPR, type, name, 
                                 build_int_cst (type, LLE_CONSTANT (lle))));
          name = make_ssa_name (resvar, stmt);
-         TREE_OPERAND (stmt, 0) = name;
+         GIMPLE_STMT_OPERAND (stmt, 0) = name;
          fold_stmt (&stmt);
          tsi = tsi_last (stmts);
          tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1739,11 +1741,11 @@ lle_to_gcc_expression (lambda_linear_expression lle,
          name = name + linear offset.  */
       if (LLE_CONSTANT (offset) != 0)
        {
-         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+         stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                         build2 (PLUS_EXPR, type, name, 
                                 build_int_cst (type, LLE_CONSTANT (offset))));
          name = make_ssa_name (resvar, stmt);
-         TREE_OPERAND (stmt, 0) = name;
+         GIMPLE_STMT_OPERAND (stmt, 0) = name;
          fold_stmt (&stmt);
          tsi = tsi_last (stmts);
          tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
@@ -1755,11 +1757,11 @@ lle_to_gcc_expression (lambda_linear_expression lle,
          stmt = build_int_cst (type, LLE_DENOMINATOR (lle));
          stmt = build2 (wrap == MAX_EXPR ? CEIL_DIV_EXPR : FLOOR_DIV_EXPR,
                         type, name, stmt);
-         stmt = build2 (MODIFY_EXPR, void_type_node, resvar, stmt);
+         stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar, stmt);
 
          /* name = {ceil, floor}(name/denominator) */
          name = make_ssa_name (resvar, stmt);
-         TREE_OPERAND (stmt, 0) = name;
+         GIMPLE_STMT_OPERAND (stmt, 0) = name;
          tsi = tsi_last (stmts);
          tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
        }
@@ -1775,10 +1777,10 @@ lle_to_gcc_expression (lambda_linear_expression lle,
     {
       tree op1 = VEC_index (tree, results, 0);
       tree op2 = VEC_index (tree, results, 1);
-      stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+      stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, resvar,
                     build2 (wrap, type, op1, op2));
       name = make_ssa_name (resvar, stmt);
-      TREE_OPERAND (stmt, 0) = name;
+      GIMPLE_STMT_OPERAND (stmt, 0) = name;
       tsi = tsi_last (stmts);
       tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
     }
@@ -1893,10 +1895,10 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
         test,  and let redundancy elimination sort it out.  */
       inc_stmt = build2 (PLUS_EXPR, type, 
                         ivvar, build_int_cst (type, LL_STEP (newloop)));
-      inc_stmt = build2 (MODIFY_EXPR, void_type_node, SSA_NAME_VAR (ivvar),
-                        inc_stmt);
+      inc_stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node,
+                        SSA_NAME_VAR (ivvar), inc_stmt);
       ivvarinced = make_ssa_name (SSA_NAME_VAR (ivvar), inc_stmt);
-      TREE_OPERAND (inc_stmt, 0) = ivvarinced;
+      GIMPLE_STMT_OPERAND (inc_stmt, 0) = ivvarinced;
       bsi = bsi_for_stmt (exitcond);
       bsi_insert_before (&bsi, inc_stmt, BSI_SAME_STMT);
 
@@ -2185,9 +2187,9 @@ replace_uses_equiv_to_x_with_y (struct loop *loop, tree stmt, tree x,
       var = create_tmp_var (TREE_TYPE (use), "perfecttmp");
       add_referenced_var (var);
       val = force_gimple_operand_bsi (firstbsi, val, false, NULL);
-      setstmt = build2 (MODIFY_EXPR, void_type_node, var, val);
+      setstmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, var, val);
       var = make_ssa_name (var, setstmt);
-      TREE_OPERAND (setstmt, 0) = var;
+      GIMPLE_STMT_OPERAND (setstmt, 0) = var;
       bsi_insert_before (firstbsi, setstmt, BSI_SAME_STMT);
       update_stmt (setstmt);
       SET_USE (use_p, var);
@@ -2224,12 +2226,12 @@ can_put_in_inner_loop (struct loop *inner, tree stmt)
   imm_use_iterator imm_iter;
   use_operand_p use_p;
   
-  gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
+  gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT);
   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)
-      || !expr_invariant_in_loop_p (inner, TREE_OPERAND (stmt, 1)))
+      || !expr_invariant_in_loop_p (inner, GIMPLE_STMT_OPERAND (stmt, 1)))
     return false;
   
-  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, TREE_OPERAND (stmt, 0))
+  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0))
     {
       if (!exit_phi_for_loop_p (inner, USE_STMT (use_p)))
        {
@@ -2252,7 +2254,7 @@ can_put_after_inner_loop (struct loop *loop, tree stmt)
   if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
     return false;
   
-  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, TREE_OPERAND (stmt, 0))
+  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, GIMPLE_STMT_OPERAND (stmt, 0))
     {
       if (!exit_phi_for_loop_p (loop, USE_STMT (use_p)))
        {
@@ -2310,12 +2312,12 @@ can_convert_to_perfect_nest (struct loop *loop)
                 win we get from rearranging the memory walk
                 the loop is doing so that it has better
                 cache behavior.  */
-             if (TREE_CODE (stmt) == MODIFY_EXPR)
+             if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
                {
                  use_operand_p use_a, use_b;
                  imm_use_iterator imm_iter;
                  ssa_op_iter op_iter, op_iter1;
-                 tree op0 = TREE_OPERAND (stmt, 0);
+                 tree op0 = GIMPLE_STMT_OPERAND (stmt, 0);
                  tree scev = instantiate_parameters
                    (loop, analyze_scalar_evolution (loop, op0));
 
@@ -2538,10 +2540,10 @@ perfect_nestify (struct loop *loop,
   exit_condition = get_loop_exit_condition (newloop);
   uboundvar = create_tmp_var (integer_type_node, "uboundvar");
   add_referenced_var (uboundvar);
-  stmt = build2 (MODIFY_EXPR, void_type_node, uboundvar, 
+  stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, uboundvar, 
                 VEC_index (tree, ubounds, 0));
   uboundvar = make_ssa_name (uboundvar, stmt);
-  TREE_OPERAND (stmt, 0) = uboundvar;
+  GIMPLE_STMT_OPERAND (stmt, 0) = uboundvar;
 
   if (insert_after)
     bsi_insert_after (&bsi, stmt, BSI_SAME_STMT);
index 7fca436..5b0e09f 100644 (file)
@@ -577,7 +577,7 @@ lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
 tree
 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
 {
-  return build2 (MODIFY_EXPR, void_type_node, dst, src);
+  return build2 (GIMPLE_MODIFY_STMT, void_type_node, dst, src);
 }
 
 /* Register language specific type size variables as potentially OpenMP
index f58ee1f..625ac37 100644 (file)
@@ -157,11 +157,11 @@ extract_omp_for_data (tree for_stmt, struct omp_for_data *fd)
   fd->pre = NULL;
 
   t = OMP_FOR_INIT (for_stmt);
-  gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
-  fd->v = TREE_OPERAND (t, 0);
+  gcc_assert (TREE_CODE (t) == GIMPLE_MODIFY_STMT);
+  fd->v = GIMPLE_STMT_OPERAND (t, 0);
   gcc_assert (DECL_P (fd->v));
   gcc_assert (TREE_CODE (TREE_TYPE (fd->v)) == INTEGER_TYPE);
-  fd->n1 = TREE_OPERAND (t, 1);
+  fd->n1 = GIMPLE_STMT_OPERAND (t, 1);
 
   t = OMP_FOR_COND (for_stmt);
   fd->cond_code = TREE_CODE (t);
@@ -187,9 +187,9 @@ extract_omp_for_data (tree for_stmt, struct omp_for_data *fd)
     }
 
   t = OMP_FOR_INCR (fd->for_stmt);
-  gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
-  gcc_assert (TREE_OPERAND (t, 0) == fd->v);
-  t = TREE_OPERAND (t, 1);
+  gcc_assert (TREE_CODE (t) == GIMPLE_MODIFY_STMT);
+  gcc_assert (GIMPLE_STMT_OPERAND (t, 0) == fd->v);
+  t = GIMPLE_STMT_OPERAND (t, 1);
   gcc_assert (TREE_OPERAND (t, 0) == fd->v);
   switch (TREE_CODE (t))
     {
@@ -1680,7 +1680,7 @@ lower_rec_input_clauses (tree clauses, tree *ilist, tree *dlist,
              x = built_in_decls[BUILT_IN_ALLOCA];
              x = build_function_call_expr (x, args);
              x = fold_convert (TREE_TYPE (ptr), x);
-             x = build2 (MODIFY_EXPR, void_type_node, ptr, x);
+             x = build2 (GIMPLE_MODIFY_STMT, void_type_node, ptr, x);
              gimplify_and_add (x, ilist);
            }
          else if (is_reference (var))
@@ -1716,7 +1716,7 @@ lower_rec_input_clauses (tree clauses, tree *ilist, tree *dlist,
                  x = fold_convert (TREE_TYPE (new_var), x);
                }
 
-             x = build2 (MODIFY_EXPR, void_type_node, new_var, x);
+             x = build2 (GIMPLE_MODIFY_STMT, void_type_node, new_var, x);
              gimplify_and_add (x, ilist);
 
              new_var = build_fold_indirect_ref (new_var);
@@ -1799,7 +1799,7 @@ lower_rec_input_clauses (tree clauses, tree *ilist, tree *dlist,
                {
                  x = omp_reduction_init (c, TREE_TYPE (new_var));
                  gcc_assert (TREE_CODE (TREE_TYPE (new_var)) != ARRAY_TYPE);
-                 x = build2 (MODIFY_EXPR, void_type_node, new_var, x);
+                 x = build2 (GIMPLE_MODIFY_STMT, void_type_node, new_var, x);
                  gimplify_and_add (x, ilist);
                }
              break;
@@ -1964,7 +1964,7 @@ lower_reduction_clauses (tree clauses, tree *stmt_list, omp_context *ctx)
        {
          x = build2 (code, TREE_TYPE (ref), ref, new_var);
          ref = build_outer_var_ref (var, ctx);
-         x = build2 (MODIFY_EXPR, void_type_node, ref, x);
+         x = build2 (GIMPLE_MODIFY_STMT, void_type_node, ref, x);
          append_to_statement_list (x, &sub_list);
        }
     }
@@ -2003,7 +2003,7 @@ lower_copyprivate_clauses (tree clauses, tree *slist, tree *rlist,
       ref = build_sender_ref (var, ctx);
       x = (ctx->is_nested) ? lookup_decl_in_outer_ctx (var, ctx) : var;
       x = by_ref ? build_fold_addr_expr (x) : x;
-      x = build2 (MODIFY_EXPR, void_type_node, ref, x);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, ref, x);
       gimplify_and_add (x, slist);
 
       ref = build_receiver_ref (var, by_ref, ctx);
@@ -2084,14 +2084,14 @@ lower_send_clauses (tree clauses, tree *ilist, tree *olist, omp_context *ctx)
        {
          ref = build_sender_ref (val, ctx);
          x = by_ref ? build_fold_addr_expr (var) : var;
-         x = build2 (MODIFY_EXPR, void_type_node, ref, x);
+         x = build2 (GIMPLE_MODIFY_STMT, void_type_node, ref, x);
          gimplify_and_add (x, ilist);
        }
 
       if (do_out)
        {
          ref = build_sender_ref (val, ctx);
-         x = build2 (MODIFY_EXPR, void_type_node, var, ref);
+         x = build2 (GIMPLE_MODIFY_STMT, void_type_node, var, ref);
          gimplify_and_add (x, olist);
        }
     }
@@ -2128,17 +2128,17 @@ lower_send_shared_vars (tree *ilist, tree *olist, omp_context *ctx)
        {
          x = build_sender_ref (ovar, ctx);
          var = build_fold_addr_expr (var);
-         x = build2 (MODIFY_EXPR, void_type_node, x, var);
+         x = build2 (GIMPLE_MODIFY_STMT, void_type_node, x, var);
          gimplify_and_add (x, ilist);
        }
       else
        {
          x = build_sender_ref (ovar, ctx);
-         x = build2 (MODIFY_EXPR, void_type_node, x, var);
+         x = build2 (GIMPLE_MODIFY_STMT, void_type_node, x, var);
          gimplify_and_add (x, ilist);
 
          x = build_sender_ref (ovar, ctx);
-         x = build2 (MODIFY_EXPR, void_type_node, var, x);
+         x = build2 (GIMPLE_MODIFY_STMT, void_type_node, var, x);
          gimplify_and_add (x, olist);
        }
     }
@@ -2236,13 +2236,13 @@ expand_parallel_call (struct omp_region *region, basic_block bb,
          si = bsi_start (then_bb);
          t = build1 (LABEL_EXPR, void_type_node, then_lab);
          bsi_insert_after (&si, t, BSI_CONTINUE_LINKING);
-         t = build2 (MODIFY_EXPR, void_type_node, tmp, val);
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, tmp, val);
          bsi_insert_after (&si, t, BSI_CONTINUE_LINKING);
 
          si = bsi_start (else_bb);
          t = build1 (LABEL_EXPR, void_type_node, else_lab);
          bsi_insert_after (&si, t, BSI_CONTINUE_LINKING);
-         t = build2 (MODIFY_EXPR, void_type_node, tmp, 
+         t = build2 (GIMPLE_MODIFY_STMT, void_type_node, tmp, 
                      build_int_cst (unsigned_type_node, 1));
          bsi_insert_after (&si, t, BSI_CONTINUE_LINKING);
 
@@ -2483,19 +2483,20 @@ expand_omp_parallel (struct omp_region *region)
 
              gcc_assert (!bsi_end_p (si));
              stmt = bsi_stmt (si);
-             if (TREE_CODE (stmt) != MODIFY_EXPR)
+             if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
                continue;
 
-             arg = TREE_OPERAND (stmt, 1);
+             arg = GIMPLE_STMT_OPERAND (stmt, 1);
              STRIP_NOPS (arg);
              if (TREE_CODE (arg) == ADDR_EXPR
                  && TREE_OPERAND (arg, 0)
                     == OMP_PARALLEL_DATA_ARG (entry_stmt))
                {
-                 if (TREE_OPERAND (stmt, 0) == DECL_ARGUMENTS (child_fn))
+                 if (GIMPLE_STMT_OPERAND (stmt, 0)
+                     == DECL_ARGUMENTS (child_fn))
                    bsi_remove (&si, true);
                  else
-                   TREE_OPERAND (stmt, 1) = DECL_ARGUMENTS (child_fn);
+                   GIMPLE_STMT_OPERAND (stmt, 1) = DECL_ARGUMENTS (child_fn);
                  break;
                }
            }
@@ -2651,11 +2652,11 @@ expand_omp_for_generic (struct omp_region *region,
   /* Iteration setup for sequential loop goes in L0_BB.  */
   list = alloc_stmt_list ();
   t = fold_convert (type, istart0);
-  t = build2 (MODIFY_EXPR, void_type_node, fd->v, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, fd->v, t);
   gimplify_and_add (t, &list);
 
   t = fold_convert (type, iend0);
-  t = build2 (MODIFY_EXPR, void_type_node, iend, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, iend, t);
   gimplify_and_add (t, &list);
 
   si = bsi_start (l0_bb);
@@ -2677,7 +2678,7 @@ expand_omp_for_generic (struct omp_region *region,
   list = alloc_stmt_list ();
 
   t = build2 (PLUS_EXPR, type, fd->v, fd->step);
-  t = build2 (MODIFY_EXPR, void_type_node, fd->v, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, fd->v, t);
   gimplify_and_add (t, &list);
   
   t = build2 (fd->cond_code, boolean_type_node, fd->v, iend);
@@ -2856,7 +2857,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
   t = fold_convert (type, s0);
   t = build2 (MULT_EXPR, type, t, fd->step);
   t = build2 (PLUS_EXPR, type, t, fd->n1);
-  t = build2 (MODIFY_EXPR, void_type_node, fd->v, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, fd->v, t);
   gimplify_and_add (t, &list);
 
   t = fold_convert (type, e0);
@@ -2871,7 +2872,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
   list = alloc_stmt_list ();
 
   t = build2 (PLUS_EXPR, type, fd->v, fd->step);
-  t = build2 (MODIFY_EXPR, void_type_node, fd->v, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, fd->v, t);
   gimplify_and_add (t, &list);
 
   t = build2 (fd->cond_code, boolean_type_node, fd->v, e);
@@ -3040,7 +3041,7 @@ expand_omp_for_static_chunk (struct omp_region *region, struct omp_for_data *fd)
   t = fold_convert (type, s0);
   t = build2 (MULT_EXPR, type, t, fd->step);
   t = build2 (PLUS_EXPR, type, t, fd->n1);
-  t = build2 (MODIFY_EXPR, void_type_node, fd->v, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, fd->v, t);
   gimplify_and_add (t, &list);
 
   t = fold_convert (type, e0);
@@ -3056,7 +3057,7 @@ expand_omp_for_static_chunk (struct omp_region *region, struct omp_for_data *fd)
   list = alloc_stmt_list ();
 
   t = build2 (PLUS_EXPR, type, fd->v, fd->step);
-  t = build2 (MODIFY_EXPR, void_type_node, fd->v, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, fd->v, t);
   gimplify_and_add (t, &list);
 
   t = build2 (fd->cond_code, boolean_type_node, fd->v, e);
@@ -3075,7 +3076,7 @@ expand_omp_for_static_chunk (struct omp_region *region, struct omp_for_data *fd)
 
   t = build_int_cst (type, 1);
   t = build2 (PLUS_EXPR, type, trip, t);
-  t = build2 (MODIFY_EXPR, void_type_node, trip, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, trip, t);
   gimplify_and_add (t, &list);
 
   si = bsi_start (trip_update_bb);
@@ -3224,7 +3225,7 @@ expand_omp_sections (struct omp_region *region)
       t = tree_cons (NULL, t, NULL);
       u = built_in_decls[BUILT_IN_GOMP_SECTIONS_START];
       t = build_function_call_expr (u, t);
-      t = build2 (MODIFY_EXPR, void_type_node, v, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, v, t);
       bsi_insert_after (&si, t, BSI_SAME_STMT);
     }
   bsi_remove (&si, true);
@@ -3293,7 +3294,7 @@ expand_omp_sections (struct omp_region *region)
 
       t = built_in_decls[BUILT_IN_GOMP_SECTIONS_NEXT];
       t = build_function_call_expr (t, NULL);
-      t = build2 (MODIFY_EXPR, void_type_node, v, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, v, t);
       bsi_insert_after (&si, t, BSI_SAME_STMT);
       bsi_remove (&si, true);
     }
@@ -3731,7 +3732,7 @@ lower_omp_single_copy (tree single_stmt, tree *pre_p, omp_context *ctx)
   t = built_in_decls[BUILT_IN_GOMP_SINGLE_COPY_START];
   t = build_function_call_expr (t, NULL);
   t = fold_convert (ptr_type, t);
-  t = build2 (MODIFY_EXPR, void_type_node, ctx->receiver_decl, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, ctx->receiver_decl, t);
   gimplify_and_add (t, pre_p);
 
   t = build2 (EQ_EXPR, boolean_type_node, ctx->receiver_decl,
@@ -4048,7 +4049,7 @@ lower_omp_for (tree *stmt_p, omp_context *ctx)
 
      We just need to make sure that VAL1, VAL2 and VAL3 are lowered
      using the .omp_data_s mapping, if needed.  */
-  rhs_p = &TREE_OPERAND (OMP_FOR_INIT (stmt), 1);
+  rhs_p = &GIMPLE_STMT_OPERAND (OMP_FOR_INIT (stmt), 1);
   if (!is_gimple_min_invariant (*rhs_p))
     *rhs_p = get_formal_tmp_var (*rhs_p, body_p);
 
@@ -4056,7 +4057,7 @@ lower_omp_for (tree *stmt_p, omp_context *ctx)
   if (!is_gimple_min_invariant (*rhs_p))
     *rhs_p = get_formal_tmp_var (*rhs_p, body_p);
 
-  rhs_p = &TREE_OPERAND (TREE_OPERAND (OMP_FOR_INCR (stmt), 1), 1);
+  rhs_p = &TREE_OPERAND (GIMPLE_STMT_OPERAND (OMP_FOR_INCR (stmt), 1), 1);
   if (!is_gimple_min_invariant (*rhs_p))
     *rhs_p = get_formal_tmp_var (*rhs_p, body_p);
 
@@ -4144,7 +4145,7 @@ lower_omp_parallel (tree *stmt_p, omp_context *ctx)
       t = build_fold_addr_expr (ctx->sender_decl);
       /* fixup_child_record_type might have changed receiver_decl's type.  */
       t = fold_convert (TREE_TYPE (ctx->receiver_decl), t);
-      t = build2 (MODIFY_EXPR, void_type_node, ctx->receiver_decl, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, ctx->receiver_decl, t);
       append_to_statement_list (t, &new_body);
     }
 
index d28e515..4b5344b 100644 (file)
@@ -902,9 +902,10 @@ expr_expected_value (tree expr, bitmap visited)
            }
          return val;
        }
-      if (TREE_CODE (def) != MODIFY_EXPR || TREE_OPERAND (def, 0) != expr)
+      if (TREE_CODE (def) != GIMPLE_MODIFY_STMT
+         || GIMPLE_STMT_OPERAND (def, 0) != expr)
        return NULL;
-      return expr_expected_value (TREE_OPERAND (def, 1), visited);
+      return expr_expected_value (GIMPLE_STMT_OPERAND (def, 1), visited);
     }
   else if (TREE_CODE (expr) == CALL_EXPR)
     {
@@ -968,15 +969,15 @@ strip_builtin_expect (void)
          tree fndecl;
          tree arglist;
 
-         if (TREE_CODE (stmt) == MODIFY_EXPR
-             && TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR
-             && (fndecl = get_callee_fndecl (TREE_OPERAND (stmt, 1)))
+         if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+             && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR
+             && (fndecl = get_callee_fndecl (GIMPLE_STMT_OPERAND (stmt, 1)))
              && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
              && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
-             && (arglist = TREE_OPERAND (TREE_OPERAND (stmt, 1), 1))
+             && (arglist = TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 1))
              && TREE_CHAIN (arglist))
            {
-             TREE_OPERAND (stmt, 1) = TREE_VALUE (arglist);
+             GIMPLE_STMT_OPERAND (stmt, 1) = TREE_VALUE (arglist);
              update_stmt (stmt);
            }
        }
@@ -1167,8 +1168,8 @@ apply_return_prediction (int *heads)
   return_val = TREE_OPERAND (return_stmt, 0);
   if (!return_val)
     return;
-  if (TREE_CODE (return_val) == MODIFY_EXPR)
-    return_val = TREE_OPERAND (return_val, 1);
+  if (TREE_CODE (return_val) == GIMPLE_MODIFY_STMT)
+    return_val = GIMPLE_STMT_OPERAND (return_val, 1);
   if (TREE_CODE (return_val) != SSA_NAME
       || !SSA_NAME_DEF_STMT (return_val)
       || TREE_CODE (SSA_NAME_DEF_STMT (return_val)) != PHI_NODE)
@@ -1221,10 +1222,10 @@ tree_bb_level_predictions (void)
          tree stmt = bsi_stmt (bsi);
          switch (TREE_CODE (stmt))
            {
-             case MODIFY_EXPR:
-               if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
+             case GIMPLE_MODIFY_STMT:
+               if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR)
                  {
-                   stmt = TREE_OPERAND (stmt, 1);
+                   stmt = GIMPLE_STMT_OPERAND (stmt, 1);
                    goto call_expr;
                  }
                break;
@@ -1306,8 +1307,9 @@ tree_estimate_probability (void)
                {
                  tree stmt = bsi_stmt (bi);
                  if ((TREE_CODE (stmt) == CALL_EXPR
-                      || (TREE_CODE (stmt) == MODIFY_EXPR
-                          && TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR))
+                      || (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+                          && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1))
+                             == CALL_EXPR))
                      /* Constant and pure calls are hardly used to signalize
                         something exceptional.  */
                      && TREE_SIDE_EFFECTS (stmt))
index 57b07ac..1ed17de 100644 (file)
@@ -263,7 +263,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
       if (indent <= 4)
        print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
     }
-  else
+  else if (!GIMPLE_TUPLE_P (node))
     {
       print_node (file, "type", TREE_TYPE (node), indent + 4);
       if (TREE_TYPE (node))
@@ -679,6 +679,18 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
       print_node (file, "chain", TREE_CHAIN (node), indent + 4);
       break;
 
+    case tcc_gimple_stmt:
+      len = TREE_CODE_LENGTH (TREE_CODE (node));
+
+      for (i = 0; i < len; i++)
+       {
+         char temp[10];
+
+         sprintf (temp, "arg %d", i);
+         print_node (file, temp, GIMPLE_STMT_OPERAND (node, i), indent + 4);
+       }
+      break;
+
     case tcc_constant:
     case tcc_exceptional:
       switch (TREE_CODE (node))
index d5a181b..819d9be 100644 (file)
@@ -1362,6 +1362,9 @@ expand_expr_stmt (tree exp)
   tree type;
 
   value = expand_expr (exp, const0_rtx, VOIDmode, 0);
+  if (GIMPLE_TUPLE_P (exp))
+    type = void_type_node;
+  else
   type = TREE_TYPE (exp);
 
   /* If all we do is reference a volatile value in memory,
@@ -1415,6 +1418,7 @@ warn_if_unused_value (tree exp, location_t locus)
     case PREDECREMENT_EXPR:
     case POSTDECREMENT_EXPR:
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
     case TARGET_EXPR:
     case CALL_EXPR:
@@ -1582,10 +1586,10 @@ expand_return (tree retval)
       expand_null_return ();
       return;
     }
-  else if ((TREE_CODE (retval) == MODIFY_EXPR
+  else if ((TREE_CODE (retval) == GIMPLE_MODIFY_STMT
            || TREE_CODE (retval) == INIT_EXPR)
-          && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
-    retval_rhs = TREE_OPERAND (retval, 1);
+          && TREE_CODE (GENERIC_TREE_OPERAND (retval, 0)) == RESULT_DECL)
+    retval_rhs = GENERIC_TREE_OPERAND (retval, 1);
   else
     retval_rhs = retval;
 
@@ -1604,7 +1608,7 @@ expand_return (tree retval)
      (and in expand_call).  */
 
   else if (retval_rhs != 0
-          && TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
+          && TYPE_MODE (GENERIC_TREE_TYPE (retval_rhs)) == BLKmode
           && REG_P (result_rtl))
     {
       int i;
index bdbff33..e4733a2 100644 (file)
@@ -314,8 +314,8 @@ factor_computed_gotos (void)
            }
 
          /* Copy the original computed goto's destination into VAR.  */
-         assignment = build2 (MODIFY_EXPR, ptr_type_node,
-                              var, GOTO_DESTINATION (last));
+         assignment = build2_gimple (GIMPLE_MODIFY_STMT,
+                                     var, GOTO_DESTINATION (last));
          bsi_insert_before (&bsi, assignment, BSI_SAME_STMT);
 
          /* And re-vector the computed goto to the new destination.  */
@@ -501,11 +501,14 @@ make_edges (void)
              break;
 
            case MODIFY_EXPR:
+             gcc_unreachable ();
+
+           case GIMPLE_MODIFY_STMT:
              if (is_ctrl_altering_stmt (last))
                {
-                 /* A MODIFY_EXPR may have a CALL_EXPR on its RHS and the
-                    CALL_EXPR may have an abnormal edge.  Search the RHS for
-                    this case and create any required edges.  */
+                 /* A GIMPLE_MODIFY_STMT may have a CALL_EXPR on its RHS and
+                    the CALL_EXPR may have an abnormal edge.  Search the RHS
+                    for this case and create any required edges.  */
                  if (tree_can_make_abnormal_goto (last))
                    make_abnormal_goto_edges (bb, true);  
 
@@ -1330,7 +1333,7 @@ tree_merge_blocks (basic_block a, basic_block b)
             with ordering of phi nodes.  This is because A is the single
             predecessor of B, therefore results of the phi nodes cannot
             appear as arguments of the phi nodes.  */
-         copy = build2 (MODIFY_EXPR, void_type_node, def, use);
+         copy = build2_gimple (GIMPLE_MODIFY_STMT, def, use);
          bsi_insert_after (&bsi, copy, BSI_NEW_STMT);
          SET_PHI_RESULT (phi, NULL_TREE);
          SSA_NAME_DEF_STMT (def) = copy;
@@ -1559,9 +1562,9 @@ remove_useless_stmts_cond (tree *stmt_p, struct rus_data *data)
       else if (TREE_CODE (cond) == VAR_DECL || TREE_CODE (cond) == PARM_DECL)
        {
          if (else_stmt
-             && TREE_CODE (else_stmt) == MODIFY_EXPR
-             && TREE_OPERAND (else_stmt, 0) == cond
-             && integer_zerop (TREE_OPERAND (else_stmt, 1)))
+             && TREE_CODE (else_stmt) == GIMPLE_MODIFY_STMT
+             && GIMPLE_STMT_OPERAND (else_stmt, 0) == cond
+             && integer_zerop (GIMPLE_STMT_OPERAND (else_stmt, 1)))
            COND_EXPR_ELSE (*stmt_p) = alloc_stmt_list ();
        }
       else if ((TREE_CODE (cond) == EQ_EXPR || TREE_CODE (cond) == NE_EXPR)
@@ -1576,9 +1579,9 @@ remove_useless_stmts_cond (tree *stmt_p, struct rus_data *data)
                            : &COND_EXPR_ELSE (*stmt_p));
 
          if (stmt
-             && TREE_CODE (stmt) == MODIFY_EXPR
-             && TREE_OPERAND (stmt, 0) == TREE_OPERAND (cond, 0)
-             && TREE_OPERAND (stmt, 1) == TREE_OPERAND (cond, 1))
+             && TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+             && GIMPLE_STMT_OPERAND (stmt, 0) == TREE_OPERAND (cond, 0)
+             && GIMPLE_STMT_OPERAND (stmt, 1) == TREE_OPERAND (cond, 1))
            *location = alloc_stmt_list ();
        }
     }
@@ -1871,6 +1874,9 @@ remove_useless_stmts_1 (tree *tp, struct rus_data *data)
       break;
 
     case MODIFY_EXPR:
+      gcc_unreachable ();
+
+    case GIMPLE_MODIFY_STMT:
       data->last_goto = NULL;
       fold_stmt (tp);
       op = get_call_expr_in (t);
@@ -2508,8 +2514,8 @@ tree_can_make_abnormal_goto (tree t)
 {
   if (computed_goto_p (t))
     return true;
-  if (TREE_CODE (t) == MODIFY_EXPR)
-    t = TREE_OPERAND (t, 1);
+  if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
+    t = GIMPLE_STMT_OPERAND (t, 1);
   if (TREE_CODE (t) == WITH_SIZE_EXPR)
     t = TREE_OPERAND (t, 0);
   if (TREE_CODE (t) == CALL_EXPR)
@@ -3011,9 +3017,9 @@ tree_find_edge_insert_loc (edge e, block_stmt_iterator *bsi,
          tree op = TREE_OPERAND (tmp, 0);
          if (op && !is_gimple_val (op))
            {
-             gcc_assert (TREE_CODE (op) == MODIFY_EXPR);
+             gcc_assert (TREE_CODE (op) == GIMPLE_MODIFY_STMT);
              bsi_insert_before (bsi, op, BSI_NEW_STMT);
-             TREE_OPERAND (tmp, 0) = TREE_OPERAND (op, 0);
+             TREE_OPERAND (tmp, 0) = GIMPLE_STMT_OPERAND (op, 0);
            }
          bsi_prev (bsi);
          return true;
@@ -3232,7 +3238,10 @@ verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
       break;
 
     case MODIFY_EXPR:
-      x = TREE_OPERAND (t, 0);
+      gcc_unreachable ();
+
+    case GIMPLE_MODIFY_STMT:
+      x = GIMPLE_STMT_OPERAND (t, 0);
       if (TREE_CODE (x) == BIT_FIELD_REF
          && is_gimple_reg (TREE_OPERAND (x, 0)))
        {
@@ -3536,6 +3545,35 @@ verify_node_sharing (tree * tp, int *walk_subtrees, void *data)
 }
 
 
+/* Helper function for verify_gimple_tuples.  */
+
+static tree
+verify_gimple_tuples_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+                        void *data ATTRIBUTE_UNUSED)
+{
+  switch (TREE_CODE (*tp))
+    {
+    case MODIFY_EXPR:
+      error ("unexpected non-tuple");
+      debug_tree (*tp);
+      gcc_unreachable ();
+      return NULL_TREE;
+
+    default:
+      return NULL_TREE;
+    }
+}
+
+/* Verify that there are no trees that should have been converted to
+   gimple tuples.  Return true if T contains a node that should have
+   been converted to a gimple tuple, but hasn't.  */
+
+static bool
+verify_gimple_tuples (tree t)
+{
+  return walk_tree (&t, verify_gimple_tuples_1, NULL, NULL) != NULL;
+}
+
 /* Verify the GIMPLE statement chain.  */
 
 void
@@ -3604,6 +3642,8 @@ verify_stmts (void)
        {
          tree stmt = bsi_stmt (bsi);
 
+         err |= verify_gimple_tuples (stmt);
+
          if (bb_for_stmt (stmt) != bb)
            {
              error ("bb_for_stmt (stmt) is set to a wrong basic block");
@@ -4570,7 +4610,8 @@ move_stmt_r (tree *tp, int *walk_subtrees, void *data)
   struct move_stmt_d *p = (struct move_stmt_d *) data;
   tree t = *tp;
 
-  if (p->block && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t))))
+  if (p->block
+      && (EXPR_P (t) || GIMPLE_STMT_P (t)))
     TREE_BLOCK (t) = p->block;
 
   if (OMP_DIRECTIVE_P (t)
@@ -5638,7 +5679,7 @@ gimplify_val (block_stmt_iterator *bsi, tree type, tree exp)
     return exp;
 
   t = make_rename_temp (type, NULL);
-  new_stmt = build2 (MODIFY_EXPR, type, t, exp);
+  new_stmt = build2_gimple (GIMPLE_MODIFY_STMT, t, exp);
 
   orig_stmt = bsi_stmt (*bsi);
   SET_EXPR_LOCUS (new_stmt, EXPR_LOCUS (orig_stmt));
index d3909ae..38b2101 100644 (file)
@@ -206,13 +206,13 @@ init_dont_simulate_again (void)
                 since it's never used as an input to another computation.  */
              dsa = true;
              stmt = TREE_OPERAND (stmt, 0);
-             if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
+             if (!stmt || TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
                break;
              /* FALLTHRU */
 
-           case MODIFY_EXPR:
-             dsa = !is_complex_reg (TREE_OPERAND (stmt, 0));
-             rhs = TREE_OPERAND (stmt, 1);
+           case GIMPLE_MODIFY_STMT:
+             dsa = !is_complex_reg (GIMPLE_STMT_OPERAND (stmt, 0));
+             rhs = GIMPLE_STMT_OPERAND (stmt, 1);
              break;
 
            case COND_EXPR:
@@ -267,11 +267,11 @@ complex_visit_stmt (tree stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
   unsigned int ver;
   tree lhs, rhs;
 
-  if (TREE_CODE (stmt) != MODIFY_EXPR)
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
     return SSA_PROP_VARYING;
 
-  lhs = TREE_OPERAND (stmt, 0);
-  rhs = TREE_OPERAND (stmt, 1);
+  lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+  rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
   /* These conditions should be satisfied due to the initial filter
      set up in init_dont_simulate_again.  */
@@ -532,7 +532,7 @@ set_component_ssa_name (tree ssa_name, bool imag_p, tree value)
   
   /* Do all the work to assign VALUE to COMP.  */
   value = force_gimple_operand (value, &list, false, NULL);
-  last = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, value);
+  last = build2_gimple (GIMPLE_MODIFY_STMT, comp, value);
   append_to_statement_list (last, &list);
 
   gcc_assert (SSA_NAME_DEF_STMT (comp) == NULL);
@@ -588,7 +588,7 @@ extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
 static void
 update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
 {
-  tree lhs = TREE_OPERAND (stmt, 0);
+  tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
   tree list;
 
   list = set_component_ssa_name (lhs, false, r);
@@ -628,8 +628,8 @@ update_complex_assignment (block_stmt_iterator *bsi, tree r, tree i)
   else if (gimple_in_ssa_p (cfun))
     update_complex_components (bsi, stmt, r, i);
   
-  type = TREE_TYPE (TREE_OPERAND (mod, 1));
-  TREE_OPERAND (mod, 1) = build2 (COMPLEX_EXPR, type, r, i);
+  type = TREE_TYPE (GIMPLE_STMT_OPERAND (mod, 1));
+  GIMPLE_STMT_OPERAND (mod, 1) = build2 (COMPLEX_EXPR, type, r, i);
   update_stmt (stmt);
 }
 
@@ -773,25 +773,24 @@ expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
       i = extract_component (bsi, rhs, 1, false);
 
       x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
-      x = build2 (MODIFY_EXPR, inner_type, x, r);
+      x = build2_gimple (GIMPLE_MODIFY_STMT, x, r);
       bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
       if (stmt == bsi_stmt (*bsi))
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
-         TREE_OPERAND (stmt, 0) = x;
-         TREE_OPERAND (stmt, 1) = i;
-         TREE_TYPE (stmt) = inner_type;
+         GIMPLE_STMT_OPERAND (stmt, 0) = x;
+         GIMPLE_STMT_OPERAND (stmt, 1) = i;
        }
       else
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
-         x = build2 (MODIFY_EXPR, inner_type, x, i);
+         x = build2_gimple (GIMPLE_MODIFY_STMT, x, i);
          bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
          stmt = bsi_stmt (*bsi);
          gcc_assert (TREE_CODE (stmt) == RETURN_EXPR);
-         TREE_OPERAND (stmt, 0) = lhs;
+         GIMPLE_STMT_OPERAND (stmt, 0) = lhs;
        }
 
       update_all_vops (stmt);
@@ -894,7 +893,7 @@ expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
   args = tree_cons (NULL, ar, args);
 
   stmt = bsi_stmt (*bsi);
-  type = TREE_TYPE (TREE_OPERAND (stmt, 1));
+  type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 1));
 
   mode = TYPE_MODE (type);
   gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
@@ -906,13 +905,13 @@ expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
     gcc_unreachable ();
   fn = built_in_decls[bcode];
 
-  TREE_OPERAND (stmt, 1)
+  GIMPLE_STMT_OPERAND (stmt, 1)
     = build3 (CALL_EXPR, type, build_fold_addr_expr (fn), args, NULL);
   update_stmt (stmt);
 
   if (gimple_in_ssa_p (cfun))
     {
-      tree lhs = TREE_OPERAND (stmt, 0);
+      tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
       type = TREE_TYPE (type);
       update_complex_components (bsi, stmt,
                                 build1 (REALPART_EXPR, type, lhs),
@@ -1122,9 +1121,9 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
 
      if (bb_true)
        {
-        t1 = build2 (MODIFY_EXPR, inner_type, rr, tr);
+        t1 = build2_gimple (GIMPLE_MODIFY_STMT, rr, tr);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
-        t1 = build2 (MODIFY_EXPR, inner_type, ri, ti);
+        t1 = build2_gimple (GIMPLE_MODIFY_STMT, ri, ti);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_remove (bsi, true);
        }
@@ -1161,9 +1160,9 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
 
      if (bb_false)
        {
-        t1 = build2 (MODIFY_EXPR, inner_type, rr, tr);
+        t1 = build2_gimple (GIMPLE_MODIFY_STMT, rr, tr);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
-        t1 = build2 (MODIFY_EXPR, inner_type, ri, ti);
+        t1 = build2_gimple (GIMPLE_MODIFY_STMT, ri, ti);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_remove (bsi, true);
        }
@@ -1307,9 +1306,9 @@ expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
     case RETURN_EXPR:
       expr = TREE_OPERAND (stmt, 0);
       /* FALLTHRU */
-    case MODIFY_EXPR:
-      type = TREE_TYPE (TREE_OPERAND (expr, 1));
-      TREE_OPERAND (expr, 1) = fold_convert (type, cc);
+    case GIMPLE_MODIFY_STMT:
+      type = TREE_TYPE (GIMPLE_STMT_OPERAND (expr, 1));
+      GIMPLE_STMT_OPERAND (expr, 1) = fold_convert (type, cc);
       break;
     case COND_EXPR:
       TREE_OPERAND (stmt, 0) = cc;
@@ -1338,12 +1337,12 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
       stmt = TREE_OPERAND (stmt, 0);
       if (!stmt)
        return;
-      if (TREE_CODE (stmt) != MODIFY_EXPR)
+      if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
        return;
       /* FALLTHRU */
 
-    case MODIFY_EXPR:
-      rhs = TREE_OPERAND (stmt, 1);
+    case GIMPLE_MODIFY_STMT:
+      rhs = GIMPLE_STMT_OPERAND (stmt, 1);
       break;
 
     case COND_EXPR:
@@ -1384,8 +1383,8 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
 
     default:
       {
-       tree lhs = TREE_OPERAND (stmt, 0);
-       tree rhs = TREE_OPERAND (stmt, 1);
+       tree lhs = GENERIC_TREE_OPERAND (stmt, 0);
+       tree rhs = GENERIC_TREE_OPERAND (stmt, 1);
 
        if (TREE_CODE (type) == COMPLEX_TYPE)
          expand_complex_move (bsi, stmt, type, lhs, rhs);
@@ -1393,7 +1392,7 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
                  || TREE_CODE (rhs) == IMAGPART_EXPR)
                 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
          {
-           TREE_OPERAND (stmt, 1)
+           GENERIC_TREE_OPERAND (stmt, 1)
              = extract_component (bsi, TREE_OPERAND (rhs, 0),
                                   TREE_CODE (rhs) == IMAGPART_EXPR, false);
            update_stmt (stmt);
index 3734058..7ed14f0 100644 (file)
@@ -4019,10 +4019,10 @@ get_references_in_stmt (tree stmt, VEC (data_ref_loc, heap) **references)
   if (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
     return clobbers_memory;
 
-  if (TREE_CODE (stmt) ==  MODIFY_EXPR)
+  if (TREE_CODE (stmt) ==  GIMPLE_MODIFY_STMT)
     {
-      op0 = &TREE_OPERAND (stmt, 0);
-      op1 = &TREE_OPERAND (stmt, 1);
+      op0 = &GIMPLE_STMT_OPERAND (stmt, 0);
+      op1 = &GIMPLE_STMT_OPERAND (stmt, 1);
                
       if (DECL_P (*op1)
          || REFERENCE_CLASS_P (*op1))
index 3330624..b2d09f4 100644 (file)
@@ -128,13 +128,13 @@ create_var_ann (tree t)
 
   gcc_assert (t);
   gcc_assert (DECL_P (t));
-  gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == VAR_ANN);
 
   ann = GGC_CNEW (struct var_ann_d);
 
   ann->common.type = VAR_ANN;
 
-  t->common.ann = (tree_ann_t) ann;
+  t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
@@ -148,14 +148,14 @@ create_function_ann (tree t)
 
   gcc_assert (t);
   gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
-  gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == FUNCTION_ANN);
 
   ann = ggc_alloc (sizeof (*ann));
   memset ((void *) ann, 0, sizeof (*ann));
 
   ann->common.type = FUNCTION_ANN;
 
-  t->common.ann = (tree_ann_t) ann;
+  t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
@@ -168,7 +168,7 @@ create_stmt_ann (tree t)
   stmt_ann_t ann;
 
   gcc_assert (is_gimple_stmt (t));
-  gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_ANN);
 
   ann = GGC_CNEW (struct stmt_ann_d);
 
@@ -177,7 +177,7 @@ create_stmt_ann (tree t)
   /* Since we just created the annotation, mark the statement modified.  */
   ann->modified = true;
 
-  t->common.ann = (tree_ann_t) ann;
+  t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
@@ -190,12 +190,12 @@ create_tree_common_ann (tree t)
   tree_ann_common_t ann;
 
   gcc_assert (t);
-  gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
+  gcc_assert (!t->base.ann || t->base.ann->common.type == TREE_ANN_COMMON);
 
   ann = GGC_CNEW (struct tree_ann_common_d);
 
   ann->type = TREE_ANN_COMMON;
-  t->common.ann = (tree_ann_t) ann;
+  t->base.ann = (tree_ann_t) ann;
 
   return ann;
 }
@@ -540,9 +540,9 @@ collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
   tree t = *tp;
   struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
 
-  if (t->common.ann)
+  if (t->base.ann)
     {
-      switch (ann_type (t->common.ann))
+      switch (ann_type (t->base.ann))
        {
        case STMT_ANN:
          {
index 8c008ab..2cea582 100644 (file)
@@ -576,6 +576,11 @@ dequeue_and_dump (dump_info_p di)
       dump_child ("op 1", TREE_OPERAND (t, 1));
       break;
 
+    case GIMPLE_MODIFY_STMT:
+      dump_child ("op 0", GIMPLE_STMT_OPERAND (t, 0));
+      dump_child ("op 1", GIMPLE_STMT_OPERAND (t, 1));
+      break;
+
     case COMPONENT_REF:
       dump_child ("op 0", TREE_OPERAND (t, 0));
       dump_child ("op 1", TREE_OPERAND (t, 1));
index 2a723b3..760cdc3 100644 (file)
@@ -115,7 +115,7 @@ add_stmt_to_eh_region_fn (struct function *ifun, tree t, int num)
   /* ??? For the benefit of calls.c, converting all this to rtl,
      we need to record the call expression, not just the outer
      modify statement.  */
-  if (TREE_CODE (t) == MODIFY_EXPR
+  if (TREE_CODE (t) == GIMPLE_MODIFY_STMT
       && (t = get_call_expr_in (t)))
     add_stmt_to_eh_region_fn (ifun, t, num);
 }
@@ -144,7 +144,7 @@ remove_stmt_from_eh_region_fn (struct function *ifun, tree t)
       /* ??? For the benefit of calls.c, converting all this to rtl,
         we need to record the call expression, not just the outer
         modify statement.  */
-      if (TREE_CODE (t) == MODIFY_EXPR
+      if (TREE_CODE (t) == GIMPLE_MODIFY_STMT
          && (t = get_call_expr_in (t)))
        remove_stmt_from_eh_region_fn (ifun, t);
       return true;
@@ -624,10 +624,10 @@ do_return_redirection (struct goto_queue_node *q, tree finlab, tree mod,
          q->cont_stmt = q->stmt;
          break;
 
-       case MODIFY_EXPR:
+       case GIMPLE_MODIFY_STMT:
          {
-           tree result = TREE_OPERAND (ret_expr, 0);
-           tree new, old = TREE_OPERAND (ret_expr, 1);
+           tree result = GIMPLE_STMT_OPERAND (ret_expr, 0);
+           tree new, old = GIMPLE_STMT_OPERAND (ret_expr, 1);
 
            if (!*return_value_p)
              {
@@ -646,13 +646,13 @@ do_return_redirection (struct goto_queue_node *q, tree finlab, tree mod,
            else
              new = *return_value_p;
 
-           x = build2 (MODIFY_EXPR, TREE_TYPE (new), new, old);
+           x = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (new), new, old);
            append_to_statement_list (x, &q->repl_stmt);
 
            if (new == result)
              x = result;
            else
-             x = build2 (MODIFY_EXPR, TREE_TYPE (result), result, new);
+             x = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (result), result, new);
            q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
          }
 
@@ -842,20 +842,20 @@ honor_protect_cleanup_actions (struct leh_state *outer_state,
 
       i = tsi_start (finally);
       x = build0 (EXC_PTR_EXPR, ptr_type_node);
-      x = build2 (MODIFY_EXPR, void_type_node, save_eptr, x);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, save_eptr, x);
       tsi_link_before (&i, x, TSI_CONTINUE_LINKING);
 
       x = build0 (FILTER_EXPR, integer_type_node);
-      x = build2 (MODIFY_EXPR, void_type_node, save_filt, x);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, save_filt, x);
       tsi_link_before (&i, x, TSI_CONTINUE_LINKING);
 
       i = tsi_last (finally);
       x = build0 (EXC_PTR_EXPR, ptr_type_node);
-      x = build2 (MODIFY_EXPR, void_type_node, x, save_eptr);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, x, save_eptr);
       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 
       x = build0 (FILTER_EXPR, integer_type_node);
-      x = build2 (MODIFY_EXPR, void_type_node, x, save_filt);
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, x, save_filt);
       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 
       x = build_resx (get_eh_region_number (tf->region));
@@ -1177,7 +1177,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
 
   if (tf->may_fallthru)
     {
-      x = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, finally_tmp,
                  build_int_cst (NULL_TREE, fallthru_index));
       append_to_statement_list (x, tf->top_p);
 
@@ -1207,7 +1207,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
       x = build1 (LABEL_EXPR, void_type_node, tf->eh_label);
       append_to_statement_list (x, tf->top_p);
 
-      x = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+      x = build2 (GIMPLE_MODIFY_STMT, void_type_node, finally_tmp,
                  build_int_cst (NULL_TREE, eh_index));
       append_to_statement_list (x, tf->top_p);
 
@@ -1239,14 +1239,14 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
 
       if (q->index < 0)
        {
-         mod = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+         mod = build2 (GIMPLE_MODIFY_STMT, void_type_node, finally_tmp,
                        build_int_cst (NULL_TREE, return_index));
          do_return_redirection (q, finally_label, mod, &return_val);
          switch_id = return_index;
        }
       else
        {
-         mod = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+         mod = build2 (GIMPLE_MODIFY_STMT, void_type_node, finally_tmp,
                        build_int_cst (NULL_TREE, q->index));
          do_goto_redirection (q, finally_label, mod);
          switch_id = q->index;
@@ -1612,7 +1612,7 @@ lower_eh_constructs_1 (struct leh_state *state, tree *tp)
        }
       break;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       /* Look for things that can throw exceptions, and record them.  */
       if (state->cur_region && tree_could_throw_p (t))
        {
@@ -1997,12 +1997,12 @@ tree_could_throw_p (tree t)
 {
   if (!flag_exceptions)
     return false;
-  if (TREE_CODE (t) == MODIFY_EXPR)
+  if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
     {
       if (flag_non_call_exceptions
-         && tree_could_trap_p (TREE_OPERAND (t, 0)))
+         && tree_could_trap_p (GIMPLE_STMT_OPERAND (t, 0)))
        return true;
-      t = TREE_OPERAND (t, 1);
+      t = GIMPLE_STMT_OPERAND (t, 1);
     }
 
   if (TREE_CODE (t) == WITH_SIZE_EXPR)
@@ -2081,7 +2081,7 @@ verify_eh_throw_stmt_node (void **slot, void *data ATTRIBUTE_UNUSED)
 {
   struct throw_stmt_node *node = (struct throw_stmt_node *)*slot;
 
-  gcc_assert (node->stmt->common.ann == NULL);
+  gcc_assert (node->stmt->base.ann == NULL);
   return 1;
 }
 
index 5040375..f19faa1 100644 (file)
@@ -194,9 +194,10 @@ var_ann (tree t)
   gcc_assert (t);
   gcc_assert (DECL_P (t));
   gcc_assert (TREE_CODE (t) != FUNCTION_DECL);
-  gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
+  gcc_assert (!t->base.ann
+             || t->base.ann->common.type == VAR_ANN);
 
-  return (var_ann_t) t->common.ann;
+  return (var_ann_t) t->base.ann;
 }
 
 /* Return the variable annotation for T, which must be a _DECL node.
@@ -215,9 +216,10 @@ function_ann (tree t)
 {
   gcc_assert (t);
   gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
-  gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
+  gcc_assert (!t->base.ann
+             || t->base.ann->common.type == FUNCTION_ANN);
 
-  return (function_ann_t) t->common.ann;
+  return (function_ann_t) t->base.ann;
 }
 
 /* Return the function annotation for T, which must be a FUNCTION_DECL node.
@@ -226,7 +228,7 @@ static inline function_ann_t
 get_function_ann (tree var)
 {
   function_ann_t ann = function_ann (var);
-  gcc_assert (!var->common.ann || var->common.ann->common.type == FUNCTION_ANN);
+  gcc_assert (!var->base.ann || var->base.ann->common.type == FUNCTION_ANN);
   return (ann) ? ann : create_function_ann (var);
 }
 
@@ -238,7 +240,7 @@ has_stmt_ann (tree t)
 #ifdef ENABLE_CHECKING
   gcc_assert (is_gimple_stmt (t));
 #endif
-  return t->common.ann && t->common.ann->common.type == STMT_ANN;
+  return t->base.ann && t->base.ann->common.type == STMT_ANN;
 }
 
 /* Return the statement annotation for T, which must be a statement
@@ -249,8 +251,8 @@ stmt_ann (tree t)
 #ifdef ENABLE_CHECKING
   gcc_assert (is_gimple_stmt (t));
 #endif
-  gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
-  return (stmt_ann_t) t->common.ann;
+  gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_ANN);
+  return (stmt_ann_t) t->base.ann;
 }
 
 /* Return the statement annotation for T, which must be a statement
@@ -868,7 +870,7 @@ mark_non_addressable (tree var)
 static inline tree_ann_common_t
 tree_common_ann (tree t)
 {
-  return &t->common.ann->common;
+  return &t->base.ann->common;
 }
 
 /* Return a common annotation for T.  Create the constant annotation if it
index 3be370c..bee5cd9 100644 (file)
@@ -156,7 +156,7 @@ struct ptr_info_def GTY(())
 
 
 /*---------------------------------------------------------------------------
-                  Tree annotations stored in tree_common.ann
+                  Tree annotations stored in tree_base.ann
 ---------------------------------------------------------------------------*/
 enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, FUNCTION_ANN, STMT_ANN };
 
index 3dab75d..eda4541 100644 (file)
@@ -87,7 +87,7 @@ is_gimple_formal_tmp_rhs (tree t)
 bool
 is_gimple_reg_rhs (tree t)
 {
-  /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
+  /* If the RHS of the GIMPLE_MODIFY_STMT may throw or make a nonlocal goto
      and the LHS is a user variable, then we need to introduce a formal
      temporary.  This way the optimizers can determine that the user
      variable is only modified if evaluation of the RHS does not throw.
@@ -233,7 +233,7 @@ is_gimple_stmt (tree t)
       return true;
 
     case CALL_EXPR:
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       /* These are valid regardless of their type.  */
       return true;
 
@@ -427,8 +427,10 @@ is_gimple_call_addr (tree t)
 tree
 get_call_expr_in (tree t)
 {
-  if (TREE_CODE (t) == MODIFY_EXPR)
-    t = TREE_OPERAND (t, 1);
+  /* FIXME tuples: delete the assertion below when conversion complete.  */
+  gcc_assert (TREE_CODE (t) != MODIFY_EXPR);
+  if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
+    t = GIMPLE_STMT_OPERAND (t, 1);
   if (TREE_CODE (t) == WITH_SIZE_EXPR)
     t = TREE_OPERAND (t, 0);
   if (TREE_CODE (t) == CALL_EXPR)
@@ -473,7 +475,7 @@ recalculate_side_effects (tree t)
       switch (code)
        {
        case INIT_EXPR:
-       case MODIFY_EXPR:
+       case GIMPLE_MODIFY_STMT:
        case VA_ARG_EXPR:
        case PREDECREMENT_EXPR:
        case PREINCREMENT_EXPR:
index 7ccb48c..2f30435 100644 (file)
@@ -108,7 +108,8 @@ static tree tree_if_convert_stmt (struct loop *loop, tree, tree,
 static void tree_if_convert_cond_expr (struct loop *, tree, tree,
                                       block_stmt_iterator *);
 static bool if_convertible_phi_p (struct loop *, basic_block, tree);
-static bool if_convertible_modify_expr_p (struct loop *, basic_block, tree);
+static bool if_convertible_gimple_modify_stmt_p (struct loop *, basic_block,
+                                                tree);
 static bool if_convertible_stmt_p (struct loop *, basic_block, tree);
 static bool if_convertible_bb_p (struct loop *, basic_block, basic_block);
 static bool if_convertible_loop_p (struct loop *, bool);
@@ -119,7 +120,7 @@ static void clean_predicate_lists (struct loop *loop);
 static basic_block find_phi_replacement_condition (struct loop *loop,
                                                   basic_block, tree *,
                                                   block_stmt_iterator *);
-static void replace_phi_with_cond_modify_expr (tree, tree, basic_block,
+static void replace_phi_with_cond_gimple_modify_stmt (tree, tree, basic_block,
                                                block_stmt_iterator *);
 static void process_phi_nodes (struct loop *);
 static void combine_blocks (struct loop *);
@@ -209,7 +210,7 @@ tree_if_conversion (struct loop *loop, bool for_vectorizer)
 }
 
 /* if-convert stmt T which is part of LOOP.
-   If T is a MODIFY_EXPR than it is converted into conditional modify
+   If T is a GIMPLE_MODIFY_STMT than it is converted into conditional modify
    expression using COND.  For conditional expressions, add condition in the
    destination basic block's predicate list and remove conditional
    expression itself. BSI is the iterator used to traverse statements of
@@ -232,12 +233,12 @@ tree_if_convert_stmt (struct loop *  loop, tree t, tree cond,
     case LABEL_EXPR:
       break;
 
-    case MODIFY_EXPR:
-      /* This modify_expr is killing previous value of LHS. Appropriate value will
-        be selected by PHI node based on condition. It is possible that before
-        this transformation, PHI nodes was selecting default value and now it will
-        use this new value. This is OK because it does not change validity the
-        program.  */
+    case GIMPLE_MODIFY_STMT:
+      /* This GIMPLE_MODIFY_STMT is killing previous value of LHS. Appropriate
+        value will be selected by PHI node based on condition. It is possible
+        that before this transformation, PHI nodes was selecting default
+        value and now it will use this new value. This is OK because it does 
+        not change validity the program.  */
       break;
 
     case COND_EXPR:
@@ -334,15 +335,16 @@ if_convertible_phi_p (struct loop *loop, basic_block bb, tree phi)
 }
 
 /* Return true, if M_EXPR is if-convertible.
-   MODIFY_EXPR is not if-convertible if,
+   GIMPLE_MODIFY_STMT is not if-convertible if,
    - It is not movable.
    - It could trap.
    - LHS is not var decl.
-  MODIFY_EXPR is part of block BB, which is inside loop LOOP.
+  GIMPLE_MODIFY_STMT is part of block BB, which is inside loop LOOP.
 */
 
 static bool
-if_convertible_modify_expr_p (struct loop *loop, basic_block bb, tree m_expr)
+if_convertible_gimple_modify_stmt_p (struct loop *loop, basic_block bb,
+                                    tree m_expr)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
@@ -360,21 +362,21 @@ if_convertible_modify_expr_p (struct loop *loop, basic_block bb, tree m_expr)
 
   /* See if it needs speculative loading or not.  */
   if (bb != loop->header
-      && tree_could_trap_p (TREE_OPERAND (m_expr, 1)))
+      && tree_could_trap_p (GIMPLE_STMT_OPERAND (m_expr, 1)))
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
        fprintf (dump_file, "tree could trap...\n");
       return false;
     }
 
-  if (TREE_CODE (TREE_OPERAND (m_expr, 1)) == CALL_EXPR)
+  if (TREE_CODE (GIMPLE_STMT_OPERAND (m_expr, 1)) == CALL_EXPR)
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
        fprintf (dump_file, "CALL_EXPR \n");
       return false;
     }
 
-  if (TREE_CODE (TREE_OPERAND (m_expr, 0)) != SSA_NAME
+  if (TREE_CODE (GIMPLE_STMT_OPERAND (m_expr, 0)) != SSA_NAME
       && bb != loop->header
       && !bb_with_exit_edge_p (loop, bb))
     {
@@ -392,7 +394,7 @@ if_convertible_modify_expr_p (struct loop *loop, basic_block bb, tree m_expr)
 
 /* Return true, iff STMT is if-convertible.
    Statement is if-convertible if,
-   - It is if-convertible MODIFY_EXPR
+   - It is if-convertible GIMPLE_MODIFY_STMT
    - IT is LABEL_EXPR or COND_EXPR.
    STMT is inside block BB, which is inside loop LOOP.  */
 
@@ -404,9 +406,9 @@ if_convertible_stmt_p (struct loop *loop, basic_block bb, tree stmt)
     case LABEL_EXPR:
       break;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
 
-      if (!if_convertible_modify_expr_p (loop, bb, stmt))
+      if (!if_convertible_gimple_modify_stmt_p (loop, bb, stmt))
        return false;
       break;
 
@@ -634,7 +636,7 @@ add_to_dst_predicate_list (struct loop * loop, basic_block bb,
                    unshare_expr (prev_cond), cond);
       tmp_stmt = ifc_temp_var (boolean_type_node, tmp);
       bsi_insert_before (bsi, tmp_stmt, BSI_SAME_STMT);
-      new_cond = TREE_OPERAND (tmp_stmt, 0);
+      new_cond = GIMPLE_STMT_OPERAND (tmp_stmt, 0);
     }
   add_to_predicate_list (bb, new_cond);
   return new_cond;
@@ -741,7 +743,7 @@ find_phi_replacement_condition (struct loop *loop,
 
       new_stmt = ifc_temp_var (TREE_TYPE (*cond), unshare_expr (*cond));
       bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
-      *cond = TREE_OPERAND (new_stmt, 0);
+      *cond = GIMPLE_STMT_OPERAND (new_stmt, 0);
     }
 
   gcc_assert (*cond);
@@ -761,8 +763,9 @@ find_phi_replacement_condition (struct loop *loop,
 */
 
 static void
-replace_phi_with_cond_modify_expr (tree phi, tree cond, basic_block true_bb,
-                                   block_stmt_iterator *bsi)
+replace_phi_with_cond_gimple_modify_stmt (tree phi, tree cond,
+                                         basic_block true_bb,
+                                         block_stmt_iterator *bsi)
 {
   tree new_stmt;
   basic_block bb;
@@ -799,7 +802,7 @@ replace_phi_with_cond_modify_expr (tree phi, tree cond, basic_block true_bb,
                unshare_expr (arg_1));
 
   /* Create new MODIFY expression using RHS.  */
-  new_stmt = build2 (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
+  new_stmt = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (PHI_RESULT (phi)),
                     unshare_expr (PHI_RESULT (phi)), rhs);
 
   /* Make new statement definition of the original phi result.  */
@@ -848,7 +851,7 @@ process_phi_nodes (struct loop *loop)
       while (phi)
        {
          tree next = PHI_CHAIN (phi);
-         replace_phi_with_cond_modify_expr (phi, cond, true_bb, &bsi);
+         replace_phi_with_cond_gimple_modify_stmt (phi, cond, true_bb, &bsi);
          release_phi_node (phi);
          phi = next;
        }
@@ -963,7 +966,7 @@ combine_blocks (struct loop *loop)
     merge_blocks (loop->header, exit_bb);
 }
 
-/* Make new  temp variable of type TYPE. Add MODIFY_EXPR to assign EXP
+/* Make new  temp variable of type TYPE. Add GIMPLE_MODIFY_STMT to assign EXP
    to the new variable.  */
 
 static tree
@@ -980,12 +983,12 @@ ifc_temp_var (tree type, tree exp)
   add_referenced_var (var);
 
   /* Build new statement to assign EXP to new variable.  */
-  stmt = build2 (MODIFY_EXPR, type, var, exp);
+  stmt = build2 (GIMPLE_MODIFY_STMT, type, var, exp);
 
   /* Get SSA name for the new variable and set make new statement
      its definition statement.  */
   new_name = make_ssa_name (var, stmt);
-  TREE_OPERAND (stmt, 0) = new_name;
+  GIMPLE_STMT_OPERAND (stmt, 0) = new_name;
   SSA_NAME_DEF_STMT (new_name) = stmt;
 
   return stmt;
index 4b1c709..429cc2c 100644 (file)
@@ -58,7 +58,7 @@ Boston, MA 02110-1301, USA.  */
 
    Inlining: a function body is duplicated, but the PARM_DECLs are
    remapped into VAR_DECLs, and non-void RETURN_EXPRs become
-   MODIFY_EXPRs that store to a dedicated returned-value variable.
+   GIMPLE_MODIFY_STMTs that store to a dedicated returned-value variable.
    The duplicated eh_region info of the copy will later be appended
    to the info for the caller; the eh_region info in copied throwing
    statements and RESX_EXPRs is adjusted accordingly.
@@ -476,7 +476,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
      duplicated and/or tweaked.  */
 
   /* When requested, RETURN_EXPRs should be transformed to just the
-     contained MODIFY_EXPR.  The branch semantics of the return will
+     contained GIMPLE_MODIFY_STMT.  The branch semantics of the return will
      be handled elsewhere by manipulating the CFG rather than a statement.  */
   if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
     {
@@ -487,10 +487,10 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
         If the "assignment" is just the result decl, the result
         decl has already been set (e.g. a recent "foo (&result_decl,
         ...)"); just toss the entire RETURN_EXPR.  */
-      if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
+      if (assignment && TREE_CODE (assignment) == GIMPLE_MODIFY_STMT)
        {
          /* Replace the RETURN_EXPR with (a copy of) the
-            MODIFY_EXPR hanging underneath.  */
+            GIMPLE_MODIFY_STMT hanging underneath.  */
          *tp = copy_node (assignment);
        }
       else /* Else the RETURN_EXPR returns no value.  */
@@ -557,15 +557,15 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
       /* Here we handle trees that are not completely rewritten.
         First we detect some inlining-induced bogosities for
         discarding.  */
-      if (TREE_CODE (*tp) == MODIFY_EXPR
-         && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
+      if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT
+         && GIMPLE_STMT_OPERAND (*tp, 0) == GIMPLE_STMT_OPERAND (*tp, 1)
          && (lang_hooks.tree_inlining.auto_var_in_fn_p
-             (TREE_OPERAND (*tp, 0), fn)))
+             (GIMPLE_STMT_OPERAND (*tp, 0), fn)))
        {
          /* Some assignments VAR = VAR; don't generate any rtl code
             and thus don't count as variable modification.  Avoid
             keeping bogosities like 0 = 0.  */
-         tree decl = TREE_OPERAND (*tp, 0), value;
+         tree decl = GIMPLE_STMT_OPERAND (*tp, 0), value;
          splay_tree_node n;
 
          n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
@@ -624,7 +624,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
       /* If EXPR has block defined, map it to newly constructed block.
          When inlining we want EXPRs without block appear in the block
         of function call.  */
-      if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (*tp))))
+      if (EXPR_P (*tp) || GIMPLE_STMT_P (*tp))
        {
          new_block = id->block;
          if (TREE_BLOCK (*tp))
@@ -644,7 +644,8 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
            (NULL_TREE,
             id->eh_region_offset + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0)));
 
-      TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
+      if (!GIMPLE_TUPLE_P (*tp))
+       TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
 
       /* The copied TARGET_EXPR has never been expanded, even if the
         original node was expanded already.  */
@@ -708,9 +709,9 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, int count_scal
 
          /* With return slot optimization we can end up with
             non-gimple (foo *)&this->m, fix that here.  */
-         if (TREE_CODE (stmt) == MODIFY_EXPR
-             && TREE_CODE (TREE_OPERAND (stmt, 1)) == NOP_EXPR
-             && !is_gimple_val (TREE_OPERAND (TREE_OPERAND (stmt, 1), 0)))
+         if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+             && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == NOP_EXPR
+             && !is_gimple_val (TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0)))
            gimplify_stmt (&stmt);
 
           bsi_insert_after (&copy_bsi, stmt, BSI_NEW_STMT);
@@ -1093,9 +1094,9 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
 
       STRIP_USELESS_TYPE_CONVERSION (rhs);
 
-      /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
+      /* We want to use GIMPLE_MODIFY_STMT, not INIT_EXPR here so that we
         keep our trees in gimple form.  */
-      init_stmt = build2 (MODIFY_EXPR, TREE_TYPE (var), var, rhs);
+      init_stmt = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (var), var, rhs);
 
       /* If we did not create a gimple value and we did not create a gimple
         cast of a gimple value, then we will need to gimplify INIT_STMTS
@@ -1167,7 +1168,7 @@ initialize_inlined_parameters (copy_body_data *id, tree args, tree static_chain,
 
    RETURN_SLOT_ADDR, if non-null, was a fake parameter that
    took the address of the result.  MODIFY_DEST, if non-null, was the LHS of
-   the MODIFY_EXPR to which this call is the RHS.
+   the GIMPLE_MODIFY_STMT to which this call is the RHS.
 
    The return value is a (possibly null) value that is the result of the
    function as seen by the callee.  *USE_P is a (possibly null) value that
@@ -1657,30 +1658,32 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
        3) TARGET_EXPRs.
 
        Let us look at the first two cases, assuming we have "a = b + C":
-       <modify_expr <var_decl "a"> <plus_expr <var_decl "b"> <constant C>>
+       <GIMPLE_MODIFY_STMT <var_decl "a">
+                                  <plus_expr <var_decl "b"> <constant C>>
        If "a" is a GIMPLE register, the assignment to it is free on almost
        any target, because "a" usually ends up in a real register.  Hence
        the only cost of this expression comes from the PLUS_EXPR, and we
-       can ignore the MODIFY_EXPR.
+       can ignore the GIMPLE_MODIFY_STMT.
        If "a" is not a GIMPLE register, the assignment to "a" will most
-       likely be a real store, so the cost of the MODIFY_EXPR is the cost
+       likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost
        of moving something into "a", which we compute using the function
        estimate_move_cost.
 
        The third case deals with TARGET_EXPRs, for which the semantics are
        that a temporary is assigned, unless the TARGET_EXPR itself is being
        assigned to something else.  In the latter case we do not need the
-       temporary.  E.g. in <modify_expr <var_decl "a"> <target_expr>>, the
-       MODIFY_EXPR is free.  */
+       temporary.  E.g. in:
+                       <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the
+       GIMPLE_MODIFY_STMT is free.  */
     case INIT_EXPR:
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       /* Is the right and side a TARGET_EXPR?  */
-      if (TREE_CODE (TREE_OPERAND (x, 1)) == TARGET_EXPR)
+      if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
        break;
       /* ... fall through ...  */
 
     case TARGET_EXPR:
-      x = TREE_OPERAND (x, 0);
+      x = GENERIC_TREE_OPERAND (x, 0);
       /* Is this an assignments to a register?  */
       if (is_gimple_reg (x))
        break;
@@ -2100,9 +2103,9 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
 
   /* Find the lhs to which the result of this call is assigned.  */
   return_slot_addr = NULL;
-  if (TREE_CODE (stmt) == MODIFY_EXPR)
+  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
     {
-      modify_dest = TREE_OPERAND (stmt, 0);
+      modify_dest = GIMPLE_STMT_OPERAND (stmt, 0);
 
       /* The function which we are inlining might not return a value,
         in which case we should issue a warning that the function
@@ -2189,7 +2192,7 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
 
 /* Expand call statements reachable from STMT_P.
    We can only have CALL_EXPRs as the "toplevel" tree code or nested
-   in a MODIFY_EXPR.  See tree-gimple.c:get_call_expr_in().  We can
+   in a GIMPLE_MODIFY_STMT.  See tree-gimple.c:get_call_expr_in().  We can
    unfortunately not use that function here because we need a pointer
    to the CALL_EXPR, not the tree itself.  */
 
@@ -2205,8 +2208,8 @@ gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
       tree *expr_p = bsi_stmt_ptr (bsi);
       tree stmt = *expr_p;
 
-      if (TREE_CODE (*expr_p) == MODIFY_EXPR)
-       expr_p = &TREE_OPERAND (*expr_p, 1);
+      if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT)
+       expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1);
       if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
        expr_p = &TREE_OPERAND (*expr_p, 0);
       if (TREE_CODE (*expr_p) == CALL_EXPR)
@@ -2320,9 +2323,11 @@ tree
 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
 {
   enum tree_code code = TREE_CODE (*tp);
+  enum tree_code_class cl = TREE_CODE_CLASS (code);
 
   /* We make copies of most nodes.  */
-  if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
+  if (IS_EXPR_CODE_CLASS (cl)
+      || IS_GIMPLE_STMT_CODE_CLASS (cl)
       || code == TREE_LIST
       || code == TREE_VEC
       || code == TYPE_DECL
@@ -2330,8 +2335,10 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
     {
       /* Because the chain gets clobbered when we make a copy, we save it
         here.  */
-      tree chain = TREE_CHAIN (*tp);
-      tree new;
+      tree chain = NULL_TREE, new;
+
+      if (!GIMPLE_TUPLE_P (*tp))
+       chain = TREE_CHAIN (*tp);
 
       /* Copy the node.  */
       new = copy_node (*tp);
index 3fb2c53..90f3dd3 100644 (file)
@@ -245,7 +245,7 @@ enum rewrite_mode {
    processed from those that only need to have their defs processed.
    Statements that define new SSA names only need to have their defs
    registered, but they don't need to have their uses renamed.  */
-#define REGISTER_DEFS_IN_THIS_STMT(T)  (T)->common.unsigned_flag
+#define REGISTER_DEFS_IN_THIS_STMT(T)  (T)->base.unsigned_flag
 
 
 /* Prototypes for debugging functions.  */
index 54cedb8..4d80c19 100644 (file)
@@ -458,13 +458,13 @@ mf_decl_cache_locals (void)
 
   /* Build initialization nodes for the cache vars.  We just load the
      globals into the cache variables.  */
-  t = build2 (MODIFY_EXPR, TREE_TYPE (mf_cache_shift_decl_l),
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (mf_cache_shift_decl_l),
               mf_cache_shift_decl_l, mf_cache_shift_decl);
   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
   gimplify_to_stmt_list (&t);
   shift_init_stmts = t;
 
-  t = build2 (MODIFY_EXPR, TREE_TYPE (mf_cache_mask_decl_l),
+  t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (mf_cache_mask_decl_l),
               mf_cache_mask_decl_l, mf_cache_mask_decl);
   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
   gimplify_to_stmt_list (&t);
@@ -553,7 +553,7 @@ mf_build_check_statement_for (tree base, tree limit,
   mf_limit = create_tmp_var (mf_uintptr_type, "__mf_limit");
 
   /* Build: __mf_base = (uintptr_t) <base address expression>.  */
-  t = build2 (MODIFY_EXPR, void_type_node, mf_base,
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, mf_base,
               convert (mf_uintptr_type, unshare_expr (base)));
   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
@@ -561,7 +561,7 @@ mf_build_check_statement_for (tree base, tree limit,
   tsi = tsi_last (t);
 
   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */
-  t = build2 (MODIFY_EXPR, void_type_node, mf_limit,
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, mf_limit,
               convert (mf_uintptr_type, unshare_expr (limit)));
   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
@@ -577,7 +577,7 @@ mf_build_check_statement_for (tree base, tree limit,
               TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
               mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
   t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
-  t = build2 (MODIFY_EXPR, void_type_node, mf_elem, t);
+  t = build2 (GIMPLE_MODIFY_STMT, void_type_node, mf_elem, t);
   SET_EXPR_LOCUS (t, locus);
   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
@@ -623,7 +623,7 @@ mf_build_check_statement_for (tree base, tree limit,
      can use as the condition for the conditional jump.  */
   t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);
   cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");
-  t = build2 (MODIFY_EXPR, boolean_type_node, cond, t);
+  t = build2 (GIMPLE_MODIFY_STMT, boolean_type_node, cond, t);
   gimplify_to_stmt_list (&t);
   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
@@ -676,11 +676,11 @@ mf_build_check_statement_for (tree base, tree limit,
 
   if (! flag_mudflap_threads)
     {
-      t = build2 (MODIFY_EXPR, void_type_node,
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node,
                   mf_cache_shift_decl_l, mf_cache_shift_decl);
       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 
-      t = build2 (MODIFY_EXPR, void_type_node,
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node,
                   mf_cache_mask_decl_l, mf_cache_mask_decl);
       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
     }
@@ -912,18 +912,19 @@ mf_xform_derefs (void)
           /* Only a few GIMPLE statements can reference memory.  */
           switch (TREE_CODE (s))
             {
-            case MODIFY_EXPR:
-              mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
-                                 integer_one_node);
-              mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 1), EXPR_LOCUS (s),
-                                 integer_zero_node);
+            case GIMPLE_MODIFY_STMT:
+              mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND (s, 0),
+                                EXPR_LOCUS (s), integer_one_node);
+              mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND (s, 1),
+                                EXPR_LOCUS (s), integer_zero_node);
               break;
 
             case RETURN_EXPR:
               if (TREE_OPERAND (s, 0) != NULL_TREE)
                 {
-                  if (TREE_CODE (TREE_OPERAND (s, 0)) == MODIFY_EXPR)
-                    mf_xform_derefs_1 (&i, &TREE_OPERAND (TREE_OPERAND (s, 0), 1),
+                  if (TREE_CODE (TREE_OPERAND (s, 0)) == GIMPLE_MODIFY_STMT)
+                    mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND
+                                            (TREE_OPERAND (s, 0), 1),
                                        EXPR_LOCUS (s), integer_zero_node);
                   else
                     mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
index 7467dca..ed4a1ae 100644 (file)
@@ -388,7 +388,7 @@ init_tmp_var (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
   tree t, stmt;
 
   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
-  stmt = build2 (MODIFY_EXPR, TREE_TYPE (t), t, exp);
+  stmt = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (t), t, exp);
   SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
   tsi_link_before (tsi, stmt, TSI_SAME_STMT);
 
@@ -416,7 +416,7 @@ save_tmp_var (struct nesting_info *info, tree exp,
   tree t, stmt;
 
   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
-  stmt = build2 (MODIFY_EXPR, TREE_TYPE (t), exp, t);
+  stmt = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (t), exp, t);
   SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
   tsi_link_after (tsi, stmt, TSI_SAME_STMT);
 
@@ -613,16 +613,16 @@ walk_stmts (struct walk_stmt_info *wi, tree *tp)
       walk_stmts (wi, &TREE_OPERAND (t, 0));
       break;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       /* A formal temporary lhs may use a COMPONENT_REF rhs.  */
-      wi->val_only = !is_gimple_formal_tmp_var (TREE_OPERAND (t, 0));
-      walk_tree (&TREE_OPERAND (t, 1), wi->callback, wi, NULL);
+      wi->val_only = !is_gimple_formal_tmp_var (GIMPLE_STMT_OPERAND (t, 0));
+      walk_tree (&GIMPLE_STMT_OPERAND (t, 1), wi->callback, wi, NULL);
 
       /* If the rhs is appropriate for a memory, we may use a
         COMPONENT_REF on the lhs.  */
-      wi->val_only = !is_gimple_mem_rhs (TREE_OPERAND (t, 1));
+      wi->val_only = !is_gimple_mem_rhs (GIMPLE_STMT_OPERAND (t, 1));
       wi->is_lhs = true;
-      walk_tree (&TREE_OPERAND (t, 0), wi->callback, wi, NULL);
+      walk_tree (&GIMPLE_STMT_OPERAND (t, 0), wi->callback, wi, NULL);
 
       wi->val_only = true;
       wi->is_lhs = false;
@@ -1648,7 +1648,7 @@ convert_call_expr (tree *tp, int *walk_subtrees, void *data)
       break;
 
     case RETURN_EXPR:
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case WITH_SIZE_EXPR:
       /* Only return modify and with_size_expr may contain calls.  */
       *walk_subtrees = 1;
@@ -1770,7 +1770,7 @@ finalize_nesting_tree_1 (struct nesting_info *root)
 
          y = build3 (COMPONENT_REF, TREE_TYPE (field),
                      root->frame_decl, field, NULL_TREE);
-         x = build2 (MODIFY_EXPR, TREE_TYPE (field), y, x);
+         x = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (field), y, x);
          append_to_statement_list (x, &stmt_list);
        }
     }
@@ -1781,7 +1781,7 @@ finalize_nesting_tree_1 (struct nesting_info *root)
     {
       tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
                       root->frame_decl, root->chain_field, NULL_TREE);
-      x = build2 (MODIFY_EXPR, TREE_TYPE (x), x, get_chain_decl (root));
+      x = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (x), x, get_chain_decl (root));
       append_to_statement_list (x, &stmt_list);
     }
 
index f51afdb..c33ff0e 100644 (file)
@@ -133,10 +133,10 @@ tree_nrv (void)
              if (ret_expr)
                gcc_assert (ret_expr == result);
            }
-         else if (TREE_CODE (stmt) == MODIFY_EXPR
-                  && TREE_OPERAND (stmt, 0) == result)
+         else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+                  && GIMPLE_STMT_OPERAND (stmt, 0) == result)
            {
-             ret_expr = TREE_OPERAND (stmt, 1);
+             ret_expr = GIMPLE_STMT_OPERAND (stmt, 1);
 
              /* Now verify that this return statement uses the same value
                 as any previously encountered return statement.  */
@@ -197,9 +197,9 @@ tree_nrv (void)
        {
          tree *tp = bsi_stmt_ptr (bsi);
          /* If this is a copy from VAR to RESULT, remove it.  */
-         if (TREE_CODE (*tp) == MODIFY_EXPR
-             && TREE_OPERAND (*tp, 0) == result
-             && TREE_OPERAND (*tp, 1) == found)
+         if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT
+             && GIMPLE_STMT_OPERAND (*tp, 0) == result
+             && GIMPLE_STMT_OPERAND (*tp, 1) == found)
            bsi_remove (&bsi, true);
          else
            {
@@ -264,7 +264,7 @@ dest_safe_for_nrv_p (tree dest)
     }
 }
 
-/* Walk through the function looking for MODIFY_EXPRs with calls that
+/* Walk through the function looking for GIMPLE_MODIFY_STMTs with calls that
    return in memory on the RHS.  For each of these, determine whether it is
    safe to pass the address of the LHS as the return slot, and mark the
    call appropriately if so.
@@ -289,15 +289,15 @@ execute_return_slot_opt (void)
          tree stmt = bsi_stmt (i);
          tree call;
 
-         if (TREE_CODE (stmt) == MODIFY_EXPR
-             && (call = TREE_OPERAND (stmt, 1),
+         if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+             && (call = GIMPLE_STMT_OPERAND (stmt, 1),
                  TREE_CODE (call) == CALL_EXPR)
              && !CALL_EXPR_RETURN_SLOT_OPT (call)
              && aggregate_value_p (call, call))
            /* Check if the location being assigned to is
               call-clobbered.  */
            CALL_EXPR_RETURN_SLOT_OPT (call) =
-             dest_safe_for_nrv_p (TREE_OPERAND (stmt, 0)) ? 1 : 0;
+             dest_safe_for_nrv_p (GIMPLE_STMT_OPERAND (stmt, 0)) ? 1 : 0;
        }
     }
   return 0;
index 7a3d775..7ae87d6 100644 (file)
@@ -688,13 +688,13 @@ collect_object_sizes_for (struct object_size_info *osi, tree var)
   switch (TREE_CODE (stmt))
     {
     case RETURN_EXPR:
-      gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
+      gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT);
       stmt = TREE_OPERAND (stmt, 0);
       /* FALLTHRU  */
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
-       tree rhs = TREE_OPERAND (stmt, 1), arg;
+       tree rhs = GIMPLE_STMT_OPERAND (stmt, 1), arg;
        STRIP_NOPS (rhs);
 
        if (TREE_CODE (rhs) == CALL_EXPR)
@@ -814,13 +814,13 @@ check_for_plus_in_loops_1 (struct object_size_info *osi, tree var,
   switch (TREE_CODE (stmt))
     {
     case RETURN_EXPR:
-      gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
+      gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT);
       stmt = TREE_OPERAND (stmt, 0);
       /* FALLTHRU  */
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
-       tree rhs = TREE_OPERAND (stmt, 1), arg;
+       tree rhs = GIMPLE_STMT_OPERAND (stmt, 1), arg;
        STRIP_NOPS (rhs);
 
        if (TREE_CODE (rhs) == CALL_EXPR)
@@ -892,13 +892,13 @@ check_for_plus_in_loops (struct object_size_info *osi, tree var)
   switch (TREE_CODE (stmt))
     {
     case RETURN_EXPR:
-      gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR);
+      gcc_assert (TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT);
       stmt = TREE_OPERAND (stmt, 0);
       /* FALLTHRU  */
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       {
-       tree rhs = TREE_OPERAND (stmt, 1), arg;
+       tree rhs = GIMPLE_STMT_OPERAND (stmt, 1), arg;
        STRIP_NOPS (rhs);
 
        if (TREE_CODE (rhs) == CALL_EXPR)
index 50dd22b..9e4af19 100644 (file)
@@ -206,8 +206,8 @@ execute_free_cfg_annotations (void)
     for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
       {
        tree stmt = bsi_stmt (bsi);
-       ggc_free (stmt->common.ann);
-       stmt->common.ann = NULL;
+       ggc_free (stmt->base.ann);
+       stmt->base.ann = NULL;
       }
 
   /* And get rid of annotations we no longer need.  */
index 3a7d017..279934d 100644 (file)
@@ -188,7 +188,7 @@ insert_copy_on_edge (edge e, tree dest, tree src)
 {
   tree copy;
 
-  copy = build2 (MODIFY_EXPR, TREE_TYPE (dest), dest, src);
+  copy = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (dest), dest, src);
   set_is_used (dest);
 
   if (TREE_CODE (src) == ADDR_EXPR)
@@ -1026,10 +1026,10 @@ replace_use_variable (var_map map, use_operand_p p, tree *expr)
       int version = SSA_NAME_VERSION (var);
       if (expr[version])
         {
-         tree new_expr = TREE_OPERAND (expr[version], 1);
+         tree new_expr = GIMPLE_STMT_OPERAND (expr[version], 1);
          SET_USE (p, new_expr);
          /* Clear the stmt's RHS, or GC might bite us.  */
-         TREE_OPERAND (expr[version], 1) = NULL_TREE;
+         GIMPLE_STMT_OPERAND (expr[version], 1) = NULL_TREE;
          return true;
        }
     }
@@ -1437,7 +1437,7 @@ check_replaceable (temp_expr_table_p tab, tree stmt)
   tree call_expr;
   bitmap def_vars, use_vars;
 
-  if (TREE_CODE (stmt) != MODIFY_EXPR)
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
     return false;
   
   /* Punt if there is more than 1 def, or more than 1 use.  */
@@ -1453,7 +1453,8 @@ check_replaceable (temp_expr_table_p tab, tree stmt)
     return false;
 
   /* Float expressions must go through memory if float-store is on.  */
-  if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (stmt, 1))))
+  if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE
+                                       (GENERIC_TREE_OPERAND (stmt, 1))))
     return false;
 
   /* Calls to functions with side-effects cannot be replaced.  */
@@ -1793,8 +1794,8 @@ rewrite_trees (var_map map, tree *values)
          ann = stmt_ann (stmt);
          changed = false;
 
-         if (TREE_CODE (stmt) == MODIFY_EXPR 
-             && (TREE_CODE (TREE_OPERAND (stmt, 1)) == SSA_NAME))
+         if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT 
+             && (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == SSA_NAME))
            is_copy = true;
 
          copy_use_p = NULL_USE_OPERAND_P;
@@ -1877,17 +1878,17 @@ static inline bool
 identical_copies_p (tree s1, tree s2)
 {
 #ifdef ENABLE_CHECKING
-  gcc_assert (TREE_CODE (s1) == MODIFY_EXPR);
-  gcc_assert (TREE_CODE (s2) == MODIFY_EXPR);
-  gcc_assert (DECL_P (TREE_OPERAND (s1, 0)));
-  gcc_assert (DECL_P (TREE_OPERAND (s2, 0)));
+  gcc_assert (TREE_CODE (s1) == GIMPLE_MODIFY_STMT);
+  gcc_assert (TREE_CODE (s2) == GIMPLE_MODIFY_STMT);
+  gcc_assert (DECL_P (GIMPLE_STMT_OPERAND (s1, 0)));
+  gcc_assert (DECL_P (GIMPLE_STMT_OPERAND (s2, 0)));
 #endif
 
-  if (TREE_OPERAND (s1, 0) != TREE_OPERAND (s2, 0))
+  if (GIMPLE_STMT_OPERAND (s1, 0) != GIMPLE_STMT_OPERAND (s2, 0))
     return false;
 
-  s1 = TREE_OPERAND (s1, 1);
-  s2 = TREE_OPERAND (s2, 1);
+  s1 = GIMPLE_STMT_OPERAND (s1, 1);
+  s2 = GIMPLE_STMT_OPERAND (s2, 1);
 
   if (s1 != s2)
     return false;
@@ -2343,10 +2344,10 @@ insert_backedge_copies (void)
 
                  /* Create a new instance of the underlying
                     variable of the PHI result.  */
-                 stmt = build2 (MODIFY_EXPR, TREE_TYPE (result_var),
+                 stmt = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (result_var),
                                 NULL_TREE, PHI_ARG_DEF (phi, i));
                  name = make_ssa_name (result_var, stmt);
-                 TREE_OPERAND (stmt, 0) = name;
+                 GIMPLE_STMT_OPERAND (stmt, 0) = name;
 
                  /* Insert the new statement into the block and update
                     the PHI node.  */
index d33d831..2c9a8c8 100644 (file)
@@ -419,7 +419,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
   if (node == NULL_TREE)
     return spc;
 
-  is_expr = EXPR_P (node);
+  is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
 
   /* We use has_stmt_ann because CALL_EXPR can be both an expression
      and a statement, and we have no guarantee that it will have a
@@ -1024,12 +1024,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       break;
 
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
-      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+      dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
+                        false);
       pp_space (buffer);
       pp_character (buffer, '=');
       pp_space (buffer);
-      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+      dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
+                        false);
       break;
 
     case TARGET_EXPR:
@@ -1485,8 +1488,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (op0)
        {
          pp_space (buffer);
-         if (TREE_CODE (op0) == MODIFY_EXPR)
-           dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
+         if (TREE_CODE (op0) == MODIFY_EXPR
+             || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
+           dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
+                              spc, flags, false);
          else
            dump_generic_node (buffer, op0, spc, flags, false);
        }
@@ -2180,6 +2185,7 @@ op_prio (tree op)
       return 1;
 
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
       return 2;
 
@@ -2311,6 +2317,7 @@ op_symbol_1 (enum tree_code code)
   switch (code)
     {
     case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       return "=";
 
     case TRUTH_OR_EXPR:
index fe42309..329ebcd 100644 (file)
@@ -106,11 +106,11 @@ tree_gen_edge_profiler (int edgeno, edge e)
   tree tmp1 = create_tmp_var (gcov_type_node, "PROF");
   tree tmp2 = create_tmp_var (gcov_type_node, "PROF");
   tree ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
-  tree stmt1 = build2 (MODIFY_EXPR, gcov_type_node, tmp1, ref);
-  tree stmt2 = build2 (MODIFY_EXPR, gcov_type_node, tmp2,
+  tree stmt1 = build2 (GIMPLE_MODIFY_STMT, gcov_type_node, tmp1, ref);
+  tree stmt2 = build2 (GIMPLE_MODIFY_STMT, gcov_type_node, tmp2,
                       build2 (PLUS_EXPR, gcov_type_node, 
                              tmp1, integer_one_node));
-  tree stmt3 = build2 (MODIFY_EXPR, gcov_type_node, ref, tmp2);
+  tree stmt3 = build2 (GIMPLE_MODIFY_STMT, gcov_type_node, ref, tmp2);
   bsi_insert_on_edge (e, stmt1);
   bsi_insert_on_edge (e, stmt2);
   bsi_insert_on_edge (e, stmt3);
index 0c59557..b882d45 100644 (file)
@@ -48,7 +48,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
    Given a scalar variable to be analyzed, follow the SSA edge to
    its definition:
      
-   - When the definition is a MODIFY_EXPR: if the right hand side
+   - When the definition is a GIMPLE_MODIFY_STMT: if the right hand side
    (RHS) of the definition cannot be statically analyzed, the answer
    of the analyzer is: "don't know".  
    Otherwise, for all the variables that are not yet analyzed in the
@@ -1405,15 +1405,15 @@ follow_ssa_edge (struct loop *loop, tree def, tree halting_phi,
       /* Outer loop.  */
       return t_false;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       return follow_ssa_edge_in_rhs (loop, def,
-                                    TREE_OPERAND (def, 1), 
+                                    GIMPLE_STMT_OPERAND (def, 1), 
                                     halting_phi, 
                                     evolution_of_loop, limit);
       
     default:
       /* At this level of abstraction, the program is just a set
-        of MODIFY_EXPRs and PHI_NODEs.  In principle there is no
+        of GIMPLE_MODIFY_STMTs and PHI_NODEs.  In principle there is no
         other node to be handled.  */
       return t_false;
     }
@@ -1607,16 +1607,16 @@ interpret_condition_phi (struct loop *loop, tree condition_phi)
   return res;
 }
 
-/* Interpret the right hand side of a modify_expr OPND1.  If we didn't
+/* Interpret the right hand side of a GIMPLE_MODIFY_STMT OPND1.  If we didn't
    analyze this node before, follow the definitions until ending
-   either on an analyzed modify_expr, or on a loop-phi-node.  On the
+   either on an analyzed GIMPLE_MODIFY_STMT, or on a loop-phi-node.  On the
    return path, this function propagates evolutions (ala constant copy
    propagation).  OPND1 is not a GIMPLE expression because we could
    analyze the effect of an inner loop: see interpret_loop_phi.  */
 
 static tree
-interpret_rhs_modify_expr (struct loop *loop, tree at_stmt,
-                          tree opnd1, tree type)
+interpret_rhs_modify_stmt (struct loop *loop, tree at_stmt,
+                                 tree opnd1, tree type)
 {
   tree res, opnd10, opnd11, chrec10, chrec11;
 
@@ -1883,15 +1883,15 @@ pointer_used_p (tree ptr)
       if (TREE_CODE (stmt) == COND_EXPR)
        return true;
 
-      if (TREE_CODE (stmt) != MODIFY_EXPR)
+      if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
        continue;
 
-      rhs = TREE_OPERAND (stmt, 1);
+      rhs = GIMPLE_STMT_OPERAND (stmt, 1);
       if (!COMPARISON_CLASS_P (rhs))
        continue;
 
-      if (TREE_OPERAND (stmt, 0) == ptr
-         || TREE_OPERAND (stmt, 1) == ptr)
+      if (GIMPLE_STMT_OPERAND (stmt, 0) == ptr
+         || GIMPLE_STMT_OPERAND (stmt, 1) == ptr)
        return true;
     }
 
@@ -1911,7 +1911,7 @@ analyze_scalar_evolution_1 (struct loop *loop, tree var, tree res)
     return chrec_dont_know;
 
   if (TREE_CODE (var) != SSA_NAME)
-    return interpret_rhs_modify_expr (loop, NULL_TREE, var, type);
+    return interpret_rhs_modify_stmt (loop, NULL_TREE, var, type);
 
   def = SSA_NAME_DEF_STMT (var);
   bb = bb_for_stmt (def);
@@ -1944,8 +1944,9 @@ analyze_scalar_evolution_1 (struct loop *loop, tree var, tree res)
 
   switch (TREE_CODE (def))
     {
-    case MODIFY_EXPR:
-      res = interpret_rhs_modify_expr (loop, def, TREE_OPERAND (def, 1), type);
+    case GIMPLE_MODIFY_STMT:
+      res = interpret_rhs_modify_stmt (loop, def,
+                                      GIMPLE_STMT_OPERAND (def, 1), type);
 
       if (POINTER_TYPE_P (type)
          && !automatically_generated_chrec_p (res)
@@ -3005,14 +3006,14 @@ scev_const_prop (void)
          SET_PHI_RESULT (phi, NULL_TREE);
          remove_phi_node (phi, NULL_TREE);
 
-         ass = build2 (MODIFY_EXPR, void_type_node, rslt, NULL_TREE);
+         ass = build2 (GIMPLE_MODIFY_STMT, void_type_node, rslt, NULL_TREE);
          SSA_NAME_DEF_STMT (rslt) = ass;
          {
            block_stmt_iterator dest = bsi;
            bsi_insert_before (&dest, ass, BSI_NEW_STMT);
            def = force_gimple_operand_bsi (&dest, def, false, NULL_TREE);
          }
-         TREE_OPERAND (ass, 1) = def;
+         GIMPLE_STMT_OPERAND (ass, 1) = def;
          update_stmt (ass);
        }
     }
index a5ed161..2db1925 100644 (file)
@@ -851,17 +851,17 @@ sra_walk_asm_expr (tree expr, block_stmt_iterator *bsi,
   sra_walk_tree_list (ASM_OUTPUTS (expr), bsi, true, fns);
 }
 
-/* Walk a MODIFY_EXPR and categorize the assignment appropriately.  */
+/* Walk a GIMPLE_MODIFY_STMT and categorize the assignment appropriately.  */
 
 static void
-sra_walk_modify_expr (tree expr, block_stmt_iterator *bsi,
+sra_walk_gimple_modify_stmt (tree expr, block_stmt_iterator *bsi,
                      const struct sra_walk_fns *fns)
 {
   struct sra_elt *lhs_elt, *rhs_elt;
   tree lhs, rhs;
 
-  lhs = TREE_OPERAND (expr, 0);
-  rhs = TREE_OPERAND (expr, 1);
+  lhs = GIMPLE_STMT_OPERAND (expr, 0);
+  rhs = GIMPLE_STMT_OPERAND (expr, 1);
   lhs_elt = maybe_lookup_element_for_expr (lhs);
   rhs_elt = maybe_lookup_element_for_expr (rhs);
 
@@ -878,7 +878,7 @@ sra_walk_modify_expr (tree expr, block_stmt_iterator *bsi,
       if (!rhs_elt->is_scalar)
        fns->ldst (rhs_elt, lhs, bsi, false);
       else
-       fns->use (rhs_elt, &TREE_OPERAND (expr, 1), bsi, false, false);
+       fns->use (rhs_elt, &GIMPLE_STMT_OPERAND (expr, 1), bsi, false, false);
     }
 
   /* If it isn't scalarizable, there may be scalarizable variables within, so
@@ -892,7 +892,7 @@ sra_walk_modify_expr (tree expr, block_stmt_iterator *bsi,
       if (call)
        sra_walk_call_expr (call, bsi, fns);
       else
-       sra_walk_expr (&TREE_OPERAND (expr, 1), bsi, false, fns);
+       sra_walk_expr (&GIMPLE_STMT_OPERAND (expr, 1), bsi, false, fns);
     }
 
   /* Likewise, handle the LHS being scalarizable.  We have cases similar
@@ -924,14 +924,14 @@ sra_walk_modify_expr (tree expr, block_stmt_iterator *bsi,
       /* Otherwise we're being used in some context that requires the
         aggregate to be seen as a whole.  Invoke USE.  */
       else
-       fns->use (lhs_elt, &TREE_OPERAND (expr, 0), bsi, true, false);
+       fns->use (lhs_elt, &GIMPLE_STMT_OPERAND (expr, 0), bsi, true, false);
     }
 
   /* Similarly to above, LHS_ELT being null only means that the LHS as a
      whole is not a scalarizable reference.  There may be occurrences of
      scalarizable variables within, which implies a USE.  */
   else
-    sra_walk_expr (&TREE_OPERAND (expr, 0), bsi, true, fns);
+    sra_walk_expr (&GIMPLE_STMT_OPERAND (expr, 0), bsi, true, fns);
 }
 
 /* Entry point to the walk functions.  Search the entire function,
@@ -977,14 +977,14 @@ sra_walk_function (const struct sra_walk_fns *fns)
               as a USE of the variable on the RHS of this assignment.  */
 
            t = TREE_OPERAND (stmt, 0);
-           if (TREE_CODE (t) == MODIFY_EXPR)
-             sra_walk_expr (&TREE_OPERAND (t, 1), &si, false, fns);
+           if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
+             sra_walk_expr (&GIMPLE_STMT_OPERAND (t, 1), &si, false, fns);
            else
              sra_walk_expr (&TREE_OPERAND (stmt, 0), &si, false, fns);
            break;
 
-         case MODIFY_EXPR:
-           sra_walk_modify_expr (stmt, &si, fns);
+         case GIMPLE_MODIFY_STMT:
+           sra_walk_gimple_modify_stmt (stmt, &si, fns);
            break;
          case CALL_EXPR:
            sra_walk_call_expr (stmt, &si, fns);
@@ -1689,16 +1689,16 @@ generate_copy_inout (struct sra_elt *elt, bool copy_out, tree expr,
       i = c->replacement;
 
       t = build2 (COMPLEX_EXPR, elt->type, r, i);
-      t = build2 (MODIFY_EXPR, void_type_node, expr, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, expr, t);
       SSA_NAME_DEF_STMT (expr) = t;
       append_to_statement_list (t, list_p);
     }
   else if (elt->replacement)
     {
       if (copy_out)
-       t = build2 (MODIFY_EXPR, void_type_node, elt->replacement, expr);
+       t = build2 (GIMPLE_MODIFY_STMT, void_type_node, elt->replacement, expr);
       else
-       t = build2 (MODIFY_EXPR, void_type_node, expr, elt->replacement);
+       t = build2 (GIMPLE_MODIFY_STMT, void_type_node, expr, elt->replacement);
       append_to_statement_list (t, list_p);
     }
   else
@@ -1733,7 +1733,7 @@ generate_element_copy (struct sra_elt *dst, struct sra_elt *src, tree *list_p)
 
       gcc_assert (src->replacement);
 
-      t = build2 (MODIFY_EXPR, void_type_node, dst->replacement,
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dst->replacement,
                  src->replacement);
       append_to_statement_list (t, list_p);
     }
@@ -1765,7 +1765,7 @@ generate_element_zero (struct sra_elt *elt, tree *list_p)
       gcc_assert (elt->is_scalar);
       t = fold_convert (elt->type, integer_zero_node);
 
-      t = build2 (MODIFY_EXPR, void_type_node, elt->replacement, t);
+      t = build2 (GIMPLE_MODIFY_STMT, void_type_node, elt->replacement, t);
       append_to_statement_list (t, list_p);
     }
 }
@@ -1777,7 +1777,7 @@ static void
 generate_one_element_init (tree var, tree init, tree *list_p)
 {
   /* The replacement can be almost arbitrarily complex.  Gimplify.  */
-  tree stmt = build2 (MODIFY_EXPR, void_type_node, var, init);
+  tree stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, var, init);
   gimplify_and_add (stmt, list_p);
 }
 
@@ -2024,10 +2024,10 @@ scalarize_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
 
       /* See the commentary in sra_walk_function concerning
         RETURN_EXPR, and why we should never see one here.  */
-      gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
+      gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT);
 
-      TREE_OPERAND (stmt, 0) = lhs_elt->replacement;
-      TREE_OPERAND (stmt, 1) = rhs_elt->replacement;
+      GIMPLE_STMT_OPERAND (stmt, 0) = lhs_elt->replacement;
+      GIMPLE_STMT_OPERAND (stmt, 1) = rhs_elt->replacement;
       update_stmt (stmt);
     }
   else if (lhs_elt->use_block_copy || rhs_elt->use_block_copy)
index 163c78d..6853ea1 100644 (file)
@@ -408,7 +408,7 @@ compute_call_clobbered (struct alias_info *ai)
 static bool
 lhs_may_store_to (tree stmt, tree sym ATTRIBUTE_UNUSED)
 {
-  tree lhs = TREE_OPERAND (stmt, 0);
+  tree lhs = GENERIC_TREE_OPERAND (stmt, 0);
   
   lhs = get_base_address (lhs);
   
@@ -459,8 +459,8 @@ recalculate_used_alone (void)
          stmt = bsi_stmt (bsi);
          
          if (TREE_CODE (stmt) == CALL_EXPR
-             || (TREE_CODE (stmt) == MODIFY_EXPR 
-                 && TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR))
+             || (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT 
+                 && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR))
            {
              iscall = true;
              VEC_safe_push (tree, heap, calls, stmt);      
@@ -786,24 +786,24 @@ count_uses_and_derefs (tree ptr, tree stmt, unsigned *num_uses_p,
      find all the indirect and direct uses of x_1 inside.  The only
      shortcut we can take is the fact that GIMPLE only allows
      INDIRECT_REFs inside the expressions below.  */
-  if (TREE_CODE (stmt) == MODIFY_EXPR
+  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
       || (TREE_CODE (stmt) == RETURN_EXPR
-         && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
+         && TREE_CODE (TREE_OPERAND (stmt, 0)) == GIMPLE_MODIFY_STMT)
       || TREE_CODE (stmt) == ASM_EXPR
       || TREE_CODE (stmt) == CALL_EXPR)
     {
       tree lhs, rhs;
 
-      if (TREE_CODE (stmt) == MODIFY_EXPR)
+      if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
        {
-         lhs = TREE_OPERAND (stmt, 0);
-         rhs = TREE_OPERAND (stmt, 1);
+         lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+         rhs = GIMPLE_STMT_OPERAND (stmt, 1);
        }
       else if (TREE_CODE (stmt) == RETURN_EXPR)
        {
          tree e = TREE_OPERAND (stmt, 0);
-         lhs = TREE_OPERAND (e, 0);
-         rhs = TREE_OPERAND (e, 1);
+         lhs = GIMPLE_STMT_OPERAND (e, 0);
+         rhs = GIMPLE_STMT_OPERAND (e, 1);
        }
       else if (TREE_CODE (stmt) == ASM_EXPR)
        {
@@ -816,7 +816,8 @@ count_uses_and_derefs (tree ptr, tree stmt, unsigned *num_uses_p,
          rhs = stmt;
        }
 
-      if (lhs && (TREE_CODE (lhs) == TREE_LIST || EXPR_P (lhs)))
+      if (lhs && (TREE_CODE (lhs) == TREE_LIST
+                 || EXPR_P (lhs) || GIMPLE_STMT_P (lhs)))
        {
          struct count_ptr_d count;
          count.ptr = ptr;
@@ -826,7 +827,8 @@ count_uses_and_derefs (tree ptr, tree stmt, unsigned *num_uses_p,
          *num_derefs_p = count.count;
        }
 
-      if (rhs && (TREE_CODE (rhs) == TREE_LIST || EXPR_P (rhs)))
+      if (rhs && (TREE_CODE (rhs) == TREE_LIST
+                 || EXPR_P (rhs) || GIMPLE_STMT_P (rhs)))
        {
          struct count_ptr_d count;
          count.ptr = ptr;
@@ -2167,9 +2169,9 @@ is_escape_site (tree stmt)
     }
   else if (TREE_CODE (stmt) == ASM_EXPR)
     return ESCAPE_TO_ASM;
-  else if (TREE_CODE (stmt) == MODIFY_EXPR)
+  else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
     {
-      tree lhs = TREE_OPERAND (stmt, 0);
+      tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
 
       /* Get to the base of _REF nodes.  */
       if (TREE_CODE (lhs) != SSA_NAME)
@@ -2180,12 +2182,13 @@ is_escape_site (tree stmt)
       if (lhs == NULL_TREE)
        return ESCAPE_UNKNOWN;
 
-      if (TREE_CODE (TREE_OPERAND (stmt, 1)) == NOP_EXPR
-         || TREE_CODE (TREE_OPERAND (stmt, 1)) == CONVERT_EXPR
-         || TREE_CODE (TREE_OPERAND (stmt, 1)) == VIEW_CONVERT_EXPR)
+      if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == NOP_EXPR
+         || TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CONVERT_EXPR
+         || TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == VIEW_CONVERT_EXPR)
        {
-         tree from = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (stmt, 1), 0));
-         tree to = TREE_TYPE (TREE_OPERAND (stmt, 1));
+         tree from
+           = TREE_TYPE (TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0));
+         tree to = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 1));
 
          /* If the RHS is a conversion between a pointer and an integer, the
             pointer escapes since we can't track the integer.  */
@@ -3173,11 +3176,12 @@ find_used_portions (tree *tp, int *walk_subtrees, void *lhs_p)
 {
   switch (TREE_CODE (*tp))
     {
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       /* Recurse manually here to track whether the use is in the
         LHS of an assignment.  */
-      find_used_portions (&TREE_OPERAND (*tp, 0), walk_subtrees, tp);
-      return find_used_portions (&TREE_OPERAND (*tp, 1), walk_subtrees, NULL);
+      find_used_portions (&GIMPLE_STMT_OPERAND (*tp, 0), walk_subtrees, tp);
+      return find_used_portions (&GIMPLE_STMT_OPERAND (*tp, 1),
+                                walk_subtrees, NULL);
     case REALPART_EXPR:
     case IMAGPART_EXPR:
     case COMPONENT_REF:
index 8da29e4..c8ec228 100644 (file)
@@ -375,7 +375,7 @@ get_default_value (tree var)
          else
            val.lattice_val = VARYING;
        }
-      else if (TREE_CODE (stmt) == MODIFY_EXPR
+      else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
               || TREE_CODE (stmt) == PHI_NODE)
        {
          /* Any other variable defined by an assignment or a PHI node
@@ -543,7 +543,7 @@ likely_value (tree stmt)
 
   /* Anything other than assignments and conditional jumps are not
      interesting for CCP.  */
-  if (TREE_CODE (stmt) != MODIFY_EXPR
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT
       && !(TREE_CODE (stmt) == RETURN_EXPR && get_rhs (stmt) != NULL_TREE)
       && TREE_CODE (stmt) != COND_EXPR
       && TREE_CODE (stmt) != SWITCH_EXPR)
@@ -601,7 +601,7 @@ surely_varying_stmt_p (tree stmt)
 
   /* Anything other than assignments and conditional jumps are not
      interesting for CCP.  */
-  if (TREE_CODE (stmt) != MODIFY_EXPR
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT
       && !(TREE_CODE (stmt) == RETURN_EXPR && get_rhs (stmt) != NULL_TREE)
       && TREE_CODE (stmt) != COND_EXPR
       && TREE_CODE (stmt) != SWITCH_EXPR)
@@ -1184,8 +1184,8 @@ visit_assignment (tree stmt, tree *output_p)
   tree lhs, rhs;
   enum ssa_prop_result retval;
 
-  lhs = TREE_OPERAND (stmt, 0);
-  rhs = TREE_OPERAND (stmt, 1);
+  lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+  rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
   if (TREE_CODE (rhs) == SSA_NAME)
     {
@@ -1219,7 +1219,7 @@ visit_assignment (tree stmt, tree *output_p)
      the constant value into the type of the destination variable.  This
      should not be necessary if GCC represented bitfields properly.  */
   {
-    tree orig_lhs = TREE_OPERAND (stmt, 0);
+    tree orig_lhs = GIMPLE_STMT_OPERAND (stmt, 0);
 
     if (TREE_CODE (orig_lhs) == VIEW_CONVERT_EXPR
        && val.lattice_val == CONSTANT)
@@ -1364,7 +1364,7 @@ ccp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p)
       fprintf (dump_file, "\n");
     }
 
-  if (TREE_CODE (stmt) == MODIFY_EXPR)
+  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
     {
       /* If the statement is an assignment that produces a single
         output value, evaluate its RHS to see if the lattice value of
@@ -2145,14 +2145,14 @@ get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
 
   switch (TREE_CODE (def_stmt))
     {
-      case MODIFY_EXPR:
+      case GIMPLE_MODIFY_STMT:
        {
          tree rhs;
 
          /* The RHS of the statement defining VAR must either have a
             constant length or come from another SSA_NAME with a constant
             length.  */
-         rhs = TREE_OPERAND (def_stmt, 1);
+         rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
          STRIP_NOPS (rhs);
          return get_maxval_strlen (rhs, length, visited, type);
        }
@@ -2204,7 +2204,7 @@ ccp_fold_builtin (tree stmt, tree fn)
   bitmap visited;
   bool ignore;
 
-  ignore = TREE_CODE (stmt) != MODIFY_EXPR;
+  ignore = TREE_CODE (stmt) != GIMPLE_MODIFY_STMT;
 
   /* First try the generic builtin folder.  If that succeeds, return the
      result directly.  */
@@ -2308,13 +2308,13 @@ ccp_fold_builtin (tree stmt, tree fn)
 
     case BUILT_IN_FPUTS:
       result = fold_builtin_fputs (arglist,
-                                  TREE_CODE (stmt) != MODIFY_EXPR, 0,
+                                  TREE_CODE (stmt) != GIMPLE_MODIFY_STMT, 0,
                                   val[0]);
       break;
 
     case BUILT_IN_FPUTS_UNLOCKED:
       result = fold_builtin_fputs (arglist,
-                                  TREE_CODE (stmt) != MODIFY_EXPR, 1,
+                                  TREE_CODE (stmt) != GIMPLE_MODIFY_STMT, 1,
                                   val[0]);
       break;
 
@@ -2578,7 +2578,7 @@ execute_fold_all_builtins (void)
            {
              result = convert_to_gimple_builtin (&i, result,
                                                  TREE_CODE (old_stmt)
-                                                 != MODIFY_EXPR);
+                                                 != GIMPLE_MODIFY_STMT);
              if (result)
                {
                  bool ok = set_rhs (stmtp, result);
index 43172d7..6b9f353 100644 (file)
@@ -370,11 +370,11 @@ stmt_may_generate_copy (tree stmt)
   if (TREE_CODE (stmt) == PHI_NODE)
     return !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (stmt));
 
-  if (TREE_CODE (stmt) != MODIFY_EXPR)
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
     return false;
 
-  lhs = TREE_OPERAND (stmt, 0);
-  rhs = TREE_OPERAND (stmt, 1);
+  lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+  rhs = GIMPLE_STMT_OPERAND (stmt, 1);
   ann = stmt_ann (stmt);
 
   /* If the statement has volatile operands, it won't generate a
@@ -554,8 +554,8 @@ copy_prop_visit_assignment (tree stmt, tree *result_p)
   tree lhs, rhs;
   prop_value_t *rhs_val;
 
-  lhs = TREE_OPERAND (stmt, 0);
-  rhs = TREE_OPERAND (stmt, 1);
+  lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+  rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
   gcc_assert (TREE_CODE (rhs) == SSA_NAME);
 
@@ -690,17 +690,17 @@ copy_prop_visit_stmt (tree stmt, edge *taken_edge_p, tree *result_p)
       fprintf (dump_file, "\n");
     }
 
-  if (TREE_CODE (stmt) == MODIFY_EXPR
-      && TREE_CODE (TREE_OPERAND (stmt, 1)) == SSA_NAME
+  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+      && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == SSA_NAME
       && (do_store_copy_prop
-         || TREE_CODE (TREE_OPERAND (stmt, 0)) == SSA_NAME))
+         || TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME))
     {
       /* If the statement is a copy assignment, evaluate its RHS to
         see if the lattice value of its output has changed.  */
       retval = copy_prop_visit_assignment (stmt, result_p);
     }
-  else if (TREE_CODE (stmt) == MODIFY_EXPR
-          && TREE_CODE (TREE_OPERAND (stmt, 0)) == SSA_NAME
+  else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+          && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME
           && do_store_copy_prop
           && stmt_makes_single_load (stmt))
     {
@@ -711,14 +711,14 @@ copy_prop_visit_stmt (tree stmt, edge *taken_edge_p, tree *result_p)
       if (val
          && val->mem_ref
          && is_gimple_reg (val->value)
-         && operand_equal_p (val->mem_ref, TREE_OPERAND (stmt, 1), 0))
+         && operand_equal_p (val->mem_ref, GIMPLE_STMT_OPERAND (stmt, 1), 0))
         {
          bool changed;
-         changed = set_copy_of_val (TREE_OPERAND (stmt, 0),
+         changed = set_copy_of_val (GIMPLE_STMT_OPERAND (stmt, 0),
                                     val->value, val->mem_ref);
          if (changed)
            {
-             *result_p = TREE_OPERAND (stmt, 0);
+             *result_p = GIMPLE_STMT_OPERAND (stmt, 0);
              retval = SSA_PROP_INTERESTING;
            }
          else
@@ -910,7 +910,7 @@ init_copy_prop (void)
          if (stmt_ends_bb_p (stmt))
            DONT_SIMULATE_AGAIN (stmt) = false;
          else if (stmt_may_generate_copy (stmt)
-                  && loop_depth_of_name (TREE_OPERAND (stmt, 1)) <= depth)
+                  && loop_depth_of_name (GIMPLE_STMT_OPERAND (stmt, 1)) <= depth)
            DONT_SIMULATE_AGAIN (stmt) = false;
          else
            DONT_SIMULATE_AGAIN (stmt) = true;
index b2921a2..a2423a0 100644 (file)
@@ -315,10 +315,10 @@ rename_ssa_copies (void)
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        {
          stmt = bsi_stmt (bsi); 
-         if (TREE_CODE (stmt) == MODIFY_EXPR)
+         if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
            {
-             tree lhs = TREE_OPERAND (stmt, 0);
-             tree rhs = TREE_OPERAND (stmt, 1);
+             tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+             tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
               if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs) == SSA_NAME)
                copy_rename_partition_coalesce (map, lhs, rhs, debug);
index 7b492b2..3b20562 100644 (file)
@@ -216,7 +216,7 @@ find_pdom (basic_block block)
     }
 }
 \f
-#define NECESSARY(stmt)                stmt->common.asm_written_flag
+#define NECESSARY(stmt)                stmt->base.asm_written_flag
 
 /* If STMT is not already marked necessary, mark it, and add it to the
    worklist if ADD_TO_WORKLIST is true.  */
@@ -318,7 +318,7 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
        mark_stmt_necessary (stmt, true);
       return;
 
-    case MODIFY_EXPR:
+    case GIMPLE_MODIFY_STMT:
       op = get_call_expr_in (stmt);
       if (op && TREE_SIDE_EFFECTS (op))
        {
@@ -329,8 +329,8 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
       /* These values are mildly magic bits of the EH runtime.  We can't
         see the entire lifetime of these values until landing pads are
         generated.  */
-      if (TREE_CODE (TREE_OPERAND (stmt, 0)) == EXC_PTR_EXPR
-         || TREE_CODE (TREE_OPERAND (stmt, 0)) == FILTER_EXPR)
+      if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == EXC_PTR_EXPR
+         || TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == FILTER_EXPR)
        {
          mark_stmt_necessary (stmt, true);
          return;
index b277068..134cfe9 100644 (file)
@@ -489,7 +489,7 @@ initialize_hash_element (tree expr, tree lhs, struct expr_hash_elt *element)
   else if (TREE_CODE (expr) == RETURN_EXPR && TREE_OPERAND (expr, 0))
     {
       element->stmt = expr;
-      element->rhs = TREE_OPERAND (TREE_OPERAND (expr, 0), 1);
+      element->rhs = GIMPLE_STMT_OPERAND (TREE_OPERAND (expr, 0), 1);
     }
   else if (TREE_CODE (expr) == GOTO_EXPR)
     {
@@ -499,7 +499,7 @@ initialize_hash_element (tree expr, tree lhs, struct expr_hash_elt *element)
   else
     {
       element->stmt = expr;
-      element->rhs = TREE_OPERAND (expr, 1);
+      element->rhs = GENERIC_TREE_OPERAND (expr, 1);
     }
 
   element->lhs = lhs;
@@ -1183,14 +1183,14 @@ simple_iv_increment_p (tree stmt)
   tree lhs, rhs, preinc, phi;
   unsigned i;
 
-  if (TREE_CODE (stmt) != MODIFY_EXPR)
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
     return false;
 
-  lhs = TREE_OPERAND (stmt, 0);
+  lhs = GIMPLE_STMT_OPERAND (stmt, 0);
   if (TREE_CODE (lhs) != SSA_NAME)
     return false;
 
-  rhs = TREE_OPERAND (stmt, 1);
+  rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
   if (TREE_CODE (rhs) != PLUS_EXPR
       && TREE_CODE (rhs) != MINUS_EXPR)
@@ -1473,8 +1473,8 @@ eliminate_redundant_computations (tree stmt)
   bool retval = false;
   bool modify_expr_p = false;
 
-  if (TREE_CODE (stmt) == MODIFY_EXPR)
-    def = TREE_OPERAND (stmt, 0);
+  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
+    def = GIMPLE_STMT_OPERAND (stmt, 0);
 
   /* Certain expressions on the RHS can be optimized away, but can not
      themselves be entered into the hash tables.  */
@@ -1499,12 +1499,12 @@ eliminate_redundant_computations (tree stmt)
     expr_p = &SWITCH_COND (stmt);
   else if (TREE_CODE (stmt) == RETURN_EXPR && TREE_OPERAND (stmt, 0))
     {
-      expr_p = &TREE_OPERAND (TREE_OPERAND (stmt, 0), 1);
+      expr_p = &GIMPLE_STMT_OPERAND (TREE_OPERAND (stmt, 0), 1);
       modify_expr_p = true;
     }
   else
     {
-      expr_p = &TREE_OPERAND (stmt, 1);
+      expr_p = &GENERIC_TREE_OPERAND (stmt, 1);
       modify_expr_p = true;
     }
 
@@ -1552,7 +1552,7 @@ eliminate_redundant_computations (tree stmt)
   return retval;
 }
 
-/* STMT, a MODIFY_EXPR, may create certain equivalences, in either
+/* STMT, a GIMPLE_MODIFY_STMT, may create certain equivalences, in either
    the available expressions table or the const_and_copies table.
    Detect and record those equivalences.  */
 
@@ -1561,12 +1561,12 @@ record_equivalences_from_stmt (tree stmt,
                               int may_optimize_p,
                               stmt_ann_t ann)
 {
-  tree lhs = TREE_OPERAND (stmt, 0);
+  tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
   enum tree_code lhs_code = TREE_CODE (lhs);
 
   if (lhs_code == SSA_NAME)
     {
-      tree rhs = TREE_OPERAND (stmt, 1);
+      tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
       /* Strip away any useless type conversions.  */
       STRIP_USELESS_TYPE_CONVERSION (rhs);