diff options
Diffstat (limited to 'gcc')
329 files changed, 8479 insertions, 4457 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index b38ccbb2896..73b478e6558 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,1014 @@ +2008-08-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c/28152 + * c-parser.c (c_lex_one_token): Do not store the canonical spelling + for keywords. + +2008-08-14 Dorit Nuzman <dorit@il.ibm.com> + + * tree-vect-transform.c (vect_create_epilog_for_reduction): Takes an + additional argument. Support reduction when duplication is needed due + to data-types of different sizes in the loop. + (get_initial_def_for_induction): Fix printout. + (vect_get_vec_def_for_stmt_copy): Support case where the + vec_stmt_for_operand is a phi node. + (vectorizable_reduction): Support reduction when duplication is needed + due to data-types of different sizes in the loop. + (vectorizable_call): Remove restriction to not vectorize in case we + have data-types of different sizes in the loop. + (vectorizable_conversion): Likewise. + (vectorizable_operation): Likewise. + (vectorizable_type_demotion): Likewise. + (vectorizable_type_promotion): Likewise. + (vectorizable_induction): Add restriction to not vectorize in case + we have data-types of different sizes in the loop. + +2008-08-14 Christophe Saout <christophe@saout.de> + Uros Bizjak <ubizjak@gmail.com> + + PR target/37101 + * config/i386/sse.md (vec_concatv2di): Remove movlps alternative. + (*vec_concatv2di_rex64_sse4_1): Ditto. + (*vec_concatv2di_rex64_sse): Ditto. + +2008-08-14 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/37103 + * fold-const.c (fold_widened_comparison): Do not allow + sign changes that change the result even if shorter type + is wider than arg1_unw's type. + +2008-08-13 Kazu Hirata <kazu@codesourcery.com> + + * gcc.dg/arm-g2.c, gcc.dg/arm-mmx-1.c, gcc.dg/arm-scd42-2.c: + Skip if the multilib testing specifies -march that does not + agree with the one specified in the testcase. + +2008-08-13 Joseph Myers <joseph@codesourcery.com> + + * config/sparc/sparc.c (emit_soft_tfmode_cvt): Explicitly sign or + zero extend SImode values being converted to TFmode before passing + to libcalls. + +2008-08-13 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * config/rs6000/rs6000-c.c (rs6000_cpu_cpp_builtins): Predefine + __PPU__ when targeting the Cell/B.E. PPU processor. + +2008-08-13 Eric Botcazou <ebotcazou@adacore.com> + + * gimple.h (gimple_call_set_chain): Accept SSA variables. + * tree-ssa-pre.c (create_component_ref_by_pieces_1) <CALL_EXPR>: + Rematerialize the static chain, if any. + * tree-ssa-sccvn.c (copy_reference_ops_from_call): Also copy the + static chain. + +2008-08-13 H.J. Lu <hongjiu.lu@intel.com> + + * dwarf2out.c (dwarf_stack_op_name): Remove prototype. + (new_loc_descr): Likewise. + (add_loc_descr): Likewise. + (size_of_loc_descr): Likewise. + (size_of_locs): Likewise. + (output_loc_operands): Likewise. + (output_loc_sequence): Likewise. + (new_reg_loc_descr): New. + (build_cfa_loc): Use it. + (build_cfa_aligned_loc): Likewise. + (one_reg_loc_descriptor): Likewise. + (based_loc_descr): Likewise. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 30551 + * doc/invoke.texi (Wmain): Update. + * c-decl.c (start_decl): warn_main is only 0 or 1. + (start_function): Likewise. Fix formatting. + (finish_function): Delete redundant warning. + * c.opt (Wmain): Add Var(warn_main) and Init(-1). + * c-opts (c_common_handle_option): -Wall only has effect if + warn_main is uninitialized. OPT_Wmain is automatically + handled. -pedantic also enables Wmain. + (c_common_post_options): Handle all logic for Wmain here. + * c-common.c (warn_main): Delete. + (check_main_parameter_types): Make pedwarns conditional on + OPT_Wmain. + * c-common.h (warn_main): Delete. + +2008-08-13 H.J. Lu <hongjiu.lu@intel.com> + + PR middle-end/36701 + * expr.c (emit_group_store): Allocate stack temp with the + largest alignment when copying from register to stack. + +2008-08-13 Richard Guenther <rguenther@suse.de> + + * tree.h (maybe_fold_offset_to_address): Declare. + * tree-ssa-ccp.c (surely_varying_stmt_p): Fix typo in last commit. + (ccp_fold): Handle pointer conversions the same as fold_stmt. + Likewise for POINTER_PLUS_EXPR. + (maybe_fold_offset_to_reference): Enable disabled code. + (maybe_fold_offset_to_address): New function. + (fold_stmt_r): Use it. + (fold_gimple_assign): Likewise. + * gimplify.c (gimplify_conversion): Use maybe_fold_offset_to_address. + (gimplify_expr): Likewise. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + * toplev.h (pedwarn_at): Fix declaration. + +2008-08-13 Joseph Myers <joseph@codesourcery.com> + + * config/sparc/linux64.h (LINK_ARCH32_SPEC, LINK_ARCH64_SPEC, + LINK_SPEC): Use %R in -Y P argument. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c/15236 + * diagnostic.c (pedwarn_at): New. + * toplev.h (pedwarn_at): Declare. + * c-tree.h (build_enumerator): Update declaration. + * c-decl.c (finish_enum): Update comment. + (build_enumerator): Take a location parameter. Give a pedwarn but do + not perform any conversion. + * c-parser.c (c_parser_enum_specifier): Set correct location for + enumerator. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 35635 + * c-common.c (conversion_warning): Use a switch. Ignore boolean + expressions except for conversions to signed:1 bitfields. Handle + COND_EXPR with constant operands. + +2008-08-13 Richard Guenther <rguenther@suse.de> + + PR tree-optimization/15255 + * tree-ssa-reassoc.c (linearize_expr_tree): Declare. + (struct oecount_s): New struct and VEC types. + (cvec): New global. + (oecount_hash): New function. + (oecount_eq): Likewise. + (oecount_cmp): Likewise. + (zero_one_operation): New function. + (build_and_add_sum): Likewise. + (undistribute_ops_list): Perform un-distribution of multiplication + and division on the chain of summands. + (should_break_up_subtract): Also break up subtracts for factors. + (reassociate_bb): Delete dead visited statements. + Call undistribute_ops_list. Re-sort and optimize if it did something. + * passes.c (init_optimization_passes): Move DSE before + reassociation. + * tree-ssa-loop-niter.c (stmt_dominates_stmt_p): Correctly handle + PHI nodes. + +2008-08-12 Janis Johnson <janis187@us.ibm.com> + + * doc/invoke.texi (-fipa-pta): Say the option is experimental. + + * doc/invoke.texi: Revert unintended checkin. + +2008-08-12 Nathan Froyd <froydnj@codesourcery.com> + + PR libgomp/26165 + * gcc.c (include_spec_function): Tweak call to find_a_file. + +2008-08-12 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/37014 + * expr.c (expand_expr_real_1): Handle TRUTH_ANDIF_EXPR + and TRUTH_ORIF_EXPR. + * dojump.c (do_jump): Likewise. + + PR tree-optimization/37084 + * tree-inline.c (copy_bb): Call gimple_regimplify_operands + if id->regimplify, don't assume stmt is a cast assignment. + +2008-08-12 Anatoly Sokolov <aesok@post.ru> + + * final.c (final_scan_insn): Use app_enable/app_disable functions. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + PR bootstrap/37097 + * builtins.c (do_mpfr_bessel_n): Fix copy-and-paste bug introduced + by last change. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * defaults.h (TARGET_FLOAT_FORMAT): Remove. + (UNKNOWN_FLOAT_FORMAT, IEEE_FLOAT_FORMAT, VAX_FLOAT_FORMAT): Remove. + + * config/alpha/alpha.h (TARGET_FLOAT_FORMAT): Remove. + * config/iq2000/iq2000.h (TARGET_FLOAT_FORMAT): Remove. + * config/pdp11/pdp11.h (TARGET_FLOAT_FORMAT): Remove. + * config/score/score.h (TARGET_FLOAT_FORMAT): Remove. + * config/vax/vax.h (TARGET_FLOAT_FORMAT): Remove. + + * doc/tm.texi (Storage Layout): Remove documentation for + TARGET_FLOAT_FORMAT. + + * simplify-rtx.c (simplify_binary_operation_1): Replace + TARGET_FLOAT_FORMAT check by appropriate HONOR_... checks. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * real.h (struct real_format): New member has_sign_dependent_rounding. + * real.c (ieee_single_format, mips_single_format, motorola_single_format, + spu_single_format, ieee_double_format, mips_double_format, + motorola_double_format, ieee_extended_motorola_format, + ieee_extended_intel_96_format, ieee_extended_intel_128_format, + ieee_extended_intel_96_round_53_format, ibm_extended_format, + mips_extended_format, ieee_quad_format, mips_quad_format, + vax_f_format, vax_d_format, vax_g_format): Initialize it. + * config/pdp11/pdp11.c (pdp11_f_format, pdp11_d_format): Likewise. + + * defaults.h (MODE_HAS_NANS, MODE_HAS_INFINITIES, + MODE_HAS_SIGNED_ZEROS, MODE_HAS_SIGN_DEPENDENT_ROUNDING): Remove. + * config/spu/spu.h (MODE_HAS_NANS, MODE_HAS_INFINITIES, + MODE_HAS_SIGN_DEPENDENT_ROUNDING): Remove. + (ROUND_TOWARDS_ZERO): Likewise. + + * real.h (REAL_MODE_FORMAT): Protect MODE against macro expansion. + (FLOAT_MODE_FORMAT): New macro. + (REAL_MODE_FORMAT_COMPOSITE_P): Remove, replace by ... + (MODE_COMPOSITE_P): ... this new macro. + (MODE_HAS_NANS, MODE_HAS_INFINITIES, MODE_HAS_SIGNED_ZEROS, + MODE_HAS_SIGN_DEPENDENT_ROUNDING): New macros. + * machmode.h (GET_MODE_INNER): Cast result to enum machine_mode. + + * flags.h: Include "real.h". + + * fold-const.c (const_binop): Use MODE_COMPOSITE_P instead of + REAL_MODE_FORMAT_COMPOSITE_P. + * simplify-rtx.c (simplify_const_binary_operation): Likewise. + + * doc/tm.texi (Storage Layout): Remove documentation of + MODE_HAS_NANS, MODE_HAS_INFINITIES, MODE_HAS_SIGNED_ZEROS, + MODE_HAS_SIGN_DEPENDENT_ROUNDING. Update documentation of + ROUND_TOWARDS_ZERO and LARGEST_EXPONENT_IS_NORMAL to clarify + they only apply to libgcc2.a. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * config/spu/float_disf.c: New file. + * config/spu/float_unsdisf.c: New file. + * config/spu/t-elf (LIB2FUNCS_STATIC_EXTRA): Add them. + (LIB2FUNCS_EXCLUDE): Define. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + Trevor Smigiel <trevor_smigiel@playstation.sony.com> + + * real.h (struct real_format): New member round_towards_zero. + * real.c (round_for_format): Respect fmt->round_towards_zero. + (ieee_single_format, mips_single_format, motorola_single_format, + spu_single_format, ieee_double_format, mips_double_format, + motorola_double_format, ieee_extended_motorola_format, + ieee_extended_intel_96_format, ieee_extended_intel_128_format, + ieee_extended_intel_96_round_53_format, ibm_extended_format, + mips_extended_format, ieee_quad_format, mips_quad_format, + vax_f_format, vax_d_format, vax_g_format): Initialize it. + * config/pdp11/pdp11.c (pdp11_f_format, pdp11_d_format): Likewise. + + * builtins.s (do_mpfr_arg1): Consider round_towards_zero member of + real_format to choose rounding mode when calling MPFR functions. + (do_mpfr_arg2, do_mpfr_arg3, do_mpfr_sincos): Likewise. + (do_mpfr_bessel_n, do_mpfr_remquo, do_mpfr_lgamma_r): Likewise. + + * real.h (real_to_decimal_for_mode): Add prototype. + * real.c (real_to_decimal_for_mode): Renames old real_to_decimal. + Respect target rounding mode when generating decimal representation. + (real_to_decimal): New stub for backwards compatibility. + * c-cppbuiltin.c (builtin_define_with_hex_fp_value): Use + real_to_decimal_for_mode instead of real_to_decimal. + + * config/spu/spu.md ("floatdisf2", "floatunsdisf2"): New. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + Trevor Smigiel <trevor_smigiel@playstation.sony.com> + + * real.c (spu_single_format): New variable. + * real.h (spu_single_format): Declare. + + * config/spu/spu.c (spu_override_options): Install SFmode format. + (spu_split_immediate): Use integer mode to operate on pieces of + floating-point values in all cases. + + * config/spu/spu.md (UNSPEC_FLOAT_EXTEND, UNSPEC_FLOAT_TRUNCATE): New. + ("extendsfdf2"): Use UNSPEC_FLOAT_EXTEND instead of FLOAT_EXTEND. + ("truncdfsf2"): Use UNSPEC_FLOAT_TRUNCATE instead of FLOAT_TRUNCATE. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * config/spu/spu.c (spu_safe_dma): Respect TARGET_SAFE_DMA. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * config/spu/spu.h (DWARF_FRAME_RETURN_COLUMN): Define. + +2008-08-12 Jakub Jelinek <jakub@redhat.com> + + PR c++/36688 + * gimplify.c (gimplify_modify_expr_rhs): Test TREE_READONLY + on the VAR_DECL instead of TYPE_READONLY on its type. + +2008-08-12 Ira Rosen <irar@il.ibm.com> + + * tree-vectorizer.c: Depend on langhooks.h. + (supportable_widening_operation): Add two arguments. Support double + type conversions. + (supportable_narrowing_operation): Likewise. + * tree-vectorizer.h (supportable_widening_operation): Add two + arguments. + (supportable_narrowing_operation): Likewise. + * tree-vect-patterns.c (vect_recog_widen_mult_pattern) : Call + supportable_widening_operation with correct arguments. + * tree-vect-transform.c (vectorizable_conversion): Likewise. + (vectorizable_type_demotion): Support double type conversions. + (vectorizable_type_promotion): Likewise. + * Makefile.in (tree-vectorizer.o): Depend on langhooks.h. + +2008-08-11 Michael Matz <matz@suse.de> + + * i386/i386.c (override_options): Move initialisation from + flag_schedule_insns_after_reload to here from ... + (optimization_options): ... here. + +2008-08-11 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/36998 + * dwarf2out.c (compute_barrier_args_size_1, + compute_barrier_args_size): Temporarily remove assertions. + +2008-08-10 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR middle-end/20644 + * tree-ssa.c (struct walk_data): Add new flag + warn_possibly_uninitialized. + (warn_uninitialized_var): Use it. + (warn_uninitialized_vars): New. + (execute_early_warn_uninitialized): Call it. + (execute_late_warn_uninitialized): Likewise. + +2008-08-09 Andrew Pinski <andrew_pinski@playstation.sony.com> + + PR middle-end/36238 + * reload1.c (gen_reload): Guard calls to get_secondary_mem + for memory subregs. + +2008-08-09 Jan Hubicka <jh@suse.cz> + + PR target/37055 + * optabs.c (maybe_emit_unop_insn): Remove produced code if + expansion failed. + (expand_fix): Be prepared for expansion to fail. + (expand_sfix_optab): Remove instructions if expansion failed. + +2008-08-09 Anatoly Sokolov <aesok@post.ru> + + * config/avr/avr.c (avr_mcu_types): Move the AT43USB320 device to + avr31 architecture. + * config/avr/avr.h (CRT_BINUTILS_SPECS): (Ditto.). + * config/avr/t-avr (MULTILIB_MATCHES): (Ditto.). + +2008-08-09 Richard Sandiford <rdsandiford@googlemail.com> + + * config.gcc (mips*-*-linux*, mips64*-*-linux*): Add + mips/t-libgcc-mips16 to tmake_file. + * config/mips/mips-protos.h (mips_call_type): New enum. + (mips_pic_base_register, mips_got_load): Declare. + (mips_restore_gp): Take an rtx argument. + (mips_use_pic_fn_addr_reg_p): Declare. + (mips_expand_call): Replace the sibcall_p argument with + a mips_call_type argument. Add a lazy_p parameter. + (mips_split_call): Declare. + * config/mips/mips.h (MIPS16_PIC_TEMP_REGNUM): New macro. + (MIPS16_PIC_TEMP): Likewise. + (reg_class): Delete M16_NA_REGS. + (REG_CLASS_NAMES, REG_CLASS_CONTENTS): Update accordingly. + (SYMBOL_FLAG_BIND_NOW, SYMBOL_REF_BIND_NOW_P): New macros. + (mips_split_hi_p): Declare. + * config/mips/mips.c (mips_split_hi_p): New array. + (mips_regno_to_class): Change M16_NA_REGS entries to M16_REGS. + (mips_got_symbol_type_p): New function. + (mips_global_symbol_p): Check SYMBOL_REF_EXTERNAL_P. + (mips16_stub_function_p): New function. + (mips16_local_function_p): Likewise. + (mips_use_pic_fn_addr_reg_p): Likewise. + (mips_cannot_force_const_mem): Return false for HIGHs. + Extend CONST_INT and symbolic handling to MIPS16, using + mips_symbol_insns to check that the base symbol type is a + legitimate constant. Reject GOT-based constants if + TARGET_MIPS16_PCREL_LOADS. + (mips_const_insns): Check targetm.cannot_force_const_mem when + decomposing a symbolic base and a large offset. + (mips_emit_call_insn): Add ORIG_ADDR and ADDR parameters. + When calling a function that needs $25 from MIPS16 code, + move the target address into $25 separately and add a USE + to the call insn. + (mips16_gp_pseudo_reg): Insert the initializer immediately + before the first real insn. + (mips_pic_base_register, mips_got_load): New functions. + (mips_split_symbol): Generalize the name of the LO_SUM_OUT + parameter to LOW_OUT. Say that it can be any valid SET_SRC + when splitting a load-address operation. Split SYMBOL_GOT_DISP + constants and highs of SYMBOL_GOT_PAGE_OFST constants. + (mips_call_tls_get_addr): Update the call to mips_expand_call, + also passing NULL_RTX rather than const0_rtx as the aux argument. + (mips_rewrite_small_data_p): Check mips_lo_relocs and mips_split_p + instead of TARGET_EXPLICIT_RELOCS. + (mips_ok_for_lazy_binding_p): Check SYMBOL_REF_BIND_NOW_P. + (mips_load_call_address): Replace the sibcall_p argument with + a mips_call_type argument. Use mips_got_load. + (mips16_local_alias): New structure. + (mips16_local_aliases): New variable. + (mips16_local_aliases_hash): New function. + (mips16_local_aliases_eq): Likewise. + (mips16_local_alias): Likewise. + (mips16_stub_function): Likewise. + (mips16_build_function_stub): Create a local alias for the target + function. Handle TARGET_ABICALLS. For PIC abicalls, emit a + .cpload directive and an R_MIPS_NONE relocation for the target + function, then load the alias rather than the function itself. + Wrap the non-PIC abicalls version in ".option pic0/.option pic2". + (mips16_copy_fpr_return_value): Use mips16_stub_function and + mips_expand_call. Set SYMBOL_REF_BIND_NOW on the symbol. + (mips16_build_call_stub): Replace the FN parameter with an + FN_PTR parameter. Force the address into a register if it + isn't a call_insn_operand; don't rely on the caller to do this. + If a call to a locally-defined and locally-binding MIPS16 + function must be made indirectly, redirect the call to the + function's local alias. Use mips16_stub_function_p, + mips16_stub_function, mips_expand_call and use_reg. + Set SYMBOL_FLAG_BIND_NOW on __mips_call_* symbols. + Use explicit %hi and %lo accesses where possible. + Use MIPS_CALL to generate the correct code form of a + jal instruction. Add clobbers of $18 instead of uses. + Update the call to mips_emit_call_insn. + (mips_expand_call): Replace the SIBCALL_P argument with a + mips_call_type argument and handle the new MIPS_CALL_EPILOGUE value. + Take a LAZY_P parameter. Call mips16_build_call_stub first, + allowing it to modify the call address. Update the calls to + mips_load_call_address and mips_emit_call_insn. + (mips_split_call): New function. + (mips_init_relocs): Clear mips_split_hi_p. Only use %gp_rel if + !TARGET_MIPS16. Split SYMBOL_GOT_DISP, and the high parts of + SYMBOL_GOT_PAGE_OFST, for MIPS16 code. + (mips_global_pointer): Check mips16_cfun_returns_in_fpr_p. + (mips_extra_live_on_entry): Include MIPS16_PIC_TEMP_REGNUM + if TARGET_MIPS16. + (mips_cprestore_slot): New function. + (mips_restore_gp): Take a TEMP parameter. Handle TARGET_MIPS16 + and use mips_cprestore_slot. + (mips_output_function_prologue): Handle TARGET_MIPS16 for + LOADGP_OLDABI. + (mips_emit_loadgp): Move into MIPS16_PIC_TEMP for MIPS16, + then use a copygp_mips16 instruction to set up $28. + (mips_expand_prologue): Initialize the cprestore slot for MIPS16 too. + (mips16_lay_out_constants): Call split_all_insns_noflow. + (mips_reorg_process_insns): Explicitly set all_noreorder_p to + false if TARGET_MIPS16. + (mips_reorg): Don't call vr4130_align_insns if TARGET_MIPS16. + (mips_output_mi_thunk): Use mips_got_symbol_type_p. Use the + mips_dangerous_for_la25_p approach for MIPS16 PIC calls too. + (mips_set_mips16_mode): Always set MASK_EXPLICIT_RELOCS for + MIPS16 code. Allow MIPS16 o32 PIC. + (mips_override_options): Allow MIPS16 o32 PIC. + * config/mips/mips.md: Lower CONST_GP_P moves into register moves + after reload if TARGET_USE_GOT. + (UNSPEC_COPYGP): New constant. + (length): Use a default length of 8 for MIPS16 GOT loads. + (*got_disp<mode>): Check mips_split_p instead of TARGET_XGOT. + (*got_page<mode>): Check mips_split_hi_p. + (*got_disp<mode>, *got_page<mode>): Use mips_got_load. + (unspec_got<mode>, unspec_call<mode>): New expanders. + (load_got<mode>, load_call<mode>): Remove the length attributes. + Use a got attribute instead of a type attribute. + (copygp_mips16): New insn. + (restore_gp): Add a scratch clobber and pass it to mips_restore_gp. + (load_call<mode>): Use a "d" constraint instead of an "r" constraint. + (sibcall, sibcall_value, call, call_value): Update the calls + to mips_expand_call. + (call_internal, call_value_internal): Use mips_split_call. + (call_value_multiple_internal): Likewise. + (call_split): Move after call_internal (the insn it is split from). + (call_internal_direct, call_value_internal_direct): Turn into + define_insn_and_splits. Split if TARGET_SPLIT_CALLS. + (call_direct_split, call_value_direct_split): New patterns. + * config/mips/constraints.md (c): Handle TARGET_MIPS16 first + and use M16_REGS instead of M16_NA_REGS. + * config/mips/predicates.md (const_call_insn_operand): Replace + the TARGET_ABSOLUTE_ABICALLS-based check with a more general + mips_use_pic_fn_addr_reg_p check. + (move_operand): Reject HIGHs if mips_split_hi_p. + * config/mips/mips16.S: Assembly as empty if the ABI is not suitable. + (__mips16_floatunsisf): Inline __mips16_floatsisf. + (CALL_STUB_NO_RET, CALL_STUB_REG): Copy the target register to $25. + * config/mips/libgcc-mips16.ver: New file. + * config/mips/t-libgcc-mips16 (SHLIB_MAPFILES): Add + $(srcdir)/config/mips/libgcc-mips16.ver. + +2008-08-09 Richard Sandiford <rdsandiford@googlemail.com> + + * config/mips/mips.c (mips_unspec_address_offset): Move earlier in file. + (mips_unspec_address, mips_unspec_offset_high): Likewise. + (mips_ok_for_lazy_binding_p, mips_load_call_address): Likewise. + (mips16_cfun_returns_in_fpr_p): Likewise. + +2008-08-09 Richard Sandiford <rdsandiford@googlemail.com> + + * config/mips/mips.h (MASK_RETURN_ADDR): Expand commentary. + * config/mips/linux-unwind.h (mips_fallback_frame_state): Add 2 + rather than 4 to PC. + +2008-08-09 Richard Sandiford <rdsandiford@googlemail.com> + + * config/mips/mips.h (STATIC_CHAIN_REGNUM): Remap to $15. + (FUNCTION_PROFILER): Save the static chain pointer into $2 + beforehand and restore it aftewards. + (TRAMPOLINE_TEMPLATE): Adjust accordingly. Load the target + address directly into $25 and call the function through $25; + do not clobber $3. Pad the DImode version to cover the space + left by the deleted $25 <- $3 move. + (TRAMPOLINE_SIZE): Adjust the size of the SImode version after + the removal of the $25 <- $3 move. + (INITIALIZE_TRAMPOLINE): Update offsets accordingly. + * config/mips/sdemtk.h (FUNCTION_PROFILER): As for mips.h. + +2008-08-09 Richard Sandiford <rdsandiford@googlemail.com> + Daniel Jacobowitz <dan@codesourcery.com> + + * config/mips/mips.h (FUNCTION_NAME_ALREADY_DECLARED): Delete. + * config/mips/linux.h (ASM_DECLARE_FUNCTION_NAME): Delete. + (ASM_DECLARE_FUNCTION_SIZE, FUNCTION_NAME_ALREADY_DECLARED): Delete. + * config/mips/mips.c (mips_start_function_definition): New function. + (mips_end_function_definition): Likewise. + (mips_output_function_prologue): Use mips_start_function_definition. + (mips_output_function_epilogue): Use mips_end_function_definition. + (build_mips16_function_stub): Use mips_start_function_definition + and mips_end_function_definition. + (build_mips16_call_stub): Likewise. + +2008-08-09 Richard Guenther <rguenther@suse.de> + + * gimple.c (gimple_build_call_1): Deal with FUNCTION_DECL fn. + * gimple.h (gimple_call_fn): Adjust comment. + (gimple_call_set_fndecl): New function. + (gimple_call_fndecl): Adjust for GIMPLE_CALL no + longer having bare FUNCTION_DECL operand. + (gimple_call_return_type): Likewise. + * tree-cfg.c (verify_stmt): Verify function operand of a GIMPLE_CALL. + + * value-prof.c (gimple_divmod_fixed_value): Do not emit labels. + (gimple_mod_pow2): Likewise. + (gimple_mod_subtract): Likewise. + (gimple_ic): Likewise. + (gimple_stringop_fixed_value): Likewise. + (gimple_indirect_call_to_profile): Fix for GIMPLE_CALL no + longer having bare FUNCTION_DECL operand. + * ipa-cp.c (ipcp_update_callgraph): Use gimple_call_set_fndecl. + * omp-low.c (optimize_omp_library_calls): Likewise. + * cgraphunit.c (update_call_expr): Likewise. + * tree-ssa-math-opts.c (execute_cse_reciprocals): Likewise. + (execute_convert_to_rsqrt): Likewise. + * cfgexpand.c (gimple_to_tree): Simplify. + (release_stmt_tree): Fix for GIMPLE_CALL no longer having + bare FUNCTION_DECL operand. + * tree-nested.c (init_tmp_var_with_call): Use gimple_call_return_type. + (convert_gimple_call): Use gimple_call_fndecl. + * c-common.c (c_warn_unused_result): Likewise. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c/17880 + * c-typeck.c (digest_init): Call verify_sequence_points from here. + (c_finish_return): Likewise. + (c_start_case): Likewise. + * c-common.c (warn_for_collisions_1): Use explicit location in + warning. + * c-parser.c (c_parser_condition): New. Call + verify_sequence_points. + (c_parser_paren_condition): Call c_parser_condition. + (c_parser_for_statement): Call c_parser_condition. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 36901 + * diagnostic.def (DK_PEDWARN, DK_PERMERROR): New. + * diagnostic.c (pedantic_warning_kind, permissive_error_kind): + Moved from diagnostic.h + (diagnostic_report_diagnostic): Return bool. Handle DK_PEDWARN and + DK_PERMERROR. + (emit_diagnostic): New. + (warning0, pedwarn0): Delete. + (warning, warning_at, pedwarn, permerror): Return bool. + * diagnostic.h (pedantic_warning_kind, permissive_error_kind): + Moved to diagnostic.c. + (struct diagnostic_context): Use correct type for + classify_diagnostic. + (diagnostic_report_diagnostic): Update declaration. + (emit_diagnostic): Declare. + * errors.c (warning): Return bool. + * errors.h (warning): Update declaration. + * toplev.h (warning0, pedwarn0): Delete. + (warning, warning_at, pedwarn, permerror): Return bool. + * c-errors.c (pedwarn_c99, pedwarn_c90): Use DK_PEDWARN. + * c-decl.c (locate_old_decl): Delete 'diag' argument. Always use + inform. Update all calls. + (diagnose_mismatched_decls): Check return value of warning/pedwarn + before giving informative note. + (implicit_decl_warning): Likewise. + * c-typeck.c (build_function_call): Likewise. + * tree-sssa.c (warn_uninit): Likewise. + * builtins.c (gimplify_va_arg_expr): Likewise. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 7651 + * doc/invoke.texi (-Wextra): Move warning from here... + (-Wuninitialized): ... to here. + +2008-08-08 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 28875 + * flags.h (set_Wunused): Delete + * toplev.c (process_options): Handle Wunused flags here. + * opts.c (maybe_warn_unused_parameter): Delete. + (common_handle_option): Replace set_Wunused by warn_unused. + (set_Wextra): Do not handle Wunused-parameter here. + (set_Wunused): Delete. + * c-opts.c (c_common_handle_option): Replace set_Wunused by + warn_unused. + * common.opt (Wunused): Add Var and Init. + (Wunused-function): Likewise. + (Wunused-label): Likewise. + (Wunused-parameter): Likewise. + (Wunused-value): Likewise. + (Wunused-variable): Likewise. + +2008-08-08 Peter Bergner <bergner@vnet.ibm.com> + + * doc/invoke.texi: Add cpu_type power7. + * config.in (HAVE_AS_VSX): New. + * config.gcc: Add cpu_type power7. + * configure.ac (HAVE_AS_VSX): Check for assembler support of the + VSX instructions. + * configure: Regenerate. + * config/rs6000/rs6000.c (rs6000_override_options): Alias power7 to + power5. + * config/rs6000/rs6000.h (ASM_CPU_POWER7_SPEC): Define. + (ASM_CPU_SPEC): Pass %(asm_cpu_power7) for -mcpu=power7. + (EXTRA_SPECS): Add asm_cpu_power7 spec string. + +2008-08-08 Dorit Nuzman <dorit@il.ibm.com> + + * tree-vect-transform.c (vectorizable_conversion): Pass the integral + type to vectorize.builtin_conversion. + (vectorizable_conversion): Likewise. + * config/i386/i386.c (ix86_vectorize_builtin_conversion): Always takes + integral type as input. + * config/rs6000/rs6000.c (rs6000_builtin_conversion): Add case for + FIX_TRUNC_EXPR. + (rs6000_expand_builtin): Add case for ALTIVEC_BUILTIN_VCTUXS + and ALTIVEC_BUILTIN_VCTSXS. + (rs6000_builtin_mul_widen_even. rs6000_builtin_mul_widen_odd): Fix + formatting. + +2008-08-08 Richard Guenther <rguenther@suse.de> + + * tree-ssa-ccp.c (likely_value): Calls are not all varying. + (surely_varying_stmt_p): Calls are varying only if they are + non-builtin and not indirect or have no result. + (ccp_fold): Re-instantiate code before the tuples merge. + +2008-08-08 Richard Guenther <rguenther@suse.de> + + PR tree-optimization/37056 + * gimple.h (gimple_assign_rhs_class): New helper function. + * tree-ssa-loop-niter.c (get_val_for): Fix tuplification, handle + unary operations properly. + +2008-08-07 Jan Hubicka <jh@suse.cz> + + * i386.h (ix86_size_cost): Declare. + (ix86_cur_cost): New function macro. + * i386.md (peepholes expanding size and splitters): Predicate by + optimize_insn_for_speed_p. + (peepholes reduce size and splitters): Predicate by + optimize_insn_for_size_p. + * i386.c (ix86_size_cost): Rename from ... + (size_cost): This one. + (override_options): Update. + (decide_alg): Likewise. + (ix86_expand_clear): Use RTL profile. + (ix86_pad_returns): Use RTL profile. + +2008-08-07 Jan Hubicka <jh@suse.cz> + + * recog.c (split_all_insns): Set RTL profile + (peephole2_optimize): Likewise. + * function.c (thread_prologue_and_epilogue_insns): Likewise. + * combine.c (combine_instructions): Likewise. + +2008-08-07 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> + + * c-common.c (c_common_reswords): Also warn about keyword "bool". + +2008-08-07 Bob Wilson <bob.wilson@acm.org> + + * config/xtensa/xtensa.c (xtensa_copy_incoming_a7): Copy incoming + value in a6 after the set_frame_ptr insn. + +2008-08-07 Richard Henderson <rth@redhat.com> + + PR debug/37033 + * gcc.c (cpp_options): Pass along -g*. + +2008-08-07 Joseph Myers <joseph@codesourcery.com> + + * config/arm/arm.c (output_move_neon): Update comment describing + big-endian vector layout. + (arm_assemble_integer): Do not handle big-endian NEON vectors + specially. + * config/arm/neon.md (vec_set<mode>_internal, vec_extract<mode>, + neon_vget_lane<mode>_sext_internal, + neon_vget_lane<mode>_zext_internal, neon_vget_lane<mode>): Adjust + element indices for big-endian. + +2008-08-07 Richard Henderson <rth@redhat.com> + + * configure.ac (HAVE_GAS_CFI_PERSONALITY_DIRECTIVE): New. + * configure, config.in: Rebuild. + * debug.h (dwarf2out_do_cfi_asm): Declare. + * c-cppbuiltin.c (c_cpp_builtins): Use it. + * dwarf2out.c (dwarf2out_do_cfi_asm): New. + (dwarf2out_cfi_label, add_fde_cfi, output_call_frame_info, + dwarf2out_begin_prologue, dwarf2out_end_epilogue): Use it. + +2008-08-07 Joseph Myers <joseph@codesourcery.com> + + * config/arm/iwmmxt.md (movv8qi_internal, movv4hi_internal, + movv2si_internal): Combine into mov<mode>_internal. + (movv2si_internal_2): Remove. + +2008-08-07 Jan Hubicka <jh@suse.cz> + + PR target/37048 + * i386.md (single stringop patterns): Enable unconditionally. + +2008-08-07 H.J. Lu <hongjiu.lu@intel.com> + + PR target/36992 + * config/i386/emmintrin.h (_mm_move_epi64): Use + __builtin_ia32_movq128. + + * config/i386/i386.c (ix86_builtins): Add IX86_BUILTIN_MOVQ128. + (bdesc_args): Add IX86_BUILTIN_MOVQ128. + + * config/i386/sse.md (sse2_movq128): New. + + * doc/extend.texi: Document __builtin_ia32_movq128. + +2008-08-07 Richard Guenther <rguenther@suse.de> + + PR middle-end/37042 + * tree-ssa-alias-warnings.c (nonstandard_alias_p): Ref-all + pointers can access anything. + +2008-08-06 Jan Hubicka <jh@suse.cz> + + * optabs.c (emit_unop_insn): Break out to ... + (maybe_emit_unop_insn): ... this one. + (expand_sfix_optab): Use maybe variant. + * optabs.h (maybe_emit_unop_insn): Declare. + + * i386.md (mov0 patterns): Enable by default. + (FP conversion expanders): Disable expansion of code expanding + sequences when instruction should be optimized for size. + (single strinop patterns): Enable when optimizing for size. + (string expanders): Disable expanding of code expanding sequences + when optimizning instruction for size. + * i386.c (ix86_expand_vector_move_misalign): Do code size optimization + per BB basis. + (ix86_fp_comparison_sahf_cost): Likewise. + (ix86_expand_branch): Likewise. + (ix86_expand_ashl_const): Likewise. + (ix86_split_ashl): Likewise. + (ix86_expand_strlen): Likewise. + (ix86_emit_fp_unordered_jump): Likewie. + +2008-08-06 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> + + * c-common.c: Fix typo. + (c_common_reswords): Activate more C++ keyword warnings. + + * matrix-reorg.c (compute_offset): Avoid C++ keywords. + +2008-08-06 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 26785 + * diagnostic.c (permerror_at): New. + * toplev.h (permerror_at): Declare. + +2008-08-06 Victor Kaplansky <victork@il.ibm.com> + Ira Rosen <irar@il.ibm.com> + + * tree-vect-transform.c (vect_model_simple_cost): Return + immediately if stmt is pure SLP. + (vect_model_store_cost): Ditto. + (vect_model_load_cost): Ditto. + (vectorizable_store): Remove PURE_SLP check before call + to vect_model_store_cost. + (vect_model_store_cost): When checking whether stmt describe + strided access, add a check that it is not slp_node. + +2008-08-06 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 8715 + * c-common.c (warn_for_sign_compare): New. Handle separately the + case that 'constant' is zero. + * c-typeck.c (build_binary_op): Move code to c-common.c + +2008-08-06 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> + + * config/alpha/alpha.c (alpha_preferred_reload_class, + alpha_secondary_reload, alpha_emit_set_const_1, function_value, + alpha_output_mi_thunk_osf): Avoid C++ keywords. + * config/arm/arm.c (output_move_vfp, output_move_neon): Likewise. + * config/arm/arm.md: Likewise. + * config/avr/avr-protos.h (preferred_reload_class, + test_hard_reg_class, avr_simplify_comparison_p, + out_shift_with_cnt, class_max_nregs): Likewise. + * config/avr/avr.c (class_max_nregs, avr_simplify_comparison_p, + output_movqi, output_movhi, output_movsisf, out_shift_with_cnt, + preferred_reload_class, test_hard_reg_class): Likewise. + * config/bfin/bfin.c (legitimize_pic_address, hard_regno_mode_ok, + bfin_memory_move_cost, bfin_secondary_reload, + bfin_output_mi_thunk): Likewise. + * config/crx/crx.c (crx_secondary_reload_class, + crx_memory_move_cost): Likewise. + * config/frv/frv-protos.h (frv_secondary_reload_class, + frv_class_likely_spilled_p, frv_class_max_nregs): Likewise. + * config/frv/frv.c (frv_override_options, frv_alloc_temp_reg, + frv_secondary_reload_class, frv_class_likely_spilled_p, + frv_class_max_nregs): Likewise. + * config/h8300/h8300.c (h8300_classify_operand, + h8300_unary_length, h8300_bitfield_length, h8300_asm_insn_count): + Likewise. + * config/i386/winnt.c (i386_pe_declare_function_type): Likewise. + * config/ia64/ia64.c (ia64_preferred_reload_class, + ia64_secondary_reload_class, ia64_output_mi_thunk): Likewise. + * config/iq2000/iq2000.c (gen_int_relational): Likewise. + * config/m32c/m32c.c (class_can_hold_mode, m32c_output_compare): + Likewise. + * config/m68hc11/m68hc11.c (preferred_reload_class, + m68hc11_memory_move_cost): Likewise. + * config/mcore/mcore.c (mcore_secondary_reload_class, + mcore_reload_class): Likewise. + * config/mips/mips.c (mips_hard_regno_mode_ok_p, + mips_class_max_nregs, mips_cannot_change_mode_class, + mips_preferred_reload_class, mips_secondary_reload_class, + mips_output_mi_thunk): Likewise. + * config/mmix/mmix.c (mmix_preferred_reload_class, + mmix_preferred_output_reload_class, mmix_secondary_reload_class): + Likewise. + * config/mn10300/mn10300.c (mn10300_secondary_reload_class): + Likewise. + * config/pa/pa.c (pa_secondary_reload, pa_combine_instructions, + pa_can_combine_p, pa_cannot_change_mode_class): Likewise. + * config/pa/pa.h (LEGITIMIZE_RELOAD_ADDRESS): Likewise. + * config/rs6000/rs6000.c (paired_expand_vector_init, + rs6000_secondary_reload_class, rs6000_output_mi_thunk, + compare_section_name, rs6000_memory_move_cost): Likewise. + * config/s390/s390.c (s390_emit_compare_and_swap, + s390_preferred_reload_class, s390_secondary_reload, + legitimize_pic_address, legitimize_tls_address, + legitimize_reload_address, s390_expand_cs_hqi, s390_expand_atomic, + s390_class_max_nregs): Likewise. + * config/s390/s390.h (LEGITIMIZE_RELOAD_ADDRESS): Likewise. + * config/s390/s390.md: Likewise. + * config/score/score-protos.h (score_secondary_reload_class, + score_preferred_reload_class): Likewise. + * config/score/score.c (score_preferred_reload_class, + score_secondary_reload_class): Likewise. + * config/score/score3.c (score3_output_mi_thunk, + score3_preferred_reload_class, score3_secondary_reload_class, + score3_hard_regno_mode_ok): Likewise. + * config/score/score3.h (score3_preferred_reload_class, + score3_secondary_reload_class): Likewise. + * config/score/score7.c (score7_output_mi_thunk, + score7_preferred_reload_class, score7_secondary_reload_class, + score7_hard_regno_mode_ok): Likewise. + * config/score/score7.h (score7_preferred_reload_class, + score7_secondary_reload_class): Likewise. + * config/sh/sh.c (prepare_move_operands, output_far_jump, + output_branchy_insn, add_constant, gen_block_redirect, + sh_insn_length_adjustment, sh_cannot_change_mode_class, + sh_output_mi_thunk, replace_n_hard_rtx, sh_secondary_reload): + Likewise. + * config/sparc/sparc.c (sparc_output_mi_thunk): Likewise. + * config/stormy16/stormy16.c (xstormy16_output_cbranch_hi, + xstormy16_output_cbranch_si, xstormy16_secondary_reload_class, + xstormy16_preferred_reload_class): Likewise. + * config/xtensa/xtensa.c (xtensa_expand_compare_and_swap, + xtensa_expand_atomic, override_options, + xtensa_preferred_reload_class, xtensa_secondary_reload_class): + Likewise. + * reorg.c (try_merge_delay_insns): Likewise. + * tree.c (merge_dllimport_decl_attributes): Likewise. + + * config/frv/frv.c (frv_print_operand): Change isalpha to ISALPHA. + +2008-08-06 Michael Matz <matz@suse.de> + + * Makefile.in (write_entries_to_file): Quote words. + * gengtype.c: (read_input_line): Skip over leading white-space. + +2008-08-06 Marc Gauthier <marc@tensilica.com> + + * config.gcc: Match more processor names for Xtensa. + * configure.ac: Likewise. + * doc/install.texi (Specific): Likewise. + * configure: Regenerate. + +2008-08-06 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> + + * builtins.c (expand_builtin_profile_func): Avoid C++ keywords. + * calls.c (avoid_likely_spilled_reg): Likewise. + * cfgexpand.c (gimple_assign_rhs_to_tree): Likewise. + * cgraph.c (cgraph_clone_edge, cgraph_clone_node): Likewise. + * config/i386/i386.c (ix86_expand_special_args_builtin, + ix86_secondary_reload): Likewise. + * except.c (struct eh_region, gen_eh_region_catch, + remove_unreachable_regions, duplicate_eh_regions, + assign_filter_values, build_post_landing_pads, + sjlj_find_directly_reachable_regions, remove_eh_handler, + reachable_next_level, foreach_reachable_handler, + can_throw_internal_1, can_throw_external_1, + collect_one_action_chain): Likewise. + * expr.c (expand_expr_real_1, vector_mode_valid_p): Likewise. + * fold-const.c (twoval_comparison_p, eval_subst): Likewise. + * function.c (update_temp_slot_address, instantiate_new_reg, + instantiate_virtual_regs_in_rtx, + instantiate_virtual_regs_in_insn): Likewise. + * gimple.c (extract_ops_from_tree, gimple_seq_copy): Likewise. + * gimplify.c (gimplify_call_expr, gimplify_init_constructor, + gimplify_cleanup_point_expr): Likewise. + * ipa-cp.c (ipcp_lattice_changed): Likewise. + * passes.c (next_pass_1): Likewise. + * print-tree.c (print_node_brief, print_node): Likewise. + * profile.c (branch_prob): Likewise. + * tree-dump.c (dump_register): Likewise. + * tree-eh.c (replace_goto_queue_cond_clause, lower_catch): + Likewise. + * tree-inline.c (remap_ssa_name, remap_type_1, remap_blocks, + copy_statement_list, remap_gimple_op_r, copy_tree_body_r, + copy_edges_for_bb, copy_cfg_body, copy_tree_r, + copy_arguments_for_versioning, copy_static_chain): Likewise. + * tree-into-ssa.c (names_replaced_by, add_to_repl_tbl, + add_new_name_mapping, register_new_name_mapping): Likewise. + * tree-mudflap.c (mf_xform_derefs): Likewise. + * tree-predcom.c (struct chain, dump_chain, replace_ref_with, + get_init_expr, combine_chains): Likewise. + * tree-pretty-print.c (dump_generic_node): Likewise. + * tree-ssa-structalias.c (create_variable_info_for): Likewise. + * tree-vrp.c (simplify_cond_using_ranges): Likewise. + * tree.c (substitute_in_expr, iterative_hash_expr): Likewise. + * value-prof.c (gimple_duplicate_stmt_histograms): Likewise. + +2008-08-06 H.J. Lu <hongjiu.lu@intel.com> + + PR middle-end/37010 + * calls.c (expand_call): Use the biggest preferred stack + boundary. + +2008-08-06 Michael Matz <matz@suse.de> + + PR target/36613 + * reload.c (push_reload): Merge in,out,in_reg,out_reg members + for reused reload, instead of overwriting them. + +2008-08-06 H.J. Lu <hongjiu.lu@intel.com> + + PR middle-end/37009 + * cfgexpand.c (expand_stack_alignment): Check parm_stack_boundary + for incoming stack boundary. + + * function.c (assign_parm_find_entry_rtl): Update + parm_stack_boundary. + + * function.h (rtl_data): Add parm_stack_boundary. + + * config/i386/i386.c (ix86_finalize_stack_realign_flags): Check + parm_stack_boundary for incoming stack boundary. + +2008-08-06 Joseph Myers <joseph@codesourcery.com> + + * jump.c (rtx_renumbered_equal_p): Do not call subreg_regno_offset + for unrepresentable subregs or treat them as equal to other regs + or subregs with the same register number. + 2008-08-06 Aldy Hernandez <aldyh@redhat.com> PR middle-end/35432 diff --git a/gcc/ChangeLog-2007 b/gcc/ChangeLog-2007 index 5327a6cf8c1..004ef92911d 100644 --- a/gcc/ChangeLog-2007 +++ b/gcc/ChangeLog-2007 @@ -26440,7 +26440,7 @@ * tree-ssa-coalesce.c (fail_abnormal_edge_coalesce): Remove spurious whitespace from error message. -2007-03-08 Volker Reichelt <reichelt@netcologne.de> +2007-03-08 Volker Reichelt <v.reichelt@netcologne.de> PR c++/30852 * c-common.c (fold_offsetof_1): Handle COMPOUND_EXPR. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 69a86636623..657795f131f 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20080806 +20080814 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 3edbd498179..aaaf1190623 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -262,8 +262,8 @@ write_entries_to_file = $(shell rm -f $(2) || :) $(shell touch $(2)) \ $(foreach range, \ $(shell i=1; while test $$i -le $(words $(1)); do \ echo $$i; i=`expr $$i + $(write_entries_to_file_split)`; done), \ - $(shell echo $(wordlist $(range), \ - $(shell expr $(range) + $(write_entries_to_file_split) - 1), $(1)) \ + $(shell echo "$(wordlist $(range), \ + $(shell expr $(range) + $(write_entries_to_file_split) - 1), $(1))" \ | tr ' ' '\n' >> $(2))) # -------- @@ -2384,7 +2384,7 @@ tree-vectorizer.o: tree-vectorizer.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(GGC_H) $(OPTABS_H) $(TREE_H) $(RTL_H) $(BASIC_BLOCK_H) \ $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(TIMEVAR_H) $(CFGLOOP_H) \ tree-pass.h $(EXPR_H) $(RECOG_H) tree-vectorizer.h $(TREE_DATA_REF_H) $(SCEV_H) \ - $(INPUT_H) $(TARGET_H) $(CFGLAYOUT_H) $(TOPLEV_H) tree-chrec.h + $(INPUT_H) $(TARGET_H) $(CFGLAYOUT_H) $(TOPLEV_H) tree-chrec.h langhooks.h tree-loop-linear.o: tree-loop-linear.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(GGC_H) $(OPTABS_H) $(TREE_H) $(RTL_H) $(BASIC_BLOCK_H) \ $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(TIMEVAR_H) $(CFGLOOP_H) \ diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index be092505283..bf3c7dd903d 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,127 @@ +2008-08-13 Samuel Tardieu <sam@rfc1149.net> + + PR ada/36777 + * sem_util.ads, sem_util.adb (Is_Protected_Self_Reference): New. + * sem_attr.adb (Check_Type): The current instance of a protected + object is not a type name. + (Analyze_Access_Attribute): Accept instances of protected objects. + (Analyze_Attribute, Attribute_Address clause): Ditto. + * exp_attr.adb (Expand_N_Attribute_Reference): Rewrite + the prefix as being the current instance if needed. + +2008-08-12 Danny Smith <danyssmith@users.sourceforge.net> + + * gcc-interface/Makefile.in (EXTRA_GNATRTL_NONTASKING_OBJS) [WINDOWS]: Remove + duplicate s-win32.o. Add s-winext.o. + +2008-08-12 Danny Smith <danyssmith@users.sourceforge.net> + + * g-stsifd-sockets.adb (Create): Replace Constants.SOCK_STREAM + with SOSC.SOCK__STREAM. + * g-socthi-mingw.adb (C_Select) Replace Constants.MSG_OOB with + SOSC.MSG_OOB. + +2008-08-11 Joel Sherrill <joel.sherrill@oarcorp.com> + + * s-oscons-tmplt.c: RTEMS defines AF_INET6 but does support it. + * gsocket.h, socket.c: Update to support RTEMS. + * gcc-interface/Make-lang.in: Include CFLAGS_FOR_TARGET when cross. + +2008-08-10 Samuel Tardieu <sam@rfc1149.net> + Robert Dewar <dewar@adacore.com> + + * exp_ch4.adb (Expand_N_Op_Expon): Force evaluation of + left argument even when right argument is 0. + (Expand_N_Op_Mod): Ditto when right argument is 1. + (Expand_N_Op_Multiply): Ditto when any argument is 0. + (Expand_N_Op_Rem): Ditto when right argument is 1. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + * gcc-interface/misc.c (gnat_handle_option): Replace set_Wunused + by warn_unused. + +2008-08-08 Ed Schonberg <schonberg@adacore.com> + + * freeze.adb (Generate_Prim_Op_References): New procedure, abstracted + from Freeze_Entity. Used to generate cross-reference information for + types declared in generic packages. + +2008-08-08 Thomas Quinot <quinot@adacore.com> + + * gcc-interface/Makefile.in: Reintroduce g-soccon.ads as a + compatibility shim. + +2008-08-08 Thomas Quinot <quinot@adacore.com> + + * gsocket.h: + On Windows, include <errno.h> and redefine only selected errno values + from their <winsock2.h> definitions. + + * s-osinte-freebsd.ads: Minor reformatting + + * s-osinte-hpux.ads, s-osinte-irix.ads: Minor reformatting + + * g-soccon.ads: New file. + + * g-stheme.adb, g-socthi-vms.adb, g-socthi-vxworks.adb, + g-socthi-mingw.adb, g-sttsne-vxworks.adb, g-socthi.adb, + g-stsifd-sockets.adb, g-socket.adb, g-socket.ads, + g-sothco.adb, g-sothco.ads: Add back GNAT.Sockets.Constants as a child + unit, to allow building software that depends on this internal unit + with both older and newer compilers. + +2008-08-08 Robert Dewar <dewar@adacore.com> + + * s-strxdr.adb: Minor reformatting + +2008-08-08 Bob Duff <duff@adacore.com> + + * gnat_ugn.texi: The "Run-Time Checks" section said "arithmetic overflow + checking for integer operations (including division by zero)", which + is wrong -- divide by zero is not part of overflow checking. + Also added misc clarification about what check-suppression means. + + * gnat_rm.texi: Clarify the meaning of pragma Suppress. + +2008-08-08 Jerome Lambourg <lambourg@adacore.com> + + * g-comlin.adb (Add_Switch): Handle addition of switches at the + begining of the command line. + (Append, Add): Renaming of Append to Add as this now allows addition + at the begining of the list. + + * g-comlin.ads (Add_Switch): Handle addition of switches at the + begining of the command line. + +2008-08-08 Thomas Quinot <quinot@adacore.com> + + * g-sercom.ads: + (Name): Document application scope (only legacy PC serial ports on + Linux and Windows). + +2008-08-08 Thomas Quinot <quinot@adacore.com> + + * gcc-interface/Makefile.in, gcc-interface/Make-lang.in: Revert + previous change, not needed after all. + +2008-08-08 Ed Schonberg <schonberg@adacore.com> + + * exp_ch4.adb (Expand_Allocator_Expression): add check if null + exclusion indicator is present + +2008-08-08 Robert Dewar <dewar@adacore.com> + + * g-comlin.adb: Minor code reorganization + Minor reformatting + + * g-comlin.ads: Minor reformatting + + * s-fileio.adb: Minor reformatting + + * sem_attr.adb: Minor code reorganization (use Nkind_In) + Minor reformatting + 2008-08-06 Samuel Tardieu <sam@rfc1149.net> * gcc-interface/Make-lang.in: Use GCC_FOR_TARGET when dealing diff --git a/gcc/ada/exp_attr.adb b/gcc/ada/exp_attr.adb index 890f09b1d82..80cd34d5593 100644 --- a/gcc/ada/exp_attr.adb +++ b/gcc/ada/exp_attr.adb @@ -636,6 +636,14 @@ package body Exp_Attr is Make_Build_In_Place_Call_In_Anonymous_Context (Pref); end if; + -- If prefix is a protected type name, this is a reference to + -- the current instance of the type. + + if Is_Protected_Self_Reference (Pref) then + Rewrite (Pref, Concurrent_Ref (Pref)); + Analyze (Pref); + end if; + -- Remaining processing depends on specific attribute case Id is diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index d0b60f313f7..2f95a84207d 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -944,6 +944,11 @@ package body Exp_Ch4 is Rewrite (N, New_Reference_To (Temp, Loc)); Analyze_And_Resolve (N, PtrT); + elsif Is_Access_Type (T) + and then Can_Never_Be_Null (T) + then + Install_Null_Excluding_Check (Exp); + elsif Is_Access_Type (DesigT) and then Nkind (Exp) = N_Allocator and then Nkind (Expression (Exp)) /= N_Qualified_Expression @@ -5466,6 +5471,13 @@ package body Exp_Ch4 is -- X ** 0 = 1 (or 1.0) if Expv = 0 then + + -- Call Remove_Side_Effects to ensure that any side effects + -- in the ignored left operand (in particular function calls + -- to user defined functions) are properly executed. + + Remove_Side_Effects (Base); + if Ekind (Typ) in Integer_Kind then Xnode := Make_Integer_Literal (Loc, Intval => 1); else @@ -5940,6 +5952,12 @@ package body Exp_Ch4 is and then Compile_Time_Known_Value (Right) and then Expr_Value (Right) = Uint_1 then + -- Call Remove_Side_Effects to ensure that any side effects in + -- the ignored left operand (in particular function calls to + -- user defined functions) are properly executed. + + Remove_Side_Effects (Left); + Rewrite (N, Make_Integer_Literal (Loc, 0)); Analyze_And_Resolve (N, Typ); return; @@ -5988,17 +6006,17 @@ package body Exp_Ch4 is -------------------------- procedure Expand_N_Op_Multiply (N : Node_Id) is - Loc : constant Source_Ptr := Sloc (N); - Lop : constant Node_Id := Left_Opnd (N); - Rop : constant Node_Id := Right_Opnd (N); + Loc : constant Source_Ptr := Sloc (N); + Lop : constant Node_Id := Left_Opnd (N); + Rop : constant Node_Id := Right_Opnd (N); - Lp2 : constant Boolean := - Nkind (Lop) = N_Op_Expon - and then Is_Power_Of_2_For_Shift (Lop); + Lp2 : constant Boolean := + Nkind (Lop) = N_Op_Expon + and then Is_Power_Of_2_For_Shift (Lop); - Rp2 : constant Boolean := - Nkind (Rop) = N_Op_Expon - and then Is_Power_Of_2_For_Shift (Rop); + Rp2 : constant Boolean := + Nkind (Rop) = N_Op_Expon + and then Is_Power_Of_2_For_Shift (Rop); Ltyp : constant Entity_Id := Etype (Lop); Rtyp : constant Entity_Id := Etype (Rop); @@ -6011,14 +6029,28 @@ package body Exp_Ch4 is if Is_Integer_Type (Typ) then - -- N * 0 = 0 * N = 0 for integer types + -- N * 0 = 0 for integer types - if (Compile_Time_Known_Value (Rop) - and then Expr_Value (Rop) = Uint_0) - or else - (Compile_Time_Known_Value (Lop) - and then Expr_Value (Lop) = Uint_0) + if Compile_Time_Known_Value (Rop) + and then Expr_Value (Rop) = Uint_0 then + -- Call Remove_Side_Effects to ensure that any side effects in + -- the ignored left operand (in particular function calls to + -- user defined functions) are properly executed. + + Remove_Side_Effects (Lop); + + Rewrite (N, Make_Integer_Literal (Loc, Uint_0)); + Analyze_And_Resolve (N, Typ); + return; + end if; + + -- Similar handling for 0 * N = 0 + + if Compile_Time_Known_Value (Lop) + and then Expr_Value (Lop) = Uint_0 + then + Remove_Side_Effects (Rop); Rewrite (N, Make_Integer_Literal (Loc, Uint_0)); Analyze_And_Resolve (N, Typ); return; @@ -6497,6 +6529,12 @@ package body Exp_Ch4 is and then Compile_Time_Known_Value (Right) and then Expr_Value (Right) = Uint_1 then + -- Call Remove_Side_Effects to ensure that any side effects in the + -- ignored left operand (in particular function calls to user defined + -- functions) are properly executed. + + Remove_Side_Effects (Left); + Rewrite (N, Make_Integer_Literal (Loc, 0)); Analyze_And_Resolve (N, Typ); return; diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb index 5a8f98380a7..5e069f4c7a4 100644 --- a/gcc/ada/freeze.adb +++ b/gcc/ada/freeze.adb @@ -134,6 +134,11 @@ package body Freeze is -- the designated type. Otherwise freezing the access type does not freeze -- the designated type. + procedure Generate_Prim_Op_References + (Typ : Entity_Id); + -- For a tagged type, generate implicit references to its primitive + -- operations, for source navigation. + procedure Process_Default_Expressions (E : Entity_Id; After : in out Node_Id); @@ -2600,6 +2605,10 @@ package body Freeze is -- -- type T is tagged; -- function F (X : Boolean) return T; -- ERROR + -- The type must be declared in the current scope + -- for the use to be legal, and the full view + -- must be available when the construct that mentions + -- it is frozen. elsif Ekind (Etype (E)) = E_Incomplete_Type and then Is_Tagged_Type (Etype (E)) @@ -2608,7 +2617,7 @@ package body Freeze is then Error_Msg_N ("(Ada 2005): invalid use of tagged incomplete type", - E); + E); end if; end if; end; @@ -2635,10 +2644,30 @@ package body Freeze is -- Here for other than a subprogram or type else + -- For a generic package, freeze types within, so that proper + -- cross-reference information is generated for tagged types. + -- This is the only freeze processing needed for generic packages. + + if Ekind (E) = E_Generic_Package then + declare + T : Entity_Id; + + begin + T := First_Entity (E); + + while Present (T) loop + if Is_Type (T) then + Generate_Prim_Op_References (T); + end if; + + Next_Entity (T); + end loop; + end; + -- If entity has a type, and it is not a generic unit, then -- freeze it first (RM 13.14(10)). - if Present (Etype (E)) + elsif Present (Etype (E)) and then Ekind (E) /= E_Generic_Function then Freeze_And_Append (Etype (E), Loc, Result); @@ -3628,66 +3657,9 @@ package body Freeze is end if; end if; - -- Generate primitive operation references for a tagged type - - if Is_Tagged_Type (E) - and then not Is_Class_Wide_Type (E) - then - declare - Prim_List : Elist_Id; - Prim : Elmt_Id; - Ent : Entity_Id; - Aux_E : Entity_Id; - - begin - -- Handle subtypes + -- Generate references to primitive operations for a tagged type - if Ekind (E) = E_Protected_Subtype - or else Ekind (E) = E_Task_Subtype - then - Aux_E := Etype (E); - else - Aux_E := E; - end if; - - -- Ada 2005 (AI-345): In case of concurrent type generate - -- reference to the wrapper that allow us to dispatch calls - -- through their implemented abstract interface types. - - -- The check for Present here is to protect against previously - -- reported critical errors. - - if Is_Concurrent_Type (Aux_E) - and then Present (Corresponding_Record_Type (Aux_E)) - then - Prim_List := Primitive_Operations - (Corresponding_Record_Type (Aux_E)); - else - Prim_List := Primitive_Operations (Aux_E); - end if; - - -- Loop to generate references for primitive operations - - if Present (Prim_List) then - Prim := First_Elmt (Prim_List); - while Present (Prim) loop - - -- If the operation is derived, get the original for - -- cross-reference purposes (it is the original for - -- which we want the xref, and for which the comes - -- from source test needs to be performed). - - Ent := Node (Prim); - while Present (Alias (Ent)) loop - Ent := Alias (Ent); - end loop; - - Generate_Reference (E, Ent, 'p', Set_Ref => False); - Next_Elmt (Prim); - end loop; - end if; - end; - end if; + Generate_Prim_Op_References (E); -- Now that all types from which E may depend are frozen, see if the -- size is known at compile time, if it must be unsigned, or if @@ -5232,6 +5204,74 @@ package body Freeze is end Is_Fully_Defined; --------------------------------- + -- Generate_Prim_Op_References -- + --------------------------------- + + procedure Generate_Prim_Op_References + (Typ : Entity_Id) + is + Base_T : Entity_Id; + Prim : Elmt_Id; + Prim_List : Elist_Id; + Ent : Entity_Id; + + begin + -- Handle subtypes of synchronized types. + + if Ekind (Typ) = E_Protected_Subtype + or else Ekind (Typ) = E_Task_Subtype + then + Base_T := Etype (Typ); + else + Base_T := Typ; + end if; + + -- References to primitive operations are only relevant for tagged types + + if not Is_Tagged_Type (Base_T) + or else Is_Class_Wide_Type (Base_T) + then + return; + end if; + + -- Ada 2005 (AI-345): For synchronized types generate reference + -- to the wrapper that allow us to dispatch calls through their + -- implemented abstract interface types. + + -- The check for Present here is to protect against previously + -- reported critical errors. + + if Is_Concurrent_Type (Base_T) + and then Present (Corresponding_Record_Type (Base_T)) + then + Prim_List := Primitive_Operations + (Corresponding_Record_Type (Base_T)); + else + Prim_List := Primitive_Operations (Base_T); + end if; + + if No (Prim_List) then + return; + end if; + + Prim := First_Elmt (Prim_List); + while Present (Prim) loop + + -- If the operation is derived, get the original for cross-reference + -- reference purposes (it is the original for which we want the xref + -- and for which the comes_from_source test must be performed). + + Ent := Node (Prim); + while Present (Alias (Ent)) loop + Ent := Alias (Ent); + end loop; + + Generate_Reference (Typ, Ent, 'p', Set_Ref => False); + Next_Elmt (Prim); + end loop; + end Generate_Prim_Op_References; + + --------------------------------- -- Process_Default_Expressions -- --------------------------------- diff --git a/gcc/ada/g-comlin.adb b/gcc/ada/g-comlin.adb index 02a0f9a47a8..11ed78a3476 100644 --- a/gcc/ada/g-comlin.adb +++ b/gcc/ada/g-comlin.adb @@ -1143,6 +1143,7 @@ package body GNAT.Command_Line is is Ret : Ada.Strings.Unbounded.Unbounded_String; use type Ada.Strings.Unbounded.Unbounded_String; + begin if Config = null or else Config.Switches = null then return ""; @@ -1150,9 +1151,10 @@ package body GNAT.Command_Line is for J in Config.Switches'Range loop if Config.Switches (J) (Config.Switches (J)'First) = Switch_Char then - Ret := Ret & " " & - Config.Switches (J) - (Config.Switches (J)'First + 1 .. Config.Switches (J)'Last); + Ret := + Ret & " " & + Config.Switches (J) + (Config.Switches (J)'First + 1 .. Config.Switches (J)'Last); else Ret := Ret & " " & Config.Switches (J).all; end if; @@ -1259,13 +1261,16 @@ package body GNAT.Command_Line is if not Is_Section then if Section = null then + -- Workaround some weird cases: some switches may -- expect parameters, but have the same value as -- longer switches: -gnaty3 (-gnaty, parameter=3) and -- -gnatya (-gnatya, no parameter). + -- So we are calling add_switch here with parameter -- attached. This will be anyway correctly handled by -- Add_Switch if -gnaty3 is actually furnished. + if Separator (Parser) = ASCII.NUL then Add_Switch (Cmd, Sw & Parameter (Parser), ""); @@ -1295,6 +1300,7 @@ package body GNAT.Command_Line is -- Add it with no parameter, if that's the way the user -- wants it. + -- Specify the separator in all cases, as the switch might -- need to be unaliased, and the alias might contain -- switches with parameters. @@ -1406,9 +1412,11 @@ package body GNAT.Command_Line is (Prefix : String; Group : String) return Boolean is - Idx : Natural := Group'First; + Idx : Natural; Found : Boolean; + begin + Idx := Group'First; while Idx <= Group'Last loop Found := False; @@ -1424,17 +1432,23 @@ package body GNAT.Command_Line is begin if Sw'Length >= Prefix'Length - -- Verify that sw starts with Prefix - and then Looking_At (Sw, Sw'First, Prefix) - -- Verify that the group starts with sw - and then Looking_At (Full, Full'First, Sw) + + -- Verify that sw starts with Prefix + + and then Looking_At (Sw, Sw'First, Prefix) + + -- Verify that the group starts with sw + + and then Looking_At (Full, Full'First, Sw) then Last := Idx + Sw'Length - Prefix'Length - 1; Param := Last + 1; if Can_Have_Parameter (Cmd.Config.Switches (S).all) then + -- Include potential parameter to the recursive call. -- Only numbers are allowed. + while Last < Group'Last and then Group (Last + 1) in '0' .. '9' loop @@ -1456,12 +1470,14 @@ package body GNAT.Command_Line is -- a parameter is detected in the switch, as this -- is a way to correctly identify such a parameter -- in aliases. + return False; end if; Found := True; -- Recursive call, using the detected parameter if any + if Last >= Param then For_Each_Simple_Switch (Cmd, @@ -1871,16 +1887,19 @@ package body GNAT.Command_Line is function Compatible_Parameter (Param : String_Access) return Boolean is begin + -- No parameter OK + if Param = null then - -- No parameter, OK return True; + -- We need parameters without separators + elsif Param (Param'First) /= ASCII.NUL then - -- We need parameters without separators... return False; + -- Parameters must be all digits + else - -- We need number only parameters. for J in Param'First + 1 .. Param'Last loop if Param (J) not in '0' .. '9' then return False; @@ -1889,13 +1908,16 @@ package body GNAT.Command_Line is return True; end if; - end Compatible_Parameter; - Group : Ada.Strings.Unbounded.Unbounded_String; - First : Natural; + -- Local declarations + + Group : Ada.Strings.Unbounded.Unbounded_String; + First : Natural; use type Ada.Strings.Unbounded.Unbounded_String; + -- Start of processing for Group_Switches + begin if Cmd.Config = null or else Cmd.Config.Prefixes = null @@ -1914,24 +1936,26 @@ package body GNAT.Command_Line is (Result (C).all, Result (C)'First, Cmd.Config.Prefixes (P).all) then -- If we are still in the same section, group the switches + if First = 0 or else (Sections (C) = null - and then Sections (First) = null) + and then Sections (First) = null) or else (Sections (C) /= null - and then Sections (First) /= null - and then Sections (C).all = Sections (First).all) + and then Sections (First) /= null + and then Sections (C).all = Sections (First).all) then Group := Group & Result (C) (Result (C)'First + Cmd.Config.Prefixes (P)'Length .. - Result (C)'Last); + Result (C)'Last); if Params (C) /= null then - Group := Group & - Params (C) (Params (C)'First + 1 .. Params (C)'Last); + Group := + Group & + Params (C) (Params (C)'First + 1 .. Params (C)'Last); Free (Params (C)); end if; @@ -1940,9 +1964,11 @@ package body GNAT.Command_Line is end if; Free (Result (C)); + else -- We changed section: we put the grouped switches to the -- first place, on continue with the new section. + Result (First) := new String' (Cmd.Config.Prefixes (P).all & diff --git a/gcc/ada/g-comlin.ads b/gcc/ada/g-comlin.ads index 738afe96a69..41cdfb8e36d 100644 --- a/gcc/ada/g-comlin.ads +++ b/gcc/ada/g-comlin.ads @@ -530,8 +530,7 @@ package GNAT.Command_Line is function Get_Switches (Config : Command_Line_Configuration; - Switch_Char : Character) - return String; + Switch_Char : Character) return String; -- Get the switches list as expected by getopt. This list is built using -- all switches defined previously via Define_Switch above. @@ -636,7 +635,7 @@ package GNAT.Command_Line is -- If Remove_All is True, then all matching switches are removed, otherwise -- only the first matching one is removed. -- - -- if Has_Parameter is set to True, then only switches having a parameter + -- If Has_Parameter is set to True, then only switches having a parameter -- are removed. -- -- If the switch belongs to a section, then this section should be @@ -664,7 +663,7 @@ package GNAT.Command_Line is -- string, then only a switch with no parameter will be removed. --------------- - -- Iterating -- + -- Iteration -- --------------- type Command_Line_Iterator is private; @@ -807,15 +806,15 @@ private Prefixes : GNAT.OS_Lib.Argument_List_Access; -- The list of prefixes - Sections : GNAT.OS_Lib.Argument_List_Access; + Sections : GNAT.OS_Lib.Argument_List_Access; -- The list of sections Aliases : GNAT.OS_Lib.Argument_List_Access; Expansions : GNAT.OS_Lib.Argument_List_Access; - -- The aliases. Both arrays have the same indices + -- The aliases (Both arrays have the same bounds) - Switches : GNAT.OS_Lib.Argument_List_Access; - -- List of expected switches. Used when expanding switch groups. + Switches : GNAT.OS_Lib.Argument_List_Access; + -- List of expected switches (Used when expanding switch groups) end record; type Command_Line_Configuration is access Command_Line_Configuration_Record; @@ -825,19 +824,19 @@ private Params : GNAT.OS_Lib.Argument_List_Access; -- Parameter for the corresponding switch in Expanded. The first - -- character is the separator (or ASCII.NUL if there is no separator) + -- character is the separator (or ASCII.NUL if there is no separator). - Sections : GNAT.OS_Lib.Argument_List_Access; + Sections : GNAT.OS_Lib.Argument_List_Access; -- The list of sections Coalesce : GNAT.OS_Lib.Argument_List_Access; Coalesce_Params : GNAT.OS_Lib.Argument_List_Access; Coalesce_Sections : GNAT.OS_Lib.Argument_List_Access; - -- Cached version of the command line. This is recomputed every time the - -- command line changes. Switches are grouped as much as possible, and - -- aliases are used to reduce the length of the command line. - -- The parameters are not allocated, they point into Params, so must not - -- be freed. + -- Cached version of the command line. This is recomputed every time + -- the command line changes. Switches are grouped as much as possible, + -- and aliases are used to reduce the length of the command line. The + -- parameters are not allocated, they point into Params, so they must + -- not be freed. end record; type Command_Line_Iterator is record diff --git a/gcc/ada/g-sercom.ads b/gcc/ada/g-sercom.ads index e425d9d5550..8b4c5590684 100644 --- a/gcc/ada/g-sercom.ads +++ b/gcc/ada/g-sercom.ads @@ -45,7 +45,11 @@ package GNAT.Serial_Communications is -- A serial com port name function Name (Number : Positive) return Port_Name; - -- Returns the port name for the given port number + -- Returns a possible port name for the given legacy PC architecture serial + -- port number (COM<number>: on Windows, ttyS<number-1> on Linux). + -- Note that this function does not support other kinds of serial ports + -- nor operating systems other than Windows and Linux. For all other + -- cases, an explicit port name can be passed directly to Open. type Data_Rate is (B1200, B2400, B4800, B9600, B19200, B38400, B57600, B115200); diff --git a/gcc/ada/g-socket.adb b/gcc/ada/g-socket.adb index e1fc4099308..2f729bd0314 100644 --- a/gcc/ada/g-socket.adb +++ b/gcc/ada/g-socket.adb @@ -58,7 +58,7 @@ package body GNAT.Sockets is ENOERROR : constant := 0; - Netdb_Buffer_Size : constant := Constants.Need_Netdb_Buffer * 1024; + Netdb_Buffer_Size : constant := SOSC.Need_Netdb_Buffer * 1024; -- The network database functions gethostbyname, gethostbyaddr, -- getservbyname and getservbyport can either be guaranteed task safe by -- the operating system, or else return data through a user-provided buffer @@ -67,49 +67,49 @@ package body GNAT.Sockets is -- Correspondence tables Levels : constant array (Level_Type) of C.int := - (Socket_Level => Constants.SOL_SOCKET, - IP_Protocol_For_IP_Level => Constants.IPPROTO_IP, - IP_Protocol_For_UDP_Level => Constants.IPPROTO_UDP, - IP_Protocol_For_TCP_Level => Constants.IPPROTO_TCP); + (Socket_Level => SOSC.SOL_SOCKET, + IP_Protocol_For_IP_Level => SOSC.IPPROTO_IP, + IP_Protocol_For_UDP_Level => SOSC.IPPROTO_UDP, + IP_Protocol_For_TCP_Level => SOSC.IPPROTO_TCP); Modes : constant array (Mode_Type) of C.int := - (Socket_Stream => Constants.SOCK_STREAM, - Socket_Datagram => Constants.SOCK_DGRAM); + (Socket_Stream => SOSC.SOCK_STREAM, + Socket_Datagram => SOSC.SOCK_DGRAM); Shutmodes : constant array (Shutmode_Type) of C.int := - (Shut_Read => Constants.SHUT_RD, - Shut_Write => Constants.SHUT_WR, - Shut_Read_Write => Constants.SHUT_RDWR); + (Shut_Read => SOSC.SHUT_RD, + Shut_Write => SOSC.SHUT_WR, + Shut_Read_Write => SOSC.SHUT_RDWR); Requests : constant array (Request_Name) of C.int := - (Non_Blocking_IO => Constants.FIONBIO, - N_Bytes_To_Read => Constants.FIONREAD); + (Non_Blocking_IO => SOSC.FIONBIO, + N_Bytes_To_Read => SOSC.FIONREAD); Options : constant array (Option_Name) of C.int := - (Keep_Alive => Constants.SO_KEEPALIVE, - Reuse_Address => Constants.SO_REUSEADDR, - Broadcast => Constants.SO_BROADCAST, - Send_Buffer => Constants.SO_SNDBUF, - Receive_Buffer => Constants.SO_RCVBUF, - Linger => Constants.SO_LINGER, - Error => Constants.SO_ERROR, - No_Delay => Constants.TCP_NODELAY, - Add_Membership => Constants.IP_ADD_MEMBERSHIP, - Drop_Membership => Constants.IP_DROP_MEMBERSHIP, - Multicast_If => Constants.IP_MULTICAST_IF, - Multicast_TTL => Constants.IP_MULTICAST_TTL, - Multicast_Loop => Constants.IP_MULTICAST_LOOP, - Receive_Packet_Info => Constants.IP_PKTINFO, - Send_Timeout => Constants.SO_SNDTIMEO, - Receive_Timeout => Constants.SO_RCVTIMEO); + (Keep_Alive => SOSC.SO_KEEPALIVE, + Reuse_Address => SOSC.SO_REUSEADDR, + Broadcast => SOSC.SO_BROADCAST, + Send_Buffer => SOSC.SO_SNDBUF, + Receive_Buffer => SOSC.SO_RCVBUF, + Linger => SOSC.SO_LINGER, + Error => SOSC.SO_ERROR, + No_Delay => SOSC.TCP_NODELAY, + Add_Membership => SOSC.IP_ADD_MEMBERSHIP, + Drop_Membership => SOSC.IP_DROP_MEMBERSHIP, + Multicast_If => SOSC.IP_MULTICAST_IF, + Multicast_TTL => SOSC.IP_MULTICAST_TTL, + Multicast_Loop => SOSC.IP_MULTICAST_LOOP, + Receive_Packet_Info => SOSC.IP_PKTINFO, + Send_Timeout => SOSC.SO_SNDTIMEO, + Receive_Timeout => SOSC.SO_RCVTIMEO); -- ??? Note: for OpenSolaris, Receive_Packet_Info should be IP_RECVPKTINFO, -- but for Linux compatibility this constant is the same as IP_PKTINFO. Flags : constant array (0 .. 3) of C.int := - (0 => Constants.MSG_OOB, -- Process_Out_Of_Band_Data - 1 => Constants.MSG_PEEK, -- Peek_At_Incoming_Data - 2 => Constants.MSG_WAITALL, -- Wait_For_A_Full_Reception - 3 => Constants.MSG_EOR); -- Send_End_Of_Record + (0 => SOSC.MSG_OOB, -- Process_Out_Of_Band_Data + 1 => SOSC.MSG_PEEK, -- Peek_At_Incoming_Data + 2 => SOSC.MSG_WAITALL, -- Wait_For_A_Full_Reception + 3 => SOSC.MSG_EOR); -- Send_End_Of_Record Socket_Error_Id : constant Exception_Id := Socket_Error'Identity; Host_Error_Id : constant Exception_Id := Host_Error'Identity; @@ -138,7 +138,7 @@ package body GNAT.Sockets is -- Return the int value corresponding to the specified flags combination function Set_Forced_Flags (F : C.int) return C.int; - -- Return F with the bits from Constants.MSG_Forced_Flags forced set + -- Return F with the bits from SOSC.MSG_Forced_Flags forced set function Short_To_Network (S : C.unsigned_short) return C.unsigned_short; @@ -882,7 +882,7 @@ package body GNAT.Sockets is Err : aliased C.int; begin - if Safe_Gethostbyaddr (HA'Address, HA'Size / 8, Constants.AF_INET, + if Safe_Gethostbyaddr (HA'Address, HA'Size / 8, SOSC.AF_INET, Res'Access, Buf'Address, Buflen, Err'Access) /= 0 then Raise_Host_Error (Integer (Err)); @@ -1260,7 +1260,7 @@ package body GNAT.Sockets is -- calling Inet_Addr("") will not return an error. elsif Image = "" then - Raise_Socket_Error (Constants.EINVAL); + Raise_Socket_Error (SOSC.EINVAL); end if; Img := New_String (Image); @@ -1268,7 +1268,7 @@ package body GNAT.Sockets is Free (Img); if Res = Failure then - Raise_Socket_Error (Constants.EINVAL); + Raise_Socket_Error (SOSC.EINVAL); end if; To_Inet_Addr (To_In_Addr (Res), Result); @@ -1280,7 +1280,7 @@ package body GNAT.Sockets is ---------------- procedure Initialize (Process_Blocking_IO : Boolean) is - Expected : constant Boolean := not Constants.Thread_Blocking_IO; + Expected : constant Boolean := not SOSC.Thread_Blocking_IO; begin if Process_Blocking_IO /= Expected then raise Socket_Error with @@ -1613,16 +1613,16 @@ package body GNAT.Sockets is (Error_Value : Integer; From_Errno : Boolean := True) return Error_Type is - use GNAT.Sockets.Constants; + use GNAT.Sockets.SOSC; begin if not From_Errno then case Error_Value is - when Constants.HOST_NOT_FOUND => return Unknown_Host; - when Constants.TRY_AGAIN => return Host_Name_Lookup_Failure; - when Constants.NO_RECOVERY => return Non_Recoverable_Error; - when Constants.NO_DATA => return Unknown_Server_Error; - when others => return Cannot_Resolve_Error; + when SOSC.HOST_NOT_FOUND => return Unknown_Host; + when SOSC.TRY_AGAIN => return Host_Name_Lookup_Failure; + when SOSC.NO_RECOVERY => return Non_Recoverable_Error; + when SOSC.NO_DATA => return Unknown_Server_Error; + when others => return Cannot_Resolve_Error; end case; end if; @@ -1828,8 +1828,8 @@ package body GNAT.Sockets is pragma Warnings (Off); -- Following test may be compile time known on some targets - if Vector'Length - Iov_Count > Constants.IOV_MAX then - This_Iov_Count := Constants.IOV_MAX; + if Vector'Length - Iov_Count > SOSC.IOV_MAX then + This_Iov_Count := SOSC.IOV_MAX; else This_Iov_Count := Vector'Length - Iov_Count; end if; @@ -1879,7 +1879,7 @@ package body GNAT.Sockets is function To_int is new Ada.Unchecked_Conversion (C.unsigned, C.int); begin - return To_int (To_unsigned (F) or Constants.MSG_Forced_Flags); + return To_int (To_unsigned (F) or SOSC.MSG_Forced_Flags); end Set_Forced_Flags; ----------------------- @@ -2160,7 +2160,7 @@ package body GNAT.Sockets is if Current mod 2 /= 0 then if Flags (J) = -1 then - Raise_Socket_Error (Constants.EOPNOTSUPP); + Raise_Socket_Error (SOSC.EOPNOTSUPP); end if; Result := Result + Flags (J); diff --git a/gcc/ada/g-socket.ads b/gcc/ada/g-socket.ads index 5ec84056423..045e3bfb7d0 100644 --- a/gcc/ada/g-socket.ads +++ b/gcc/ada/g-socket.ads @@ -369,7 +369,7 @@ package GNAT.Sockets is -- Finalize; -- end PingPong; - package Constants renames System.OS_Constants; + package SOSC renames System.OS_Constants; -- Renaming used to provide short-hand notations thoughout the sockets -- binding. Note that System.OS_Constants is an internal unit, and the -- entities declared therein are not meant for direct access by users, @@ -414,10 +414,9 @@ package GNAT.Sockets is Immediate : constant Duration := 0.0; - Timeval_Forever : constant := - 2.0 ** (Constants.SIZEOF_tv_sec * 8 - 1) - 1.0; - Forever : constant Duration := - Duration'Min (Duration'Last, Timeval_Forever); + Timeval_Forever : constant := 2.0 ** (SOSC.SIZEOF_tv_sec * 8 - 1) - 1.0; + Forever : constant Duration := + Duration'Min (Duration'Last, Timeval_Forever); subtype Timeval_Duration is Duration range Immediate .. Forever; diff --git a/gcc/ada/g-socthi-mingw.adb b/gcc/ada/g-socthi-mingw.adb index 3e13641d34f..8c048eef132 100644 --- a/gcc/ada/g-socthi-mingw.adb +++ b/gcc/ada/g-socthi-mingw.adb @@ -239,8 +239,8 @@ package body GNAT.Sockets.Thin is Res := Standard_Connect (S, Name, Namelen); if Res = -1 then - if Socket_Errno = Constants.EWOULDBLOCK then - Set_Socket_Errno (Constants.EINPROGRESS); + if Socket_Errno = SOSC.EWOULDBLOCK then + Set_Socket_Errno (SOSC.EINPROGRESS); end if; end if; @@ -341,7 +341,7 @@ package body GNAT.Sockets.Thin is if EFS /= No_Fd_Set_Access then declare EFSC : constant Fd_Set_Access := New_Socket_Set (EFS); - Flag : constant C.int := Constants.MSG_PEEK + Constants.MSG_OOB; + Flag : constant C.int := SOSC.MSG_PEEK + SOSC.MSG_OOB; Buffer : Character; Length : C.int; Fromlen : aliased C.int; @@ -487,7 +487,7 @@ package body GNAT.Sockets.Thin is function Socket_Error_Message (Errno : Integer) return C.Strings.chars_ptr is - use GNAT.Sockets.Constants; + use GNAT.Sockets.SOSC; begin case Errno is when EINTR => return Error_Messages (N_EINTR); diff --git a/gcc/ada/g-socthi-vms.adb b/gcc/ada/g-socthi-vms.adb index b94e0d0f4be..0151ef567f4 100644 --- a/gcc/ada/g-socthi-vms.adb +++ b/gcc/ada/g-socthi-vms.adb @@ -52,7 +52,7 @@ package body GNAT.Sockets.Thin is -- been set in non-blocking mode by the user. Quantum : constant Duration := 0.2; - -- When Constants.Thread_Blocking_IO is False, we set sockets in + -- When SOSC.Thread_Blocking_IO is False, we set sockets in -- non-blocking mode and we spend a period of time Quantum between -- two attempts on a blocking operation. @@ -134,14 +134,14 @@ package body GNAT.Sockets.Thin is begin loop R := Syscall_Accept (S, Addr, Addrlen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else R /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; - if not Constants.Thread_Blocking_IO + if not SOSC.Thread_Blocking_IO and then R /= Failure then -- A socket inherits the properties of its server, especially @@ -149,7 +149,7 @@ package body GNAT.Sockets.Thin is -- tracks sockets set in non-blocking mode by user. Set_Non_Blocking_Socket (R, Non_Blocking_Socket (S)); - Discard := Syscall_Ioctl (R, Constants.FIONBIO, Val'Unchecked_Access); + Discard := Syscall_Ioctl (R, SOSC.FIONBIO, Val'Unchecked_Access); end if; return R; @@ -169,10 +169,10 @@ package body GNAT.Sockets.Thin is begin Res := Syscall_Connect (S, Name, Namelen); - if Constants.Thread_Blocking_IO + if SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EINPROGRESS + or else Errno /= SOSC.EINPROGRESS then return Res; end if; @@ -208,7 +208,7 @@ package body GNAT.Sockets.Thin is Res := Syscall_Connect (S, Name, Namelen); - if Res = Failure and then Errno = Constants.EISCONN then + if Res = Failure and then Errno = SOSC.EISCONN then return Thin_Common.Success; else @@ -226,8 +226,8 @@ package body GNAT.Sockets.Thin is Arg : Int_Access) return C.int is begin - if not Constants.Thread_Blocking_IO - and then Req = Constants.FIONBIO + if not SOSC.Thread_Blocking_IO + and then Req = SOSC.FIONBIO then if Arg.all /= 0 then Set_Non_Blocking_Socket (S, True); @@ -252,10 +252,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Recv (S, Msg, Len, Flags); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -279,10 +279,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Recvfrom (S, Msg, Len, Flags, From, Fromlen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -304,10 +304,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Send (S, Msg, Len, Flags); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -331,10 +331,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Sendto (S, Msg, Len, Flags, To, Tolen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -359,13 +359,13 @@ package body GNAT.Sockets.Thin is begin R := Syscall_Socket (Domain, Typ, Protocol); - if not Constants.Thread_Blocking_IO + if not SOSC.Thread_Blocking_IO and then R /= Failure then -- Do not use C_Ioctl as this subprogram tracks sockets set -- in non-blocking mode by user. - Discard := Syscall_Ioctl (R, Constants.FIONBIO, Val'Unchecked_Access); + Discard := Syscall_Ioctl (R, SOSC.FIONBIO, Val'Unchecked_Access); Set_Non_Blocking_Socket (R, False); end if; @@ -508,7 +508,7 @@ package body GNAT.Sockets.Thin is (Fd, Iovec (J).Base.all'Address, Interfaces.C.int (Iovec (J).Length), - Constants.MSG_Forced_Flags); + SOSC.MSG_Forced_Flags); if Res < 0 then return Res; diff --git a/gcc/ada/g-socthi-vxworks.adb b/gcc/ada/g-socthi-vxworks.adb index 1872b8b560f..3a1d1fe9a5f 100644 --- a/gcc/ada/g-socthi-vxworks.adb +++ b/gcc/ada/g-socthi-vxworks.adb @@ -56,7 +56,7 @@ package body GNAT.Sockets.Thin is -- been set in non-blocking mode by the user. Quantum : constant Duration := 0.2; - -- When Constants.Thread_Blocking_IO is False, we set sockets in + -- When SOSC.Thread_Blocking_IO is False, we set sockets in -- non-blocking mode and we spend a period of time Quantum between -- two attempts on a blocking operation. @@ -146,14 +146,14 @@ package body GNAT.Sockets.Thin is begin loop R := Syscall_Accept (S, Addr, Addrlen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else R /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; - if not Constants.Thread_Blocking_IO + if not SOSC.Thread_Blocking_IO and then R /= Failure then -- A socket inherits the properties of its server especially @@ -161,7 +161,7 @@ package body GNAT.Sockets.Thin is -- tracks sockets set in non-blocking mode by user. Set_Non_Blocking_Socket (R, Non_Blocking_Socket (S)); - Res := Syscall_Ioctl (R, Constants.FIONBIO, Val'Unchecked_Access); + Res := Syscall_Ioctl (R, SOSC.FIONBIO, Val'Unchecked_Access); -- Is it OK to ignore result ??? end if; @@ -182,10 +182,10 @@ package body GNAT.Sockets.Thin is begin Res := Syscall_Connect (S, Name, Namelen); - if Constants.Thread_Blocking_IO + if SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EINPROGRESS + or else Errno /= SOSC.EINPROGRESS then return Res; end if; @@ -223,7 +223,7 @@ package body GNAT.Sockets.Thin is Res := Syscall_Connect (S, Name, Namelen); if Res = Failure - and then Errno = Constants.EISCONN + and then Errno = SOSC.EISCONN then return Thin_Common.Success; else @@ -241,8 +241,8 @@ package body GNAT.Sockets.Thin is Arg : Int_Access) return C.int is begin - if not Constants.Thread_Blocking_IO - and then Req = Constants.FIONBIO + if not SOSC.Thread_Blocking_IO + and then Req = SOSC.FIONBIO then if Arg.all /= 0 then Set_Non_Blocking_Socket (S, True); @@ -267,10 +267,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Recv (S, Msg, Len, Flags); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -294,10 +294,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Recvfrom (S, Msg, Len, Flags, From, Fromlen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -319,10 +319,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Send (S, Msg, Len, Flags); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -346,10 +346,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Sendto (S, Msg, Len, Flags, To, Tolen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -374,13 +374,13 @@ package body GNAT.Sockets.Thin is begin R := Syscall_Socket (Domain, Typ, Protocol); - if not Constants.Thread_Blocking_IO + if not SOSC.Thread_Blocking_IO and then R /= Failure then -- Do not use C_Ioctl as this subprogram tracks sockets set -- in non-blocking mode by user. - Res := Syscall_Ioctl (R, Constants.FIONBIO, Val'Unchecked_Access); + Res := Syscall_Ioctl (R, SOSC.FIONBIO, Val'Unchecked_Access); -- Is it OK to ignore result ??? Set_Non_Blocking_Socket (R, False); end if; diff --git a/gcc/ada/g-socthi.adb b/gcc/ada/g-socthi.adb index cc90c640a04..57b76bc2fe0 100644 --- a/gcc/ada/g-socthi.adb +++ b/gcc/ada/g-socthi.adb @@ -56,7 +56,7 @@ package body GNAT.Sockets.Thin is -- been set in non-blocking mode by the user. Quantum : constant Duration := 0.2; - -- When Constants.Thread_Blocking_IO is False, we set sockets in + -- When SOSC.Thread_Blocking_IO is False, we set sockets in -- non-blocking mode and we spend a period of time Quantum between -- two attempts on a blocking operation. @@ -150,14 +150,14 @@ package body GNAT.Sockets.Thin is begin loop R := Syscall_Accept (S, Addr, Addrlen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else R /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; - if not Constants.Thread_Blocking_IO + if not SOSC.Thread_Blocking_IO and then R /= Failure then -- A socket inherits the properties ot its server especially @@ -165,7 +165,7 @@ package body GNAT.Sockets.Thin is -- tracks sockets set in non-blocking mode by user. Set_Non_Blocking_Socket (R, Non_Blocking_Socket (S)); - Discard := Syscall_Ioctl (R, Constants.FIONBIO, Val'Unchecked_Access); + Discard := Syscall_Ioctl (R, SOSC.FIONBIO, Val'Unchecked_Access); end if; Disable_SIGPIPE (R); @@ -186,10 +186,10 @@ package body GNAT.Sockets.Thin is begin Res := Syscall_Connect (S, Name, Namelen); - if Constants.Thread_Blocking_IO + if SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EINPROGRESS + or else Errno /= SOSC.EINPROGRESS then return Res; end if; @@ -226,7 +226,7 @@ package body GNAT.Sockets.Thin is Res := Syscall_Connect (S, Name, Namelen); if Res = Failure - and then Errno = Constants.EISCONN + and then Errno = SOSC.EISCONN then return Thin_Common.Success; else @@ -244,8 +244,8 @@ package body GNAT.Sockets.Thin is Arg : Int_Access) return C.int is begin - if not Constants.Thread_Blocking_IO - and then Req = Constants.FIONBIO + if not SOSC.Thread_Blocking_IO + and then Req = SOSC.FIONBIO then if Arg.all /= 0 then Set_Non_Blocking_Socket (S, True); @@ -270,10 +270,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Recv (S, Msg, Len, Flags); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -297,10 +297,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Recvfrom (S, Msg, Len, Flags, From, Fromlen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -322,10 +322,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Send (S, Msg, Len, Flags); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -349,10 +349,10 @@ package body GNAT.Sockets.Thin is begin loop Res := Syscall_Sendto (S, Msg, Len, Flags, To, Tolen); - exit when Constants.Thread_Blocking_IO + exit when SOSC.Thread_Blocking_IO or else Res /= Failure or else Non_Blocking_Socket (S) - or else Errno /= Constants.EWOULDBLOCK; + or else Errno /= SOSC.EWOULDBLOCK; delay Quantum; end loop; @@ -377,13 +377,13 @@ package body GNAT.Sockets.Thin is begin R := Syscall_Socket (Domain, Typ, Protocol); - if not Constants.Thread_Blocking_IO + if not SOSC.Thread_Blocking_IO and then R /= Failure then -- Do not use C_Ioctl as this subprogram tracks sockets set -- in non-blocking mode by user. - Discard := Syscall_Ioctl (R, Constants.FIONBIO, Val'Unchecked_Access); + Discard := Syscall_Ioctl (R, SOSC.FIONBIO, Val'Unchecked_Access); Set_Non_Blocking_Socket (R, False); end if; Disable_SIGPIPE (R); diff --git a/gcc/ada/g-sothco.adb b/gcc/ada/g-sothco.adb index 590bffeee80..7a8b5a13e00 100644 --- a/gcc/ada/g-sothco.adb +++ b/gcc/ada/g-sothco.adb @@ -54,7 +54,7 @@ package body GNAT.Sockets.Thin_Common is Family : Family_Type) is C_Family : C.int renames Families (Family); - Has_Sockaddr_Len : constant Boolean := Constants.Has_Sockaddr_Len /= 0; + Has_Sockaddr_Len : constant Boolean := SOSC.Has_Sockaddr_Len /= 0; begin if Has_Sockaddr_Len then Length_And_Family.Length := Lengths (Family); diff --git a/gcc/ada/g-sothco.ads b/gcc/ada/g-sothco.ads index 5780c035414..434557d1f08 100644 --- a/gcc/ada/g-sothco.ads +++ b/gcc/ada/g-sothco.ads @@ -51,15 +51,15 @@ package GNAT.Sockets.Thin_Common is Failure : constant C.int := -1; type time_t is - range -2 ** (8 * Constants.SIZEOF_tv_sec - 1) - .. 2 ** (8 * Constants.SIZEOF_tv_sec - 1) - 1; - for time_t'Size use 8 * Constants.SIZEOF_tv_sec; + range -2 ** (8 * SOSC.SIZEOF_tv_sec - 1) + .. 2 ** (8 * SOSC.SIZEOF_tv_sec - 1) - 1; + for time_t'Size use 8 * SOSC.SIZEOF_tv_sec; pragma Convention (C, time_t); type suseconds_t is - range -2 ** (8 * Constants.SIZEOF_tv_usec - 1) - .. 2 ** (8 * Constants.SIZEOF_tv_usec - 1) - 1; - for suseconds_t'Size use 8 * Constants.SIZEOF_tv_usec; + range -2 ** (8 * SOSC.SIZEOF_tv_usec - 1) + .. 2 ** (8 * SOSC.SIZEOF_tv_usec - 1) - 1; + for suseconds_t'Size use 8 * SOSC.SIZEOF_tv_usec; pragma Convention (C, suseconds_t); type Timeval is record @@ -78,12 +78,12 @@ package GNAT.Sockets.Thin_Common is ------------------------------------------- Families : constant array (Family_Type) of C.int := - (Family_Inet => Constants.AF_INET, - Family_Inet6 => Constants.AF_INET6); + (Family_Inet => SOSC.AF_INET, + Family_Inet6 => SOSC.AF_INET6); Lengths : constant array (Family_Type) of C.unsigned_char := - (Family_Inet => Constants.SIZEOF_sockaddr_in, - Family_Inet6 => Constants.SIZEOF_sockaddr_in6); + (Family_Inet => SOSC.SIZEOF_sockaddr_in, + Family_Inet6 => SOSC.SIZEOF_sockaddr_in6); ---------------------------- -- Generic socket address -- @@ -95,7 +95,7 @@ package GNAT.Sockets.Thin_Common is -- and protocol specific address types) start with the same 2-byte header, -- which is either a length and a family (one byte each) or just a two-byte -- family. The following unchecked union describes the two possible layouts - -- and is meant to be constrained with Constants.Have_Sockaddr_Len. + -- and is meant to be constrained with SOSC.Have_Sockaddr_Len. type Sockaddr_Length_And_Family (Has_Sockaddr_Len : Boolean := False) @@ -231,8 +231,8 @@ package GNAT.Sockets.Thin_Common is type Hostent is record H_Name : C.Strings.chars_ptr; H_Aliases : Chars_Ptr_Pointers.Pointer; - H_Addrtype : Constants.H_Addrtype_T; - H_Length : Constants.H_Length_T; + H_Addrtype : SOSC.H_Addrtype_T; + H_Length : SOSC.H_Length_T; H_Addr_List : In_Addr_Access_Pointers.Pointer; end record; pragma Convention (C, Hostent); diff --git a/gcc/ada/g-stheme.adb b/gcc/ada/g-stheme.adb index 25d6c61921d..5222f448dcf 100644 --- a/gcc/ada/g-stheme.adb +++ b/gcc/ada/g-stheme.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 2007, AdaCore -- +-- Copyright (C) 2007-2008, AdaCore -- -- -- -- GNAT is free software; you can redistribute it and/or modify it under -- -- terms of the GNU General Public License as published by the Free Soft- -- @@ -54,16 +54,16 @@ package body Host_Error_Messages is renames To_Chars_Ptr; begin case H_Errno is - when Constants.HOST_NOT_FOUND => + when SOSC.HOST_NOT_FOUND => return TCP (Messages.HOST_NOT_FOUND'Access); - when Constants.TRY_AGAIN => + when SOSC.TRY_AGAIN => return TCP (Messages.TRY_AGAIN'Access); - when Constants.NO_RECOVERY => + when SOSC.NO_RECOVERY => return TCP (Messages.NO_RECOVERY'Access); - when Constants.NO_DATA => + when SOSC.NO_DATA => return TCP (Messages.NO_DATA'Access); when others => diff --git a/gcc/ada/g-stsifd-sockets.adb b/gcc/ada/g-stsifd-sockets.adb index 44bf2d8056e..5fe43af4654 100644 --- a/gcc/ada/g-stsifd-sockets.adb +++ b/gcc/ada/g-stsifd-sockets.adb @@ -82,7 +82,7 @@ package body Signalling_Fds is -- Create a listening socket - L_Sock := C_Socket (Constants.AF_INET, Constants.SOCK_STREAM, 0); + L_Sock := C_Socket (SOSC.AF_INET, SOSC.SOCK_STREAM, 0); if L_Sock = Failure then goto Fail; @@ -122,7 +122,7 @@ package body Signalling_Fds is -- Create read end (client) socket - R_Sock := C_Socket (Constants.AF_INET, Constants.SOCK_STREAM, 0); + R_Sock := C_Socket (SOSC.AF_INET, SOSC.SOCK_STREAM, 0); if R_Sock = Failure then goto Fail; @@ -134,7 +134,7 @@ package body Signalling_Fds is exit when Res /= Failure; - if Socket_Errno /= Constants.EADDRINUSE then + if Socket_Errno /= SOSC.EADDRINUSE then goto Fail; end if; @@ -152,7 +152,7 @@ package body Signalling_Fds is pragma Assert (Res = Failure and then - Socket_Errno = Constants.EADDRINUSE); + Socket_Errno = SOSC.EADDRINUSE); pragma Warnings (Off); -- useless assignment to "Res" Res := C_Close (W_Sock); pragma Warnings (On); @@ -217,7 +217,7 @@ package body Signalling_Fds is function Read (Rsig : C.int) return C.int is Buf : aliased Character; begin - return C_Recv (Rsig, Buf'Address, 1, Constants.MSG_Forced_Flags); + return C_Recv (Rsig, Buf'Address, 1, SOSC.MSG_Forced_Flags); end Read; ----------- @@ -227,7 +227,7 @@ package body Signalling_Fds is function Write (Wsig : C.int) return C.int is Buf : aliased Character := ASCII.NUL; begin - return C_Send (Wsig, Buf'Address, 1, Constants.MSG_Forced_Flags); + return C_Send (Wsig, Buf'Address, 1, SOSC.MSG_Forced_Flags); end Write; end Signalling_Fds; diff --git a/gcc/ada/g-sttsne-vxworks.adb b/gcc/ada/g-sttsne-vxworks.adb index 161029d51be..be0578d048c 100644 --- a/gcc/ada/g-sttsne-vxworks.adb +++ b/gcc/ada/g-sttsne-vxworks.adb @@ -81,7 +81,7 @@ package body GNAT.Sockets.Thin.Task_Safe_NetDB is -- VxWorks does not provide h_errno begin - pragma Assert (Addr_Type = Constants.AF_INET); + pragma Assert (Addr_Type = SOSC.AF_INET); pragma Assert (Addr_Len = In_Addr'Size / 8); -- Check that provided buffer is sufficiently large to hold the @@ -93,7 +93,7 @@ package body GNAT.Sockets.Thin.Task_Safe_NetDB is if VxWorks_hostGetByAddr (To_Pointer (Addr).all, Netdb_Data.Name'Address) - /= Constants.OK + /= SOSC.OK then return -1; end if; @@ -106,7 +106,7 @@ package body GNAT.Sockets.Thin.Task_Safe_NetDB is Ret.H_Name := C.Strings.To_Chars_Ptr (Netdb_Data.Name'Unrestricted_Access); Ret.H_Aliases := Alias_Access; - Ret.H_Addrtype := Constants.AF_INET; + Ret.H_Addrtype := SOSC.AF_INET; Ret.H_Length := 4; Ret.H_Addr_List := Netdb_Data.Addr_List (Netdb_Data.Addr_List'First)'Unchecked_Access; @@ -135,7 +135,7 @@ package body GNAT.Sockets.Thin.Task_Safe_NetDB is begin Addr := VxWorks_hostGetByName (Name); - if Addr = Constants.ERROR then + if Addr = SOSC.ERROR then return -1; end if; @@ -161,7 +161,7 @@ package body GNAT.Sockets.Thin.Task_Safe_NetDB is Ret.H_Name := C.Strings.To_Chars_Ptr (Netdb_Data.Name'Unrestricted_Access); Ret.H_Aliases := Alias_Access; - Ret.H_Addrtype := Constants.AF_INET; + Ret.H_Addrtype := SOSC.AF_INET; Ret.H_Length := 4; Ret.H_Addr_List := Netdb_Data.Addr_List (Netdb_Data.Addr_List'First)'Unchecked_Access; diff --git a/gcc/ada/gcc-interface/Make-lang.in b/gcc/ada/gcc-interface/Make-lang.in index 9af841d2915..40017100128 100644 --- a/gcc/ada/gcc-interface/Make-lang.in +++ b/gcc/ada/gcc-interface/Make-lang.in @@ -933,12 +933,12 @@ OSCONS_EXTRACT=../../../$(DECC) -DNATIVE \ ./s-oscons-tmplt.exe > s-oscons-tmplt.s else -OSCONS_CPP=$(GCC_FOR_TARGET) -E -C \ +OSCONS_CPP=$(GCC_FOR_TARGET) $(CFLAGS_FOR_TARGET) -E -C \ -DTARGET=\"$(target)\" s-oscons-tmplt.c > s-oscons-tmplt.i -OSCONS_EXTRACT=$(GCC_FOR_TARGET) -S s-oscons-tmplt.i +OSCONS_EXTRACT=$(GCC_FOR_TARGET) $(CFLAGS_FOR_TARGET) -S s-oscons-tmplt.i endif -ada/s-oscons-$(THREAD_KIND).ads : ada/s-oscons-tmplt.c ada/gsocket.h ada/xoscons.adb ada/xutil.ads ada/xutil.adb +ada/s-oscons.ads : ada/s-oscons-tmplt.c ada/gsocket.h ada/xoscons.adb ada/xutil.ads ada/xutil.adb -$(MKDIR) ada/bldtools/oscons $(RM) $(addprefix ada/bldtools/oscons/,$(notdir $^)) $(CP) $^ ada/bldtools/oscons @@ -947,8 +947,8 @@ ada/s-oscons-$(THREAD_KIND).ads : ada/s-oscons-tmplt.c ada/gsocket.h ada/xoscons $(OSCONS_CPP) ; \ $(OSCONS_EXTRACT) ; \ ./xoscons ; \ - $(RM) ../../s-oscons-$(THREAD_KIND).ads ; \ - $(CP) s-oscons.ads ../../s-oscons-$(THREAD_KIND).ads) + $(RM) ../../s-oscons.ads ; \ + $(CP) s-oscons.ads ../../s-oscons.ads) update-sources : ada/treeprs.ads ada/einfo.h ada/sinfo.h ada/nmake.adb \ ada/nmake.ads diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in index 49a32cc9171..28763d7872f 100644 --- a/gcc/ada/gcc-interface/Makefile.in +++ b/gcc/ada/gcc-interface/Makefile.in @@ -368,7 +368,7 @@ PREFIX_REAL_OBJS = ../prefix.o \ # sockets, reset this variable to empty and add DUMMY_SOCKETS_TARGET_PAIRS # to LIBGNAT_TARGET_PAIRS. -GNATRTL_SOCKETS_OBJS = g-socket$(objext) g-socthi$(objext) \ +GNATRTL_SOCKETS_OBJS = g-soccon$(objext) g-socket$(objext) g-socthi$(objext) \ g-soliop$(objext) g-sothco$(objext) g-sttsne$(objext) DUMMY_SOCKETS_TARGET_PAIRS = \ @@ -1363,7 +1363,7 @@ ifeq ($(strip $(filter-out cygwin32% mingw32% pe,$(osys))),) system.ads<system-mingw.ads endif - EXTRA_GNATRTL_NONTASKING_OBJS = s-win32.o s-win32.o g-regist.o + EXTRA_GNATRTL_NONTASKING_OBJS = s-win32.o s-winext.o g-regist.o EXTRA_GNATRTL_TASKING_OBJS = a-exetim.o MISCLIB = -lwsock32 @@ -1931,7 +1931,7 @@ install-gnatlib: ../stamp-gnatlib-$(RTSDIR) $(RTSDIR)/$(word 1,$(subst <, ,$(PAIR)));) # Copy generated target dependent sources $(RM) $(RTSDIR)/s-oscons.ads - (cd $(RTSDIR); $(LN_S) ../s-oscons-$(THREAD_KIND).ads s-oscons.ads) + (cd $(RTSDIR); $(LN_S) ../s-oscons.ads s-oscons.ads) $(RM) ../stamp-gnatlib-$(RTSDIR) touch ../stamp-gnatlib1-$(RTSDIR) diff --git a/gcc/ada/gcc-interface/misc.c b/gcc/ada/gcc-interface/misc.c index 47d249a4578..7c7dc02f36f 100644 --- a/gcc/ada/gcc-interface/misc.c +++ b/gcc/ada/gcc-interface/misc.c @@ -240,7 +240,7 @@ gnat_handle_option (size_t scode, const char *arg, int value) break; case OPT_Wall: - set_Wunused (value); + warn_unused = value; /* We save the value of warn_uninitialized, since if they put -Wuninitialized on the command line, we need to generate a diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi index 29c1aec6dae..a768528d40b 100644 --- a/gcc/ada/gnat_rm.texi +++ b/gcc/ada/gnat_rm.texi @@ -3413,7 +3413,7 @@ Syntax: @smallexample @c ada pragma Obsolescent - (Entity => NAME [, static_string_EXPRESSION [,Ada_05]]); + [(Entity => NAME [, static_string_EXPRESSION [,Ada_05]])]; @end smallexample @noindent @@ -4447,6 +4447,17 @@ on addresses used in address clauses. Such checks can also be suppressed by suppressing range checks, but the specific use of @code{Alignment_Check} allows suppression of alignment checks without suppressing other range checks. +Note that pragma Suppress gives the compiler permission to omit +checks, but does not require the compiler to omit checks. The compiler +will generate checks if they are essentially free, even when they are +suppressed. In particular, if the compiler can prove that a certain +check will necessarily fail, it will generate code to do an +unconditional ``raise'', even if checks are suppressed. The compiler +warns in this case. + +Of course, run-time checks are omitted whenever the compiler can prove +that they will not fail, whether or not checks are suppressed. + @node Pragma Suppress_All @unnumberedsec Pragma Suppress_All @findex Suppress_All diff --git a/gcc/ada/gnat_ugn.texi b/gcc/ada/gnat_ugn.texi index 3c5d287acef..5918edda65b 100644 --- a/gcc/ada/gnat_ugn.texi +++ b/gcc/ada/gnat_ugn.texi @@ -4022,12 +4022,12 @@ catches that cannot be dealt with in the front-end. @item -gnato @cindex @option{-gnato} (@command{gcc}) Enable numeric overflow checking (which is not normally enabled by -default). Not that division by zero is a separate check that is not +default). Note that division by zero is a separate check that is not controlled by this switch (division by zero checking is on by default). @item -gnatp @cindex @option{-gnatp} (@command{gcc}) -Suppress all checks. +Suppress all checks. See @ref{Run-Time Checks} for details. @item -gnatP @cindex @option{-gnatP} (@command{gcc}) @@ -6222,14 +6222,11 @@ clears any previously set style checks. @cindex Checks, stack overflow checking @noindent -If you compile with the default options, GNAT will insert many run-time -checks into the compiled code, including code that performs range -checking against constraints, but not arithmetic overflow checking for -integer operations (including division by zero), checks for access -before elaboration on subprogram calls, or stack overflow checking. All -other run-time checks, as required by the Ada Reference Manual, are -generated by default. The following @command{gcc} switches refine this -default behavior: +By default, the following checks are suppressed: integer overflow +checks, stack overflow checks, and checks for access before +elaboration on subprogram calls. All other checks, including range +checks and array bounds checks, are turned on by default. The +following @command{gcc} switches refine this default behavior. @table @option @c !sort! @@ -6238,13 +6235,33 @@ default behavior: @cindex Suppressing checks @cindex Checks, suppressing @findex Suppress -Suppress all run-time checks as though @code{pragma Suppress (all_checks}) +Suppress all run-time checks as though @code{pragma Suppress (All_checks)} had been present in the source. Validity checks are also suppressed (in other words @option{-gnatp} also implies @option{-gnatVn}. Use this switch to improve the performance of the code at the expense of safety in the presence of invalid data or program bugs. +Note that when checks are suppressed, the compiler is allowed, but not +required, to omit the checking code. If the run-time cost of the +checking code is zero or near-zero, the compiler will generate it even +if checks are suppressed. In particular, if the compiler can prove +that a certain check will necessarily fail, it will generate code to +do an unconditional ``raise'', even if checks are suppressed. The +compiler warns in this case. + +Of course, run-time checks are omitted whenever the compiler can prove +that they will not fail, whether or not checks are suppressed. + +Note that if you suppress a check that would have failed, program +execution is erroneous, which means the behavior is totally +unpredictable. The program might crash, or print wrong answers, or +do anything else. It might even do exactly what you wanted it to do +(and then it might start failing mysteriously next week or next +year). The compiler will generate code based on the assumption that +the condition being checked is true, which can result in disaster if +that assumption is wrong. + @item -gnato @cindex @option{-gnato} (@command{gcc}) @cindex Overflow checks @@ -6271,22 +6288,23 @@ X4 := Integer (F); @end smallexample @noindent -Note that if explicit values are assigned at compile time, the compiler may -be able to detect overflow at compile time, in which case no run-time check -is required, and the setting of -gnato is irrelevant. That's why the assigned -values in the above fragment are in quotes, the meaning is "assign a value -not known to the compiler that happens to be equal to ...". The remaining -discussion assumes that the compiler cannot detect the values at compile time. +Note that if explicit values are assigned at compile time, the +compiler may be able to detect overflow at compile time, in which case +no actual run-time checking code is required, and Constraint_Error +will be raised unconditionally, with or without +@option{-gnato}. That's why the assigned values in the above fragment +are in quotes, the meaning is "assign a value not known to the +compiler that happens to be equal to ...". The remaining discussion +assumes that the compiler cannot detect the values at compile time. Here the first addition results in a value that is outside the base range of Integer, and hence requires an overflow check for detection of the constraint error. Thus the first assignment to @code{X1} raises a @code{Constraint_Error} exception only if @option{-gnato} is set. -The second increment operation results in a violation -of the explicit range constraint, and such range checks are always -performed (unless specifically suppressed with a pragma @code{suppress} -or the use of @option{-gnatp}). +The second increment operation results in a violation of the explicit +range constraint; such range checks are performed by default, and are +unaffected by @option{-gnato}. The two conversions of @code{F} both result in values that are outside the base range of type @code{Integer} and thus will raise @@ -6342,6 +6360,8 @@ explicitly use the -gnato switch either on the @command{gnatmake} or @cindex Check, elaboration Enables dynamic checks for access-before-elaboration on subprogram calls and generic instantiations. +Note that @option{-gnatE} is not necessary for safety, because in the +default mode, GNAT ensures statically that the checks would not fail. For full details of the effect and use of this switch, @xref{Compiling Using gcc}. @@ -9548,8 +9568,8 @@ some guidelines on debugging optimized code. @subsection Controlling Run-Time Checks @noindent -By default, GNAT generates all run-time checks, except arithmetic overflow -checking for integer operations and checks for access before elaboration on +By default, GNAT generates all run-time checks, except integer overflow +checks, stack overflow checks, and checks for access before elaboration on subprogram calls. The latter are not required in default mode, because all necessary checking is done at compile time. @cindex @option{-gnatp} (@command{gcc}) diff --git a/gcc/ada/gsocket.h b/gcc/ada/gsocket.h index b98da05f9a7..0dca1a9f503 100644 --- a/gcc/ada/gsocket.h +++ b/gcc/ada/gsocket.h @@ -60,6 +60,7 @@ #endif #include <limits.h> +#include <errno.h> #if defined(__vxworks) #include <vxWorks.h> @@ -78,48 +79,83 @@ #include <winsock2.h> #include <ws2tcpip.h> -#define EACCES WSAEACCES -#define EADDRINUSE WSAEADDRINUSE -#define EADDRNOTAVAIL WSAEADDRNOTAVAIL -#define EAFNOSUPPORT WSAEAFNOSUPPORT -#define EALREADY WSAEALREADY -#define EBADF WSAEBADF -#define ECONNABORTED WSAECONNABORTED -#define ECONNREFUSED WSAECONNREFUSED -#define ECONNRESET WSAECONNRESET -#define EDESTADDRREQ WSAEDESTADDRREQ -#define EFAULT WSAEFAULT -#define EHOSTDOWN WSAEHOSTDOWN -#define EHOSTUNREACH WSAEHOSTUNREACH -#define EINPROGRESS WSAEINPROGRESS -#define EINTR WSAEINTR -#define EINVAL WSAEINVAL -#define EIO WSAEDISCON -#define EISCONN WSAEISCONN -#define ELOOP WSAELOOP -#define EMFILE WSAEMFILE -#define EMSGSIZE WSAEMSGSIZE -#define ENAMETOOLONG WSAENAMETOOLONG -#define ENETDOWN WSAENETDOWN -#define ENETRESET WSAENETRESET -#define ENETUNREACH WSAENETUNREACH -#define ENOBUFS WSAENOBUFS -#define ENOPROTOOPT WSAENOPROTOOPT -#define ENOTCONN WSAENOTCONN -#define ENOTSOCK WSAENOTSOCK -#define EOPNOTSUPP WSAEOPNOTSUPP -#define EPFNOSUPPORT WSAEPFNOSUPPORT -#define EPROTONOSUPPORT WSAEPROTONOSUPPORT -#define ENOTSOCK WSAENOTSOCK -#define EOPNOTSUPP WSAEOPNOTSUPP -#define EPFNOSUPPORT WSAEPFNOSUPPORT -#define EPROTONOSUPPORT WSAEPROTONOSUPPORT -#define EPROTOTYPE WSAEPROTOTYPE -#define ESHUTDOWN WSAESHUTDOWN -#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT -#define ETIMEDOUT WSAETIMEDOUT -#define ETOOMANYREFS WSAETOOMANYREFS -#define EWOULDBLOCK WSAEWOULDBLOCK +#undef EACCES +#define EACCES WSAEACCES +#undef EADDRINUSE +#define EADDRINUSE WSAEADDRINUSE +#undef EADDRNOTAVAIL +#define EADDRNOTAVAIL WSAEADDRNOTAVAIL +#undef EAFNOSUPPORT +#define EAFNOSUPPORT WSAEAFNOSUPPORT +#undef EALREADY +#define EALREADY WSAEALREADY +#undef EBADF +#define EBADF WSAEBADF +#undef ECONNABORTED +#define ECONNABORTED WSAECONNABORTED +#undef ECONNREFUSED +#define ECONNREFUSED WSAECONNREFUSED +#undef ECONNRESET +#define ECONNRESET WSAECONNRESET +#undef EDESTADDRREQ +#define EDESTADDRREQ WSAEDESTADDRREQ +#undef EFAULT +#define EFAULT WSAEFAULT +#undef EHOSTDOWN +#define EHOSTDOWN WSAEHOSTDOWN +#undef EHOSTUNREACH +#define EHOSTUNREACH WSAEHOSTUNREACH +#undef EINPROGRESS +#define EINPROGRESS WSAEINPROGRESS +#undef EINTR +#define EINTR WSAEINTR +#undef EINVAL +#define EINVAL WSAEINVAL +#undef EIO +#define EIO WSAEDISCON +#undef EISCONN +#define EISCONN WSAEISCONN +#undef ELOOP +#define ELOOP WSAELOOP +#undef EMFILE +#define EMFILE WSAEMFILE +#undef EMSGSIZE +#define EMSGSIZE WSAEMSGSIZE +#undef ENAMETOOLONG +#define ENAMETOOLONG WSAENAMETOOLONG +#undef ENETDOWN +#define ENETDOWN WSAENETDOWN +#undef ENETRESET +#define ENETRESET WSAENETRESET +#undef ENETUNREACH +#define ENETUNREACH WSAENETUNREACH +#undef ENOBUFS +#define ENOBUFS WSAENOBUFS +#undef ENOPROTOOPT +#define ENOPROTOOPT WSAENOPROTOOPT +#undef ENOTCONN +#define ENOTCONN WSAENOTCONN +#undef ENOTSOCK +#define ENOTSOCK WSAENOTSOCK +#undef EOPNOTSUPP +#define EOPNOTSUPP WSAEOPNOTSUPP +#undef EPFNOSUPPORT +#define EPFNOSUPPORT WSAEPFNOSUPPORT +#undef EPROTONOSUPPORT +#define EPROTONOSUPPORT WSAEPROTONOSUPPORT +#undef EPROTOTYPE +#define EPROTOTYPE WSAEPROTOTYPE +#undef ESHUTDOWN +#define ESHUTDOWN WSAESHUTDOWN +#undef ESOCKTNOSUPPORT +#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT +#undef ETIMEDOUT +#define ETIMEDOUT WSAETIMEDOUT +#undef ETOOMANYREFS +#define ETOOMANYREFS WSAETOOMANYREFS +#undef EWOULDBLOCK +#define EWOULDBLOCK WSAEWOULDBLOCK + #define SHUT_RD SD_RECEIVE #define SHUT_WR SD_SEND #define SHUT_RDWR SD_BOTH @@ -138,10 +174,6 @@ #endif -#ifndef __MINGW32__ -#include <errno.h> -#endif - #ifdef __vxworks #include <sys/times.h> #else @@ -184,7 +216,7 @@ #if defined (_AIX) || defined (__FreeBSD__) || defined (__hpux__) || defined (__osf__) || defined (_WIN32) || defined (__APPLE__) # define HAVE_THREAD_SAFE_GETxxxBYyyy 1 -#elif defined (sgi) || defined (linux) || defined (__GLIBC__) || (defined (sun) && defined (__SVR4) && !defined (__vxworks)) +#elif defined (sgi) || defined (linux) || defined (__GLIBC__) || (defined (sun) && defined (__SVR4) && !defined (__vxworks)) || defined(__rtems__) # define HAVE_GETxxxBYyyy_R 1 #endif @@ -194,7 +226,7 @@ # define Need_Netdb_Buffer 0 #endif -#if defined (__FreeBSD__) || defined (__vxworks) +#if defined (__FreeBSD__) || defined (__vxworks) || defined(__rtems__) # define Has_Sockaddr_Len 1 #else # define Has_Sockaddr_Len 0 diff --git a/gcc/ada/s-fileio.adb b/gcc/ada/s-fileio.adb index 79b718eadce..7c20fb18f38 100644 --- a/gcc/ada/s-fileio.adb +++ b/gcc/ada/s-fileio.adb @@ -988,9 +988,11 @@ package body System.File_IO is Stream := fopen (Namestr'Address, Fopstr'Address, Encoding); if Stream = NULL_Stream then + -- Raise Name_Error if trying to open a non-existent file. - -- Otherwise raise Use_Error. Should we raise Device_Error for - -- ENOSPC??? + -- Otherwise raise Use_Error. + + -- Should we raise Device_Error for ENOSPC??? if System.OS_Lib.Errno = System.OS_Constants.ENOENT then raise Name_Error; diff --git a/gcc/ada/s-oscons-tmplt.c b/gcc/ada/s-oscons-tmplt.c index 8017c382137..614a8660d9b 100644 --- a/gcc/ada/s-oscons-tmplt.c +++ b/gcc/ada/s-oscons-tmplt.c @@ -829,6 +829,14 @@ CND(VEOL2, "Alternative EOL") #endif CND(AF_INET, "IPv4 address family") +/** + ** RTEMS lies and defines AF_INET6 even though there is no IPV6 support. + ** Its TCP/IP stack is in transition. It has newer .h files but no IPV6 yet. + **/ +#if defined(__rtems__) +# undef AF_INET6 +#endif + #ifndef AF_INET6 # define AF_INET6 -1 #else diff --git a/gcc/ada/s-osinte-freebsd.ads b/gcc/ada/s-osinte-freebsd.ads index 51f498397f9..c1ed40b7720 100644 --- a/gcc/ada/s-osinte-freebsd.ads +++ b/gcc/ada/s-osinte-freebsd.ads @@ -67,11 +67,11 @@ package System.OS_Interface is function Errno return int; pragma Inline (Errno); - EAGAIN : constant := 35; - EINTR : constant := 4; - EINVAL : constant := 22; - ENOMEM : constant := 12; - ETIMEDOUT : constant := 60; + EAGAIN : constant := 35; + EINTR : constant := 4; + EINVAL : constant := 22; + ENOMEM : constant := 12; + ETIMEDOUT : constant := 60; ------------- -- Signals -- diff --git a/gcc/ada/s-osinte-hpux.ads b/gcc/ada/s-osinte-hpux.ads index 0fc5ef1db54..29605b8e1d0 100644 --- a/gcc/ada/s-osinte-hpux.ads +++ b/gcc/ada/s-osinte-hpux.ads @@ -86,7 +86,7 @@ package System.OS_Interface is SIGILL : constant := 4; -- illegal instruction (not reset) SIGTRAP : constant := 5; -- trace trap (not reset) SIGIOT : constant := 6; -- IOT instruction - SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the future + SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the future SIGEMT : constant := 7; -- EMT instruction SIGFPE : constant := 8; -- floating point exception SIGKILL : constant := 9; -- kill (cannot be caught or ignored) @@ -122,6 +122,7 @@ package System.OS_Interface is SIGADAABORT : constant := SIGABRT; -- Note: on other targets, we usually use SIGABRT, but on HPUX, it -- appears that SIGABRT can't be used in sigwait(), so we use SIGTERM. + -- Do we use SIGTERM or SIGABRT??? type Signal_Set is array (Natural range <>) of Signal; diff --git a/gcc/ada/s-osinte-irix.ads b/gcc/ada/s-osinte-irix.ads index 01b01b54222..5432656208f 100644 --- a/gcc/ada/s-osinte-irix.ads +++ b/gcc/ada/s-osinte-irix.ads @@ -87,8 +87,7 @@ package System.OS_Interface is SIGILL : constant := 4; -- illegal instruction (not reset) SIGTRAP : constant := 5; -- trace trap (not reset) SIGIOT : constant := 6; -- IOT instruction - SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the - -- future + SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the future SIGEMT : constant := 7; -- EMT instruction SIGFPE : constant := 8; -- floating point exception SIGKILL : constant := 9; -- kill (cannot be caught or ignored) diff --git a/gcc/ada/s-strxdr.adb b/gcc/ada/s-strxdr.adb index 7732daadfb1..c123feac1f4 100644 --- a/gcc/ada/s-strxdr.adb +++ b/gcc/ada/s-strxdr.adb @@ -47,11 +47,11 @@ package body System.Stream_Attributes is use UST; Data_Error : exception renames Ada.IO_Exceptions.End_Error; - -- Exception raised if insufficient data read (End_Error is - -- mandated by AI95-00132). + -- Exception raised if insufficient data read (End_Error is mandated by + -- AI95-00132). SU : constant := System.Storage_Unit; - -- XXXXX pragma Assert (SU = 8); + -- The code in this body assumes that SU = 8 BB : constant := 2 ** SU; -- Byte base BL : constant := 2 ** SU - 1; -- Byte last @@ -127,7 +127,7 @@ package body System.Stream_Attributes is -- in the range [-2147483648,2147483647]. The integer is represented -- in two's complement notation. The most and least significant bytes -- are 0 and 3, respectively. Integers are declared as follows: - -- + -- (MSB) (LSB) -- +-------+-------+-------+-------+ -- |byte 0 |byte 1 |byte 2 |byte 3 | @@ -175,7 +175,7 @@ package body System.Stream_Attributes is -- integer in the range [0,4294967295]. It is represented by an unsigned -- binary number whose most and least significant bytes are 0 and 3, -- respectively. An unsigned integer is declared as follows: - -- + -- (MSB) (LSB) -- +-------+-------+-------+-------+ -- |byte 0 |byte 1 |byte 2 |byte 3 | @@ -222,10 +222,10 @@ package body System.Stream_Attributes is -- or 4 bytes). The encoding used is the IEEE standard for normalized -- single-precision floating-point numbers. - -- The standard defines the encoding for the double-precision - -- floating-point data type "double" (64 bits or 8 bytes). The - -- encoding used is the IEEE standard for normalized double-precision - -- floating-point numbers. + -- The standard defines the encoding used for the double-precision + -- floating-point data type "double" (64 bits or 8 bytes). The encoding + -- used is the IEEE standard for normalized double-precision floating-point + -- numbers. SF_L : constant := 4; -- Single precision F_L : constant := 4; -- Single precision diff --git a/gcc/ada/sem_attr.adb b/gcc/ada/sem_attr.adb index f32d0b7acd9..6a77fd1160c 100644 --- a/gcc/ada/sem_attr.adb +++ b/gcc/ada/sem_attr.adb @@ -713,6 +713,12 @@ package body Sem_Attr is then null; + -- OK if reference to the current instance of a protected + -- object. + + elsif Is_Protected_Self_Reference (P) then + null; + -- Otherwise we have an error case else @@ -1643,6 +1649,11 @@ package body Sem_Attr is then Error_Attr_P ("prefix of % attribute must be a type"); + elsif Is_Protected_Self_Reference (P) then + Error_Attr_P + ("prefix of % attribute denotes current instance " & + "(RM 9.4(21/2))"); + elsif Ekind (Entity (P)) = E_Incomplete_Type and then Present (Full_View (Entity (P))) then @@ -2009,7 +2020,13 @@ package body Sem_Attr is -- An Address attribute created by expansion is legal even when it -- applies to other entity-denoting expressions. - if Is_Entity_Name (P) then + if Is_Protected_Self_Reference (P) then + -- An Address attribute on a protected object self reference + -- is legal. + + null; + + elsif Is_Entity_Name (P) then declare Ent : constant Entity_Id := Entity (P); @@ -3831,8 +3848,7 @@ package body Sem_Attr is then -- Check OK prefix - if (Nkind (P) = N_Identifier - or else Nkind (P) = N_Operator_Symbol) + if Nkind_In (P, N_Identifier, N_Operator_Symbol) and then Chars (P) = Chars (PS) then null; diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index 96e24a4c994..e1d042c92c2 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -6372,6 +6372,42 @@ package body Sem_Util is end if; end Is_Potentially_Persistent_Type; + --------------------------------- + -- Is_Protected_Self_Reference -- + --------------------------------- + + function Is_Protected_Self_Reference (N : Node_Id) return Boolean + is + function In_Access_Definition (N : Node_Id) return Boolean; + -- Returns true if N belongs to an access definition + + -------------------------- + -- In_Access_Definition -- + -------------------------- + + function In_Access_Definition (N : Node_Id) return Boolean + is + P : Node_Id := Parent (N); + begin + while Present (P) loop + if Nkind (P) = N_Access_Definition then + return True; + end if; + P := Parent (P); + end loop; + return False; + end In_Access_Definition; + + -- Start of processing for Is_Protected_Self_Reference + + begin + return Ada_Version >= Ada_05 + and then Is_Entity_Name (N) + and then Is_Protected_Type (Entity (N)) + and then In_Open_Scopes (Entity (N)) + and then not In_Access_Definition (N); + end Is_Protected_Self_Reference; + ----------------------------- -- Is_RCI_Pkg_Spec_Or_Body -- ----------------------------- diff --git a/gcc/ada/sem_util.ads b/gcc/ada/sem_util.ads index 00c1e380d88..a8f7fc8dc33 100644 --- a/gcc/ada/sem_util.ads +++ b/gcc/ada/sem_util.ads @@ -726,6 +726,10 @@ package Sem_Util is -- persistent. A private type is potentially persistent if the full type -- is potentially persistent. + function Is_Protected_Self_Reference (N : Node_Id) return Boolean; + -- Return True if node N denotes a protected type name which represents + -- the current instance of a protected object according to RM 9.4(21/2). + function Is_RCI_Pkg_Spec_Or_Body (Cunit : Node_Id) return Boolean; -- Return True if a compilation unit is the specification or the -- body of a remote call interface package. diff --git a/gcc/ada/socket.c b/gcc/ada/socket.c index 9653aae1dfa..aadc9b084f7 100644 --- a/gcc/ada/socket.c +++ b/gcc/ada/socket.c @@ -240,7 +240,7 @@ __gnat_safe_getservbyname (const char *name, const char *proto, struct servent *rh; int ri; -#if defined(__linux__) || defined(__GLIBC__) +#if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__) (void) getservbyname_r (name, proto, ret, buf, buflen, &rh); #else rh = getservbyname_r (name, proto, ret, buf, buflen); @@ -256,7 +256,7 @@ __gnat_safe_getservbyport (int port, const char *proto, struct servent *rh; int ri; -#if defined(__linux__) || defined(__GLIBC__) +#if defined(__linux__) || defined(__GLIBC__) || defined(__rtems__) (void) getservbyport_r (port, proto, ret, buf, buflen, &rh); #else rh = getservbyport_r (port, proto, ret, buf, buflen); diff --git a/gcc/builtins.c b/gcc/builtins.c index 953fb7bddc6..68cadb6a1db 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -4923,13 +4923,14 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) != type) { static bool gave_help; + bool warned; /* Unfortunately, this is merely undefined, rather than a constraint violation, so we cannot make this an error. If this call is never executed, the program is still strictly conforming. */ - warning (0, "%qT is promoted to %qT when passed through %<...%>", - type, promoted_type); - if (! gave_help) + warned = warning (0, "%qT is promoted to %qT when passed through %<...%>", + type, promoted_type); + if (!gave_help && warned) { gave_help = true; inform ("(so you should pass %qT not %qT to %<va_arg%>)", @@ -4938,7 +4939,8 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) /* We can, however, treat "undefined" any way we please. Call abort to encourage the user to fix the program. */ - inform ("if this code is reached, the program will abort"); + if (warned) + inform ("if this code is reached, the program will abort"); t = build_call_expr (implicit_built_in_decls[BUILT_IN_TRAP], 0); gimplify_and_add (t, pre_p); @@ -5576,18 +5578,18 @@ expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode) static rtx expand_builtin_profile_func (bool exitp) { - rtx this, which; + rtx this_rtx, which; - this = DECL_RTL (current_function_decl); - gcc_assert (MEM_P (this)); - this = XEXP (this, 0); + this_rtx = DECL_RTL (current_function_decl); + gcc_assert (MEM_P (this_rtx)); + this_rtx = XEXP (this_rtx, 0); if (exitp) which = profile_function_exit_libfunc; else which = profile_function_entry_libfunc; - emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this, Pmode, + emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode, expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS, 0), Pmode); @@ -12865,14 +12867,16 @@ do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t), && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)) && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max))) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; int inexact; mpfr_t m; mpfr_init2 (m, prec); mpfr_from_real (m, ra, GMP_RNDN); mpfr_clear_flags (); - inexact = func (m, m, GMP_RNDN); + inexact = func (m, m, rnd); result = do_mpfr_ckconv (m, type, inexact); mpfr_clear (m); } @@ -12907,7 +12911,9 @@ do_mpfr_arg2 (tree arg1, tree arg2, tree type, if (real_isfinite (ra1) && real_isfinite (ra2)) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; int inexact; mpfr_t m1, m2; @@ -12915,7 +12921,7 @@ do_mpfr_arg2 (tree arg1, tree arg2, tree type, mpfr_from_real (m1, ra1, GMP_RNDN); mpfr_from_real (m2, ra2, GMP_RNDN); mpfr_clear_flags (); - inexact = func (m1, m1, m2, GMP_RNDN); + inexact = func (m1, m1, m2, rnd); result = do_mpfr_ckconv (m1, type, inexact); mpfr_clears (m1, m2, NULL); } @@ -12953,7 +12959,9 @@ do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type, if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3)) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; int inexact; mpfr_t m1, m2, m3; @@ -12962,7 +12970,7 @@ do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type, mpfr_from_real (m2, ra2, GMP_RNDN); mpfr_from_real (m3, ra3, GMP_RNDN); mpfr_clear_flags (); - inexact = func (m1, m1, m2, m3, GMP_RNDN); + inexact = func (m1, m1, m2, m3, rnd); result = do_mpfr_ckconv (m1, type, inexact); mpfr_clears (m1, m2, m3, NULL); } @@ -12996,7 +13004,9 @@ do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp) if (real_isfinite (ra)) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; tree result_s, result_c; int inexact; mpfr_t m, ms, mc; @@ -13004,7 +13014,7 @@ do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp) mpfr_inits2 (prec, m, ms, mc, NULL); mpfr_from_real (m, ra, GMP_RNDN); mpfr_clear_flags (); - inexact = mpfr_sin_cos (ms, mc, m, GMP_RNDN); + inexact = mpfr_sin_cos (ms, mc, m, rnd); result_s = do_mpfr_ckconv (ms, type, inexact); result_c = do_mpfr_ckconv (mc, type, inexact); mpfr_clears (m, ms, mc, NULL); @@ -13069,14 +13079,16 @@ do_mpfr_bessel_n (tree arg1, tree arg2, tree type, && real_isfinite (ra) && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; int inexact; mpfr_t m; mpfr_init2 (m, prec); mpfr_from_real (m, ra, GMP_RNDN); mpfr_clear_flags (); - inexact = func (m, n, m, GMP_RNDN); + inexact = func (m, n, m, rnd); result = do_mpfr_ckconv (m, type, inexact); mpfr_clear (m); } @@ -13110,7 +13122,9 @@ do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo) if (real_isfinite (ra0) && real_isfinite (ra1)) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; tree result_rem; long integer_quo; mpfr_t m0, m1; @@ -13119,7 +13133,7 @@ do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo) mpfr_from_real (m0, ra0, GMP_RNDN); mpfr_from_real (m1, ra1, GMP_RNDN); mpfr_clear_flags (); - mpfr_remquo (m0, &integer_quo, m0, m1, GMP_RNDN); + mpfr_remquo (m0, &integer_quo, m0, m1, rnd); /* Remquo is independent of the rounding mode, so pass inexact=0 to do_mpfr_ckconv(). */ result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0); @@ -13187,7 +13201,9 @@ do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type) && ra->cl != rvc_zero && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type)))) { - const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p; + const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); + const int prec = fmt->p; + const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; int inexact, sg; mpfr_t m; tree result_lg; @@ -13195,7 +13211,7 @@ do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type) mpfr_init2 (m, prec); mpfr_from_real (m, ra, GMP_RNDN); mpfr_clear_flags (); - inexact = mpfr_lgamma (m, &sg, m, GMP_RNDN); + inexact = mpfr_lgamma (m, &sg, m, rnd); result_lg = do_mpfr_ckconv (m, type, inexact); mpfr_clear (m); if (result_lg) diff --git a/gcc/c-common.c b/gcc/c-common.c index 72471e4ad8a..101921b4f11 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -342,10 +342,6 @@ int flag_isoc99; int flag_hosted = 1; -/* Warn if main is suspicious. */ - -int warn_main; - /* ObjC language option variables. */ @@ -604,7 +600,7 @@ static int resort_field_decl_cmp (const void *, const void *); If -fno-asm is used, D_ASM is added to the mask. If -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords. - In C with -Wcxx-compat, we warn if D_CXXWARN is set. */ + In C with -Wc++-compat, we warn if D_CXXWARN is set. */ const struct c_common_resword c_common_reswords[] = { @@ -671,44 +667,44 @@ const struct c_common_resword c_common_reswords[] = { "__volatile__", RID_VOLATILE, 0 }, { "asm", RID_ASM, D_ASM }, { "auto", RID_AUTO, 0 }, - { "bool", RID_BOOL, D_CXXONLY }, + { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN }, { "break", RID_BREAK, 0 }, { "case", RID_CASE, 0 }, - { "catch", RID_CATCH, D_CXX_OBJC }, + { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN }, { "char", RID_CHAR, 0 }, - { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X }, - { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X }, - { "class", RID_CLASS, D_CXX_OBJC }, + { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN }, + { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN }, + { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN }, { "const", RID_CONST, 0 }, { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN }, { "continue", RID_CONTINUE, 0 }, - { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X }, + { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN }, { "default", RID_DEFAULT, 0 }, - { "delete", RID_DELETE, D_CXXONLY }, + { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN }, { "do", RID_DO, 0 }, { "double", RID_DOUBLE, 0 }, { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN }, { "else", RID_ELSE, 0 }, { "enum", RID_ENUM, 0 }, - { "explicit", RID_EXPLICIT, D_CXXONLY }, - { "export", RID_EXPORT, D_CXXONLY }, + { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN }, + { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN }, { "extern", RID_EXTERN, 0 }, - { "false", RID_FALSE, D_CXXONLY }, + { "false", RID_FALSE, D_CXXONLY | D_CXXWARN }, { "float", RID_FLOAT, 0 }, { "for", RID_FOR, 0 }, - { "friend", RID_FRIEND, D_CXXONLY }, + { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN }, { "goto", RID_GOTO, 0 }, { "if", RID_IF, 0 }, { "inline", RID_INLINE, D_EXT89 }, { "int", RID_INT, 0 }, { "long", RID_LONG, 0 }, { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN }, - { "namespace", RID_NAMESPACE, D_CXXONLY }, - { "new", RID_NEW, D_CXXONLY }, - { "operator", RID_OPERATOR, D_CXXONLY }, - { "private", RID_PRIVATE, D_CXX_OBJC }, - { "protected", RID_PROTECTED, D_CXX_OBJC }, - { "public", RID_PUBLIC, D_CXX_OBJC }, + { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN }, + { "new", RID_NEW, D_CXXONLY | D_CXXWARN }, + { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN }, + { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN }, + { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN }, + { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN }, { "register", RID_REGISTER, 0 }, { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN }, { "restrict", RID_RESTRICT, D_CONLY | D_C99 }, @@ -721,19 +717,19 @@ const struct c_common_resword c_common_reswords[] = { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN }, { "struct", RID_STRUCT, 0 }, { "switch", RID_SWITCH, 0 }, - { "template", RID_TEMPLATE, D_CXXONLY }, - { "this", RID_THIS, D_CXXONLY }, - { "throw", RID_THROW, D_CXX_OBJC }, - { "true", RID_TRUE, D_CXXONLY }, - { "try", RID_TRY, D_CXX_OBJC }, + { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN }, + { "this", RID_THIS, D_CXXONLY | D_CXXWARN }, + { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN }, + { "true", RID_TRUE, D_CXXONLY | D_CXXWARN }, + { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN }, { "typedef", RID_TYPEDEF, 0 }, - { "typename", RID_TYPENAME, D_CXXONLY }, - { "typeid", RID_TYPEID, D_CXXONLY }, + { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN }, + { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN }, { "typeof", RID_TYPEOF, D_ASM | D_EXT }, { "union", RID_UNION, 0 }, { "unsigned", RID_UNSIGNED, 0 }, - { "using", RID_USING, D_CXXONLY }, - { "virtual", RID_VIRTUAL, D_CXXONLY }, + { "using", RID_USING, D_CXXONLY | D_CXXWARN }, + { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN }, { "void", RID_VOID, 0 }, { "volatile", RID_VOLATILE, 0 }, { "wchar_t", RID_WCHAR, D_CXXONLY }, @@ -1375,7 +1371,8 @@ check_main_parameter_types (tree decl) { case 1: if (TYPE_MAIN_VARIANT (type) != integer_type_node) - pedwarn (0, "first argument of %q+D should be %<int%>", decl); + pedwarn (OPT_Wmain, "first argument of %q+D should be %<int%>", + decl); break; case 2: @@ -1383,8 +1380,8 @@ check_main_parameter_types (tree decl) || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type))) != char_type_node)) - pedwarn (0, "second argument of %q+D should be %<char **%>", - decl); + pedwarn (OPT_Wmain, "second argument of %q+D should be %<char **%>", + decl); break; case 3: @@ -1392,8 +1389,8 @@ check_main_parameter_types (tree decl) || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type))) != char_type_node)) - pedwarn (0, "third argument of %q+D should probably be " - "%<char **%>", decl); + pedwarn (OPT_Wmain, "third argument of %q+D should probably be " + "%<char **%>", decl); break; } } @@ -1402,7 +1399,7 @@ check_main_parameter_types (tree decl) argument because it's only mentioned in an appendix of the standard. */ if (argct > 0 && (argct < 2 || argct > 3)) - pedwarn (0, "%q+D takes only zero or two arguments", decl); + pedwarn (OPT_Wmain, "%q+D takes only zero or two arguments", decl); } /* True if pointers to distinct types T1 and T2 can be converted to @@ -1571,39 +1568,63 @@ conversion_warning (tree type, tree expr) { bool give_warning = false; - unsigned int formal_prec = TYPE_PRECISION (type); + tree expr_type = TREE_TYPE (expr); if (!warn_conversion && !warn_sign_conversion) return; - if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST) + switch (TREE_CODE (expr)) { + case EQ_EXPR: + case NE_EXPR: + case LE_EXPR: + case GE_EXPR: + case LT_EXPR: + case GT_EXPR: + case TRUTH_ANDIF_EXPR: + case TRUTH_ORIF_EXPR: + case TRUTH_AND_EXPR: + case TRUTH_OR_EXPR: + case TRUTH_XOR_EXPR: + case TRUTH_NOT_EXPR: + /* Conversion from boolean to a signed:1 bit-field (which only + can hold the values 0 and -1) doesn't lose information - but + it does change the value. */ + if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type)) + warning (OPT_Wconversion, + "conversion to %qT from boolean expression", type); + return; + + case REAL_CST: + case INTEGER_CST: + /* Warn for real constant that is not an exact integer converted to integer type. */ - if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE + if (TREE_CODE (expr_type) == REAL_TYPE && TREE_CODE (type) == INTEGER_TYPE) { - if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr)))) + if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type))) give_warning = true; } /* Warn for an integer constant that does not fit into integer type. */ - else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE + else if (TREE_CODE (expr_type) == INTEGER_TYPE && TREE_CODE (type) == INTEGER_TYPE && !int_fits_type_p (expr, type)) { - if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))) + if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type) + && tree_int_cst_sgn (expr) < 0) warning (OPT_Wsign_conversion, "negative integer implicitly converted to unsigned type"); - else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (TREE_TYPE (expr))) - warning (OPT_Wsign_conversion, - "conversion of unsigned constant value to negative integer"); + else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type)) + warning (OPT_Wsign_conversion, "conversion of unsigned constant " + "value to negative integer"); else give_warning = true; } else if (TREE_CODE (type) == REAL_TYPE) { /* Warn for an integer constant that does not fit into real type. */ - if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE) + if (TREE_CODE (expr_type) == INTEGER_TYPE) { REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr); if (!exact_real_truncate (TYPE_MODE (type), &a)) @@ -1611,8 +1632,8 @@ conversion_warning (tree type, tree expr) } /* Warn for a real constant that does not fit into a smaller real type. */ - else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE - && formal_prec < TYPE_PRECISION (TREE_TYPE (expr))) + else if (TREE_CODE (expr_type) == REAL_TYPE + && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) { REAL_VALUE_TYPE a = TREE_REAL_CST (expr); if (!exact_real_truncate (TYPE_MODE (type), &a)) @@ -1623,11 +1644,31 @@ conversion_warning (tree type, tree expr) if (give_warning) warning (OPT_Wconversion, "conversion to %qT alters %qT constant value", - type, TREE_TYPE (expr)); - } - else /* 'expr' is not a constant. */ - { - tree expr_type = TREE_TYPE (expr); + type, expr_type); + + return; + + case COND_EXPR: + { + /* In case of COND_EXPR, if both operands are constants or + COND_EXPR, then we do not care about the type of COND_EXPR, + only about the conversion of each operand. */ + tree op1 = TREE_OPERAND (expr, 1); + tree op2 = TREE_OPERAND (expr, 2); + + if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST + || TREE_CODE (op1) == COND_EXPR) + && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST + || TREE_CODE (op2) == COND_EXPR)) + { + conversion_warning (type, op1); + conversion_warning (type, op2); + return; + } + /* Fall through. */ + } + + default: /* 'expr' is not a constant. */ /* Warn for real types converted to integer types. */ if (TREE_CODE (expr_type) == REAL_TYPE @@ -1643,11 +1684,11 @@ conversion_warning (tree type, tree expr) /* Don't warn for short y; short x = ((int)y & 0xff); */ if (TREE_CODE (expr) == BIT_AND_EXPR - || TREE_CODE (expr) == BIT_IOR_EXPR + || TREE_CODE (expr) == BIT_IOR_EXPR || TREE_CODE (expr) == BIT_XOR_EXPR) { - /* It both args were extended from a shortest type, use - that type if that is safe. */ + /* If both args were extended from a shortest type, + use that type if that is safe. */ expr_type = shorten_binary_op (expr_type, TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1), @@ -1664,25 +1705,26 @@ conversion_warning (tree type, tree expr) && int_fits_type_p (op0, c_common_signed_type (type)) && int_fits_type_p (op0, c_common_unsigned_type (type))) || (TREE_CODE (op1) == INTEGER_CST - && int_fits_type_p (op1, c_common_signed_type (type)) - && int_fits_type_p (op1, c_common_unsigned_type (type)))) + && int_fits_type_p (op1, c_common_signed_type (type)) + && int_fits_type_p (op1, + c_common_unsigned_type (type)))) return; } } /* Warn for integer types converted to smaller integer types. */ - if (formal_prec < TYPE_PRECISION (expr_type)) + if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) give_warning = true; /* When they are the same width but different signedness, then the value may change. */ - else if ((formal_prec == TYPE_PRECISION (expr_type) + else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type) && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type)) /* Even when converted to a bigger type, if the type is unsigned but expr is signed, then negative values will be changed. */ || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type))) - warning (OPT_Wsign_conversion, - "conversion to %qT from %qT may change the sign of the result", + warning (OPT_Wsign_conversion, "conversion to %qT from %qT " + "may change the sign of the result", type, expr_type); } @@ -1694,8 +1736,10 @@ conversion_warning (tree type, tree expr) { tree type_low_bound = TYPE_MIN_VALUE (expr_type); tree type_high_bound = TYPE_MAX_VALUE (expr_type); - REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound); - REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound); + REAL_VALUE_TYPE real_low_bound + = real_value_from_int_cst (0, type_low_bound); + REAL_VALUE_TYPE real_high_bound + = real_value_from_int_cst (0, type_high_bound); if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound) || !exact_real_truncate (TYPE_MODE (type), &real_high_bound)) @@ -1705,7 +1749,7 @@ conversion_warning (tree type, tree expr) /* Warn for real types converted to smaller real types. */ else if (TREE_CODE (expr_type) == REAL_TYPE && TREE_CODE (type) == REAL_TYPE - && formal_prec < TYPE_PRECISION (expr_type)) + && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) give_warning = true; @@ -1914,8 +1958,10 @@ warn_for_collisions_1 (tree written, tree writer, struct tlist *list, && DECL_NAME (list->expr)) { warned_ids = new_tlist (warned_ids, written, NULL_TREE); - warning (OPT_Wsequence_point, "operation on %qE may be undefined", - list->expr); + warning_at (EXPR_HAS_LOCATION (writer) + ? EXPR_LOCATION (writer) : input_location, + OPT_Wsequence_point, "operation on %qE may be undefined", + list->expr); } list = list->next; } @@ -7581,15 +7627,8 @@ c_warn_unused_result (gimple_seq seq) /* This is a naked call, as opposed to a GIMPLE_CALL with an LHS. All calls whose value is ignored should be represented like this. Look for the attribute. */ - fdecl = gimple_call_fn (g); - if (TREE_CODE (fdecl) == FUNCTION_DECL) - ftype = TREE_TYPE (fdecl); - else - { - ftype = TREE_TYPE (fdecl); - /* Look past pointer-to-function to the function type itself. */ - ftype = TREE_TYPE (ftype); - } + fdecl = gimple_call_fndecl (g); + ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g))); if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype))) { @@ -8239,4 +8278,145 @@ warn_for_div_by_zero (tree divisor) warning (OPT_Wdiv_by_zero, "division by zero"); } +/* Subroutine of build_binary_op. Give warnings for comparisons + between signed and unsigned quantities that may fail. Do the + checking based on the original operand trees ORIG_OP0 and ORIG_OP1, + so that casts will be considered, but default promotions won't + be. + + The arguments of this function map directly to local variables + of build_binary_op. */ + +void +warn_for_sign_compare (tree orig_op0, tree orig_op1, + tree op0, tree op1, + tree result_type, enum tree_code resultcode) +{ + int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); + int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); + int unsignedp0, unsignedp1; + + /* In C++, check for comparison of different enum types. */ + if (c_dialect_cxx() + && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE + && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE + && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) + != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))) + { + warning (OPT_Wsign_compare, "comparison between types %qT and %qT", + TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); + } + + /* Do not warn if the comparison is being done in a signed type, + since the signed type will only be chosen if it can represent + all the values of the unsigned type. */ + if (!TYPE_UNSIGNED (result_type)) + /* OK */; + /* Do not warn if both operands are unsigned. */ + else if (op0_signed == op1_signed) + /* OK */; + else + { + tree sop, uop; + bool ovf; + + if (op0_signed) + sop = orig_op0, uop = orig_op1; + else + sop = orig_op1, uop = orig_op0; + + STRIP_TYPE_NOPS (sop); + STRIP_TYPE_NOPS (uop); + + /* Do not warn if the signed quantity is an unsuffixed integer + literal (or some static constant expression involving such + literals or a conditional expression involving such literals) + and it is non-negative. */ + if (tree_expr_nonnegative_warnv_p (sop, &ovf)) + /* OK */; + /* Do not warn if the comparison is an equality operation, the + unsigned quantity is an integral constant, and it would fit + in the result if the result were signed. */ + else if (TREE_CODE (uop) == INTEGER_CST + && (resultcode == EQ_EXPR || resultcode == NE_EXPR) + && int_fits_type_p (uop, c_common_signed_type (result_type))) + /* OK */; + /* In C, do not warn if the unsigned quantity is an enumeration + constant and its maximum value would fit in the result if the + result were signed. */ + else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST + && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE + && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)), + c_common_signed_type (result_type))) + /* OK */; + else + warning (OPT_Wsign_compare, + "comparison between signed and unsigned integer expressions"); + } + + /* Warn if two unsigned values are being compared in a size larger + than their original size, and one (and only one) is the result of + a `~' operator. This comparison will always fail. + + Also warn if one operand is a constant, and the constant does not + have all bits set that are set in the ~ operand when it is + extended. */ + + op0 = get_narrower (op0, &unsignedp0); + op1 = get_narrower (op1, &unsignedp1); + + if ((TREE_CODE (op0) == BIT_NOT_EXPR) + ^ (TREE_CODE (op1) == BIT_NOT_EXPR)) + { + if (TREE_CODE (op0) == BIT_NOT_EXPR) + op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0); + if (TREE_CODE (op1) == BIT_NOT_EXPR) + op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1); + + if (host_integerp (op0, 0) || host_integerp (op1, 0)) + { + tree primop; + HOST_WIDE_INT constant, mask; + int unsignedp; + unsigned int bits; + + if (host_integerp (op0, 0)) + { + primop = op1; + unsignedp = unsignedp1; + constant = tree_low_cst (op0, 0); + } + else + { + primop = op0; + unsignedp = unsignedp0; + constant = tree_low_cst (op1, 0); + } + + bits = TYPE_PRECISION (TREE_TYPE (primop)); + if (bits < TYPE_PRECISION (result_type) + && bits < HOST_BITS_PER_LONG && unsignedp) + { + mask = (~ (HOST_WIDE_INT) 0) << bits; + if ((mask & constant) != mask) + { + if (constant == 0) + warning (OPT_Wsign_compare, + "promoted ~unsigned is always non-zero"); + else + warning (OPT_Wsign_compare, + "comparison of promoted ~unsigned with constant"); + } + } + } + else if (unsignedp0 && unsignedp1 + && (TYPE_PRECISION (TREE_TYPE (op0)) + < TYPE_PRECISION (result_type)) + && (TYPE_PRECISION (TREE_TYPE (op1)) + < TYPE_PRECISION (result_type))) + warning (OPT_Wsign_compare, + "comparison of promoted ~unsigned with unsigned"); + } +} + #include "gt-c-common.h" diff --git a/gcc/c-common.h b/gcc/c-common.h index f600751f0c0..b0abe3e1a51 100644 --- a/gcc/c-common.h +++ b/gcc/c-common.h @@ -498,11 +498,6 @@ extern int flag_isoc99; extern int flag_hosted; -/* Warn if main is suspicious. */ - -extern int warn_main; - - /* ObjC language option variables. */ @@ -928,6 +923,10 @@ extern void warn_about_parentheses (enum tree_code, enum tree_code, enum tree_code); extern void warn_for_unused_label (tree label); extern void warn_for_div_by_zero (tree divisor); +extern void warn_for_sign_compare (tree orig_op0, tree orig_op1, + tree op0, tree op1, + tree result_type, + enum tree_code resultcode); /* In c-gimplify.c */ extern void c_genericize (tree); diff --git a/gcc/c-cppbuiltin.c b/gcc/c-cppbuiltin.c index 01f92155fd6..f1a454fed9a 100644 --- a/gcc/c-cppbuiltin.c +++ b/gcc/c-cppbuiltin.c @@ -693,7 +693,7 @@ c_cpp_builtins (cpp_reader *pfile) #endif #ifdef DWARF2_UNWIND_INFO - if (flag_dwarf2_cfi_asm && dwarf2out_do_frame ()) + if (dwarf2out_do_cfi_asm ()) cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); #endif @@ -852,7 +852,7 @@ builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) /* Pass an object-like macro a hexadecimal floating-point value. */ static void builtin_define_with_hex_fp_value (const char *macro, - tree type ATTRIBUTE_UNUSED, int digits, + tree type, int digits, const char *hex_str, const char *fp_suffix, const char *fp_cast) @@ -871,7 +871,8 @@ builtin_define_with_hex_fp_value (const char *macro, then print it back out as decimal. */ real_from_string (&real, hex_str); - real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0); + real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0, + TYPE_MODE (type)); /* Assemble the macro in the following fashion macro = fp_cast [dec_str fp_suffix] */ diff --git a/gcc/c-decl.c b/gcc/c-decl.c index ff23f6e4186..7be2ca4e60a 100644 --- a/gcc/c-decl.c +++ b/gcc/c-decl.c @@ -1115,16 +1115,16 @@ validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype) first in a pair of mismatched declarations, using the diagnostic function DIAG. */ static void -locate_old_decl (tree decl, void (*diag)(const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2)) +locate_old_decl (tree decl) { if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)) ; else if (DECL_INITIAL (decl)) - diag (G_("previous definition of %q+D was here"), decl); + inform ("previous definition of %q+D was here", decl); else if (C_DECL_IMPLICIT (decl)) - diag (G_("previous implicit declaration of %q+D was here"), decl); + inform ("previous implicit declaration of %q+D was here", decl); else - diag (G_("previous declaration of %q+D was here"), decl); + inform ("previous declaration of %q+D was here", decl); } /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL. @@ -1165,7 +1165,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && !C_DECL_DECLARED_BUILTIN (olddecl))) { error ("%q+D redeclared as different kind of symbol", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); } else if (TREE_PUBLIC (newdecl)) warning (0, "built-in function %q+D declared as non-function", @@ -1181,7 +1181,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, if (TREE_CODE (olddecl) == CONST_DECL) { error ("redeclaration of enumerator %q+D", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } @@ -1225,11 +1225,10 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl)) { - pedwarn (0, "conflicting types for %q+D", newdecl); + pedwarned = pedwarn (0, "conflicting types for %q+D", newdecl); /* Make sure we keep void as the return type. */ TREE_TYPE (newdecl) = *newtypep = newtype = oldtype; C_FUNCTION_IMPLICIT_INT (newdecl) = 0; - pedwarned = true; } /* Permit void foo (...) to match an earlier call to foo (...) with no declared type (thus, implicitly int). */ @@ -1238,10 +1237,9 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl)) { - pedwarn (0, "conflicting types for %q+D", newdecl); + pedwarned = pedwarn (0, "conflicting types for %q+D", newdecl); /* Make sure we keep void as the return type. */ TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype; - pedwarned = true; } else { @@ -1250,7 +1248,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, else error ("conflicting types for %q+D", newdecl); diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } } @@ -1267,7 +1265,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, return true; /* Allow OLDDECL to continue in use. */ error ("redefinition of typedef %q+D", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } @@ -1318,7 +1316,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && same_translation_unit_p (newdecl, olddecl)) { error ("redefinition of %q+D", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } } @@ -1330,7 +1328,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && TYPE_ACTUAL_ARG_TYPES (oldtype) && !validate_proto_after_old_defn (newdecl, newtype, oldtype)) { - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } /* A non-static declaration (even an "extern") followed by a @@ -1354,7 +1352,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, { error ("static declaration of %q+D follows " "non-static declaration", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); } return false; } @@ -1364,14 +1362,14 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, { error ("non-static declaration of %q+D follows " "static declaration", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } else if (warn_traditional) { - warning (OPT_Wtraditional, "non-static declaration of %q+D " - "follows static declaration", newdecl); - warned = true; + warned |= warning (OPT_Wtraditional, + "non-static declaration of %q+D " + "follows static declaration", newdecl); } } @@ -1412,7 +1410,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, error ("non-thread-local declaration of %q+D follows " "thread-local declaration", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } @@ -1420,7 +1418,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl)) { error ("redefinition of %q+D", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } @@ -1441,14 +1439,14 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, { error ("extern declaration of %q+D follows " "declaration with no linkage", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } else if (warn_traditional) { - warning (OPT_Wtraditional, "non-static declaration of %q+D " - "follows static declaration", newdecl); - warned = true; + warned |= warning (OPT_Wtraditional, + "non-static declaration of %q+D " + "follows static declaration", newdecl); } } else @@ -1460,7 +1458,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, error ("static declaration of %q+D follows " "non-static declaration", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } } @@ -1477,12 +1475,12 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, { error ("declaration of %q+D with no linkage follows " "extern declaration", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); } else { error ("redeclaration of %q+D with no linkage", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); } return false; @@ -1495,9 +1493,8 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl) && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl)) { - warning (0, "redeclaration of %q+D with different visibility " - "(old visibility preserved)", newdecl); - warned = true; + warned |= warning (0, "redeclaration of %q+D with different visibility " + "(old visibility preserved)", newdecl); } if (TREE_CODE (newdecl) == FUNCTION_DECL) @@ -1506,16 +1503,16 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, if (DECL_DECLARED_INLINE_P (newdecl) && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) { - warning (OPT_Wattributes, "inline declaration of %qD follows " - "declaration with attribute noinline", newdecl); - warned = true; + warned |= warning (OPT_Wattributes, + "inline declaration of %qD follows " + "declaration with attribute noinline", newdecl); } else if (DECL_DECLARED_INLINE_P (olddecl) && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) { - warning (OPT_Wattributes, "declaration of %q+D with attribute " - "noinline follows inline declaration ", newdecl); - warned = true; + warned |= warning (OPT_Wattributes, + "declaration of %q+D with attribute " + "noinline follows inline declaration ", newdecl); } } else /* PARM_DECL, VAR_DECL */ @@ -1533,7 +1530,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl))) { error ("redefinition of parameter %q+D", newdecl); - locate_old_decl (olddecl, error); + locate_old_decl (olddecl); return false; } } @@ -1559,14 +1556,13 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl, && !(TREE_CODE (newdecl) == VAR_DECL && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))) { - warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D", - newdecl); - warned = true; + warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D", + newdecl); } - /* Report location of previous decl/defn in a consistent manner. */ + /* Report location of previous decl/defn. */ if (warned || pedwarned) - locate_old_decl (olddecl, pedwarned ? pedwarn0 : warning0); + locate_old_decl (olddecl); #undef DECL_EXTERN_INLINE @@ -2330,14 +2326,16 @@ implicit_decl_warning (tree id, tree olddecl) { if (warn_implicit_function_declaration) { + bool warned; + if (flag_isoc99) - pedwarn (OPT_Wimplicit_function_declaration, - G_("implicit declaration of function %qE"), id); + warned = pedwarn (OPT_Wimplicit_function_declaration, + G_("implicit declaration of function %qE"), id); else - warning (OPT_Wimplicit_function_declaration, - G_("implicit declaration of function %qE"), id); - if (olddecl) - locate_old_decl (olddecl, inform); + warned = warning (OPT_Wimplicit_function_declaration, + G_("implicit declaration of function %qE"), id); + if (olddecl && warned) + locate_old_decl (olddecl); } } @@ -2408,7 +2406,7 @@ implicitly_declare (tree functionid) { error ("incompatible implicit declaration of function %qD", decl); - locate_old_decl (decl, error); + locate_old_decl (decl); } } b->type = TREE_TYPE (decl); @@ -2550,7 +2548,7 @@ declare_label (tree name) if (b && B_IN_CURRENT_SCOPE (b)) { error ("duplicate label declaration %qE", name); - locate_old_decl (b->decl, error); + locate_old_decl (b->decl); /* Just use the previous declaration. */ return b->decl; @@ -2586,7 +2584,7 @@ define_label (location_t location, tree name) && C_DECLARED_LABEL_FLAG (label)))) { error ("%Hduplicate label %qD", &location, label); - locate_old_decl (label, error); + locate_old_decl (label); return 0; } else if (label && DECL_CONTEXT (label) == current_function_decl) @@ -3155,8 +3153,7 @@ start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs, if (!decl) return 0; - if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL - && MAIN_NAME_P (DECL_NAME (decl))) + if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl))) warning (OPT_Wmain, "%q+D is usually a function", decl); if (initialized) @@ -5879,11 +5876,13 @@ finish_enum (tree enumtype, tree values, tree attributes) /* The ISO C Standard mandates enumerators to have type int, even though the underlying type of an enum type is - unspecified. Here we convert any enumerators that fit in - an int to type int, to avoid promotions to unsigned types - when comparing integers with enumerators that fit in the - int range. When -pedantic is given, build_enumerator() - would have already taken care of those that don't fit. */ + unspecified. However, GCC allows enumerators of any + integer type as an extensions. Here we convert any + enumerators that fit in an int to type int, to avoid + promotions to unsigned types when comparing integers with + enumerators that fit in the int range. When -pedantic is + given, build_enumerator() would have already warned about + those that don't fit. */ if (int_fits_type_p (ini, integer_type_node)) tem = integer_type_node; else @@ -5935,7 +5934,8 @@ finish_enum (tree enumtype, tree values, tree attributes) Assignment of sequential values by default is handled here. */ tree -build_enumerator (struct c_enum_contents *the_enum, tree name, tree value) +build_enumerator (struct c_enum_contents *the_enum, tree name, tree value, + location_t value_loc) { tree decl, type; @@ -5969,14 +5969,13 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value) if (the_enum->enum_overflow) error ("overflow in enumeration values"); } - - if (pedantic && !int_fits_type_p (value, integer_type_node)) - { - pedwarn (OPT_pedantic, "ISO C restricts enumerator values to range of %<int%>"); - /* XXX This causes -pedantic to change the meaning of the program. - Remove? -zw 2004-03-15 */ - value = convert (integer_type_node, value); - } + /* Even though the underlying type of an enum is unspecified, the + type of enumeration constants is explicitly defined as int + (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as + an extension. */ + else if (!int_fits_type_p (value, integer_type_node)) + pedwarn_at (value_loc, OPT_pedantic, + "ISO C restricts enumerator values to range of %<int%>"); /* Set basis for default for next value. */ the_enum->enum_next_value = build_binary_op (PLUS_EXPR, value, @@ -6207,13 +6206,13 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator, maybe_apply_pragma_weak (decl1); /* Warn for unlikely, improbable, or stupid declarations of `main'. */ - if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1))) + if (warn_main && MAIN_NAME_P (DECL_NAME (decl1))) { if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1))) != integer_type_node) pedwarn (OPT_Wmain, "return type of %q+D is not %<int%>", decl1); - check_main_parameter_types(decl1); + check_main_parameter_types (decl1); if (!TREE_PUBLIC (decl1)) pedwarn (OPT_Wmain, "%q+D is normally a non-static function", decl1); @@ -6672,30 +6671,18 @@ finish_function (void) if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node) DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; - if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted) - { - if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) - != integer_type_node) - { - /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned. - If warn_main is -1 (-Wno-main) we don't want to be warned. */ - if (!warn_main) - pedwarn (0, "return type of %q+D is not %<int%>", fndecl); - } - else - { - if (flag_isoc99) - { - tree stmt = c_finish_return (integer_zero_node); - /* Hack. We don't want the middle-end to warn that this return - is unreachable, so we mark its location as special. Using - UNKNOWN_LOCATION has the problem that it gets clobbered in - annotate_one_with_locus. A cleaner solution might be to - ensure ! should_carry_locus_p (stmt), but that needs a flag. - */ - SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION); - } - } + if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted + && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) + == integer_type_node && flag_isoc99) + { + tree stmt = c_finish_return (integer_zero_node); + /* Hack. We don't want the middle-end to warn that this return + is unreachable, so we mark its location as special. Using + UNKNOWN_LOCATION has the problem that it gets clobbered in + annotate_one_with_locus. A cleaner solution might be to + ensure ! should_carry_locus_p (stmt), but that needs a flag. + */ + SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION); } /* Tie off the statement tree for this function. */ diff --git a/gcc/c-errors.c b/gcc/c-errors.c index 8adeeeb3538..999743259f1 100644 --- a/gcc/c-errors.c +++ b/gcc/c-errors.c @@ -38,7 +38,7 @@ pedwarn_c99 (int opt, const char *gmsgid, ...) va_start (ap, gmsgid); diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, - flag_isoc99 ? pedantic_warning_kind () : DK_WARNING); + flag_isoc99 ? DK_PEDWARN : DK_WARNING); diagnostic.option_index = opt; report_diagnostic (&diagnostic); va_end (ap); @@ -57,7 +57,7 @@ pedwarn_c90 (int opt, const char *gmsgid, ...) va_start (ap, gmsgid); diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, - flag_isoc99 ? DK_WARNING : pedantic_warning_kind ()); + flag_isoc99 ? DK_WARNING : DK_PEDWARN); diagnostic.option_index = opt; report_diagnostic (&diagnostic); va_end (ap); diff --git a/gcc/c-opts.c b/gcc/c-opts.c index 8b31b8879e7..300bf14f503 100644 --- a/gcc/c-opts.c +++ b/gcc/c-opts.c @@ -376,7 +376,7 @@ c_common_handle_option (size_t scode, const char *arg, int value) break; case OPT_Wall: - set_Wunused (value); + warn_unused = value; set_Wformat (value); set_Wimplicit (value); warn_char_subscripts = value; @@ -404,9 +404,12 @@ c_common_handle_option (size_t scode, const char *arg, int value) warn_uninitialized = (value ? 2 : 0); if (!c_dialect_cxx ()) - /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding - can turn it off only if it's not explicit. */ - warn_main = value * 2; + { + /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding + can turn it off only if it's not explicit. */ + if (warn_main == -1) + warn_main = (value ? 2 : 0); + } else { /* C++-specific warnings. */ @@ -467,13 +470,6 @@ c_common_handle_option (size_t scode, const char *arg, int value) cpp_opts->warn_invalid_pch = value; break; - case OPT_Wmain: - if (value) - warn_main = 1; - else - warn_main = -1; - break; - case OPT_Wmissing_include_dirs: cpp_opts->warn_missing_include_dirs = value; break; @@ -615,9 +611,6 @@ c_common_handle_option (size_t scode, const char *arg, int value) case OPT_fhosted: flag_hosted = value; flag_no_builtin = !value; - /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */ - if (!value && warn_main == 2) - warn_main = 0; break; case OPT_fshort_double: @@ -907,6 +900,8 @@ c_common_handle_option (size_t scode, const char *arg, int value) warn_pointer_sign = 1; if (warn_overlength_strings == -1) warn_overlength_strings = 1; + if (warn_main == -1) + warn_main = 2; break; case OPT_print_objc_runtime_info: @@ -1071,6 +1066,15 @@ c_common_post_options (const char **pfilename) if (warn_overlength_strings == -1 || c_dialect_cxx ()) warn_overlength_strings = 0; + /* Wmain is enabled by default in C++ but not in C. */ + /* Wmain is disabled by default for -ffreestanding (!flag_hosted), + even if -Wall was given (warn_main will be 2 if set by -Wall, 1 + if set by -Wmain). */ + if (warn_main == -1) + warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0; + else if (warn_main == 2) + warn_main = flag_hosted ? 1 : 0; + /* In C, -Wconversion enables -Wsign-conversion (unless disabled through -Wno-sign-conversion). While in C++, -Wsign-conversion needs to be requested explicitly. */ diff --git a/gcc/c-parser.c b/gcc/c-parser.c index a2ea45f6a78..1ea9d07fcdf 100644 --- a/gcc/c-parser.c +++ b/gcc/c-parser.c @@ -241,8 +241,6 @@ c_lex_one_token (c_parser *parser, c_token *token) } else { - /* Return the canonical spelling for this keyword. */ - token->value = ridpointers[(int) rid_code]; token->type = CPP_KEYWORD; token->keyword = rid_code; break; @@ -1630,6 +1628,7 @@ c_parser_enum_specifier (c_parser *parser) bool seen_comma; c_token *token; location_t comma_loc; + location_t value_loc; if (c_parser_next_token_is_not (parser, CPP_NAME)) { c_parser_error (parser, "expected identifier"); @@ -1641,15 +1640,19 @@ c_parser_enum_specifier (c_parser *parser) enum_id = token->value; /* Set the location in case we create a decl now. */ c_parser_set_source_position_from_token (token); + value_loc = token->location; c_parser_consume_token (parser); if (c_parser_next_token_is (parser, CPP_EQ)) { c_parser_consume_token (parser); + value_loc = c_parser_peek_token (parser)->location; + /* This may call cb_line_change and alter the input_location. */ enum_value = c_parser_expr_no_commas (parser, NULL).value; } else enum_value = NULL_TREE; - enum_decl = build_enumerator (&the_enum, enum_id, enum_value); + enum_decl = build_enumerator (&the_enum, enum_id, enum_value, + value_loc); TREE_CHAIN (enum_decl) = values; values = enum_decl; seen_comma = false; @@ -3791,6 +3794,23 @@ c_parser_statement_after_labels (c_parser *parser) parser->in_if_block = in_if_block; } +/* Parse the condition from an if, do, while or for statements. */ + +static tree +c_parser_condition (c_parser *parser) +{ + location_t loc; + tree cond; + loc = c_parser_peek_token (parser)->location; + cond = c_objc_common_truthvalue_conversion + (c_parser_expression_conv (parser).value); + if (CAN_HAVE_LOCATION_P (cond)) + SET_EXPR_LOCATION (cond, loc); + if (warn_sequence_point) + verify_sequence_points (cond); + return cond; +} + /* Parse a parenthesized condition from an if, do or while statement. condition: @@ -3799,15 +3819,10 @@ c_parser_statement_after_labels (c_parser *parser) static tree c_parser_paren_condition (c_parser *parser) { - location_t loc; tree cond; if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) return error_mark_node; - loc = c_parser_peek_token (parser)->location; - cond = c_objc_common_truthvalue_conversion - (c_parser_expression_conv (parser).value); - if (CAN_HAVE_LOCATION_P (cond)) - SET_EXPR_LOCATION (cond, loc); + cond = c_parser_condition (parser); c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); return cond; } @@ -4073,7 +4088,6 @@ c_parser_for_statement (c_parser *parser) c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); } /* Parse the loop condition. */ - loc = c_parser_peek_token (parser)->location; if (c_parser_next_token_is (parser, CPP_SEMICOLON)) { c_parser_consume_token (parser); @@ -4081,10 +4095,7 @@ c_parser_for_statement (c_parser *parser) } else { - tree ocond = c_parser_expression_conv (parser).value; - cond = c_objc_common_truthvalue_conversion (ocond); - if (CAN_HAVE_LOCATION_P (cond)) - SET_EXPR_LOCATION (cond, loc); + cond = c_parser_condition (parser); c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); } /* Parse the increment expression. */ diff --git a/gcc/c-tree.h b/gcc/c-tree.h index d3e3695341c..fc76ee32b35 100644 --- a/gcc/c-tree.h +++ b/gcc/c-tree.h @@ -462,7 +462,7 @@ extern void c_print_identifier (FILE *, tree, int); extern int quals_from_declspecs (const struct c_declspecs *); extern struct c_declarator *build_array_declarator (tree, struct c_declspecs *, bool, bool); -extern tree build_enumerator (struct c_enum_contents *, tree, tree); +extern tree build_enumerator (struct c_enum_contents *, tree, tree, location_t); extern tree check_for_loop_decls (void); extern void mark_forward_parm_decls (void); extern void declare_parm_level (void); diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index 4756e256f38..7646272dbd1 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -2408,11 +2408,10 @@ build_function_call (tree function, tree params) /* This situation leads to run-time undefined behavior. We can't, therefore, simply error unless we can prove that all possible executions of the program must execute the code. */ - warning (0, "function called through a non-compatible type"); - - /* We can, however, treat "undefined" any way we please. - Call abort to encourage the user to fix the program. */ - inform ("if this code is reached, the program will abort"); + if (warning (0, "function called through a non-compatible type")) + /* We can, however, treat "undefined" any way we please. + Call abort to encourage the user to fix the program. */ + inform ("if this code is reached, the program will abort"); if (VOID_TYPE_P (return_type)) return trap; @@ -4802,6 +4801,9 @@ digest_init (tree type, tree init, bool strict_string, int require_constant) } } + if (warn_sequence_point) + verify_sequence_points (inside_init); + /* Any type can be initialized from an expression of the same type, optionally with braces. */ @@ -7167,6 +7169,9 @@ c_finish_return (tree retval) } retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); + + if (warn_sequence_point) + verify_sequence_points (retval); } ret_stmt = build_stmt (RETURN_EXPR, retval); @@ -7244,6 +7249,9 @@ c_start_case (tree exp) "converted to %<int%> in ISO C"); exp = default_conversion (exp); + + if (warn_sequence_point) + verify_sequence_points (exp); } } @@ -8372,124 +8380,10 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, converted = 1; resultcode = xresultcode; - if (warn_sign_compare && skip_evaluation == 0) - { - int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); - int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); - int unsignedp0, unsignedp1; - tree primop0 = get_narrower (op0, &unsignedp0); - tree primop1 = get_narrower (op1, &unsignedp1); - - xop0 = orig_op0; - xop1 = orig_op1; - STRIP_TYPE_NOPS (xop0); - STRIP_TYPE_NOPS (xop1); - - /* Give warnings for comparisons between signed and unsigned - quantities that may fail. - - Do the checking based on the original operand trees, so that - casts will be considered, but default promotions won't be. - - Do not warn if the comparison is being done in a signed type, - since the signed type will only be chosen if it can represent - all the values of the unsigned type. */ - if (!TYPE_UNSIGNED (result_type)) - /* OK */; - /* Do not warn if both operands are the same signedness. */ - else if (op0_signed == op1_signed) - /* OK */; - else - { - tree sop, uop; - bool ovf; - - if (op0_signed) - sop = xop0, uop = xop1; - else - sop = xop1, uop = xop0; - - /* Do not warn if the signed quantity is an - unsuffixed integer literal (or some static - constant expression involving such literals or a - conditional expression involving such literals) - and it is non-negative. */ - if (tree_expr_nonnegative_warnv_p (sop, &ovf)) - /* OK */; - /* Do not warn if the comparison is an equality operation, - the unsigned quantity is an integral constant, and it - would fit in the result if the result were signed. */ - else if (TREE_CODE (uop) == INTEGER_CST - && (resultcode == EQ_EXPR || resultcode == NE_EXPR) - && int_fits_type_p - (uop, c_common_signed_type (result_type))) - /* OK */; - /* Do not warn if the unsigned quantity is an enumeration - constant and its maximum value would fit in the result - if the result were signed. */ - else if (TREE_CODE (uop) == INTEGER_CST - && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE - && int_fits_type_p - (TYPE_MAX_VALUE (TREE_TYPE (uop)), - c_common_signed_type (result_type))) - /* OK */; - else - warning (OPT_Wsign_compare, "comparison between signed and unsigned"); - } - - /* Warn if two unsigned values are being compared in a size - larger than their original size, and one (and only one) is the - result of a `~' operator. This comparison will always fail. - - Also warn if one operand is a constant, and the constant - does not have all bits set that are set in the ~ operand - when it is extended. */ - - if ((TREE_CODE (primop0) == BIT_NOT_EXPR) - != (TREE_CODE (primop1) == BIT_NOT_EXPR)) - { - if (TREE_CODE (primop0) == BIT_NOT_EXPR) - primop0 = get_narrower (TREE_OPERAND (primop0, 0), - &unsignedp0); - else - primop1 = get_narrower (TREE_OPERAND (primop1, 0), - &unsignedp1); - - if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) - { - tree primop; - HOST_WIDE_INT constant, mask; - int unsignedp, bits; - - if (host_integerp (primop0, 0)) - { - primop = primop1; - unsignedp = unsignedp1; - constant = tree_low_cst (primop0, 0); - } - else - { - primop = primop0; - unsignedp = unsignedp0; - constant = tree_low_cst (primop1, 0); - } - - bits = TYPE_PRECISION (TREE_TYPE (primop)); - if (bits < TYPE_PRECISION (result_type) - && bits < HOST_BITS_PER_WIDE_INT && unsignedp) - { - mask = (~(HOST_WIDE_INT) 0) << bits; - if ((mask & constant) != mask) - warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with constant"); - } - } - else if (unsignedp0 && unsignedp1 - && (TYPE_PRECISION (TREE_TYPE (primop0)) - < TYPE_PRECISION (result_type)) - && (TYPE_PRECISION (TREE_TYPE (primop1)) - < TYPE_PRECISION (result_type))) - warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with unsigned"); - } + if (warn_sign_compare && !skip_evaluation) + { + warn_for_sign_compare (orig_op0, orig_op1, op0, op1, + result_type, resultcode); } } } diff --git a/gcc/c.opt b/gcc/c.opt index 30782d4f3a7..d33fa46e8a7 100644 --- a/gcc/c.opt +++ b/gcc/c.opt @@ -281,7 +281,7 @@ C ObjC C++ ObjC++ Var(warn_long_long) Init(1) Warning Do not warn about using \"long long\" when -pedantic Wmain -C ObjC C++ ObjC++ Warning +C ObjC C++ ObjC++ Var(warn_main) Init(-1) Warning Warn about suspicious declarations of \"main\" Wmissing-braces diff --git a/gcc/calls.c b/gcc/calls.c index d48c0d15654..27aaaee6eff 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -1877,7 +1877,7 @@ shift_return_value (enum machine_mode mode, bool left_p, rtx value) static rtx avoid_likely_spilled_reg (rtx x) { - rtx new; + rtx new_rtx; if (REG_P (x) && HARD_REGISTER_P (x) @@ -1888,10 +1888,10 @@ avoid_likely_spilled_reg (rtx x) and the whole point of this function is to avoid using the hard register directly in such a situation. */ generating_concat_p = 0; - new = gen_reg_rtx (GET_MODE (x)); + new_rtx = gen_reg_rtx (GET_MODE (x)); generating_concat_p = 1; - emit_move_insn (new, x); - return new; + emit_move_insn (new_rtx, x); + return new_rtx; } return x; } @@ -2319,10 +2319,13 @@ expand_call (tree exp, rtx target, int ignore) || !lang_hooks.decls.ok_for_sibcall (fndecl)) try_tail_call = 0; - /* Ensure current function's preferred stack - boundary is at least what we need. */ + /* Ensure current function's preferred stack boundary is at least + what we need. Stack alignment may also increase preferred stack + boundary. */ if (crtl->preferred_stack_boundary < preferred_stack_boundary) crtl->preferred_stack_boundary = preferred_stack_boundary; + else + preferred_stack_boundary = crtl->preferred_stack_boundary; preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT; diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index a943eff6ec1..ac228f9b79f 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -50,20 +50,20 @@ tree gimple_assign_rhs_to_tree (gimple stmt) { tree t; - enum gimple_rhs_class class; + enum gimple_rhs_class grhs_class; - class = get_gimple_rhs_class (gimple_expr_code (stmt)); + grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt)); - if (class == GIMPLE_BINARY_RHS) + if (grhs_class == GIMPLE_BINARY_RHS) t = build2 (gimple_assign_rhs_code (stmt), TREE_TYPE (gimple_assign_lhs (stmt)), gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt)); - else if (class == GIMPLE_UNARY_RHS) + else if (grhs_class == GIMPLE_UNARY_RHS) t = build1 (gimple_assign_rhs_code (stmt), TREE_TYPE (gimple_assign_lhs (stmt)), gimple_assign_rhs1 (stmt)); - else if (class == GIMPLE_SINGLE_RHS) + else if (grhs_class == GIMPLE_SINGLE_RHS) t = gimple_assign_rhs1 (stmt); else gcc_unreachable (); @@ -216,16 +216,8 @@ gimple_to_tree (gimple stmt) t = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3); - fn = gimple_call_fn (stmt); - if (TREE_CODE (fn) == FUNCTION_DECL) - CALL_EXPR_FN (t) = build1 (ADDR_EXPR, - build_pointer_type (TREE_TYPE (fn)), - fn); - else - CALL_EXPR_FN (t) = fn; - + CALL_EXPR_FN (t) = gimple_call_fn (stmt); TREE_TYPE (t) = gimple_call_return_type (stmt); - CALL_EXPR_STATIC_CHAIN (t) = gimple_call_chain (stmt); for (i = 0; i < gimple_call_num_args (stmt); i++) @@ -253,7 +245,9 @@ gimple_to_tree (gimple stmt) /* Record the original call statement, as it may be used to retrieve profile information during expansion. */ - if (TREE_CODE (fn) == FUNCTION_DECL && DECL_BUILT_IN (fn)) + + if ((fn = gimple_call_fndecl (stmt)) != NULL_TREE + && DECL_BUILT_IN (fn)) { ann = get_tree_common_ann (t); ann->stmt = stmt; @@ -368,15 +362,11 @@ release_stmt_tree (gimple stmt, tree stmt_tree) case GIMPLE_CALL: if (gimple_call_lhs (stmt)) { - if (TREE_CODE (gimple_call_fn (stmt)) == FUNCTION_DECL) - ggc_free (CALL_EXPR_FN (TREE_OPERAND (stmt_tree, 1))); ann = tree_common_ann (TREE_OPERAND (stmt_tree, 1)); if (ann) ggc_free (ann); ggc_free (TREE_OPERAND (stmt_tree, 1)); } - else if (TREE_CODE (gimple_call_fn (stmt)) == FUNCTION_DECL) - ggc_free (CALL_EXPR_FN (stmt_tree)); break; default: break; @@ -2184,7 +2174,7 @@ static void expand_stack_alignment (void) { rtx drap_rtx; - unsigned int preferred_stack_boundary; + unsigned int preferred_stack_boundary, incoming_stack_boundary; if (! SUPPORTS_STACK_ALIGNMENT) return; @@ -2215,8 +2205,15 @@ expand_stack_alignment (void) if (preferred_stack_boundary > crtl->stack_alignment_needed) crtl->stack_alignment_needed = preferred_stack_boundary; + /* The incoming stack frame has to be aligned at least at + parm_stack_boundary. */ + if (crtl->parm_stack_boundary > INCOMING_STACK_BOUNDARY) + incoming_stack_boundary = crtl->parm_stack_boundary; + else + incoming_stack_boundary = INCOMING_STACK_BOUNDARY; + crtl->stack_realign_needed - = INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated; + = incoming_stack_boundary < crtl->stack_alignment_estimated; crtl->stack_realign_tried = crtl->stack_realign_needed; crtl->stack_realign_processed = true; diff --git a/gcc/cgraph.c b/gcc/cgraph.c index b5564b679d4..37ad9f1606f 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -1159,25 +1159,25 @@ cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n, gimple call_stmt, gcov_type count_scale, int freq_scale, int loop_nest, bool update_original) { - struct cgraph_edge *new; + struct cgraph_edge *new_edge; gcov_type count = e->count * count_scale / REG_BR_PROB_BASE; gcov_type freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE; if (freq > CGRAPH_FREQ_MAX) freq = CGRAPH_FREQ_MAX; - new = cgraph_create_edge (n, e->callee, call_stmt, count, freq, + new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq, e->loop_nest + loop_nest); - new->inline_failed = e->inline_failed; - new->indirect_call = e->indirect_call; + new_edge->inline_failed = e->inline_failed; + new_edge->indirect_call = e->indirect_call; if (update_original) { - e->count -= new->count; + e->count -= new_edge->count; if (e->count < 0) e->count = 0; } - cgraph_call_edge_duplication_hooks (e, new); - return new; + cgraph_call_edge_duplication_hooks (e, new_edge); + return new_edge; } /* Create node representing clone of N executed COUNT times. Decrease @@ -1190,25 +1190,25 @@ struct cgraph_node * cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq, int loop_nest, bool update_original) { - struct cgraph_node *new = cgraph_create_node (); + struct cgraph_node *new_node = cgraph_create_node (); struct cgraph_edge *e; gcov_type count_scale; - new->decl = n->decl; - new->origin = n->origin; - if (new->origin) + new_node->decl = n->decl; + new_node->origin = n->origin; + if (new_node->origin) { - new->next_nested = new->origin->nested; - new->origin->nested = new; + new_node->next_nested = new_node->origin->nested; + new_node->origin->nested = new_node; } - new->analyzed = n->analyzed; - new->local = n->local; - new->global = n->global; - new->rtl = n->rtl; - new->master_clone = n->master_clone; - new->count = count; + new_node->analyzed = n->analyzed; + new_node->local = n->local; + new_node->global = n->global; + new_node->rtl = n->rtl; + new_node->master_clone = n->master_clone; + new_node->count = count; if (n->count) - count_scale = new->count * REG_BR_PROB_BASE / n->count; + count_scale = new_node->count * REG_BR_PROB_BASE / n->count; else count_scale = 0; if (update_original) @@ -1219,17 +1219,17 @@ cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq, } for (e = n->callees;e; e=e->next_callee) - cgraph_clone_edge (e, new, e->call_stmt, count_scale, freq, loop_nest, + cgraph_clone_edge (e, new_node, e->call_stmt, count_scale, freq, loop_nest, update_original); - new->next_clone = n->next_clone; - new->prev_clone = n; - n->next_clone = new; - if (new->next_clone) - new->next_clone->prev_clone = new; + new_node->next_clone = n->next_clone; + new_node->prev_clone = n; + n->next_clone = new_node; + if (new_node->next_clone) + new_node->next_clone->prev_clone = new_node; - cgraph_call_node_duplication_hooks (n, new); - return new; + cgraph_call_node_duplication_hooks (n, new_node); + return new_node; } /* Return true if N is an master_clone, (see cgraph_master_clone). */ diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 48dd70bcac7..ae3dee417da 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -1420,7 +1420,7 @@ update_call_expr (struct cgraph_node *new_version) /* Update the call expr on the edges to call the new version. */ for (e = new_version->callers; e; e = e->next_caller) - gimple_call_set_fn (e->call_stmt, new_version->decl); + gimple_call_set_fndecl (e->call_stmt, new_version->decl); } diff --git a/gcc/combine.c b/gcc/combine.c index 16cd040afd5..a39649d7c8e 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -1112,6 +1112,7 @@ combine_instructions (rtx f, unsigned int nregs) last_call_luid = 0; mem_last_set = -1; label_tick++; + rtl_profile_for_bb (this_basic_block); for (insn = BB_HEAD (this_basic_block); insn != NEXT_INSN (BB_END (this_basic_block)); insn = next ? next : NEXT_INSN (insn)) @@ -1268,6 +1269,7 @@ combine_instructions (rtx f, unsigned int nregs) } } + default_rtl_profile (); clear_log_links (); clear_bb_flags (); new_direct_jump_p |= purge_all_dead_edges (); diff --git a/gcc/common.opt b/gcc/common.opt index 25e6c0de5a9..4db650c88d4 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -210,27 +210,27 @@ Common Var(warn_notreached) Warning Warn about code that will never be executed Wunused -Common Warning +Common Var(warn_unused) Init(0) Warning Enable all -Wunused- warnings Wunused-function -Common Var(warn_unused_function) Warning +Common Var(warn_unused_function) Init(-1) Warning Warn when a function is unused Wunused-label -Common Var(warn_unused_label) Warning +Common Var(warn_unused_label) Init(-1) Warning Warn when a label is unused Wunused-parameter -Common Var(warn_unused_parameter) Warning +Common Var(warn_unused_parameter) Init(-1) Warning Warn when a function parameter is unused Wunused-value -Common Var(warn_unused_value) Warning +Common Var(warn_unused_value) Init(-1) Warning Warn when an expression value is unused Wunused-variable -Common Var(warn_unused_variable) Warning +Common Var(warn_unused_variable) Init(-1) Warning Warn when a variable is unused Wcoverage-mismatch diff --git a/gcc/config.gcc b/gcc/config.gcc index a2aa4242f80..30339e233d4 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -334,7 +334,7 @@ powerpc*-*-*) extra_headers="ppc-asm.h altivec.h spe.h ppu_intrinsics.h paired.h spu2vmx.h vec_types.h si2vmx.h" need_64bit_hwint=yes case x$with_cpu in - xpowerpc64|xdefault64|x6[23]0|x970|xG5|xpower[3456]|xpower6x|xrs64a|xcell) + xpowerpc64|xdefault64|x6[23]0|x970|xG5|xpower[34567]|xpower6x|xrs64a|xcell) cpu_is_64bit=yes ;; esac @@ -1544,7 +1544,7 @@ mips*-*-netbsd*) # NetBSD/mips, either endian. ;; mips64*-*-linux* | mipsisa64*-*-linux*) tm_file="dbxelf.h elfos.h svr4.h linux.h ${tm_file} mips/linux.h mips/linux64.h" - tmake_file="${tmake_file} mips/t-linux64" + tmake_file="${tmake_file} mips/t-linux64 mips/t-libgcc-mips16" tm_defines="${tm_defines} MIPS_ABI_DEFAULT=ABI_N32" case ${target} in mips64el-st-linux-gnu) @@ -1561,6 +1561,7 @@ mips64*-*-linux* | mipsisa64*-*-linux*) ;; mips*-*-linux*) # Linux MIPS, either endian. tm_file="dbxelf.h elfos.h svr4.h linux.h ${tm_file} mips/linux.h" + tmake_file="${tmake_file} mips/t-libgcc-mips16" case ${target} in mipsisa32r2*) tm_defines="${tm_defines} MIPS_ISA_DEFAULT=33" @@ -2348,11 +2349,11 @@ xstormy16-*-elf) tmake_file="stormy16/t-stormy16" extra_parts="crtbegin.o crtend.o" ;; -xtensa-*-elf*) +xtensa*-*-elf*) tm_file="${tm_file} dbxelf.h elfos.h svr4.h xtensa/elf.h" tmake_file="xtensa/t-xtensa xtensa/t-elf" ;; -xtensa-*-linux*) +xtensa*-*-linux*) tm_file="${tm_file} dbxelf.h elfos.h svr4.h linux.h xtensa/linux.h" tmake_file="${tmake_file} xtensa/t-xtensa xtensa/t-linux" ;; @@ -2842,7 +2843,7 @@ case "${target}" in eval "with_$which=405" ;; "" | common \ - | power | power[23456] | power6x | powerpc | powerpc64 \ + | power | power[234567] | power6x | powerpc | powerpc64 \ | rios | rios1 | rios2 | rsc | rsc1 | rs64a \ | 401 | 403 | 405 | 405fp | 440 | 440fp | 464 | 464fp \ | 505 | 601 | 602 | 603 | 603e | ec603e | 604 \ diff --git a/gcc/config.in b/gcc/config.in index 5ce81480f93..19b529cf4ab 100644 --- a/gcc/config.in +++ b/gcc/config.in @@ -390,6 +390,12 @@ #endif +/* Define if your assembler supports VSX instructions. */ +#ifndef USED_FOR_TARGET +#undef HAVE_AS_VSX +#endif + + /* Define to 1 if you have the `atoll' function. */ #ifndef USED_FOR_TARGET #undef HAVE_ATOLL @@ -839,6 +845,12 @@ #endif +/* Define 0/1 if your assembler supports .cfi_personality. */ +#ifndef USED_FOR_TARGET +#undef HAVE_GAS_CFI_PERSONALITY_DIRECTIVE +#endif + + /* Define if your assembler uses the new HImode fild and fist notation. */ #ifndef USED_FOR_TARGET #undef HAVE_GAS_FILDS_FISTS diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c index e2835acd3b7..cba9370f629 100644 --- a/gcc/config/alpha/alpha.c +++ b/gcc/config/alpha/alpha.c @@ -1506,43 +1506,43 @@ get_unaligned_offset (rtx addr, HOST_WIDE_INT ofs) /* On the Alpha, all (non-symbolic) constants except zero go into a floating-point register via memory. Note that we cannot - return anything that is not a subset of CLASS, and that some + return anything that is not a subset of RCLASS, and that some symbolic constants cannot be dropped to memory. */ enum reg_class -alpha_preferred_reload_class(rtx x, enum reg_class class) +alpha_preferred_reload_class(rtx x, enum reg_class rclass) { /* Zero is present in any register class. */ if (x == CONST0_RTX (GET_MODE (x))) - return class; + return rclass; /* These sorts of constants we can easily drop to memory. */ if (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE || GET_CODE (x) == CONST_VECTOR) { - if (class == FLOAT_REGS) + if (rclass == FLOAT_REGS) return NO_REGS; - if (class == ALL_REGS) + if (rclass == ALL_REGS) return GENERAL_REGS; - return class; + return rclass; } /* All other kinds of constants should not (and in the case of HIGH cannot) be dropped to memory -- instead we use a GENERAL_REGS secondary reload. */ if (CONSTANT_P (x)) - return (class == ALL_REGS ? GENERAL_REGS : class); + return (rclass == ALL_REGS ? GENERAL_REGS : rclass); - return class; + return rclass; } /* Inform reload about cases where moving X with a mode MODE to a register in - CLASS requires an extra scratch or immediate register. Return the class + RCLASS requires an extra scratch or immediate register. Return the class needed for the immediate register. */ static enum reg_class -alpha_secondary_reload (bool in_p, rtx x, enum reg_class class, +alpha_secondary_reload (bool in_p, rtx x, enum reg_class rclass, enum machine_mode mode, secondary_reload_info *sri) { /* Loading and storing HImode or QImode values to and from memory @@ -1564,7 +1564,7 @@ alpha_secondary_reload (bool in_p, rtx x, enum reg_class class, /* We also cannot do integral arithmetic into FP regs, as might result from register elimination into a DImode fp register. */ - if (class == FLOAT_REGS) + if (rclass == FLOAT_REGS) { if (MEM_P (x) && GET_CODE (XEXP (x, 0)) == AND) return GENERAL_REGS; @@ -1644,7 +1644,7 @@ static rtx alpha_emit_set_const_1 (rtx target, enum machine_mode mode, HOST_WIDE_INT c, int n, bool no_output) { - HOST_WIDE_INT new; + HOST_WIDE_INT new_const; int i, bits; /* Use a pseudo if highly optimizing and still generating RTL. */ rtx subtarget @@ -1743,15 +1743,15 @@ alpha_emit_set_const_1 (rtx target, enum machine_mode mode, /* First, see if minus some low bits, we've an easy load of high bits. */ - new = ((c & 0xffff) ^ 0x8000) - 0x8000; - if (new != 0) + new_const = ((c & 0xffff) ^ 0x8000) - 0x8000; + if (new_const != 0) { - temp = alpha_emit_set_const (subtarget, mode, c - new, i, no_output); + temp = alpha_emit_set_const (subtarget, mode, c - new_const, i, no_output); if (temp) { if (no_output) return temp; - return expand_binop (mode, add_optab, temp, GEN_INT (new), + return expand_binop (mode, add_optab, temp, GEN_INT (new_const), target, 0, OPTAB_WIDEN); } } @@ -1778,12 +1778,12 @@ alpha_emit_set_const_1 (rtx target, enum machine_mode mode, if (bits > 0) for (; bits > 0; bits--) { - new = c >> bits; - temp = alpha_emit_set_const (subtarget, mode, new, i, no_output); + new_const = c >> bits; + temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output); if (!temp && c < 0) { - new = (unsigned HOST_WIDE_INT)c >> bits; - temp = alpha_emit_set_const (subtarget, mode, new, + new_const = (unsigned HOST_WIDE_INT)c >> bits; + temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output); } if (temp) @@ -1806,12 +1806,12 @@ alpha_emit_set_const_1 (rtx target, enum machine_mode mode, if (bits > 0) for (; bits > 0; bits--) { - new = c << bits; - temp = alpha_emit_set_const (subtarget, mode, new, i, no_output); + new_const = c << bits; + temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output); if (!temp) { - new = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1); - temp = alpha_emit_set_const (subtarget, mode, new, + new_const = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1); + temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output); } if (temp) @@ -1832,12 +1832,12 @@ alpha_emit_set_const_1 (rtx target, enum machine_mode mode, if (bits > 0) for (; bits > 0; bits--) { - new = c << bits; - temp = alpha_emit_set_const (subtarget, mode, new, i, no_output); + new_const = c << bits; + temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output); if (!temp) { - new = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1); - temp = alpha_emit_set_const (subtarget, mode, new, + new_const = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1); + temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output); } if (temp) @@ -1855,25 +1855,25 @@ alpha_emit_set_const_1 (rtx target, enum machine_mode mode, constant except that all bytes that are 0 are changed to be 0xff. If we can, then we can do a ZAPNOT to obtain the desired constant. */ - new = c; + new_const = c; for (i = 0; i < 64; i += 8) - if ((new & ((HOST_WIDE_INT) 0xff << i)) == 0) - new |= (HOST_WIDE_INT) 0xff << i; + if ((new_const & ((HOST_WIDE_INT) 0xff << i)) == 0) + new_const |= (HOST_WIDE_INT) 0xff << i; /* We are only called for SImode and DImode. If this is SImode, ensure that we are sign extended to a full word. */ if (mode == SImode) - new = ((new & 0xffffffff) ^ 0x80000000) - 0x80000000; + new_const = ((new_const & 0xffffffff) ^ 0x80000000) - 0x80000000; - if (new != c) + if (new_const != c) { - temp = alpha_emit_set_const (subtarget, mode, new, n - 1, no_output); + temp = alpha_emit_set_const (subtarget, mode, new_const, n - 1, no_output); if (temp) { if (no_output) return temp; - return expand_binop (mode, and_optab, temp, GEN_INT (c | ~ new), + return expand_binop (mode, and_optab, temp, GEN_INT (c | ~ new_const), target, 0, OPTAB_WIDEN); } } @@ -5708,15 +5708,15 @@ function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED, enum machine_mode mode) { unsigned int regnum, dummy; - enum mode_class class; + enum mode_class mclass; gcc_assert (!valtype || !alpha_return_in_memory (valtype, func)); if (valtype) mode = TYPE_MODE (valtype); - class = GET_MODE_CLASS (mode); - switch (class) + mclass = GET_MODE_CLASS (mode); + switch (mclass) { case MODE_INT: PROMOTE_MODE (mode, dummy, valtype); @@ -8261,7 +8261,7 @@ alpha_output_mi_thunk_osf (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, tree function) { HOST_WIDE_INT hi, lo; - rtx this, insn, funexp; + rtx this_rtx, insn, funexp; /* We always require a valid GP. */ emit_insn (gen_prologue_ldgp ()); @@ -8270,9 +8270,9 @@ alpha_output_mi_thunk_osf (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* Find the "this" pointer. If the function returns a structure, the structure return pointer is in $16. */ if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function)) - this = gen_rtx_REG (Pmode, 17); + this_rtx = gen_rtx_REG (Pmode, 17); else - this = gen_rtx_REG (Pmode, 16); + this_rtx = gen_rtx_REG (Pmode, 16); /* Add DELTA. When possible we use ldah+lda. Otherwise load the entire constant for the add. */ @@ -8281,15 +8281,15 @@ alpha_output_mi_thunk_osf (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, if (hi + lo == delta) { if (hi) - emit_insn (gen_adddi3 (this, this, GEN_INT (hi))); + emit_insn (gen_adddi3 (this_rtx, this_rtx, GEN_INT (hi))); if (lo) - emit_insn (gen_adddi3 (this, this, GEN_INT (lo))); + emit_insn (gen_adddi3 (this_rtx, this_rtx, GEN_INT (lo))); } else { rtx tmp = alpha_emit_set_long_const (gen_rtx_REG (Pmode, 0), delta, -(delta < 0)); - emit_insn (gen_adddi3 (this, this, tmp)); + emit_insn (gen_adddi3 (this_rtx, this_rtx, tmp)); } /* Add a delta stored in the vtable at VCALL_OFFSET. */ @@ -8298,7 +8298,7 @@ alpha_output_mi_thunk_osf (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, rtx tmp, tmp2; tmp = gen_rtx_REG (Pmode, 0); - emit_move_insn (tmp, gen_rtx_MEM (Pmode, this)); + emit_move_insn (tmp, gen_rtx_MEM (Pmode, this_rtx)); lo = ((vcall_offset & 0xffff) ^ 0x8000) - 0x8000; hi = (((vcall_offset - lo) & 0xffffffff) ^ 0x80000000) - 0x80000000; @@ -8320,7 +8320,7 @@ alpha_output_mi_thunk_osf (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, tmp2 = tmp; emit_move_insn (tmp, gen_rtx_MEM (Pmode, tmp2)); - emit_insn (gen_adddi3 (this, this, tmp)); + emit_insn (gen_adddi3 (this_rtx, this_rtx, tmp)); } /* Generate a tail call to the target function. */ diff --git a/gcc/config/alpha/alpha.h b/gcc/config/alpha/alpha.h index 5f2431e2978..b37a19d1e44 100644 --- a/gcc/config/alpha/alpha.h +++ b/gcc/config/alpha/alpha.h @@ -245,10 +245,6 @@ extern enum alpha_fp_trap_mode alpha_fptm; /* Define the size of `long long'. The default is the twice the word size. */ #define LONG_LONG_TYPE_SIZE 64 -/* We're IEEE unless someone says to use VAX. */ -#define TARGET_FLOAT_FORMAT \ - (TARGET_FLOAT_VAX ? VAX_FLOAT_FORMAT : IEEE_FLOAT_FORMAT) - /* The two floating-point formats we support are S-floating, which is 4 bytes, and T-floating, which is 8 bytes. `float' is S and `double' and `long double' are T. */ diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c index f449d087e2b..a3a49f7242b 100644 --- a/gcc/config/arm/arm.c +++ b/gcc/config/arm/arm.c @@ -10283,7 +10283,7 @@ output_move_vfp (rtx *operands) int load = REG_P (operands[0]); int dp = GET_MODE_SIZE (GET_MODE (operands[0])) == 8; int integer_p = GET_MODE_CLASS (GET_MODE (operands[0])) == MODE_INT; - const char *template; + const char *templ; char buff[50]; enum machine_mode mode; @@ -10306,25 +10306,25 @@ output_move_vfp (rtx *operands) switch (GET_CODE (addr)) { case PRE_DEC: - template = "f%smdb%c%%?\t%%0!, {%%%s1}%s"; + templ = "f%smdb%c%%?\t%%0!, {%%%s1}%s"; ops[0] = XEXP (addr, 0); ops[1] = reg; break; case POST_INC: - template = "f%smia%c%%?\t%%0!, {%%%s1}%s"; + templ = "f%smia%c%%?\t%%0!, {%%%s1}%s"; ops[0] = XEXP (addr, 0); ops[1] = reg; break; default: - template = "f%s%c%%?\t%%%s0, %%1%s"; + templ = "f%s%c%%?\t%%%s0, %%1%s"; ops[0] = reg; ops[1] = mem; break; } - sprintf (buff, template, + sprintf (buff, templ, load ? "ld" : "st", dp ? 'd' : 's', dp ? "P" : "", @@ -10335,37 +10335,35 @@ output_move_vfp (rtx *operands) } /* Output a Neon quad-word load or store, or a load or store for - larger structure modes. We could also support post-modify forms using - VLD1/VST1 (for the vectorizer, and perhaps otherwise), but we don't do that - yet. - WARNING: The ordering of elements in memory is weird in big-endian mode, - because we use VSTM instead of VST1, to make it easy to make vector stores - via ARM registers write values in the same order as stores direct from Neon - registers. For example, the byte ordering of a quadword vector with 16-byte - elements like this: + larger structure modes. - [e7:e6:e5:e4:e3:e2:e1:e0] (highest-numbered element first) + WARNING: The ordering of elements is weird in big-endian mode, + because we use VSTM, as required by the EABI. GCC RTL defines + element ordering based on in-memory order. This can be differ + from the architectural ordering of elements within a NEON register. + The intrinsics defined in arm_neon.h use the NEON register element + ordering, not the GCC RTL element ordering. - will be (with lowest address first, h = most-significant byte, - l = least-significant byte of element): + For example, the in-memory ordering of a big-endian a quadword + vector with 16-bit elements when stored from register pair {d0,d1} + will be (lowest address first, d0[N] is NEON register element N): - [e3h, e3l, e2h, e2l, e1h, e1l, e0h, e0l, - e7h, e7l, e6h, e6l, e5h, e5l, e4h, e4l] + [d0[3], d0[2], d0[1], d0[0], d1[7], d1[6], d1[5], d1[4]] - When necessary, quadword registers (dN, dN+1) are moved to ARM registers from - rN in the order: + When necessary, quadword registers (dN, dN+1) are moved to ARM + registers from rN in the order: dN -> (rN+1, rN), dN+1 -> (rN+3, rN+2) - So that STM/LDM can be used on vectors in ARM registers, and the same memory - layout will result as if VSTM/VLDM were used. */ + So that STM/LDM can be used on vectors in ARM registers, and the + same memory layout will result as if VSTM/VLDM were used. */ const char * output_move_neon (rtx *operands) { rtx reg, mem, addr, ops[2]; int regno, load = REG_P (operands[0]); - const char *template; + const char *templ; char buff[50]; enum machine_mode mode; @@ -10392,7 +10390,7 @@ output_move_neon (rtx *operands) switch (GET_CODE (addr)) { case POST_INC: - template = "v%smia%%?\t%%0!, %%h1"; + templ = "v%smia%%?\t%%0!, %%h1"; ops[0] = XEXP (addr, 0); ops[1] = reg; break; @@ -10435,12 +10433,12 @@ output_move_neon (rtx *operands) } default: - template = "v%smia%%?\t%%m0, %%h1"; + templ = "v%smia%%?\t%%m0, %%h1"; ops[0] = mem; ops[1] = reg; } - sprintf (buff, template, load ? "ld" : "st"); + sprintf (buff, templ, load ? "ld" : "st"); output_asm_insn (buff, ops); return ""; @@ -13326,28 +13324,16 @@ arm_assemble_integer (rtx x, unsigned int size, int aligned_p) if (arm_vector_mode_supported_p (mode)) { int i, units; - unsigned int invmask = 0, parts_per_word; gcc_assert (GET_CODE (x) == CONST_VECTOR); units = CONST_VECTOR_NUNITS (x); size = GET_MODE_SIZE (GET_MODE_INNER (mode)); - /* For big-endian Neon vectors, we must permute the vector to the form - which, when loaded by a VLDR or VLDM instruction, will give a vector - with the elements in the right order. */ - if (TARGET_NEON && WORDS_BIG_ENDIAN) - { - parts_per_word = UNITS_PER_WORD / size; - /* FIXME: This might be wrong for 64-bit vector elements, but we don't - support those anywhere yet. */ - invmask = (parts_per_word == 0) ? 0 : (1 << (parts_per_word - 1)) - 1; - } - if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT) for (i = 0; i < units; i++) { - rtx elt = CONST_VECTOR_ELT (x, i ^ invmask); + rtx elt = CONST_VECTOR_ELT (x, i); assemble_integer (elt, size, i == 0 ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT, 1); } diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md index 9cd6e7262a2..5b514451c5d 100644 --- a/gcc/config/arm/arm.md +++ b/gcc/config/arm/arm.md @@ -5286,12 +5286,12 @@ && GET_CODE (base = XEXP (base, 0)) == REG)) && REGNO_POINTER_ALIGN (REGNO (base)) >= 32) { - rtx new; + rtx new_rtx; - new = widen_memory_access (operands[1], SImode, - ((INTVAL (offset) & ~3) - - INTVAL (offset))); - emit_insn (gen_movsi (reg, new)); + new_rtx = widen_memory_access (operands[1], SImode, + ((INTVAL (offset) & ~3) + - INTVAL (offset))); + emit_insn (gen_movsi (reg, new_rtx)); if (((INTVAL (offset) & 2) != 0) ^ (BYTES_BIG_ENDIAN ? 1 : 0)) { diff --git a/gcc/config/arm/iwmmxt.md b/gcc/config/arm/iwmmxt.md index b484b55e6cd..668172f8407 100644 --- a/gcc/config/arm/iwmmxt.md +++ b/gcc/config/arm/iwmmxt.md @@ -167,9 +167,9 @@ (set_attr "neg_pool_range" "*,*,4084, *,*,*")] ) -(define_insn "movv8qi_internal" - [(set (match_operand:V8QI 0 "nonimmediate_operand" "=y,m,y,?r,?y,?r,?r,?m") - (match_operand:V8QI 1 "general_operand" "y,y,mi,y,r,r,mi,r"))] +(define_insn "mov<mode>_internal" + [(set (match_operand:VMMX 0 "nonimmediate_operand" "=y,m,y,?r,?y,?r,?r,?m") + (match_operand:VMMX 1 "general_operand" "y,y,mi,y,r,r,mi,r"))] "TARGET_REALLY_IWMMXT" "* switch (which_alternative) @@ -188,64 +188,6 @@ (set_attr "pool_range" "*, *, 256,*,*,*, 256,*") (set_attr "neg_pool_range" "*, *, 244,*,*,*, 244,*")]) -(define_insn "movv4hi_internal" - [(set (match_operand:V4HI 0 "nonimmediate_operand" "=y,m,y,?r,?y,?r,?r,?m") - (match_operand:V4HI 1 "general_operand" "y,y,mi,y,r,r,mi,r"))] - "TARGET_REALLY_IWMMXT" - "* - switch (which_alternative) - { - case 0: return \"wmov%?\\t%0, %1\"; - case 1: return \"wstrd%?\\t%1, %0\"; - case 2: return \"wldrd%?\\t%0, %1\"; - case 3: return \"tmrrc%?\\t%Q0, %R0, %1\"; - case 4: return \"tmcrr%?\\t%0, %Q1, %R1\"; - case 5: return \"#\"; - default: return output_move_double (operands); - }" - [(set_attr "predicable" "yes") - (set_attr "length" "4, 4, 4,4,4,8, 8,8") - (set_attr "type" "*,store1,load1,*,*,*,load1,store1") - (set_attr "pool_range" "*, *, 256,*,*,*, 256,*") - (set_attr "neg_pool_range" "*, *, 244,*,*,*, 244,*")]) - -(define_insn "movv2si_internal" - [(set (match_operand:V2SI 0 "nonimmediate_operand" "=y,m,y,?r,?y,?r,?r,?m") - (match_operand:V2SI 1 "general_operand" "y,y,mi,y,r,r,mi,r"))] - "TARGET_REALLY_IWMMXT" - "* - switch (which_alternative) - { - case 0: return \"wmov%?\\t%0, %1\"; - case 1: return \"wstrd%?\\t%1, %0\"; - case 2: return \"wldrd%?\\t%0, %1\"; - case 3: return \"tmrrc%?\\t%Q0, %R0, %1\"; - case 4: return \"tmcrr%?\\t%0, %Q1, %R1\"; - case 5: return \"#\"; - default: return output_move_double (operands); - }" - [(set_attr "predicable" "yes") - (set_attr "length" "4, 4, 4,4,4,8, 24,8") - (set_attr "type" "*,store1,load1,*,*,*,load1,store1") - (set_attr "pool_range" "*, *, 256,*,*,*, 256,*") - (set_attr "neg_pool_range" "*, *, 244,*,*,*, 244,*")]) - -;; This pattern should not be needed. It is to match a -;; wierd case generated by GCC when no optimizations are -;; enabled. (Try compiling gcc/testsuite/gcc.c-torture/ -;; compile/simd-5.c at -O0). The mode for operands[1] is -;; deliberately omitted. -(define_insn "movv2si_internal_2" - [(set (match_operand:V2SI 0 "nonimmediate_operand" "=?r") - (match_operand 1 "immediate_operand" "mi"))] - "TARGET_REALLY_IWMMXT" - "* return output_move_double (operands);" - [(set_attr "predicable" "yes") - (set_attr "length" "8") - (set_attr "type" "load1") - (set_attr "pool_range" "256") - (set_attr "neg_pool_range" "244")]) - ;; Vector add/subtract (define_insn "*add<mode>3_iwmmxt" diff --git a/gcc/config/arm/neon.md b/gcc/config/arm/neon.md index 0c312e7c336..8d10c1e5b42 100644 --- a/gcc/config/arm/neon.md +++ b/gcc/config/arm/neon.md @@ -735,7 +735,10 @@ (match_operand:SI 2 "immediate_operand" "i")))] "TARGET_NEON" { - operands[2] = GEN_INT (ffs ((int) INTVAL (operands[2]) - 1)); + int elt = ffs ((int) INTVAL (operands[2]) - 1); + if (BYTES_BIG_ENDIAN) + elt = GET_MODE_NUNITS (<MODE>mode) - 1 - elt; + operands[2] = GEN_INT (elt); return "vmov%?.<V_uf_sclr>\t%P0[%c2], %1"; } @@ -757,6 +760,9 @@ int hi = (elem / half_elts) * 2; int regno = REGNO (operands[0]); + if (BYTES_BIG_ENDIAN) + elt = half_elts - 1 - elt; + operands[0] = gen_rtx_REG (<V_HALF>mode, regno + hi); operands[2] = GEN_INT (elt); @@ -804,7 +810,15 @@ (match_operand:VD 1 "s_register_operand" "w") (parallel [(match_operand:SI 2 "immediate_operand" "i")])))] "TARGET_NEON" - "vmov%?.<V_uf_sclr>\t%0, %P1[%c2]" +{ + if (BYTES_BIG_ENDIAN) + { + int elt = INTVAL (operands[2]); + elt = GET_MODE_NUNITS (<MODE>mode) - 1 - elt; + operands[2] = GEN_INT (elt); + } + return "vmov%?.<V_uf_sclr>\t%0, %P1[%c2]"; +} [(set_attr "predicable" "yes") (set_attr "neon_type" "neon_bp_simple")] ) @@ -821,6 +835,9 @@ int hi = (INTVAL (operands[2]) / half_elts) * 2; int regno = REGNO (operands[1]); + if (BYTES_BIG_ENDIAN) + elt = half_elts - 1 - elt; + operands[1] = gen_rtx_REG (<V_HALF>mode, regno + hi); operands[2] = GEN_INT (elt); @@ -2413,7 +2430,15 @@ (match_operand:VD 1 "s_register_operand" "w") (parallel [(match_operand:SI 2 "immediate_operand" "i")]))))] "TARGET_NEON" - "vmov%?.s<V_sz_elem>\t%0, %P1[%c2]" +{ + if (BYTES_BIG_ENDIAN) + { + int elt = INTVAL (operands[2]); + elt = GET_MODE_NUNITS (<MODE>mode) - 1 - elt; + operands[2] = GEN_INT (elt); + } + return "vmov%?.s<V_sz_elem>\t%0, %P1[%c2]"; +} [(set_attr "predicable" "yes") (set_attr "neon_type" "neon_bp_simple")] ) @@ -2425,7 +2450,15 @@ (match_operand:VD 1 "s_register_operand" "w") (parallel [(match_operand:SI 2 "immediate_operand" "i")]))))] "TARGET_NEON" - "vmov%?.u<V_sz_elem>\t%0, %P1[%c2]" +{ + if (BYTES_BIG_ENDIAN) + { + int elt = INTVAL (operands[2]); + elt = GET_MODE_NUNITS (<MODE>mode) - 1 - elt; + operands[2] = GEN_INT (elt); + } + return "vmov%?.u<V_sz_elem>\t%0, %P1[%c2]"; +} [(set_attr "predicable" "yes") (set_attr "neon_type" "neon_bp_simple")] ) @@ -2442,10 +2475,14 @@ int regno = REGNO (operands[1]); unsigned int halfelts = GET_MODE_NUNITS (<MODE>mode) / 2; unsigned int elt = INTVAL (operands[2]); + unsigned int elt_adj = elt % halfelts; + + if (BYTES_BIG_ENDIAN) + elt_adj = halfelts - 1 - elt_adj; ops[0] = operands[0]; ops[1] = gen_rtx_REG (<V_HALF>mode, regno + 2 * (elt / halfelts)); - ops[2] = GEN_INT (elt % halfelts); + ops[2] = GEN_INT (elt_adj); output_asm_insn ("vmov%?.s<V_sz_elem>\t%0, %P1[%c2]", ops); return ""; @@ -2466,10 +2503,14 @@ int regno = REGNO (operands[1]); unsigned int halfelts = GET_MODE_NUNITS (<MODE>mode) / 2; unsigned int elt = INTVAL (operands[2]); + unsigned int elt_adj = elt % halfelts; + + if (BYTES_BIG_ENDIAN) + elt_adj = halfelts - 1 - elt_adj; ops[0] = operands[0]; ops[1] = gen_rtx_REG (<V_HALF>mode, regno + 2 * (elt / halfelts)); - ops[2] = GEN_INT (elt % halfelts); + ops[2] = GEN_INT (elt_adj); output_asm_insn ("vmov%?.u<V_sz_elem>\t%0, %P1[%c2]", ops); return ""; @@ -2490,6 +2531,20 @@ neon_lane_bounds (operands[2], 0, GET_MODE_NUNITS (<MODE>mode)); + if (BYTES_BIG_ENDIAN) + { + /* The intrinsics are defined in terms of a model where the + element ordering in memory is vldm order, whereas the generic + RTL is defined in terms of a model where the element ordering + in memory is array order. Convert the lane number to conform + to this model. */ + unsigned int elt = INTVAL (operands[2]); + unsigned int reg_nelts + = 64 / GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode)); + elt ^= reg_nelts - 1; + operands[2] = GEN_INT (elt); + } + if ((magic & 3) == 3 || GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode)) == 32) insn = gen_vec_extract<mode> (operands[0], operands[1], operands[2]); else diff --git a/gcc/config/avr/avr-protos.h b/gcc/config/avr/avr-protos.h index 7665555fd84..bcf81d9afc5 100644 --- a/gcc/config/avr/avr-protos.h +++ b/gcc/config/avr/avr-protos.h @@ -94,7 +94,7 @@ extern void avr_output_bld (rtx operands[], int bit_nr); extern void avr_output_addr_vec_elt (FILE *stream, int value); extern const char *avr_out_sbxx_branch (rtx insn, rtx operands[]); -extern enum reg_class preferred_reload_class (rtx x, enum reg_class class); +extern enum reg_class preferred_reload_class (rtx x, enum reg_class rclass); extern int extra_constraint_Q (rtx x); extern rtx legitimize_address (rtx x, rtx oldx, enum machine_mode mode); extern int adjust_insn_length (rtx insn, int len); @@ -111,21 +111,21 @@ extern int reg_unused_after (rtx insn, rtx reg); extern int _reg_unused_after (rtx insn, rtx reg); extern int avr_jump_mode (rtx x, rtx insn); extern int byte_immediate_operand (rtx op, enum machine_mode mode); -extern int test_hard_reg_class (enum reg_class class, rtx x); +extern int test_hard_reg_class (enum reg_class rclass, rtx x); extern int jump_over_one_insn_p (rtx insn, rtx dest); extern int avr_hard_regno_mode_ok (int regno, enum machine_mode mode); extern void final_prescan_insn (rtx insn, rtx *operand, int num_operands); extern int avr_simplify_comparison_p (enum machine_mode mode, - RTX_CODE operator, rtx x); + RTX_CODE op, rtx x); extern RTX_CODE avr_normalize_condition (RTX_CODE condition); extern int compare_eq_p (rtx insn); -extern void out_shift_with_cnt (const char *template, rtx insn, +extern void out_shift_with_cnt (const char *templ, rtx insn, rtx operands[], int *len, int t_len); #endif /* RTX_CODE */ #ifdef HAVE_MACHINE_MODES -extern int class_max_nregs (enum reg_class class, enum machine_mode mode); +extern int class_max_nregs (enum reg_class rclass, enum machine_mode mode); #endif /* HAVE_MACHINE_MODES */ #ifdef REAL_VALUE_TYPE diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c index 84625d81f8a..5fbf57189ec 100644 --- a/gcc/config/avr/avr.c +++ b/gcc/config/avr/avr.c @@ -192,12 +192,12 @@ static const struct mcu_type_s avr_mcu_types[] = { { "at86rf401", ARCH_AVR25, "__AVR_AT86RF401__" }, /* Classic, > 8K, <= 64K. */ { "avr3", ARCH_AVR3, NULL }, - { "at43usb320", ARCH_AVR3, "__AVR_AT43USB320__" }, { "at43usb355", ARCH_AVR3, "__AVR_AT43USB355__" }, { "at76c711", ARCH_AVR3, "__AVR_AT76C711__" }, /* Classic, == 128K. */ { "avr31", ARCH_AVR31, NULL }, { "atmega103", ARCH_AVR31, "__AVR_ATmega103__" }, + { "at43usb320", ARCH_AVR31, "__AVR_AT43USB320__" }, /* Classic + MOVW + JMP/CALL. */ { "avr35", ARCH_AVR35, NULL }, { "at90usb82", ARCH_AVR35, "__AVR_AT90USB82__" }, @@ -1403,7 +1403,7 @@ notice_update_cc (rtx body ATTRIBUTE_UNUSED, rtx insn) class CLASS needed to hold a value of mode MODE. */ int -class_max_nregs (enum reg_class class ATTRIBUTE_UNUSED,enum machine_mode mode) +class_max_nregs (enum reg_class rclass ATTRIBUTE_UNUSED,enum machine_mode mode) { return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD); } @@ -1566,14 +1566,14 @@ final_prescan_insn (rtx insn, rtx *operand ATTRIBUTE_UNUSED, /* Return 0 if undefined, 1 if always true or always false. */ int -avr_simplify_comparison_p (enum machine_mode mode, RTX_CODE operator, rtx x) +avr_simplify_comparison_p (enum machine_mode mode, RTX_CODE op, rtx x) { unsigned int max = (mode == QImode ? 0xff : mode == HImode ? 0xffff : mode == SImode ? 0xffffffff : 0); - if (max && operator && GET_CODE (x) == CONST_INT) + if (max && op && GET_CODE (x) == CONST_INT) { - if (unsigned_condition (operator) != operator) + if (unsigned_condition (op) != op) max >>= 1; if (max != (INTVAL (x) & max) @@ -1743,15 +1743,15 @@ output_movqi (rtx insn, rtx operands[], int *l) } else if (GET_CODE (dest) == MEM) { - const char *template; + const char *templ; if (src == const0_rtx) operands[1] = zero_reg_rtx; - template = out_movqi_mr_r (insn, operands, real_l); + templ = out_movqi_mr_r (insn, operands, real_l); if (!real_l) - output_asm_insn (template, operands); + output_asm_insn (templ, operands); operands[1] = src; } @@ -1893,15 +1893,15 @@ output_movhi (rtx insn, rtx operands[], int *l) } else if (GET_CODE (dest) == MEM) { - const char *template; + const char *templ; if (src == const0_rtx) operands[1] = zero_reg_rtx; - template = out_movhi_mr_r (insn, operands, real_l); + templ = out_movhi_mr_r (insn, operands, real_l); if (!real_l) - output_asm_insn (template, operands); + output_asm_insn (templ, operands); operands[1] = src; return ""; @@ -2581,15 +2581,15 @@ output_movsisf(rtx insn, rtx operands[], int *l) } else if (GET_CODE (dest) == MEM) { - const char *template; + const char *templ; if (src == const0_rtx) operands[1] = zero_reg_rtx; - template = out_movsi_mr_r (insn, operands, real_l); + templ = out_movsi_mr_r (insn, operands, real_l); if (!real_l) - output_asm_insn (template, operands); + output_asm_insn (templ, operands); operands[1] = src; return ""; @@ -2930,7 +2930,7 @@ out_tstsi (rtx insn, int *l) carefully hand-optimized in ?sh??i3_out. */ void -out_shift_with_cnt (const char *template, rtx insn, rtx operands[], +out_shift_with_cnt (const char *templ, rtx insn, rtx operands[], int *len, int t_len) { rtx op[10]; @@ -2975,7 +2975,7 @@ out_shift_with_cnt (const char *template, rtx insn, rtx operands[], else { while (count-- > 0) - output_asm_insn (template, op); + output_asm_insn (templ, op); } return; @@ -3056,7 +3056,7 @@ out_shift_with_cnt (const char *template, rtx insn, rtx operands[], else { strcat (str, "\n1:\t"); - strcat (str, template); + strcat (str, templ); strcat (str, second_label ? "\n2:\t" : "\n\t"); strcat (str, use_zero_reg ? AS1 (lsr,%3) : AS1 (dec,%3)); strcat (str, CR_TAB); @@ -5735,19 +5735,19 @@ avr_function_value (const_tree type, in class CLASS. */ enum reg_class -preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) +preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class rclass) { - return class; + return rclass; } int -test_hard_reg_class (enum reg_class class, rtx x) +test_hard_reg_class (enum reg_class rclass, rtx x) { int regno = true_regnum (x); if (regno < 0) return 0; - if (TEST_HARD_REG_CLASS (class, regno)) + if (TEST_HARD_REG_CLASS (rclass, regno)) return 1; return 0; diff --git a/gcc/config/avr/avr.h b/gcc/config/avr/avr.h index 2b72112822c..6a27c3b7edb 100644 --- a/gcc/config/avr/avr.h +++ b/gcc/config/avr/avr.h @@ -931,10 +931,10 @@ mmcu=*:-mmcu=%*}" %{mmcu=attiny48:crttn48.o%s} \ %{mmcu=attiny88:crttn88.o%s} \ %{mmcu=attiny167:crttn167.o%s} \ -%{mmcu=at43usb320|mmcu=avr3:crt43320.o%s} \ -%{mmcu=at43usb355:crt43355.o%s} \ +%{mmcu=at43usb355|mmcu=avr3:crt43355.o%s} \ %{mmcu=at76c711:crt76711.o%s} \ %{mmcu=atmega103|mmcu=avr31:crtm103.o%s} \ +%{mmcu=at43usb320:crt43320.o%s} \ %{mmcu=at90usb162|mmcu=avr35:crtusb162.o%s} \ %{mmcu=at90usb82:crtusb82.o%s} \ %{mmcu=atmega8|mmcu=avr4:crtm8.o%s} \ diff --git a/gcc/config/avr/t-avr b/gcc/config/avr/t-avr index e64152bda19..082da67756d 100644 --- a/gcc/config/avr/t-avr +++ b/gcc/config/avr/t-avr @@ -58,10 +58,10 @@ MULTILIB_MATCHES = \ mmcu?avr25=mmcu?attiny48 \ mmcu?avr25=mmcu?attiny88 \ mmcu?avr25=mmcu?at86rf401 \ - mmcu?avr3=mmcu?at43usb320 \ mmcu?avr3=mmcu?at43usb355 \ mmcu?avr3=mmcu?at76c711 \ mmcu?avr31=mmcu?atmega103 \ + mmcu?avr31=mmcu?at43usb320 \ mmcu?avr35=mmcu?at90usb82 \ mmcu?avr35=mmcu?at90usb162 \ mmcu?avr35=mmcu?attiny167 \ diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c index 843726067b6..8fda5c01d8e 100644 --- a/gcc/config/bfin/bfin.c +++ b/gcc/config/bfin/bfin.c @@ -279,7 +279,7 @@ static rtx legitimize_pic_address (rtx orig, rtx reg, rtx picreg) { rtx addr = orig; - rtx new = orig; + rtx new_rtx = orig; if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF) { @@ -301,9 +301,9 @@ legitimize_pic_address (rtx orig, rtx reg, rtx picreg) } tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), unspec); - new = gen_const_mem (Pmode, gen_rtx_PLUS (Pmode, picreg, tmp)); + new_rtx = gen_const_mem (Pmode, gen_rtx_PLUS (Pmode, picreg, tmp)); - emit_move_insn (reg, new); + emit_move_insn (reg, new_rtx); if (picreg == pic_offset_table_rtx) crtl->uses_pic_offset_table = 1; return reg; @@ -348,7 +348,7 @@ legitimize_pic_address (rtx orig, rtx reg, rtx picreg) return gen_rtx_PLUS (Pmode, base, addr); } - return new; + return new_rtx; } /* Stack frame layout. */ @@ -2156,14 +2156,14 @@ int hard_regno_mode_ok (int regno, enum machine_mode mode) { /* Allow only dregs to store value of mode HI or QI */ - enum reg_class class = REGNO_REG_CLASS (regno); + enum reg_class rclass = REGNO_REG_CLASS (regno); if (mode == CCmode) return 0; if (mode == V2HImode) return D_REGNO_P (regno); - if (class == CCREGS) + if (rclass == CCREGS) return mode == BImode; if (mode == PDImode || mode == V2PDImode) return regno == REG_A0 || regno == REG_A1; @@ -2232,24 +2232,24 @@ bfin_register_move_cost (enum machine_mode mode, int bfin_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED, - enum reg_class class, + enum reg_class rclass, int in ATTRIBUTE_UNUSED) { /* Make memory accesses slightly more expensive than any register-register move. Also, penalize non-DP registers, since they need secondary reloads to load and store. */ - if (! reg_class_subset_p (class, DPREGS)) + if (! reg_class_subset_p (rclass, DPREGS)) return 10; return 8; } /* Inform reload about cases where moving X with a mode MODE to a register in - CLASS requires an extra scratch register. Return the class needed for the + RCLASS requires an extra scratch register. Return the class needed for the scratch register. */ static enum reg_class -bfin_secondary_reload (bool in_p, rtx x, enum reg_class class, +bfin_secondary_reload (bool in_p, rtx x, enum reg_class rclass, enum machine_mode mode, secondary_reload_info *sri) { /* If we have HImode or QImode, we can only use DREGS as secondary registers; @@ -2280,11 +2280,11 @@ bfin_secondary_reload (bool in_p, rtx x, enum reg_class class, rtx op2 = XEXP (x, 1); int large_constant_p = ! satisfies_constraint_Ks7 (op2); - if (class == PREGS || class == PREGS_CLOBBERED) + if (rclass == PREGS || rclass == PREGS_CLOBBERED) return NO_REGS; /* If destination is a DREG, we can do this without a scratch register if the constant is valid for an add instruction. */ - if ((class == DREGS || class == DPREGS) + if ((rclass == DREGS || rclass == DPREGS) && ! large_constant_p) return NO_REGS; /* Reloading to anything other than a DREG? Use a PREG scratch @@ -2297,11 +2297,11 @@ bfin_secondary_reload (bool in_p, rtx x, enum reg_class class, AREGS are an exception; they can only move to or from another register in AREGS or one in DREGS. They can also be assigned the constant 0. */ if (x_class == AREGS || x_class == EVEN_AREGS || x_class == ODD_AREGS) - return (class == DREGS || class == AREGS || class == EVEN_AREGS - || class == ODD_AREGS + return (rclass == DREGS || rclass == AREGS || rclass == EVEN_AREGS + || rclass == ODD_AREGS ? NO_REGS : DREGS); - if (class == AREGS || class == EVEN_AREGS || class == ODD_AREGS) + if (rclass == AREGS || rclass == EVEN_AREGS || rclass == ODD_AREGS) { if (code == MEM) { @@ -2318,15 +2318,15 @@ bfin_secondary_reload (bool in_p, rtx x, enum reg_class class, } /* CCREGS can only be moved from/to DREGS. */ - if (class == CCREGS && x_class != DREGS) + if (rclass == CCREGS && x_class != DREGS) return DREGS; - if (x_class == CCREGS && class != DREGS) + if (x_class == CCREGS && rclass != DREGS) return DREGS; /* All registers other than AREGS can load arbitrary constants. The only case that remains is MEM. */ if (code == MEM) - if (! reg_class_subset_p (class, default_class)) + if (! reg_class_subset_p (rclass, default_class)) return default_class; return NO_REGS; @@ -5127,12 +5127,12 @@ bfin_output_mi_thunk (FILE *file ATTRIBUTE_UNUSED, { rtx xops[3]; /* The this parameter is passed as the first argument. */ - rtx this = gen_rtx_REG (Pmode, REG_R0); + rtx this_rtx = gen_rtx_REG (Pmode, REG_R0); /* Adjust the this parameter by a fixed constant. */ if (delta) { - xops[1] = this; + xops[1] = this_rtx; if (delta >= -64 && delta <= 63) { xops[0] = GEN_INT (delta); @@ -5175,7 +5175,7 @@ bfin_output_mi_thunk (FILE *file ATTRIBUTE_UNUSED, output_asm_insn ("%h1 = %h0; %d1 = %d0; %2 = %2 + %1", xops); xops[0] = gen_rtx_MEM (Pmode, p2tmp); } - xops[2] = this; + xops[2] = this_rtx; output_asm_insn ("%1 = %0; %2 = %2 + %1;", xops); } diff --git a/gcc/config/crx/crx.c b/gcc/config/crx/crx.c index 9e8c3a97cf1..2f4aa6f176b 100644 --- a/gcc/config/crx/crx.c +++ b/gcc/config/crx/crx.c @@ -371,11 +371,11 @@ crx_regno_reg_class (int regno) /* Transfer between HILO_REGS and memory via secondary reloading. */ enum reg_class -crx_secondary_reload_class (enum reg_class class, +crx_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED) { - if (reg_classes_intersect_p (class, HILO_REGS) + if (reg_classes_intersect_p (rclass, HILO_REGS) && true_regnum (x) == -1) return GENERAL_REGS; @@ -839,22 +839,22 @@ crx_address_cost (rtx addr) } /* Return the cost of moving data of mode MODE between a register of class - * CLASS and memory; IN is zero if the value is to be written to memory, + * RCLASS and memory; IN is zero if the value is to be written to memory, * nonzero if it is to be read in. This cost is relative to those in * REGISTER_MOVE_COST. */ int crx_memory_move_cost (enum machine_mode mode, - enum reg_class class ATTRIBUTE_UNUSED, + enum reg_class rclass ATTRIBUTE_UNUSED, int in ATTRIBUTE_UNUSED) { /* One LD or ST takes twice the time of a simple reg-reg move */ - if (reg_classes_intersect_p (class, GENERAL_REGS)) + if (reg_classes_intersect_p (rclass, GENERAL_REGS)) { /* printf ("GENERAL_REGS LD/ST = %d\n", 4 * HARD_REGNO_NREGS (0, mode));*/ return 4 * HARD_REGNO_NREGS (0, mode); } - else if (reg_classes_intersect_p (class, HILO_REGS)) + else if (reg_classes_intersect_p (rclass, HILO_REGS)) { /* HILO to memory and vice versa */ /* printf ("HILO_REGS %s = %d\n", in ? "LD" : "ST", diff --git a/gcc/config/frv/frv-protos.h b/gcc/config/frv/frv-protos.h index dd41fc27767..8d6b29bc7cf 100644 --- a/gcc/config/frv/frv-protos.h +++ b/gcc/config/frv/frv-protos.h @@ -104,13 +104,13 @@ extern void frv_ifcvt_modify_cancel (ce_if_block_t *); extern int frv_trampoline_size (void); extern void frv_initialize_trampoline (rtx, rtx, rtx); extern enum reg_class frv_secondary_reload_class - (enum reg_class class, + (enum reg_class rclass, enum machine_mode mode, rtx x, int); -extern int frv_class_likely_spilled_p (enum reg_class class); +extern int frv_class_likely_spilled_p (enum reg_class rclass); extern int frv_hard_regno_mode_ok (int, enum machine_mode); extern int frv_hard_regno_nregs (int, enum machine_mode); -extern int frv_class_max_nregs (enum reg_class class, +extern int frv_class_max_nregs (enum reg_class rclass, enum machine_mode mode); extern int frv_legitimate_constant_p (rtx); extern enum machine_mode frv_select_cc_mode (enum rtx_code, rtx, rtx); diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c index 07e8eaae928..7fa2e22f094 100644 --- a/gcc/config/frv/frv.c +++ b/gcc/config/frv/frv.c @@ -651,83 +651,83 @@ frv_override_options (void) for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) { - enum reg_class class; + enum reg_class rclass; if (GPR_P (regno)) { int gpr_reg = regno - GPR_FIRST; if (gpr_reg == GR8_REG) - class = GR8_REGS; + rclass = GR8_REGS; else if (gpr_reg == GR9_REG) - class = GR9_REGS; + rclass = GR9_REGS; else if (gpr_reg == GR14_REG) - class = FDPIC_FPTR_REGS; + rclass = FDPIC_FPTR_REGS; else if (gpr_reg == FDPIC_REGNO) - class = FDPIC_REGS; + rclass = FDPIC_REGS; else if ((gpr_reg & 3) == 0) - class = QUAD_REGS; + rclass = QUAD_REGS; else if ((gpr_reg & 1) == 0) - class = EVEN_REGS; + rclass = EVEN_REGS; else - class = GPR_REGS; + rclass = GPR_REGS; } else if (FPR_P (regno)) { int fpr_reg = regno - GPR_FIRST; if ((fpr_reg & 3) == 0) - class = QUAD_FPR_REGS; + rclass = QUAD_FPR_REGS; else if ((fpr_reg & 1) == 0) - class = FEVEN_REGS; + rclass = FEVEN_REGS; else - class = FPR_REGS; + rclass = FPR_REGS; } else if (regno == LR_REGNO) - class = LR_REG; + rclass = LR_REG; else if (regno == LCR_REGNO) - class = LCR_REG; + rclass = LCR_REG; else if (ICC_P (regno)) - class = ICC_REGS; + rclass = ICC_REGS; else if (FCC_P (regno)) - class = FCC_REGS; + rclass = FCC_REGS; else if (ICR_P (regno)) - class = ICR_REGS; + rclass = ICR_REGS; else if (FCR_P (regno)) - class = FCR_REGS; + rclass = FCR_REGS; else if (ACC_P (regno)) { int r = regno - ACC_FIRST; if ((r & 3) == 0) - class = QUAD_ACC_REGS; + rclass = QUAD_ACC_REGS; else if ((r & 1) == 0) - class = EVEN_ACC_REGS; + rclass = EVEN_ACC_REGS; else - class = ACC_REGS; + rclass = ACC_REGS; } else if (ACCG_P (regno)) - class = ACCG_REGS; + rclass = ACCG_REGS; else - class = NO_REGS; + rclass = NO_REGS; - regno_reg_class[regno] = class; + regno_reg_class[regno] = rclass; } /* Check for small data option */ @@ -1539,14 +1539,14 @@ frv_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) static rtx frv_alloc_temp_reg ( frv_tmp_reg_t *info, /* which registers are available */ - enum reg_class class, /* register class desired */ + enum reg_class rclass, /* register class desired */ enum machine_mode mode, /* mode to allocate register with */ int mark_as_used, /* register not available after allocation */ int no_abort) /* return NULL instead of aborting */ { - int regno = info->next_reg[ (int)class ]; + int regno = info->next_reg[ (int)rclass ]; int orig_regno = regno; - HARD_REG_SET *reg_in_class = ®_class_contents[ (int)class ]; + HARD_REG_SET *reg_in_class = ®_class_contents[ (int)rclass ]; int i, nr; for (;;) @@ -1565,7 +1565,7 @@ frv_alloc_temp_reg ( } nr = HARD_REGNO_NREGS (regno, mode); - info->next_reg[ (int)class ] = regno + nr; + info->next_reg[ (int)rclass ] = regno + nr; if (mark_as_used) for (i = 0; i < nr; i++) @@ -2777,7 +2777,7 @@ frv_print_operand (FILE * file, rtx x, int code) HOST_WIDE_INT value; int offset; - if (code != 0 && !isalpha (code)) + if (code != 0 && !ISALPHA (code)) value = 0; else if (GET_CODE (x) == CONST_INT) @@ -6300,11 +6300,11 @@ frv_initialize_trampoline (rtx addr, rtx fnaddr, rtx static_chain) You should define these macros to indicate to the reload phase that it may need to allocate at least one register for a reload in addition to the register to contain the data. Specifically, if copying X to a register - CLASS in MODE requires an intermediate register, you should define + RCLASS in MODE requires an intermediate register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to return the largest register class all of whose registers can be used as intermediate registers or scratch registers. - If copying a register CLASS in MODE to X requires an intermediate or scratch + If copying a register RCLASS in MODE to X requires an intermediate or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be defined to return the largest register class required. If the requirements for input and output reloads are the same, the macro `SECONDARY_RELOAD_CLASS' should be used @@ -6312,7 +6312,7 @@ frv_initialize_trampoline (rtx addr, rtx fnaddr, rtx static_chain) The values returned by these macros are often `GENERAL_REGS'. Return `NO_REGS' if no spare register is needed; i.e., if X can be directly copied - to or from a register of CLASS in MODE without requiring a scratch register. + to or from a register of RCLASS in MODE without requiring a scratch register. Do not define this macro if it would always return `NO_REGS'. If a scratch register is required (either with or without an intermediate @@ -6323,7 +6323,7 @@ frv_initialize_trampoline (rtx addr, rtx fnaddr, rtx static_chain) Define constraints for the reload register and scratch register that contain a single register class. If the original reload register (whose class is - CLASS) can meet the constraint given in the pattern, the value returned by + RCLASS) can meet the constraint given in the pattern, the value returned by these macros is used for the class of the scratch register. Otherwise, two additional reload registers are required. Their classes are obtained from the constraints in the insn pattern. @@ -6341,14 +6341,14 @@ frv_initialize_trampoline (rtx addr, rtx fnaddr, rtx static_chain) This case often occurs between floating-point and general registers. */ enum reg_class -frv_secondary_reload_class (enum reg_class class, +frv_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x, int in_p ATTRIBUTE_UNUSED) { enum reg_class ret; - switch (class) + switch (rclass) { default: ret = NO_REGS; @@ -6405,10 +6405,10 @@ frv_secondary_reload_class (enum reg_class class, /* A C expression whose value is nonzero if pseudos that have been assigned to - registers of class CLASS would likely be spilled because registers of CLASS + registers of class RCLASS would likely be spilled because registers of RCLASS are needed for spill registers. - The default value of this macro returns 1 if CLASS has exactly one register + The default value of this macro returns 1 if RCLASS has exactly one register and zero otherwise. On most machines, this default should be used. Only define this macro to some other expression if pseudo allocated by `local-alloc.c' end up in memory because their hard registers were needed @@ -6420,9 +6420,9 @@ frv_secondary_reload_class (enum reg_class class, register allocation. */ int -frv_class_likely_spilled_p (enum reg_class class) +frv_class_likely_spilled_p (enum reg_class rclass) { - switch (class) + switch (rclass) { default: break; @@ -6686,11 +6686,11 @@ frv_hard_regno_nregs (int regno, enum machine_mode mode) /* A C expression for the maximum number of consecutive registers of - class CLASS needed to hold a value of mode MODE. + class RCLASS needed to hold a value of mode MODE. This is closely related to the macro `HARD_REGNO_NREGS'. In fact, the value - of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be the maximum value of - `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO values in the class CLASS. + of the macro `CLASS_MAX_NREGS (RCLASS, MODE)' should be the maximum value of + `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO values in the class RCLASS. This macro helps control the handling of multiple-word values in the reload pass. @@ -6698,9 +6698,9 @@ frv_hard_regno_nregs (int regno, enum machine_mode mode) This declaration is required. */ int -frv_class_max_nregs (enum reg_class class, enum machine_mode mode) +frv_class_max_nregs (enum reg_class rclass, enum machine_mode mode) { - if (class == ACCG_REGS) + if (rclass == ACCG_REGS) /* An N-byte value requires N accumulator guards. */ return GET_MODE_SIZE (mode); else diff --git a/gcc/config/h8300/h8300.c b/gcc/config/h8300/h8300.c index 86790699f13..3d9c0fb7efb 100644 --- a/gcc/config/h8300/h8300.c +++ b/gcc/config/h8300/h8300.c @@ -2147,21 +2147,21 @@ h8300_displacement_length (rtx addr, int size) return h8300_constant_length (offset); } -/* Store the class of operand OP in *CLASS and return the length of any - extra operand fields. SIZE is the number of bytes in OP. CLASS +/* Store the class of operand OP in *OPCLASS and return the length of any + extra operand fields. SIZE is the number of bytes in OP. OPCLASS can be null if only the length is needed. */ static unsigned int -h8300_classify_operand (rtx op, int size, enum h8300_operand_class *class) +h8300_classify_operand (rtx op, int size, enum h8300_operand_class *opclass) { enum h8300_operand_class dummy; - if (class == 0) - class = &dummy; + if (opclass == 0) + opclass = &dummy; if (CONSTANT_P (op)) { - *class = H8OP_IMMEDIATE; + *opclass = H8OP_IMMEDIATE; /* Byte-sized immediates are stored in the opcode fields. */ if (size == 1) @@ -2182,27 +2182,27 @@ h8300_classify_operand (rtx op, int size, enum h8300_operand_class *class) op = XEXP (op, 0); if (CONSTANT_P (op)) { - *class = H8OP_MEM_ABSOLUTE; + *opclass = H8OP_MEM_ABSOLUTE; return h8300_constant_length (op); } else if (GET_CODE (op) == PLUS && CONSTANT_P (XEXP (op, 1))) { - *class = H8OP_MEM_COMPLEX; + *opclass = H8OP_MEM_COMPLEX; return h8300_displacement_length (op, size); } else if (GET_RTX_CLASS (GET_CODE (op)) == RTX_AUTOINC) { - *class = H8OP_MEM_COMPLEX; + *opclass = H8OP_MEM_COMPLEX; return 0; } else if (register_operand (op, VOIDmode)) { - *class = H8OP_MEM_BASE; + *opclass = H8OP_MEM_BASE; return 0; } } gcc_assert (register_operand (op, VOIDmode)); - *class = H8OP_REGISTER; + *opclass = H8OP_REGISTER; return 0; } @@ -2228,12 +2228,12 @@ h8300_length_from_table (rtx op1, rtx op2, const h8300_length_table *table) unsigned int h8300_unary_length (rtx op) { - enum h8300_operand_class class; + enum h8300_operand_class opclass; unsigned int size, operand_length; size = GET_MODE_SIZE (GET_MODE (op)); - operand_length = h8300_classify_operand (op, size, &class); - switch (class) + operand_length = h8300_classify_operand (op, size, &opclass); + switch (opclass) { case H8OP_REGISTER: return 2; @@ -2257,13 +2257,13 @@ h8300_unary_length (rtx op) static unsigned int h8300_short_immediate_length (rtx op) { - enum h8300_operand_class class; + enum h8300_operand_class opclass; unsigned int size, operand_length; size = GET_MODE_SIZE (GET_MODE (op)); - operand_length = h8300_classify_operand (op, size, &class); + operand_length = h8300_classify_operand (op, size, &opclass); - switch (class) + switch (opclass) { case H8OP_REGISTER: return 2; @@ -2283,7 +2283,7 @@ h8300_short_immediate_length (rtx op) static unsigned int h8300_bitfield_length (rtx op, rtx op2) { - enum h8300_operand_class class; + enum h8300_operand_class opclass; unsigned int size, operand_length; if (GET_CODE (op) == REG) @@ -2291,9 +2291,9 @@ h8300_bitfield_length (rtx op, rtx op2) gcc_assert (GET_CODE (op) != REG); size = GET_MODE_SIZE (GET_MODE (op)); - operand_length = h8300_classify_operand (op, size, &class); + operand_length = h8300_classify_operand (op, size, &opclass); - switch (class) + switch (opclass) { case H8OP_MEM_BASE: case H8OP_MEM_ABSOLUTE: @@ -4526,15 +4526,15 @@ output_a_shift (rtx *operands) } } -/* Count the number of assembly instructions in a string TEMPLATE. */ +/* Count the number of assembly instructions in a string TEMPL. */ static unsigned int -h8300_asm_insn_count (const char *template) +h8300_asm_insn_count (const char *templ) { unsigned int count = 1; - for (; *template; template++) - if (*template == '\n') + for (; *templ; templ++) + if (*templ == '\n') count++; return count; diff --git a/gcc/config/i386/emmintrin.h b/gcc/config/i386/emmintrin.h index 933dcd61e63..c6590dce4d4 100644 --- a/gcc/config/i386/emmintrin.h +++ b/gcc/config/i386/emmintrin.h @@ -726,7 +726,7 @@ _mm_movpi64_epi64 (__m64 __A) extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__)) _mm_move_epi64 (__m128i __A) { - return _mm_set_epi64 ((__m64)0LL, _mm_movepi64_pi64 (__A)); + return (__m128i)__builtin_ia32_movq128 ((__v2di) __A); } /* Create a vector of zeros. */ diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index d31f176d9a3..8da85e16e5c 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -75,8 +75,8 @@ static rtx legitimize_dllimport_symbol (rtx, bool); #define DUMMY_STRINGOP_ALGS {libcall, {{-1, libcall}}} -static const -struct processor_costs size_cost = { /* costs for tuning for size */ +const +struct processor_costs ix86_size_cost = {/* costs for tuning for size */ COSTS_N_BYTES (2), /* cost of an add instruction */ COSTS_N_BYTES (3), /* cost of a lea instruction */ COSTS_N_BYTES (2), /* variable shift costs */ @@ -2841,7 +2841,7 @@ override_options (bool main_args_p) ix86_tune_features[i] = !!(initial_ix86_tune_features[i] & ix86_tune_mask); if (optimize_size) - ix86_cost = &size_cost; + ix86_cost = &ix86_size_cost; else ix86_cost = processor_target_table[ix86_tune].cost; @@ -3173,6 +3173,11 @@ override_options (bool main_args_p) *p = '\0'; } + /* When scheduling description is not available, disable scheduler pass + so it won't slow down the compilation and make x87 code slower. */ + if (!TARGET_SCHEDULE) + flag_schedule_insns_after_reload = flag_schedule_insns = 0; + if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES)) set_param_value ("simultaneous-prefetches", ix86_cost->simultaneous_prefetches); @@ -3942,11 +3947,6 @@ optimization_options (int level, int size ATTRIBUTE_UNUSED) flag_schedule_insns = 0; #endif - /* When scheduling description is not available, disable scheduler pass - so it won't slow down the compilation and make x87 code slower. */ - if (!TARGET_SCHEDULE) - flag_schedule_insns_after_reload = flag_schedule_insns = 0; - if (TARGET_MACHO) /* The Darwin libraries never set errno, so we might as well avoid calling them when that's the only reason we would. */ @@ -7614,7 +7614,10 @@ ix86_finalize_stack_realign_flags (void) { /* Check if stack realign is really needed after reload, and stores result in cfun */ - unsigned int stack_realign = (ix86_incoming_stack_boundary + unsigned int incoming_stack_boundary + = (crtl->parm_stack_boundary > ix86_incoming_stack_boundary + ? crtl->parm_stack_boundary : ix86_incoming_stack_boundary); + unsigned int stack_realign = (incoming_stack_boundary < (current_function_is_leaf ? crtl->max_used_stack_slot_alignment : crtl->stack_alignment_needed)); @@ -11538,7 +11541,7 @@ ix86_expand_clear (rtx dest) tmp = gen_rtx_SET (VOIDmode, dest, const0_rtx); /* This predicate should match that for movsi_xor and movdi_xor_rex64. */ - if (reload_completed && (!TARGET_USE_MOV0 || optimize_size)) + if (reload_completed && (!TARGET_USE_MOV0 || optimize_insn_for_speed_p ())) { rtx clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG)); tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, tmp, clob)); @@ -11805,7 +11808,7 @@ ix86_expand_vector_move_misalign (enum machine_mode mode, rtx operands[]) if (MEM_P (op1)) { /* If we're optimizing for size, movups is the smallest. */ - if (optimize_size) + if (optimize_insn_for_size_p ()) { op0 = gen_lowpart (V4SFmode, op0); op1 = gen_lowpart (V4SFmode, op1); @@ -11887,7 +11890,7 @@ ix86_expand_vector_move_misalign (enum machine_mode mode, rtx operands[]) else if (MEM_P (op0)) { /* If we're optimizing for size, movups is the smallest. */ - if (optimize_size) + if (optimize_insn_for_size_p ()) { op0 = gen_lowpart (V4SFmode, op0); op1 = gen_lowpart (V4SFmode, op1); @@ -13091,7 +13094,7 @@ ix86_fp_comparison_sahf_cost (enum rtx_code code) enum rtx_code bypass_code, first_code, second_code; /* Return arbitrarily high cost when instruction is not preferred - this avoids gcc from using it. */ - if (!(TARGET_SAHF && (TARGET_USE_SAHF || optimize_size))) + if (!(TARGET_SAHF && (TARGET_USE_SAHF || optimize_insn_for_size_p ()))) return 1024; ix86_fp_comparison_codes (code, &bypass_code, &first_code, &second_code); return (bypass_code != UNKNOWN || second_code != UNKNOWN) + 3; @@ -13576,7 +13579,7 @@ ix86_expand_branch (enum rtx_code code, rtx label) optimizing for size. */ if ((code == EQ || code == NE) - && (!optimize_size + && (!optimize_insn_for_size_p () || hi[1] == const0_rtx || lo[1] == const0_rtx)) { rtx xor0, xor1; @@ -15628,7 +15631,7 @@ ix86_split_long_move (rtx operands[]) } /* If optimizing for size, attempt to locally unCSE nonzero constants. */ - if (optimize_size) + if (optimize_insn_for_size_p ()) { for (j = 0; j < nparts - 1; j++) if (CONST_INT_P (operands[6 + j]) @@ -15659,7 +15662,7 @@ ix86_expand_ashl_const (rtx operand, int count, enum machine_mode mode) ? gen_addsi3 : gen_adddi3) (operand, operand, operand)); } - else if (!optimize_size + else if (!optimize_insn_for_size_p () && count * ix86_cost->add <= ix86_cost->shift_const) { int i; @@ -15742,7 +15745,7 @@ ix86_split_ashl (rtx *operands, rtx scratch, enum machine_mode mode) { rtx x; - if (TARGET_PARTIAL_REG_STALL && !optimize_size) + if (TARGET_PARTIAL_REG_STALL && !optimize_insn_for_size_p ()) x = gen_rtx_ZERO_EXTEND (mode == DImode ? SImode : DImode, operands[2]); else x = gen_lowpart (mode == DImode ? SImode : DImode, operands[2]); @@ -15774,7 +15777,7 @@ ix86_split_ashl (rtx *operands, rtx scratch, enum machine_mode mode) /* For -1 << N, we can avoid the shld instruction, because we know that we're shifting 0...31/63 ones into a -1. */ emit_move_insn (low[0], constm1_rtx); - if (optimize_size) + if (optimize_insn_for_size_p ()) emit_move_insn (high[0], low[0]); else emit_move_insn (high[0], constm1_rtx); @@ -16629,7 +16632,7 @@ decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset, && alg != rep_prefix_8_byte)) const struct processor_costs *cost; - cost = optimize_insn_for_size_p () ? &size_cost : ix86_cost; + cost = optimize_insn_for_size_p () ? &ix86_size_cost : ix86_cost; *dynamic_check = -1; if (memset) @@ -16639,7 +16642,7 @@ decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset, if (stringop_alg != no_stringop && ALG_USABLE_P (stringop_alg)) return stringop_alg; /* rep; movq or rep; movl is the smallest variant. */ - else if (optimize_size) + else if (optimize_insn_for_size_p ()) { if (!count || (count & 3)) return rep_prefix_usable ? rep_prefix_1_byte : loop_1_byte; @@ -17554,7 +17557,7 @@ ix86_expand_strlen (rtx out, rtx src, rtx eoschar, rtx align) if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1 && !TARGET_INLINE_ALL_STRINGOPS - && !optimize_size + && !optimize_insn_for_size_p () && (!CONST_INT_P (align) || INTVAL (align) < 4)) return 0; @@ -17562,7 +17565,7 @@ ix86_expand_strlen (rtx out, rtx src, rtx eoschar, rtx align) scratch1 = gen_reg_rtx (Pmode); if (TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > 1 - && !optimize_size) + && !optimize_insn_for_size_p ()) { /* Well it seems that some optimizer does not combine a call like foo(strlen(bar), strlen(bar)); @@ -18726,6 +18729,8 @@ enum ix86_builtins IX86_BUILTIN_MOVNTPD, IX86_BUILTIN_MOVNTDQ, + IX86_BUILTIN_MOVQ128, + /* SSE2 MMX */ IX86_BUILTIN_MASKMOVDQU, IX86_BUILTIN_MOVMSKPD, @@ -19855,6 +19860,8 @@ static const struct builtin_description bdesc_args[] = { OPTION_MASK_ISA_SSE2, CODE_FOR_abstf2, 0, IX86_BUILTIN_FABSQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128 }, { OPTION_MASK_ISA_SSE2, CODE_FOR_copysigntf3, 0, IX86_BUILTIN_COPYSIGNQ, UNKNOWN, (int) FLOAT128_FTYPE_FLOAT128_FLOAT128 }, + { OPTION_MASK_ISA_SSE, CODE_FOR_sse2_movq128, "__builtin_ia32_movq128", IX86_BUILTIN_MOVQ128, UNKNOWN, (int) V2DI_FTYPE_V2DI }, + /* SSE2 MMX */ { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_addv1di3, "__builtin_ia32_paddq", IX86_BUILTIN_PADDQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI }, { OPTION_MASK_ISA_SSE2, CODE_FOR_mmx_subv1di3, "__builtin_ia32_psubq", IX86_BUILTIN_PSUBQ, UNKNOWN, (int) V1DI_FTYPE_V1DI_V1DI }, @@ -22431,7 +22438,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, bool last_arg_constant = false; const struct insn_data *insn_p = &insn_data[icode]; enum machine_mode tmode = insn_p->operand[0].mode; - enum { load, store } class; + enum { load, store } klass; switch ((enum ix86_special_builtin_type) d->flag) { @@ -22443,7 +22450,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, case V4SF_FTYPE_PCFLOAT: case V2DF_FTYPE_PCDOUBLE: nargs = 1; - class = load; + klass = load; memory = 0; break; case VOID_FTYPE_PV2SF_V4SF: @@ -22454,14 +22461,14 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, case VOID_FTYPE_PDI_DI: case VOID_FTYPE_PINT_INT: nargs = 1; - class = store; + klass = store; /* Reserve memory operand for target. */ memory = ARRAY_SIZE (args); break; case V4SF_FTYPE_V4SF_PCV2SF: case V2DF_FTYPE_V2DF_PCDOUBLE: nargs = 2; - class = load; + klass = load; memory = 1; break; default: @@ -22470,7 +22477,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, gcc_assert (nargs <= ARRAY_SIZE (args)); - if (class == store) + if (klass == store) { arg = CALL_EXPR_ARG (exp, 0); op = expand_normal (arg); @@ -22547,7 +22554,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d, if (! pat) return 0; emit_insn (pat); - return class == store ? 0 : target; + return klass == store ? 0 : target; } /* Return the integer constant in ARG. Constrain it to be in the range @@ -23141,8 +23148,10 @@ ix86_veclibabi_acml (enum built_in_function fn, tree type_out, tree type_in) } -/* Returns a decl of a function that implements conversion of the - input vector of type TYPE, or NULL_TREE if it is not available. */ +/* Returns a decl of a function that implements conversion of an integer vector + into a floating-point vector, or vice-versa. TYPE is the type of the integer + side of the conversion. + Return NULL_TREE if it is not available. */ static tree ix86_vectorize_builtin_conversion (unsigned int code, tree type) @@ -23164,7 +23173,7 @@ ix86_vectorize_builtin_conversion (unsigned int code, tree type) case FIX_TRUNC_EXPR: switch (TYPE_MODE (type)) { - case V4SFmode: + case V4SImode: return ix86_builtins[IX86_BUILTIN_CVTTPS2DQ]; default: return NULL_TREE; @@ -23182,7 +23191,7 @@ static tree ix86_builtin_reciprocal (unsigned int fn, bool md_fn, bool sqrt ATTRIBUTE_UNUSED) { - if (! (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size + if (! (TARGET_SSE_MATH && TARGET_RECIP && !optimize_insn_for_size_p () && flag_finite_math_only && !flag_trapping_math && flag_unsafe_math_optimizations)) return NULL_TREE; @@ -23414,16 +23423,16 @@ ix86_preferred_output_reload_class (rtx x, enum reg_class regclass) } static enum reg_class -ix86_secondary_reload (bool in_p, rtx x, enum reg_class class, +ix86_secondary_reload (bool in_p, rtx x, enum reg_class rclass, enum machine_mode mode, secondary_reload_info *sri ATTRIBUTE_UNUSED) { /* QImode spills from non-QI registers require intermediate register on 32bit targets. */ if (!in_p && mode == QImode && !TARGET_64BIT - && (class == GENERAL_REGS - || class == LEGACY_REGS - || class == INDEX_REGS)) + && (rclass == GENERAL_REGS + || rclass == LEGACY_REGS + || rclass == INDEX_REGS)) { int regno; @@ -24821,7 +24830,7 @@ ix86_pad_returns (void) bool replace = false; if (!JUMP_P (ret) || GET_CODE (PATTERN (ret)) != RETURN - || !maybe_hot_bb_p (bb)) + || optimize_bb_for_size_p (bb)) continue; for (prev = PREV_INSN (ret); prev; prev = PREV_INSN (prev)) if (active_insn_p (prev) || LABEL_P (prev)) @@ -26134,7 +26143,7 @@ ix86_emit_fp_unordered_jump (rtx label) emit_insn (gen_x86_fnstsw_1 (reg)); - if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_size)) + if (TARGET_SAHF && (TARGET_USE_SAHF || optimize_insn_for_size_p ())) { emit_insn (gen_x86_sahf_1 (reg)); diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h index 3247c10d430..23871561544 100644 --- a/gcc/config/i386/i386.h +++ b/gcc/config/i386/i386.h @@ -170,6 +170,10 @@ struct processor_costs { }; extern const struct processor_costs *ix86_cost; +extern const struct processor_costs ix86_size_cost; + +#define ix86_cur_cost() \ + (optimize_insn_for_size_p () ? &ix86_size_cost: ix86_cost) /* Macros used in the machine description to test the flags. */ diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index 2e737b10abe..f8d4c7db118 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -1419,7 +1419,7 @@ [(set (match_operand:SI 0 "register_operand" "=r") (match_operand:SI 1 "const0_operand" "")) (clobber (reg:CC FLAGS_REG))] - "reload_completed && (!TARGET_USE_MOV0 || optimize_size)" + "reload_completed" "xor{l}\t%0, %0" [(set_attr "type" "alu1") (set_attr "mode" "SI") @@ -1430,8 +1430,7 @@ (match_operand:SI 1 "immediate_operand" "i")) (clobber (reg:CC FLAGS_REG))] "reload_completed - && operands[1] == constm1_rtx - && (TARGET_MOVE_M1_VIA_OR || optimize_size)" + && operands[1] == constm1_rtx" { operands[1] = constm1_rtx; return "or{l}\t{%1, %0|%0, %1}"; @@ -1710,8 +1709,7 @@ [(set (strict_low_part (match_operand:HI 0 "register_operand" "+r")) (match_operand:HI 1 "const0_operand" "")) (clobber (reg:CC FLAGS_REG))] - "reload_completed - && ((!TARGET_USE_MOV0 && !TARGET_PARTIAL_REG_STALL) || optimize_size)" + "reload_completed" "xor{w}\t%0, %0" [(set_attr "type" "alu1") (set_attr "mode" "HI") @@ -1867,7 +1865,7 @@ [(set (strict_low_part (match_operand:QI 0 "q_regs_operand" "+q")) (match_operand:QI 1 "const0_operand" "")) (clobber (reg:CC FLAGS_REG))] - "reload_completed && (!TARGET_USE_MOV0 || optimize_size)" + "reload_completed" "xor{b}\t%0, %0" [(set_attr "type" "alu1") (set_attr "mode" "QI") @@ -2193,7 +2191,7 @@ [(set (match_operand:DI 0 "register_operand" "=r") (match_operand:DI 1 "const0_operand" "")) (clobber (reg:CC FLAGS_REG))] - "TARGET_64BIT && (!TARGET_USE_MOV0 || optimize_size) + "TARGET_64BIT && reload_completed" "xor{l}\t%k0, %k0"; [(set_attr "type" "alu1") @@ -2204,7 +2202,7 @@ [(set (match_operand:DI 0 "register_operand" "=r") (match_operand:DI 1 "const_int_operand" "i")) (clobber (reg:CC FLAGS_REG))] - "TARGET_64BIT && (TARGET_MOVE_M1_VIA_OR || optimize_size) + "TARGET_64BIT && reload_completed && operands[1] == constm1_rtx" { @@ -4502,13 +4500,16 @@ (use (match_dup 2)) (clobber (match_scratch:<ssevecmode> 3 "")) (clobber (match_scratch:<ssevecmode> 4 ""))])] - "!TARGET_64BIT && TARGET_SSE2 && TARGET_SSE_MATH && !optimize_size" + "!TARGET_64BIT && TARGET_SSE2 && TARGET_SSE_MATH" { enum machine_mode mode = <MODE>mode; enum machine_mode vecmode = <ssevecmode>mode; REAL_VALUE_TYPE TWO31r; rtx two31; + if (optimize_insn_for_size_p ()) + FAIL; + real_ldexp (&TWO31r, &dconst1, 31); two31 = const_double_from_real_value (TWO31r, mode); two31 = ix86_build_const_vector (mode, true, two31); @@ -8215,7 +8216,7 @@ (match_operand:SF 2 "nonimmediate_operand" "")))] "TARGET_80387 || TARGET_SSE_MATH" { - if (TARGET_SSE_MATH && TARGET_RECIP && !optimize_size + if (TARGET_SSE_MATH && TARGET_RECIP && optimize_insn_for_speed_p () && flag_finite_math_only && !flag_trapping_math && flag_unsafe_math_optimizations) { @@ -16911,10 +16912,13 @@ UNSPEC_FPATAN)) (clobber (match_scratch:XF 6 ""))])] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { int i; + if (optimize_insn_for_size_p ()) + FAIL; + for (i = 2; i < 6; i++) operands[i] = gen_reg_rtx (XFmode); @@ -16927,11 +16931,14 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { rtx op0 = gen_reg_rtx (XFmode); rtx op1 = gen_reg_rtx (XFmode); + if (optimize_insn_for_size_p ()) + FAIL; + emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_asinxf2 (op0, op1)); emit_insn (gen_truncxf<mode>2_i387_noop (operands[0], op0)); @@ -16949,10 +16956,13 @@ UNSPEC_FPATAN)) (clobber (match_scratch:XF 6 ""))])] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { int i; + if (optimize_insn_for_size_p ()) + FAIL; + for (i = 2; i < 6; i++) operands[i] = gen_reg_rtx (XFmode); @@ -16965,11 +16975,14 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { rtx op0 = gen_reg_rtx (XFmode); rtx op1 = gen_reg_rtx (XFmode); + if (optimize_insn_for_size_p ()) + FAIL; + emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_acosxf2 (op0, op1)); emit_insn (gen_truncxf<mode>2_i387_noop (operands[0], op0)); @@ -17124,8 +17137,11 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { + if (optimize_insn_for_size_p ()) + FAIL; + ix86_emit_i387_log1p (operands[0], operands[1]); DONE; }) @@ -17136,9 +17152,14 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); + rtx op0; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); operands[1] = gen_rtx_FLOAT_EXTEND (XFmode, operands[1]); @@ -17206,10 +17227,15 @@ [(use (match_operand:SI 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_fxtractxf3_i387 (op0, op1, operands[1])); emit_insn (gen_fix_truncxfsi2 (operands[0], op1)); @@ -17222,10 +17248,15 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_fxtract_extend<mode>xf3_i387 (op0, op1, operands[1])); emit_insn (gen_fix_truncxfsi2 (operands[0], op1)); @@ -17270,10 +17301,13 @@ (unspec:XF [(match_dup 8) (match_dup 4)] UNSPEC_FSCALE_EXP))])] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { int i; + if (optimize_insn_for_size_p ()) + FAIL; + for (i = 3; i < 10; i++) operands[i] = gen_reg_rtx (XFmode); @@ -17284,9 +17318,14 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op2 = gen_reg_rtx (XFmode); + rtx op2; + + if (optimize_insn_for_size_p ()) + FAIL; + + op2 = gen_reg_rtx (XFmode); emit_move_insn (op2, standard_80387_constant_rtx (5)); /* fldl2e */ emit_insn (gen_expNcorexf3 (operands[0], operands[1], op2)); @@ -17299,10 +17338,15 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_expxf2 (op0, op1)); @@ -17314,9 +17358,14 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op2 = gen_reg_rtx (XFmode); + rtx op2; + + if (optimize_insn_for_size_p ()) + FAIL; + + op2 = gen_reg_rtx (XFmode); emit_move_insn (op2, standard_80387_constant_rtx (6)); /* fldl2t */ emit_insn (gen_expNcorexf3 (operands[0], operands[1], op2)); @@ -17329,10 +17378,15 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_exp10xf2 (op0, op1)); @@ -17344,9 +17398,14 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op2 = gen_reg_rtx (XFmode); + rtx op2; + + if (optimize_insn_for_size_p ()) + FAIL; + + op2 = gen_reg_rtx (XFmode); emit_move_insn (op2, CONST1_RTX (XFmode)); /* fld1 */ emit_insn (gen_expNcorexf3 (operands[0], operands[1], op2)); @@ -17359,10 +17418,15 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_exp2xf2 (op0, op1)); @@ -17394,10 +17458,13 @@ (set (match_operand:XF 0 "register_operand" "") (plus:XF (match_dup 12) (match_dup 7)))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { int i; + if (optimize_insn_for_size_p ()) + FAIL; + for (i = 2; i < 13; i++) operands[i] = gen_reg_rtx (XFmode); @@ -17413,10 +17480,15 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_expm1xf2 (op0, op1)); @@ -17435,8 +17507,11 @@ (unspec:XF [(match_dup 1) (match_dup 3)] UNSPEC_FSCALE_EXP))])] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { + if (optimize_insn_for_size_p ()) + FAIL; + operands[3] = gen_reg_rtx (XFmode); operands[4] = gen_reg_rtx (XFmode); }) @@ -17448,10 +17523,15 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_ldexpxf3 (op0, op1, operands[2])); @@ -17468,8 +17548,11 @@ (unspec:XF [(match_dup 1) (match_dup 2)] UNSPEC_FSCALE_EXP))])] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { + if (optimize_insn_for_size_p ()) + FAIL; + operands[3] = gen_reg_rtx (XFmode); }) @@ -17480,11 +17563,16 @@ "TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); - rtx op2 = gen_reg_rtx (XFmode); + rtx op0, op1, op2; + + if (optimize_insn_for_size_p ()) + FAIL; + + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); + op2 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_extend<mode>xf2 (op2, operands[2])); @@ -17523,13 +17611,13 @@ || TARGET_MIX_SSE_I387) && flag_unsafe_math_optimizations) || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math - && (TARGET_ROUND || !optimize_size))" + && !flag_trapping_math)" { if (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math - && (TARGET_ROUND || !optimize_size)) + && !flag_trapping_math) { + if (!TARGET_ROUND && optimize_insn_for_size_p ()) + FAIL; if (TARGET_ROUND) emit_insn (gen_sse4_1_round<mode>2 (operands[0], operands[1], GEN_INT (0x04))); @@ -17553,9 +17641,10 @@ [(match_operand:MODEF 0 "register_operand" "") (match_operand:MODEF 1 "nonimmediate_operand" "")] "SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math && !flag_rounding_math - && !optimize_size" + && !flag_trapping_math && !flag_rounding_math" { + if (optimize_insn_for_size_p ()) + FAIL; if (TARGET_64BIT || (<MODE>mode != DFmode)) ix86_expand_round (operand0, operand1); else @@ -17706,9 +17795,10 @@ (match_operand:MODEF 1 "register_operand" "")] "SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH && ((<SSEMODEI24:MODE>mode != DImode) || TARGET_64BIT) - && !flag_trapping_math && !flag_rounding_math - && !optimize_size" + && !flag_trapping_math && !flag_rounding_math" { + if (optimize_insn_for_size_p ()) + FAIL; ix86_expand_lround (operand0, operand1); DONE; }) @@ -17756,8 +17846,10 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { + if (optimize_insn_for_size_p ()) + FAIL; emit_insn (gen_frndintxf2_floor (operands[0], operands[1])); DONE; }) @@ -17768,15 +17860,16 @@ "(TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size) + && flag_unsafe_math_optimizations) || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math - && (TARGET_ROUND || !optimize_size))" + && !flag_trapping_math)" { if (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH && !flag_trapping_math - && (TARGET_ROUND || !optimize_size)) + && (TARGET_ROUND || optimize_insn_for_speed_p ())) { + if (!TARGET_ROUND && optimize_insn_for_size_p ()) + FAIL; if (TARGET_ROUND) emit_insn (gen_sse4_1_round<mode>2 (operands[0], operands[1], GEN_INT (0x01))); @@ -17787,9 +17880,13 @@ } else { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_frndintxf2_floor (op0, op1)); @@ -17960,9 +18057,10 @@ [(match_operand:DI 0 "nonimmediate_operand" "") (match_operand:MODEF 1 "register_operand" "")] "SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH && TARGET_64BIT - && !flag_trapping_math - && !optimize_size" + && !flag_trapping_math" { + if (optimize_insn_for_size_p ()) + FAIL; ix86_expand_lfloorceil (operand0, operand1, true); DONE; }) @@ -17971,9 +18069,10 @@ [(match_operand:SI 0 "nonimmediate_operand" "") (match_operand:MODEF 1 "register_operand" "")] "SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math - && (!optimize_size || !TARGET_64BIT)" + && !flag_trapping_math" { + if (optimize_insn_for_size_p () && TARGET_64BIT) + FAIL; ix86_expand_lfloorceil (operand0, operand1, true); DONE; }) @@ -18021,8 +18120,10 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { + if (optimize_insn_for_size_p ()) + FAIL; emit_insn (gen_frndintxf2_ceil (operands[0], operands[1])); DONE; }) @@ -18033,18 +18134,19 @@ "(TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size) + && flag_unsafe_math_optimizations) || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math - && (TARGET_ROUND || !optimize_size))" + && !flag_trapping_math)" { if (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH && !flag_trapping_math - && (TARGET_ROUND || !optimize_size)) + && (TARGET_ROUND || optimize_insn_for_speed_p ())) { if (TARGET_ROUND) emit_insn (gen_sse4_1_round<mode>2 (operands[0], operands[1], GEN_INT (0x02))); + else if (optimize_insn_for_size_p ()) + FAIL; else if (TARGET_64BIT || (<MODE>mode != DFmode)) ix86_expand_floorceil (operand0, operand1, false); else @@ -18052,9 +18154,13 @@ } else { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_frndintxf2_ceil (op0, op1)); @@ -18284,8 +18390,10 @@ [(use (match_operand:XF 0 "register_operand" "")) (use (match_operand:XF 1 "register_operand" ""))] "TARGET_USE_FANCY_MATH_387 - && flag_unsafe_math_optimizations && !optimize_size" + && flag_unsafe_math_optimizations" { + if (optimize_insn_for_size_p ()) + FAIL; emit_insn (gen_frndintxf2_trunc (operands[0], operands[1])); DONE; }) @@ -18296,18 +18404,19 @@ "(TARGET_USE_FANCY_MATH_387 && (!(SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH) || TARGET_MIX_SSE_I387) - && flag_unsafe_math_optimizations && !optimize_size) + && flag_unsafe_math_optimizations) || (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH - && !flag_trapping_math - && (TARGET_ROUND || !optimize_size))" + && !flag_trapping_math)" { if (SSE_FLOAT_MODE_P (<MODE>mode) && TARGET_SSE_MATH && !flag_trapping_math - && (TARGET_ROUND || !optimize_size)) + && (TARGET_ROUND || optimize_insn_for_speed_p ())) { if (TARGET_ROUND) emit_insn (gen_sse4_1_round<mode>2 (operands[0], operands[1], GEN_INT (0x03))); + else if (optimize_insn_for_size_p ()) + FAIL; else if (TARGET_64BIT || (<MODE>mode != DFmode)) ix86_expand_trunc (operand0, operand1); else @@ -18315,9 +18424,13 @@ } else { - rtx op0 = gen_reg_rtx (XFmode); - rtx op1 = gen_reg_rtx (XFmode); + rtx op0, op1; + + if (optimize_insn_for_size_p ()) + FAIL; + op0 = gen_reg_rtx (XFmode); + op1 = gen_reg_rtx (XFmode); emit_insn (gen_extend<mode>xf2 (op1, operands[1])); emit_insn (gen_frndintxf2_trunc (op0, op1)); @@ -18508,7 +18621,7 @@ operands[6] = gen_rtx_PLUS (Pmode, operands[2], adjust); /* Can't use this if the user has appropriated esi or edi. */ - if ((TARGET_SINGLE_STRINGOP || optimize_size) + if ((TARGET_SINGLE_STRINGOP || optimize_insn_for_size_p ()) && !(fixed_regs[SI_REG] || fixed_regs[DI_REG])) { emit_insn (gen_strmov_singleop (operands[0], operands[1], @@ -18527,7 +18640,7 @@ (match_operand 4 "" "")) (set (match_operand 2 "register_operand" "") (match_operand 5 "" ""))])] - "TARGET_SINGLE_STRINGOP || optimize_size" + "" "ix86_current_function_needs_cld = 1;") (define_insn "*strmovdi_rex_1" @@ -18539,7 +18652,7 @@ (set (match_operand:DI 1 "register_operand" "=S") (plus:DI (match_dup 3) (const_int 8)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "movsq" [(set_attr "type" "str") (set_attr "mode" "DI") @@ -18554,7 +18667,7 @@ (set (match_operand:SI 1 "register_operand" "=S") (plus:SI (match_dup 3) (const_int 4)))] - "!TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "!TARGET_64BIT" "movs{l|d}" [(set_attr "type" "str") (set_attr "mode" "SI") @@ -18569,7 +18682,7 @@ (set (match_operand:DI 1 "register_operand" "=S") (plus:DI (match_dup 3) (const_int 4)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "movs{l|d}" [(set_attr "type" "str") (set_attr "mode" "SI") @@ -18584,7 +18697,7 @@ (set (match_operand:SI 1 "register_operand" "=S") (plus:SI (match_dup 3) (const_int 2)))] - "!TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "!TARGET_64BIT" "movsw" [(set_attr "type" "str") (set_attr "memory" "both") @@ -18599,7 +18712,7 @@ (set (match_operand:DI 1 "register_operand" "=S") (plus:DI (match_dup 3) (const_int 2)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "movsw" [(set_attr "type" "str") (set_attr "memory" "both") @@ -18614,7 +18727,7 @@ (set (match_operand:SI 1 "register_operand" "=S") (plus:SI (match_dup 3) (const_int 1)))] - "!TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "!TARGET_64BIT" "movsb" [(set_attr "type" "str") (set_attr "memory" "both") @@ -18629,7 +18742,7 @@ (set (match_operand:DI 1 "register_operand" "=S") (plus:DI (match_dup 3) (const_int 1)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "movsb" [(set_attr "type" "str") (set_attr "memory" "both") @@ -18791,7 +18904,7 @@ operands[3] = gen_rtx_PLUS (Pmode, operands[0], GEN_INT (GET_MODE_SIZE (GET_MODE (operands[2])))); - if (TARGET_SINGLE_STRINGOP || optimize_size) + if (TARGET_SINGLE_STRINGOP || optimize_insn_for_size_p ()) { emit_insn (gen_strset_singleop (operands[0], operands[1], operands[2], operands[3])); @@ -18804,7 +18917,7 @@ (match_operand 2 "register_operand" "")) (set (match_operand 0 "register_operand" "") (match_operand 3 "" ""))])] - "TARGET_SINGLE_STRINGOP || optimize_size" + "" "ix86_current_function_needs_cld = 1;") (define_insn "*strsetdi_rex_1" @@ -18813,7 +18926,7 @@ (set (match_operand:DI 0 "register_operand" "=D") (plus:DI (match_dup 1) (const_int 8)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "stosq" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18825,7 +18938,7 @@ (set (match_operand:SI 0 "register_operand" "=D") (plus:SI (match_dup 1) (const_int 4)))] - "!TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "!TARGET_64BIT" "stos{l|d}" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18837,7 +18950,7 @@ (set (match_operand:DI 0 "register_operand" "=D") (plus:DI (match_dup 1) (const_int 4)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "stos{l|d}" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18849,7 +18962,7 @@ (set (match_operand:SI 0 "register_operand" "=D") (plus:SI (match_dup 1) (const_int 2)))] - "!TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "!TARGET_64BIT" "stosw" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18861,7 +18974,7 @@ (set (match_operand:DI 0 "register_operand" "=D") (plus:DI (match_dup 1) (const_int 2)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "stosw" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18873,7 +18986,7 @@ (set (match_operand:SI 0 "register_operand" "=D") (plus:SI (match_dup 1) (const_int 1)))] - "!TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "!TARGET_64BIT" "stosb" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18885,7 +18998,7 @@ (set (match_operand:DI 0 "register_operand" "=D") (plus:DI (match_dup 1) (const_int 1)))] - "TARGET_64BIT && (TARGET_SINGLE_STRINGOP || optimize_size)" + "TARGET_64BIT" "stosb" [(set_attr "type" "str") (set_attr "memory" "store") @@ -18990,10 +19103,13 @@ (match_operand:BLK 2 "general_operand" ""))) (use (match_operand 3 "general_operand" "")) (use (match_operand 4 "immediate_operand" ""))] - "! optimize_size || TARGET_INLINE_ALL_STRINGOPS" + "" { rtx addr1, addr2, out, outlow, count, countreg, align; + if (optimize_insn_for_size_p () && !TARGET_INLINE_ALL_STRINGOPS) + FAIL; + /* Can't use this if the user has appropriated esi or edi. */ if (fixed_regs[SI_REG] || fixed_regs[DI_REG]) FAIL; @@ -19914,7 +20030,7 @@ (const_int 0)]))] "! TARGET_PARTIAL_REG_STALL && reload_completed && ! TARGET_FAST_PREFIX - && ! optimize_size + && optimize_insn_for_speed_p () /* Ensure that the operand will remain sign-extended immediate. */ && ix86_match_ccmode (insn, INTVAL (operands[3]) >= 0 ? CCNOmode : CCZmode)" [(set (match_dup 0) @@ -19934,7 +20050,8 @@ "! TARGET_PARTIAL_REG_STALL && reload_completed && (GET_MODE (operands[0]) == HImode || (GET_MODE (operands[0]) == QImode - && (TARGET_PROMOTE_QImode || optimize_size)))" + && (TARGET_PROMOTE_QImode + || optimize_insn_for_size_p ())))" [(parallel [(set (match_dup 0) (neg:SI (match_dup 1))) (clobber (reg:CC FLAGS_REG))])] @@ -19947,7 +20064,8 @@ "! TARGET_PARTIAL_REG_STALL && reload_completed && (GET_MODE (operands[0]) == HImode || (GET_MODE (operands[0]) == QImode - && (TARGET_PROMOTE_QImode || optimize_size)))" + && (TARGET_PROMOTE_QImode + || optimize_insn_for_size_p ())))" [(set (match_dup 0) (not:SI (match_dup 1)))] "operands[0] = gen_lowpart (SImode, operands[0]); @@ -19962,7 +20080,8 @@ "! TARGET_PARTIAL_REG_STALL && TARGET_CMOVE && (GET_MODE (operands[0]) == HImode || (GET_MODE (operands[0]) == QImode - && (TARGET_PROMOTE_QImode || optimize_size)))" + && (TARGET_PROMOTE_QImode + || optimize_insn_for_size_p ())))" [(set (match_dup 0) (if_then_else:SI (match_dup 1) (match_dup 2) (match_dup 3)))] "operands[0] = gen_lowpart (SImode, operands[0]); @@ -19978,7 +20097,7 @@ [(set (match_operand:SI 0 "push_operand" "") (match_operand:SI 1 "memory_operand" "")) (match_scratch:SI 2 "r")] - "!optimize_size && !TARGET_PUSH_MEMORY + "optimize_insn_for_speed_p () && !TARGET_PUSH_MEMORY && !RTX_FRAME_RELATED_P (peep2_next_insn (0))" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] @@ -19988,7 +20107,7 @@ [(set (match_operand:DI 0 "push_operand" "") (match_operand:DI 1 "memory_operand" "")) (match_scratch:DI 2 "r")] - "!optimize_size && !TARGET_PUSH_MEMORY + "optimize_insn_for_speed_p () && !TARGET_PUSH_MEMORY && !RTX_FRAME_RELATED_P (peep2_next_insn (0))" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] @@ -20000,7 +20119,7 @@ [(set (match_operand:SF 0 "push_operand" "") (match_operand:SF 1 "memory_operand" "")) (match_scratch:SF 2 "r")] - "!optimize_size && !TARGET_PUSH_MEMORY + "optimize_insn_for_speed_p () && !TARGET_PUSH_MEMORY && !RTX_FRAME_RELATED_P (peep2_next_insn (0))" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] @@ -20010,7 +20129,7 @@ [(set (match_operand:HI 0 "push_operand" "") (match_operand:HI 1 "memory_operand" "")) (match_scratch:HI 2 "r")] - "!optimize_size && !TARGET_PUSH_MEMORY + "optimize_insn_for_speed_p () && !TARGET_PUSH_MEMORY && !RTX_FRAME_RELATED_P (peep2_next_insn (0))" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] @@ -20020,7 +20139,7 @@ [(set (match_operand:QI 0 "push_operand" "") (match_operand:QI 1 "memory_operand" "")) (match_scratch:QI 2 "q")] - "!optimize_size && !TARGET_PUSH_MEMORY + "optimize_insn_for_speed_p () && !TARGET_PUSH_MEMORY && !RTX_FRAME_RELATED_P (peep2_next_insn (0))" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] @@ -20032,10 +20151,10 @@ [(match_scratch:SI 1 "r") (set (match_operand:SI 0 "memory_operand" "") (const_int 0))] - "! optimize_size + "optimize_insn_for_speed_p () && ! TARGET_USE_MOV0 && TARGET_SPLIT_LONG_MOVES - && get_attr_length (insn) >= ix86_cost->large_insn + && get_attr_length (insn) >= ix86_cur_cost ()->large_insn && peep2_regno_dead_p (0, FLAGS_REG)" [(parallel [(set (match_dup 1) (const_int 0)) (clobber (reg:CC FLAGS_REG))]) @@ -20046,10 +20165,10 @@ [(match_scratch:HI 1 "r") (set (match_operand:HI 0 "memory_operand" "") (const_int 0))] - "! optimize_size + "optimize_insn_for_speed_p () && ! TARGET_USE_MOV0 && TARGET_SPLIT_LONG_MOVES - && get_attr_length (insn) >= ix86_cost->large_insn + && get_attr_length (insn) >= ix86_cur_cost ()->large_insn && peep2_regno_dead_p (0, FLAGS_REG)" [(parallel [(set (match_dup 2) (const_int 0)) (clobber (reg:CC FLAGS_REG))]) @@ -20060,10 +20179,10 @@ [(match_scratch:QI 1 "q") (set (match_operand:QI 0 "memory_operand" "") (const_int 0))] - "! optimize_size + "optimize_insn_for_speed_p () && ! TARGET_USE_MOV0 && TARGET_SPLIT_LONG_MOVES - && get_attr_length (insn) >= ix86_cost->large_insn + && get_attr_length (insn) >= ix86_cur_cost ()->large_insn && peep2_regno_dead_p (0, FLAGS_REG)" [(parallel [(set (match_dup 2) (const_int 0)) (clobber (reg:CC FLAGS_REG))]) @@ -20074,9 +20193,9 @@ [(match_scratch:SI 2 "r") (set (match_operand:SI 0 "memory_operand" "") (match_operand:SI 1 "immediate_operand" ""))] - "! optimize_size + "optimize_insn_for_speed_p () && TARGET_SPLIT_LONG_MOVES - && get_attr_length (insn) >= ix86_cost->large_insn" + && get_attr_length (insn) >= ix86_cur_cost ()->large_insn" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] "") @@ -20085,9 +20204,9 @@ [(match_scratch:HI 2 "r") (set (match_operand:HI 0 "memory_operand" "") (match_operand:HI 1 "immediate_operand" ""))] - "! optimize_size + "optimize_insn_for_speed_p () && TARGET_SPLIT_LONG_MOVES - && get_attr_length (insn) >= ix86_cost->large_insn" + && get_attr_length (insn) >= ix86_cur_cost ()->large_insn" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] "") @@ -20096,9 +20215,9 @@ [(match_scratch:QI 2 "q") (set (match_operand:QI 0 "memory_operand" "") (match_operand:QI 1 "immediate_operand" ""))] - "! optimize_size + "optimize_insn_for_speed_p () && TARGET_SPLIT_LONG_MOVES - && get_attr_length (insn) >= ix86_cost->large_insn" + && get_attr_length (insn) >= ix86_cur_cost ()->large_insn" [(set (match_dup 2) (match_dup 1)) (set (match_dup 0) (match_dup 2))] "") @@ -20110,7 +20229,7 @@ [(match_operand:SI 2 "memory_operand" "") (const_int 0)])) (match_scratch:SI 3 "r")] - " ! optimize_size && ix86_match_ccmode (insn, CCNOmode)" + "optimize_insn_for_speed_p () && ix86_match_ccmode (insn, CCNOmode)" [(set (match_dup 3) (match_dup 2)) (set (match_dup 0) (match_op_dup 1 [(match_dup 3) (const_int 0)]))] "") @@ -20129,7 +20248,7 @@ (define_peephole2 [(set (match_operand:SI 0 "nonimmediate_operand" "") (not:SI (match_operand:SI 1 "nonimmediate_operand" "")))] - "!optimize_size + "optimize_insn_for_speed_p () && ((TARGET_NOT_UNPAIRABLE && (!MEM_P (operands[0]) || !memory_displacement_operand (operands[0], SImode))) @@ -20143,7 +20262,7 @@ (define_peephole2 [(set (match_operand:HI 0 "nonimmediate_operand" "") (not:HI (match_operand:HI 1 "nonimmediate_operand" "")))] - "!optimize_size + "optimize_insn_for_speed_p () && ((TARGET_NOT_UNPAIRABLE && (!MEM_P (operands[0]) || !memory_displacement_operand (operands[0], HImode))) @@ -20157,7 +20276,7 @@ (define_peephole2 [(set (match_operand:QI 0 "nonimmediate_operand" "") (not:QI (match_operand:QI 1 "nonimmediate_operand" "")))] - "!optimize_size + "optimize_insn_for_speed_p () && ((TARGET_NOT_UNPAIRABLE && (!MEM_P (operands[0]) || !memory_displacement_operand (operands[0], QImode))) @@ -20256,7 +20375,7 @@ [(match_dup 0) (match_operand:SI 1 "memory_operand" "")])) (clobber (reg:CC FLAGS_REG))])] - "! optimize_size && ! TARGET_READ_MODIFY" + "optimize_insn_for_speed_p ()" [(set (match_dup 2) (match_dup 1)) (parallel [(set (match_dup 0) (match_op_dup 3 [(match_dup 0) (match_dup 2)])) @@ -20270,7 +20389,7 @@ [(match_operand:SI 1 "memory_operand" "") (match_dup 0)])) (clobber (reg:CC FLAGS_REG))])] - "! optimize_size && ! TARGET_READ_MODIFY" + "optimize_insn_for_speed_p () && ! TARGET_READ_MODIFY" [(set (match_dup 2) (match_dup 1)) (parallel [(set (match_dup 0) (match_op_dup 3 [(match_dup 2) (match_dup 0)])) @@ -20290,7 +20409,7 @@ [(match_dup 0) (match_operand:SI 1 "nonmemory_operand" "")])) (clobber (reg:CC FLAGS_REG))])] - "! optimize_size && ! TARGET_READ_MODIFY_WRITE" + "optimize_insn_for_speed_p () && ! TARGET_READ_MODIFY_WRITE" [(set (match_dup 2) (match_dup 0)) (parallel [(set (match_dup 2) (match_op_dup 3 [(match_dup 2) (match_dup 1)])) @@ -20305,7 +20424,7 @@ [(match_operand:SI 1 "nonmemory_operand" "") (match_dup 0)])) (clobber (reg:CC FLAGS_REG))])] - "! optimize_size && ! TARGET_READ_MODIFY_WRITE" + "optimize_insn_for_speed_p () && ! TARGET_READ_MODIFY_WRITE" [(set (match_dup 2) (match_dup 0)) (parallel [(set (match_dup 2) (match_op_dup 3 [(match_dup 1) (match_dup 2)])) @@ -20318,7 +20437,7 @@ [(set (match_operand 0 "register_operand" "") (match_operand 1 "const0_operand" ""))] "GET_MODE_SIZE (GET_MODE (operands[0])) <= UNITS_PER_WORD - && (! TARGET_USE_MOV0 || optimize_size) + && (! TARGET_USE_MOV0 || optimize_insn_for_size_p ()) && GENERAL_REG_P (operands[0]) && peep2_regno_dead_p (0, FLAGS_REG)" [(parallel [(set (match_dup 0) (const_int 0)) @@ -20332,7 +20451,7 @@ (const_int 0))] "(GET_MODE (operands[0]) == QImode || GET_MODE (operands[0]) == HImode) - && (! TARGET_USE_MOV0 || optimize_size) + && (! TARGET_USE_MOV0 || optimize_insn_for_size_p ()) && peep2_regno_dead_p (0, FLAGS_REG)" [(parallel [(set (strict_low_part (match_dup 0)) (const_int 0)) (clobber (reg:CC FLAGS_REG))])]) @@ -20344,7 +20463,7 @@ "(GET_MODE (operands[0]) == HImode || GET_MODE (operands[0]) == SImode || (GET_MODE (operands[0]) == DImode && TARGET_64BIT)) - && (optimize_size || TARGET_MOVE_M1_VIA_OR) + && (optimize_insn_for_size_p () || TARGET_MOVE_M1_VIA_OR) && peep2_regno_dead_p (0, FLAGS_REG)" [(parallel [(set (match_dup 0) (const_int -1)) (clobber (reg:CC FLAGS_REG))])] @@ -20435,7 +20554,7 @@ (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_SUB_ESP_4" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_4" [(clobber (match_dup 0)) (parallel [(set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 0)) (clobber (mem:BLK (scratch)))])]) @@ -20445,7 +20564,7 @@ (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -8))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_SUB_ESP_8" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_8" [(clobber (match_dup 0)) (set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 0)) (parallel [(set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 0)) @@ -20456,7 +20575,7 @@ [(match_scratch:SI 0 "r") (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -4))) (clobber (reg:CC FLAGS_REG))])] - "optimize_size || !TARGET_SUB_ESP_4" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_4" [(clobber (match_dup 0)) (set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 0))]) @@ -20464,7 +20583,7 @@ [(match_scratch:SI 0 "r") (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int -8))) (clobber (reg:CC FLAGS_REG))])] - "optimize_size || !TARGET_SUB_ESP_8" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_8" [(clobber (match_dup 0)) (set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 0)) (set (mem:SI (pre_dec:SI (reg:SI SP_REG))) (match_dup 0))]) @@ -20475,7 +20594,7 @@ (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_ADD_ESP_4" + "optimize_insn_for_size_p () || !TARGET_ADD_ESP_4" [(parallel [(set (match_dup 0) (mem:SI (reg:SI SP_REG))) (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4))) (clobber (mem:BLK (scratch)))])] @@ -20489,7 +20608,7 @@ (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 8))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_ADD_ESP_8" + "optimize_insn_for_size_p () || !TARGET_ADD_ESP_8" [(parallel [(set (match_dup 0) (mem:SI (reg:SI SP_REG))) (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4))) (clobber (mem:BLK (scratch)))]) @@ -20502,7 +20621,7 @@ (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 8))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size" + "optimize_insn_for_size_p ()" [(parallel [(set (match_dup 0) (mem:SI (reg:SI SP_REG))) (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4))) (clobber (mem:BLK (scratch)))]) @@ -20538,7 +20657,7 @@ [(match_scratch:SI 0 "r") (parallel [(set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 8))) (clobber (reg:CC FLAGS_REG))])] - "optimize_size" + "optimize_insn_for_size_p ()" [(parallel [(set (match_dup 0) (mem:SI (reg:SI SP_REG))) (set (reg:SI SP_REG) (plus:SI (reg:SI SP_REG) (const_int 4)))]) (parallel [(set (match_dup 0) (mem:SI (reg:SI SP_REG))) @@ -20567,7 +20686,7 @@ (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_SUB_ESP_4" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_4" [(clobber (match_dup 0)) (parallel [(set (mem:DI (pre_dec:DI (reg:DI SP_REG))) (match_dup 0)) (clobber (mem:BLK (scratch)))])]) @@ -20577,7 +20696,7 @@ (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -16))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_SUB_ESP_8" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_8" [(clobber (match_dup 0)) (set (mem:DI (pre_dec:DI (reg:DI SP_REG))) (match_dup 0)) (parallel [(set (mem:DI (pre_dec:DI (reg:DI SP_REG))) (match_dup 0)) @@ -20588,7 +20707,7 @@ [(match_scratch:DI 0 "r") (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -8))) (clobber (reg:CC FLAGS_REG))])] - "optimize_size || !TARGET_SUB_ESP_4" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_4" [(clobber (match_dup 0)) (set (mem:DI (pre_dec:DI (reg:DI SP_REG))) (match_dup 0))]) @@ -20596,7 +20715,7 @@ [(match_scratch:DI 0 "r") (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int -16))) (clobber (reg:CC FLAGS_REG))])] - "optimize_size || !TARGET_SUB_ESP_8" + "optimize_insn_for_size_p () || !TARGET_SUB_ESP_8" [(clobber (match_dup 0)) (set (mem:DI (pre_dec:DI (reg:DI SP_REG))) (match_dup 0)) (set (mem:DI (pre_dec:DI (reg:DI SP_REG))) (match_dup 0))]) @@ -20607,7 +20726,7 @@ (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 8))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_ADD_ESP_4" + "optimize_insn_for_size_p () || !TARGET_ADD_ESP_4" [(parallel [(set (match_dup 0) (mem:DI (reg:DI SP_REG))) (set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 8))) (clobber (mem:BLK (scratch)))])] @@ -20621,7 +20740,7 @@ (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 16))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size || !TARGET_ADD_ESP_8" + "optimize_insn_for_size_p () || !TARGET_ADD_ESP_8" [(parallel [(set (match_dup 0) (mem:DI (reg:DI SP_REG))) (set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 8))) (clobber (mem:BLK (scratch)))]) @@ -20634,7 +20753,7 @@ (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 16))) (clobber (reg:CC FLAGS_REG)) (clobber (mem:BLK (scratch)))])] - "optimize_size" + "optimize_insn_for_size_p ()" [(parallel [(set (match_dup 0) (mem:DI (reg:DI SP_REG))) (set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 8))) (clobber (mem:BLK (scratch)))]) @@ -20670,7 +20789,7 @@ [(match_scratch:DI 0 "r") (parallel [(set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 16))) (clobber (reg:CC FLAGS_REG))])] - "optimize_size" + "optimize_insn_for_size_p ()" [(parallel [(set (match_dup 0) (mem:DI (reg:DI SP_REG))) (set (reg:DI SP_REG) (plus:DI (reg:DI SP_REG) (const_int 8)))]) (parallel [(set (match_dup 0) (mem:DI (reg:DI SP_REG))) @@ -20698,7 +20817,7 @@ (mult:SI (match_operand:SI 1 "nonimmediate_operand" "") (match_operand:SI 2 "const_int_operand" ""))) (clobber (reg:CC FLAGS_REG))])] - "!optimize_size + "optimize_insn_for_speed_p () && (INTVAL (operands[2]) == 3 || INTVAL (operands[2]) == 5 || INTVAL (operands[2]) == 9)" @@ -20730,7 +20849,7 @@ (match_operand:DI 2 "const_int_operand" ""))) (clobber (reg:CC FLAGS_REG))])] "TARGET_64BIT - && !optimize_size + && optimize_insn_for_speed_p () && (INTVAL (operands[2]) == 3 || INTVAL (operands[2]) == 5 || INTVAL (operands[2]) == 9)" @@ -20748,7 +20867,7 @@ (mult:DI (match_operand:DI 1 "memory_operand" "") (match_operand:DI 2 "immediate_operand" ""))) (clobber (reg:CC FLAGS_REG))])] - "TARGET_SLOW_IMUL_IMM32_MEM && !optimize_size + "TARGET_SLOW_IMUL_IMM32_MEM && optimize_insn_for_speed_p () && !satisfies_constraint_K (operands[2])" [(set (match_dup 3) (match_dup 1)) (parallel [(set (match_dup 0) (mult:DI (match_dup 3) (match_dup 2))) @@ -20761,7 +20880,7 @@ (mult:SI (match_operand:SI 1 "memory_operand" "") (match_operand:SI 2 "immediate_operand" ""))) (clobber (reg:CC FLAGS_REG))])] - "TARGET_SLOW_IMUL_IMM32_MEM && !optimize_size + "TARGET_SLOW_IMUL_IMM32_MEM && optimize_insn_for_speed_p () && !satisfies_constraint_K (operands[2])" [(set (match_dup 3) (match_dup 1)) (parallel [(set (match_dup 0) (mult:SI (match_dup 3) (match_dup 2))) @@ -20775,7 +20894,7 @@ (mult:SI (match_operand:SI 1 "memory_operand" "") (match_operand:SI 2 "immediate_operand" "")))) (clobber (reg:CC FLAGS_REG))])] - "TARGET_SLOW_IMUL_IMM32_MEM && !optimize_size + "TARGET_SLOW_IMUL_IMM32_MEM && optimize_insn_for_speed_p () && !satisfies_constraint_K (operands[2])" [(set (match_dup 3) (match_dup 1)) (parallel [(set (match_dup 0) (zero_extend:DI (mult:SI (match_dup 3) (match_dup 2)))) @@ -20792,7 +20911,7 @@ (match_operand:DI 2 "const_int_operand" ""))) (clobber (reg:CC FLAGS_REG))]) (match_scratch:DI 3 "r")] - "TARGET_SLOW_IMUL_IMM8 && !optimize_size + "TARGET_SLOW_IMUL_IMM8 && optimize_insn_for_speed_p () && satisfies_constraint_K (operands[2])" [(set (match_dup 3) (match_dup 2)) (parallel [(set (match_dup 0) (mult:DI (match_dup 0) (match_dup 3))) @@ -20808,7 +20927,7 @@ (match_operand:SI 2 "const_int_operand" ""))) (clobber (reg:CC FLAGS_REG))]) (match_scratch:SI 3 "r")] - "TARGET_SLOW_IMUL_IMM8 && !optimize_size + "TARGET_SLOW_IMUL_IMM8 && optimize_insn_for_speed_p () && satisfies_constraint_K (operands[2])" [(set (match_dup 3) (match_dup 2)) (parallel [(set (match_dup 0) (mult:SI (match_dup 0) (match_dup 3))) @@ -20824,7 +20943,7 @@ (match_operand:HI 2 "immediate_operand" ""))) (clobber (reg:CC FLAGS_REG))]) (match_scratch:HI 3 "r")] - "TARGET_SLOW_IMUL_IMM8 && !optimize_size" + "TARGET_SLOW_IMUL_IMM8 && optimize_insn_for_speed_p ()" [(set (match_dup 3) (match_dup 2)) (parallel [(set (match_dup 0) (mult:HI (match_dup 0) (match_dup 3))) (clobber (reg:CC FLAGS_REG))])] diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index baa9976d400..c8bf42d8193 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -210,6 +210,18 @@ DONE; }) +(define_insn "sse2_movq128" + [(set (match_operand:V2DI 0 "register_operand" "=x") + (vec_concat:V2DI + (vec_select:DI + (match_operand:V2DI 1 "nonimmediate_operand" "xm") + (parallel [(const_int 0)])) + (const_int 0)))] + "TARGET_SSE2" + "movq\t{%1, %0|%0, %1}" + [(set_attr "type" "ssemov") + (set_attr "mode" "TI")]) + (define_insn "<sse>_movup<ssemodesuffixf2c>" [(set (match_operand:SSEMODEF2P 0 "nonimmediate_operand" "=x,m") (unspec:SSEMODEF2P @@ -4940,26 +4952,25 @@ (set_attr "mode" "TI,V4SF,V2SF")]) (define_insn "vec_concatv2di" - [(set (match_operand:V2DI 0 "register_operand" "=Y2 ,?Y2,Y2,x,x,x") + [(set (match_operand:V2DI 0 "register_operand" "=Y2 ,?Y2,Y2,x,x") (vec_concat:V2DI - (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0,m") - (match_operand:DI 2 "vector_move_operand" " C , C,Y2,x,m,0")))] + (match_operand:DI 1 "nonimmediate_operand" " mY2,*y ,0 ,0,0") + (match_operand:DI 2 "vector_move_operand" " C , C,Y2,x,m")))] "!TARGET_64BIT && TARGET_SSE" "@ movq\t{%1, %0|%0, %1} movq2dq\t{%1, %0|%0, %1} punpcklqdq\t{%2, %0|%0, %2} movlhps\t{%2, %0|%0, %2} - movhps\t{%2, %0|%0, %2} - movlps\t{%1, %0|%0, %1}" - [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov,ssemov") - (set_attr "mode" "TI,TI,TI,V4SF,V2SF,V2SF")]) + movhps\t{%2, %0|%0, %2}" + [(set_attr "type" "ssemov,ssemov,sselog,ssemov,ssemov") + (set_attr "mode" "TI,TI,TI,V4SF,V2SF")]) (define_insn "*vec_concatv2di_rex64_sse4_1" - [(set (match_operand:V2DI 0 "register_operand" "=x ,x ,Yi,!x,x,x,x,x") + [(set (match_operand:V2DI 0 "register_operand" "=x ,x ,Yi,!x,x,x,x") (vec_concat:V2DI - (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0,m") - (match_operand:DI 2 "vector_move_operand" " rm,C ,C ,C ,x,x,m,0")))] + (match_operand:DI 1 "nonimmediate_operand" " 0 ,mx,r ,*y,0,0,0") + (match_operand:DI 2 "vector_move_operand" " rm,C ,C ,C ,x,x,m")))] "TARGET_64BIT && TARGET_SSE4_1" "@ pinsrq\t{$0x1, %2, %0|%0, %2, 0x1} @@ -4968,17 +4979,16 @@ movq2dq\t{%1, %0|%0, %1} punpcklqdq\t{%2, %0|%0, %2} movlhps\t{%2, %0|%0, %2} - movhps\t{%2, %0|%0, %2} - movlps\t{%1, %0|%0, %1}" - [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov,ssemov") - (set_attr "prefix_extra" "1,*,*,*,*,*,*,*") - (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF,V2SF")]) + movhps\t{%2, %0|%0, %2}" + [(set_attr "type" "sselog,ssemov,ssemov,ssemov,sselog,ssemov,ssemov") + (set_attr "prefix_extra" "1,*,*,*,*,*,*") + (set_attr "mode" "TI,TI,TI,TI,TI,V4SF,V2SF")]) (define_insn "*vec_concatv2di_rex64_sse" - [(set (match_operand:V2DI 0 "register_operand" "=Y2 ,Yi,!Y2,Y2,x,x,x") + [(set (match_operand:V2DI 0 "register_operand" "=Y2 ,Yi,!Y2,Y2,x,x") (vec_concat:V2DI - (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0,m") - (match_operand:DI 2 "vector_move_operand" " C ,C ,C ,Y2,x,m,0")))] + (match_operand:DI 1 "nonimmediate_operand" " mY2,r ,*y ,0 ,0,0") + (match_operand:DI 2 "vector_move_operand" " C ,C ,C ,Y2,x,m")))] "TARGET_64BIT && TARGET_SSE" "@ movq\t{%1, %0|%0, %1} @@ -4986,10 +4996,9 @@ movq2dq\t{%1, %0|%0, %1} punpcklqdq\t{%2, %0|%0, %2} movlhps\t{%2, %0|%0, %2} - movhps\t{%2, %0|%0, %2} - movlps\t{%1, %0|%0, %1}" - [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov,ssemov") - (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF,V2SF")]) + movhps\t{%2, %0|%0, %2}" + [(set_attr "type" "ssemov,ssemov,ssemov,sselog,ssemov,ssemov") + (set_attr "mode" "TI,TI,TI,TI,V4SF,V2SF")]) (define_expand "vec_unpacku_hi_v16qi" [(match_operand:V8HI 0 "register_operand" "") diff --git a/gcc/config/i386/winnt.c b/gcc/config/i386/winnt.c index 7fdd89471a8..8ef79058a7d 100644 --- a/gcc/config/i386/winnt.c +++ b/gcc/config/i386/winnt.c @@ -531,16 +531,16 @@ i386_pe_asm_output_aligned_decl_common (FILE *stream, tree decl, /* Mark a function appropriately. This should only be called for functions for which we are not emitting COFF debugging information. FILE is the assembler output file, NAME is the name of the - function, and PUBLIC is nonzero if the function is globally + function, and PUB is nonzero if the function is globally visible. */ void -i386_pe_declare_function_type (FILE *file, const char *name, int public) +i386_pe_declare_function_type (FILE *file, const char *name, int pub) { fprintf (file, "\t.def\t"); assemble_name (file, name); fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n", - public ? (int) C_EXT : (int) C_STAT, + pub ? (int) C_EXT : (int) C_STAT, (int) DT_FCN << N_BTSHFT); } diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index c07b21d9d53..e8a853bb256 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -4958,13 +4958,13 @@ ia64_register_move_cost (enum machine_mode mode, enum reg_class from, return 2; } -/* Implement PREFERRED_RELOAD_CLASS. Place additional restrictions on CLASS +/* Implement PREFERRED_RELOAD_CLASS. Place additional restrictions on RCLASS to use when copying X into that class. */ enum reg_class -ia64_preferred_reload_class (rtx x, enum reg_class class) +ia64_preferred_reload_class (rtx x, enum reg_class rclass) { - switch (class) + switch (rclass) { case FR_REGS: case FP_REGS: @@ -4989,16 +4989,16 @@ ia64_preferred_reload_class (rtx x, enum reg_class class) break; } - return class; + return rclass; } /* This function returns the register class required for a secondary - register when copying between one of the registers in CLASS, and X, + register when copying between one of the registers in RCLASS, and X, using MODE. A return value of NO_REGS means that no secondary register is required. */ enum reg_class -ia64_secondary_reload_class (enum reg_class class, +ia64_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) { int regno = -1; @@ -5006,7 +5006,7 @@ ia64_secondary_reload_class (enum reg_class class, if (GET_CODE (x) == REG || GET_CODE (x) == SUBREG) regno = true_regnum (x); - switch (class) + switch (rclass) { case BR_REGS: case AR_M_REGS: @@ -9571,7 +9571,7 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function) { - rtx this, insn, funexp; + rtx this_rtx, insn, funexp; unsigned int this_parmno; unsigned int this_regno; rtx delta_rtx; @@ -9600,7 +9600,7 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, if (!TARGET_REG_NAMES) reg_names[this_regno] = ia64_reg_numbers[this_parmno]; - this = gen_rtx_REG (Pmode, this_regno); + this_rtx = gen_rtx_REG (Pmode, this_regno); /* Apply the constant offset, if required. */ delta_rtx = GEN_INT (delta); @@ -9610,11 +9610,11 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, REG_POINTER (tmp) = 1; if (delta && satisfies_constraint_I (delta_rtx)) { - emit_insn (gen_ptr_extend_plus_imm (this, tmp, delta_rtx)); + emit_insn (gen_ptr_extend_plus_imm (this_rtx, tmp, delta_rtx)); delta = 0; } else - emit_insn (gen_ptr_extend (this, tmp)); + emit_insn (gen_ptr_extend (this_rtx, tmp)); } if (delta) { @@ -9624,7 +9624,7 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, emit_move_insn (tmp, delta_rtx); delta_rtx = tmp; } - emit_insn (gen_adddi3 (this, this, delta_rtx)); + emit_insn (gen_adddi3 (this_rtx, this_rtx, delta_rtx)); } /* Apply the offset from the vtable, if required. */ @@ -9637,7 +9637,7 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, { rtx t = gen_rtx_REG (ptr_mode, 2); REG_POINTER (t) = 1; - emit_move_insn (t, gen_rtx_MEM (ptr_mode, this)); + emit_move_insn (t, gen_rtx_MEM (ptr_mode, this_rtx)); if (satisfies_constraint_I (vcall_offset_rtx)) { emit_insn (gen_ptr_extend_plus_imm (tmp, t, vcall_offset_rtx)); @@ -9647,7 +9647,7 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, emit_insn (gen_ptr_extend (tmp, t)); } else - emit_move_insn (tmp, gen_rtx_MEM (Pmode, this)); + emit_move_insn (tmp, gen_rtx_MEM (Pmode, this_rtx)); if (vcall_offset) { @@ -9665,7 +9665,7 @@ ia64_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED, else emit_move_insn (tmp, gen_rtx_MEM (Pmode, tmp)); - emit_insn (gen_adddi3 (this, this, tmp)); + emit_insn (gen_adddi3 (this_rtx, this_rtx, tmp)); } /* Generate a tail call to the target function. */ diff --git a/gcc/config/iq2000/iq2000.c b/gcc/config/iq2000/iq2000.c index b66a485dbb1..06c187bc451 100644 --- a/gcc/config/iq2000/iq2000.c +++ b/gcc/config/iq2000/iq2000.c @@ -937,15 +937,15 @@ gen_int_relational (enum rtx_code test_code, rtx result, rtx cmp0, rtx cmp1, { if (p_info->const_add != 0) { - HOST_WIDE_INT new = INTVAL (cmp1) + p_info->const_add; + HOST_WIDE_INT new_const = INTVAL (cmp1) + p_info->const_add; /* If modification of cmp1 caused overflow, we would get the wrong answer if we follow the usual path; thus, x > 0xffffffffU would turn into x > 0U. */ if ((p_info->unsignedp - ? (unsigned HOST_WIDE_INT) new > + ? (unsigned HOST_WIDE_INT) new_const > (unsigned HOST_WIDE_INT) INTVAL (cmp1) - : new > INTVAL (cmp1)) + : new_const > INTVAL (cmp1)) != (p_info->const_add > 0)) { /* This test is always true, but if INVERT is true then @@ -955,7 +955,7 @@ gen_int_relational (enum rtx_code test_code, rtx result, rtx cmp0, rtx cmp1, return result; } else - cmp1 = GEN_INT (new); + cmp1 = GEN_INT (new_const); } } diff --git a/gcc/config/iq2000/iq2000.h b/gcc/config/iq2000/iq2000.h index f5574e4d757..f99a85d9593 100644 --- a/gcc/config/iq2000/iq2000.h +++ b/gcc/config/iq2000/iq2000.h @@ -128,8 +128,6 @@ #define PCC_BITFIELD_TYPE_MATTERS 1 -#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT - /* Layout of Source Language Data Types. */ diff --git a/gcc/config/m32c/m32c.c b/gcc/config/m32c/m32c.c index 0e03c9e6bf2..dcd5b374f93 100644 --- a/gcc/config/m32c/m32c.c +++ b/gcc/config/m32c/m32c.c @@ -340,36 +340,36 @@ classes_intersect (int class1, int class2) /* Used by m32c_register_move_cost to determine if a move is impossibly expensive. */ static int -class_can_hold_mode (int class, enum machine_mode mode) +class_can_hold_mode (int rclass, enum machine_mode mode) { /* Cache the results: 0=untested 1=no 2=yes */ static char results[LIM_REG_CLASSES][MAX_MACHINE_MODE]; - if (results[class][mode] == 0) + if (results[rclass][mode] == 0) { int r, n, i; - results[class][mode] = 1; + results[rclass][mode] = 1; for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) - if (class_contents[class][0] & (1 << r) + if (class_contents[rclass][0] & (1 << r) && HARD_REGNO_MODE_OK (r, mode)) { int ok = 1; n = HARD_REGNO_NREGS (r, mode); for (i = 1; i < n; i++) - if (!(class_contents[class][0] & (1 << (r + i)))) + if (!(class_contents[rclass][0] & (1 << (r + i)))) ok = 0; if (ok) { - results[class][mode] = 2; + results[rclass][mode] = 2; break; } } } #if DEBUG0 fprintf (stderr, "class %s can hold %s? %s\n", - class_names[class], mode_name[mode], - (results[class][mode] == 2) ? "yes" : "no"); + class_names[rclass], mode_name[mode], + (results[rclass][mode] == 2) ? "yes" : "no"); #endif - return results[class][mode] == 2; + return results[rclass][mode] == 2; } /* Run-time Target Specification. */ @@ -4298,22 +4298,22 @@ m32c_compare_redundant (rtx cmp, rtx *operands) char * m32c_output_compare (rtx insn, rtx *operands) { - static char template[] = ";cmp.b\t%1,%0"; + static char templ[] = ";cmp.b\t%1,%0"; /* ^ 5 */ - template[5] = " bwll"[GET_MODE_SIZE(GET_MODE(operands[0]))]; + templ[5] = " bwll"[GET_MODE_SIZE(GET_MODE(operands[0]))]; if (m32c_compare_redundant (insn, operands)) { #if DEBUG_CMP fprintf(stderr, "cbranch: cmp not needed\n"); #endif - return template; + return templ; } #if DEBUG_CMP - fprintf(stderr, "cbranch: cmp needed: `%s'\n", template); + fprintf(stderr, "cbranch: cmp needed: `%s'\n", templ); #endif - return template + 1; + return templ + 1; } #undef TARGET_ENCODE_SECTION_INFO diff --git a/gcc/config/m68hc11/m68hc11.c b/gcc/config/m68hc11/m68hc11.c index 314feb183a6..a52739be67e 100644 --- a/gcc/config/m68hc11/m68hc11.c +++ b/gcc/config/m68hc11/m68hc11.c @@ -435,7 +435,7 @@ m68hc11_hard_regno_rename_ok (int reg1, int reg2) } enum reg_class -preferred_reload_class (rtx operand, enum reg_class class) +preferred_reload_class (rtx operand, enum reg_class rclass) { enum machine_mode mode; @@ -443,97 +443,97 @@ preferred_reload_class (rtx operand, enum reg_class class) if (debug_m6811) { - printf ("Preferred reload: (class=%s): ", reg_class_names[class]); + printf ("Preferred reload: (class=%s): ", reg_class_names[rclass]); } - if (class == D_OR_A_OR_S_REGS && SP_REG_P (operand)) + if (rclass == D_OR_A_OR_S_REGS && SP_REG_P (operand)) return m68hc11_base_reg_class; - if (class >= S_REGS && (GET_CODE (operand) == MEM + if (rclass >= S_REGS && (GET_CODE (operand) == MEM || GET_CODE (operand) == CONST_INT)) { /* S_REGS class must not be used. The movhi template does not work to move a memory to a soft register. Restrict to a hard reg. */ - switch (class) + switch (rclass) { default: case G_REGS: case D_OR_A_OR_S_REGS: - class = A_OR_D_REGS; + rclass = A_OR_D_REGS; break; case A_OR_S_REGS: - class = A_REGS; + rclass = A_REGS; break; case D_OR_SP_OR_S_REGS: - class = D_OR_SP_REGS; + rclass = D_OR_SP_REGS; break; case D_OR_Y_OR_S_REGS: - class = D_OR_Y_REGS; + rclass = D_OR_Y_REGS; break; case D_OR_X_OR_S_REGS: - class = D_OR_X_REGS; + rclass = D_OR_X_REGS; break; case SP_OR_S_REGS: - class = SP_REGS; + rclass = SP_REGS; break; case Y_OR_S_REGS: - class = Y_REGS; + rclass = Y_REGS; break; case X_OR_S_REGS: - class = X_REGS; + rclass = X_REGS; break; case D_OR_S_REGS: - class = D_REGS; + rclass = D_REGS; } } - else if (class == Y_REGS && GET_CODE (operand) == MEM) + else if (rclass == Y_REGS && GET_CODE (operand) == MEM) { - class = Y_REGS; + rclass = Y_REGS; } - else if (class == A_OR_D_REGS && GET_MODE_SIZE (mode) == 4) + else if (rclass == A_OR_D_REGS && GET_MODE_SIZE (mode) == 4) { - class = D_OR_X_REGS; + rclass = D_OR_X_REGS; } - else if (class >= S_REGS && S_REG_P (operand)) + else if (rclass >= S_REGS && S_REG_P (operand)) { - switch (class) + switch (rclass) { default: case G_REGS: case D_OR_A_OR_S_REGS: - class = A_OR_D_REGS; + rclass = A_OR_D_REGS; break; case A_OR_S_REGS: - class = A_REGS; + rclass = A_REGS; break; case D_OR_SP_OR_S_REGS: - class = D_OR_SP_REGS; + rclass = D_OR_SP_REGS; break; case D_OR_Y_OR_S_REGS: - class = D_OR_Y_REGS; + rclass = D_OR_Y_REGS; break; case D_OR_X_OR_S_REGS: - class = D_OR_X_REGS; + rclass = D_OR_X_REGS; break; case SP_OR_S_REGS: - class = SP_REGS; + rclass = SP_REGS; break; case Y_OR_S_REGS: - class = Y_REGS; + rclass = Y_REGS; break; case X_OR_S_REGS: - class = X_REGS; + rclass = X_REGS; break; case D_OR_S_REGS: - class = D_REGS; + rclass = D_REGS; } } - else if (class >= S_REGS) + else if (rclass >= S_REGS) { if (debug_m6811) { - printf ("Class = %s for: ", reg_class_names[class]); + printf ("Class = %s for: ", reg_class_names[rclass]); fflush (stdout); debug_rtx (operand); } @@ -541,12 +541,12 @@ preferred_reload_class (rtx operand, enum reg_class class) if (debug_m6811) { - printf (" => class=%s\n", reg_class_names[class]); + printf (" => class=%s\n", reg_class_names[rclass]); fflush (stdout); debug_rtx (operand); } - return class; + return rclass; } /* Return 1 if the operand is a valid indexed addressing mode. @@ -5097,10 +5097,10 @@ m68hc11_init_libfuncs (void) /* Cost of moving memory. */ int -m68hc11_memory_move_cost (enum machine_mode mode, enum reg_class class, +m68hc11_memory_move_cost (enum machine_mode mode, enum reg_class rclass, int in ATTRIBUTE_UNUSED) { - if (class <= H_REGS && class > NO_REGS) + if (rclass <= H_REGS && rclass > NO_REGS) { if (GET_MODE_SIZE (mode) <= 2) return COSTS_N_INSNS (1) + (reload_completed | reload_in_progress); diff --git a/gcc/config/mcore/mcore.c b/gcc/config/mcore/mcore.c index 227f7dcd8e8..b80f59f476c 100644 --- a/gcc/config/mcore/mcore.c +++ b/gcc/config/mcore/mcore.c @@ -2602,30 +2602,30 @@ mcore_r15_operand_p (rtx x) } } -/* Implement SECONDARY_RELOAD_CLASS. If CLASS contains r15, and we can't +/* Implement SECONDARY_RELOAD_CLASS. If RCLASS contains r15, and we can't directly move X into it, use r1-r14 as a temporary. */ enum reg_class -mcore_secondary_reload_class (enum reg_class class, +mcore_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) { - if (TEST_HARD_REG_BIT (reg_class_contents[class], 15) + if (TEST_HARD_REG_BIT (reg_class_contents[rclass], 15) && !mcore_r15_operand_p (x)) return LRW_REGS; return NO_REGS; } /* Return the reg_class to use when reloading the rtx X into the class - CLASS. If X is too complex to move directly into r15, prefer to + RCLASS. If X is too complex to move directly into r15, prefer to use LRW_REGS instead. */ enum reg_class -mcore_reload_class (rtx x, enum reg_class class) +mcore_reload_class (rtx x, enum reg_class rclass) { - if (reg_class_subset_p (LRW_REGS, class) && !mcore_r15_operand_p (x)) + if (reg_class_subset_p (LRW_REGS, rclass) && !mcore_r15_operand_p (x)) return LRW_REGS; - return class; + return rclass; } /* Tell me if a pair of reg/subreg rtx's actually refer to the same diff --git a/gcc/config/mips/constraints.md b/gcc/config/mips/constraints.md index 88fcbf65ef6..3a03a3cb633 100644 --- a/gcc/config/mips/constraints.md +++ b/gcc/config/mips/constraints.md @@ -43,8 +43,10 @@ (define_register_constraint "b" "ALL_REGS" "@internal") -(define_register_constraint "c" "TARGET_USE_PIC_FN_ADDR_REG ? PIC_FN_ADDR_REG - : TARGET_MIPS16 ? M16_NA_REGS +;; MIPS16 code always calls through a MIPS16 register; see mips_emit_call_insn +;; for details. +(define_register_constraint "c" "TARGET_MIPS16 ? M16_REGS + : TARGET_USE_PIC_FN_ADDR_REG ? PIC_FN_ADDR_REG : GR_REGS" "A register suitable for use in an indirect jump. This will always be @code{$25} for @option{-mabicalls}.") diff --git a/gcc/config/mips/linux-unwind.h b/gcc/config/mips/linux-unwind.h index 4e71182f5cf..818b436e360 100644 --- a/gcc/config/mips/linux-unwind.h +++ b/gcc/config/mips/linux-unwind.h @@ -106,12 +106,17 @@ mips_fallback_frame_state (struct _Unwind_Context *context, fs->regs.reg[i].loc.offset = (_Unwind_Ptr)&(sc->sc_regs[i]) + reg_offset - new_cfa; } - /* The PC points to the faulting instruction, but the unwind tables - expect it point to the following instruction. We compensate by - reporting a return address at the next instruction. */ + /* "PC & -2" points to the faulting instruction, but the unwind code + searches for "(ADDR & -2) - 1". (See MASK_RETURN_ADDR for the source + of the -2 mask.) Adding 2 here ensures that "(ADDR & -2) - 1" is the + address of the second byte of the faulting instruction. + + Note that setting fs->signal_frame would not work. As the comment + above MASK_RETURN_ADDR explains, MIPS unwinders must earch for an + odd-valued address. */ fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].how = REG_SAVED_VAL_OFFSET; fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].loc.offset - = (_Unwind_Ptr)(sc->sc_pc) + 4 - new_cfa; + = (_Unwind_Ptr)(sc->sc_pc) + 2 - new_cfa; fs->retaddr_column = DWARF_ALT_FRAME_RETURN_COLUMN; return _URC_NO_REASON; diff --git a/gcc/config/mips/linux.h b/gcc/config/mips/linux.h index 2e7b1028c6e..90cf63df23c 100644 --- a/gcc/config/mips/linux.h +++ b/gcc/config/mips/linux.h @@ -96,36 +96,6 @@ along with GCC; see the file COPYING3. If not see fputc ( '\n', FILE); \ } while (0) -#undef ASM_DECLARE_FUNCTION_NAME -#define ASM_DECLARE_FUNCTION_NAME(STREAM, NAME, DECL) \ - do { \ - if (!flag_inhibit_size_directive) \ - { \ - fputs ("\t.ent\t", STREAM); \ - assemble_name (STREAM, NAME); \ - putc ('\n', STREAM); \ - } \ - ASM_OUTPUT_TYPE_DIRECTIVE (STREAM, NAME, "function"); \ - assemble_name (STREAM, NAME); \ - fputs (":\n", STREAM); \ - } while (0) - -#undef ASM_DECLARE_FUNCTION_SIZE -#define ASM_DECLARE_FUNCTION_SIZE(STREAM, NAME, DECL) \ - do { \ - if (!flag_inhibit_size_directive) \ - { \ - fputs ("\t.end\t", STREAM); \ - assemble_name (STREAM, NAME); \ - putc ('\n', STREAM); \ - } \ - } while (0) - -/* Tell function_prologue in mips.c that we have already output the .ent/.end - pseudo-ops. */ -#undef FUNCTION_NAME_ALREADY_DECLARED -#define FUNCTION_NAME_ALREADY_DECLARED 1 - /* The glibc _mcount stub will save $v0 for us. Don't mess with saving it, since ASM_OUTPUT_REG_PUSH/ASM_OUTPUT_REG_POP do not work in the presence of $gp-relative calls. */ diff --git a/gcc/config/mips/mips-protos.h b/gcc/config/mips/mips-protos.h index d092cb6f5c1..01645a1ebc2 100644 --- a/gcc/config/mips/mips-protos.h +++ b/gcc/config/mips/mips-protos.h @@ -164,6 +164,22 @@ enum mips_loadgp_style { struct mips16e_save_restore_info; +/* Classifies a type of call. + + MIPS_CALL_NORMAL + A normal call or call_value pattern. + + MIPS_CALL_SIBCALL + A sibcall or sibcall_value pattern. + + MIPS_CALL_EPILOGUE + A call inserted in the epilogue. */ +enum mips_call_type { + MIPS_CALL_NORMAL, + MIPS_CALL_SIBCALL, + MIPS_CALL_EPILOGUE +}; + extern bool mips_symbolic_constant_p (rtx, enum mips_symbol_context, enum mips_symbol_type *); extern int mips_regno_mode_ok_for_base_p (int, enum machine_mode, bool); @@ -175,6 +191,8 @@ extern int mips_split_const_insns (rtx); extern int mips_load_store_insns (rtx, rtx); extern int mips_idiv_insns (void); extern rtx mips_emit_move (rtx, rtx); +extern rtx mips_pic_base_register (rtx); +extern rtx mips_got_load (rtx, rtx, enum mips_symbol_type); extern bool mips_split_symbol (rtx, rtx, enum machine_mode, rtx *); extern rtx mips_unspec_address (rtx, enum mips_symbol_type); extern bool mips_legitimize_address (rtx *, enum machine_mode); @@ -202,7 +220,7 @@ extern rtx mips_subword (rtx, bool); extern bool mips_split_64bit_move_p (rtx, rtx); extern void mips_split_doubleword_move (rtx, rtx); extern const char *mips_output_move (rtx, rtx); -extern void mips_restore_gp (void); +extern void mips_restore_gp (rtx); #ifdef RTX_CODE extern bool mips_expand_scc (enum rtx_code, rtx); extern void mips_expand_conditional_branch (rtx *, enum rtx_code); @@ -210,7 +228,9 @@ extern void mips_expand_vcondv2sf (rtx, rtx, rtx, enum rtx_code, rtx, rtx); extern void mips_expand_conditional_move (rtx *); extern void mips_expand_conditional_trap (enum rtx_code); #endif -extern rtx mips_expand_call (rtx, rtx, rtx, rtx, bool); +extern bool mips_use_pic_fn_addr_reg_p (const_rtx); +extern rtx mips_expand_call (enum mips_call_type, rtx, rtx, rtx, rtx, bool); +extern void mips_split_call (rtx, rtx); extern void mips_expand_fcc_reload (rtx, rtx, rtx); extern void mips_set_return_address (rtx, rtx); extern bool mips_expand_block_move (rtx, rtx, rtx); diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index c4006c2f616..48daec4175d 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -469,6 +469,10 @@ static GTY (()) int mips_output_filename_first_time = 1; mips_split_symbol. */ bool mips_split_p[NUM_SYMBOL_TYPES]; +/* mips_split_hi_p[X] is true if the high parts of symbols of type X + can be split by mips_split_symbol. */ +bool mips_split_hi_p[NUM_SYMBOL_TYPES]; + /* mips_lo_relocs[X] is the relocation to use when a symbol of type X appears in a LO_SUM. It can be null if such LO_SUMs aren't valid or if they are matched by a special .md file pattern. */ @@ -479,11 +483,11 @@ static const char *mips_hi_relocs[NUM_SYMBOL_TYPES]; /* Index R is the smallest register class that contains register R. */ const enum reg_class mips_regno_to_class[FIRST_PSEUDO_REGISTER] = { - LEA_REGS, LEA_REGS, M16_NA_REGS, V1_REG, + LEA_REGS, LEA_REGS, M16_REGS, V1_REG, M16_REGS, M16_REGS, M16_REGS, M16_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, - M16_NA_REGS, M16_NA_REGS, LEA_REGS, LEA_REGS, + M16_REGS, M16_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, T_REG, PIC_FN_ADDR_REG, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, LEA_REGS, @@ -1342,6 +1346,22 @@ mips_build_integer (struct mips_integer_op *codes, } } +/* Return true if symbols of type TYPE require a GOT access. */ + +static bool +mips_got_symbol_type_p (enum mips_symbol_type type) +{ + switch (type) + { + case SYMBOL_GOT_PAGE_OFST: + case SYMBOL_GOT_DISP: + return true; + + default: + return false; + } +} + /* Return true if X is a thread-local symbol. */ static bool @@ -1359,7 +1379,7 @@ mips_global_symbol_p (const_rtx x) const_tree decl = SYMBOL_REF_DECL (x); if (!decl) - return !SYMBOL_REF_LOCAL_P (x); + return !SYMBOL_REF_LOCAL_P (x) || SYMBOL_REF_EXTERNAL_P (x); /* Weakref symbols are not TREE_PUBLIC, but their targets are global or weak symbols. Relocations in the object file will be against @@ -1367,6 +1387,27 @@ mips_global_symbol_p (const_rtx x) return DECL_P (decl) && (TREE_PUBLIC (decl) || DECL_WEAK (decl)); } +/* Return true if function X is a libgcc MIPS16 stub function. */ + +static bool +mips16_stub_function_p (const_rtx x) +{ + return (GET_CODE (x) == SYMBOL_REF + && strncmp (XSTR (x, 0), "__mips16_", 9) == 0); +} + +/* Return true if function X is a locally-defined and locally-binding + MIPS16 function. */ + +static bool +mips16_local_function_p (const_rtx x) +{ + return (GET_CODE (x) == SYMBOL_REF + && SYMBOL_REF_LOCAL_P (x) + && !SYMBOL_REF_EXTERNAL_P (x) + && mips_use_mips16_mode_p (SYMBOL_REF_DECL (x))); +} + /* Return true if SYMBOL_REF X binds locally. */ static bool @@ -1401,6 +1442,29 @@ mips_dangerous_for_la25_p (rtx x) && mips_global_symbol_p (x)); } +/* Return true if calls to X might need $25 to be valid on entry. */ + +bool +mips_use_pic_fn_addr_reg_p (const_rtx x) +{ + if (!TARGET_USE_PIC_FN_ADDR_REG) + return false; + + /* MIPS16 stub functions are guaranteed not to use $25. */ + if (mips16_stub_function_p (x)) + return false; + + /* When TARGET_ABSOLUTE_ABICALLS is true, locally-defined functions + use absolute accesses to set up the global pointer. */ + if (TARGET_ABSOLUTE_ABICALLS + && GET_CODE (x) == SYMBOL_REF + && mips_symbol_binds_local_p (x) + && !SYMBOL_REF_EXTERNAL_P (x)) + return false; + + return true; +} + /* Return the method that should be used to access SYMBOL_REF or LABEL_REF X in context CONTEXT. */ @@ -1736,24 +1800,37 @@ mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED) static bool mips_cannot_force_const_mem (rtx x) { + enum mips_symbol_type type; rtx base, offset; - if (!TARGET_MIPS16) - { - /* As an optimization, reject constants that mips_legitimize_move - can expand inline. + /* There is no assembler syntax for expressing an address-sized + high part. */ + if (GET_CODE (x) == HIGH) + return true; + + /* As an optimization, reject constants that mips_legitimize_move + can expand inline. - Suppose we have a multi-instruction sequence that loads constant C - into register R. If R does not get allocated a hard register, and - R is used in an operand that allows both registers and memory - references, reload will consider forcing C into memory and using - one of the instruction's memory alternatives. Returning false - here will force it to use an input reload instead. */ - if (GET_CODE (x) == CONST_INT) + Suppose we have a multi-instruction sequence that loads constant C + into register R. If R does not get allocated a hard register, and + R is used in an operand that allows both registers and memory + references, reload will consider forcing C into memory and using + one of the instruction's memory alternatives. Returning false + here will force it to use an input reload instead. */ + if (GET_CODE (x) == CONST_INT && LEGITIMATE_CONSTANT_P (x)) + return true; + + split_const (x, &base, &offset); + if (mips_symbolic_constant_p (base, SYMBOL_CONTEXT_LEA, &type) + && type != SYMBOL_FORCE_TO_MEM) + { + /* The same optimization as for CONST_INT. */ + if (SMALL_INT (offset) && mips_symbol_insns (type, MAX_MACHINE_MODE) > 0) return true; - split_const (x, &base, &offset); - if (symbolic_operand (base, VOIDmode) && SMALL_INT (offset)) + /* If MIPS16 constant pools live in the text section, they should + not refer to anything that might need run-time relocation. */ + if (TARGET_MIPS16_PCREL_LOADS && mips_got_symbol_type_p (type)) return true; } @@ -2097,8 +2174,13 @@ mips_const_insns (rtx x) return mips_symbol_insns (symbol_type, MAX_MACHINE_MODE); /* Otherwise try splitting the constant into a base and offset. - 16-bit offsets can be added using an extra ADDIU. Larger offsets - must be calculated separately and then added to the base. */ + If the offset is a 16-bit value, we can load the base address + into a register and then use (D)ADDIU to add in the offset. + If the offset is larger, we can load the base and offset + into separate registers and add them together with (D)ADDU. + However, the latter is only possible before reload; during + and after reload, we must have the option of forcing the + constant into the pool instead. */ split_const (x, &x, &offset); if (offset != 0) { @@ -2107,7 +2189,7 @@ mips_const_insns (rtx x) { if (SMALL_INT (offset)) return n + 1; - else + else if (!targetm.cannot_force_const_mem (x)) return n + 1 + mips_build_integer (codes, INTVAL (offset)); } } @@ -2238,17 +2320,30 @@ mips_force_temporary (rtx dest, rtx value) /* Emit a call sequence with call pattern PATTERN and return the call instruction itself (which is not necessarily the last instruction - emitted). LAZY_P is true if the call address is lazily-bound. */ + emitted). ORIG_ADDR is the original, unlegitimized address, + ADDR is the legitimized form, and LAZY_P is true if the call + address is lazily-bound. */ static rtx -mips_emit_call_insn (rtx pattern, bool lazy_p) +mips_emit_call_insn (rtx pattern, rtx orig_addr, rtx addr, bool lazy_p) { - rtx insn; + rtx insn, reg; insn = emit_call_insn (pattern); - /* Lazy-binding stubs require $gp to be valid on entry. */ + if (TARGET_MIPS16 && mips_use_pic_fn_addr_reg_p (orig_addr)) + { + /* MIPS16 JALRs only take MIPS16 registers. If the target + function requires $25 to be valid on entry, we must copy it + there separately. The move instruction can be put in the + call's delay slot. */ + reg = gen_rtx_REG (Pmode, PIC_FUNCTION_ADDR_REGNUM); + emit_insn_before (gen_move_insn (reg, addr), insn); + use_reg (&CALL_INSN_FUNCTION_USAGE (insn), reg); + } + if (lazy_p) + /* Lazy-binding stubs require $gp to be valid on entry. */ use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx); if (TARGET_USE_GOT) @@ -2261,6 +2356,51 @@ mips_emit_call_insn (rtx pattern, bool lazy_p) return insn; } +/* Wrap symbol or label BASE in an UNSPEC address of type SYMBOL_TYPE, + then add CONST_INT OFFSET to the result. */ + +static rtx +mips_unspec_address_offset (rtx base, rtx offset, + enum mips_symbol_type symbol_type) +{ + base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base), + UNSPEC_ADDRESS_FIRST + symbol_type); + if (offset != const0_rtx) + base = gen_rtx_PLUS (Pmode, base, offset); + return gen_rtx_CONST (Pmode, base); +} + +/* Return an UNSPEC address with underlying address ADDRESS and symbol + type SYMBOL_TYPE. */ + +rtx +mips_unspec_address (rtx address, enum mips_symbol_type symbol_type) +{ + rtx base, offset; + + split_const (address, &base, &offset); + return mips_unspec_address_offset (base, offset, symbol_type); +} + +/* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the + high part to BASE and return the result. Just return BASE otherwise. + TEMP is as for mips_force_temporary. + + The returned expression can be used as the first operand to a LO_SUM. */ + +static rtx +mips_unspec_offset_high (rtx temp, rtx base, rtx addr, + enum mips_symbol_type symbol_type) +{ + if (mips_split_p[symbol_type]) + { + addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type)); + addr = mips_force_temporary (temp, addr); + base = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base)); + } + return base; +} + /* Return an instruction that copies $gp into register REG. We want GCC to treat the register's value as constant, so that its value can be rematerialized on demand. */ @@ -2289,21 +2429,17 @@ mips16_gp_pseudo_reg (void) if (!cfun->machine->initialized_mips16_gp_pseudo_p && (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl)) { - rtx insn, scan, after; + rtx insn, scan; + + push_topmost_sequence (); + + scan = get_insns (); + while (NEXT_INSN (scan) && !INSN_P (NEXT_INSN (scan))) + scan = NEXT_INSN (scan); insn = gen_load_const_gp (cfun->machine->mips16_gp_pseudo_rtx); + emit_insn_after (insn, scan); - push_topmost_sequence (); - /* We need to emit the initialization after the FUNCTION_BEG - note, so that it will be integrated. */ - after = get_insns (); - for (scan = after; scan != NULL_RTX; scan = NEXT_INSN (scan)) - if (NOTE_P (scan) && NOTE_KIND (scan) == NOTE_INSN_FUNCTION_BEG) - { - after = scan; - break; - } - insn = emit_insn_after (insn, after); pop_topmost_sequence (); cfun->machine->initialized_mips16_gp_pseudo_p = true; @@ -2312,17 +2448,74 @@ mips16_gp_pseudo_reg (void) return cfun->machine->mips16_gp_pseudo_rtx; } +/* Return a base register that holds pic_offset_table_rtx. + TEMP, if nonnull, is a scratch Pmode base register. */ + +rtx +mips_pic_base_register (rtx temp) +{ + if (!TARGET_MIPS16) + return pic_offset_table_rtx; + + if (can_create_pseudo_p ()) + return mips16_gp_pseudo_reg (); + + if (TARGET_USE_GOT) + /* The first post-reload split exposes all references to $gp + (both uses and definitions). All references must remain + explicit after that point. + + It is safe to introduce uses of $gp at any time, so for + simplicity, we do that before the split too. */ + mips_emit_move (temp, pic_offset_table_rtx); + else + emit_insn (gen_load_const_gp (temp)); + return temp; +} + +/* Create and return a GOT reference of type TYPE for address ADDR. + TEMP, if nonnull, is a scratch Pmode base register. */ + +rtx +mips_got_load (rtx temp, rtx addr, enum mips_symbol_type type) +{ + rtx base, high, lo_sum_symbol; + + base = mips_pic_base_register (temp); + + /* If we used the temporary register to load $gp, we can't use + it for the high part as well. */ + if (temp != NULL && reg_overlap_mentioned_p (base, temp)) + temp = NULL; + + high = mips_unspec_offset_high (temp, base, addr, type); + lo_sum_symbol = mips_unspec_address (addr, type); + + if (type == SYMBOL_GOTOFF_CALL) + return (Pmode == SImode + ? gen_unspec_callsi (high, lo_sum_symbol) + : gen_unspec_calldi (high, lo_sum_symbol)); + else + return (Pmode == SImode + ? gen_unspec_gotsi (high, lo_sum_symbol) + : gen_unspec_gotdi (high, lo_sum_symbol)); +} + /* If MODE is MAX_MACHINE_MODE, ADDR appears as a move operand, otherwise it appears in a MEM of that mode. Return true if ADDR is a legitimate - constant in that context and can be split into a high part and a LO_SUM. - If so, and if LO_SUM_OUT is nonnull, emit the high part and return - the LO_SUM in *LO_SUM_OUT. Leave *LO_SUM_OUT unchanged otherwise. + constant in that context and can be split into high and low parts. + If so, and if LOW_OUT is nonnull, emit the high part and store the + low part in *LOW_OUT. Leave *LOW_OUT unchanged otherwise. TEMP is as for mips_force_temporary and is used to load the high - part into a register. */ + part into a register. + + When MODE is MAX_MACHINE_MODE, the low part is guaranteed to be + a legitimize SET_SRC for an .md pattern, otherwise the low part + is guaranteed to be a legitimate address for mode MODE. */ bool -mips_split_symbol (rtx temp, rtx addr, enum machine_mode mode, rtx *lo_sum_out) +mips_split_symbol (rtx temp, rtx addr, enum machine_mode mode, rtx *low_out) { enum mips_symbol_context context; enum mips_symbol_type symbol_type; @@ -2331,76 +2524,56 @@ mips_split_symbol (rtx temp, rtx addr, enum machine_mode mode, rtx *lo_sum_out) context = (mode == MAX_MACHINE_MODE ? SYMBOL_CONTEXT_LEA : SYMBOL_CONTEXT_MEM); - if (!mips_symbolic_constant_p (addr, context, &symbol_type) - || mips_symbol_insns (symbol_type, mode) == 0 - || !mips_split_p[symbol_type]) - return false; - - if (lo_sum_out) + if (GET_CODE (addr) == HIGH && context == SYMBOL_CONTEXT_LEA) { - if (symbol_type == SYMBOL_GP_RELATIVE) - { - if (!can_create_pseudo_p ()) - { - emit_insn (gen_load_const_gp (temp)); - high = temp; - } - else - high = mips16_gp_pseudo_reg (); - } - else + addr = XEXP (addr, 0); + if (mips_symbolic_constant_p (addr, context, &symbol_type) + && mips_symbol_insns (symbol_type, mode) > 0 + && mips_split_hi_p[symbol_type]) { - high = gen_rtx_HIGH (Pmode, copy_rtx (addr)); - high = mips_force_temporary (temp, high); + if (low_out) + switch (symbol_type) + { + case SYMBOL_GOT_PAGE_OFST: + /* The high part of a page/ofst pair is loaded from the GOT. */ + *low_out = mips_got_load (temp, addr, SYMBOL_GOTOFF_PAGE); + break; + + default: + gcc_unreachable (); + } + return true; } - *lo_sum_out = gen_rtx_LO_SUM (Pmode, high, addr); } - return true; -} - -/* Wrap symbol or label BASE in an UNSPEC address of type SYMBOL_TYPE, - then add CONST_INT OFFSET to the result. */ - -static rtx -mips_unspec_address_offset (rtx base, rtx offset, - enum mips_symbol_type symbol_type) -{ - base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base), - UNSPEC_ADDRESS_FIRST + symbol_type); - if (offset != const0_rtx) - base = gen_rtx_PLUS (Pmode, base, offset); - return gen_rtx_CONST (Pmode, base); -} - -/* Return an UNSPEC address with underlying address ADDRESS and symbol - type SYMBOL_TYPE. */ - -rtx -mips_unspec_address (rtx address, enum mips_symbol_type symbol_type) -{ - rtx base, offset; - - split_const (address, &base, &offset); - return mips_unspec_address_offset (base, offset, symbol_type); -} - -/* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the - high part to BASE and return the result. Just return BASE otherwise. - TEMP is as for mips_force_temporary. + else + { + if (mips_symbolic_constant_p (addr, context, &symbol_type) + && mips_symbol_insns (symbol_type, mode) > 0 + && mips_split_p[symbol_type]) + { + if (low_out) + switch (symbol_type) + { + case SYMBOL_GOT_DISP: + /* SYMBOL_GOT_DISP symbols are loaded from the GOT. */ + *low_out = mips_got_load (temp, addr, SYMBOL_GOTOFF_DISP); + break; - The returned expression can be used as the first operand to a LO_SUM. */ + case SYMBOL_GP_RELATIVE: + high = mips_pic_base_register (temp); + *low_out = gen_rtx_LO_SUM (Pmode, high, addr); + break; -static rtx -mips_unspec_offset_high (rtx temp, rtx base, rtx addr, - enum mips_symbol_type symbol_type) -{ - if (mips_split_p[symbol_type]) - { - addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type)); - addr = mips_force_temporary (temp, addr); - base = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base)); + default: + high = gen_rtx_HIGH (Pmode, copy_rtx (addr)); + high = mips_force_temporary (temp, high); + *low_out = gen_rtx_LO_SUM (Pmode, high, addr); + break; + } + return true; + } } - return base; + return false; } /* Return a legitimate address for REG + OFFSET. TEMP is as for @@ -2457,7 +2630,8 @@ mips_call_tls_get_addr (rtx sym, enum mips_symbol_type type, rtx v0) emit_insn (gen_rtx_SET (Pmode, a0, gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, loc))); - insn = mips_expand_call (v0, mips_tls_symbol, const0_rtx, const0_rtx, false); + insn = mips_expand_call (MIPS_CALL_NORMAL, v0, mips_tls_symbol, + const0_rtx, NULL_RTX, false); RTL_CONST_CALL_P (insn) = 1; use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0); insn = get_insns (); @@ -2716,7 +2890,8 @@ mips_rewrite_small_data_p (rtx x, enum mips_symbol_context context) { enum mips_symbol_type symbol_type; - return (TARGET_EXPLICIT_RELOCS + return (mips_lo_relocs[SYMBOL_GP_RELATIVE] + && !mips_split_p[SYMBOL_GP_RELATIVE] && mips_symbolic_constant_p (x, context, &symbol_type) && symbol_type == SYMBOL_GP_RELATIVE); } @@ -5170,6 +5345,153 @@ mips_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p, return addr; } +/* Start a definition of function NAME. MIPS16_P indicates whether the + function contains MIPS16 code. */ + +static void +mips_start_function_definition (const char *name, bool mips16_p) +{ + if (mips16_p) + fprintf (asm_out_file, "\t.set\tmips16\n"); + else + fprintf (asm_out_file, "\t.set\tnomips16\n"); + + if (!flag_inhibit_size_directive) + { + fputs ("\t.ent\t", asm_out_file); + assemble_name (asm_out_file, name); + fputs ("\n", asm_out_file); + } + + ASM_OUTPUT_TYPE_DIRECTIVE (asm_out_file, name, "function"); + + /* Start the definition proper. */ + assemble_name (asm_out_file, name); + fputs (":\n", asm_out_file); +} + +/* End a function definition started by mips_start_function_definition. */ + +static void +mips_end_function_definition (const char *name) +{ + if (!flag_inhibit_size_directive) + { + fputs ("\t.end\t", asm_out_file); + assemble_name (asm_out_file, name); + fputs ("\n", asm_out_file); + } +} + +/* Return true if calls to X can use R_MIPS_CALL* relocations. */ + +static bool +mips_ok_for_lazy_binding_p (rtx x) +{ + return (TARGET_USE_GOT + && GET_CODE (x) == SYMBOL_REF + && !SYMBOL_REF_BIND_NOW_P (x) + && !mips_symbol_binds_local_p (x)); +} + +/* Load function address ADDR into register DEST. TYPE is as for + mips_expand_call. Return true if we used an explicit lazy-binding + sequence. */ + +static bool +mips_load_call_address (enum mips_call_type type, rtx dest, rtx addr) +{ + /* If we're generating PIC, and this call is to a global function, + try to allow its address to be resolved lazily. This isn't + possible for sibcalls when $gp is call-saved because the value + of $gp on entry to the stub would be our caller's gp, not ours. */ + if (TARGET_EXPLICIT_RELOCS + && !(type == MIPS_CALL_SIBCALL && TARGET_CALL_SAVED_GP) + && mips_ok_for_lazy_binding_p (addr)) + { + addr = mips_got_load (dest, addr, SYMBOL_GOTOFF_CALL); + emit_insn (gen_rtx_SET (VOIDmode, dest, addr)); + return true; + } + else + { + mips_emit_move (dest, addr); + return false; + } +} + +/* Each locally-defined hard-float MIPS16 function has a local symbol + associated with it. This hash table maps the function symbol (FUNC) + to the local symbol (LOCAL). */ +struct mips16_local_alias GTY(()) { + rtx func; + rtx local; +}; +static GTY ((param_is (struct mips16_local_alias))) htab_t mips16_local_aliases; + +/* Hash table callbacks for mips16_local_aliases. */ + +static hashval_t +mips16_local_aliases_hash (const void *entry) +{ + const struct mips16_local_alias *alias; + + alias = (const struct mips16_local_alias *) entry; + return htab_hash_string (XSTR (alias->func, 0)); +} + +static int +mips16_local_aliases_eq (const void *entry1, const void *entry2) +{ + const struct mips16_local_alias *alias1, *alias2; + + alias1 = (const struct mips16_local_alias *) entry1; + alias2 = (const struct mips16_local_alias *) entry2; + return rtx_equal_p (alias1->func, alias2->func); +} + +/* FUNC is the symbol for a locally-defined hard-float MIPS16 function. + Return a local alias for it, creating a new one if necessary. */ + +static rtx +mips16_local_alias (rtx func) +{ + struct mips16_local_alias *alias, tmp_alias; + void **slot; + + /* Create the hash table if this is the first call. */ + if (mips16_local_aliases == NULL) + mips16_local_aliases = htab_create_ggc (37, mips16_local_aliases_hash, + mips16_local_aliases_eq, NULL); + + /* Look up the function symbol, creating a new entry if need be. */ + tmp_alias.func = func; + slot = htab_find_slot (mips16_local_aliases, &tmp_alias, INSERT); + gcc_assert (slot != NULL); + + alias = (struct mips16_local_alias *) *slot; + if (alias == NULL) + { + const char *func_name, *local_name; + rtx local; + + /* Create a new SYMBOL_REF for the local symbol. The choice of + __fn_local_* is based on the __fn_stub_* names that we've + traditionally used for the non-MIPS16 stub. */ + func_name = targetm.strip_name_encoding (XSTR (func, 0)); + local_name = ACONCAT (("__fn_local_", func_name, NULL)); + local = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (local_name)); + SYMBOL_REF_FLAGS (local) = SYMBOL_REF_FLAGS (func) | SYMBOL_FLAG_LOCAL; + + /* Create a new structure to represent the mapping. */ + alias = GGC_NEW (struct mips16_local_alias); + alias->func = func; + alias->local = local; + *slot = alias; + } + return alias->local; +} + /* A chained list of functions for which mips16_build_call_stub has already generated a stub. NAME is the name of the function and FP_RET_P is true if the function returns a value in floating-point registers. */ @@ -5180,6 +5502,18 @@ struct mips16_stub { }; static struct mips16_stub *mips16_stubs; +/* Return a SYMBOL_REF for a MIPS16 function called NAME. */ + +static rtx +mips16_stub_function (const char *name) +{ + rtx x; + + x = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name)); + SYMBOL_REF_FLAGS (x) |= (SYMBOL_FLAG_EXTERNAL | SYMBOL_FLAG_FUNCTION); + return x; +} + /* Return the two-character string that identifies floating-point return mode MODE in the name of a MIPS16 function stub. */ @@ -5286,14 +5620,18 @@ mips_output_args_xfer (int fp_code, char direction) static void mips16_build_function_stub (void) { - const char *fnname, *separator; + const char *fnname, *alias_name, *separator; char *secname, *stubname; tree stubdecl; unsigned int f; + rtx symbol, alias; /* Create the name of the stub, and its unique section. */ - fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); - fnname = targetm.strip_name_encoding (fnname); + symbol = XEXP (DECL_RTL (current_function_decl), 0); + alias = mips16_local_alias (symbol); + + fnname = targetm.strip_name_encoding (XSTR (symbol, 0)); + alias_name = targetm.strip_name_encoding (XSTR (alias, 0)); secname = ACONCAT ((".mips16.fn.", fnname, NULL)); stubname = ACONCAT (("__fn_stub_", fnname, NULL)); @@ -5315,46 +5653,51 @@ mips16_build_function_stub (void) } fprintf (asm_out_file, ")\n"); - /* Write the preamble leading up to the function declaration. */ - fprintf (asm_out_file, "\t.set\tnomips16\n"); - switch_to_section (function_section (stubdecl)); - ASM_OUTPUT_ALIGN (asm_out_file, - floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT)); + /* Start the function definition. */ + assemble_start_function (stubdecl, stubname); + mips_start_function_definition (stubname, false); - /* ??? If FUNCTION_NAME_ALREADY_DECLARED is defined, then we are - within a .ent, and we cannot emit another .ent. */ - if (!FUNCTION_NAME_ALREADY_DECLARED) + /* If generating abicalls code, either set up the global pointer or + switch to absolute mode. */ + if (TARGET_ABSOLUTE_ABICALLS) + fprintf (asm_out_file, "\t.option\tpic0\n"); + else if (TARGET_ABICALLS) { - fputs ("\t.ent\t", asm_out_file); - assemble_name (asm_out_file, stubname); - fputs ("\n", asm_out_file); + output_asm_insn ("%(.cpload\t%^%)", NULL); + /* Emit an R_MIPS_NONE relocation to tell the linker what the + target function is. Use a local GOT access when loading the + symbol, to cut down on the number of unnecessary GOT entries + for stubs that aren't needed. */ + output_asm_insn (".reloc\t0,R_MIPS_NONE,%0", &symbol); + symbol = alias; } - /* Start the definition proper. */ - assemble_name (asm_out_file, stubname); - fputs (":\n", asm_out_file); - /* Load the address of the MIPS16 function into $at. Do this first so that targets with coprocessor interlocks can use an MFC1 to fill the delay slot. */ fprintf (asm_out_file, "\t.set\tnoat\n"); - fprintf (asm_out_file, "\tla\t%s,", reg_names[GP_REG_FIRST + 1]); - assemble_name (asm_out_file, fnname); - fprintf (asm_out_file, "\n"); + output_asm_insn ("la\t%@,%0", &symbol); /* Move the arguments from floating-point registers to general registers. */ mips_output_args_xfer (crtl->args.info.fp_code, 'f'); /* Jump to the MIPS16 function. */ - fprintf (asm_out_file, "\tjr\t%s\n", reg_names[GP_REG_FIRST + 1]); + output_asm_insn ("jr\t%@", NULL); fprintf (asm_out_file, "\t.set\tat\n"); - if (!FUNCTION_NAME_ALREADY_DECLARED) - { - fputs ("\t.end\t", asm_out_file); - assemble_name (asm_out_file, stubname); - fputs ("\n", asm_out_file); - } + if (TARGET_ABSOLUTE_ABICALLS) + fprintf (asm_out_file, "\t.option\tpic2\n"); + + mips_end_function_definition (stubname); + + /* If the linker needs to create a dynamic symbol for the target + function, it will associate the symbol with the stub (which, + unlike the target function, follows the proper calling conventions). + It is therefore useful to have a local alias for the target function, + so that it can still be identified as MIPS16 code. As an optimization, + this symbol can also be used for indirect MIPS16 references from + within this file. */ + ASM_OUTPUT_DEF (asm_out_file, alias_name, fnname); switch_to_section (function_section (current_function_decl)); } @@ -5366,31 +5709,46 @@ mips16_build_function_stub (void) static void mips16_copy_fpr_return_value (void) { - rtx fn, insn, arg, call; - tree id, return_type; + rtx fn, insn, retval; + tree return_type; enum machine_mode return_mode; + const char *name; return_type = DECL_RESULT (current_function_decl); return_mode = DECL_MODE (return_type); - id = get_identifier (ACONCAT (("__mips16_ret_", - mips16_call_stub_mode_suffix (return_mode), - NULL))); - fn = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (id)); - arg = gen_rtx_REG (return_mode, GP_RETURN); - call = gen_call_value_internal (arg, fn, const0_rtx); - insn = mips_emit_call_insn (call, false); - use_reg (&CALL_INSN_FUNCTION_USAGE (insn), arg); + name = ACONCAT (("__mips16_ret_", + mips16_call_stub_mode_suffix (return_mode), + NULL)); + fn = mips16_stub_function (name); + + /* The function takes arguments in $2 (and possibly $3), so calls + to it cannot be lazily bound. */ + SYMBOL_REF_FLAGS (fn) |= SYMBOL_FLAG_BIND_NOW; + + /* Model the call as something that takes the GPR return value as + argument and returns an "updated" value. */ + retval = gen_rtx_REG (return_mode, GP_RETURN); + insn = mips_expand_call (MIPS_CALL_EPILOGUE, retval, fn, + const0_rtx, NULL_RTX, false); + use_reg (&CALL_INSN_FUNCTION_USAGE (insn), retval); } -/* Consider building a stub for a MIPS16 call to function FN. +/* Consider building a stub for a MIPS16 call to function *FN_PTR. RETVAL is the location of the return value, or null if this is a "call" rather than a "call_value". ARGS_SIZE is the size of the arguments and FP_CODE is the code built by mips_function_arg; see the comment above CUMULATIVE_ARGS for details. - If a stub was needed, emit the call and return the call insn itself. - Return null otherwise. + There are three alternatives: + + - If a stub was needed, emit the call and return the call insn itself. + + - If we can avoid using a stub by redirecting the call, set *FN_PTR + to the new target and return null. + + - If *FN_PTR doesn't need a stub, return null and leave *FN_PTR + unmodified. A stub is needed for calls to functions that, in normal mode, receive arguments in FPRs or return values in FPRs. The stub @@ -5399,17 +5757,18 @@ mips16_copy_fpr_return_value (void) return value from its hard-float position to its soft-float position. - We emit a JAL to FN even when FN might need a stub. If FN turns out - to be to a non-MIPS16 function, the linker automatically redirects - the JAL to the stub, otherwise the JAL continues to call FN directly. */ + We can emit a JAL to *FN_PTR even when *FN_PTR might need a stub. + If *FN_PTR turns out to be to a non-MIPS16 function, the linker + automatically redirects the JAL to the stub, otherwise the JAL + continues to call FN directly. */ static rtx -mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) +mips16_build_call_stub (rtx retval, rtx *fn_ptr, rtx args_size, int fp_code) { const char *fnname; bool fp_ret_p; struct mips16_stub *l; - rtx insn; + rtx insn, fn; /* We don't need to do anything if we aren't in MIPS16 mode, or if we were invoked with the -msoft-float option. */ @@ -5428,8 +5787,8 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) /* We don't need to do anything if this is a call to a special MIPS16 support function. */ - if (GET_CODE (fn) == SYMBOL_REF - && strncmp (XSTR (fn, 0), "__mips16_", 9) == 0) + fn = *fn_ptr; + if (mips16_stub_function_p (fn)) return NULL_RTX; /* This code will only work for o32 and o64 abis. The other ABI's @@ -5439,11 +5798,20 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) /* If we're calling via a function pointer, use one of the magic libgcc.a stubs provided for each (FP_CODE, FP_RET_P) combination. Each stub expects the function address to arrive in register $2. */ - if (GET_CODE (fn) != SYMBOL_REF) + if (GET_CODE (fn) != SYMBOL_REF + || !call_insn_operand (fn, VOIDmode)) { char buf[30]; - tree id; - rtx stub_fn, insn; + rtx stub_fn, insn, addr; + bool lazy_p; + + /* If this is a locally-defined and locally-binding function, + avoid the stub by calling the local alias directly. */ + if (mips16_local_function_p (fn)) + { + *fn_ptr = mips16_local_alias (fn); + return NULL_RTX; + } /* Create a SYMBOL_REF for the libgcc.a function. */ if (fp_ret_p) @@ -5452,24 +5820,22 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) fp_code); else sprintf (buf, "__mips16_call_stub_%d", fp_code); - id = get_identifier (buf); - stub_fn = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (id)); + stub_fn = mips16_stub_function (buf); + + /* The function uses $2 as an argument, so calls to it + cannot be lazily bound. */ + SYMBOL_REF_FLAGS (stub_fn) |= SYMBOL_FLAG_BIND_NOW; /* Load the target function into $2. */ - mips_emit_move (gen_rtx_REG (Pmode, 2), fn); + addr = gen_rtx_REG (Pmode, GP_REG_FIRST + 2); + lazy_p = mips_load_call_address (MIPS_CALL_NORMAL, addr, fn); /* Emit the call. */ - if (retval == NULL_RTX) - insn = gen_call_internal (stub_fn, args_size); - else - insn = gen_call_value_internal (retval, stub_fn, args_size); - insn = mips_emit_call_insn (insn, false); + insn = mips_expand_call (MIPS_CALL_NORMAL, retval, stub_fn, + args_size, NULL_RTX, lazy_p); /* Tell GCC that this call does indeed use the value of $2. */ - CALL_INSN_FUNCTION_USAGE (insn) = - gen_rtx_EXPR_LIST (VOIDmode, - gen_rtx_USE (VOIDmode, gen_rtx_REG (Pmode, 2)), - CALL_INSN_FUNCTION_USAGE (insn)); + use_reg (&CALL_INSN_FUNCTION_USAGE (insn), addr); /* If we are handling a floating-point return value, we need to save $18 in the function prologue. Putting a note on the @@ -5479,8 +5845,8 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) if (fp_ret_p) CALL_INSN_FUNCTION_USAGE (insn) = gen_rtx_EXPR_LIST (VOIDmode, - gen_rtx_USE (VOIDmode, - gen_rtx_REG (word_mode, 18)), + gen_rtx_CLOBBER (VOIDmode, + gen_rtx_REG (word_mode, 18)), CALL_INSN_FUNCTION_USAGE (insn)); return insn; @@ -5534,19 +5900,9 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) } fprintf (asm_out_file, ")\n"); - /* Write the preamble leading up to the function declaration. */ - fprintf (asm_out_file, "\t.set\tnomips16\n"); + /* Start the function definition. */ assemble_start_function (stubdecl, stubname); - - if (!FUNCTION_NAME_ALREADY_DECLARED) - { - fputs ("\t.ent\t", asm_out_file); - assemble_name (asm_out_file, stubname); - fputs ("\n", asm_out_file); - - assemble_name (asm_out_file, stubname); - fputs (":\n", asm_out_file); - } + mips_start_function_definition (stubname, false); if (!fp_ret_p) { @@ -5554,8 +5910,13 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) first so that targets with coprocessor interlocks can use an MFC1 to fill the delay slot. */ fprintf (asm_out_file, "\t.set\tnoat\n"); - fprintf (asm_out_file, "\tla\t%s,%s\n", reg_names[GP_REG_FIRST + 1], - fnname); + if (TARGET_EXPLICIT_RELOCS) + { + output_asm_insn ("lui\t%^,%%hi(%0)", &fn); + output_asm_insn ("addiu\t%^,%^,%%lo(%0)", &fn); + } + else + output_asm_insn ("la\t%^,%0", &fn); } /* Move the arguments from general registers to floating-point @@ -5565,7 +5926,7 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) if (!fp_ret_p) { /* Jump to the previously-loaded address. */ - fprintf (asm_out_file, "\tjr\t%s\n", reg_names[GP_REG_FIRST + 1]); + output_asm_insn ("jr\t%^", NULL); fprintf (asm_out_file, "\t.set\tat\n"); } else @@ -5575,7 +5936,7 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) $18 is usually a call-saved register. */ fprintf (asm_out_file, "\tmove\t%s,%s\n", reg_names[GP_REG_FIRST + 18], reg_names[GP_REG_FIRST + 31]); - fprintf (asm_out_file, "\tjal\t%s\n", fnname); + output_asm_insn (MIPS_CALL ("jal", &fn, 0), &fn); /* Move the result from floating-point registers to general registers. */ @@ -5621,12 +5982,7 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) ASM_DECLARE_FUNCTION_SIZE (asm_out_file, stubname, stubdecl); #endif - if (!FUNCTION_NAME_ALREADY_DECLARED) - { - fputs ("\t.end\t", asm_out_file); - assemble_name (asm_out_file, stubname); - fputs ("\n", asm_out_file); - } + mips_end_function_definition (stubname); /* Record this stub. */ l = XNEW (struct mips16_stub); @@ -5650,7 +6006,7 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) insn = gen_call_internal_direct (fn, args_size); else insn = gen_call_value_internal_direct (retval, fn, args_size); - insn = mips_emit_call_insn (insn, false); + insn = mips_emit_call_insn (insn, fn, fn, false); /* If we are calling a stub which handles a floating-point return value, we need to arrange to save $18 in the prologue. We do this @@ -5659,113 +6015,114 @@ mips16_build_call_stub (rtx retval, rtx fn, rtx args_size, int fp_code) if (fp_ret_p) CALL_INSN_FUNCTION_USAGE (insn) = gen_rtx_EXPR_LIST (VOIDmode, - gen_rtx_USE (VOIDmode, gen_rtx_REG (word_mode, 18)), + gen_rtx_CLOBBER (VOIDmode, + gen_rtx_REG (word_mode, 18)), CALL_INSN_FUNCTION_USAGE (insn)); return insn; } -/* Return true if calls to X can use R_MIPS_CALL* relocations. */ - -static bool -mips_ok_for_lazy_binding_p (rtx x) -{ - return (TARGET_USE_GOT - && GET_CODE (x) == SYMBOL_REF - && !mips_symbol_binds_local_p (x)); -} - -/* Load function address ADDR into register DEST. SIBCALL_P is true - if the address is needed for a sibling call. Return true if we - used an explicit lazy-binding sequence. */ - -static bool -mips_load_call_address (rtx dest, rtx addr, bool sibcall_p) -{ - /* If we're generating PIC, and this call is to a global function, - try to allow its address to be resolved lazily. This isn't - possible for sibcalls when $gp is call-saved because the value - of $gp on entry to the stub would be our caller's gp, not ours. */ - if (TARGET_EXPLICIT_RELOCS - && !(sibcall_p && TARGET_CALL_SAVED_GP) - && mips_ok_for_lazy_binding_p (addr)) - { - rtx high, lo_sum_symbol; - - high = mips_unspec_offset_high (dest, pic_offset_table_rtx, - addr, SYMBOL_GOTOFF_CALL); - lo_sum_symbol = mips_unspec_address (addr, SYMBOL_GOTOFF_CALL); - if (Pmode == SImode) - emit_insn (gen_load_callsi (dest, high, lo_sum_symbol)); - else - emit_insn (gen_load_calldi (dest, high, lo_sum_symbol)); - return true; - } - else - { - mips_emit_move (dest, addr); - return false; - } -} - -/* Expand a "call", "sibcall", "call_value" or "sibcall_value" instruction. - RESULT is where the result will go (null for "call"s and "sibcall"s), - ADDR is the address of the function, ARGS_SIZE is the size of the - arguments and AUX is the value passed to us by mips_function_arg. - SIBCALL_P is true if we are expanding a sibling call, false if we're - expanding a normal call. +/* Expand a call of type TYPE. RESULT is where the result will go (null + for "call"s and "sibcall"s), ADDR is the address of the function, + ARGS_SIZE is the size of the arguments and AUX is the value passed + to us by mips_function_arg. LAZY_P is true if this call already + involves a lazily-bound function address (such as when calling + functions through a MIPS16 hard-float stub). Return the call itself. */ rtx -mips_expand_call (rtx result, rtx addr, rtx args_size, rtx aux, bool sibcall_p) +mips_expand_call (enum mips_call_type type, rtx result, rtx addr, + rtx args_size, rtx aux, bool lazy_p) { rtx orig_addr, pattern, insn; - bool lazy_p; + int fp_code; + fp_code = aux == 0 ? 0 : (int) GET_MODE (aux); + insn = mips16_build_call_stub (result, &addr, args_size, fp_code); + if (insn) + { + gcc_assert (!lazy_p && type == MIPS_CALL_NORMAL); + return insn; + } + ; orig_addr = addr; - lazy_p = false; if (!call_insn_operand (addr, VOIDmode)) { - addr = gen_reg_rtx (Pmode); - lazy_p = mips_load_call_address (addr, orig_addr, sibcall_p); + if (type == MIPS_CALL_EPILOGUE) + addr = MIPS_EPILOGUE_TEMP (Pmode); + else + addr = gen_reg_rtx (Pmode); + lazy_p |= mips_load_call_address (type, addr, orig_addr); } - insn = mips16_build_call_stub (result, addr, args_size, - aux == 0 ? 0 : (int) GET_MODE (aux)); - if (insn) + if (result == 0) { - gcc_assert (!sibcall_p && !lazy_p); - return insn; - } + rtx (*fn) (rtx, rtx); - if (result == 0) - pattern = (sibcall_p - ? gen_sibcall_internal (addr, args_size) - : gen_call_internal (addr, args_size)); + if (type == MIPS_CALL_EPILOGUE && TARGET_SPLIT_CALLS) + fn = gen_call_split; + else if (type == MIPS_CALL_SIBCALL) + fn = gen_sibcall_internal; + else + fn = gen_call_internal; + + pattern = fn (addr, args_size); + } else if (GET_CODE (result) == PARALLEL && XVECLEN (result, 0) == 2) { /* Handle return values created by mips_return_fpr_pair. */ + rtx (*fn) (rtx, rtx, rtx, rtx); rtx reg1, reg2; + if (type == MIPS_CALL_EPILOGUE && TARGET_SPLIT_CALLS) + fn = gen_call_value_multiple_split; + else if (type == MIPS_CALL_SIBCALL) + fn = gen_sibcall_value_multiple_internal; + else + fn = gen_call_value_multiple_internal; + reg1 = XEXP (XVECEXP (result, 0, 0), 0); reg2 = XEXP (XVECEXP (result, 0, 1), 0); - pattern = - (sibcall_p - ? gen_sibcall_value_multiple_internal (reg1, addr, args_size, reg2) - : gen_call_value_multiple_internal (reg1, addr, args_size, reg2)); + pattern = fn (reg1, addr, args_size, reg2); } else { + rtx (*fn) (rtx, rtx, rtx); + + if (type == MIPS_CALL_EPILOGUE && TARGET_SPLIT_CALLS) + fn = gen_call_value_split; + else if (type == MIPS_CALL_SIBCALL) + fn = gen_sibcall_value_internal; + else + fn = gen_call_value_internal; + /* Handle return values created by mips_return_fpr_single. */ if (GET_CODE (result) == PARALLEL && XVECLEN (result, 0) == 1) result = XEXP (XVECEXP (result, 0, 0), 0); - pattern = (sibcall_p - ? gen_sibcall_value_internal (result, addr, args_size) - : gen_call_value_internal (result, addr, args_size)); + pattern = fn (result, addr, args_size); } - return mips_emit_call_insn (pattern, lazy_p); + return mips_emit_call_insn (pattern, orig_addr, addr, lazy_p); +} + +/* Split call instruction INSN into a $gp-clobbering call and + (where necessary) an instruction to restore $gp from its save slot. + CALL_PATTERN is the pattern of the new call. */ + +void +mips_split_call (rtx insn, rtx call_pattern) +{ + rtx new_insn; + + new_insn = emit_call_insn (call_pattern); + CALL_INSN_FUNCTION_USAGE (new_insn) + = copy_rtx (CALL_INSN_FUNCTION_USAGE (insn)); + if (!find_reg_note (insn, REG_NORETURN, 0)) + /* Pick a temporary register that is suitable for both MIPS16 and + non-MIPS16 code. $4 and $5 are used for returning complex double + values in soft-float code, so $6 is the first suitable candidate. */ + mips_restore_gp (gen_rtx_REG (Pmode, GP_ARG_FIRST + 2)); } /* Implement TARGET_FUNCTION_OK_FOR_SIBCALL. */ @@ -6312,6 +6669,7 @@ static void mips_init_relocs (void) { memset (mips_split_p, '\0', sizeof (mips_split_p)); + memset (mips_split_hi_p, '\0', sizeof (mips_split_hi_p)); memset (mips_hi_relocs, '\0', sizeof (mips_hi_relocs)); memset (mips_lo_relocs, '\0', sizeof (mips_lo_relocs)); @@ -6353,13 +6711,13 @@ mips_init_relocs (void) mips_split_p[SYMBOL_GP_RELATIVE] = true; mips_lo_relocs[SYMBOL_GP_RELATIVE] = "%gprel("; } + else if (TARGET_EXPLICIT_RELOCS) + /* Small data constants are kept whole until after reload, + then lowered by mips_rewrite_small_data. */ + mips_lo_relocs[SYMBOL_GP_RELATIVE] = "%gp_rel("; if (TARGET_EXPLICIT_RELOCS) { - /* Small data constants are kept whole until after reload, - then lowered by mips_rewrite_small_data. */ - mips_lo_relocs[SYMBOL_GP_RELATIVE] = "%gp_rel("; - mips_split_p[SYMBOL_GOT_PAGE_OFST] = true; if (TARGET_NEWABI) { @@ -6371,6 +6729,9 @@ mips_init_relocs (void) mips_lo_relocs[SYMBOL_GOTOFF_PAGE] = "%got("; mips_lo_relocs[SYMBOL_GOT_PAGE_OFST] = "%lo("; } + if (TARGET_MIPS16) + /* Expose the use of $28 as soon as possible. */ + mips_split_hi_p[SYMBOL_GOT_PAGE_OFST] = true; if (TARGET_XGOT) { @@ -6392,6 +6753,9 @@ mips_init_relocs (void) else mips_lo_relocs[SYMBOL_GOTOFF_DISP] = "%got("; mips_lo_relocs[SYMBOL_GOTOFF_CALL] = "%call16("; + if (TARGET_MIPS16) + /* Expose the use of $28 as soon as possible. */ + mips_split_p[SYMBOL_GOT_DISP] = true; } } @@ -7881,6 +8245,19 @@ mips_function_has_gp_insn (void) return cfun->machine->has_gp_insn_p; } +/* Return true if the current function returns its value in a floating-point + register in MIPS16 mode. */ + +static bool +mips16_cfun_returns_in_fpr_p (void) +{ + tree return_type = DECL_RESULT (current_function_decl); + return (TARGET_MIPS16 + && TARGET_HARD_FLOAT_ABI + && !aggregate_value_p (return_type, current_function_decl) + && mips_return_mode_in_fpr_p (DECL_MODE (return_type))); +} + /* Return the register that should be used as the global pointer within this function. Return 0 if the function doesn't need a global pointer. */ @@ -7923,6 +8300,7 @@ mips_global_pointer (void) but no instruction will yet refer to it. */ if (!df_regs_ever_live_p (GLOBAL_POINTER_REGNUM) && !crtl->uses_const_pool + && !mips16_cfun_returns_in_fpr_p () && !mips_function_has_gp_insn ()) return 0; @@ -7939,19 +8317,6 @@ mips_global_pointer (void) return GLOBAL_POINTER_REGNUM; } -/* Return true if the current function returns its value in a floating-point - register in MIPS16 mode. */ - -static bool -mips16_cfun_returns_in_fpr_p (void) -{ - tree return_type = DECL_RESULT (current_function_decl); - return (TARGET_MIPS16 - && TARGET_HARD_FLOAT_ABI - && !aggregate_value_p (return_type, current_function_decl) - && mips_return_mode_in_fpr_p (DECL_MODE (return_type))); -} - /* Return true if the current function must save register REGNO. */ static bool @@ -8258,6 +8623,11 @@ mips_extra_live_on_entry (bitmap regs) if (!TARGET_ABSOLUTE_ABICALLS) bitmap_set_bit (regs, PIC_FUNCTION_ADDR_REGNUM); + /* The prologue may set MIPS16_PIC_TEMP_REGNUM to the value of + the global pointer. */ + if (TARGET_MIPS16) + bitmap_set_bit (regs, MIPS16_PIC_TEMP_REGNUM); + /* See the comment above load_call<mode> for details. */ bitmap_set_bit (regs, GOT_VERSION_REGNUM); } @@ -8290,20 +8660,45 @@ mips_set_return_address (rtx address, rtx scratch) mips_emit_move (gen_frame_mem (GET_MODE (address), slot_address), address); } -/* Restore $gp from its save slot. Valid only when using o32 or - o64 abicalls. */ +/* Return a MEM rtx for the cprestore slot, using TEMP as a temporary base + register if need be. */ -void -mips_restore_gp (void) +static rtx +mips_cprestore_slot (rtx temp) { - rtx base, address; + const struct mips_frame_info *frame; + rtx base; + HOST_WIDE_INT offset; + + frame = &cfun->machine->frame; + if (frame_pointer_needed) + { + base = hard_frame_pointer_rtx; + offset = frame->args_size - frame->hard_frame_pointer_offset; + } + else + { + base = stack_pointer_rtx; + offset = frame->args_size; + } + return gen_frame_mem (Pmode, mips_add_offset (temp, base, offset)); +} +/* Restore $gp from its save slot, using TEMP as a temporary base register + if need be. This function is for o32 and o64 abicalls only. */ + +void +mips_restore_gp (rtx temp) +{ gcc_assert (TARGET_ABICALLS && TARGET_OLDABI); - base = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx; - address = mips_add_offset (pic_offset_table_rtx, base, - crtl->outgoing_args_size); - mips_emit_move (pic_offset_table_rtx, gen_frame_mem (Pmode, address)); + if (TARGET_MIPS16) + { + mips_emit_move (temp, mips_cprestore_slot (temp)); + mips_emit_move (pic_offset_table_rtx, temp); + } + else + mips_emit_move (pic_offset_table_rtx, mips_cprestore_slot (temp)); if (!TARGET_EXPLICIT_RELOCS) emit_insn (gen_blockage ()); } @@ -8395,29 +8790,11 @@ mips_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) && crtl->args.info.fp_code != 0) mips16_build_function_stub (); - /* Select the MIPS16 mode for this function. */ - if (TARGET_MIPS16) - fprintf (file, "\t.set\tmips16\n"); - else - fprintf (file, "\t.set\tnomips16\n"); - - if (!FUNCTION_NAME_ALREADY_DECLARED) - { - /* Get the function name the same way that toplev.c does before calling - assemble_start_function. This is needed so that the name used here - exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ - fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); - - if (!flag_inhibit_size_directive) - { - fputs ("\t.ent\t", file); - assemble_name (file, fnname); - fputs ("\n", file); - } - - assemble_name (file, fnname); - fputs (":\n", file); - } + /* Get the function name the same way that toplev.c does before calling + assemble_start_function. This is needed so that the name used here + exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ + fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); + mips_start_function_definition (fnname, TARGET_MIPS16); /* Stop mips_file_end from treating this function as external. */ if (TARGET_IRIX && mips_abi == ABI_32) @@ -8463,8 +8840,18 @@ mips_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) that need it. */ if (mips_current_loadgp_style () == LOADGP_OLDABI) { + if (TARGET_MIPS16) + { + /* This is a fixed-form sequence. The position of the + first two instructions is important because of the + way _gp_disp is defined. */ + output_asm_insn ("li\t$2,%%hi(_gp_disp)", 0); + output_asm_insn ("addiu\t$3,$pc,%%lo(_gp_disp)", 0); + output_asm_insn ("sll\t$2,16", 0); + output_asm_insn ("addu\t$2,$3", 0); + } /* .cpload must be in a .set noreorder but not a .set nomacro block. */ - if (!cfun->machine->all_noreorder_p) + else if (!cfun->machine->all_noreorder_p) output_asm_insn ("%(.cpload\t%^%)", 0); else output_asm_insn ("%(.cpload\t%^\n\t%<", 0); @@ -8484,6 +8871,8 @@ static void mips_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED, HOST_WIDE_INT size ATTRIBUTE_UNUSED) { + const char *fnname; + /* Reinstate the normal $gp. */ SET_REGNO (pic_offset_table_rtx, GLOBAL_POINTER_REGNUM); mips_output_cplocal (); @@ -8496,18 +8885,11 @@ mips_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED, set_noreorder = set_nomacro = 0; } - if (!FUNCTION_NAME_ALREADY_DECLARED && !flag_inhibit_size_directive) - { - const char *fnname; - - /* Get the function name the same way that toplev.c does before calling - assemble_start_function. This is needed so that the name used here - exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ - fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); - fputs ("\t.end\t", file); - assemble_name (file, fnname); - fputs ("\n", file); - } + /* Get the function name the same way that toplev.c does before calling + assemble_start_function. This is needed so that the name used here + exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ + fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); + mips_end_function_definition (fnname); } /* Save register REG to MEM. Make the instruction frame-related. */ @@ -8561,7 +8943,7 @@ mips_emit_loadgp (void) { rtx addr, offset, incoming_address, base, index, pic_reg; - pic_reg = pic_offset_table_rtx; + pic_reg = TARGET_MIPS16 ? MIPS16_PIC_TEMP : pic_offset_table_rtx; switch (mips_current_loadgp_style ()) { case LOADGP_ABSOLUTE: @@ -8575,6 +8957,10 @@ mips_emit_loadgp (void) : gen_loadgp_absolute_di (pic_reg, mips_gnu_local_gp)); break; + case LOADGP_OLDABI: + /* Added by mips_output_function_prologue. */ + break; + case LOADGP_NEWABI: addr = XEXP (DECL_RTL (current_function_decl), 0); offset = mips_unspec_address (addr, SYMBOL_GOTOFF_LOADGP); @@ -8595,6 +8981,10 @@ mips_emit_loadgp (void) default: return; } + + if (TARGET_MIPS16) + emit_insn (gen_copygp_mips16 (pic_offset_table_rtx, pic_reg)); + /* Emit a blockage if there are implicit uses of the GP register. This includes profiled functions, because FUNCTION_PROFILE uses a jal macro. */ @@ -8730,7 +9120,13 @@ mips_expand_prologue (void) /* Initialize the $gp save slot. */ if (frame->cprestore_size > 0) - emit_insn (gen_cprestore (GEN_INT (crtl->outgoing_args_size))); + { + if (TARGET_MIPS16) + mips_emit_move (mips_cprestore_slot (MIPS_PROLOGUE_TEMP (Pmode)), + MIPS16_PIC_TEMP); + else + emit_insn (gen_cprestore (GEN_INT (frame->args_size))); + } /* If we are profiling, make sure no instructions are scheduled before the call to mcount. */ @@ -8952,7 +9348,7 @@ static bool mips_hard_regno_mode_ok_p (unsigned int regno, enum machine_mode mode) { unsigned int size; - enum mode_class class; + enum mode_class mclass; if (mode == CCV2mode) return (ISA_HAS_8CC @@ -8975,7 +9371,7 @@ mips_hard_regno_mode_ok_p (unsigned int regno, enum machine_mode mode) } size = GET_MODE_SIZE (mode); - class = GET_MODE_CLASS (mode); + mclass = GET_MODE_CLASS (mode); if (GP_REG_P (regno)) return ((regno - GP_REG_FIRST) & 1) == 0 || size <= UNITS_PER_WORD; @@ -8996,16 +9392,16 @@ mips_hard_regno_mode_ok_p (unsigned int regno, enum machine_mode mode) || mode == DImode)) return true; - if (class == MODE_FLOAT - || class == MODE_COMPLEX_FLOAT - || class == MODE_VECTOR_FLOAT) + if (mclass == MODE_FLOAT + || mclass == MODE_COMPLEX_FLOAT + || mclass == MODE_VECTOR_FLOAT) return size <= UNITS_PER_FPVALUE; /* Allow integer modes that fit into a single register. We need to put integers into FPRs when using instructions like CVT and TRUNC. There's no point allowing sizes smaller than a word, because the FPU has no appropriate load/store instructions. */ - if (class == MODE_INT) + if (mclass == MODE_INT) return size >= MIN_UNITS_PER_WORD && size <= UNITS_PER_FPREG; } @@ -9039,7 +9435,7 @@ mips_hard_regno_mode_ok_p (unsigned int regno, enum machine_mode mode) } if (ALL_COP_REG_P (regno)) - return class == MODE_INT && size <= UNITS_PER_WORD; + return mclass == MODE_INT && size <= UNITS_PER_WORD; if (regno == GOT_VERSION_REGNUM) return mode == SImode; @@ -9068,13 +9464,13 @@ mips_hard_regno_nregs (int regno, enum machine_mode mode) in mips_hard_regno_nregs. */ int -mips_class_max_nregs (enum reg_class class, enum machine_mode mode) +mips_class_max_nregs (enum reg_class rclass, enum machine_mode mode) { int size; HARD_REG_SET left; size = 0x8000; - COPY_HARD_REG_SET (left, reg_class_contents[(int) class]); + COPY_HARD_REG_SET (left, reg_class_contents[(int) rclass]); if (hard_reg_set_intersect_p (left, reg_class_contents[(int) ST_REGS])) { size = MIN (size, 4); @@ -9095,7 +9491,7 @@ mips_class_max_nregs (enum reg_class class, enum machine_mode mode) bool mips_cannot_change_mode_class (enum machine_mode from ATTRIBUTE_UNUSED, enum machine_mode to ATTRIBUTE_UNUSED, - enum reg_class class) + enum reg_class rclass) { /* There are several problems with changing the modes of values in floating-point registers: @@ -9118,7 +9514,7 @@ mips_cannot_change_mode_class (enum machine_mode from ATTRIBUTE_UNUSED, not ask it to treat the value as having a different format. We therefore disallow all mode changes involving FPRs. */ - return reg_classes_intersect_p (FP_REGS, class); + return reg_classes_intersect_p (FP_REGS, rclass); } /* Return true if moves in mode MODE can use the FPU's mov.fmt instruction. */ @@ -9157,22 +9553,22 @@ mips_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2) /* Implement PREFERRED_RELOAD_CLASS. */ enum reg_class -mips_preferred_reload_class (rtx x, enum reg_class class) +mips_preferred_reload_class (rtx x, enum reg_class rclass) { - if (mips_dangerous_for_la25_p (x) && reg_class_subset_p (LEA_REGS, class)) + if (mips_dangerous_for_la25_p (x) && reg_class_subset_p (LEA_REGS, rclass)) return LEA_REGS; - if (reg_class_subset_p (FP_REGS, class) + if (reg_class_subset_p (FP_REGS, rclass) && mips_mode_ok_for_mov_fmt_p (GET_MODE (x))) return FP_REGS; - if (reg_class_subset_p (GR_REGS, class)) - class = GR_REGS; + if (reg_class_subset_p (GR_REGS, rclass)) + rclass = GR_REGS; - if (TARGET_MIPS16 && reg_class_subset_p (M16_REGS, class)) - class = M16_REGS; + if (TARGET_MIPS16 && reg_class_subset_p (M16_REGS, rclass)) + rclass = M16_REGS; - return class; + return rclass; } /* Implement REGISTER_MOVE_COST. */ @@ -9234,13 +9630,13 @@ mips_register_move_cost (enum machine_mode mode, } /* Return the register class required for a secondary register when - copying between one of the registers in CLASS and value X, which + copying between one of the registers in RCLASS and value X, which has mode MODE. X is the source of the move if IN_P, otherwise it is the destination. Return NO_REGS if no secondary register is needed. */ enum reg_class -mips_secondary_reload_class (enum reg_class class, +mips_secondary_reload_class (enum reg_class rclass, enum machine_mode mode, rtx x, bool in_p) { int regno; @@ -9248,17 +9644,17 @@ mips_secondary_reload_class (enum reg_class class, /* If X is a constant that cannot be loaded into $25, it must be loaded into some other GPR. No other register class allows a direct move. */ if (mips_dangerous_for_la25_p (x)) - return reg_class_subset_p (class, LEA_REGS) ? NO_REGS : LEA_REGS; + return reg_class_subset_p (rclass, LEA_REGS) ? NO_REGS : LEA_REGS; regno = true_regnum (x); if (TARGET_MIPS16) { /* In MIPS16 mode, every move must involve a member of M16_REGS. */ - if (!reg_class_subset_p (class, M16_REGS) && !M16_REG_P (regno)) + if (!reg_class_subset_p (rclass, M16_REGS) && !M16_REG_P (regno)) return M16_REGS; /* We can't really copy to HI or LO at all in MIPS16 mode. */ - if (in_p ? reg_classes_intersect_p (class, ACC_REGS) : ACC_REG_P (regno)) + if (in_p ? reg_classes_intersect_p (rclass, ACC_REGS) : ACC_REG_P (regno)) return M16_REGS; return NO_REGS; @@ -9266,16 +9662,16 @@ mips_secondary_reload_class (enum reg_class class, /* Copying from accumulator registers to anywhere other than a general register requires a temporary general register. */ - if (reg_class_subset_p (class, ACC_REGS)) + if (reg_class_subset_p (rclass, ACC_REGS)) return GP_REG_P (regno) ? NO_REGS : GR_REGS; if (ACC_REG_P (regno)) - return reg_class_subset_p (class, GR_REGS) ? NO_REGS : GR_REGS; + return reg_class_subset_p (rclass, GR_REGS) ? NO_REGS : GR_REGS; /* We can only copy a value to a condition code register from a floating-point register, and even then we require a scratch floating-point register. We can only copy a value out of a condition-code register into a general register. */ - if (reg_class_subset_p (class, ST_REGS)) + if (reg_class_subset_p (rclass, ST_REGS)) { if (in_p) return FP_REGS; @@ -9285,10 +9681,10 @@ mips_secondary_reload_class (enum reg_class class, { if (!in_p) return FP_REGS; - return reg_class_subset_p (class, GR_REGS) ? NO_REGS : GR_REGS; + return reg_class_subset_p (rclass, GR_REGS) ? NO_REGS : GR_REGS; } - if (reg_class_subset_p (class, FP_REGS)) + if (reg_class_subset_p (rclass, FP_REGS)) { if (MEM_P (x) && (GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8)) @@ -9314,7 +9710,7 @@ mips_secondary_reload_class (enum reg_class class, return GR_REGS; } if (FP_REG_P (regno)) - return reg_class_subset_p (class, GR_REGS) ? NO_REGS : GR_REGS; + return reg_class_subset_p (rclass, GR_REGS) ? NO_REGS : GR_REGS; return NO_REGS; } @@ -11482,6 +11878,7 @@ mips16_lay_out_constants (void) if (!TARGET_MIPS16_PCREL_LOADS) return; + split_all_insns_noflow (); barrier = 0; memset (&pool, 0, sizeof (pool)); for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) @@ -12116,6 +12513,11 @@ mips_reorg_process_insns (void) cfun->machine->all_noreorder_p = true; + /* We don't track MIPS16 PC-relative offsets closely enough to make + a good job of "set .noreorder" code in MIPS16 mode. */ + if (TARGET_MIPS16) + cfun->machine->all_noreorder_p = false; + /* Code that doesn't use explicit relocs can't be ".set nomacro". */ if (!TARGET_EXPLICIT_RELOCS) cfun->machine->all_noreorder_p = false; @@ -12205,7 +12607,10 @@ mips_reorg (void) if (mips_base_delayed_branch) dbr_schedule (get_insns ()); mips_reorg_process_insns (); - if (TARGET_EXPLICIT_RELOCS && TUNE_MIPS4130 && TARGET_VR4130_ALIGN) + if (!TARGET_MIPS16 + && TARGET_EXPLICIT_RELOCS + && TUNE_MIPS4130 + && TARGET_VR4130_ALIGN) vr4130_align_insns (); } @@ -12217,7 +12622,7 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function) { - rtx this, temp1, temp2, insn, fnaddr; + rtx this_rtx, temp1, temp2, insn, fnaddr; bool use_sibcall_p; /* Pretend to be a post-reload pass while generating rtl. */ @@ -12232,24 +12637,19 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, && const_call_insn_operand (fnaddr, Pmode)); /* Determine if we need to load FNADDR from the GOT. */ - if (!use_sibcall_p) - switch (mips_classify_symbol (fnaddr, SYMBOL_CONTEXT_LEA)) - { - case SYMBOL_GOT_PAGE_OFST: - case SYMBOL_GOT_DISP: - /* Pick a global pointer. Use a call-clobbered register if - TARGET_CALL_SAVED_GP. */ - cfun->machine->global_pointer = - TARGET_CALL_SAVED_GP ? 15 : GLOBAL_POINTER_REGNUM; - SET_REGNO (pic_offset_table_rtx, cfun->machine->global_pointer); - - /* Set up the global pointer for n32 or n64 abicalls. */ - mips_emit_loadgp (); - break; + if (!use_sibcall_p + && (mips_got_symbol_type_p + (mips_classify_symbol (fnaddr, SYMBOL_CONTEXT_LEA)))) + { + /* Pick a global pointer. Use a call-clobbered register if + TARGET_CALL_SAVED_GP. */ + cfun->machine->global_pointer + = TARGET_CALL_SAVED_GP ? 15 : GLOBAL_POINTER_REGNUM; + SET_REGNO (pic_offset_table_rtx, cfun->machine->global_pointer); - default: - break; - } + /* Set up the global pointer for n32 or n64 abicalls. */ + mips_emit_loadgp (); + } /* We need two temporary registers in some cases. */ temp1 = gen_rtx_REG (Pmode, 2); @@ -12257,11 +12657,11 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* Find out which register contains the "this" pointer. */ if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function)) - this = gen_rtx_REG (Pmode, GP_ARG_FIRST + 1); + this_rtx = gen_rtx_REG (Pmode, GP_ARG_FIRST + 1); else - this = gen_rtx_REG (Pmode, GP_ARG_FIRST); + this_rtx = gen_rtx_REG (Pmode, GP_ARG_FIRST); - /* Add DELTA to THIS. */ + /* Add DELTA to THIS_RTX. */ if (delta != 0) { rtx offset = GEN_INT (delta); @@ -12270,23 +12670,23 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, mips_emit_move (temp1, offset); offset = temp1; } - emit_insn (gen_add3_insn (this, this, offset)); + emit_insn (gen_add3_insn (this_rtx, this_rtx, offset)); } - /* If needed, add *(*THIS + VCALL_OFFSET) to THIS. */ + /* If needed, add *(*THIS_RTX + VCALL_OFFSET) to THIS_RTX. */ if (vcall_offset != 0) { rtx addr; - /* Set TEMP1 to *THIS. */ - mips_emit_move (temp1, gen_rtx_MEM (Pmode, this)); + /* Set TEMP1 to *THIS_RTX. */ + mips_emit_move (temp1, gen_rtx_MEM (Pmode, this_rtx)); - /* Set ADDR to a legitimate address for *THIS + VCALL_OFFSET. */ + /* Set ADDR to a legitimate address for *THIS_RTX + VCALL_OFFSET. */ addr = mips_add_offset (temp2, temp1, vcall_offset); - /* Load the offset and add it to THIS. */ + /* Load the offset and add it to THIS_RTX. */ mips_emit_move (temp1, gen_rtx_MEM (Pmode, addr)); - emit_insn (gen_add3_insn (this, this, temp1)); + emit_insn (gen_add3_insn (this_rtx, this_rtx, temp1)); } /* Jump to the target function. Use a sibcall if direct jumps are @@ -12308,12 +12708,17 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, We must therefore load the address via a temporary register if mips_dangerous_for_la25_p. - If we jump to the temporary register rather than $25, the assembler - can use the move insn to fill the jump's delay slot. */ + If we jump to the temporary register rather than $25, + the assembler can use the move insn to fill the jump's + delay slot. + + We can use the same technique for MIPS16 code, where $25 + is not a valid JR register. */ if (TARGET_USE_PIC_FN_ADDR_REG + && !TARGET_MIPS16 && !mips_dangerous_for_la25_p (fnaddr)) temp1 = gen_rtx_REG (Pmode, PIC_FUNCTION_ADDR_REGNUM); - mips_load_call_address (temp1, fnaddr, true); + mips_load_call_address (MIPS_CALL_SIBCALL, temp1, fnaddr); if (TARGET_USE_PIC_FN_ADDR_REG && REGNO (temp1) != PIC_FUNCTION_ADDR_REGNUM) @@ -12387,11 +12792,7 @@ mips_set_mips16_mode (int mips16_p) call. */ flag_move_loop_invariants = 0; - /* Silently disable -mexplicit-relocs since it doesn't apply - to MIPS16 code. Even so, it would overly pedantic to warn - about "-mips16 -mexplicit-relocs", especially given that - we use a %gprel() operator. */ - target_flags &= ~MASK_EXPLICIT_RELOCS; + target_flags |= MASK_EXPLICIT_RELOCS; /* Experiments suggest we get the best overall section-anchor results from using the range of an unextended LW or SW. Code @@ -12401,8 +12802,11 @@ mips_set_mips16_mode (int mips16_p) targetm.min_anchor_offset = 0; targetm.max_anchor_offset = 127; - if (flag_pic || TARGET_ABICALLS) - sorry ("MIPS16 PIC"); + if (flag_pic && !TARGET_OLDABI) + sorry ("MIPS16 PIC for ABIs other than o32 and o64"); + + if (TARGET_XGOT) + sorry ("MIPS16 -mxgot code"); if (TARGET_HARD_FLOAT_ABI && !TARGET_OLDABI) sorry ("hard-float MIPS16 code for ABIs other than o32 and o64"); diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h index f5fc2e642ef..ffeef0a16d4 100644 --- a/gcc/config/mips/mips.h +++ b/gcc/config/mips/mips.h @@ -1657,18 +1657,31 @@ enum mips_code_readable_setting { #define FRAME_POINTER_REQUIRED (mips_frame_pointer_required ()) /* Register in which static-chain is passed to a function. */ -#define STATIC_CHAIN_REGNUM (GP_REG_FIRST + 2) +#define STATIC_CHAIN_REGNUM (GP_REG_FIRST + 15) -/* Registers used as temporaries in prologue/epilogue code. If we're - generating mips16 code, these registers must come from the core set - of 8. The prologue register mustn't conflict with any incoming - arguments, the static chain pointer, or the frame pointer. The - epilogue temporary mustn't conflict with the return registers, the - frame pointer, the EH stack adjustment, or the EH data registers. */ +/* Registers used as temporaries in prologue/epilogue code: + - If a MIPS16 PIC function needs access to _gp, it first loads + the value into MIPS16_PIC_TEMP and then copies it to $gp. + + - The prologue can use MIPS_PROLOGUE_TEMP as a general temporary + register. The register must not conflict with MIPS16_PIC_TEMP. + + - The epilogue can use MIPS_EPILOGUE_TEMP as a general temporary + register. + + If we're generating MIPS16 code, these registers must come from the + core set of 8. The prologue registers mustn't conflict with any + incoming arguments, the static chain pointer, or the frame pointer. + The epilogue temporary mustn't conflict with the return registers, + the PIC call register ($25), the frame pointer, the EH stack adjustment, + or the EH data registers. */ + +#define MIPS16_PIC_TEMP_REGNUM (GP_REG_FIRST + 2) #define MIPS_PROLOGUE_TEMP_REGNUM (GP_REG_FIRST + 3) #define MIPS_EPILOGUE_TEMP_REGNUM (GP_REG_FIRST + (TARGET_MIPS16 ? 6 : 8)) +#define MIPS16_PIC_TEMP gen_rtx_REG (Pmode, MIPS16_PIC_TEMP_REGNUM) #define MIPS_PROLOGUE_TEMP(MODE) gen_rtx_REG (MODE, MIPS_PROLOGUE_TEMP_REGNUM) #define MIPS_EPILOGUE_TEMP(MODE) gen_rtx_REG (MODE, MIPS_EPILOGUE_TEMP_REGNUM) @@ -1716,7 +1729,6 @@ enum mips_code_readable_setting { enum reg_class { NO_REGS, /* no registers in set */ - M16_NA_REGS, /* mips16 regs not used to pass args */ M16_REGS, /* mips16 directly accessible registers */ T_REG, /* mips16 T register ($24) */ M16_T_REGS, /* mips16 registers plus T register */ @@ -1757,7 +1769,6 @@ enum reg_class #define REG_CLASS_NAMES \ { \ "NO_REGS", \ - "M16_NA_REGS", \ "M16_REGS", \ "T_REG", \ "M16_T_REGS", \ @@ -1801,7 +1812,6 @@ enum reg_class #define REG_CLASS_CONTENTS \ { \ { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* no registers */ \ - { 0x0003000c, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* mips16 nonarg regs */\ { 0x000300fc, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* mips16 registers */ \ { 0x01000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* mips16 T register */ \ { 0x010300fc, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* mips16 and T regs */ \ @@ -1958,10 +1968,32 @@ enum reg_class #define RETURN_ADDR_RTX mips_return_addr -/* Since the mips16 ISA mode is encoded in the least-significant bit - of the address, mask it off return addresses for purposes of - finding exception handling regions. */ +/* Mask off the MIPS16 ISA bit in unwind addresses. + + The reason for this is a little subtle. When unwinding a call, + we are given the call's return address, which on most targets + is the address of the following instruction. However, what we + actually want to find is the EH region for the call itself. + The target-independent unwind code therefore searches for "RA - 1". + + In the MIPS16 case, RA is always an odd-valued (ISA-encoded) address. + RA - 1 is therefore the real (even-valued) start of the return + instruction. EH region labels are usually odd-valued MIPS16 symbols + too, so a search for an even address within a MIPS16 region would + usually work. + However, there is an exception. If the end of an EH region is also + the end of a function, the end label is allowed to be even. This is + necessary because a following non-MIPS16 function may also need EH + information for its first instruction. + + Thus a MIPS16 region may be terminated by an ISA-encoded or a + non-ISA-encoded address. This probably isn't ideal, but it is + the traditional (legacy) behavior. It is therefore only safe + to search MIPS EH regions for an _odd-valued_ address. + + Masking off the ISA bit means that the target-independent code + will search for "(RA & -2) - 1", which is guaranteed to be odd. */ #define MASK_RETURN_ADDR GEN_INT (-2) @@ -2181,6 +2213,10 @@ typedef struct mips_args { fprintf (FILE, "\t.set\tnoat\n"); \ fprintf (FILE, "\tmove\t%s,%s\t\t# save current return address\n", \ reg_names[GP_REG_FIRST + 1], reg_names[GP_REG_FIRST + 31]); \ + /* _mcount treats $2 as the static chain register. */ \ + if (cfun->static_chain_decl != NULL) \ + fprintf (FILE, "\tmove\t%s,%s\n", reg_names[2], \ + reg_names[STATIC_CHAIN_REGNUM]); \ if (!TARGET_NEWABI) \ { \ fprintf (FILE, \ @@ -2192,6 +2228,10 @@ typedef struct mips_args { } \ fprintf (FILE, "\tjal\t_mcount\n"); \ fprintf (FILE, "\t.set\tat\n"); \ + /* _mcount treats $2 as the static chain register. */ \ + if (cfun->static_chain_decl != NULL) \ + fprintf (FILE, "\tmove\t%s,%s\n", reg_names[STATIC_CHAIN_REGNUM], \ + reg_names[2]); \ } /* The profiler preserves all interesting registers, including $31. */ @@ -2231,20 +2271,19 @@ typedef struct mips_args { fprintf (STREAM, "\t.word\t0x00000000\t\t# nop\n"); \ if (ptr_mode == DImode) \ { \ - fprintf (STREAM, "\t.word\t0xdfe30014\t\t# ld $3,20($31)\n"); \ - fprintf (STREAM, "\t.word\t0xdfe2001c\t\t# ld $2,28($31)\n"); \ - fprintf (STREAM, "\t.word\t0x0060c82d\t\t# dmove $25,$3\n"); \ + fprintf (STREAM, "\t.word\t0xdff90014\t\t# ld $25,20($31)\n"); \ + fprintf (STREAM, "\t.word\t0xdfef001c\t\t# ld $15,28($31)\n"); \ } \ else \ { \ - fprintf (STREAM, "\t.word\t0x8fe30014\t\t# lw $3,20($31)\n"); \ - fprintf (STREAM, "\t.word\t0x8fe20018\t\t# lw $2,24($31)\n"); \ - fprintf (STREAM, "\t.word\t0x0060c821\t\t# move $25,$3\n"); \ + fprintf (STREAM, "\t.word\t0x8ff90010\t\t# lw $25,16($31)\n"); \ + fprintf (STREAM, "\t.word\t0x8fef0014\t\t# lw $15,20($31)\n"); \ } \ - fprintf (STREAM, "\t.word\t0x00600008\t\t# jr $3\n"); \ + fprintf (STREAM, "\t.word\t0x03200008\t\t# jr $25\n"); \ if (ptr_mode == DImode) \ { \ fprintf (STREAM, "\t.word\t0x0020f82d\t\t# dmove $31,$1\n"); \ + fprintf (STREAM, "\t.word\t0x00000000\t\t# <padding>\n"); \ fprintf (STREAM, "\t.dword\t0x00000000\t\t# <function address>\n"); \ fprintf (STREAM, "\t.dword\t0x00000000\t\t# <static chain value>\n"); \ } \ @@ -2259,7 +2298,7 @@ typedef struct mips_args { /* A C expression for the size in bytes of the trampoline, as an integer. */ -#define TRAMPOLINE_SIZE (32 + GET_MODE_SIZE (ptr_mode) * 2) +#define TRAMPOLINE_SIZE (ptr_mode == DImode ? 48 : 36) /* Alignment required for trampolines, in bits. */ @@ -2289,7 +2328,7 @@ typedef struct mips_args { { \ rtx func_addr, chain_addr, end_addr; \ \ - func_addr = plus_constant (ADDR, 32); \ + func_addr = plus_constant (ADDR, ptr_mode == DImode ? 32 : 28); \ chain_addr = plus_constant (func_addr, GET_MODE_SIZE (ptr_mode)); \ mips_emit_move (gen_rtx_MEM (ptr_mode, func_addr), FUNC); \ mips_emit_move (gen_rtx_MEM (ptr_mode, chain_addr), CHAIN); \ @@ -2390,6 +2429,11 @@ typedef struct mips_args { #define SYMBOL_REF_LONG_CALL_P(X) \ ((SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_LONG_CALL) != 0) +/* This flag marks functions that cannot be lazily bound. */ +#define SYMBOL_FLAG_BIND_NOW (SYMBOL_FLAG_MACH_DEP << 1) +#define SYMBOL_REF_BIND_NOW_P(RTX) \ + ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_BIND_NOW) != 0) + /* True if we're generating a form of MIPS16 code in which jump tables are stored in the text section and encoded as 16-bit PC-relative offsets. This is only possible when general text loads are allowed, @@ -2703,10 +2747,6 @@ while (0) #undef ASM_DECLARE_FUNCTION_NAME #define ASM_DECLARE_FUNCTION_NAME(STREAM,NAME,DECL) -#ifndef FUNCTION_NAME_ALREADY_DECLARED -#define FUNCTION_NAME_ALREADY_DECLARED 0 -#endif - /* This is how to store into the string LABEL the symbol_ref name of an internal numbered label where PREFIX is the class of label and NUM is the number within the class. @@ -3255,6 +3295,7 @@ extern int set_nomacro; /* # of nested .set nomacro's */ extern int mips_dbx_regno[]; extern int mips_dwarf_regno[]; extern bool mips_split_p[]; +extern bool mips_split_hi_p[]; extern GTY(()) rtx cmp_operands[2]; extern enum processor_type mips_arch; /* which cpu to codegen for */ extern enum processor_type mips_tune; /* which cpu to schedule for */ diff --git a/gcc/config/mips/mips.md b/gcc/config/mips/mips.md index 43c47e5883c..4d09085757d 100644 --- a/gcc/config/mips/mips.md +++ b/gcc/config/mips/mips.md @@ -66,6 +66,7 @@ (UNSPEC_MEMORY_BARRIER 45) (UNSPEC_SET_GOT_VERSION 46) (UNSPEC_UPDATE_GOT_VERSION 47) + (UNSPEC_COPYGP 48) (UNSPEC_ADDRESS_FIRST 100) @@ -478,7 +479,9 @@ (const_int 0) (eq_attr "got" "load") - (const_int 4) + (if_then_else (ne (symbol_ref "TARGET_MIPS16") (const_int 0)) + (const_int 8) + (const_int 4)) (eq_attr "got" "xgot_high") (const_int 8) @@ -3590,15 +3593,11 @@ (define_insn_and_split "*got_disp<mode>" [(set (match_operand:P 0 "register_operand" "=d") (match_operand:P 1 "got_disp_operand" ""))] - "TARGET_EXPLICIT_RELOCS && !TARGET_XGOT" + "TARGET_EXPLICIT_RELOCS && !mips_split_p[SYMBOL_GOT_DISP]" "#" "&& reload_completed" - [(set (match_dup 0) - (unspec:P [(match_dup 2) (match_dup 3)] UNSPEC_LOAD_GOT))] -{ - operands[2] = pic_offset_table_rtx; - operands[3] = mips_unspec_address (operands[1], SYMBOL_GOTOFF_DISP); -} + [(set (match_dup 0) (match_dup 2))] + { operands[2] = mips_got_load (NULL, operands[1], SYMBOL_GOTOFF_DISP); } [(set_attr "got" "load") (set_attr "mode" "<MODE>")]) @@ -3607,18 +3606,19 @@ (define_insn_and_split "*got_page<mode>" [(set (match_operand:P 0 "register_operand" "=d") (high:P (match_operand:P 1 "got_page_ofst_operand" "")))] - "TARGET_EXPLICIT_RELOCS" + "TARGET_EXPLICIT_RELOCS && !mips_split_hi_p[SYMBOL_GOT_PAGE_OFST]" "#" "&& reload_completed" - [(set (match_dup 0) - (unspec:P [(match_dup 2) (match_dup 3)] UNSPEC_LOAD_GOT))] -{ - operands[2] = pic_offset_table_rtx; - operands[3] = mips_unspec_address (operands[1], SYMBOL_GOTOFF_PAGE); -} + [(set (match_dup 0) (match_dup 2))] + { operands[2] = mips_got_load (NULL, operands[1], SYMBOL_GOTOFF_PAGE); } [(set_attr "got" "load") (set_attr "mode" "<MODE>")]) +;; Convenience expander that generates the rhs of a load_got<mode> insn. +(define_expand "unspec_got<mode>" + [(unspec:P [(match_operand:P 0) + (match_operand:P 1)] UNSPEC_LOAD_GOT)]) + ;; Lower-level instructions for loading an address from the GOT. ;; We could use MEMs, but an unspec gives more optimization ;; opportunities. @@ -3630,9 +3630,8 @@ UNSPEC_LOAD_GOT))] "" "<load>\t%0,%R2(%1)" - [(set_attr "type" "load") - (set_attr "mode" "<MODE>") - (set_attr "length" "4")]) + [(set_attr "got" "load") + (set_attr "mode" "<MODE>")]) ;; Instructions for adding the low 16 bits of an address to a register. ;; Operand 2 is the address: mips_print_operand works out which relocation @@ -3657,6 +3656,15 @@ (set_attr "mode" "<MODE>") (set_attr "extended_mips16" "yes")]) +;; Expose MIPS16 uses of the global pointer after reload if the function +;; is responsible for setting up the register itself. +(define_split + [(set (match_operand:GPR 0 "d_operand") + (const:GPR (unspec:GPR [(const_int 0)] UNSPEC_GP)))] + "TARGET_MIPS16 && TARGET_USE_GOT && reload_completed" + [(set (match_dup 0) (match_dup 1))] + { operands[1] = pic_offset_table_rtx; }) + ;; Allow combine to split complex const_int load sequences, using operand 2 ;; to store the intermediate results. See move_operand for details. (define_split @@ -4521,6 +4529,18 @@ } [(set_attr "length" "12")]) +;; Initialize the global pointer for MIPS16 code. Operand 0 is the +;; global pointer and operand 1 is the MIPS16 register that holds +;; the required value. +(define_insn_and_split "copygp_mips16" + [(set (match_operand:SI 0 "register_operand" "=y") + (unspec_volatile:SI [(match_operand:SI 1 "register_operand" "d")] + UNSPEC_COPYGP))] + "TARGET_MIPS16" + "#" + "&& reload_completed" + [(set (match_dup 0) (match_dup 1))]) + ;; Emit a .cprestore directive, which normally expands to a single store ;; instruction. Note that we continue to use .cprestore for explicit reloc ;; code so that jals inside inline asms will work correctly. @@ -5981,16 +6001,17 @@ ;; volatile until all uses of $28 are exposed. (define_insn_and_split "restore_gp" [(set (reg:SI 28) - (unspec_volatile:SI [(const_int 0)] UNSPEC_RESTORE_GP))] + (unspec_volatile:SI [(const_int 0)] UNSPEC_RESTORE_GP)) + (clobber (match_scratch:SI 0 "=&d"))] "TARGET_CALL_CLOBBERED_GP" "#" "&& reload_completed" [(const_int 0)] { - mips_restore_gp (); + mips_restore_gp (operands[0]); DONE; } - [(set_attr "type" "load") + [(set_attr "type" "load") (set_attr "length" "12")]) ;; @@ -6043,16 +6064,22 @@ ;; - Leave GOT_VERSION_REGNUM out of all register classes. ;; The register is therefore not a valid register_operand ;; and cannot be moved to or from other registers. + +;; Convenience expander that generates the rhs of a load_call<mode> insn. +(define_expand "unspec_call<mode>" + [(unspec:P [(match_operand:P 0) + (match_operand:P 1) + (reg:SI GOT_VERSION_REGNUM)] UNSPEC_LOAD_CALL)]) + (define_insn "load_call<mode>" [(set (match_operand:P 0 "register_operand" "=d") - (unspec:P [(match_operand:P 1 "register_operand" "r") + (unspec:P [(match_operand:P 1 "register_operand" "d") (match_operand:P 2 "immediate_operand" "") (reg:SI GOT_VERSION_REGNUM)] UNSPEC_LOAD_CALL))] "TARGET_USE_GOT" "<load>\t%0,%R2(%1)" - [(set_attr "type" "load") - (set_attr "mode" "<MODE>") - (set_attr "length" "4")]) + [(set_attr "got" "load") + (set_attr "mode" "<MODE>")]) (define_insn "set_got_version" [(set (reg:SI GOT_VERSION_REGNUM) @@ -6088,7 +6115,8 @@ (use (match_operand 3 ""))])] ;; struct_value_size_rtx "TARGET_SIBCALLS" { - mips_expand_call (0, XEXP (operands[0], 0), operands[1], operands[2], true); + mips_expand_call (MIPS_CALL_SIBCALL, NULL_RTX, XEXP (operands[0], 0), + operands[1], operands[2], false); DONE; }) @@ -6106,8 +6134,8 @@ (use (match_operand 3 ""))])] ;; next_arg_reg "TARGET_SIBCALLS" { - mips_expand_call (operands[0], XEXP (operands[1], 0), - operands[2], operands[3], true); + mips_expand_call (MIPS_CALL_SIBCALL, operands[0], XEXP (operands[1], 0), + operands[2], operands[3], false); DONE; }) @@ -6137,7 +6165,8 @@ (use (match_operand 3 ""))])] ;; struct_value_size_rtx "" { - mips_expand_call (0, XEXP (operands[0], 0), operands[1], operands[2], false); + mips_expand_call (MIPS_CALL_NORMAL, NULL_RTX, XEXP (operands[0], 0), + operands[1], operands[2], false); DONE; }) @@ -6187,28 +6216,44 @@ "reload_completed && TARGET_SPLIT_CALLS && (operands[2] = insn)" [(const_int 0)] { - emit_call_insn (gen_call_split (operands[0], operands[1])); - if (!find_reg_note (operands[2], REG_NORETURN, 0)) - mips_restore_gp (); + mips_split_call (operands[2], gen_call_split (operands[0], operands[1])); DONE; } [(set_attr "jal" "indirect,direct")]) +(define_insn "call_split" + [(call (mem:SI (match_operand 0 "call_insn_operand" "cS")) + (match_operand 1 "" "")) + (clobber (reg:SI 31)) + (clobber (reg:SI 28))] + "TARGET_SPLIT_CALLS" + { return MIPS_CALL ("jal", operands, 0); } + [(set_attr "type" "call")]) + ;; A pattern for calls that must be made directly. It is used for ;; MIPS16 calls that the linker may need to redirect to a hard-float ;; stub; the linker relies on the call relocation type to detect when ;; such redirection is needed. -(define_insn "call_internal_direct" +(define_insn_and_split "call_internal_direct" [(call (mem:SI (match_operand 0 "const_call_insn_operand")) (match_operand 1)) (const_int 1) (clobber (reg:SI 31))] "" - { return MIPS_CALL ("jal", operands, 0); }) + { return TARGET_SPLIT_CALLS ? "#" : MIPS_CALL ("jal", operands, 0); } + "reload_completed && TARGET_SPLIT_CALLS && (operands[2] = insn)" + [(const_int 0)] +{ + mips_split_call (operands[2], + gen_call_direct_split (operands[0], operands[1])); + DONE; +} + [(set_attr "type" "call")]) -(define_insn "call_split" - [(call (mem:SI (match_operand 0 "call_insn_operand" "cS")) - (match_operand 1 "" "")) +(define_insn "call_direct_split" + [(call (mem:SI (match_operand 0 "const_call_insn_operand")) + (match_operand 1)) + (const_int 1) (clobber (reg:SI 31)) (clobber (reg:SI 28))] "TARGET_SPLIT_CALLS" @@ -6222,7 +6267,7 @@ (use (match_operand 3 ""))])] ;; next_arg_reg "" { - mips_expand_call (operands[0], XEXP (operands[1], 0), + mips_expand_call (MIPS_CALL_NORMAL, operands[0], XEXP (operands[1], 0), operands[2], operands[3], false); DONE; }) @@ -6238,10 +6283,9 @@ "reload_completed && TARGET_SPLIT_CALLS && (operands[3] = insn)" [(const_int 0)] { - emit_call_insn (gen_call_value_split (operands[0], operands[1], - operands[2])); - if (!find_reg_note (operands[3], REG_NORETURN, 0)) - mips_restore_gp (); + mips_split_call (operands[3], + gen_call_value_split (operands[0], operands[1], + operands[2])); DONE; } [(set_attr "jal" "indirect,direct")]) @@ -6257,14 +6301,34 @@ [(set_attr "type" "call")]) ;; See call_internal_direct. -(define_insn "call_value_internal_direct" +(define_insn_and_split "call_value_internal_direct" [(set (match_operand 0 "register_operand") (call (mem:SI (match_operand 1 "const_call_insn_operand")) (match_operand 2))) (const_int 1) (clobber (reg:SI 31))] "" - { return MIPS_CALL ("jal", operands, 1); }) + { return TARGET_SPLIT_CALLS ? "#" : MIPS_CALL ("jal", operands, 1); } + "reload_completed && TARGET_SPLIT_CALLS && (operands[3] = insn)" + [(const_int 0)] +{ + mips_split_call (operands[3], + gen_call_value_direct_split (operands[0], operands[1], + operands[2])); + DONE; +} + [(set_attr "type" "call")]) + +(define_insn "call_value_direct_split" + [(set (match_operand 0 "register_operand") + (call (mem:SI (match_operand 1 "const_call_insn_operand")) + (match_operand 2))) + (const_int 1) + (clobber (reg:SI 31)) + (clobber (reg:SI 28))] + "TARGET_SPLIT_CALLS" + { return MIPS_CALL ("jal", operands, 1); } + [(set_attr "type" "call")]) ;; See comment for call_internal. (define_insn_and_split "call_value_multiple_internal" @@ -6280,10 +6344,9 @@ "reload_completed && TARGET_SPLIT_CALLS && (operands[4] = insn)" [(const_int 0)] { - emit_call_insn (gen_call_value_multiple_split (operands[0], operands[1], - operands[2], operands[3])); - if (!find_reg_note (operands[4], REG_NORETURN, 0)) - mips_restore_gp (); + mips_split_call (operands[4], + gen_call_value_multiple_split (operands[0], operands[1], + operands[2], operands[3])); DONE; } [(set_attr "jal" "indirect,direct")]) diff --git a/gcc/config/mips/mips16.S b/gcc/config/mips/mips16.S index 90651b196b3..edc84de8043 100644 --- a/gcc/config/mips/mips16.S +++ b/gcc/config/mips/mips16.S @@ -38,6 +38,8 @@ Boston, MA 02110-1301, USA. */ values using the soft-float calling convention, but do the actual operation using the hard floating point instructions. */ +#if defined _MIPS_SIM && (_MIPS_SIM == _ABIO32 || _MIPS_SIM == _ABIO64) + /* This file contains 32-bit assembly code. */ .set nomips16 @@ -303,8 +305,12 @@ STARTFN (__mips16_floatsisf) #ifdef L_m16fltunsisf STARTFN (__mips16_floatunsisf) + .set noreorder bltz $4,1f - j __mips16_floatsisf + MOVE_SF_BYTE0 (t) + .set reorder + cvt.s.w RET,ARG1 + MOVE_SF_RET (f, $31) 1: and $2,$4,1 srl $3,$4,1 @@ -522,7 +528,10 @@ RET_FUNCTION (__mips16_ret_dc, DC) #define CALL_STUB_NO_RET(NAME, CODE) \ STARTFN (NAME); \ STUB_ARGS_##CODE; \ + .set noreorder; \ jr $2; \ + move $25,$2; \ + .set reorder; \ ENDFN (NAME) #ifdef L_m16stub1 @@ -569,7 +578,10 @@ CALL_STUB_NO_RET (__mips16_call_stub_10, 10) STARTFN (NAME); \ move $18,$31; \ STUB_ARGS_##CODE; \ + .set noreorder; \ jalr $2; \ + move $25,$2; \ + .set reorder; \ MOVE_##MODE##_RET (f, $18); \ ENDFN (NAME) @@ -705,3 +717,4 @@ CALL_STUB_RET (__mips16_call_stub_dc_9, 9, DC) CALL_STUB_RET (__mips16_call_stub_dc_10, 10, DC) #endif #endif /* !__mips_single_float */ +#endif diff --git a/gcc/config/mips/predicates.md b/gcc/config/mips/predicates.md index 73db0274936..0e8c85b93be 100644 --- a/gcc/config/mips/predicates.md +++ b/gcc/config/mips/predicates.md @@ -104,14 +104,9 @@ switch (symbol_type) { case SYMBOL_ABSOLUTE: - /* We can only use direct calls for TARGET_ABSOLUTE_ABICALLS if we - are sure that the target function does not need $25 to be live - on entry. This is true for any locally-defined function because - any such function will use %hi/%lo accesses to set up $gp. */ - if (TARGET_ABSOLUTE_ABICALLS - && !(GET_CODE (op) == SYMBOL_REF - && SYMBOL_REF_DECL (op) - && !DECL_EXTERNAL (SYMBOL_REF_DECL (op)))) + /* We can only use direct calls if we're sure that the target + function does not need $25 to be valid on entry. */ + if (mips_use_pic_fn_addr_reg_p (op)) return false; /* If -mlong-calls or if this function has an explicit long_call @@ -206,6 +201,11 @@ return (mips_symbolic_constant_p (op, SYMBOL_CONTEXT_LEA, &symbol_type) && !mips_split_p[symbol_type]); + case HIGH: + op = XEXP (op, 0); + return (mips_symbolic_constant_p (op, SYMBOL_CONTEXT_LEA, &symbol_type) + && !mips_split_hi_p[symbol_type]); + default: return true; } diff --git a/gcc/config/mips/sdemtk.h b/gcc/config/mips/sdemtk.h index a73e7d2d7b3..f6b60970727 100644 --- a/gcc/config/mips/sdemtk.h +++ b/gcc/config/mips/sdemtk.h @@ -94,12 +94,20 @@ extern void mips_sync_icache (void *beg, unsigned long len); #define FUNCTION_PROFILER(FILE, LABELNO) \ { \ fprintf (FILE, "\t.set\tnoat\n"); \ + /* _mcount treats $2 as the static chain register. */ \ + if (cfun->static_chain_decl != NULL) \ + fprintf (FILE, "\tmove\t%s,%s\n", reg_names[2], \ + reg_names[STATIC_CHAIN_REGNUM]); \ /* MIPS16 code passes saved $ra in $v1 instead of $at. */ \ fprintf (FILE, "\tmove\t%s,%s\n", \ reg_names[GP_REG_FIRST + (TARGET_MIPS16 ? 3 : 1)], \ reg_names[GP_REG_FIRST + 31]); \ fprintf (FILE, "\tjal\t_mcount\n"); \ fprintf (FILE, "\t.set\tat\n"); \ + /* _mcount treats $2 as the static chain register. */ \ + if (cfun->static_chain_decl != NULL) \ + fprintf (FILE, "\tmove\t%s,%s\n", reg_names[STATIC_CHAIN_REGNUM], \ + reg_names[2]); \ } /* ...nor does the call sequence preserve $31. */ diff --git a/gcc/config/mips/t-libgcc-mips16 b/gcc/config/mips/t-libgcc-mips16 index d37b6eef539..b1a547d7029 100644 --- a/gcc/config/mips/t-libgcc-mips16 +++ b/gcc/config/mips/t-libgcc-mips16 @@ -22,3 +22,6 @@ LIB1ASMFUNCS = _m16addsf3 _m16subsf3 _m16mulsf3 _m16divsf3 \ LIBGCC_SYNC = yes LIBGCC_SYNC_CFLAGS = -mno-mips16 + +# Version these symbols if building libgcc.so. +SHLIB_MAPFILES += $(srcdir)/config/mips/libgcc-mips16.ver diff --git a/gcc/config/mmix/mmix.c b/gcc/config/mmix/mmix.c index fe38bb01eca..e57f52dd796 100644 --- a/gcc/config/mmix/mmix.c +++ b/gcc/config/mmix/mmix.c @@ -353,11 +353,11 @@ mmix_local_regno (int regno) We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */ enum reg_class -mmix_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) +mmix_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class rclass) { /* FIXME: Revisit. */ return GET_CODE (x) == MOD && GET_MODE (x) == DImode - ? REMAINDER_REG : class; + ? REMAINDER_REG : rclass; } /* PREFERRED_OUTPUT_RELOAD_CLASS. @@ -365,25 +365,25 @@ mmix_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) enum reg_class mmix_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED, - enum reg_class class) + enum reg_class rclass) { /* FIXME: Revisit. */ return GET_CODE (x) == MOD && GET_MODE (x) == DImode - ? REMAINDER_REG : class; + ? REMAINDER_REG : rclass; } /* SECONDARY_RELOAD_CLASS. We need to reload regs of REMAINDER_REG and HIMULT_REG elsewhere. */ enum reg_class -mmix_secondary_reload_class (enum reg_class class, +mmix_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED, int in_p ATTRIBUTE_UNUSED) { - if (class == REMAINDER_REG - || class == HIMULT_REG - || class == SYSTEM_REGS) + if (rclass == REMAINDER_REG + || rclass == HIMULT_REG + || rclass == SYSTEM_REGS) return GENERAL_REGS; return NO_REGS; diff --git a/gcc/config/mn10300/mn10300.c b/gcc/config/mn10300/mn10300.c index ea7392bb0f9..6f172fc0b26 100644 --- a/gcc/config/mn10300/mn10300.c +++ b/gcc/config/mn10300/mn10300.c @@ -1319,11 +1319,11 @@ store_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED) } /* What (if any) secondary registers are needed to move IN with mode - MODE into a register in register class CLASS. + MODE into a register in register class RCLASS. We might be able to simplify this. */ enum reg_class -mn10300_secondary_reload_class (enum reg_class class, enum machine_mode mode, +mn10300_secondary_reload_class (enum reg_class rclass, enum machine_mode mode, rtx in) { /* Memory loads less than a full word wide can't have an @@ -1336,8 +1336,8 @@ mn10300_secondary_reload_class (enum reg_class class, enum machine_mode mode, && GET_CODE (SUBREG_REG (in)) == REG && REGNO (SUBREG_REG (in)) >= FIRST_PSEUDO_REGISTER)) && (mode == QImode || mode == HImode) - && (class == ADDRESS_REGS || class == SP_REGS - || class == SP_OR_ADDRESS_REGS)) + && (rclass == ADDRESS_REGS || rclass == SP_REGS + || rclass == SP_OR_ADDRESS_REGS)) { if (TARGET_AM33) return DATA_OR_EXTENDED_REGS; @@ -1346,12 +1346,12 @@ mn10300_secondary_reload_class (enum reg_class class, enum machine_mode mode, /* We can't directly load sp + const_int into a data register; we must use an address register as an intermediate. */ - if (class != SP_REGS - && class != ADDRESS_REGS - && class != SP_OR_ADDRESS_REGS - && class != SP_OR_EXTENDED_REGS - && class != ADDRESS_OR_EXTENDED_REGS - && class != SP_OR_ADDRESS_OR_EXTENDED_REGS + if (rclass != SP_REGS + && rclass != ADDRESS_REGS + && rclass != SP_OR_ADDRESS_REGS + && rclass != SP_OR_EXTENDED_REGS + && rclass != ADDRESS_OR_EXTENDED_REGS + && rclass != SP_OR_ADDRESS_OR_EXTENDED_REGS && (in == stack_pointer_rtx || (GET_CODE (in) == PLUS && (XEXP (in, 0) == stack_pointer_rtx @@ -1363,7 +1363,7 @@ mn10300_secondary_reload_class (enum reg_class class, enum machine_mode mode, || XEXP (in, 1) == stack_pointer_rtx)) return GENERAL_REGS; - if (TARGET_AM33_2 && class == FP_REGS + if (TARGET_AM33_2 && rclass == FP_REGS && GET_CODE (in) == MEM && ! (GET_CODE (in) == MEM && !CONSTANT_ADDRESS_P (XEXP (in, 0)))) { diff --git a/gcc/config/pa/pa.c b/gcc/config/pa/pa.c index 76d84bad092..9ff778b5b47 100644 --- a/gcc/config/pa/pa.c +++ b/gcc/config/pa/pa.c @@ -5684,19 +5684,19 @@ output_arg_descriptor (rtx call_insn) } static enum reg_class -pa_secondary_reload (bool in_p, rtx x, enum reg_class class, +pa_secondary_reload (bool in_p, rtx x, enum reg_class rclass, enum machine_mode mode, secondary_reload_info *sri) { int is_symbolic, regno; /* Handle the easy stuff first. */ - if (class == R1_REGS) + if (rclass == R1_REGS) return NO_REGS; if (REG_P (x)) { regno = REGNO (x); - if (class == BASE_REG_CLASS && regno < FIRST_PSEUDO_REGISTER) + if (rclass == BASE_REG_CLASS && regno < FIRST_PSEUDO_REGISTER) return NO_REGS; } else @@ -5712,7 +5712,7 @@ pa_secondary_reload (bool in_p, rtx x, enum reg_class class, generation requires %r1 as a scratch register. */ if (flag_pic && (mode == SImode || mode == DImode) - && FP_REG_CLASS_P (class) + && FP_REG_CLASS_P (rclass) && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)) { sri->icode = (mode == SImode ? CODE_FOR_reload_insi_r1 @@ -5735,7 +5735,7 @@ pa_secondary_reload (bool in_p, rtx x, enum reg_class class, memory loads and stores. */ if ((regno >= FIRST_PSEUDO_REGISTER || regno == -1) && GET_MODE_CLASS (mode) == MODE_INT - && FP_REG_CLASS_P (class)) + && FP_REG_CLASS_P (rclass)) { /* Reload passes (mem:SI (reg/f:DI 30 %r30) when it wants to check the secondary reload needed for a pseudo. It never passes a @@ -5767,7 +5767,7 @@ pa_secondary_reload (bool in_p, rtx x, enum reg_class class, /* We need a secondary register (GPR) for copies between the SAR and anything other than a general register. */ - if (class == SHIFT_REGS && (regno <= 0 || regno >= 32)) + if (rclass == SHIFT_REGS && (regno <= 0 || regno >= 32)) { sri->icode = in_p ? reload_in_optab[mode] : reload_out_optab[mode]; return NO_REGS; @@ -5777,7 +5777,7 @@ pa_secondary_reload (bool in_p, rtx x, enum reg_class class, well as secondary memory. */ if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER && (REGNO_REG_CLASS (regno) == SHIFT_REGS - && FP_REG_CLASS_P (class))) + && FP_REG_CLASS_P (rclass))) { sri->icode = in_p ? reload_in_optab[mode] : reload_out_optab[mode]; return NO_REGS; @@ -8831,7 +8831,7 @@ pa_reorg (void) static void pa_combine_instructions (void) { - rtx anchor, new; + rtx anchor, new_rtx; /* This can get expensive since the basic algorithm is on the order of O(n^2) (or worse). Only do it for -O2 or higher @@ -8843,8 +8843,8 @@ pa_combine_instructions (void) may be combined with "floating" insns. As the name implies, "anchor" instructions don't move, while "floating" insns may move around. */ - new = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, NULL_RTX, NULL_RTX)); - new = make_insn_raw (new); + new_rtx = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, NULL_RTX, NULL_RTX)); + new_rtx = make_insn_raw (new_rtx); for (anchor = get_insns (); anchor; anchor = NEXT_INSN (anchor)) { @@ -8900,7 +8900,7 @@ pa_combine_instructions (void) { /* If ANCHOR and FLOATER can be combined, then we're done with this pass. */ - if (pa_can_combine_p (new, anchor, floater, 0, + if (pa_can_combine_p (new_rtx, anchor, floater, 0, SET_DEST (PATTERN (floater)), XEXP (SET_SRC (PATTERN (floater)), 0), XEXP (SET_SRC (PATTERN (floater)), 1))) @@ -8912,7 +8912,7 @@ pa_combine_instructions (void) { if (GET_CODE (SET_SRC (PATTERN (floater))) == PLUS) { - if (pa_can_combine_p (new, anchor, floater, 0, + if (pa_can_combine_p (new_rtx, anchor, floater, 0, SET_DEST (PATTERN (floater)), XEXP (SET_SRC (PATTERN (floater)), 0), XEXP (SET_SRC (PATTERN (floater)), 1))) @@ -8920,7 +8920,7 @@ pa_combine_instructions (void) } else { - if (pa_can_combine_p (new, anchor, floater, 0, + if (pa_can_combine_p (new_rtx, anchor, floater, 0, SET_DEST (PATTERN (floater)), SET_SRC (PATTERN (floater)), SET_SRC (PATTERN (floater)))) @@ -8962,7 +8962,7 @@ pa_combine_instructions (void) { /* If ANCHOR and FLOATER can be combined, then we're done with this pass. */ - if (pa_can_combine_p (new, anchor, floater, 1, + if (pa_can_combine_p (new_rtx, anchor, floater, 1, SET_DEST (PATTERN (floater)), XEXP (SET_SRC (PATTERN (floater)), 0), @@ -9021,7 +9021,7 @@ pa_combine_instructions (void) } static int -pa_can_combine_p (rtx new, rtx anchor, rtx floater, int reversed, rtx dest, +pa_can_combine_p (rtx new_rtx, rtx anchor, rtx floater, int reversed, rtx dest, rtx src1, rtx src2) { int insn_code_number; @@ -9034,12 +9034,12 @@ pa_can_combine_p (rtx new, rtx anchor, rtx floater, int reversed, rtx dest, If the pattern doesn't match or the constraints aren't met keep searching for a suitable floater insn. */ - XVECEXP (PATTERN (new), 0, 0) = PATTERN (anchor); - XVECEXP (PATTERN (new), 0, 1) = PATTERN (floater); - INSN_CODE (new) = -1; - insn_code_number = recog_memoized (new); + XVECEXP (PATTERN (new_rtx), 0, 0) = PATTERN (anchor); + XVECEXP (PATTERN (new_rtx), 0, 1) = PATTERN (floater); + INSN_CODE (new_rtx) = -1; + insn_code_number = recog_memoized (new_rtx); if (insn_code_number < 0 - || (extract_insn (new), ! constrain_operands (1))) + || (extract_insn (new_rtx), ! constrain_operands (1))) return 0; if (reversed) @@ -9652,11 +9652,11 @@ pa_hpux_file_end (void) #endif /* Return true if a change from mode FROM to mode TO for a register - in register class CLASS is invalid. */ + in register class RCLASS is invalid. */ bool pa_cannot_change_mode_class (enum machine_mode from, enum machine_mode to, - enum reg_class class) + enum reg_class rclass) { if (from == to) return false; @@ -9674,7 +9674,7 @@ pa_cannot_change_mode_class (enum machine_mode from, enum machine_mode to, On the 64-bit target, this conflicts with the definition of LOAD_EXTEND_OP. Thus, we can't allow changing between modes with different sizes in the floating-point registers. */ - if (MAYBE_FP_REG_CLASS_P (class)) + if (MAYBE_FP_REG_CLASS_P (rclass)) return true; /* HARD_REGNO_MODE_OK places modes with sizes larger than a word diff --git a/gcc/config/pa/pa.h b/gcc/config/pa/pa.h index 22cd9f33f32..610bcf5da3c 100644 --- a/gcc/config/pa/pa.h +++ b/gcc/config/pa/pa.h @@ -1377,7 +1377,7 @@ extern int may_call_alloca; #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \ do { \ long offset, newoffset, mask; \ - rtx new, temp = NULL_RTX; \ + rtx new_rtx, temp = NULL_RTX; \ \ mask = (GET_MODE_CLASS (MODE) == MODE_FLOAT \ ? (INT14_OK_STRICT ? 0x3fff : 0x1f) : 0x3fff); \ @@ -1386,14 +1386,14 @@ do { \ temp = simplify_binary_operation (PLUS, Pmode, \ XEXP (AD, 0), XEXP (AD, 1)); \ \ - new = temp ? temp : AD; \ + new_rtx = temp ? temp : AD; \ \ if (optimize \ - && GET_CODE (new) == PLUS \ - && GET_CODE (XEXP (new, 0)) == REG \ - && GET_CODE (XEXP (new, 1)) == CONST_INT) \ + && GET_CODE (new_rtx) == PLUS \ + && GET_CODE (XEXP (new_rtx, 0)) == REG \ + && GET_CODE (XEXP (new_rtx, 1)) == CONST_INT) \ { \ - offset = INTVAL (XEXP ((new), 1)); \ + offset = INTVAL (XEXP ((new_rtx), 1)); \ \ /* Choose rounding direction. Round up if we are >= halfway. */ \ if ((offset & mask) >= ((mask + 1) / 2)) \ @@ -1409,7 +1409,7 @@ do { \ \ if (newoffset != 0 && VAL_14_BITS_P (newoffset)) \ { \ - temp = gen_rtx_PLUS (Pmode, XEXP (new, 0), \ + temp = gen_rtx_PLUS (Pmode, XEXP (new_rtx, 0), \ GEN_INT (newoffset)); \ AD = gen_rtx_PLUS (Pmode, temp, GEN_INT (offset - newoffset));\ push_reload (XEXP (AD, 0), 0, &XEXP (AD, 0), 0, \ diff --git a/gcc/config/pdp11/pdp11.c b/gcc/config/pdp11/pdp11.c index ba649eac60f..661980fd13e 100644 --- a/gcc/config/pdp11/pdp11.c +++ b/gcc/config/pdp11/pdp11.c @@ -78,6 +78,8 @@ const struct real_format pdp11_f_format = false, false, false, + false, + false, false }; @@ -97,6 +99,8 @@ const struct real_format pdp11_d_format = false, false, false, + false, + false, false }; diff --git a/gcc/config/pdp11/pdp11.h b/gcc/config/pdp11/pdp11.h index 4b8c231376e..662886cf8db 100644 --- a/gcc/config/pdp11/pdp11.h +++ b/gcc/config/pdp11/pdp11.h @@ -100,8 +100,6 @@ along with GCC; see the file COPYING3. If not see big endian, opposite for what you need for float, the vax float conversion routines aren't actually used directly. But the underlying format is indeed the vax/pdp11 float format. */ -#define TARGET_FLOAT_FORMAT VAX_FLOAT_FORMAT - extern const struct real_format pdp11_f_format; extern const struct real_format pdp11_d_format; diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c index 76c92352b57..8cbace8a795 100644 --- a/gcc/config/rs6000/rs6000-c.c +++ b/gcc/config/rs6000/rs6000-c.c @@ -278,6 +278,8 @@ rs6000_cpu_cpp_builtins (cpp_reader *pfile) cpp_get_callbacks (pfile)->macro_to_expand = rs6000_macro_to_expand; } } + if (rs6000_cpu == PROCESSOR_CELL) + builtin_define ("__PPU__"); if (TARGET_SPE) builtin_define ("__SPE__"); if (TARGET_PAIRED_FLOAT) diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index e67b1a7fed8..0f2779e54bf 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -1507,6 +1507,9 @@ rs6000_override_options (const char *default_cpu) {"power6x", PROCESSOR_POWER6, POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP | MASK_MFPGPR}, + {"power7", PROCESSOR_POWER5, + POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF + | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP}, {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK}, {"powerpc64", PROCESSOR_POWERPC64, POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}, @@ -1960,7 +1963,11 @@ rs6000_builtin_mask_for_load (void) return 0; } -/* Implement targetm.vectorize.builtin_conversion. */ +/* Implement targetm.vectorize.builtin_conversion. + Returns a decl of a function that implements conversion of an integer vector + into a floating-point vector, or vice-versa. TYPE is the type of the integer + side of the conversion. + Return NULL_TREE if it is not available. */ static tree rs6000_builtin_conversion (enum tree_code code, tree type) { @@ -1969,16 +1976,28 @@ rs6000_builtin_conversion (enum tree_code code, tree type) switch (code) { + case FIX_TRUNC_EXPR: + switch (TYPE_MODE (type)) + { + case V4SImode: + return TYPE_UNSIGNED (type) + ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VCTUXS] + : rs6000_builtin_decls[ALTIVEC_BUILTIN_VCTSXS]; + default: + return NULL_TREE; + } + case FLOAT_EXPR: switch (TYPE_MODE (type)) { case V4SImode: - return TYPE_UNSIGNED (type) ? - rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFUX] : - rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFSX]; + return TYPE_UNSIGNED (type) + ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFUX] + : rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFSX]; default: return NULL_TREE; } + default: return NULL_TREE; } @@ -1994,14 +2013,14 @@ rs6000_builtin_mul_widen_even (tree type) switch (TYPE_MODE (type)) { case V8HImode: - return TYPE_UNSIGNED (type) ? - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH] : - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH]; + return TYPE_UNSIGNED (type) + ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH] + : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH]; case V16QImode: - return TYPE_UNSIGNED (type) ? - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB] : - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB]; + return TYPE_UNSIGNED (type) + ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB] + : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB]; default: return NULL_TREE; } @@ -2017,14 +2036,14 @@ rs6000_builtin_mul_widen_odd (tree type) switch (TYPE_MODE (type)) { case V8HImode: - return TYPE_UNSIGNED (type) ? - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH] : - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH]; + return TYPE_UNSIGNED (type) + ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH] + : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH]; case V16QImode: - return TYPE_UNSIGNED (type) ? - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB] : - rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB]; + return TYPE_UNSIGNED (type) + ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB] + : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB]; default: return NULL_TREE; } @@ -2849,7 +2868,7 @@ paired_expand_vector_init (rtx target, rtx vals) enum machine_mode mode = GET_MODE (target); int n_elts = GET_MODE_NUNITS (mode); int n_var = 0; - rtx x, new, tmp, constant_op, op1, op2; + rtx x, new_rtx, tmp, constant_op, op1, op2; int i; for (i = 0; i < n_elts; ++i) @@ -2868,10 +2887,10 @@ paired_expand_vector_init (rtx target, rtx vals) if (n_var == 2) { /* The vector is initialized only with non-constants. */ - new = gen_rtx_VEC_CONCAT (V2SFmode, XVECEXP (vals, 0, 0), + new_rtx = gen_rtx_VEC_CONCAT (V2SFmode, XVECEXP (vals, 0, 0), XVECEXP (vals, 0, 1)); - emit_move_insn (target, new); + emit_move_insn (target, new_rtx); return; } @@ -2887,11 +2906,11 @@ paired_expand_vector_init (rtx target, rtx vals) emit_move_insn (tmp, constant_op); if (CONSTANT_P (op1)) - new = gen_rtx_VEC_CONCAT (V2SFmode, tmp, op2); + new_rtx = gen_rtx_VEC_CONCAT (V2SFmode, tmp, op2); else - new = gen_rtx_VEC_CONCAT (V2SFmode, op1, tmp); + new_rtx = gen_rtx_VEC_CONCAT (V2SFmode, op1, tmp); - emit_move_insn (target, new); + emit_move_insn (target, new_rtx); } void @@ -9102,7 +9121,9 @@ rs6000_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, /* FIXME: There's got to be a nicer way to handle this case than constructing a new CALL_EXPR. */ if (fcode == ALTIVEC_BUILTIN_VCFUX - || fcode == ALTIVEC_BUILTIN_VCFSX) + || fcode == ALTIVEC_BUILTIN_VCFSX + || fcode == ALTIVEC_BUILTIN_VCTUXS + || fcode == ALTIVEC_BUILTIN_VCTSXS) { if (call_expr_nargs (exp) == 1) exp = build_call_nary (TREE_TYPE (exp), CALL_EXPR_FN (exp), @@ -11370,11 +11391,11 @@ rs6000_instantiate_decls (void) } /* Return the register class of a scratch register needed to copy IN into - or out of a register in CLASS in MODE. If it can be done directly, + or out of a register in RCLASS in MODE. If it can be done directly, NO_REGS is returned. */ enum reg_class -rs6000_secondary_reload_class (enum reg_class class, +rs6000_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx in) { @@ -11393,7 +11414,7 @@ rs6000_secondary_reload_class (enum reg_class class, On Darwin, pic addresses require a load from memory, which needs a base register. */ - if (class != BASE_REGS + if (rclass != BASE_REGS && (GET_CODE (in) == SYMBOL_REF || GET_CODE (in) == HIGH || GET_CODE (in) == LABEL_REF @@ -11422,22 +11443,22 @@ rs6000_secondary_reload_class (enum reg_class class, /* We can place anything into GENERAL_REGS and can put GENERAL_REGS into anything. */ - if (class == GENERAL_REGS || class == BASE_REGS + if (rclass == GENERAL_REGS || rclass == BASE_REGS || (regno >= 0 && INT_REGNO_P (regno))) return NO_REGS; /* Constants, memory, and FP registers can go into FP registers. */ if ((regno == -1 || FP_REGNO_P (regno)) - && (class == FLOAT_REGS || class == NON_SPECIAL_REGS)) + && (rclass == FLOAT_REGS || rclass == NON_SPECIAL_REGS)) return (mode != SDmode) ? NO_REGS : GENERAL_REGS; /* Memory, and AltiVec registers can go into AltiVec registers. */ if ((regno == -1 || ALTIVEC_REGNO_P (regno)) - && class == ALTIVEC_REGS) + && rclass == ALTIVEC_REGS) return NO_REGS; /* We can copy among the CR registers. */ - if ((class == CR_REGS || class == CR0_REGS) + if ((rclass == CR_REGS || rclass == CR0_REGS) && regno >= 0 && CR_REGNO_P (regno)) return NO_REGS; @@ -17578,7 +17599,7 @@ rs6000_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function) { - rtx this, insn, funexp; + rtx this_rtx, insn, funexp; reload_completed = 1; epilogue_completed = 1; @@ -17589,17 +17610,17 @@ rs6000_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* Find the "this" pointer. If the function returns a structure, the structure return pointer is in r3. */ if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function)) - this = gen_rtx_REG (Pmode, 4); + this_rtx = gen_rtx_REG (Pmode, 4); else - this = gen_rtx_REG (Pmode, 3); + this_rtx = gen_rtx_REG (Pmode, 3); /* Apply the constant offset, if required. */ if (delta) { rtx delta_rtx = GEN_INT (delta); emit_insn (TARGET_32BIT - ? gen_addsi3 (this, this, delta_rtx) - : gen_adddi3 (this, this, delta_rtx)); + ? gen_addsi3 (this_rtx, this_rtx, delta_rtx) + : gen_adddi3 (this_rtx, this_rtx, delta_rtx)); } /* Apply the offset from the vtable, if required. */ @@ -17608,7 +17629,7 @@ rs6000_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, rtx vcall_offset_rtx = GEN_INT (vcall_offset); rtx tmp = gen_rtx_REG (Pmode, 12); - emit_move_insn (tmp, gen_rtx_MEM (Pmode, this)); + emit_move_insn (tmp, gen_rtx_MEM (Pmode, this_rtx)); if (((unsigned HOST_WIDE_INT) vcall_offset) + 0x8000 >= 0x10000) { emit_insn (TARGET_32BIT @@ -17623,8 +17644,8 @@ rs6000_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, emit_move_insn (tmp, gen_rtx_MEM (Pmode, loc)); } emit_insn (TARGET_32BIT - ? gen_addsi3 (this, this, tmp) - : gen_adddi3 (this, this, tmp)); + ? gen_addsi3 (this_rtx, this_rtx, tmp) + : gen_adddi3 (this_rtx, this_rtx, tmp)); } /* Generate a tail call to the target function. */ @@ -20520,12 +20541,12 @@ rs6000_elf_encode_section_info (tree decl, rtx rtl, int first) } static inline bool -compare_section_name (const char *section, const char *template) +compare_section_name (const char *section, const char *templ) { int len; - len = strlen (template); - return (strncmp (section, template, len) == 0 + len = strlen (templ); + return (strncmp (section, templ, len) == 0 && (section[len] == 0 || section[len] == '.')); } @@ -21813,17 +21834,17 @@ rs6000_register_move_cost (enum machine_mode mode, or from memory. */ int -rs6000_memory_move_cost (enum machine_mode mode, enum reg_class class, +rs6000_memory_move_cost (enum machine_mode mode, enum reg_class rclass, int in ATTRIBUTE_UNUSED) { - if (reg_classes_intersect_p (class, GENERAL_REGS)) + if (reg_classes_intersect_p (rclass, GENERAL_REGS)) return 4 * hard_regno_nregs[0][mode]; - else if (reg_classes_intersect_p (class, FLOAT_REGS)) + else if (reg_classes_intersect_p (rclass, FLOAT_REGS)) return 4 * hard_regno_nregs[32][mode]; - else if (reg_classes_intersect_p (class, ALTIVEC_REGS)) + else if (reg_classes_intersect_p (rclass, ALTIVEC_REGS)) return 4 * hard_regno_nregs[FIRST_ALTIVEC_REGNO][mode]; else - return 4 + rs6000_register_move_cost (mode, class, GENERAL_REGS); + return 4 + rs6000_register_move_cost (mode, rclass, GENERAL_REGS); } /* Returns a code for a target-specific builtin that implements diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index def3b53ab95..1f6d07b8c06 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -72,6 +72,12 @@ #define ASM_CPU_POWER6_SPEC "-mpower4 -maltivec" #endif +#ifdef HAVE_AS_VSX +#define ASM_CPU_POWER7_SPEC "-mpower7" +#else +#define ASM_CPU_POWER7_SPEC "-mpower4 -maltivec" +#endif + /* Common ASM definitions used by ASM_SPEC among the various targets for handling -mcpu=xxx switches. */ #define ASM_CPU_SPEC \ @@ -92,6 +98,7 @@ %{mcpu=power5+: %(asm_cpu_power5)} \ %{mcpu=power6: %(asm_cpu_power6) -maltivec} \ %{mcpu=power6x: %(asm_cpu_power6) -maltivec} \ +%{mcpu=power7: %(asm_cpu_power7)} \ %{mcpu=powerpc: -mppc} \ %{mcpu=rios: -mpwr} \ %{mcpu=rios1: -mpwr} \ @@ -160,6 +167,7 @@ { "cc1_cpu", CC1_CPU_SPEC }, \ { "asm_cpu_power5", ASM_CPU_POWER5_SPEC }, \ { "asm_cpu_power6", ASM_CPU_POWER6_SPEC }, \ + { "asm_cpu_power7", ASM_CPU_POWER7_SPEC }, \ SUBTARGET_EXTRA_SPECS /* -mcpu=native handling only makes sense with compiler running on diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index 3c7d92b3c8d..9d60c442542 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -836,17 +836,17 @@ s390_emit_compare (enum rtx_code code, rtx op0, rtx op1) return ret; } -/* Emit a SImode compare and swap instruction setting MEM to NEW if OLD +/* Emit a SImode compare and swap instruction setting MEM to NEW_RTX if OLD matches CMP. Return the correct condition RTL to be placed in the IF_THEN_ELSE of the conditional branch testing the result. */ static rtx -s390_emit_compare_and_swap (enum rtx_code code, rtx old, rtx mem, rtx cmp, rtx new) +s390_emit_compare_and_swap (enum rtx_code code, rtx old, rtx mem, rtx cmp, rtx new_rtx) { rtx ret; - emit_insn (gen_sync_compare_and_swap_ccsi (old, mem, cmp, new)); + emit_insn (gen_sync_compare_and_swap_ccsi (old, mem, cmp, new_rtx)); ret = gen_rtx_fmt_ee (code, VOIDmode, s390_compare_emitted, const0_rtx); s390_compare_emitted = NULL_RTX; @@ -2758,11 +2758,11 @@ legitimate_reload_constant_p (rtx op) return false; } -/* Given an rtx OP being reloaded into a reg required to be in class CLASS, +/* Given an rtx OP being reloaded into a reg required to be in class RCLASS, return the class of reg to actually use. */ enum reg_class -s390_preferred_reload_class (rtx op, enum reg_class class) +s390_preferred_reload_class (rtx op, enum reg_class rclass) { switch (GET_CODE (op)) { @@ -2772,7 +2772,7 @@ s390_preferred_reload_class (rtx op, enum reg_class class) case CONST_DOUBLE: case CONST_INT: if (legitimate_reload_constant_p (op)) - return class; + return rclass; else return NO_REGS; @@ -2784,7 +2784,7 @@ s390_preferred_reload_class (rtx op, enum reg_class class) case LABEL_REF: case SYMBOL_REF: case CONST: - if (reg_class_subset_p (ADDR_REGS, class)) + if (reg_class_subset_p (ADDR_REGS, rclass)) return ADDR_REGS; else return NO_REGS; @@ -2793,7 +2793,7 @@ s390_preferred_reload_class (rtx op, enum reg_class class) break; } - return class; + return rclass; } /* Return true if ADDR is of kind symbol_ref or symbol_ref + const_int @@ -2923,15 +2923,15 @@ s390_reload_symref_address (rtx reg, rtx mem, rtx scratch, bool tomem) } /* Inform reload about cases where moving X with a mode MODE to a register in - CLASS requires an extra scratch or immediate register. Return the class + RCLASS requires an extra scratch or immediate register. Return the class needed for the immediate register. */ static enum reg_class -s390_secondary_reload (bool in_p, rtx x, enum reg_class class, +s390_secondary_reload (bool in_p, rtx x, enum reg_class rclass, enum machine_mode mode, secondary_reload_info *sri) { /* Intermediate register needed. */ - if (reg_classes_intersect_p (CC_REGS, class)) + if (reg_classes_intersect_p (CC_REGS, rclass)) return GENERAL_REGS; if (TARGET_Z10) @@ -3007,12 +3007,12 @@ s390_secondary_reload (bool in_p, rtx x, enum reg_class class, /* For GENERAL_REGS a displacement overflow is no problem if occurring in a s_operand address since we may fallback to lm/stm. So we only have to care about overflows in the b+i+d case. */ - if ((reg_classes_intersect_p (GENERAL_REGS, class) + if ((reg_classes_intersect_p (GENERAL_REGS, rclass) && s390_class_max_nregs (GENERAL_REGS, mode) > 1 && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS) /* For FP_REGS no lm/stm is available so this check is triggered for displacement overflows in b+i+d and b+d like addresses. */ - || (reg_classes_intersect_p (FP_REGS, class) + || (reg_classes_intersect_p (FP_REGS, rclass) && s390_class_max_nregs (FP_REGS, mode) > 1)) { if (in_p) @@ -3029,7 +3029,7 @@ s390_secondary_reload (bool in_p, rtx x, enum reg_class class, /* A scratch address register is needed when a symbolic constant is copied to r0 compiling with -fPIC. In other cases the target register might be used as temporary (see legitimize_pic_address). */ - if (in_p && SYMBOLIC_CONST (x) && flag_pic == 2 && class != ADDR_REGS) + if (in_p && SYMBOLIC_CONST (x) && flag_pic == 2 && rclass != ADDR_REGS) sri->icode = (TARGET_64BIT ? CODE_FOR_reloaddi_PIC_addr : CODE_FOR_reloadsi_PIC_addr); @@ -3218,7 +3218,7 @@ rtx legitimize_pic_address (rtx orig, rtx reg) { rtx addr = orig; - rtx new = orig; + rtx new_rtx = orig; rtx base; gcc_assert (!TLS_SYMBOLIC_CONST (addr)); @@ -3247,11 +3247,11 @@ legitimize_pic_address (rtx orig, rtx reg) addr = force_const_mem (Pmode, addr); emit_move_insn (temp, addr); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } } } @@ -3268,12 +3268,12 @@ legitimize_pic_address (rtx orig, rtx reg) if (reload_in_progress || reload_completed) df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT); - new = gen_rtx_CONST (Pmode, new); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new); - new = gen_const_mem (Pmode, new); - emit_move_insn (reg, new); - new = reg; + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx); + new_rtx = gen_const_mem (Pmode, new_rtx); + emit_move_insn (reg, new_rtx); + new_rtx = reg; } else if (TARGET_CPU_ZARCH) { @@ -3285,13 +3285,13 @@ legitimize_pic_address (rtx orig, rtx reg) gcc_assert (REGNO (temp) >= FIRST_PSEUDO_REGISTER || REGNO_REG_CLASS (REGNO (temp)) == ADDR_REGS); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTENT); - new = gen_rtx_CONST (Pmode, new); - emit_move_insn (temp, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTENT); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + emit_move_insn (temp, new_rtx); - new = gen_const_mem (Pmode, temp); - emit_move_insn (reg, new); - new = reg; + new_rtx = gen_const_mem (Pmode, temp); + emit_move_insn (reg, new_rtx); + new_rtx = reg; } else { @@ -3311,10 +3311,10 @@ legitimize_pic_address (rtx orig, rtx reg) addr = force_const_mem (Pmode, addr); emit_move_insn (temp, addr); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); - new = gen_const_mem (Pmode, new); - emit_move_insn (reg, new); - new = reg; + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); + new_rtx = gen_const_mem (Pmode, new_rtx); + emit_move_insn (reg, new_rtx); + new_rtx = reg; } } else @@ -3331,13 +3331,13 @@ legitimize_pic_address (rtx orig, rtx reg) out of the literal pool, force them back in. */ case UNSPEC_GOTOFF: case UNSPEC_PLTOFF: - new = force_const_mem (Pmode, orig); + new_rtx = force_const_mem (Pmode, orig); break; /* @GOT is OK as is if small. */ case UNSPEC_GOT: if (flag_pic == 2) - new = force_const_mem (Pmode, orig); + new_rtx = force_const_mem (Pmode, orig); break; /* @GOTENT is OK as is. */ @@ -3361,11 +3361,11 @@ legitimize_pic_address (rtx orig, rtx reg) addr = force_const_mem (Pmode, addr); emit_move_insn (temp, addr); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } } break; @@ -3411,12 +3411,12 @@ legitimize_pic_address (rtx orig, rtx reg) } emit_move_insn (temp, op0); - new = gen_rtx_PLUS (Pmode, temp, op1); + new_rtx = gen_rtx_PLUS (Pmode, temp, op1); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } } else @@ -3441,11 +3441,11 @@ legitimize_pic_address (rtx orig, rtx reg) addr = force_const_mem (Pmode, addr); emit_move_insn (temp, addr); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } } } @@ -3459,34 +3459,34 @@ legitimize_pic_address (rtx orig, rtx reg) { gcc_assert (XVECLEN (op0, 0) == 1); - new = force_const_mem (Pmode, orig); + new_rtx = force_const_mem (Pmode, orig); } /* Otherwise, compute the sum. */ else { base = legitimize_pic_address (XEXP (addr, 0), reg); - new = legitimize_pic_address (XEXP (addr, 1), + new_rtx = legitimize_pic_address (XEXP (addr, 1), base == reg ? NULL_RTX : reg); - if (GET_CODE (new) == CONST_INT) - new = plus_constant (base, INTVAL (new)); + if (GET_CODE (new_rtx) == CONST_INT) + new_rtx = plus_constant (base, INTVAL (new_rtx)); else { - if (GET_CODE (new) == PLUS && CONSTANT_P (XEXP (new, 1))) + if (GET_CODE (new_rtx) == PLUS && CONSTANT_P (XEXP (new_rtx, 1))) { - base = gen_rtx_PLUS (Pmode, base, XEXP (new, 0)); - new = XEXP (new, 1); + base = gen_rtx_PLUS (Pmode, base, XEXP (new_rtx, 0)); + new_rtx = XEXP (new_rtx, 1); } - new = gen_rtx_PLUS (Pmode, base, new); + new_rtx = gen_rtx_PLUS (Pmode, base, new_rtx); } - if (GET_CODE (new) == CONST) - new = XEXP (new, 0); - new = force_operand (new, 0); + if (GET_CODE (new_rtx) == CONST) + new_rtx = XEXP (new_rtx, 0); + new_rtx = force_operand (new_rtx, 0); } } } - return new; + return new_rtx; } /* Load the thread pointer into a register. */ @@ -3532,7 +3532,7 @@ s390_emit_tls_call_insn (rtx result_reg, rtx tls_call) static rtx legitimize_tls_address (rtx addr, rtx reg) { - rtx new, tls_call, temp, base, r2, insn; + rtx new_rtx, tls_call, temp, base, r2, insn; if (GET_CODE (addr) == SYMBOL_REF) switch (tls_symbolic_operand (addr)) @@ -3541,22 +3541,22 @@ legitimize_tls_address (rtx addr, rtx reg) start_sequence (); r2 = gen_rtx_REG (Pmode, 2); tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_TLSGD); - new = gen_rtx_CONST (Pmode, tls_call); - new = force_const_mem (Pmode, new); - emit_move_insn (r2, new); + new_rtx = gen_rtx_CONST (Pmode, tls_call); + new_rtx = force_const_mem (Pmode, new_rtx); + emit_move_insn (r2, new_rtx); s390_emit_tls_call_insn (r2, tls_call); insn = get_insns (); end_sequence (); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF); temp = gen_reg_rtx (Pmode); - emit_libcall_block (insn, temp, r2, new); + emit_libcall_block (insn, temp, r2, new_rtx); - new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); + new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } break; @@ -3564,32 +3564,32 @@ legitimize_tls_address (rtx addr, rtx reg) start_sequence (); r2 = gen_rtx_REG (Pmode, 2); tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM); - new = gen_rtx_CONST (Pmode, tls_call); - new = force_const_mem (Pmode, new); - emit_move_insn (r2, new); + new_rtx = gen_rtx_CONST (Pmode, tls_call); + new_rtx = force_const_mem (Pmode, new_rtx); + emit_move_insn (r2, new_rtx); s390_emit_tls_call_insn (r2, tls_call); insn = get_insns (); end_sequence (); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM_NTPOFF); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM_NTPOFF); temp = gen_reg_rtx (Pmode); - emit_libcall_block (insn, temp, r2, new); + emit_libcall_block (insn, temp, r2, new_rtx); - new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); + new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); base = gen_reg_rtx (Pmode); - s390_load_address (base, new); + s390_load_address (base, new_rtx); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_DTPOFF); - new = gen_rtx_CONST (Pmode, new); - new = force_const_mem (Pmode, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_DTPOFF); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + new_rtx = force_const_mem (Pmode, new_rtx); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); - new = gen_rtx_PLUS (Pmode, base, temp); + new_rtx = gen_rtx_PLUS (Pmode, base, temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } break; @@ -3602,26 +3602,26 @@ legitimize_tls_address (rtx addr, rtx reg) if (reload_in_progress || reload_completed) df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF); - new = gen_rtx_CONST (Pmode, new); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new); - new = gen_const_mem (Pmode, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx); + new_rtx = gen_const_mem (Pmode, new_rtx); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); } else if (TARGET_CPU_ZARCH) { /* If the GOT offset might be >= 4k, we determine the position of the GOT entry via a PC-relative LARL. */ - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF); - new = gen_rtx_CONST (Pmode, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); - new = gen_const_mem (Pmode, temp); + new_rtx = gen_const_mem (Pmode, temp); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); } else if (flag_pic) { @@ -3631,57 +3631,57 @@ legitimize_tls_address (rtx addr, rtx reg) if (reload_in_progress || reload_completed) df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF); - new = gen_rtx_CONST (Pmode, new); - new = force_const_mem (Pmode, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + new_rtx = force_const_mem (Pmode, new_rtx); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); - new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); - new = gen_const_mem (Pmode, new); + new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp); + new_rtx = gen_const_mem (Pmode, new_rtx); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new, addr), UNSPEC_TLS_LOAD); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new_rtx, addr), UNSPEC_TLS_LOAD); temp = gen_reg_rtx (Pmode); - emit_insn (gen_rtx_SET (Pmode, temp, new)); + emit_insn (gen_rtx_SET (Pmode, temp, new_rtx)); } else { /* In position-dependent code, load the absolute address of the GOT entry from the literal pool. */ - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF); - new = gen_rtx_CONST (Pmode, new); - new = force_const_mem (Pmode, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + new_rtx = force_const_mem (Pmode, new_rtx); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); - new = temp; - new = gen_const_mem (Pmode, new); - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new, addr), UNSPEC_TLS_LOAD); + new_rtx = temp; + new_rtx = gen_const_mem (Pmode, new_rtx); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new_rtx, addr), UNSPEC_TLS_LOAD); temp = gen_reg_rtx (Pmode); - emit_insn (gen_rtx_SET (Pmode, temp, new)); + emit_insn (gen_rtx_SET (Pmode, temp, new_rtx)); } - new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); + new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } break; case TLS_MODEL_LOCAL_EXEC: - new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF); - new = gen_rtx_CONST (Pmode, new); - new = force_const_mem (Pmode, new); + new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF); + new_rtx = gen_rtx_CONST (Pmode, new_rtx); + new_rtx = force_const_mem (Pmode, new_rtx); temp = gen_reg_rtx (Pmode); - emit_move_insn (temp, new); + emit_move_insn (temp, new_rtx); - new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); + new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp); if (reg != 0) { - s390_load_address (reg, new); - new = reg; + s390_load_address (reg, new_rtx); + new_rtx = reg; } break; @@ -3695,7 +3695,7 @@ legitimize_tls_address (rtx addr, rtx reg) { case UNSPEC_INDNTPOFF: gcc_assert (TARGET_CPU_ZARCH); - new = addr; + new_rtx = addr; break; default: @@ -3706,19 +3706,19 @@ legitimize_tls_address (rtx addr, rtx reg) else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT) { - new = XEXP (XEXP (addr, 0), 0); - if (GET_CODE (new) != SYMBOL_REF) - new = gen_rtx_CONST (Pmode, new); + new_rtx = XEXP (XEXP (addr, 0), 0); + if (GET_CODE (new_rtx) != SYMBOL_REF) + new_rtx = gen_rtx_CONST (Pmode, new_rtx); - new = legitimize_tls_address (new, reg); - new = plus_constant (new, INTVAL (XEXP (XEXP (addr, 0), 1))); - new = force_operand (new, 0); + new_rtx = legitimize_tls_address (new_rtx, reg); + new_rtx = plus_constant (new_rtx, INTVAL (XEXP (XEXP (addr, 0), 1))); + new_rtx = force_operand (new_rtx, 0); } else gcc_unreachable (); /* for now ... */ - return new; + return new_rtx; } /* Emit insns making the address in operands[1] valid for a standard @@ -3865,19 +3865,19 @@ legitimize_reload_address (rtx ad, enum machine_mode mode ATTRIBUTE_UNUSED, { HOST_WIDE_INT lower = INTVAL (XEXP (ad, 1)) & 0xfff; HOST_WIDE_INT upper = INTVAL (XEXP (ad, 1)) ^ lower; - rtx cst, tem, new; + rtx cst, tem, new_rtx; cst = GEN_INT (upper); if (!legitimate_reload_constant_p (cst)) cst = force_const_mem (Pmode, cst); tem = gen_rtx_PLUS (Pmode, XEXP (ad, 0), cst); - new = gen_rtx_PLUS (Pmode, tem, GEN_INT (lower)); + new_rtx = gen_rtx_PLUS (Pmode, tem, GEN_INT (lower)); push_reload (XEXP (tem, 1), 0, &XEXP (tem, 1), 0, BASE_REG_CLASS, Pmode, VOIDmode, 0, 0, opnum, (enum reload_type) type); - return new; + return new_rtx; } return NULL_RTX; @@ -4547,13 +4547,13 @@ init_alignment_context (struct alignment_context *ac, rtx mem, } /* Expand an atomic compare and swap operation for HImode and QImode. MEM is - the memory location, CMP the old value to compare MEM with and NEW the value + the memory location, CMP the old value to compare MEM with and NEW_RTX the value to set if CMP == MEM. CMP is never in memory for compare_and_swap_cc because expand_bool_compare_and_swap puts it into a register for later compare. */ void -s390_expand_cs_hqi (enum machine_mode mode, rtx target, rtx mem, rtx cmp, rtx new) +s390_expand_cs_hqi (enum machine_mode mode, rtx target, rtx mem, rtx cmp, rtx new_rtx) { struct alignment_context ac; rtx cmpv, newv, val, resv, cc; @@ -4569,8 +4569,8 @@ s390_expand_cs_hqi (enum machine_mode mode, rtx target, rtx mem, rtx cmp, rtx ne /* Shift the values to the correct bit positions. */ if (!(ac.aligned && MEM_P (cmp))) cmp = s390_expand_mask_and_shift (cmp, mode, ac.shift); - if (!(ac.aligned && MEM_P (new))) - new = s390_expand_mask_and_shift (new, mode, ac.shift); + if (!(ac.aligned && MEM_P (new_rtx))) + new_rtx = s390_expand_mask_and_shift (new_rtx, mode, ac.shift); /* Load full word. Subsequent loads are performed by CS. */ val = expand_simple_binop (SImode, AND, ac.memsi, ac.modemaski, @@ -4592,13 +4592,13 @@ s390_expand_cs_hqi (enum machine_mode mode, rtx target, rtx mem, rtx cmp, rtx ne else cmpv = force_reg (SImode, expand_simple_binop (SImode, IOR, cmp, val, NULL_RTX, 1, OPTAB_DIRECT)); - if (ac.aligned && MEM_P (new)) + if (ac.aligned && MEM_P (new_rtx)) { newv = force_reg (SImode, val); - store_bit_field (newv, GET_MODE_BITSIZE (mode), 0, SImode, new); + store_bit_field (newv, GET_MODE_BITSIZE (mode), 0, SImode, new_rtx); } else - newv = force_reg (SImode, expand_simple_binop (SImode, IOR, new, val, + newv = force_reg (SImode, expand_simple_binop (SImode, IOR, new_rtx, val, NULL_RTX, 1, OPTAB_DIRECT)); /* Jump to end if we're done (likely?). */ @@ -4632,7 +4632,7 @@ s390_expand_atomic (enum machine_mode mode, enum rtx_code code, { struct alignment_context ac; rtx cmp; - rtx new = gen_reg_rtx (SImode); + rtx new_rtx = gen_reg_rtx (SImode); rtx orig = gen_reg_rtx (SImode); rtx csloop = gen_label_rtx (); @@ -4658,39 +4658,39 @@ s390_expand_atomic (enum machine_mode mode, enum rtx_code code, /* Start CS loop. */ emit_label (csloop); - emit_move_insn (new, cmp); + emit_move_insn (new_rtx, cmp); /* Patch new with val at correct position. */ switch (code) { case PLUS: case MINUS: - val = expand_simple_binop (SImode, code, new, orig, + val = expand_simple_binop (SImode, code, new_rtx, orig, NULL_RTX, 1, OPTAB_DIRECT); val = expand_simple_binop (SImode, AND, val, ac.modemask, NULL_RTX, 1, OPTAB_DIRECT); /* FALLTHRU */ case SET: if (ac.aligned && MEM_P (val)) - store_bit_field (new, GET_MODE_BITSIZE (mode), 0, SImode, val); + store_bit_field (new_rtx, GET_MODE_BITSIZE (mode), 0, SImode, val); else { - new = expand_simple_binop (SImode, AND, new, ac.modemaski, + new_rtx = expand_simple_binop (SImode, AND, new_rtx, ac.modemaski, NULL_RTX, 1, OPTAB_DIRECT); - new = expand_simple_binop (SImode, IOR, new, val, + new_rtx = expand_simple_binop (SImode, IOR, new_rtx, val, NULL_RTX, 1, OPTAB_DIRECT); } break; case AND: case IOR: case XOR: - new = expand_simple_binop (SImode, code, new, val, + new_rtx = expand_simple_binop (SImode, code, new_rtx, val, NULL_RTX, 1, OPTAB_DIRECT); break; case MULT: /* NAND */ - new = expand_simple_binop (SImode, XOR, new, ac.modemask, + new_rtx = expand_simple_binop (SImode, XOR, new_rtx, ac.modemask, NULL_RTX, 1, OPTAB_DIRECT); - new = expand_simple_binop (SImode, AND, new, val, + new_rtx = expand_simple_binop (SImode, AND, new_rtx, val, NULL_RTX, 1, OPTAB_DIRECT); break; default: @@ -4698,12 +4698,12 @@ s390_expand_atomic (enum machine_mode mode, enum rtx_code code, } s390_emit_jump (csloop, s390_emit_compare_and_swap (NE, cmp, - ac.memsi, cmp, new)); + ac.memsi, cmp, new_rtx)); /* Return the correct part of the bitfield. */ if (target) convert_move (target, expand_simple_binop (SImode, LSHIFTRT, - after ? new : cmp, ac.shift, + after ? new_rtx : cmp, ac.shift, NULL_RTX, 1, OPTAB_DIRECT), 1); } @@ -7288,12 +7288,12 @@ s390_hard_regno_rename_ok (unsigned int old_reg, unsigned int new_reg) } /* Maximum number of registers to represent a value of mode MODE - in a register of class CLASS. */ + in a register of class RCLASS. */ bool -s390_class_max_nregs (enum reg_class class, enum machine_mode mode) +s390_class_max_nregs (enum reg_class rclass, enum machine_mode mode) { - switch (class) + switch (rclass) { case FP_REGS: if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT) diff --git a/gcc/config/s390/s390.h b/gcc/config/s390/s390.h index 79286d5a9bc..a8cb4774969 100644 --- a/gcc/config/s390/s390.h +++ b/gcc/config/s390/s390.h @@ -748,10 +748,10 @@ used in insn definitions or inline assemblies. */ macro is used in only one place: `find_reloads_address' in reload.c. */ #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \ do { \ - rtx new = legitimize_reload_address (AD, MODE, OPNUM, (int)(TYPE)); \ - if (new) \ + rtx new_rtx = legitimize_reload_address (AD, MODE, OPNUM, (int)(TYPE)); \ + if (new_rtx) \ { \ - (AD) = new; \ + (AD) = new_rtx; \ goto WIN; \ } \ } while (0) diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md index ec5b7532977..f9e89c9fe07 100644 --- a/gcc/config/s390/s390.md +++ b/gcc/config/s390/s390.md @@ -1181,8 +1181,8 @@ (match_operand:P 2 "register_operand" "=a")])] "" { - rtx new = legitimize_pic_address (operands[1], operands[2]); - emit_move_insn (operands[0], new); + rtx new_rtx = legitimize_pic_address (operands[1], operands[2]); + emit_move_insn (operands[0], new_rtx); }) ; diff --git a/gcc/config/score/score-protos.h b/gcc/config/score/score-protos.h index c240d8272dc..5f444abdf73 100644 --- a/gcc/config/score/score-protos.h +++ b/gcc/config/score/score-protos.h @@ -62,13 +62,13 @@ extern void score_declare_object (FILE *stream, const char *name, const char *directive, const char *fmt, ...); extern int score_output_external (FILE *file, tree decl, const char *name); extern void score_override_options (void); -extern enum reg_class score_secondary_reload_class (enum reg_class class, +extern enum reg_class score_secondary_reload_class (enum reg_class rclass, enum machine_mode mode, rtx x); extern rtx score_function_value (tree valtype, tree func, enum machine_mode mode); extern enum reg_class score_preferred_reload_class (rtx x, - enum reg_class class); + enum reg_class rclass); extern HOST_WIDE_INT score_initial_elimination_offset (int from, int to); extern void score_print_operand (FILE *file, rtx op, int letter); extern void score_print_operand_address (FILE *file, rtx addr); diff --git a/gcc/config/score/score.c b/gcc/config/score/score.c index 4f383da88dd..c2e4176e382 100644 --- a/gcc/config/score/score.c +++ b/gcc/config/score/score.c @@ -361,12 +361,12 @@ score_reg_class (int regno) /* Implement PREFERRED_RELOAD_CLASS macro. */ enum reg_class -score_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) +score_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class rclass) { if (TARGET_SCORE5 || TARGET_SCORE5U || TARGET_SCORE7 || TARGET_SCORE7D) - return score7_preferred_reload_class (x, class); + return score7_preferred_reload_class (x, rclass); else if (TARGET_SCORE3) - return score3_preferred_reload_class (x, class); + return score3_preferred_reload_class (x, rclass); gcc_unreachable (); } @@ -374,14 +374,14 @@ score_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) /* Implement SECONDARY_INPUT_RELOAD_CLASS and SECONDARY_OUTPUT_RELOAD_CLASS macro. */ enum reg_class -score_secondary_reload_class (enum reg_class class, +score_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) { if (TARGET_SCORE5 || TARGET_SCORE5U || TARGET_SCORE7 || TARGET_SCORE7D) - return score7_secondary_reload_class (class, mode, x); + return score7_secondary_reload_class (rclass, mode, x); else if (TARGET_SCORE3) - return score3_secondary_reload_class (class, mode, x); + return score3_secondary_reload_class (rclass, mode, x); gcc_unreachable (); } diff --git a/gcc/config/score/score.h b/gcc/config/score/score.h index 78d2c574e1a..d400f6ab0ce 100644 --- a/gcc/config/score/score.h +++ b/gcc/config/score/score.h @@ -198,8 +198,6 @@ support long double, we also want a 128-bit integer type. */ #define MAX_FIXED_MODE_SIZE LONG_DOUBLE_TYPE_SIZE -#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT - /* Layout of Data Type. */ /* Set the sizes of the core types. */ #define INT_TYPE_SIZE 32 diff --git a/gcc/config/score/score3.c b/gcc/config/score/score3.c index 3114bcd1c55..c976f38c005 100644 --- a/gcc/config/score/score3.c +++ b/gcc/config/score/score3.c @@ -323,7 +323,7 @@ score3_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function) { - rtx this, temp1, insn, fnaddr; + rtx this_rtx, temp1, insn, fnaddr; /* Pretend to be a post-reload pass while generating rtl. */ reload_completed = 1; @@ -336,11 +336,11 @@ score3_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* Find out which register contains the "this" pointer. */ if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function)) - this = gen_rtx_REG (Pmode, ARG_REG_FIRST + 1); + this_rtx = gen_rtx_REG (Pmode, ARG_REG_FIRST + 1); else - this = gen_rtx_REG (Pmode, ARG_REG_FIRST); + this_rtx = gen_rtx_REG (Pmode, ARG_REG_FIRST); - /* Add DELTA to THIS. */ + /* Add DELTA to THIS_RTX. */ if (delta != 0) { rtx offset = GEN_INT (delta); @@ -349,23 +349,23 @@ score3_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, emit_move_insn (temp1, offset); offset = temp1; } - emit_insn (gen_add3_insn (this, this, offset)); + emit_insn (gen_add3_insn (this_rtx, this_rtx, offset)); } - /* If needed, add *(*THIS + VCALL_OFFSET) to THIS. */ + /* If needed, add *(*THIS_RTX + VCALL_OFFSET) to THIS_RTX. */ if (vcall_offset != 0) { rtx addr; - /* Set TEMP1 to *THIS. */ - emit_move_insn (temp1, gen_rtx_MEM (Pmode, this)); + /* Set TEMP1 to *THIS_RTX. */ + emit_move_insn (temp1, gen_rtx_MEM (Pmode, this_rtx)); - /* Set ADDR to a legitimate address for *THIS + VCALL_OFFSET. */ + /* Set ADDR to a legitimate address for *THIS_RTX + VCALL_OFFSET. */ addr = score3_add_offset (temp1, vcall_offset); - /* Load the offset and add it to THIS. */ + /* Load the offset and add it to THIS_RTX. */ emit_move_insn (temp1, gen_rtx_MEM (Pmode, addr)); - emit_insn (gen_add3_insn (this, this, temp1)); + emit_insn (gen_add3_insn (this_rtx, this_rtx, temp1)); } /* Jump to the target function. */ @@ -691,19 +691,19 @@ score3_reg_class (int regno) /* Implement PREFERRED_RELOAD_CLASS macro. */ enum reg_class -score3_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) +score3_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class rclass) { - if (reg_class_subset_p (G16_REGS, class)) + if (reg_class_subset_p (G16_REGS, rclass)) return G16_REGS; - if (reg_class_subset_p (G32_REGS, class)) + if (reg_class_subset_p (G32_REGS, rclass)) return G32_REGS; - return class; + return rclass; } /* Implement SECONDARY_INPUT_RELOAD_CLASS and SECONDARY_OUTPUT_RELOAD_CLASS macro. */ enum reg_class -score3_secondary_reload_class (enum reg_class class, +score3_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) { @@ -711,7 +711,7 @@ score3_secondary_reload_class (enum reg_class class, if (GET_CODE (x) == REG || GET_CODE(x) == SUBREG) regno = true_regnum (x); - if (!GR_REG_CLASS_P (class)) + if (!GR_REG_CLASS_P (rclass)) return GP_REG_P (regno) ? NO_REGS : G32_REGS; return NO_REGS; } @@ -768,21 +768,21 @@ int score3_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode) { int size = GET_MODE_SIZE (mode); - enum mode_class class = GET_MODE_CLASS (mode); + enum mode_class mclass = GET_MODE_CLASS (mode); - if (class == MODE_CC) + if (mclass == MODE_CC) return regno == CC_REGNUM; else if (regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM) - return class == MODE_INT; + return mclass == MODE_INT; else if (GP_REG_P (regno)) return !(regno & 1) || (size <= UNITS_PER_WORD); else if (CE_REG_P (regno)) - return (class == MODE_INT + return (mclass == MODE_INT && ((size <= UNITS_PER_WORD) || (regno == CE_REG_FIRST && size == 2 * UNITS_PER_WORD))); else - return (class == MODE_INT) && (size <= UNITS_PER_WORD); + return (mclass == MODE_INT) && (size <= UNITS_PER_WORD); } /* Implement INITIAL_ELIMINATION_OFFSET. FROM is either the frame diff --git a/gcc/config/score/score3.h b/gcc/config/score/score3.h index 098da9500d2..79677702d47 100644 --- a/gcc/config/score/score3.h +++ b/gcc/config/score/score3.h @@ -93,9 +93,9 @@ extern void score3_asm_file_end (void); extern void score3_override_options (void); extern int score3_reg_class (int regno); extern enum reg_class score3_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, - enum reg_class class); + enum reg_class rclass); extern enum reg_class -score3_secondary_reload_class (enum reg_class class, +score3_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x); extern int score3_const_ok_for_letter_p (HOST_WIDE_INT value, char c); diff --git a/gcc/config/score/score7.c b/gcc/config/score/score7.c index 74031c2c6ae..03c47042ed5 100644 --- a/gcc/config/score/score7.c +++ b/gcc/config/score/score7.c @@ -322,7 +322,7 @@ score7_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function) { - rtx this, temp1, insn, fnaddr; + rtx this_rtx, temp1, insn, fnaddr; /* Pretend to be a post-reload pass while generating rtl. */ reload_completed = 1; @@ -335,11 +335,11 @@ score7_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* Find out which register contains the "this" pointer. */ if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function)) - this = gen_rtx_REG (Pmode, ARG_REG_FIRST + 1); + this_rtx = gen_rtx_REG (Pmode, ARG_REG_FIRST + 1); else - this = gen_rtx_REG (Pmode, ARG_REG_FIRST); + this_rtx = gen_rtx_REG (Pmode, ARG_REG_FIRST); - /* Add DELTA to THIS. */ + /* Add DELTA to THIS_RTX. */ if (delta != 0) { rtx offset = GEN_INT (delta); @@ -348,23 +348,23 @@ score7_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, emit_move_insn (temp1, offset); offset = temp1; } - emit_insn (gen_add3_insn (this, this, offset)); + emit_insn (gen_add3_insn (this_rtx, this_rtx, offset)); } - /* If needed, add *(*THIS + VCALL_OFFSET) to THIS. */ + /* If needed, add *(*THIS_RTX + VCALL_OFFSET) to THIS_RTX. */ if (vcall_offset != 0) { rtx addr; - /* Set TEMP1 to *THIS. */ - emit_move_insn (temp1, gen_rtx_MEM (Pmode, this)); + /* Set TEMP1 to *THIS_RTX. */ + emit_move_insn (temp1, gen_rtx_MEM (Pmode, this_rtx)); - /* Set ADDR to a legitimate address for *THIS + VCALL_OFFSET. */ + /* Set ADDR to a legitimate address for *THIS_RTX + VCALL_OFFSET. */ addr = score7_add_offset (temp1, vcall_offset); - /* Load the offset and add it to THIS. */ + /* Load the offset and add it to THIS_RTX. */ emit_move_insn (temp1, gen_rtx_MEM (Pmode, addr)); - emit_insn (gen_add3_insn (this, this, temp1)); + emit_insn (gen_add3_insn (this_rtx, this_rtx, temp1)); } /* Jump to the target function. */ @@ -690,19 +690,19 @@ score7_reg_class (int regno) /* Implement PREFERRED_RELOAD_CLASS macro. */ enum reg_class -score7_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class class) +score7_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class rclass) { - if (reg_class_subset_p (G16_REGS, class)) + if (reg_class_subset_p (G16_REGS, rclass)) return G16_REGS; - if (reg_class_subset_p (G32_REGS, class)) + if (reg_class_subset_p (G32_REGS, rclass)) return G32_REGS; - return class; + return rclass; } /* Implement SECONDARY_INPUT_RELOAD_CLASS and SECONDARY_OUTPUT_RELOAD_CLASS macro. */ enum reg_class -score7_secondary_reload_class (enum reg_class class, +score7_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) { @@ -710,7 +710,7 @@ score7_secondary_reload_class (enum reg_class class, if (GET_CODE (x) == REG || GET_CODE(x) == SUBREG) regno = true_regnum (x); - if (!GR_REG_CLASS_P (class)) + if (!GR_REG_CLASS_P (rclass)) return GP_REG_P (regno) ? NO_REGS : G32_REGS; return NO_REGS; } @@ -758,22 +758,22 @@ int score7_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode) { int size = GET_MODE_SIZE (mode); - enum mode_class class = GET_MODE_CLASS (mode); + enum mode_class mclass = GET_MODE_CLASS (mode); - if (class == MODE_CC) + if (mclass == MODE_CC) return regno == CC_REGNUM; else if (regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM) - return class == MODE_INT; + return mclass == MODE_INT; else if (GP_REG_P (regno)) /* ((regno <= (GP_REG_LAST- HARD_REGNO_NREGS (dummy, mode)) + 1) */ return !(regno & 1) || (size <= UNITS_PER_WORD); else if (CE_REG_P (regno)) - return (class == MODE_INT + return (mclass == MODE_INT && ((size <= UNITS_PER_WORD) || (regno == CE_REG_FIRST && size == 2 * UNITS_PER_WORD))); else - return (class == MODE_INT) && (size <= UNITS_PER_WORD); + return (mclass == MODE_INT) && (size <= UNITS_PER_WORD); } /* Implement INITIAL_ELIMINATION_OFFSET. FROM is either the frame diff --git a/gcc/config/score/score7.h b/gcc/config/score/score7.h index 900aa6f4924..1797e472279 100644 --- a/gcc/config/score/score7.h +++ b/gcc/config/score/score7.h @@ -93,9 +93,9 @@ extern void score7_asm_file_end (void); extern void score7_override_options (void); extern int score7_reg_class (int regno); extern enum reg_class score7_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, - enum reg_class class); + enum reg_class rclass); extern enum -reg_class score7_secondary_reload_class (enum reg_class class, +reg_class score7_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x); extern int score7_const_ok_for_letter_p (HOST_WIDE_INT value, char c); diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c index 60a940bbc84..74060738ee9 100644 --- a/gcc/config/sh/sh.c +++ b/gcc/config/sh/sh.c @@ -1300,9 +1300,9 @@ prepare_move_operands (rtx operands[], enum machine_mode mode) { /* This is like change_address_1 (operands[0], mode, 0, 1) , except that we can't use that function because it is static. */ - rtx new = change_address (operands[0], mode, 0); - MEM_COPY_ATTRIBUTES (new, operands[0]); - operands[0] = new; + rtx new_rtx = change_address (operands[0], mode, 0); + MEM_COPY_ATTRIBUTES (new_rtx, operands[0]); + operands[0] = new_rtx; } /* This case can happen while generating code to move the result @@ -1915,14 +1915,14 @@ print_slot (rtx insn) const char * output_far_jump (rtx insn, rtx op) { - struct { rtx lab, reg, op; } this; + struct { rtx lab, reg, op; } this_jmp; rtx braf_base_lab = NULL_RTX; const char *jump; int far; int offset = branch_dest (insn) - INSN_ADDRESSES (INSN_UID (insn)); rtx prev; - this.lab = gen_label_rtx (); + this_jmp.lab = gen_label_rtx (); if (TARGET_SH2 && offset >= -32764 @@ -1948,10 +1948,10 @@ output_far_jump (rtx insn, rtx op) if (GET_CODE ((prev = prev_nonnote_insn (insn))) == INSN && INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch) { - this.reg = SET_DEST (XVECEXP (PATTERN (prev), 0, 0)); - if (REGNO (this.reg) == R0_REG && flag_pic && ! TARGET_SH2) + this_jmp.reg = SET_DEST (XVECEXP (PATTERN (prev), 0, 0)); + if (REGNO (this_jmp.reg) == R0_REG && flag_pic && ! TARGET_SH2) jump = "mov.l r1,@-r15; mova %O0,r0; mov.l @r0,r1; add r1,r0; mov.l @r15+,r1; jmp @%1"; - output_asm_insn (jump, &this.lab); + output_asm_insn (jump, &this_jmp.lab); if (dbr_sequence_length ()) print_slot (final_sequence); else @@ -1963,7 +1963,7 @@ output_far_jump (rtx insn, rtx op) if (dbr_sequence_length ()) print_slot (final_sequence); - this.reg = gen_rtx_REG (SImode, 13); + this_jmp.reg = gen_rtx_REG (SImode, 13); /* We must keep the stack aligned to 8-byte boundaries on SH5. Fortunately, MACL is fixed and call-clobbered, and we never need its value across jumps, so save r13 in it instead of in @@ -1972,7 +1972,7 @@ output_far_jump (rtx insn, rtx op) output_asm_insn ("lds r13, macl", 0); else output_asm_insn ("mov.l r13,@-r15", 0); - output_asm_insn (jump, &this.lab); + output_asm_insn (jump, &this_jmp.lab); if (TARGET_SH5) output_asm_insn ("sts macl, r13", 0); else @@ -1986,16 +1986,16 @@ output_far_jump (rtx insn, rtx op) } if (far) output_asm_insn (".align 2", 0); - (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (this.lab)); - this.op = op; + (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (this_jmp.lab)); + this_jmp.op = op; if (far && flag_pic) { if (TARGET_SH2) - this.lab = braf_base_lab; - output_asm_insn (".long %O2-%O0", &this.lab); + this_jmp.lab = braf_base_lab; + output_asm_insn (".long %O2-%O0", &this_jmp.lab); } else - output_asm_insn (far ? ".long %O2" : ".word %O2-%O0", &this.lab); + output_asm_insn (far ? ".long %O2" : ".word %O2-%O0", &this_jmp.lab); return ""; } @@ -2092,14 +2092,14 @@ output_branch (int logic, rtx insn, rtx *operands) } } -/* Output a code sequence for INSN using TEMPLATE with OPERANDS; but before, +/* Output a code sequence for INSN using TEMPL with OPERANDS; but before, fill in operands 9 as a label to the successor insn. We try to use jump threading where possible. IF CODE matches the comparison in the IF_THEN_ELSE of a following jump, we assume the jump is taken. I.e. EQ means follow jmp and bf, NE means follow jmp and bt, if the address is in range. */ const char * -output_branchy_insn (enum rtx_code code, const char *template, +output_branchy_insn (enum rtx_code code, const char *templ, rtx insn, rtx *operands) { rtx next_insn = NEXT_INSN (insn); @@ -2115,7 +2115,7 @@ output_branchy_insn (enum rtx_code code, const char *template, INSN_ADDRESSES_NEW (operands[9], INSN_ADDRESSES (INSN_UID (next_insn)) + get_attr_length (next_insn)); - return template; + return templ; } else { @@ -2127,7 +2127,7 @@ output_branchy_insn (enum rtx_code code, const char *template, /* branch_true */ src = XEXP (src, 1); operands[9] = src; - return template; + return templ; } } } @@ -2136,7 +2136,7 @@ output_branchy_insn (enum rtx_code code, const char *template, INSN_ADDRESSES_NEW (operands[9], INSN_ADDRESSES (INSN_UID (insn)) + get_attr_length (insn)); - return template; + return templ; } const char * @@ -3483,7 +3483,7 @@ static rtx add_constant (rtx x, enum machine_mode mode, rtx last_value) { int i; - rtx lab, new; + rtx lab, new_rtx; label_ref_list_t ref, newref; /* First see if we've already got it. */ @@ -3499,14 +3499,14 @@ add_constant (rtx x, enum machine_mode mode, rtx last_value) } if (rtx_equal_p (x, pool_vector[i].value)) { - lab = new = 0; + lab = new_rtx = 0; if (! last_value || ! i || ! rtx_equal_p (last_value, pool_vector[i-1].value)) { - new = gen_label_rtx (); - LABEL_REFS (new) = pool_vector[i].label; - pool_vector[i].label = lab = new; + new_rtx = gen_label_rtx (); + LABEL_REFS (new_rtx) = pool_vector[i].label; + pool_vector[i].label = lab = new_rtx; } if (lab && pool_window_label) { @@ -3516,8 +3516,8 @@ add_constant (rtx x, enum machine_mode mode, rtx last_value) newref->next = ref; pool_vector[pool_window_last].wend = newref; } - if (new) - pool_window_label = new; + if (new_rtx) + pool_window_label = new_rtx; pool_window_last = i; return lab; } @@ -4421,7 +4421,7 @@ gen_block_redirect (rtx jump, int addr, int need_block) rtx scan; /* Don't look for the stack pointer as a scratch register, it would cause trouble if an interrupt occurred. */ - unsigned try = 0x7fff, used; + unsigned attempt = 0x7fff, used; int jump_left = flag_expensive_optimizations + 1; /* It is likely that the most recent eligible instruction is wanted for @@ -4442,7 +4442,7 @@ gen_block_redirect (rtx jump, int addr, int need_block) && GET_CODE (PATTERN (scan)) != CLOBBER && get_attr_in_delay_slot (scan) == IN_DELAY_SLOT_YES) { - try &= ~regs_used (PATTERN (scan), 0); + attempt &= ~regs_used (PATTERN (scan), 0); break; } } @@ -4460,9 +4460,9 @@ gen_block_redirect (rtx jump, int addr, int need_block) if (code == CALL_INSN) used |= regs_used (CALL_INSN_FUNCTION_USAGE (scan), 0); dead |= (used >> 16) & ~used; - if (dead & try) + if (dead & attempt) { - dead &= try; + dead &= attempt; break; } if (code == JUMP_INSN) @@ -8775,14 +8775,14 @@ sh_insn_length_adjustment (rtx insn) { int sum = 0; rtx body = PATTERN (insn); - const char *template; + const char *templ; char c; int maybe_label = 1; if (GET_CODE (body) == ASM_INPUT) - template = XSTR (body, 0); + templ = XSTR (body, 0); else if (asm_noperands (body) >= 0) - template + templ = decode_asm_operands (body, NULL, NULL, NULL, NULL, NULL); else return 0; @@ -8791,20 +8791,20 @@ sh_insn_length_adjustment (rtx insn) int ppi_adjust = 0; do - c = *template++; + c = *templ++; while (c == ' ' || c == '\t'); /* all sh-dsp parallel-processing insns start with p. The only non-ppi sh insn starting with p is pref. The only ppi starting with pr is prnd. */ - if ((c == 'p' || c == 'P') && strncasecmp ("re", template, 2)) + if ((c == 'p' || c == 'P') && strncasecmp ("re", templ, 2)) ppi_adjust = 2; /* The repeat pseudo-insn expands two three insns, a total of six bytes in size. */ else if ((c == 'r' || c == 'R') - && ! strncasecmp ("epeat", template, 5)) + && ! strncasecmp ("epeat", templ, 5)) ppi_adjust = 4; while (c && c != '\n' - && ! IS_ASM_LOGICAL_LINE_SEPARATOR (c, template)) + && ! IS_ASM_LOGICAL_LINE_SEPARATOR (c, templ)) { /* If this is a label, it is obviously not a ppi insn. */ if (c == ':' && maybe_label) @@ -8814,7 +8814,7 @@ sh_insn_length_adjustment (rtx insn) } else if (c == '\'' || c == '"') maybe_label = 0; - c = *template++; + c = *templ++; } sum += ppi_adjust; maybe_label = c != ':'; @@ -10234,24 +10234,24 @@ sh_expand_binop_v2sf (enum rtx_code code, rtx op0, rtx op1, rtx op2) is invalid. */ bool sh_cannot_change_mode_class (enum machine_mode from, enum machine_mode to, - enum reg_class class) + enum reg_class rclass) { /* We want to enable the use of SUBREGs as a means to VEC_SELECT a single element of a vector. */ if (to == SFmode && VECTOR_MODE_P (from) && GET_MODE_INNER (from) == SFmode) - return (reg_classes_intersect_p (GENERAL_REGS, class)); + return (reg_classes_intersect_p (GENERAL_REGS, rclass)); if (GET_MODE_SIZE (from) != GET_MODE_SIZE (to)) { if (TARGET_LITTLE_ENDIAN) { if (GET_MODE_SIZE (to) < 8 || GET_MODE_SIZE (from) < 8) - return reg_classes_intersect_p (DF_REGS, class); + return reg_classes_intersect_p (DF_REGS, rclass); } else { if (GET_MODE_SIZE (from) < 8) - return reg_classes_intersect_p (DF_HI_REGS, class); + return reg_classes_intersect_p (DF_HI_REGS, rclass); } } return 0; @@ -10371,7 +10371,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, { CUMULATIVE_ARGS cum; int structure_value_byref = 0; - rtx this, this_value, sibcall, insns, funexp; + rtx this_rtx, this_value, sibcall, insns, funexp; tree funtype = TREE_TYPE (function); int simple_add = CONST_OK_FOR_ADD (delta); int did_load = 0; @@ -10399,7 +10399,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, FUNCTION_ARG_ADVANCE (cum, Pmode, ptype, 1); } - this = FUNCTION_ARG (cum, Pmode, ptr_type_node, 1); + this_rtx = FUNCTION_ARG (cum, Pmode, ptr_type_node, 1); /* For SHcompact, we only have r0 for a scratch register: r1 is the static chain pointer (even if you can't have nested virtual functions @@ -10440,7 +10440,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, error ("Need a call-clobbered target register"); } - this_value = plus_constant (this, delta); + this_value = plus_constant (this_rtx, delta); if (vcall_offset && (simple_add || scratch0 != scratch1) && strict_memory_address_p (ptr_mode, this_value)) @@ -10452,11 +10452,11 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, if (!delta) ; /* Do nothing. */ else if (simple_add) - emit_move_insn (this, this_value); + emit_move_insn (this_rtx, this_value); else { emit_move_insn (scratch1, GEN_INT (delta)); - emit_insn (gen_add2_insn (this, scratch1)); + emit_insn (gen_add2_insn (this_rtx, scratch1)); } if (vcall_offset) @@ -10464,7 +10464,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, rtx offset_addr; if (!did_load) - emit_load_ptr (scratch0, this); + emit_load_ptr (scratch0, this_rtx); offset_addr = plus_constant (scratch0, vcall_offset); if (strict_memory_address_p (ptr_mode, offset_addr)) @@ -10474,7 +10474,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* scratch0 != scratch1, and we have indexed loads. Get better schedule by loading the offset into r1 and using an indexed load - then the load of r1 can issue before the load from - (this + delta) finishes. */ + (this_rtx + delta) finishes. */ emit_move_insn (scratch1, GEN_INT (vcall_offset)); offset_addr = gen_rtx_PLUS (Pmode, scratch0, scratch1); } @@ -10495,7 +10495,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, if (Pmode != ptr_mode) scratch0 = gen_rtx_TRUNCATE (ptr_mode, scratch0); - emit_insn (gen_add2_insn (this, scratch0)); + emit_insn (gen_add2_insn (this_rtx, scratch0)); } /* Generate a tail call to the target function. */ @@ -10530,7 +10530,7 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, } sibcall = emit_call_insn (sibcall); SIBLING_CALL_P (sibcall) = 1; - use_reg (&CALL_INSN_FUNCTION_USAGE (sibcall), this); + use_reg (&CALL_INSN_FUNCTION_USAGE (sibcall), this_rtx); emit_barrier (); /* Run just enough of rest_of_compilation to do scheduling and get @@ -10930,19 +10930,19 @@ replace_n_hard_rtx (rtx x, rtx *replacements, int n_replacements, int modify) if (GET_CODE (x) == SUBREG) { - rtx new = replace_n_hard_rtx (SUBREG_REG (x), replacements, + rtx new_rtx = replace_n_hard_rtx (SUBREG_REG (x), replacements, n_replacements, modify); - if (GET_CODE (new) == CONST_INT) + if (GET_CODE (new_rtx) == CONST_INT) { - x = simplify_subreg (GET_MODE (x), new, + x = simplify_subreg (GET_MODE (x), new_rtx, GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x)); if (! x) abort (); } else if (modify) - SUBREG_REG (x) = new; + SUBREG_REG (x) = new_rtx; return x; } @@ -10990,18 +10990,18 @@ replace_n_hard_rtx (rtx x, rtx *replacements, int n_replacements, int modify) } else if (GET_CODE (x) == ZERO_EXTEND) { - rtx new = replace_n_hard_rtx (XEXP (x, 0), replacements, + rtx new_rtx = replace_n_hard_rtx (XEXP (x, 0), replacements, n_replacements, modify); - if (GET_CODE (new) == CONST_INT) + if (GET_CODE (new_rtx) == CONST_INT) { x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x), - new, GET_MODE (XEXP (x, 0))); + new_rtx, GET_MODE (XEXP (x, 0))); if (! x) abort (); } else if (modify) - XEXP (x, 0) = new; + XEXP (x, 0) = new_rtx; return x; } @@ -11009,26 +11009,26 @@ replace_n_hard_rtx (rtx x, rtx *replacements, int n_replacements, int modify) fmt = GET_RTX_FORMAT (GET_CODE (x)); for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--) { - rtx new; + rtx new_rtx; if (fmt[i] == 'e') { - new = replace_n_hard_rtx (XEXP (x, i), replacements, + new_rtx = replace_n_hard_rtx (XEXP (x, i), replacements, n_replacements, modify); - if (!new) + if (!new_rtx) return NULL_RTX; if (modify) - XEXP (x, i) = new; + XEXP (x, i) = new_rtx; } else if (fmt[i] == 'E') for (j = XVECLEN (x, i) - 1; j >= 0; j--) { - new = replace_n_hard_rtx (XVECEXP (x, i, j), replacements, + new_rtx = replace_n_hard_rtx (XVECEXP (x, i, j), replacements, n_replacements, modify); - if (!new) + if (!new_rtx) return NULL_RTX; if (modify) - XVECEXP (x, i, j) = new; + XVECEXP (x, i, j) = new_rtx; } } @@ -11162,12 +11162,12 @@ shmedia_prepare_call_address (rtx fnaddr, int is_sibcall) } enum reg_class -sh_secondary_reload (bool in_p, rtx x, enum reg_class class, +sh_secondary_reload (bool in_p, rtx x, enum reg_class rclass, enum machine_mode mode, secondary_reload_info *sri) { if (in_p) { - if (REGCLASS_HAS_FP_REG (class) + if (REGCLASS_HAS_FP_REG (rclass) && ! TARGET_SHMEDIA && immediate_operand ((x), mode) && ! ((fp_zero_operand (x) || fp_one_operand (x)) @@ -11187,13 +11187,13 @@ sh_secondary_reload (bool in_p, rtx x, enum reg_class class, default: abort (); } - if (class == FPUL_REGS + if (rclass == FPUL_REGS && ((GET_CODE (x) == REG && (REGNO (x) == MACL_REG || REGNO (x) == MACH_REG || REGNO (x) == T_REG)) || GET_CODE (x) == PLUS)) return GENERAL_REGS; - if (class == FPUL_REGS && immediate_operand (x, mode)) + if (rclass == FPUL_REGS && immediate_operand (x, mode)) { if (satisfies_constraint_I08 (x) || fp_zero_operand (x)) return GENERAL_REGS; @@ -11202,11 +11202,11 @@ sh_secondary_reload (bool in_p, rtx x, enum reg_class class, sri->icode = CODE_FOR_reload_insi__i_fpul; return NO_REGS; } - if (class == FPSCR_REGS + if (rclass == FPSCR_REGS && ((GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER) || (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == PLUS))) return GENERAL_REGS; - if (REGCLASS_HAS_FP_REG (class) + if (REGCLASS_HAS_FP_REG (rclass) && TARGET_SHMEDIA && immediate_operand (x, mode) && x != CONST0_RTX (GET_MODE (x)) @@ -11219,24 +11219,24 @@ sh_secondary_reload (bool in_p, rtx x, enum reg_class class, ? CODE_FOR_reload_inqi : CODE_FOR_reload_inhi); return NO_REGS; } - if (TARGET_SHMEDIA && class == GENERAL_REGS + if (TARGET_SHMEDIA && rclass == GENERAL_REGS && (GET_CODE (x) == LABEL_REF || PIC_DIRECT_ADDR_P (x))) return TARGET_REGS; } /* end of input-only processing. */ - if (((REGCLASS_HAS_FP_REG (class) + if (((REGCLASS_HAS_FP_REG (rclass) && (GET_CODE (x) == REG && (GENERAL_OR_AP_REGISTER_P (REGNO (x)) || (FP_REGISTER_P (REGNO (x)) && mode == SImode && TARGET_FMOVD)))) - || (REGCLASS_HAS_GENERAL_REG (class) + || (REGCLASS_HAS_GENERAL_REG (rclass) && GET_CODE (x) == REG && FP_REGISTER_P (REGNO (x)))) && ! TARGET_SHMEDIA && (mode == SFmode || mode == SImode)) return FPUL_REGS; - if ((class == FPUL_REGS - || (REGCLASS_HAS_FP_REG (class) + if ((rclass == FPUL_REGS + || (REGCLASS_HAS_FP_REG (rclass) && ! TARGET_SHMEDIA && mode == SImode)) && (GET_CODE (x) == MEM || (GET_CODE (x) == REG @@ -11244,20 +11244,20 @@ sh_secondary_reload (bool in_p, rtx x, enum reg_class class, || REGNO (x) == T_REG || system_reg_operand (x, VOIDmode))))) { - if (class == FPUL_REGS) + if (rclass == FPUL_REGS) return GENERAL_REGS; return FPUL_REGS; } - if ((class == TARGET_REGS - || (TARGET_SHMEDIA && class == SIBCALL_REGS)) + if ((rclass == TARGET_REGS + || (TARGET_SHMEDIA && rclass == SIBCALL_REGS)) && !satisfies_constraint_Csy (x) && (GET_CODE (x) != REG || ! GENERAL_REGISTER_P (REGNO (x)))) return GENERAL_REGS; - if ((class == MAC_REGS || class == PR_REGS) + if ((rclass == MAC_REGS || rclass == PR_REGS) && GET_CODE (x) == REG && ! GENERAL_REGISTER_P (REGNO (x)) - && class != REGNO_REG_CLASS (REGNO (x))) + && rclass != REGNO_REG_CLASS (REGNO (x))) return GENERAL_REGS; - if (class != GENERAL_REGS && GET_CODE (x) == REG + if (rclass != GENERAL_REGS && GET_CODE (x) == REG && TARGET_REGISTER_P (REGNO (x))) return GENERAL_REGS; return NO_REGS; diff --git a/gcc/config/sparc/linux64.h b/gcc/config/sparc/linux64.h index 4c35dedacfb..4971048a31d 100644 --- a/gcc/config/sparc/linux64.h +++ b/gcc/config/sparc/linux64.h @@ -121,7 +121,7 @@ along with GCC; see the file COPYING3. If not see { "link_arch_default", LINK_ARCH_DEFAULT_SPEC }, \ { "link_arch", LINK_ARCH_SPEC }, -#define LINK_ARCH32_SPEC "-m elf32_sparc -Y P,/usr/lib %{shared:-shared} \ +#define LINK_ARCH32_SPEC "-m elf32_sparc -Y P,%R/usr/lib %{shared:-shared} \ %{!shared: \ %{!ibcs: \ %{!static: \ @@ -130,7 +130,7 @@ along with GCC; see the file COPYING3. If not see %{static:-static}}} \ " -#define LINK_ARCH64_SPEC "-m elf64_sparc -Y P,/usr/lib64 %{shared:-shared} \ +#define LINK_ARCH64_SPEC "-m elf64_sparc -Y P,%R/usr/lib64 %{shared:-shared} \ %{!shared: \ %{!ibcs: \ %{!static: \ @@ -211,7 +211,7 @@ along with GCC; see the file COPYING3. If not see #else /* !SPARC_BI_ARCH */ #undef LINK_SPEC -#define LINK_SPEC "-m elf64_sparc -Y P,/usr/lib64 %{shared:-shared} \ +#define LINK_SPEC "-m elf64_sparc -Y P,%R/usr/lib64 %{shared:-shared} \ %{!shared: \ %{!ibcs: \ %{!static: \ diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c index adf28c027b1..58667a2cb19 100644 --- a/gcc/config/sparc/sparc.c +++ b/gcc/config/sparc/sparc.c @@ -2371,6 +2371,8 @@ emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands) { case SImode: func = "_Qp_itoq"; + if (TARGET_ARCH64) + operands[1] = gen_rtx_SIGN_EXTEND (DImode, operands[1]); break; case DImode: func = "_Qp_xtoq"; @@ -2385,6 +2387,8 @@ emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands) { case SImode: func = "_Qp_uitoq"; + if (TARGET_ARCH64) + operands[1] = gen_rtx_ZERO_EXTEND (DImode, operands[1]); break; case DImode: func = "_Qp_uxtoq"; @@ -8637,7 +8641,7 @@ sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function) { - rtx this, insn, funexp; + rtx this_rtx, insn, funexp; unsigned int int_arg_first; reload_completed = 1; @@ -8668,9 +8672,9 @@ sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, /* Find the "this" pointer. Normally in %o0, but in ARCH64 if the function returns a structure, the structure return pointer is there instead. */ if (TARGET_ARCH64 && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function)) - this = gen_rtx_REG (Pmode, int_arg_first + 1); + this_rtx = gen_rtx_REG (Pmode, int_arg_first + 1); else - this = gen_rtx_REG (Pmode, int_arg_first); + this_rtx = gen_rtx_REG (Pmode, int_arg_first); /* Add DELTA. When possible use a plain add, otherwise load it into a register first. */ @@ -8685,11 +8689,11 @@ sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, delta_rtx = scratch; } - /* THIS += DELTA. */ - emit_insn (gen_add2_insn (this, delta_rtx)); + /* THIS_RTX += DELTA. */ + emit_insn (gen_add2_insn (this_rtx, delta_rtx)); } - /* Add the word at address (*THIS + VCALL_OFFSET). */ + /* Add the word at address (*THIS_RTX + VCALL_OFFSET). */ if (vcall_offset) { rtx vcall_offset_rtx = GEN_INT (vcall_offset); @@ -8697,8 +8701,8 @@ sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, gcc_assert (vcall_offset < 0); - /* SCRATCH = *THIS. */ - emit_move_insn (scratch, gen_rtx_MEM (Pmode, this)); + /* SCRATCH = *THIS_RTX. */ + emit_move_insn (scratch, gen_rtx_MEM (Pmode, this_rtx)); /* Prepare for adding VCALL_OFFSET. The difficulty is that we may not have any available scratch register at this point. */ @@ -8731,14 +8735,14 @@ sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, vcall_offset_rtx = GEN_INT (vcall_offset); /* cannot be 0 */ } - /* SCRATCH = *(*THIS + VCALL_OFFSET). */ + /* SCRATCH = *(*THIS_RTX + VCALL_OFFSET). */ emit_move_insn (scratch, gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, scratch, vcall_offset_rtx))); - /* THIS += *(*THIS + VCALL_OFFSET). */ - emit_insn (gen_add2_insn (this, scratch)); + /* THIS_RTX += *(*THIS_RTX + VCALL_OFFSET). */ + emit_insn (gen_add2_insn (this_rtx, scratch)); } /* Generate a tail call to the target function. */ diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c index b40d12c0149..1021a918275 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -352,6 +352,8 @@ spu_override_options (void) else error ("Unknown architecture '%s'", &spu_tune_string[0]); } + + REAL_MODE_FORMAT (SFmode) = &spu_single_format; } /* Handle an attribute requiring a FUNCTION_DECL; arguments as in @@ -1519,10 +1521,18 @@ spu_split_immediate (rtx * ops) { unsigned char arrhi[16]; unsigned char arrlo[16]; - rtx to, hi, lo; + rtx to, temp, hi, lo; int i; + enum machine_mode imode = mode; + /* We need to do reals as ints because the constant used in the + IOR might not be a legitimate real constant. */ + imode = int_mode_for_mode (mode); constant_to_array (mode, ops[1], arrhi); - to = !can_create_pseudo_p () ? ops[0] : gen_reg_rtx (mode); + if (imode != mode) + to = simplify_gen_subreg (imode, ops[0], mode, 0); + else + to = ops[0]; + temp = !can_create_pseudo_p () ? to : gen_reg_rtx (imode); for (i = 0; i < 16; i += 4) { arrlo[i + 2] = arrhi[i + 2]; @@ -1530,11 +1540,11 @@ spu_split_immediate (rtx * ops) arrlo[i + 0] = arrlo[i + 1] = 0; arrhi[i + 2] = arrhi[i + 3] = 0; } - hi = array_to_constant (mode, arrhi); - lo = array_to_constant (mode, arrlo); - emit_move_insn (to, hi); + hi = array_to_constant (imode, arrhi); + lo = array_to_constant (imode, arrlo); + emit_move_insn (temp, hi); emit_insn (gen_rtx_SET - (VOIDmode, ops[0], gen_rtx_IOR (mode, to, lo))); + (VOIDmode, to, gen_rtx_IOR (imode, temp, lo))); return 1; } case IC_FSMBI2: @@ -4565,7 +4575,7 @@ spu_restore_stack_block (rtx op0 ATTRIBUTE_UNUSED, rtx op1) int spu_safe_dma (HOST_WIDE_INT channel) { - return (channel >= 21 && channel <= 27); + return TARGET_SAFE_DMA && channel >= 21 && channel <= 27; } void diff --git a/gcc/config/spu/spu.h b/gcc/config/spu/spu.h index 4180c4e4638..0bd69d365cd 100644 --- a/gcc/config/spu/spu.h +++ b/gcc/config/spu/spu.h @@ -124,34 +124,6 @@ extern GTY(()) int spu_tune; #define STACK_SIZE_MODE SImode -/* #define TARGET_FLOAT_FORMAT SPU_FLOAT_FORMAT */ - -#ifndef MODE_HAS_NANS -#define MODE_HAS_NANS(MODE) \ - (FLOAT_MODE_P (MODE) \ - && MODE != SFmode \ - && !LARGEST_EXPONENT_IS_NORMAL (GET_MODE_BITSIZE (MODE))) -#endif - -#ifndef MODE_HAS_INFINITIES -#define MODE_HAS_INFINITIES(MODE) \ - (FLOAT_MODE_P (MODE) \ - && MODE != SFmode \ - && !LARGEST_EXPONENT_IS_NORMAL (GET_MODE_BITSIZE (MODE))) -#endif - -#ifndef MODE_HAS_SIGN_DEPENDENT_ROUNDING -#define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \ - (FLOAT_MODE_P (MODE) \ - && MODE != SFmode \ - && !ROUND_TOWARDS_ZERO) -#endif - -#define ROUND_TOWARDS_ZERO 1 - -/* This is certainly true. Should it be defined? (It wasn't before.) */ -/* #define LARGEST_EXPONENT_IS_NORMAL(size) (size != 32) */ - /* Type Layout */ @@ -290,6 +262,8 @@ targetm.resolve_overloaded_builtin = spu_resolve_overloaded_builtin; \ #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG(Pmode, LINK_REGISTER_REGNUM) +#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LINK_REGISTER_REGNUM) + #define ARG_POINTER_CFA_OFFSET(FNDECL) (-STACK_POINTER_OFFSET) diff --git a/gcc/config/spu/spu.md b/gcc/config/spu/spu.md index c267efd29d1..ffe46f53179 100644 --- a/gcc/config/spu/spu.md +++ b/gcc/config/spu/spu.md @@ -153,6 +153,8 @@ (UNSPEC_SPU_REALIGN_LOAD 49) (UNSPEC_SPU_MASK_FOR_LOAD 50) (UNSPEC_DFTSV 51) + (UNSPEC_FLOAT_EXTEND 52) + (UNSPEC_FLOAT_TRUNCATE 53) ]) (include "predicates.md") @@ -648,18 +650,79 @@ (define_insn "extendsfdf2" [(set (match_operand:DF 0 "spu_reg_operand" "=r") - (float_extend:DF (match_operand:SF 1 "spu_reg_operand" "r")))] + (unspec:DF [(match_operand:SF 1 "spu_reg_operand" "r")] + UNSPEC_FLOAT_EXTEND))] "" "fesd\t%0,%1" [(set_attr "type" "fpd")]) (define_insn "truncdfsf2" [(set (match_operand:SF 0 "spu_reg_operand" "=r") - (float_truncate:SF (match_operand:DF 1 "spu_reg_operand" "r")))] + (unspec:SF [(match_operand:DF 1 "spu_reg_operand" "r")] + UNSPEC_FLOAT_TRUNCATE))] "" "frds\t%0,%1" [(set_attr "type" "fpd")]) +(define_expand "floatdisf2" + [(set (match_operand:SF 0 "register_operand" "") + (float:SF (match_operand:DI 1 "register_operand" "")))] + "" + { + rtx c0 = gen_reg_rtx (SImode); + rtx r0 = gen_reg_rtx (DImode); + rtx r1 = gen_reg_rtx (SFmode); + rtx r2 = gen_reg_rtx (SImode); + rtx setneg = gen_reg_rtx (SImode); + rtx isneg = gen_reg_rtx (SImode); + rtx neg = gen_reg_rtx (DImode); + rtx mask = gen_reg_rtx (DImode); + + emit_move_insn (c0, GEN_INT (-0x80000000ll)); + + emit_insn (gen_negdi2 (neg, operands[1])); + emit_insn (gen_cgt_di_m1 (isneg, operands[1])); + emit_insn (gen_extend_compare (mask, isneg)); + emit_insn (gen_selb (r0, neg, operands[1], mask)); + emit_insn (gen_andc_si (setneg, c0, isneg)); + + emit_insn (gen_floatunsdisf2 (r1, r0)); + + emit_insn (gen_iorsi3 (r2, gen_rtx_SUBREG (SImode, r1, 0), setneg)); + emit_move_insn (operands[0], gen_rtx_SUBREG (SFmode, r2, 0)); + DONE; + }) + +(define_insn_and_split "floatunsdisf2" + [(set (match_operand:SF 0 "register_operand" "=r") + (unsigned_float:SF (match_operand:DI 1 "register_operand" "r"))) + (clobber (match_scratch:SF 2 "=r")) + (clobber (match_scratch:SF 3 "=r")) + (clobber (match_scratch:SF 4 "=r"))] + "" + "#" + "reload_completed" + [(set (match_dup:SF 0) + (unsigned_float:SF (match_dup:DI 1)))] + { + rtx op1_v4si = gen_rtx_REG (V4SImode, REGNO (operands[1])); + rtx op2_v4sf = gen_rtx_REG (V4SFmode, REGNO (operands[2])); + rtx op2_ti = gen_rtx_REG (TImode, REGNO (operands[2])); + rtx op3_ti = gen_rtx_REG (TImode, REGNO (operands[3])); + + REAL_VALUE_TYPE scale; + real_2expN (&scale, 32, SFmode); + + emit_insn (gen_floatunsv4siv4sf2 (op2_v4sf, op1_v4si)); + emit_insn (gen_shlqby_ti (op3_ti, op2_ti, GEN_INT (4))); + + emit_move_insn (operands[4], + CONST_DOUBLE_FROM_REAL_VALUE (scale, SFmode)); + emit_insn (gen_fma_sf (operands[0], + operands[2], operands[4], operands[3])); + DONE; + }) + ;; Do (double)(operands[1]+0x80000000u)-(double)0x80000000 (define_expand "floatsidf2" [(set (match_operand:DF 0 "register_operand" "") diff --git a/gcc/config/spu/t-spu-elf b/gcc/config/spu/t-spu-elf index 0a3947d9017..017f09d1fb6 100644 --- a/gcc/config/spu/t-spu-elf +++ b/gcc/config/spu/t-spu-elf @@ -21,8 +21,15 @@ CROSS_LIBGCC1 = TARGET_LIBGCC2_CFLAGS = -fPIC -mwarn-reloc -D__IN_LIBGCC2 +# We exclude those because the libgcc2.c default versions do not support +# the SPU single-precision format (round towards zero). We provide our +# own versions below. +LIB2FUNCS_EXCLUDE = _floatdisf _floatundisf + LIB2FUNCS_STATIC_EXTRA = $(srcdir)/config/spu/float_unssidf.c \ $(srcdir)/config/spu/float_unsdidf.c \ + $(srcdir)/config/spu/float_unsdisf.c \ + $(srcdir)/config/spu/float_disf.c \ $(srcdir)/config/spu/mfc_tag_table.c \ $(srcdir)/config/spu/mfc_tag_reserve.c \ $(srcdir)/config/spu/mfc_tag_release.c \ diff --git a/gcc/config/stormy16/stormy16.c b/gcc/config/stormy16/stormy16.c index 64ecec8f5e5..77aedd6e01e 100644 --- a/gcc/config/stormy16/stormy16.c +++ b/gcc/config/stormy16/stormy16.c @@ -283,7 +283,7 @@ xstormy16_output_cbranch_hi (rtx op, const char *label, int reversed, rtx insn) : get_attr_length (insn) == 4); int really_reversed = reversed ^ need_longbranch; const char *ccode; - const char *template; + const char *templ; const char *operands; enum rtx_code code; @@ -329,10 +329,10 @@ xstormy16_output_cbranch_hi (rtx op, const char *label, int reversed, rtx insn) } if (need_longbranch) - template = "b%s %s,.+8 | jmpf %s"; + templ = "b%s %s,.+8 | jmpf %s"; else - template = "b%s %s,%s"; - sprintf (string, template, ccode, operands, label); + templ = "b%s %s,%s"; + sprintf (string, templ, ccode, operands, label); return string; } @@ -354,7 +354,7 @@ xstormy16_output_cbranch_si (rtx op, const char *label, int reversed, rtx insn) int need_longbranch = get_attr_length (insn) >= 8; int really_reversed = reversed ^ need_longbranch; const char *ccode; - const char *template; + const char *templ; char prevop[16]; enum rtx_code code; @@ -400,10 +400,10 @@ xstormy16_output_cbranch_si (rtx op, const char *label, int reversed, rtx insn) } if (need_longbranch) - template = "%s | b%s .+6 | jmpf %s"; + templ = "%s | b%s .+6 | jmpf %s"; else - template = "%s | b%s %s"; - sprintf (string, template, prevop, ccode, label); + templ = "%s | b%s %s"; + sprintf (string, templ, prevop, ccode, label); return string; } @@ -420,11 +420,11 @@ xstormy16_output_cbranch_si (rtx op, const char *label, int reversed, rtx insn) You should define these macros to indicate to the reload phase that it may need to allocate at least one register for a reload in addition to the register to contain the data. Specifically, if copying X to a register - CLASS in MODE requires an intermediate register, you should define + RCLASS in MODE requires an intermediate register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to return the largest register class all of whose registers can be used as intermediate registers or scratch registers. - If copying a register CLASS in MODE to X requires an intermediate or scratch + If copying a register RCLASS in MODE to X requires an intermediate or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be defined to return the largest register class required. If the requirements for input and output reloads are the same, the macro `SECONDARY_RELOAD_CLASS' should be used @@ -432,7 +432,7 @@ xstormy16_output_cbranch_si (rtx op, const char *label, int reversed, rtx insn) The values returned by these macros are often `GENERAL_REGS'. Return `NO_REGS' if no spare register is needed; i.e., if X can be directly copied - to or from a register of CLASS in MODE without requiring a scratch register. + to or from a register of RCLASS in MODE without requiring a scratch register. Do not define this macro if it would always return `NO_REGS'. If a scratch register is required (either with or without an intermediate @@ -443,7 +443,7 @@ xstormy16_output_cbranch_si (rtx op, const char *label, int reversed, rtx insn) Define constraints for the reload register and scratch register that contain a single register class. If the original reload register (whose class is - CLASS) can meet the constraint given in the pattern, the value returned by + RCLASS) can meet the constraint given in the pattern, the value returned by these macros is used for the class of the scratch register. Otherwise, two additional reload registers are required. Their classes are obtained from the constraints in the insn pattern. @@ -461,7 +461,7 @@ xstormy16_output_cbranch_si (rtx op, const char *label, int reversed, rtx insn) This case often occurs between floating-point and general registers. */ enum reg_class -xstormy16_secondary_reload_class (enum reg_class class, +xstormy16_secondary_reload_class (enum reg_class rclass, enum machine_mode mode, rtx x) { @@ -471,7 +471,7 @@ xstormy16_secondary_reload_class (enum reg_class class, || ((GET_CODE (x) == SUBREG || GET_CODE (x) == REG) && (true_regnum (x) == -1 || true_regnum (x) >= FIRST_PSEUDO_REGISTER))) - && ! reg_class_subset_p (class, EIGHT_REGS)) + && ! reg_class_subset_p (rclass, EIGHT_REGS)) return EIGHT_REGS; /* When reloading a PLUS, the carry register will be required @@ -483,13 +483,13 @@ xstormy16_secondary_reload_class (enum reg_class class, } enum reg_class -xstormy16_preferred_reload_class (rtx x, enum reg_class class) +xstormy16_preferred_reload_class (rtx x, enum reg_class rclass) { - if (class == GENERAL_REGS + if (rclass == GENERAL_REGS && GET_CODE (x) == MEM) return EIGHT_REGS; - return class; + return rclass; } /* Predicate for symbols and addresses that reflect special 8-bit diff --git a/gcc/config/vax/vax.h b/gcc/config/vax/vax.h index 68726ffcf2b..84a6ba4bd1a 100644 --- a/gcc/config/vax/vax.h +++ b/gcc/config/vax/vax.h @@ -642,10 +642,6 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES }; so give the MEM rtx a byte's mode. */ #define FUNCTION_MODE QImode -/* This machine doesn't use IEEE floats. */ - -#define TARGET_FLOAT_FORMAT VAX_FLOAT_FORMAT - /* Specify the cost of a branch insn; roughly the number of extra insns that should be added to avoid a branch. diff --git a/gcc/config/xtensa/xtensa.c b/gcc/config/xtensa/xtensa.c index 392eafa0eee..0f6bbb50ed6 100644 --- a/gcc/config/xtensa/xtensa.c +++ b/gcc/config/xtensa/xtensa.c @@ -1030,8 +1030,10 @@ xtensa_copy_incoming_a7 (rtx opnd) { case DFmode: case DImode: - emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 0), - gen_rtx_REG (SImode, A7_REG - 1))); + /* Copy the value out of A7 here but keep the first word in A6 until + after the set_frame_ptr insn. Otherwise, the register allocator + may decide to put "subreg (tmp, 0)" in A7 and clobber the incoming + value. */ emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 4), gen_raw_REG (SImode, A7_REG))); break; @@ -1052,6 +1054,11 @@ xtensa_copy_incoming_a7 (rtx opnd) } cfun->machine->set_frame_ptr_insn = emit_insn (gen_set_frame_ptr ()); + + /* For DF and DI mode arguments, copy the incoming value in A6 now. */ + if (mode == DFmode || mode == DImode) + emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 0), + gen_rtx_REG (SImode, A7_REG - 1))); entry_insns = get_insns (); end_sequence (); @@ -1310,10 +1317,10 @@ init_alignment_context (struct alignment_context *ac, rtx mem) /* Expand an atomic compare and swap operation for HImode and QImode. MEM is the memory location, CMP the old value to compare MEM with - and NEW the value to set if CMP == MEM. */ + and NEW_RTX the value to set if CMP == MEM. */ void -xtensa_expand_compare_and_swap (rtx target, rtx mem, rtx cmp, rtx new) +xtensa_expand_compare_and_swap (rtx target, rtx mem, rtx cmp, rtx new_rtx) { enum machine_mode mode = GET_MODE (mem); struct alignment_context ac; @@ -1328,7 +1335,7 @@ xtensa_expand_compare_and_swap (rtx target, rtx mem, rtx cmp, rtx new) if (ac.shift != NULL_RTX) { cmp = xtensa_expand_mask_and_shift (cmp, mode, ac.shift); - new = xtensa_expand_mask_and_shift (new, mode, ac.shift); + new_rtx = xtensa_expand_mask_and_shift (new_rtx, mode, ac.shift); } /* Load the surrounding word into VAL with the MEM value masked out. */ @@ -1337,10 +1344,10 @@ xtensa_expand_compare_and_swap (rtx target, rtx mem, rtx cmp, rtx new) OPTAB_DIRECT)); emit_label (csloop); - /* Patch CMP and NEW into VAL at correct position. */ + /* Patch CMP and NEW_RTX into VAL at correct position. */ cmpv = force_reg (SImode, expand_simple_binop (SImode, IOR, cmp, val, NULL_RTX, 1, OPTAB_DIRECT)); - newv = force_reg (SImode, expand_simple_binop (SImode, IOR, new, val, + newv = force_reg (SImode, expand_simple_binop (SImode, IOR, new_rtx, val, NULL_RTX, 1, OPTAB_DIRECT)); /* Jump to end if we're done. */ @@ -1384,7 +1391,7 @@ xtensa_expand_atomic (enum rtx_code code, rtx target, rtx mem, rtx val, rtx csloop = gen_label_rtx (); rtx cmp, tmp; rtx old = gen_reg_rtx (SImode); - rtx new = gen_reg_rtx (SImode); + rtx new_rtx = gen_reg_rtx (SImode); rtx orig = NULL_RTX; init_alignment_context (&ac, mem); @@ -1435,35 +1442,35 @@ xtensa_expand_atomic (enum rtx_code code, rtx target, rtx mem, rtx val, tmp = expand_simple_binop (SImode, AND, old, ac.modemaski, NULL_RTX, 1, OPTAB_DIRECT); tmp = expand_simple_binop (SImode, IOR, tmp, val, - new, 1, OPTAB_DIRECT); + new_rtx, 1, OPTAB_DIRECT); break; case AND: case IOR: case XOR: tmp = expand_simple_binop (SImode, code, old, val, - new, 1, OPTAB_DIRECT); + new_rtx, 1, OPTAB_DIRECT); break; case MULT: /* NAND */ tmp = expand_simple_binop (SImode, XOR, old, ac.modemask, NULL_RTX, 1, OPTAB_DIRECT); tmp = expand_simple_binop (SImode, AND, tmp, val, - new, 1, OPTAB_DIRECT); + new_rtx, 1, OPTAB_DIRECT); break; default: gcc_unreachable (); } - if (tmp != new) - emit_move_insn (new, tmp); - emit_insn (gen_sync_compare_and_swapsi (cmp, ac.memsi, old, new)); + if (tmp != new_rtx) + emit_move_insn (new_rtx, tmp); + emit_insn (gen_sync_compare_and_swapsi (cmp, ac.memsi, old, new_rtx)); emit_cmp_and_jump_insns (cmp, old, NE, const0_rtx, SImode, true, csloop); if (target) { - tmp = (after ? new : cmp); + tmp = (after ? new_rtx : cmp); convert_move (target, (ac.shift == NULL_RTX ? tmp : expand_simple_binop (SImode, LSHIFTRT, tmp, ac.shift, @@ -1884,7 +1891,7 @@ override_options (void) mode = (enum machine_mode) ((int) mode + 1)) { int size = GET_MODE_SIZE (mode); - enum mode_class class = GET_MODE_CLASS (mode); + enum mode_class mclass = GET_MODE_CLASS (mode); for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) { @@ -1892,7 +1899,7 @@ override_options (void) if (ACC_REG_P (regno)) temp = (TARGET_MAC16 - && (class == MODE_INT) && (size <= UNITS_PER_WORD)); + && (mclass == MODE_INT) && (size <= UNITS_PER_WORD)); else if (GP_REG_P (regno)) temp = ((regno & 1) == 0 || (size <= UNITS_PER_WORD)); else if (FP_REG_P (regno)) @@ -2814,7 +2821,7 @@ xtensa_expand_builtin (tree exp, rtx target, enum reg_class -xtensa_preferred_reload_class (rtx x, enum reg_class class, int isoutput) +xtensa_preferred_reload_class (rtx x, enum reg_class rclass, int isoutput) { if (!isoutput && CONSTANT_P (x) && GET_CODE (x) == CONST_DOUBLE) return NO_REGS; @@ -2825,15 +2832,15 @@ xtensa_preferred_reload_class (rtx x, enum reg_class class, int isoutput) won't know that it is live because the hard frame pointer is treated specially. */ - if (class == AR_REGS || class == GR_REGS) + if (rclass == AR_REGS || rclass == GR_REGS) return RL_REGS; - return class; + return rclass; } enum reg_class -xtensa_secondary_reload_class (enum reg_class class, +xtensa_secondary_reload_class (enum reg_class rclass, enum machine_mode mode ATTRIBUTE_UNUSED, rtx x, int isoutput) { @@ -2845,14 +2852,14 @@ xtensa_secondary_reload_class (enum reg_class class, if (!isoutput) { - if ((class == FP_REGS || GET_MODE_SIZE (mode) < UNITS_PER_WORD) + if ((rclass == FP_REGS || GET_MODE_SIZE (mode) < UNITS_PER_WORD) && constantpool_mem_p (x)) return RL_REGS; } if (ACC_REG_P (regno)) - return ((class == GR_REGS || class == RL_REGS) ? NO_REGS : RL_REGS); - if (class == ACC_REG) + return ((rclass == GR_REGS || rclass == RL_REGS) ? NO_REGS : RL_REGS); + if (rclass == ACC_REG) return (GP_REG_P (regno) ? NO_REGS : RL_REGS); return NO_REGS; diff --git a/gcc/configure b/gcc/configure index 9da77b55653..a847b9ea114 100755 --- a/gcc/configure +++ b/gcc/configure @@ -21498,7 +21498,6 @@ fi .cfi_same_value 1 .cfi_def_cfa 1, 2 .cfi_escape 1, 2, 3, 4, 5 - .cfi_personality 0, symbol .cfi_endproc' > conftest.s if { ac_try='$gcc_cv_as -o conftest.o conftest.s >&5' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 @@ -21524,6 +21523,47 @@ cat >>confdefs.h <<_ACEOF _ACEOF +echo "$as_me:$LINENO: checking assembler for cfi personality directive" >&5 +echo $ECHO_N "checking assembler for cfi personality directive... $ECHO_C" >&6 +if test "${gcc_cv_as_cfi_personality_directive+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + gcc_cv_as_cfi_personality_directive=no + if test $in_tree_gas = yes; then + if test $in_tree_gas_is_elf = yes \ + && test $gcc_cv_gas_vers -ge `expr \( \( 2 \* 1000 \) + 17 \) \* 1000 + 0` + then gcc_cv_as_cfi_personality_directive=yes +fi + elif test x$gcc_cv_as != x; then + echo ' .text + .cfi_startproc, + .cfi_personality 0, symbol + .cfi_endproc' > conftest.s + if { ac_try='$gcc_cv_as -o conftest.o conftest.s >&5' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } + then + gcc_cv_as_cfi_personality_directive=yes + else + echo "configure: failed program was" >&5 + cat conftest.s >&5 + fi + rm -f conftest.o conftest.s + fi +fi +echo "$as_me:$LINENO: result: $gcc_cv_as_cfi_personality_directive" >&5 +echo "${ECHO_T}$gcc_cv_as_cfi_personality_directive" >&6 + + +cat >>confdefs.h <<_ACEOF +#define HAVE_GAS_CFI_PERSONALITY_DIRECTIVE `if test $gcc_cv_as_cfi_personality_directive = yes; + then echo 1; else echo 0; fi` +_ACEOF + + # GAS versions up to and including 2.11.0 may mis-optimize # .eh_frame data. echo "$as_me:$LINENO: checking assembler for eh_frame optimization" >&5 @@ -23230,6 +23270,52 @@ _ACEOF fi + case $target in + *-*-aix*) conftest_s=' .machine "pwr7" + .csect .text[PR] + lxvd2x 1,2,3';; + *) conftest_s=' .machine power7 + .text + lxvd2x 1,2,3';; + esac + + echo "$as_me:$LINENO: checking assembler for vector-scalar support" >&5 +echo $ECHO_N "checking assembler for vector-scalar support... $ECHO_C" >&6 +if test "${gcc_cv_as_powerpc_vsx+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + gcc_cv_as_powerpc_vsx=no + if test $in_tree_gas = yes; then + if test $gcc_cv_gas_vers -ge `expr \( \( 9 \* 1000 \) + 99 \) \* 1000 + 0` + then gcc_cv_as_powerpc_vsx=yes +fi + elif test x$gcc_cv_as != x; then + echo "$conftest_s" > conftest.s + if { ac_try='$gcc_cv_as -a32 -o conftest.o conftest.s >&5' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } + then + gcc_cv_as_powerpc_vsx=yes + else + echo "configure: failed program was" >&5 + cat conftest.s >&5 + fi + rm -f conftest.o conftest.s + fi +fi +echo "$as_me:$LINENO: result: $gcc_cv_as_powerpc_vsx" >&5 +echo "${ECHO_T}$gcc_cv_as_powerpc_vsx" >&6 +if test $gcc_cv_as_powerpc_vsx = yes; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_AS_VSX 1 +_ACEOF + +fi + echo "$as_me:$LINENO: checking assembler for .gnu_attribute support" >&5 echo $ECHO_N "checking assembler for .gnu_attribute support... $ECHO_C" >&6 if test "${gcc_cv_as_powerpc_gnu_attribute+set}" = set; then @@ -23447,7 +23533,7 @@ esac case "$target" in i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \ | x86_64*-*-* | hppa*-*-* | arm*-*-* \ - | xstormy16*-*-* | cris-*-* | xtensa-*-* | bfin-*-* | score*-*-* \ + | xstormy16*-*-* | cris-*-* | xtensa*-*-* | bfin-*-* | score*-*-* \ | spu-*-* | fido*-*-*) insn="nop" ;; diff --git a/gcc/configure.ac b/gcc/configure.ac index a1a2e182e1b..6f7e5457f94 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -2496,11 +2496,21 @@ gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive, .cfi_same_value 1 .cfi_def_cfa 1, 2 .cfi_escape 1, 2, 3, 4, 5 - .cfi_personality 0, symbol .cfi_endproc]) AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE, [`if test $gcc_cv_as_cfi_directive = yes; then echo 1; else echo 0; fi`], -[Define 0/1 if your assembler supports CFI directives.]) + [Define 0/1 if your assembler supports CFI directives.]) + +gcc_GAS_CHECK_FEATURE([cfi personality directive], + gcc_cv_as_cfi_personality_directive, [elf,2,17,0],, +[ .text + .cfi_startproc, + .cfi_personality 0, symbol + .cfi_endproc]) +AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE, + [`if test $gcc_cv_as_cfi_personality_directive = yes; + then echo 1; else echo 0; fi`], + [Define 0/1 if your assembler supports .cfi_personality.]) # GAS versions up to and including 2.11.0 may mis-optimize # .eh_frame data. @@ -3328,6 +3338,21 @@ LCF0: [AC_DEFINE(HAVE_AS_DFP, 1, [Define if your assembler supports DFP instructions.])]) + case $target in + *-*-aix*) conftest_s=' .machine "pwr7" + .csect .text[[PR]] + lxvd2x 1,2,3';; + *) conftest_s=' .machine power7 + .text + lxvd2x 1,2,3';; + esac + + gcc_GAS_CHECK_FEATURE([vector-scalar support], + gcc_cv_as_powerpc_vsx, [9,99,0], -a32, + [$conftest_s],, + [AC_DEFINE(HAVE_AS_VSX, 1, + [Define if your assembler supports VSX instructions.])]) + gcc_GAS_CHECK_FEATURE([.gnu_attribute support], gcc_cv_as_powerpc_gnu_attribute, [2,18,0],, [.gnu_attribute 4,1],, @@ -3392,7 +3417,7 @@ esac case "$target" in i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \ | x86_64*-*-* | hppa*-*-* | arm*-*-* \ - | xstormy16*-*-* | cris-*-* | xtensa-*-* | bfin-*-* | score*-*-* \ + | xstormy16*-*-* | cris-*-* | xtensa*-*-* | bfin-*-* | score*-*-* \ | spu-*-* | fido*-*-*) insn="nop" ;; diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 8ece21d96f9..48aab06d245 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,11 +1,98 @@ +2008-08-14 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/34600 + * decl.c (grokdeclarator): In case of extern and initializer, return + error_mark_node after the error. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 30551 + * decl.c (grokfndecl): Call check_main_parameters_type only if + -Wmain. + +2008-08-12 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/37087 + * parser.c (cp_parser_class_head): Early return error_mark_node in + case of global qualification of class name or qualified name that + does not name a class. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c++/12242 + * cvt.c (ocp_convert): Warn for out-of-range conversions to enum. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 36901 + * cp-tree.h (struct diagnostic_context, struct diagnostic_info): + Delete forward declarations. Check that toplev.h has not been + included before this file. Include toplev.h and diagnostic.h. + * error.c (cp_cpp_error): Use DK_PEDWARN. + (cxx_incomplete_type_diagnostic): Update declaration. + (cxx_incomplete_type_error): Use DK_ERROR. + * typeck2.c (cxx_incomplete_type_diagnostic): Take a diagnostic_t + as argument. Use emit_diagnostic. + (cxx_incomplete_type_error): Use DK_ERROR. + (add_exception_specifier): Use diagnostic_t instead of custom + codes. + * typeck.c (complete_type_or_else): Update call to + cxx_incomplete_type_diagnostic. + * init.c (build_delete): Likewise. + * call.c (diagnostic_fn_t): Remove unused typedef. + (build_temp): Pass a pointer to diagnostic_t. + (convert_like_real): Use emit_diagnostic. + (joust): Check return value of warning before giving informative + note. + * friend.c (do_friend): Check return value of warning + before giving informative note. + * parser.c (cp_parser_template_id): Likewise. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 7651 + * class.c (check_bases_and_members): Warn with -Wuninitialized + instead of -Wextra. + +2008-08-08 Volker Reichelt <v.reichelt@netcologne.de> + + PR c++/35985 + * decl.c (xref_basetypes): Check base for MAYBE_CLASS_TYPE_P, + and make sure it is not a union. + +2008-08-07 H.J. Lu <hongjiu.lu@intel.com> + + * semantics.c (finish_decltype_type): Initialize type. + +2008-08-07 Douglas Gregor <doug.gregor@gmail.com> + + * semantics.c (finish_decltype_type): Handle calls to function + pointers and references to functions properly. + +2008-08-06 Douglas Gregor <doug.gregor@gmail.com> + + PR c++/36460 + * parser.c (cp_parser_template_argument): Don't assume that '>>' + following a type-id is an error when in C++0x mode. + +2008-08-06 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 26785 + * decl.c (grokdeclarator): Use explicit location with permerror_at. + +2008-08-06 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 8715 + * typeck.c (cp_build_binary_op): Move code to c-common.c. + 2008-08-05 Jason Merrill <jason@redhat.com> PR c++/37016 - * decl.c (build_ptrmemfunc_type): Don't require structural + * decl.c (build_ptrmemfunc_type): Don't require structural comparison of PMF types. * tree.c (cp_build_qualified_type_real): Don't clear a valid TYPE_PTRMEMFUNC_TYPE. - * typeck.c (cp_build_unary_op): Still do build_ptrmemfunc in + * typeck.c (cp_build_unary_op): Still do build_ptrmemfunc in templates. 2008-08-04 Jason Merrill <jason@redhat.com> @@ -40,11 +127,11 @@ * tree.c (build_aggr_init_expr): Split out... (build_cplus_new): ...from here. (stabilize_init): Don't mess with AGGR_INIT_EXPR either. - * init.c (build_new_1): new T() means value-initialization, + * init.c (build_new_1): new T() means value-initialization, not default-initialization. (build_vec_init): Likewise. (build_value_init_1): Use build_aggr_init_expr. - + 2008-07-30 Dodji Seketeli <dseketel@redhat.com> PR c++/36767 @@ -58,7 +145,7 @@ PR 34389 * typeck.c (build_binary_op): Encapsulate code into shorten_binary_op. - + 2008-07-29 Jakub Jelinek <jakub@redhat.com> PR c++/36852 @@ -81,7 +168,7 @@ PR 34985 * decl.c (duplicate_decls): Merge USED flags. - + 2008-07-27 Jason Merrill <jason@redhat.com> PR c++/36943 @@ -136,10 +223,10 @@ 2008-04-29 Doug Kwan <dougkwan@google.com> - * decl2 (File): Include "gimple.h" - (cp_write_global_declarations): Use gimple_body instead of - DECL_SAVED_TREE. - * Make-lang.in (cp/decl2.o): Add $(GIMPLE_H) + * decl2 (File): Include "gimple.h" + (cp_write_global_declarations): Use gimple_body instead of + DECL_SAVED_TREE. + * Make-lang.in (cp/decl2.o): Add $(GIMPLE_H) 2008-04-10 Diego Novillo <dnovillo@google.com> @@ -528,7 +615,7 @@ (LOOKUP_NO_COPY_CTOR_CONVERSION): New macro. * parser.c (cp_parse_braced_list): Split out from... (cp_parser_initializer_clause): ...here. - (cp_parser_postfix_expression): Build up CONSTRUCTOR for compound + (cp_parser_postfix_expression): Build up CONSTRUCTOR for compound literal here. (cp_lexer_next_token_is_not_keyword): New fn. (cp_parser_parenthesized_expression_list): Handle { }. @@ -548,7 +635,7 @@ (add_function_candidate): Handle LOOKUP_NO_COPY_CTOR_CONVERSION. (build_user_type_conversion_1): When converting from an init list, we allow additional conversions except when calling a copy ctor. - (convert_like_real): Calling an explicit ctor for an init list is + (convert_like_real): Calling an explicit ctor for an init list is ill-formed. Handle ck_list and ck_addr. Check narrowing. (build_new_method_call): If CONSTRUCTOR_IS_DIRECT_INIT is set and class doesn't have a list ctor, break the {} into a TREE_LIST. @@ -566,7 +653,7 @@ (grokdeclarator): Converting constructors can have more than one parm. (grok_special_member_properties): Set TYPE_HAS_LIST_CTOR. * init.c (expand_default_init): Only do digest_init for aggregates. - * rtti.c (tinfo_base_init): Pass init_list_type_node to + * rtti.c (tinfo_base_init): Pass init_list_type_node to build_constructor_from_list. (generic_initializer, ptr_initializer): Ditto. (ptm_initializer, class_initializer): Ditto. @@ -579,7 +666,7 @@ * typeck2.c (store_init_value): Use init_list_type_node. (digest_init): Likewise. (check_narrowing): New fn. - * semantics.c: (finish_compound_literal): Take CONSTRUCTOR instead + * semantics.c: (finish_compound_literal): Take CONSTRUCTOR instead of vector of constructor elts. Handle non-aggregate types. Make constant literals static. * pt.c: (tsubst_copy_and_build): Adjust. @@ -699,16 +786,16 @@ 2008-06-08 Paolo Carlini <paolo.carlini@oracle.com> - PR c++/35242 - * pt.c (maybe_process_partial_specialization): Check the tree + PR c++/35242 + * pt.c (maybe_process_partial_specialization): Check the tree returned by push_template_decl for error_mark_node. * parser.c (cp_parser_class_head): Likewise, check the tree - returned by the latter. + returned by the latter. 2008-06-07 Paolo Carlini <paolo.carlini@oracle.com> - PR c++/35327 - * decl.c (grokdeclarator): In case of wrong return type return + PR c++/35327 + * decl.c (grokdeclarator): In case of wrong return type return immediately error_mark_node. 2008-06-06 Jakub Jelinek <jakub@redhat.com> @@ -780,22 +867,22 @@ 2008-06-02 Paolo Carlini <paolo.carlini@oracle.com> - PR c++/36404 - * pt.c (push_template_decl_real): Consistently return error_mark_node + PR c++/36404 + * pt.c (push_template_decl_real): Consistently return error_mark_node on error. 2008-06-02 Tomas Bily <tbily@suse.cz> - * typeck.c (is_bitfield_expr_with_lowered_type): Use CASE_CONVERT. - (cp_build_unary_op): Likewise. - (cp_build_indirect_ref): Use CONVERT_EXPR_P. - (maybe_warn_about_returning_address_of_local): Likewise. + * typeck.c (is_bitfield_expr_with_lowered_type): Use CASE_CONVERT. + (cp_build_unary_op): Likewise. + (cp_build_indirect_ref): Use CONVERT_EXPR_P. + (maybe_warn_about_returning_address_of_local): Likewise. 2008-05-29 Paolo Carlini <paolo.carlini@oracle.com> - PR c++/35243 - * pt.c (tsubst_initializer_list): Consistently check the tree - returned by tsubst_pack_expansion for error_mark_node. + PR c++/35243 + * pt.c (tsubst_initializer_list): Consistently check the tree + returned by tsubst_pack_expansion for error_mark_node. 2008-05-27 Michael Matz <matz@suse.de> @@ -851,16 +938,16 @@ 2008-05-12 Paolo Carlini <paolo.carlini@oracle.com> - PR c++/35331 - * semantics.c (begin_class_definition): Extend checks on the first + PR c++/35331 + * semantics.c (begin_class_definition): Extend checks on the first argument. 2008-05-12 Tomas Bily <tbily@suse.cz> - * typeck2.c (digest_init): Use CONVERT_EXPR_P. - * call.c (build_over_call): Likewise. - * error.c (dump_expr): Use CASE_CONVERT. - * class.c (fixed_type_or_null): Likewise. + * typeck2.c (digest_init): Use CONVERT_EXPR_P. + * call.c (build_over_call): Likewise. + * error.c (dump_expr): Use CASE_CONVERT. + * class.c (fixed_type_or_null): Likewise. 2008-05-11 Volker Reichelt <v.reichelt@netcologne.de> @@ -967,7 +1054,7 @@ * tree.c (cp_tree_equal): Handle FIXED_CST. PR c++/35678 - * pt.c (template_template_parm_bindings_ok_p): Set + * pt.c (template_template_parm_bindings_ok_p): Set processing_template_decl while in this function. 2008-04-18 Kris Van Hees <kris.van.hees@oracle.com> @@ -985,14 +1072,14 @@ (cp_parser_string_literal): Idem. (cp_parser_primary_expression): Support CPP_CHAR{16,32} and CPP_STRING{16,32}. - (cp_parser_simple_type_specifier): Support RID_CHAR{16,32}. + (cp_parser_simple_type_specifier): Support RID_CHAR{16,32}. * tree.c (char_type_p): Support char16_t and char32_t as char types. * typeck.c (string_conv_p): Support char16_t and char32_t. 2008-04-17 Jason Merrill <jason@redhat.com> PR c++/35773 - * call.c (build_user_type_conversion_1): Represent second step of + * call.c (build_user_type_conversion_1): Represent second step of copy-init with an rvalue conversion. (convert_like_real) [ck_user]: Don't implicitly add it here. @@ -1004,14 +1091,14 @@ 2008-04-16 Danny Smith <dannysmith@users.sourceforge.net> - PR target/35921 - * optimize.c (maybe_clone_body): Copy DECL_DLLIMPORT_P flag - to clone. + PR target/35921 + * optimize.c (maybe_clone_body): Copy DECL_DLLIMPORT_P flag + to clone. 2008-04-09 Jason Merrill <jason@redhat.com> PR c++/35708 - * semantics.c (finish_compound_literal): Return a TARGET_EXPR, + * semantics.c (finish_compound_literal): Return a TARGET_EXPR, not a pushed variable. 2008-04-09 Volker Reichelt <v.reichelt@netcologne.de> @@ -1128,7 +1215,7 @@ 2008-04-07 Jason Merrill <jason@redhat.com> PR c++/35734 - * class.c (type_has_user_nondefault_constructor): A template + * class.c (type_has_user_nondefault_constructor): A template counts as a nondefault constructor. 2008-04-04 Paolo Bonzini <bonzini@gnu.org> @@ -1156,14 +1243,14 @@ * Make-lang.in (c++_OBJS): New variable. 2008-04-03 Paolo Bonzini <bonzini@gnu.org> - + * optimize.c (clone_body): New, from tree-inline.c. 2008-04-03 Paolo Bonzini <bonzini@gnu.org> - * method.c (synthesize_method): Use {push,pop}_function_context. - * name-lookup.c (push_to_top_level): Likewise. - * parser.c (cp_parser_late_parsing_for_member): Likewise. + * method.c (synthesize_method): Use {push,pop}_function_context. + * name-lookup.c (push_to_top_level): Likewise. + * parser.c (cp_parser_late_parsing_for_member): Likewise. 2008-03-30 Volker Reichelt <v.reichelt@netcologne.de> @@ -1217,17 +1304,17 @@ 2008-03-26 Douglas Gregor <doug.gregor@gmail.com> - * pt.c (coerce_template_template_parm): Moved the body of the loop - of coerce_template_template_parms here, to make iteration over a - template argument pack simpler. - Also, allow matching of a template parameter pack in the template - template parameter to a template parameter in the template - template argument. - (coerce_template_template_parms): Deal with variadic template - template parameters. Use coerce_template_template_parm. - (unify): Make sure we coerce the template template argument's - template arguments to the template template parameter's template - parameters, not the other way around. + * pt.c (coerce_template_template_parm): Moved the body of the loop + of coerce_template_template_parms here, to make iteration over a + template argument pack simpler. + Also, allow matching of a template parameter pack in the template + template parameter to a template parameter in the template + template argument. + (coerce_template_template_parms): Deal with variadic template + template parameters. Use coerce_template_template_parm. + (unify): Make sure we coerce the template template argument's + template arguments to the template template parameter's template + parameters, not the other way around. 2008-03-25 Tom Tromey <tromey@redhat.com> @@ -1239,208 +1326,208 @@ 2008-03-25 Douglas Gregor <doug.gregor@gmail.com> - * typeck.c (composite_pointer_type_r): Add SFINAE support. - (composite_pointer_type): Ditto. - (common_type): Fix call to composite_pointer_type. - (cxx_sizeof_nowarn): New; used to be a macro. - (cxx_sizeof_expr): Add SFINAE support. - (cxx_alignof_expr): Ditto. - (decay_conversion): Fix calls for SFINAE support. - (rationalize_conditional_expr): Add SFINAE support. - (build_class_member_access_expr): Ditto. - (finish_class_member_access_expr): Ditto. - (build_x_indirect_ref): Ditto. - (build_indirect_ref): Original version renamed to - cp_build_indirect_ref; new version provides a bridge from - c-common. - (cp_build_indirect_ref): Was build_indirect_ref; added SFINAE - support. - (get_member_function_from_ptrfunc): Fix calls for SFINAE support. - (build_function_call): Original version renamed to - cp_build_function_call; new version provides a bridge from - c-common. - (cp_build_function_call): Was build_function_call; added SFINAE - support. - (convert_arguments): Add SFINAE support. - (build_x_binary_op): Ditto. - (build_binary_op): Original version renamed to cp_build_binary_op; - new version provides a bridge from c-common. - (cp_build_binary_op): Was build_binary_op; added SFINAE support. - (pointer_diff): Fix calls for SFINAE. - (build_x_unary_op): Add SFINAE support. - (condition_conversion): Fix calls for SFINAE. - (build_unary_op): Original version renamed to cp_build_unary_op; - new version provides a bridge from c-common. - (cp_build_unary_op): Was build_unary_op; added SFINAE support. - (unary_complex_lvalue): Fix calls for SFINAE. - (build_x_conditional_expr): Add SFINAE support. - (build_x_compound_expr_from_list): Fix calls for SFINAE. - (build_x_compound_expr): Add SFINAE support. - (convert_ptrmem): Fix calls for SFINAE. - (build_static_cast_1): Add SFINAE support. - (build_static_cast): Ditto. - (build_reinterpret_cast_1): Ditto. - (build_reinterpret_cast): Ditto. - (build_const_cast_1): Ditto. - (build_const_cast): Ditto. - (build_c_cast): Ditto. - (build_modify_expr): Original version renamed to - cp_build_modify_expr; new version provides a bridge from c-common. - (cp_build_modify_expr): Was build_modify_expr; added SFINAE - support. - (build_x_modify_expr): Add SFINAE support. - (build_ptrmemfunc): Fix calls for SFINAE. - (convert_for_assignment): Add SFINAE support. - (convert_for_initialization): Ditto. - (check_return_expr): Fix calls for SFINAE. - (lvalue_or_else): Add SFINAE support. - * init.c (perform_member_init): Fix calls for SFINAE. - (emit_mem_initializers): Ditto. - (expand_virtual_init): Ditto. - (expand_cleanup_for_base): Ditto. - (build_aggr_init): Add SFINAE support. - (expand_default_init): Ditto. - (expand_aggr_init_1): Fix calls for SFINAE. - (build_offset_ref): Ditto. - (build_new_1): Add SFINAE support. - (build_new): Ditto. - (build_vec_delete_1): Fix calls for SFINAE. - (get_temp_regvar): Ditto. - (build_vec_init): Add SFINAE support. - (build_dtor_call): Fix calls for SFINAE. - (build_delete): Ditto. - (push_base_cleanups): Ditto. - (build_vec_delete_1): Ditto. - * class.c (build_base_path): Fix calls for SFINAE. - (build_simple_base_path): Ditto. - (convert_to_base_statically): Ditto. - (build_vfn_ref): Ditto. - (resolve_address_of_overloaded_function): Ditto. - * decl.c (check_initializer): Fix calls for SFINAE. - (register_dtor_fn): Ditto. - (compute_array_index_type): Ditto. - (finish_enum): Ditto. - (start_preparsed_function): Ditto. - (cxx_maybe_build_cleanup): Ditto. - * call.c (convert_like): Add COMPLAIN argument. - (convert_like_with_context): Ditto. - (build_this): Fix calls for SFINAE. - (build_user_type_conversion): Ditto. - (resolve_args): Ditto. - (build_new_function_call): Add SFINAE support. - (build_operator_new_call): Fix calls for SFINAE. - (build_object_call): Add SFINAE support. - (build_conditional_expr): Ditto. - (build_new_op): Ditto. - (build_op_delete_call): Fix calls for SFINAE. - (build_temp): Ditto. - (convert_like_real): Add SFINAE support. - (build_x_va_arg): Fix calls for SFINAE. - (convert_default_arg): Ditto. - (build_over_call): Add SFINAE support. - (build_java_interface_fn_ref): Fix calls for SFINAE. - (build_special_member_call): Add SFINAE support. - (build_new_method_call): Ditto. - (perform_implicit_conversion): Ditto. - (perform_direct_initialization_if_possible): Ditto. - (initialize_reference): Fix calls for SFINAE. - * method.c (do_build_assign_ref): Fix calls for SFINAE. - * rtti.c (build_headof): Fix calls for SFINAE. - (get_tinfo_decl_dynamic): Ditto. - (get_typeid): Ditto. - (build_dynamic_cast_1): Add SFINAE support. - (build_dynamic_cast): Ditto. - (tinfo_base_init): Fix calls for SFINAE. - * except.c (do_get_exception_ptr): Fix calls for SFINAE. - (do_end_catch): Ditto. - (initialize_handler_parm): Ditto. - (expand_start_catch_block): Ditto. - (do_allocate_exception): Ditto. - (do_free_exception): Ditto. - (build_throw): Ditto. - * cvt.c (build_up_reference): Fix calls for SFINAE. - (convert_to_reference): Ditto. - (ocp_convert): Ditto. - (convert_to_void): Add SFINAE support. - * tree.c (build_dummy_object): Fix calls for SFINAE. - (stabilize_expr): Ditto. - * cp-tree.h (build_conditional_expr): Add tsubst_flags_t - parameter. - (build_new_method_call): Ditto. - (build_special_member_call): Ditto. - (build_new_op): Ditto. - (perform_implicit_conversion): Ditto. - (perform_direct_initialization_if_possible): Ditto. - (convert_to_void): Ditto. - (build_aggr_init): Ditto. - (build_new): Ditto. - (build_vec_init): Ditto. - (build_dynamic_cast): Ditto. - (finish_call_expr): Ditto - (cxx_sizeof_or_alignof_expr): Add COMPLAIN parameter. - (cxx_sizeof_nowarn): Remove macro; add function declaration. - (build_class_member_access_expr): Add tsubst_flags_t parameter. - (finish_class_member_access_expr): Ditto. - (build_x_indirect_ref): Ditto. - (cp_build_indirect_ref): New. - (cp_build_function_call): Add tsubst_flags_t parameter. - (build_x_unary_op): Ditto. - (cp_build_unary_op): New. - (build_x_conditional_expr): Add tsubst_flags_t parameter. - (build_x_compound_expr): Ditto. - (build_compound_expr): Ditto. - (build_static_cast): Ditto. - (build_reinterpret_cast): Ditto. - (build_const_cast): Ditto. - (build_c_cast): Ditto. - (build_x_modify_expr): Ditto. - (cp_build_modify_expr): New. - (convert_for_initialization): Add tsubst_flags_t parameter. - (cp_build_binary_op): Remove macro; add function declaration. - (invalid_nonstatic_memfn_p): Add tsubst_flags_t parameter. - (lvalue_or_else): Ditto. - (build_functional_cast): Ditto. - * typeck2.c (digest_init): Fix calls for SFINAE. - (process_init_constructor_array): Ditto. - (process_init_constructor_record): Ditto. - (build_x_arrow): Ditto. - (build_m_component_ref): Ditto. - (build_functional_cast): Add SFINAE support. - * pt.c (tsubst_copy_and_build): Add (more) SFINAE support. - * semantics.c (simplify_loop_decl_cond): Fix calls for SFINAE. - (finish_expr_stmt): Ditto. - (finish_for_expr): Ditto. - (finish_asm_stmt): Ditto. - (finish_non_static_data_member): Ditto. - (finish_qualified_id_expr): Ditto. - (finish_call_expr): Add SFINAE support. - (finish_increment_expr): Fix calls for SFINAE. - (finish_unary_op_expr): Ditto. - (simplify_aggr_init_expr): Ditto. - (finish_omp_clauses): Ditto. - (finish_omp_for): Ditto. - (finish_omp_barrier): Ditto. - (finish_omo_flush): Ditto. - * decl2.c (grok_array_decl): Fix calls or SFINAE. - (build_anon_union_vars): Ditto. - (get_guard_cond): Ditto. - (set_guard): Ditto. - (one_static_initialization_or_destruction): Ditto. - (do_static_initialization_or_destruction): Ditto. - (generate_ctor_or_dtor_function): Ditto. - (build_offset_ref_call_from_tree): Ditto. - * parser.c (cp_parser_postfix_expression): Fix calls for SFINAE. - (cp_parser_postfix_dot_deref_expression): Ditto. - (cp_parser_unary_expression): Ditto. - (cp_parser_new_expression): Ditto. - (cp_parser_cast_expression): Ditto. - (cp_parser_binary_expression): Ditto. - (cp_parser_question_colon_clause): Ditto. - (cp_parser_assignment_expression): Ditto. - (cp_parser_expression): Ditto. - (cp_parser_builtin_offsetof): Ditto. - (cp_parser_template_argument): Ditto. - (cp_parser_functional_cast): Ditto. + * typeck.c (composite_pointer_type_r): Add SFINAE support. + (composite_pointer_type): Ditto. + (common_type): Fix call to composite_pointer_type. + (cxx_sizeof_nowarn): New; used to be a macro. + (cxx_sizeof_expr): Add SFINAE support. + (cxx_alignof_expr): Ditto. + (decay_conversion): Fix calls for SFINAE support. + (rationalize_conditional_expr): Add SFINAE support. + (build_class_member_access_expr): Ditto. + (finish_class_member_access_expr): Ditto. + (build_x_indirect_ref): Ditto. + (build_indirect_ref): Original version renamed to + cp_build_indirect_ref; new version provides a bridge from + c-common. + (cp_build_indirect_ref): Was build_indirect_ref; added SFINAE + support. + (get_member_function_from_ptrfunc): Fix calls for SFINAE support. + (build_function_call): Original version renamed to + cp_build_function_call; new version provides a bridge from + c-common. + (cp_build_function_call): Was build_function_call; added SFINAE + support. + (convert_arguments): Add SFINAE support. + (build_x_binary_op): Ditto. + (build_binary_op): Original version renamed to cp_build_binary_op; + new version provides a bridge from c-common. + (cp_build_binary_op): Was build_binary_op; added SFINAE support. + (pointer_diff): Fix calls for SFINAE. + (build_x_unary_op): Add SFINAE support. + (condition_conversion): Fix calls for SFINAE. + (build_unary_op): Original version renamed to cp_build_unary_op; + new version provides a bridge from c-common. + (cp_build_unary_op): Was build_unary_op; added SFINAE support. + (unary_complex_lvalue): Fix calls for SFINAE. + (build_x_conditional_expr): Add SFINAE support. + (build_x_compound_expr_from_list): Fix calls for SFINAE. + (build_x_compound_expr): Add SFINAE support. + (convert_ptrmem): Fix calls for SFINAE. + (build_static_cast_1): Add SFINAE support. + (build_static_cast): Ditto. + (build_reinterpret_cast_1): Ditto. + (build_reinterpret_cast): Ditto. + (build_const_cast_1): Ditto. + (build_const_cast): Ditto. + (build_c_cast): Ditto. + (build_modify_expr): Original version renamed to + cp_build_modify_expr; new version provides a bridge from c-common. + (cp_build_modify_expr): Was build_modify_expr; added SFINAE + support. + (build_x_modify_expr): Add SFINAE support. + (build_ptrmemfunc): Fix calls for SFINAE. + (convert_for_assignment): Add SFINAE support. + (convert_for_initialization): Ditto. + (check_return_expr): Fix calls for SFINAE. + (lvalue_or_else): Add SFINAE support. + * init.c (perform_member_init): Fix calls for SFINAE. + (emit_mem_initializers): Ditto. + (expand_virtual_init): Ditto. + (expand_cleanup_for_base): Ditto. + (build_aggr_init): Add SFINAE support. + (expand_default_init): Ditto. + (expand_aggr_init_1): Fix calls for SFINAE. + (build_offset_ref): Ditto. + (build_new_1): Add SFINAE support. + (build_new): Ditto. + (build_vec_delete_1): Fix calls for SFINAE. + (get_temp_regvar): Ditto. + (build_vec_init): Add SFINAE support. + (build_dtor_call): Fix calls for SFINAE. + (build_delete): Ditto. + (push_base_cleanups): Ditto. + (build_vec_delete_1): Ditto. + * class.c (build_base_path): Fix calls for SFINAE. + (build_simple_base_path): Ditto. + (convert_to_base_statically): Ditto. + (build_vfn_ref): Ditto. + (resolve_address_of_overloaded_function): Ditto. + * decl.c (check_initializer): Fix calls for SFINAE. + (register_dtor_fn): Ditto. + (compute_array_index_type): Ditto. + (finish_enum): Ditto. + (start_preparsed_function): Ditto. + (cxx_maybe_build_cleanup): Ditto. + * call.c (convert_like): Add COMPLAIN argument. + (convert_like_with_context): Ditto. + (build_this): Fix calls for SFINAE. + (build_user_type_conversion): Ditto. + (resolve_args): Ditto. + (build_new_function_call): Add SFINAE support. + (build_operator_new_call): Fix calls for SFINAE. + (build_object_call): Add SFINAE support. + (build_conditional_expr): Ditto. + (build_new_op): Ditto. + (build_op_delete_call): Fix calls for SFINAE. + (build_temp): Ditto. + (convert_like_real): Add SFINAE support. + (build_x_va_arg): Fix calls for SFINAE. + (convert_default_arg): Ditto. + (build_over_call): Add SFINAE support. + (build_java_interface_fn_ref): Fix calls for SFINAE. + (build_special_member_call): Add SFINAE support. + (build_new_method_call): Ditto. + (perform_implicit_conversion): Ditto. + (perform_direct_initialization_if_possible): Ditto. + (initialize_reference): Fix calls for SFINAE. + * method.c (do_build_assign_ref): Fix calls for SFINAE. + * rtti.c (build_headof): Fix calls for SFINAE. + (get_tinfo_decl_dynamic): Ditto. + (get_typeid): Ditto. + (build_dynamic_cast_1): Add SFINAE support. + (build_dynamic_cast): Ditto. + (tinfo_base_init): Fix calls for SFINAE. + * except.c (do_get_exception_ptr): Fix calls for SFINAE. + (do_end_catch): Ditto. + (initialize_handler_parm): Ditto. + (expand_start_catch_block): Ditto. + (do_allocate_exception): Ditto. + (do_free_exception): Ditto. + (build_throw): Ditto. + * cvt.c (build_up_reference): Fix calls for SFINAE. + (convert_to_reference): Ditto. + (ocp_convert): Ditto. + (convert_to_void): Add SFINAE support. + * tree.c (build_dummy_object): Fix calls for SFINAE. + (stabilize_expr): Ditto. + * cp-tree.h (build_conditional_expr): Add tsubst_flags_t + parameter. + (build_new_method_call): Ditto. + (build_special_member_call): Ditto. + (build_new_op): Ditto. + (perform_implicit_conversion): Ditto. + (perform_direct_initialization_if_possible): Ditto. + (convert_to_void): Ditto. + (build_aggr_init): Ditto. + (build_new): Ditto. + (build_vec_init): Ditto. + (build_dynamic_cast): Ditto. + (finish_call_expr): Ditto + (cxx_sizeof_or_alignof_expr): Add COMPLAIN parameter. + (cxx_sizeof_nowarn): Remove macro; add function declaration. + (build_class_member_access_expr): Add tsubst_flags_t parameter. + (finish_class_member_access_expr): Ditto. + (build_x_indirect_ref): Ditto. + (cp_build_indirect_ref): New. + (cp_build_function_call): Add tsubst_flags_t parameter. + (build_x_unary_op): Ditto. + (cp_build_unary_op): New. + (build_x_conditional_expr): Add tsubst_flags_t parameter. + (build_x_compound_expr): Ditto. + (build_compound_expr): Ditto. + (build_static_cast): Ditto. + (build_reinterpret_cast): Ditto. + (build_const_cast): Ditto. + (build_c_cast): Ditto. + (build_x_modify_expr): Ditto. + (cp_build_modify_expr): New. + (convert_for_initialization): Add tsubst_flags_t parameter. + (cp_build_binary_op): Remove macro; add function declaration. + (invalid_nonstatic_memfn_p): Add tsubst_flags_t parameter. + (lvalue_or_else): Ditto. + (build_functional_cast): Ditto. + * typeck2.c (digest_init): Fix calls for SFINAE. + (process_init_constructor_array): Ditto. + (process_init_constructor_record): Ditto. + (build_x_arrow): Ditto. + (build_m_component_ref): Ditto. + (build_functional_cast): Add SFINAE support. + * pt.c (tsubst_copy_and_build): Add (more) SFINAE support. + * semantics.c (simplify_loop_decl_cond): Fix calls for SFINAE. + (finish_expr_stmt): Ditto. + (finish_for_expr): Ditto. + (finish_asm_stmt): Ditto. + (finish_non_static_data_member): Ditto. + (finish_qualified_id_expr): Ditto. + (finish_call_expr): Add SFINAE support. + (finish_increment_expr): Fix calls for SFINAE. + (finish_unary_op_expr): Ditto. + (simplify_aggr_init_expr): Ditto. + (finish_omp_clauses): Ditto. + (finish_omp_for): Ditto. + (finish_omp_barrier): Ditto. + (finish_omo_flush): Ditto. + * decl2.c (grok_array_decl): Fix calls or SFINAE. + (build_anon_union_vars): Ditto. + (get_guard_cond): Ditto. + (set_guard): Ditto. + (one_static_initialization_or_destruction): Ditto. + (do_static_initialization_or_destruction): Ditto. + (generate_ctor_or_dtor_function): Ditto. + (build_offset_ref_call_from_tree): Ditto. + * parser.c (cp_parser_postfix_expression): Fix calls for SFINAE. + (cp_parser_postfix_dot_deref_expression): Ditto. + (cp_parser_unary_expression): Ditto. + (cp_parser_new_expression): Ditto. + (cp_parser_cast_expression): Ditto. + (cp_parser_binary_expression): Ditto. + (cp_parser_question_colon_clause): Ditto. + (cp_parser_assignment_expression): Ditto. + (cp_parser_expression): Ditto. + (cp_parser_builtin_offsetof): Ditto. + (cp_parser_template_argument): Ditto. + (cp_parser_functional_cast): Ditto. 2008-03-24 Tom Tromey <tromey@redhat.com> @@ -1503,8 +1590,8 @@ 2008-03-18 Paolo Bonzini <bonzini@gnu.org> - * cp-lang.c (LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS): Delete. - + * cp-lang.c (LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS): Delete. + 2008-03-17 Jason Merrill <jason@redhat.com> PR c++/35548 @@ -1517,17 +1604,17 @@ Revert: 2008-02-04 Richard Guenther <rguenther@suse.de> - PR java/35035 - * decl.c (record_builtin_java_type): Make jboolean a - integer type again where its mode doesn't match that of bool. + PR java/35035 + * decl.c (record_builtin_java_type): Make jboolean a + integer type again where its mode doesn't match that of bool. 2008-01-25 Richard Guenther <rguenther@suse.de> - PR c++/33887 - * decl.c (record_builtin_java_type): Make __java_boolean - a variant of bool. - * typeck.c (structural_comptypes): Move TYPE_FOR_JAVA check - after TYPE_MAIN_VARIANT check. + PR c++/33887 + * decl.c (record_builtin_java_type): Make __java_boolean + a variant of bool. + * typeck.c (structural_comptypes): Move TYPE_FOR_JAVA check + after TYPE_MAIN_VARIANT check. 2008-03-10 Jakub Jelinek <jakub@redhat.com> @@ -1583,7 +1670,7 @@ (convert_to_void): Use error instead of pedwarn. * error.c (cp_cpp_error): Use pedantic_warning_kind. * decl.c (compute_array_index_type): Use constant_expression_error. - + 2008-03-01 Douglas Gregor <doug.gregor@gmail.com> * parser.c (cp_lexer_next_token_is_decl_specifier_keyword): Note @@ -1656,7 +1743,7 @@ PR 26264 * call.c (magic_varargs_p): Remove BUILT_IN_STDARG_START. - + 2008-02-26 Richard Guenther <rguenther@suse.de> * decl.c (duplicate_decls): Remove decl from global mapping @@ -1664,25 +1751,25 @@ 2008-02-26 Paolo Carlini <pcarlini@suse.de> - PR c++/35323 - * name-lookup.c (arg_assoc_type): Handle FIXED_POINT_TYPE. + PR c++/35323 + * name-lookup.c (arg_assoc_type): Handle FIXED_POINT_TYPE. 2008-02-26 Manuel Lopez-Ibanez <manu@gcc.gnu.org> - + * typeck.c (build_class_member_access_expr): Add appropriate OPT_W* parameter to warning. (build_reinterpret_cast_1): Likewise. * name-lookup.c (push_overloaded_decl): Likewise. - + 2008-02-25 Paolo Carlini <pcarlini@suse.de> - PR c++/35333 - * error.c (dump_expr): Handle CONJ_EXPR. + PR c++/35333 + * error.c (dump_expr): Handle CONJ_EXPR. 2008-02-25 Paolo Carlini <pcarlini@suse.de> - PR c++/35338 - * error.c (dump_type): Handle FIXED_POINT_TYPE. + PR c++/35338 + * error.c (dump_type): Handle FIXED_POINT_TYPE. (dump_expr): Handle FIXED_CST. 2008-02-24 Jason Merrill <jason@redhat.com> @@ -1691,7 +1778,7 @@ (cp_parser_namespace_definition): Likewise. PR c++/33486 - * name-lookup.c (arg_assoc_namespace): Look down into inline + * name-lookup.c (arg_assoc_namespace): Look down into inline namespaces, too. 2008-02-23 Manuel Lopez-Ibanez <manu@gcc.gnu.org> @@ -1703,7 +1790,7 @@ (build_reinterpret_cast_1): Update call to check_for_casting_away_constness. (build_const_cast_1): Likewise. - + 2008-02-24 Paolo Carlini <pcarlini@suse.de> * error.c (dump_expr): Don't deal directly with NEW_EXPR (and @@ -1727,8 +1814,8 @@ Revert: 2008-02-14 Paolo Carlini <pcarlini@suse.de> - PR c++/28743 - * pt.c (determine_specialization): In case of function templates, + PR c++/28743 + * pt.c (determine_specialization): In case of function templates, when the type of DECL does not match FN there is no match. 2008-02-22 Ralf Wildenhues <Ralf.Wildenhues@gmx.de> @@ -1795,8 +1882,8 @@ 2008-02-14 Paolo Carlini <pcarlini@suse.de> - PR c++/28743 - * pt.c (determine_specialization): In case of function templates, + PR c++/28743 + * pt.c (determine_specialization): In case of function templates, when the type of DECL does not match FN there is no match. 2008-02-13 Jakub Jelinek <jakub@redhat.com> @@ -1809,7 +1896,7 @@ 2008-02-13 Jason Merrill <jason@redhat.com> PR c++/34962, c++/34937, c++/34939 - * decl2.c (is_late_template_attribute): Always defer attributes + * decl2.c (is_late_template_attribute): Always defer attributes vector_size and weak. PR c++/34774 @@ -1843,12 +1930,12 @@ 2008-02-11 Douglas Gregor <doug.gregor@gmail.com> - PR c++/35113 - * tree.c (cp_build_qualified_type_real): When building a - cv-qualified array type, build it as a unique type with - build_cplus_array_type_1 and then adopt the unqualified type's - main variant. - + PR c++/35113 + * tree.c (cp_build_qualified_type_real): When building a + cv-qualified array type, build it as a unique type with + build_cplus_array_type_1 and then adopt the unqualified type's + main variant. + 2008-02-11 Paolo Carlini <pcarlini@suse.de> PR c++/35077 @@ -1857,7 +1944,7 @@ 2008-02-10 Jason Merrill <jason@redhat.com> PR c++/34094 - * decl2.c (cp_write_global_declarations): Don't write out static + * decl2.c (cp_write_global_declarations): Don't write out static data members with DECL_IN_AGGR_P set. 2008-02-08 Jason Merrill <jason@redhat.com> @@ -1910,7 +1997,7 @@ TYPE_MAIN_VARIANT to add new attributes, be sure to also modify all of the other variants to add those same attributes. Otherwise, the main variant will be inconsistent with those other variants. - + 2008-02-04 Richard Guenther <rguenther@suse.de> PR java/35035 @@ -1926,7 +2013,7 @@ * typeck2.c (build_functional_cast): Call it. * cp-gimplify.c (cp_gimplify_init_expr): Handle its output. - * cp-tree.h (TYPE_HAS_USER_CONSTRUCTOR): Rename from + * cp-tree.h (TYPE_HAS_USER_CONSTRUCTOR): Rename from TYPE_HAS_CONSTRUCTOR. * class.c (finish_struct_bits, maybe_warn_about_overly_private_class, add_implicitly_declared_members): Adjust. @@ -1943,15 +2030,15 @@ (instantiate_class_template): Adjust. 2008-01-31 Douglas Gregor <doug.gregor@gmail.com> - Jakub Jelinek <jakub@redhat.com> + Jakub Jelinek <jakub@redhat.com> - PR c++/34935 - PR c++/34936 - * typeck.c (structural_comptypes): Handle comparisons of - VOID_TYPE, BOOLEAN_TYPE, INTEGER_TYPE, FIXED_POINT_TYPE, and - REAL_TYPE nodes. - * mangle.c (write_builtin_type): Map down to the canonical type, - which will be one of the predefined type nodes. + PR c++/34935 + PR c++/34936 + * typeck.c (structural_comptypes): Handle comparisons of + VOID_TYPE, BOOLEAN_TYPE, INTEGER_TYPE, FIXED_POINT_TYPE, and + REAL_TYPE nodes. + * mangle.c (write_builtin_type): Map down to the canonical type, + which will be one of the predefined type nodes. 2008-01-29 Michael Meissner <michael.meissner@amd.com> @@ -1984,7 +2071,7 @@ (check_for_bare_parameter_packs): Parameter is now a tree, not a tree*. (process_template_parm): Tweak call to - check_for_bare_parameter_packs. + check_for_bare_parameter_packs. (push_template_decl_real): Tweak calls to check_for_bare_parameter_packs. If bare parameter packs are found in the list of exceptions, clear out that list after giving an @@ -2052,7 +2139,7 @@ to complex. (compare_ics): Such a conversion is worse than a normal arithmetic conversion. - + 2008-01-25 Richard Guenther <rguenther@suse.de> PR c++/33887 @@ -2061,14 +2148,14 @@ 2008-01-24 Paolo Carlini <pcarlini@suse.de> - PR c++/34603 - * pt.c (push_template_decl_real): Return error_mark_node in case + PR c++/34603 + * pt.c (push_template_decl_real): Return error_mark_node in case of template definition of non-template. 2008-01-24 Jason Merrill <jason@redhat.com> PR c++/34913 - * decl2.c (is_late_template_attribute): Defer any attribute with + * decl2.c (is_late_template_attribute): Defer any attribute with dependent args. Also defer type attributes if the type is dependent. 2008-01-22 Jakub Jelinek <jakub@redhat.com> @@ -2084,13 +2171,13 @@ 2008-01-22 Jason Merrill <jason@redhat.com> PR c++/28560 - * decl.c (groktypename): Also ignore attributes on dependent + * decl.c (groktypename): Also ignore attributes on dependent possibly-class types. PR c++/34912 - * friend.c (do_friend): Check for prior declaration of a friend + * friend.c (do_friend): Check for prior declaration of a friend function of a local class. - * name-lookup.c (lookup_name_innermost_nonclass_level): + * name-lookup.c (lookup_name_innermost_nonclass_level): No longer static. * name-lookup.h: Declare it. @@ -2132,14 +2219,14 @@ 2008-01-20 Paolo Carlini <pcarlini@suse.de> - PR c++/34891 - * error.c (dump_expr): Deal with VIEW_CONVERT_EXPR. + PR c++/34891 + * error.c (dump_expr): Deal with VIEW_CONVERT_EXPR. 2008-01-20 Paolo Carlini <pcarlini@suse.de> - PR c++/34776 + PR c++/34776 PR c++/34486 - * name-lookup.c (do_class_using_decl): Do not call constructor_name_p + * name-lookup.c (do_class_using_decl): Do not call constructor_name_p on non-IS_AGGR_TYPE scope. (constructor_name_p): Assert IS_AGGR_TYPE. @@ -2219,42 +2306,42 @@ 2008-01-15 Douglas Gregor <doug.gregor@gmail.com> - PR c++/34314 - * error.c (dump_simple_decl): Display ellipsis for template - non-type parameter packs. - (dump_decl): Display ellipsis for template type parameter packs. - (dump_template_decl): Display ellipsis for template template - parameter packs. - * pt.c (redeclare_class_template): When redeclaring a class - template, check for collisions between template parameters and - template parameter packs. + PR c++/34314 + * error.c (dump_simple_decl): Display ellipsis for template + non-type parameter packs. + (dump_decl): Display ellipsis for template type parameter packs. + (dump_template_decl): Display ellipsis for template template + parameter packs. + * pt.c (redeclare_class_template): When redeclaring a class + template, check for collisions between template parameters and + template parameter packs. 2008-01-15 Douglas Gregor <doug.gregor@gmail.com> - PR c++/33964 - * pt.c (process_partial_specialization): Don't mark template - parameters that occur in non-deduced contexts. - (struct pair_fn_data): Add include_nondeduced_p. - (for_each_template_parm_r): Only visit non-deduced contexts if - include_nondeduced_p is set. - (for_each_template_parm): Added parameter include_nondeduced_p, - which states whether template parameters found in non-deduced - contexts should be visited. - (uses_template_parms): Visit all template parameters, even those - in non-deduced contexts. + PR c++/33964 + * pt.c (process_partial_specialization): Don't mark template + parameters that occur in non-deduced contexts. + (struct pair_fn_data): Add include_nondeduced_p. + (for_each_template_parm_r): Only visit non-deduced contexts if + include_nondeduced_p is set. + (for_each_template_parm): Added parameter include_nondeduced_p, + which states whether template parameters found in non-deduced + contexts should be visited. + (uses_template_parms): Visit all template parameters, even those + in non-deduced contexts. 2008-01-15 Douglas Gregor <doug.gregor@gmail.com> - PR c++/34052 - * pt.c (check_default_tmpl_args): Check for parameter packs that - aren't at the end of a primary template. - (push_template_decl_real): Remove check for parameter packs that - aren't at the end of a primary template; that now happens in - check_default_tmpl_args. - * semantics.c (finish_template_template_parm): Use - check_default_tmpl_args to check for errors in the template - parameter list. - + PR c++/34052 + * pt.c (check_default_tmpl_args): Check for parameter packs that + aren't at the end of a primary template. + (push_template_decl_real): Remove check for parameter packs that + aren't at the end of a primary template; that now happens in + check_default_tmpl_args. + * semantics.c (finish_template_template_parm): Use + check_default_tmpl_args to check for errors in the template + parameter list. + 2008-01-12 Doug Kwan <dougkwan@google.com> * decl.c: (grokdeclarator): Use OPT_Wignored_qualifiers @@ -2278,9 +2365,9 @@ 2008-01-01 Douglas Gregor <doug.gregor@gmail.com> - * parser.c (cp_parser_check_decl_spec): Don't warn about "long - long" in C++0x mode; change the warning to note that "long long" - is only unsupported in C++98 mode. + * parser.c (cp_parser_check_decl_spec): Don't warn about "long + long" in C++0x mode; change the warning to note that "long long" + is only unsupported in C++98 mode. 2007-12-20 Jason Merrill <jason@redhat.com> @@ -2298,13 +2385,13 @@ 2007-12-18 Jason Merrill <jason@redhat.com> PR c++/34206 - * pt.c (tsubst_aggr_type): Do nothing if the type already doesn't + * pt.c (tsubst_aggr_type): Do nothing if the type already doesn't use template parms. (dependent_type_p_r): Handle the domain of an array. 2007-12-18 Douglas Gregor <doug.gregor@gmail.com> - Jakub Jelinek <jakub@redhat.com> - + Jakub Jelinek <jakub@redhat.com> + PR c++/32565 PR c++/33943 PR c++/33965 @@ -2313,9 +2400,9 @@ arguments have been deduced. (coerce_template_parms): Don't complain when COMPLAIN doesn't include tf_error. - (fn_type_unification): Use template_template_parm_bindings_ok_p. - (unify): Deal with variadic, bound template template parameters. - (get_class_bindings): Use template_template_parm_bindings_ok_p. + (fn_type_unification): Use template_template_parm_bindings_ok_p. + (unify): Deal with variadic, bound template template parameters. + (get_class_bindings): Use template_template_parm_bindings_ok_p. 2007-12-18 Jakub Jelinek <jakub@redhat.com> @@ -2385,38 +2472,38 @@ 2007-12-04 Douglas Gregor <doug.gregor@gmail.com> - PR c++/34101 - * name-lookup.c (arg_assoc_template_arg): Recurse on argument - packs. - (arg_assoc_type): We don't need to handle TYPE_ARGUMENT_PACK here, - since arg_assoc_template_arg will deal with them (better). + PR c++/34101 + * name-lookup.c (arg_assoc_template_arg): Recurse on argument + packs. + (arg_assoc_type): We don't need to handle TYPE_ARGUMENT_PACK here, + since arg_assoc_template_arg will deal with them (better). 2007-12-04 Douglas Gregor <doug.gregor@gmail.com> - PR c++/33509 - * pt.c (tsubst_exception_specification): Handle substitutions into - member templates, where tsubst_pack_expansion returns a - TYPE_PACK_EXPANSION. + PR c++/33509 + * pt.c (tsubst_exception_specification): Handle substitutions into + member templates, where tsubst_pack_expansion returns a + TYPE_PACK_EXPANSION. 2007-12-04 Douglas Gregor <doug.gregor@gmail.com> - PR c++/33091 - * pt.c (unify_pack_expansion): If we didn't deduce any actual - bindings for the template parameter pack, don't try to keep the - empty deduced arguments. - (unify): If a parameter is a template-id whose template argument - list contains a pack expansion that is not at the end, then we - cannot unify against that template-id. + PR c++/33091 + * pt.c (unify_pack_expansion): If we didn't deduce any actual + bindings for the template parameter pack, don't try to keep the + empty deduced arguments. + (unify): If a parameter is a template-id whose template argument + list contains a pack expansion that is not at the end, then we + cannot unify against that template-id. 2007-12-02 Paolo Carlini <pcarlini@suse.de> - PR c++/34061 - * pt.c (current_template_args): Use error_operand_p. + PR c++/34061 + * pt.c (current_template_args): Use error_operand_p. 2007-12-02 Paolo Carlini <pcarlini@suse.de> - PR c++/34273 - * error.c (dump_decl): Handle TREE_BINFO. + PR c++/34273 + * error.c (dump_decl): Handle TREE_BINFO. 2007-12-01 Ollie Wild <aaw@google.com> @@ -2456,7 +2543,7 @@ 2007-11-26 Andreas Krebbel <krebbel1@de.ibm.com> PR c++/34081 - * decl.c (start_preparsed_function): Pass + * decl.c (start_preparsed_function): Pass processing_template_decl for the new allocate_struct_function parameter. @@ -2485,11 +2572,11 @@ 2007-11-23 Mark Mitchell <mark@codesourcery.com> Manuel Lopez-Ibanez <manu@gcc.gnu.org> - + PR c++/5310 * call.c (convert_like_real): Build a zero constant when __null is converted to an integer type. - + 2007-11-22 Jakub Jelinek <jakub@redhat.com> PR c++/34094 @@ -2660,7 +2747,7 @@ check_for_bare_parameter_packs. (finish_member_declaration): Ditto. * parser.c (cp_parser_base_clause): Ditto. - + 2007-11-06 Jakub Jelinek <jakub@redhat.com> PR target/33168 @@ -2698,7 +2785,7 @@ PR c++/33939 * pt.c (unify_pack_expansion): bring handling of function call - arguments into line with type_unification_real. + arguments into line with type_unification_real. 2007-11-05 Manuel Lopez-Ibanez <manu@gcc.gnu.org> @@ -2772,12 +2859,12 @@ Fix typo. 2007-10-31 Christian Bruel <christian.bruel@st.com> - Mark Mitchell <mark@codesourcery.com> + Mark Mitchell <mark@codesourcery.com> PR c++/19531 * typeck.c (check_return_expr): Don't set named_return_value_okay_p - if retval is volatile. - + if retval is volatile. + 2007-10-30 Jakub Jelinek <jakub@redhat.com> PR c++/33616 @@ -2844,7 +2931,7 @@ PR c++/24791 * pt.c (get_template_info): New fn. (template_class_depth): Use it. - (push_template_decl_real): Check that the template args of the + (push_template_decl_real): Check that the template args of the definition match the args of the previous declaration. 2007-10-26 Paolo Carlini <pcarlini@suse.de> @@ -2888,8 +2975,8 @@ PR c++/25950 (DR 391) * call.c (struct conversion): Remove check_copy_constructor_p. - (reference_binding): Always bind a reference directly to a - compatible class rvalue. Pass down LOOKUP_NO_TEMP_BIND during + (reference_binding): Always bind a reference directly to a + compatible class rvalue. Pass down LOOKUP_NO_TEMP_BIND during temporary creation. (check_constructor_callable): Remove. (convert_like_real): Don't call it. @@ -2994,7 +3081,7 @@ (leave_scope): Don't pop_visibility. * name-lookup.h (struct cp_binding_level): Remove has_visibility. * parser.c (cp_parser_namespace_definition): Call - handle_namespace_attrs and pop_visibility as appropriate. + handle_namespace_attrs and pop_visibility as appropriate. PR c++/11756 * mangle.c (write_type) [TYPEOF_TYPE]: Just sorry. @@ -3014,7 +3101,7 @@ 2007-09-29 Jason Merrill <jason@redhat.com> PR c++/33094 - * decl.c (make_rtl_for_nonlocal_decl): It's ok for a member + * decl.c (make_rtl_for_nonlocal_decl): It's ok for a member constant to not have DECL_EXTERNAL if it's file-local. 2007-09-28 Ollie Wild <aaw@google.com> @@ -3097,14 +3184,14 @@ 2007-09-24 Danny Smith <dannysmith@user.sourceforge.net> PR c++/14688 - * search.c (check_final_overrider): Fail if + * search.c (check_final_overrider): Fail if targetm.comp_type_attributes returns 0. 2007-09-24 Jason Merrill <jason@redhat.com> PR c++/33239 * pt.c (resolve_typename_type): Don't look things up in the original - template if it would mean losing template arguments. + template if it would mean losing template arguments. 2007-09-24 Jakub Jelinek <jakub@redhat.com> @@ -3115,22 +3202,22 @@ 2007-09-24 Douglas Gregor <doug.gregor@gmail.com> - PR c++/33185 + PR c++/33185 * tree.c (cp_build_qualified_type_real): Build a canonical ARRAY_TYPE if the original ARRAY_TYPE was not a canonical type. - + 2007-09-24 Douglas Gregor <doug.gregor@gmail.com> PR c++/33112 - PR c++/33185 + PR c++/33185 * tree.c (cplus_array_compare): Compare pointers, not types. (build_cplus_array_type_1): Store new array type into the hash table before building the canonical type; build the canonical type correctly. (cp_build_qualified_type_real): Put all of the array types with - cv-qualified element types into the C++ array hash table, built as + cv-qualified element types into the C++ array hash table, built as variants of the unqualified versions. - + 2007-09-23 Jason Merrill <jason@redhat.com> PR c++/16370 @@ -3176,7 +3263,7 @@ PR c++/7586 * pt.c (tsubst): Handle typedefs by looking for the specialization. - (retrieve_specialization): Only tagged types use + (retrieve_specialization): Only tagged types use DECL_TEMPLATE_INSTANTIATIONS. (instantiate_class_template): Push nested classes too. (tsubst_decl) [TYPE_DECL]: Only check for canonical decl for @@ -3413,7 +3500,7 @@ 2007-08-31 Douglas Gregor <doug.gregor@gmail.com> * mangle.c (write_type): Change mangling of rvalue reference from - `RR' to `O'. + `RR' to `O'. 2007-08-31 Jakub Jelinek <jakub@redhat.com> @@ -3471,7 +3558,7 @@ 2007-08-27 Jason Merrill <jason@redhat.com> PR c++/29000 - * pt.c (build_non_dependent_expr, type_dependent_expression_p): + * pt.c (build_non_dependent_expr, type_dependent_expression_p): Look inside STMT_EXPR. * semantics.c (stmt_expr_value_expr): New fn. * cp-tree.h: Declare it. @@ -3484,7 +3571,7 @@ * decl.c (duplicate_decls): Merge DECL_DISREGARD_INLINE_LIMITS. 2007-08-28 Gabriel Dos Reis <gdr@integrable-solutions.net> - + * error.c (dump_expr): Handle COMPLEX_CST. * cxx-pretty-print.c (pp_cxx_primary_expression): Likewise. (pp_cxx_expression): Likewise. @@ -3832,9 +3919,9 @@ PR c++/30851 * parser.c (cp_parser_asm_definition): Detect and discard asm statements with invalid inputs or outputs. - (cp_parser_asm_operand_list): Return error mark node if any - of the operands are invalid. Adjust documentation. - + (cp_parser_asm_operand_list): Return error mark node if any + of the operands are invalid. Adjust documentation. + 2007-08-02 Nick Clifton <nickc@redhat.com> * typeck.c: Change copyright header to refer to version 3 of the @@ -3985,7 +4072,7 @@ canonical types; otherwise, fall back to structural type comparisons. If ENABLE_CHECKING and USE_CANONICAL_TYPES, give an internal compiler error if the canonical types are wrong. - + 2007-07-11 Paolo Carlini <pcarlini@suse.de> PR c++/32560 @@ -4052,7 +4139,7 @@ tests when comparing pointer-to-member-function types, because the handling of TYPE_GET_PTRMEMFUNC_TYPE currently defeats canonical types. - + 2007-07-03 Mark Mitchell <mark@codesourcery.com> * init.c (build_new): Tweak comment. @@ -4272,9 +4359,9 @@ * semantics.c (finish_trait_expr): Complete the types. 2007-05-30 Russell Yanofsky <russ@yanofsky.org> - Douglas Gregor <doug.gregor@gmail.com> - Pedro Lamarao <pedro.lamarao@mndfck.org> - Howard Hinnant <howard.hinnant@gmail.com> + Douglas Gregor <doug.gregor@gmail.com> + Pedro Lamarao <pedro.lamarao@mndfck.org> + Howard Hinnant <howard.hinnant@gmail.com> PR c++/7412 PR c++/29939 @@ -4315,7 +4402,7 @@ rvalue references. (cp_parser_make_indirect_declarator): New. (cp_parser_new_declarator_opt): Call - cp_parser_make_indirect_declarator. + cp_parser_make_indirect_declarator. (cp_parser_conversion_declarator_opt): Ditto. (cp_parser_declarator): Ditto. (cp_parser_ptr_operator): Parse "&&" tokens into rvalue reference @@ -4344,7 +4431,7 @@ case POSTDECREMENT_EXPR>): Return the error_mark_node if either the real or imaginary parts would an error_mark_node. - + 2007-05-25 Simon Martin <simartin@users.sourceforge.net> Manuel Lopez-Ibanez <manu@gcc.gnu.org> @@ -4441,14 +4528,14 @@ * typeck.c (build_indirect_ref): Add call to strict_aliasing_warning. (build_reinterpret_cast_1): Condition call to - strict_aliasing_warning. + strict_aliasing_warning. 2007-05-11 Jan Hubicka <jh@suse.cz> * semantics.c (expand_or_defer_fn): Do not call c_record_cdtor_fn. * decl2.c (start_objects): ctors and dtors are no longer public. (cp_write_global_declarations): Do not call c_build_cdtor_fns. - + 2007-05-07 Andrew Pinski <andrew_pinski@playstation.sony.com> * typeck.c (build_unary_op): Remove code that used to @@ -4474,7 +4561,7 @@ 2007-05-02 Seongbae Park <seongbae.park@gmail.com> PR c++/31663 - * decl2.c (constrain_class_visibility): + * decl2.c (constrain_class_visibility): Use strip_pointer_or_array_types instead of strip_array_types. 2007-04-28 Andrew Pinski <andrew_pinski@playstation.sony.com> @@ -4490,8 +4577,8 @@ 2007-04-27 Douglas Gregor <doug.gregor@gmail.com> * error.c (maybe_warn_variadic_templates): Variadic templates are - now in C++0x, so only warn about them in C++98 mode. - + now in C++0x, so only warn about them in C++98 mode. + 2007-04-26 Andrew Pinski <andrew_pinski@playstation.sony.com> PR C++/30016 @@ -4598,7 +4685,7 @@ * cp-objcp-common.c (cxx_staticp): Remove. * cp-objcp-common.h (LANG_HOOKS_STATICP): Remove. - * cp-tree.h (cxx_staticp): + * cp-tree.h (cxx_staticp): 2007-04-04 Danny Smith <dannysmith.users.sourceforge.net> @@ -4635,11 +4722,11 @@ (cp_parser_parameter_declaration): Ditto. Also, handle when TYPE is NULL. * pt.c (find_parameter_packs_r): Look into the bounds on integer - types (they could be used as array bounds). + types (they could be used as array bounds). (check_for_bare_parameter_packs): Deal with TEMPLATE_PARM_INDEX. (tsubst_pack_expansion): Handle failure to expand parameter packs. - + 2007-03-30 Paolo Carlini <pcarlini@suse.de> PR c++/26099 @@ -4777,13 +4864,13 @@ (cp_parser_namespace_alias_definition): if we find an open brace instead of '=', then this is actually a misplaced namespace definition. - + 2007-03-15 Manuel Lopez-Ibanez <manu@gcc.gnu.org> PR c++/24924 * decl.c (cxx_init_decl_processing): Move command-line options processing to c-opts.c. - + 2007-03-15 Douglas Gregor <doug.gregor@gmail.com> * ptree.c (cxx_print_type): Use formatting markup for integers @@ -4807,7 +4894,7 @@ (make_pack_expansion): Ditto. (check_for_bare_parameter_packs): Ditto. * name-lookup.c (push_to_top_level): Make need_pop a bool value. - + 2007-03-14 Andrew Pinski <andrew_pinski@playstation.sony.com> PR c++/31165 @@ -4830,13 +4917,13 @@ 2007-03-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org> * class.c (warn_hidden): Add OPT_Woverloaded_virtual to warning. - + 2007-03-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org> PR c/21438 * typeck.c (build_binary_op): Call warn_for_div_zero instead of warning. - + 2007-03-13 Alexandre Oliva <aoliva@redhat.com> * repo.c (init_repo): Initialize random_seed saved options. @@ -4865,7 +4952,7 @@ PR c++/30328 * semantics.c (finish_typeof): Use unlowered_expr_type. - + 2007-03-10 Mark Mitchell <mark@codesourcery.com> PR c++/30274 @@ -4909,7 +4996,7 @@ * operators.def: Add ellipsis operator for EXPR_PACK_EXPANSION. * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK, NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION, - CAST_EXPR. + CAST_EXPR. * mangle.c (write_type): Mangle TYPE_PACK_EXPANSION. (write_template_arg): Write argument packs as separate arguments. * cp-tree.h (struct template_parm_index_s): Add flag that @@ -4936,17 +5023,17 @@ (struct cp_declarator): Add parameter_pack_p flag. (maybe_warn_variadic_templates): Declare. (process_template_parm): Add bool parameter IS_PARAMETER_PACK, to - indicate a template parameter pack. + indicate a template parameter pack. (uses_parameter_packs): Declare. (template_parameter_pack_p): Declare. (template_parms_variadic_p): Declare. (make_pack_expansion): Declare. (check_for_bare_parameter_packs): Declare. * cxx-pretty-print.c (pp_cxx_unary_expression): Print - sizeof... expressions. + sizeof... expressions. (pp_cxx_expression): Print pack expansions and non-type argument packs. - (pp_cxx_exception_specification): Print pack expansions. + (pp_cxx_exception_specification): Print pack expansions. (pp_cxx_direct_declarator): Print ellipsis for parameter packs. (pp_cxx_ctor_initializer): Print pack expansions. (pp_cxx_type_id): Print pack expansions. @@ -4988,7 +5075,7 @@ comparing template argument lists. (mangle_class_name_for_template): Make argument packs as separate template arguments. - (for_each_template_parm_r): No need to handle BASELINK. + (for_each_template_parm_r): No need to handle BASELINK. (instantiate_class_template): Handle pack expansions in the base class list. (tsubst_pack_expansion): New. @@ -5000,10 +5087,10 @@ argument types. (tsubst_exception_specification): Handle pack expansions in exception specifiers. - (tsubst): See through ARGUMENT_PACK_SELECT arguments when + (tsubst): See through ARGUMENT_PACK_SELECT arguments when replacing a template parameter with its argument. If we encounter a substitution for an argument pack, just return the parameter - itself. + itself. (tsubst_copy): sizeof(X...) returns the number of elements in parameter pack X. See through ARGUMENT_PACK_SELECT when the PARM_DECL is a parameter pack. @@ -5089,13 +5176,13 @@ end a template argument. * tree.c (cp_walk_subtrees): Walk BASELINK, TYPE_ARGUMENT_PACK, NONTYPE_ARGUMENT_PACK, TYPE_PACK_EXPANSION, EXPR_PACK_EXPANSION, - CAST_EXPR. + CAST_EXPR. 2007-03-09 Dirk Mueller <dmueller@suse.de> * call.c (build_new_op): Call warn_logical_operator. -2007-03-08 Volker Reichelt <reichelt@netcologne.de> +2007-03-08 Volker Reichelt <v.reichelt@netcologne.de> PR c++/30852 * semantics.c (finish_offsetof): Handle COMPOUND_EXPR. @@ -5109,7 +5196,7 @@ * decl.c (grokdeclarator): Disable warnings for anonymous bitfields. -2007-03-05 Volker Reichelt <reichelt@netcologne.de> +2007-03-05 Volker Reichelt <v.reichelt@netcologne.de> * typeck2.c (readonly_error): Always emit a hard error. Remove last argument. @@ -5133,7 +5220,7 @@ (cp_parser_selection_statement): Set IN_IF_STMT bit when parsing body of 'if'. (cp_parser_jump_statement): Mask new IN_IF_STMT bit. - + 2007-03-02 Simon Martin <simartin@users.sourceforge.net> PR c++/28253 @@ -5149,7 +5236,7 @@ 2007-03-02 Manuel Lopez-Ibanez <manu@gcc.gnu.org> * typeck.c (common_base_type): Delete unused function. - + 2007-03-01 Brooks Moses <brooks.moses@codesourcery.com> * Make-lang.in: Add dummy lang.install-pdf target. @@ -5246,7 +5333,7 @@ 2007-02-15 Andrew Pinski <andrew_pinski@playstation.sony.com> PR C++/30158 - * semantics.c (finish_stmt_expr_expr): Set TREE_TYPE of the + * semantics.c (finish_stmt_expr_expr): Set TREE_TYPE of the statement expression if we had an error mark node. 2007-02-15 Sandra Loosemore <sandra@codesourcery.com> @@ -5256,15 +5343,15 @@ * cp-tree.def (AGGR_INIT_EXPR): Adjust documentation. Change class to tcc_vl_exp. - * call.c (build_call): Use build_call_list instead - of build3. + * call.c (build_call): Use build_call_list instead + of build3. (build_over_call): Likewise. - (build_new_method_call): Use build_min_non_dep_call_list + (build_new_method_call): Use build_min_non_dep_call_list instead of build_min_non_dep. * error.c (dump_call_expr_args): New function. (dump_aggr_init_expr_args): New function. - (dump_expr) <AGGR_INIT_EXPR, CALL_EXPR, INDIRECT_REF>: Use them. + (dump_expr) <AGGR_INIT_EXPR, CALL_EXPR, INDIRECT_REF>: Use them. Update to use new CALL_EXPR and AGGR_INIT_EXPR accessor macros. * cvt.c (convert_to_void): Use build_call_array instead @@ -5276,7 +5363,7 @@ * dump.c (cp_dump_tree) <AGGR_INIT_EXPR>: Update to use new AGGR_INIT_EXPR accessor macros. - * cp-gimplify.c (cp_gimplify_init_expr): Use + * cp-gimplify.c (cp_gimplify_init_expr): Use AGGR_INIT_EXPR_SLOT to set the slot operand. * cp-tree.h (AGGR_INIT_EXPR_FN): New macro. @@ -5305,7 +5392,7 @@ (cp_tree_equal) <CALL_EXPR>: Iterate through the arguments to check for equality instead of recursing. Handle tcc_vl_exp tree code classes. - (stabilize_call): Update to only handle CALL_EXPRs, not + (stabilize_call): Update to only handle CALL_EXPRs, not AGGR_INIT_EXPRs; use new CALL_EXPR accessor macros. (stabilize_aggr_init): New function. (stabilize_init): Use it. @@ -5313,23 +5400,23 @@ * cxx-pretty-print.c (pp_cxx_postfix_expression) <AGGR_INIT_EXPR, CALL_EXPR>: Update to use new CALL_EXPR and AGGR_INIT_EXPR accessor macros and argument iterators. - + * pt.c (tsubst_copy) <CALL_EXPR>: Replace build_nt with - build_vl_exp. Iterate through the operands, recursively + build_vl_exp. Iterate through the operands, recursively processing each one. (tsubst_copy_and_build) <CALL_EXPR>: Update to use new CALL_EXPR accessor macros. (value_dependent_expression_p) <default>: Handle tcc_vl_exp - tree code classes. Use TREE_OPERAND_LENGTH instead of + tree code classes. Use TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH. * semantics.c (finish_call_expr): Use build_nt_call_list instead of build_nt. - (simplify_aggr_init_expr): Update to use new AGGR_INIT_EXPR - accessor macros. Use build_call_array to construct the + (simplify_aggr_init_expr): Update to use new AGGR_INIT_EXPR + accessor macros. Use build_call_array to construct the CALL_EXPR node instead of build3 - - * decl2.c (build_offset_ref_call_from_tree): Use + + * decl2.c (build_offset_ref_call_from_tree): Use build_nt_call_list and build_min_non_dep_call_list instead of build_min_nt and build_min_non_dep. @@ -5340,7 +5427,7 @@ PR c++/28943 * call.c (build_conditional_expr): Improve error message. - + 2007-02-13 Dirk Mueller <dmueller@suse.de> * friend.c (do_friend): Annotate warning about friend @@ -5417,9 +5504,9 @@ o2007-02-06 Mark Mitchell <mark@codesourcery.com> 2007-02-03 Douglas Gregor <doug.gregor@gmail.com> - * parser.c (cp_lexer_get_preprocessor_token): Attach the C++0x - keyword warning to -Wc++0x-compat. - + * parser.c (cp_lexer_get_preprocessor_token): Attach the C++0x + keyword warning to -Wc++0x-compat. + 2007-02-03 Gabriel Dos Reis <gdr@integrable-solutions.net> * decl.c (grokdeclarator): Update documentation. @@ -5444,7 +5531,7 @@ o2007-02-06 Mark Mitchell <mark@codesourcery.com> to -Wpointer-arith. * call.c (convert_like_real): Don't warn when converting to boolean type. - + 2007-01-29 Manuel Lopez-Ibanez <manu@gcc.gnu.org> * decl.c (pop_label): Replace warning with call to @@ -5532,13 +5619,13 @@ o2007-02-06 Mark Mitchell <mark@codesourcery.com> * typeck.c (build_binary_op): Call overflow_warning if TREE_OVERFLOW_P is true for the result and not for any of the operands. - + 2007-01-06 Lee Millward <lee.millward@codesourcery.com> - PR c++/19439 - * class.c (add_method): Don't wait until template - instantiation time to complain about duplicate methods. - + PR c++/19439 + * class.c (add_method): Don't wait until template + instantiation time to complain about duplicate methods. + 2007-01-05 Manuel Lopez-Ibanez <manu@gcc.gnu.org> PR c/19978 @@ -5569,7 +5656,7 @@ o2007-02-06 Mark Mitchell <mark@codesourcery.com> 2007-01-02 Douglas Gregor <doug.gregor@gmail.com> * pt.c (canonical_template_parms): Correct typo in comment. - + 2007-01-02 Douglas Gregor <doug.gregor@gmail.com> * typeck.c (structural_comptypes): Renamed from "comptypes". diff --git a/gcc/cp/call.c b/gcc/cp/call.c index cb07c82f1ab..2f6767388da 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -201,8 +201,7 @@ static void add_candidates (tree, tree, tree, bool, tree, tree, int, struct z_candidate **); static conversion *merge_conversion_sequences (conversion *, conversion *); static bool magic_varargs_p (tree); -typedef void (*diagnostic_fn_t) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); -static tree build_temp (tree, tree, int, diagnostic_fn_t *); +static tree build_temp (tree, tree, int, diagnostic_t *); /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE. NAME can take many forms... */ @@ -4445,7 +4444,7 @@ enforce_access (tree basetype_path, tree decl, tree diag_decl) static tree build_temp (tree expr, tree type, int flags, - diagnostic_fn_t *diagnostic_fn) + diagnostic_t *diagnostic_kind) { int savew, savee; @@ -4455,11 +4454,11 @@ build_temp (tree expr, tree type, int flags, build_tree_list (NULL_TREE, expr), type, flags, tf_warning_or_error); if (warningcount > savew) - *diagnostic_fn = warning0; + *diagnostic_kind = DK_WARNING; else if (errorcount > savee) - *diagnostic_fn = error; + *diagnostic_kind = DK_ERROR; else - *diagnostic_fn = NULL; + *diagnostic_kind = 0; return expr; } @@ -4505,7 +4504,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, bool c_cast_p, tsubst_flags_t complain) { tree totype = convs->type; - diagnostic_fn_t diagnostic_fn; + diagnostic_t diag_kind; int flags; if (convs->bad_p @@ -4682,12 +4681,13 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, conversion (i.e. the second step of copy-initialization), so don't allow any more. */ flags |= LOOKUP_NO_CONVERSION; - expr = build_temp (expr, totype, flags, &diagnostic_fn); - if (diagnostic_fn && fn) + expr = build_temp (expr, totype, flags, &diag_kind); + if (diag_kind && fn) { if ((complain & tf_error)) - diagnostic_fn (" initializing argument %P of %qD", argnum, fn); - else if (diagnostic_fn == error) + emit_diagnostic (diag_kind, input_location, 0, + " initializing argument %P of %qD", argnum, fn); + else if (diag_kind == DK_ERROR) return error_mark_node; } return build_cplus_new (totype, expr); @@ -6647,10 +6647,12 @@ joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn) tree source = source_type (w->convs[0]); if (! DECL_CONSTRUCTOR_P (w->fn)) source = TREE_TYPE (source); - warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn); - warning (OPT_Wconversion, " for conversion from %qT to %qT", - source, w->second_conv->type); - inform (" because conversion sequence for the argument is better"); + if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn) + && warning (OPT_Wconversion, " for conversion from %qT to %qT", + source, w->second_conv->type)) + { + inform (" because conversion sequence for the argument is better"); + } } else add_warning (w, l); diff --git a/gcc/cp/class.c b/gcc/cp/class.c index f7e46a717aa..b08f9c80d29 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -4306,7 +4306,7 @@ check_bases_and_members (tree t) /* If the class has no user-declared constructor, but does have non-static const or reference data members that can never be initialized, issue a warning. */ - if (extra_warnings + if (warn_uninitialized /* Classes with user-declared constructors are presumed to initialize these members. */ && !TYPE_HAS_USER_CONSTRUCTOR (t) @@ -4325,13 +4325,13 @@ check_bases_and_members (tree t) type = TREE_TYPE (field); if (TREE_CODE (type) == REFERENCE_TYPE) - warning (OPT_Wextra, "non-static reference %q+#D in class " - "without a constructor", field); + warning (OPT_Wuninitialized, "non-static reference %q+#D " + "in class without a constructor", field); else if (CP_TYPE_CONST_P (type) && (!CLASS_TYPE_P (type) || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type))) - warning (OPT_Wextra, "non-static const member %q+#D in class " - "without a constructor", field); + warning (OPT_Wuninitialized, "non-static const member %q+#D " + "in class without a constructor", field); } } diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 02d358a8fe6..4b4bf335836 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -31,8 +31,28 @@ along with GCC; see the file COPYING3. If not see #include "varray.h" #include "c-common.h" #include "name-lookup.h" -struct diagnostic_context; -struct diagnostic_info; + +/* In order for the format checking to accept the C++ front end + diagnostic framework extensions, you must include this file before + toplev.h, not after. We override the definition of GCC_DIAG_STYLE + in c-common.h. */ +#undef GCC_DIAG_STYLE +#define GCC_DIAG_STYLE __gcc_cxxdiag__ +#if GCC_VERSION >= 4001 +#define ATTRIBUTE_GCC_CXXDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m) +#else +#define ATTRIBUTE_GCC_CXXDIAG(m, n) ATTRIBUTE_NONNULL(m) +#endif +extern void cp_cpp_error (cpp_reader *, int, + const char *, va_list *) + ATTRIBUTE_GCC_CXXDIAG(3,0); +#ifdef GCC_TOPLEV_H +#error \ +"In order for the format checking to accept the C++ front end diagnostic\n" +"framework extensions, you must include this file before toplev.h, not after." +#endif +#include "toplev.h" +#include "diagnostic.h" /* Usage of TREE_LANG_FLAG_?: 0: IDENTIFIER_MARKED (IDENTIFIER_NODEs) @@ -4887,11 +4907,11 @@ extern int lvalue_p (const_tree); /* in typeck2.c */ extern void require_complete_eh_spec_types (tree, tree); -extern void cxx_incomplete_type_diagnostic (const_tree, const_tree, int); +extern void cxx_incomplete_type_diagnostic (const_tree, const_tree, diagnostic_t); #undef cxx_incomplete_type_error extern void cxx_incomplete_type_error (const_tree, const_tree); #define cxx_incomplete_type_error(V,T) \ - (cxx_incomplete_type_diagnostic ((V), (T), 0)) + (cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR)) extern tree error_not_base_type (tree, tree); extern tree binfo_or_else (tree, tree); extern void readonly_error (tree, const char *); @@ -4945,19 +4965,4 @@ extern void cp_genericize (tree); /* -- end of C++ */ -/* In order for the format checking to accept the C++ front end - diagnostic framework extensions, you must include this file before - toplev.h, not after. We override the definition of GCC_DIAG_STYLE - in c-common.h. */ -#undef GCC_DIAG_STYLE -#define GCC_DIAG_STYLE __gcc_cxxdiag__ -#if GCC_VERSION >= 4001 -#define ATTRIBUTE_GCC_CXXDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m) -#else -#define ATTRIBUTE_GCC_CXXDIAG(m, n) ATTRIBUTE_NONNULL(m) -#endif -extern void cp_cpp_error (cpp_reader *, int, - const char *, va_list *) - ATTRIBUTE_GCC_CXXDIAG(3,0); - #endif /* ! GCC_CP_TREE_H */ diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 3ee3ba7956b..8e26927c373 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -638,19 +638,35 @@ ocp_convert (tree type, tree expr, int convtype, int flags) if (INTEGRAL_CODE_P (code)) { tree intype = TREE_TYPE (e); - /* enum = enum, enum = int, enum = float, (enum)pointer are all - errors. */ - if (TREE_CODE (type) == ENUMERAL_TYPE - && (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype) + + if (TREE_CODE (type) == ENUMERAL_TYPE) + { + /* enum = enum, enum = int, enum = float, (enum)pointer are all + errors. */ + if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype) || TREE_CODE (intype) == REAL_TYPE) && ! (convtype & CONV_STATIC)) - || TREE_CODE (intype) == POINTER_TYPE)) - { - if (flags & LOOKUP_COMPLAIN) - permerror ("conversion from %q#T to %q#T", intype, type); + || TREE_CODE (intype) == POINTER_TYPE) + { + if (flags & LOOKUP_COMPLAIN) + permerror ("conversion from %q#T to %q#T", intype, type); - if (!flag_permissive) - return error_mark_node; + if (!flag_permissive) + return error_mark_node; + } + + /* [expr.static.cast] + + 8. A value of integral or enumeration type can be explicitly + converted to an enumeration type. The value is unchanged if + the original value is within the range of the enumeration + values. Otherwise, the resulting enumeration value is + unspecified. */ + if (TREE_CODE (expr) == INTEGER_CST && !int_fits_type_p (expr, type)) + warning (OPT_Wconversion, + "the result of the conversion is unspecified because " + "%qE is outside the range of type %qT", + expr, type); } if (MAYBE_CLASS_TYPE_P (intype)) { diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 69fa647881c..b0531604d02 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -6692,7 +6692,8 @@ grokfndecl (tree ctype, newtype = build_function_type (integer_type_node, oldtypeargs); TREE_TYPE (decl) = newtype; } - check_main_parameter_types (decl); + if (warn_main) + check_main_parameter_types (decl); } if (ctype != NULL_TREE @@ -8437,8 +8438,9 @@ grokdeclarator (const cp_declarator *declarator, friendp = 0; } else - permerror ("extra qualification %<%T::%> on member %qs", - ctype, name); + permerror_at (declarator->id_loc, + "extra qualification %<%T::%> on member %qs", + ctype, name); } else if (/* If the qualifying type is already complete, then we can skip the following checks. */ @@ -9268,7 +9270,10 @@ grokdeclarator (const cp_declarator *declarator, warning (0, "%qs initialized and declared %<extern%>", name); } else - error ("%qs has both %<extern%> and initializer", name); + { + error ("%qs has both %<extern%> and initializer", name); + return error_mark_node; + } } /* Record `register' declaration for warnings on & @@ -10615,10 +10620,7 @@ xref_basetypes (tree ref, tree base_list) basetype = PACK_EXPANSION_PATTERN (basetype); if (TREE_CODE (basetype) == TYPE_DECL) basetype = TREE_TYPE (basetype); - if (TREE_CODE (basetype) != RECORD_TYPE - && TREE_CODE (basetype) != TYPENAME_TYPE - && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM - && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM) + if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE) { error ("base type %qT fails to be a struct or class type", basetype); diff --git a/gcc/cp/error.c b/gcc/cp/error.c index ef26ad9114a..03ceddffb78 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -2661,7 +2661,7 @@ cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, dlevel = DK_WARNING; break; case CPP_DL_PEDWARN: - dlevel = pedantic_warning_kind (); + dlevel = DK_PEDWARN; break; case CPP_DL_ERROR: dlevel = DK_ERROR; diff --git a/gcc/cp/friend.c b/gcc/cp/friend.c index 090f84db288..4d9a14ce88e 100644 --- a/gcc/cp/friend.c +++ b/gcc/cp/friend.c @@ -568,9 +568,11 @@ do_friend (tree ctype, tree declarator, tree decl, if (warn) { static int explained; - warning (OPT_Wnon_template_friend, "friend declaration " - "%q#D declares a non-template function", decl); - if (! explained) + bool warned; + + warned = warning (OPT_Wnon_template_friend, "friend declaration " + "%q#D declares a non-template function", decl); + if (! explained && warned) { inform ("(if this is not what you intended, make sure " "the function template has already been declared " diff --git a/gcc/cp/init.c b/gcc/cp/init.c index c6d63b84096..df36c5e829f 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -3035,12 +3035,14 @@ build_delete (tree type, tree addr, special_function_kind auto_delete, complete_type (type); if (!COMPLETE_TYPE_P (type)) { - warning (0, "possible problem detected in invocation of " - "delete operator:"); - cxx_incomplete_type_diagnostic (addr, type, 1); - inform ("neither the destructor nor the class-specific " - "operator delete will be called, even if they are " - "declared when the class is defined."); + if (warning (0, "possible problem detected in invocation of " + "delete operator:")) + { + cxx_incomplete_type_diagnostic (addr, type, DK_WARNING); + inform ("neither the destructor nor the class-specific " + "operator delete will be called, even if they are " + "declared when the class is defined."); + } complete_p = false; } } diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 76adb633ed7..fd4e1bbbe7b 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -9980,15 +9980,14 @@ cp_parser_template_id (cp_parser *parser, } /* Otherwise, emit an error about the invalid digraph, but continue parsing because we got our argument list. */ - permerror ("%H%<<::%> cannot begin a template-argument list", - &next_token->location); - inform ("%H%<<:%> is an alternate spelling for %<[%>. Insert whitespace " + if (permerror ("%H%<<::%> cannot begin a template-argument list", + &next_token->location)) + { + static bool hint = false; + inform ("%H%<<:%> is an alternate spelling for %<[%>. Insert whitespace " "between %<<%> and %<::%>", &next_token->location); - if (!flag_permissive) - { - static bool hint; - if (!hint) + if (!hint && !flag_permissive) { inform ("%H(if you use %<-fpermissive%> G++ will accept your code)", &next_token->location); @@ -10386,9 +10385,10 @@ cp_parser_template_argument (cp_parser* parser) Therefore, we try a type-id first. */ cp_parser_parse_tentatively (parser); argument = cp_parser_type_id (parser); - /* If there was no error parsing the type-id but the next token is a '>>', - we probably found a typo for '> >'. But there are type-id which are - also valid expressions. For instance: + /* If there was no error parsing the type-id but the next token is a + '>>', our behavior depends on which dialect of C++ we're + parsing. In C++98, we probably found a typo for '> >'. But there + are type-id which are also valid expressions. For instance: struct X { int operator >> (int); }; template <int V> struct Foo {}; @@ -10397,8 +10397,12 @@ cp_parser_template_argument (cp_parser* parser) Here 'X()' is a valid type-id of a function type, but the user just wanted to write the expression "X() >> 5". Thus, we remember that we found a valid type-id, but we still try to parse the argument as an - expression to see what happens. */ + expression to see what happens. + + In C++0x, the '>>' will be considered two separate '>' + tokens. */ if (!cp_parser_error_occurred (parser) + && cxx_dialect == cxx98 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT)) { maybe_type_id = true; @@ -14977,11 +14981,17 @@ cp_parser_class_head (cp_parser* parser, cp_parser_commit_to_tentative_parse (parser); /* Issue the error about the overly-qualified name now. */ if (qualified_p) - cp_parser_error (parser, - "global qualification of class name is invalid"); + { + cp_parser_error (parser, + "global qualification of class name is invalid"); + return error_mark_node; + } else if (invalid_nested_name_p) - cp_parser_error (parser, - "qualified name does not name a class"); + { + cp_parser_error (parser, + "qualified name does not name a class"); + return error_mark_node; + } else if (nested_name_specifier) { tree scope; diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 5ada42241fb..3bcab9407d4 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -4475,7 +4475,7 @@ tree finish_decltype_type (tree expr, bool id_expression_or_member_access_p) { tree orig_expr = expr; - tree type; + tree type = NULL_TREE; if (!expr || error_operand_p (expr)) return error_mark_node; @@ -4586,8 +4586,6 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p) } else { - tree fndecl; - /* Expressions of reference type are sometimes wrapped in INDIRECT_REFs. INDIRECT_REFs are just internal compiler representation, not part of the language, so we have to look @@ -4597,14 +4595,28 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p) == REFERENCE_TYPE) expr = TREE_OPERAND (expr, 0); - if (TREE_CODE (expr) == CALL_EXPR - && (fndecl = get_callee_fndecl (expr)) - && (fndecl != error_mark_node)) - /* If e is a function call (5.2.2 [expr.call]) or an + if (TREE_CODE (expr) == CALL_EXPR) + { + /* If e is a function call (5.2.2 [expr.call]) or an invocation of an overloaded operator (parentheses around e are ignored), decltype(e) is defined as the return type of that function. */ - type = TREE_TYPE (TREE_TYPE (fndecl)); + tree fndecl = get_callee_fndecl (expr); + if (fndecl && fndecl != error_mark_node) + type = TREE_TYPE (TREE_TYPE (fndecl)); + else + { + tree target_type = TREE_TYPE (CALL_EXPR_FN (expr)); + if ((TREE_CODE (target_type) == REFERENCE_TYPE + || TREE_CODE (target_type) == POINTER_TYPE) + && (TREE_CODE (TREE_TYPE (target_type)) == FUNCTION_TYPE + || TREE_CODE (TREE_TYPE (target_type)) == METHOD_TYPE)) + type = TREE_TYPE (TREE_TYPE (target_type)); + else + sorry ("unable to determine the declared type of expression %<%E%>", + expr); + } + } else { type = is_bitfield_expr_with_lowered_type (expr); diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index fd3dba9345c..a99526f1318 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -145,7 +145,7 @@ complete_type_or_else (tree type, tree value) return NULL_TREE; else if (!COMPLETE_TYPE_P (type)) { - cxx_incomplete_type_diagnostic (value, type, 0); + cxx_incomplete_type_diagnostic (value, type, DK_ERROR); return NULL_TREE; } else @@ -3839,115 +3839,11 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, && warn_sign_compare /* Do not warn until the template is instantiated; we cannot bound the ranges of the arguments until that point. */ - && !processing_template_decl) + && !processing_template_decl + && (complain & tf_warning)) { - int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); - int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); - - int unsignedp0, unsignedp1; - tree primop0 = get_narrower (op0, &unsignedp0); - tree primop1 = get_narrower (op1, &unsignedp1); - - /* Check for comparison of different enum types. */ - if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE - && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE - && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) - != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)) - && (complain & tf_warning)) - { - warning (OPT_Wsign_compare, "comparison between types %q#T and %q#T", - TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); - } - - /* Give warnings for comparisons between signed and unsigned - quantities that may fail. */ - /* Do the checking based on the original operand trees, so that - casts will be considered, but default promotions won't be. */ - - /* Do not warn if the comparison is being done in a signed type, - since the signed type will only be chosen if it can represent - all the values of the unsigned type. */ - if (!TYPE_UNSIGNED (result_type)) - /* OK */; - /* Do not warn if both operands are unsigned. */ - else if (op0_signed == op1_signed) - /* OK */; - /* Do not warn if the signed quantity is an unsuffixed - integer literal (or some static constant expression - involving such literals or a conditional expression - involving such literals) and it is non-negative. */ - else if ((op0_signed && tree_expr_nonnegative_p (orig_op0)) - || (op1_signed && tree_expr_nonnegative_p (orig_op1))) - /* OK */; - /* Do not warn if the comparison is an equality operation, - the unsigned quantity is an integral constant and it does - not use the most significant bit of result_type. */ - else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR) - && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST - && int_fits_type_p (orig_op1, c_common_signed_type - (result_type))) - || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST - && int_fits_type_p (orig_op0, c_common_signed_type - (result_type))))) - /* OK */; - else if (complain & tf_warning) - warning (OPT_Wsign_compare, - "comparison between signed and unsigned integer expressions"); - - /* Warn if two unsigned values are being compared in a size - larger than their original size, and one (and only one) is the - result of a `~' operator. This comparison will always fail. - - Also warn if one operand is a constant, and the constant does not - have all bits set that are set in the ~ operand when it is - extended. */ - - if ((TREE_CODE (primop0) == BIT_NOT_EXPR) - ^ (TREE_CODE (primop1) == BIT_NOT_EXPR)) - { - if (TREE_CODE (primop0) == BIT_NOT_EXPR) - primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0); - if (TREE_CODE (primop1) == BIT_NOT_EXPR) - primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1); - - if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) - { - tree primop; - HOST_WIDE_INT constant, mask; - int unsignedp; - unsigned int bits; - - if (host_integerp (primop0, 0)) - { - primop = primop1; - unsignedp = unsignedp1; - constant = tree_low_cst (primop0, 0); - } - else - { - primop = primop0; - unsignedp = unsignedp0; - constant = tree_low_cst (primop1, 0); - } - - bits = TYPE_PRECISION (TREE_TYPE (primop)); - if (bits < TYPE_PRECISION (result_type) - && bits < HOST_BITS_PER_LONG && unsignedp) - { - mask = (~ (HOST_WIDE_INT) 0) << bits; - if ((mask & constant) != mask - && (complain & tf_warning)) - warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with constant"); - } - } - else if (unsignedp0 && unsignedp1 - && (TYPE_PRECISION (TREE_TYPE (primop0)) - < TYPE_PRECISION (result_type)) - && (TYPE_PRECISION (TREE_TYPE (primop1)) - < TYPE_PRECISION (result_type)) - && (complain & tf_warning)) - warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with unsigned"); - } + warn_for_sign_compare (orig_op0, orig_op1, op0, op1, + result_type, resultcode); } } diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index 787f43963d6..bca95e970f1 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -332,22 +332,18 @@ abstract_virtuals_error (tree decl, tree type) /* Print an error message for invalid use of an incomplete type. VALUE is the expression that was used (or 0 if that isn't known) - and TYPE is the type that was invalid. DIAG_TYPE indicates the - type of diagnostic: 0 for an error, 1 for a warning, 2 for a - pedwarn. */ + and TYPE is the type that was invalid. DIAG_KIND indicates the + type of diagnostic (see diagnostic.def). */ void -cxx_incomplete_type_diagnostic (const_tree value, const_tree type, int diag_type) +cxx_incomplete_type_diagnostic (const_tree value, const_tree type, + diagnostic_t diag_kind) { int decl = 0; - void (*p_msg) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); - if (diag_type == 1) - p_msg = warning0; - else if (diag_type == 2) - p_msg = pedwarn0; - else - p_msg = error; + gcc_assert (diag_kind == DK_WARNING + || diag_kind == DK_PEDWARN + || diag_kind == DK_ERROR); /* Avoid duplicate error message. */ if (TREE_CODE (type) == ERROR_MARK) @@ -357,7 +353,8 @@ cxx_incomplete_type_diagnostic (const_tree value, const_tree type, int diag_type || TREE_CODE (value) == PARM_DECL || TREE_CODE (value) == FIELD_DECL)) { - p_msg ("%q+D has incomplete type", value); + emit_diagnostic (diag_kind, input_location, 0, + "%q+D has incomplete type", value); decl = 1; } retry: @@ -369,15 +366,19 @@ cxx_incomplete_type_diagnostic (const_tree value, const_tree type, int diag_type case UNION_TYPE: case ENUMERAL_TYPE: if (!decl) - p_msg ("invalid use of incomplete type %q#T", type); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of incomplete type %q#T", type); if (!TYPE_TEMPLATE_INFO (type)) - p_msg ("forward declaration of %q+#T", type); + emit_diagnostic (diag_kind, input_location, 0, + "forward declaration of %q+#T", type); else - p_msg ("declaration of %q+#T", type); + emit_diagnostic (diag_kind, input_location, 0, + "declaration of %q+#T", type); break; case VOID_TYPE: - p_msg ("invalid use of %qT", type); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of %qT", type); break; case ARRAY_TYPE: @@ -386,37 +387,45 @@ cxx_incomplete_type_diagnostic (const_tree value, const_tree type, int diag_type type = TREE_TYPE (type); goto retry; } - p_msg ("invalid use of array with unspecified bounds"); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of array with unspecified bounds"); break; case OFFSET_TYPE: bad_member: - p_msg ("invalid use of member (did you forget the %<&%> ?)"); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of member (did you forget the %<&%> ?)"); break; case TEMPLATE_TYPE_PARM: - p_msg ("invalid use of template type parameter %qT", type); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of template type parameter %qT", type); break; case BOUND_TEMPLATE_TEMPLATE_PARM: - p_msg ("invalid use of template template parameter %qT", - TYPE_NAME (type)); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of template template parameter %qT", + TYPE_NAME (type)); break; case TYPENAME_TYPE: - p_msg ("invalid use of dependent type %qT", type); + emit_diagnostic (diag_kind, input_location, 0, + "invalid use of dependent type %qT", type); break; case UNKNOWN_TYPE: if (value && TREE_CODE (value) == COMPONENT_REF) goto bad_member; else if (value && TREE_CODE (value) == ADDR_EXPR) - p_msg ("address of overloaded function with no contextual " - "type information"); + emit_diagnostic (diag_kind, input_location, 0, + "address of overloaded function with no contextual " + "type information"); else if (value && TREE_CODE (value) == OVERLOAD) - p_msg ("overloaded function with no contextual type information"); + emit_diagnostic (diag_kind, input_location, 0, + "overloaded function with no contextual type information"); else - p_msg ("insufficient contextual information to determine type"); + emit_diagnostic (diag_kind, input_location, 0, + "insufficient contextual information to determine type"); break; default: @@ -430,7 +439,7 @@ cxx_incomplete_type_diagnostic (const_tree value, const_tree type, int diag_type void cxx_incomplete_type_error (const_tree value, const_tree type) { - cxx_incomplete_type_diagnostic (value, type, 0); + cxx_incomplete_type_diagnostic (value, type, DK_ERROR); } @@ -1483,7 +1492,7 @@ add_exception_specifier (tree list, tree spec, int complain) bool ok; tree core = spec; bool is_ptr; - int diag_type = -1; /* none */ + diagnostic_t diag_type = DK_UNSPECIFIED; /* none */ if (spec == error_mark_node) return list; @@ -1512,7 +1521,7 @@ add_exception_specifier (tree list, tree spec, int complain) and calls. So just give a pedwarn at this point; we will give an error later if we hit one of those two cases. */ if (!COMPLETE_TYPE_P (complete_type (core))) - diag_type = 2; /* pedwarn */ + diag_type = DK_PEDWARN; /* pedwarn */ } if (ok) @@ -1526,9 +1535,9 @@ add_exception_specifier (tree list, tree spec, int complain) list = tree_cons (NULL_TREE, spec, list); } else - diag_type = 0; /* error */ + diag_type = DK_ERROR; /* error */ - if (diag_type >= 0 && complain) + if (diag_type != DK_UNSPECIFIED && complain) cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type); return list; diff --git a/gcc/debug.h b/gcc/debug.h index cab1e2603e2..6cdf7863a25 100644 --- a/gcc/debug.h +++ b/gcc/debug.h @@ -160,6 +160,7 @@ extern void dwarf2out_frame_finish (void); /* Decide whether we want to emit frame unwind information for the current translation unit. */ extern int dwarf2out_do_frame (void); +extern int dwarf2out_do_cfi_asm (void); extern void dwarf2out_switch_text_section (void); extern void debug_flush_symbol_queue (void); diff --git a/gcc/defaults.h b/gcc/defaults.h index e68a0651a67..282a14ac00a 100644 --- a/gcc/defaults.h +++ b/gcc/defaults.h @@ -663,16 +663,6 @@ along with GCC; see the file COPYING3. If not see #define PREFERRED_DEBUGGING_TYPE NO_DEBUG #endif -/* Define codes for all the float formats that we know of. */ -#define UNKNOWN_FLOAT_FORMAT 0 -#define IEEE_FLOAT_FORMAT 1 -#define VAX_FLOAT_FORMAT 2 - -/* Default to IEEE float if not specified. Nearly all machines use it. */ -#ifndef TARGET_FLOAT_FORMAT -#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT -#endif - #ifndef LARGEST_EXPONENT_IS_NORMAL #define LARGEST_EXPONENT_IS_NORMAL(SIZE) 0 #endif @@ -681,32 +671,6 @@ along with GCC; see the file COPYING3. If not see #define ROUND_TOWARDS_ZERO 0 #endif -#ifndef MODE_HAS_NANS -#define MODE_HAS_NANS(MODE) \ - (FLOAT_MODE_P (MODE) \ - && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT \ - && !LARGEST_EXPONENT_IS_NORMAL (GET_MODE_BITSIZE (MODE))) -#endif - -#ifndef MODE_HAS_INFINITIES -#define MODE_HAS_INFINITIES(MODE) \ - (FLOAT_MODE_P (MODE) \ - && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT \ - && !LARGEST_EXPONENT_IS_NORMAL (GET_MODE_BITSIZE (MODE))) -#endif - -#ifndef MODE_HAS_SIGNED_ZEROS -#define MODE_HAS_SIGNED_ZEROS(MODE) \ - (FLOAT_MODE_P (MODE) && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT) -#endif - -#ifndef MODE_HAS_SIGN_DEPENDENT_ROUNDING -#define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \ - (FLOAT_MODE_P (MODE) \ - && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT \ - && !ROUND_TOWARDS_ZERO) -#endif - #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false #endif diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c index 356180df830..6fff79ceed5 100644 --- a/gcc/diagnostic.c +++ b/gcc/diagnostic.c @@ -42,7 +42,10 @@ along with GCC; see the file COPYING3. If not see #include "opts.h" #include "compiler-probe.h" + /* we just need to kill the compiler probe on internal|fatal errors */ +#define pedantic_warning_kind() (flag_pedantic_errors ? DK_ERROR : DK_WARNING) +#define permissive_error_kind() (flag_permissive ? DK_WARNING : DK_ERROR) /* Prototypes. */ static char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1; @@ -295,9 +298,10 @@ diagnostic_classify_diagnostic (diagnostic_context *context, DC. This function is *the* subroutine in terms of which front-ends should implement their specific diagnostic handling modules. The front-end independent format specifiers are exactly those described - in the documentation of output_format. */ + in the documentation of output_format. + Return true if a diagnostic was printed, false otherwise. */ -void +bool diagnostic_report_diagnostic (diagnostic_context *context, diagnostic_info *diagnostic) { @@ -307,9 +311,12 @@ diagnostic_report_diagnostic (diagnostic_context *context, /* Give preference to being able to inhibit warnings, before they get reclassified to something else. */ - if (diagnostic->kind == DK_WARNING + if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN) && !diagnostic_report_warnings_p (location)) - return; + return false; + + if (diagnostic->kind == DK_PEDWARN) + diagnostic->kind = pedantic_warning_kind (); if (context->lock > 0) { @@ -338,7 +345,7 @@ diagnostic_report_diagnostic (diagnostic_context *context, /* This tests if the user provided the appropriate -Wfoo or -Wno-foo option. */ if (! option_enabled (diagnostic->option_index)) - return; + return false; /* This tests if the user provided the appropriate -Werror=foo option. */ if (context->classify_diagnostic[diagnostic->option_index] != DK_UNSPECIFIED) @@ -349,7 +356,7 @@ diagnostic_report_diagnostic (diagnostic_context *context, /* This allows for future extensions, like temporarily disabling warnings for ranges of source code. */ if (diagnostic->kind == DK_IGNORED) - return; + return false; } /* If we changed the kind due to -Werror, and didn't override it, we @@ -405,6 +412,8 @@ diagnostic_report_diagnostic (diagnostic_context *context, diagnostic->abstract_origin = NULL; context->lock--; + + return true; } /* Given a partial pathname as input, return another pathname that @@ -459,51 +468,66 @@ verbatim (const char *gmsgid, ...) va_end (ap); } -/* An informative note. Use this for additional details on an error - message. */ -void -inform (const char *gmsgid, ...) +bool +emit_diagnostic (diagnostic_t kind, location_t location, int opt, + const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; va_start (ap, gmsgid); - diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_NOTE); - report_diagnostic (&diagnostic); + if (kind == DK_PERMERROR) + { + diagnostic_set_info (&diagnostic, gmsgid, &ap, location, + permissive_error_kind ()); + diagnostic.option_index = OPT_fpermissive; + } + else { + diagnostic_set_info (&diagnostic, gmsgid, &ap, location, kind); + if (kind == DK_WARNING || kind == DK_PEDWARN) + diagnostic.option_index = opt; + } va_end (ap); + + return report_diagnostic (&diagnostic); } -/* A warning at INPUT_LOCATION. Use this for code which is correct according - to the relevant language specification but is likely to be buggy anyway. */ +/* An informative note. Use this for additional details on an error + message. */ void -warning (int opt, const char *gmsgid, ...) +inform (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; va_start (ap, gmsgid); - diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING); - diagnostic.option_index = opt; - + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_NOTE); report_diagnostic (&diagnostic); va_end (ap); } -void -warning0 (const char *gmsgid, ...) +/* A warning at INPUT_LOCATION. Use this for code which is correct according + to the relevant language specification but is likely to be buggy anyway. + Returns true if the warning was printed, false if it was inhibited. */ +bool +warning (int opt, const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; va_start (ap, gmsgid); diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING); - report_diagnostic (&diagnostic); + diagnostic.option_index = opt; + va_end (ap); + return report_diagnostic (&diagnostic); } /* A warning at LOCATION. Use this for code which is correct according to the - relevant language specification but is likely to be buggy anyway. */ -void + relevant language specification but is likely to be buggy anyway. + Returns true if the warning was printed, false if it was inhibited. */ + +bool warning_at (location_t location, int opt, const char *gmsgid, ...) { diagnostic_info diagnostic; @@ -512,56 +536,75 @@ warning_at (location_t location, int opt, const char *gmsgid, ...) va_start (ap, gmsgid); diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_WARNING); diagnostic.option_index = opt; - - report_diagnostic (&diagnostic); va_end (ap); + return report_diagnostic (&diagnostic); } -/* A "pedantic" warning: issues a warning unless -pedantic-errors was - given on the command line, in which case it issues an error. Use - this for diagnostics required by the relevant language standard, - if you have chosen not to make them errors. +/* A "pedantic" warning at LOCATION: issues a warning unless + -pedantic-errors was given on the command line, in which case it + issues an error. Use this for diagnostics required by the relevant + language standard, if you have chosen not to make them errors. Note that these diagnostics are issued independent of the setting of the -pedantic command-line switch. To get a warning enabled only with that switch, use either "if (pedantic) pedwarn (OPT_pedantic,...)" or just "pedwarn (OPT_pedantic,..)". To get a - pedwarn independently of the -pedantic switch use "pedwarn (0,...)". */ + pedwarn independently of the -pedantic switch use "pedwarn (0,...)". -void -pedwarn (int opt, const char *gmsgid, ...) + Returns true if the warning was printed, false if it was inhibited. */ + +bool +pedwarn_at (location_t location, int opt, const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; va_start (ap, gmsgid); - diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, - pedantic_warning_kind ()); + diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_PEDWARN); diagnostic.option_index = opt; + va_end (ap); + return report_diagnostic (&diagnostic); +} - report_diagnostic (&diagnostic); +/* Equivalent to pedwarn_at using INPUT_LOCATION. */ + +bool +pedwarn (int opt, const char *gmsgid, ...) +{ + diagnostic_info diagnostic; + va_list ap; + + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_PEDWARN); + diagnostic.option_index = opt; va_end (ap); + return report_diagnostic (&diagnostic); } -void -pedwarn0 (const char *gmsgid, ...) +/* A "permissive" error at LOCATION: issues an error unless + -fpermissive was given on the command line, in which case it issues + a warning. Use this for things that really should be errors but we + want to support legacy code. + + Returns true if the warning was printed, false if it was inhibited. */ + +bool +permerror_at (location_t location, const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; va_start (ap, gmsgid); - diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, - pedantic_warning_kind ()); - report_diagnostic (&diagnostic); + diagnostic_set_info (&diagnostic, gmsgid, &ap, location, + permissive_error_kind ()); + diagnostic.option_index = OPT_fpermissive; va_end (ap); + return report_diagnostic (&diagnostic); } -/* A "permissive" error: issues an error unless -fpermissive was given - on the command line, in which case it issues a warning. Use this - for things that really should be errors but we want to support - legacy code. */ +/* Equivalent to permerror_at (input_location, ...). */ -void +bool permerror (const char *gmsgid, ...) { diagnostic_info diagnostic; @@ -571,8 +614,8 @@ permerror (const char *gmsgid, ...) diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, permissive_error_kind ()); diagnostic.option_index = OPT_fpermissive; - report_diagnostic (&diagnostic); va_end (ap); + return report_diagnostic (&diagnostic); } diff --git a/gcc/diagnostic.def b/gcc/diagnostic.def index bbdba2f1aa2..39064198eae 100644 --- a/gcc/diagnostic.def +++ b/gcc/diagnostic.def @@ -20,4 +20,8 @@ DEFINE_DIAGNOSTIC_KIND (DK_WARNING, "warning: ") DEFINE_DIAGNOSTIC_KIND (DK_ANACHRONISM, "anachronism: ") DEFINE_DIAGNOSTIC_KIND (DK_NOTE, "note: ") DEFINE_DIAGNOSTIC_KIND (DK_DEBUG, "debug: ") +/* These two would be re-classified as DK_WARNING or DK_ERROR, so the +prefix does not matter. */ +DEFINE_DIAGNOSTIC_KIND (DK_PEDWARN, "pedwarn: ") +DEFINE_DIAGNOSTIC_KIND (DK_PERMERROR, "permerror: ") diff --git a/gcc/diagnostic.h b/gcc/diagnostic.h index 8906cc48ca0..19bc5e9c8d0 100644 --- a/gcc/diagnostic.h +++ b/gcc/diagnostic.h @@ -50,10 +50,6 @@ typedef struct diagnostic_info int option_index; } diagnostic_info; -#define pedantic_warning_kind() (flag_pedantic_errors ? DK_ERROR : DK_WARNING) -#define permissive_error_kind() (flag_permissive ? DK_WARNING : DK_ERROR) - - /* Forward declarations. */ typedef struct diagnostic_context diagnostic_context; typedef void (*diagnostic_starter_fn) (diagnostic_context *, @@ -82,7 +78,7 @@ struct diagnostic_context the diagnostic should be changed to before reporting, or DK_UNSPECIFIED to leave it as the reported kind, or DK_IGNORED to not report it at all. N_OPTS is from <options.h>. */ - char classify_diagnostic[N_OPTS]; + diagnostic_t classify_diagnostic[N_OPTS]; /* True if we should print the command line option which controls each diagnostic, if known. */ @@ -199,7 +195,7 @@ extern void diagnostic_report_current_function (diagnostic_context *, extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *, int /* optidx */, diagnostic_t /* kind */); -extern void diagnostic_report_diagnostic (diagnostic_context *, +extern bool diagnostic_report_diagnostic (diagnostic_context *, diagnostic_info *); #ifdef ATTRIBUTE_GCC_DIAG extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *, @@ -208,6 +204,8 @@ extern void diagnostic_set_info_translated (diagnostic_info *, const char *, va_list *, location_t, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0); +extern bool emit_diagnostic (diagnostic_t, location_t, int, + const char *, ...) ATTRIBUTE_GCC_DIAG(4,5); #endif extern char *diagnostic_build_prefix (diagnostic_info *); diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 9557ba3bad9..66fb8401c78 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -8071,6 +8071,7 @@ v2di __builtin_ia32_psrlqi128 (v2di, int) v8hi __builtin_ia32_psrawi128 (v8hi, int) v4si __builtin_ia32_psradi128 (v4si, int) v4si __builtin_ia32_pmaddwd128 (v8hi, v8hi) +v2di __builtin_ia32_movq128 (v2di) @end smallexample The following built-in functions are available when @option{-msse3} is used. diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index f2aeb2c9586..a69a0859ce0 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -2416,7 +2416,7 @@ AIX: @uref{http://www.bullfreeware.com,,Bull's Freeware and Shareware Archive for AIX}; @item -@uref{http://pware.hvcc.edu,,Hudson Valley Community College Open Source Softeware for IBM System p}; +@uref{http://pware.hvcc.edu,,Hudson Valley Community College Open Source Software for IBM System p}; @item @uref{http://www.perzl.org/aix,,AIX 5L and 6 Open Source Packages}. @@ -2625,9 +2625,9 @@ information are. @item @uref{#x86-64-x-x,,x86_64-*-*, amd64-*-*} @item -@uref{#xtensa-x-elf,,xtensa-*-elf} +@uref{#xtensa-x-elf,,xtensa*-*-elf} @item -@uref{#xtensa-x-linux,,xtensa-*-linux*} +@uref{#xtensa-x-linux,,xtensa*-*-linux*} @item @uref{#windows,,Microsoft Windows} @item @@ -4036,7 +4036,7 @@ both 64-bit x86-64 and 32-bit x86 code (via the @option{-m32} switch). @html <hr /> @end html -@heading @anchor{xtensa-x-elf}xtensa-*-elf +@heading @anchor{xtensa-x-elf}xtensa*-*-elf This target is intended for embedded Xtensa systems using the @samp{newlib} C library. It uses ELF but does not support shared @@ -4054,14 +4054,14 @@ which you can use to replace the default header file. @html <hr /> @end html -@heading @anchor{xtensa-x-linux}xtensa-*-linux* +@heading @anchor{xtensa-x-linux}xtensa*-*-linux* This target is for Xtensa systems running GNU/Linux. It supports ELF shared objects and the GNU C library (glibc). It also generates position-independent code (PIC) regardless of whether the @option{-fpic} or @option{-fPIC} options are used. In other respects, this target is the same as the -@uref{#xtensa-*-elf,,@samp{xtensa-*-elf}} target. +@uref{#xtensa*-*-elf,,@samp{xtensa*-*-elf}} target. @html <hr /> diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 99ad87b969d..d855e9bcb61 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -2754,10 +2754,6 @@ A pointer is compared against integer zero with @samp{<}, @samp{<=}, conditional expression. @item -(C++ only) A non-static reference or non-static @samp{const} member -appears in a class without constructors. - -@item (C++ only) Ambiguous virtual bases. @item @@ -2949,10 +2945,11 @@ This warning is also enabled by @option{-Wextra}. @item -Wmain @opindex Wmain @opindex Wno-main -Warn if the type of @samp{main} is suspicious. @samp{main} should be a -function with external linkage, returning int, taking either zero -arguments, two, or three arguments of appropriate types. -This warning is enabled by @option{-Wall}. +Warn if the type of @samp{main} is suspicious. @samp{main} should be +a function with external linkage, returning int, taking either zero +arguments, two, or three arguments of appropriate types. This warning +is enabled by default in C++ and is enabled by either @option{-Wall} +or @option{-pedantic}. @item -Wmissing-braces @opindex Wmissing-braces @@ -3178,8 +3175,10 @@ either specify @samp{-Wextra -Wunused} (note that @samp{-Wall} implies @item -Wuninitialized @opindex Wuninitialized @opindex Wno-uninitialized -Warn if an automatic variable is used without first being initialized or -if a variable may be clobbered by a @code{setjmp} call. +Warn if an automatic variable is used without first being initialized +or if a variable may be clobbered by a @code{setjmp} call. In C++, +warn if a non-static reference or non-static @samp{const} member +appears in a class without constructors. If you want to warn about code which uses the uninitialized value of the variable in its own initializer, use the @option{-Winit-self} option. @@ -5849,7 +5848,8 @@ With this flag, the program debug info reflects a new structure layout. @item -fipa-pta @opindex fipa-pta -Perform interprocedural pointer analysis. +Perform interprocedural pointer analysis. This option is experimental +and does not affect generated code. @item -fipa-cp @opindex fipa-cp @@ -13029,7 +13029,7 @@ Supported values for @var{cpu_type} are @samp{401}, @samp{403}, @samp{860}, @samp{970}, @samp{8540}, @samp{e300c2}, @samp{e300c3}, @samp{e500mc}, @samp{ec603e}, @samp{G3}, @samp{G4}, @samp{G5}, @samp{power}, @samp{power2}, @samp{power3}, @samp{power4}, -@samp{power5}, @samp{power5+}, @samp{power6}, @samp{power6x}, +@samp{power5}, @samp{power5+}, @samp{power6}, @samp{power6x}, @samp{power7} @samp{common}, @samp{powerpc}, @samp{powerpc64}, @samp{rios}, @samp{rios1}, @samp{rios2}, @samp{rsc}, and @samp{rs64}. diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 228af27d621..5decc331bd4 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -1385,100 +1385,12 @@ of shift instructions expanded to libgcc calls. If not defined targets. @end deftypefn -@defmac TARGET_FLOAT_FORMAT -A code distinguishing the floating point format of the target machine. -There are two defined values: - -@ftable @code -@item IEEE_FLOAT_FORMAT -This code indicates IEEE floating point. It is the default; there is no -need to define @code{TARGET_FLOAT_FORMAT} when the format is IEEE@. - -@item VAX_FLOAT_FORMAT -This code indicates the ``F float'' (for @code{float}) and ``D float'' -or ``G float'' formats (for @code{double}) used on the VAX and PDP-11@. -@end ftable - -If your target uses a floating point format other than these, you must -define a new @var{name}_FLOAT_FORMAT code for it, and add support for -it to @file{real.c}. - -The ordering of the component words of floating point values stored in -memory is controlled by @code{FLOAT_WORDS_BIG_ENDIAN}. -@end defmac - -@defmac MODE_HAS_NANS (@var{mode}) -When defined, this macro should be true if @var{mode} has a NaN -representation. The compiler assumes that NaNs are not equal to -anything (including themselves) and that addition, subtraction, -multiplication and division all return NaNs when one operand is -NaN@. - -By default, this macro is true if @var{mode} is a floating-point -mode and the target floating-point format is IEEE@. -@end defmac - -@defmac MODE_HAS_INFINITIES (@var{mode}) -This macro should be true if @var{mode} can represent infinity. At -present, the compiler uses this macro to decide whether @samp{x - x} -is always defined. By default, the macro is true when @var{mode} -is a floating-point mode and the target format is IEEE@. -@end defmac - -@defmac MODE_HAS_SIGNED_ZEROS (@var{mode}) -True if @var{mode} distinguishes between positive and negative zero. -The rules are expected to follow the IEEE standard: - -@itemize @bullet -@item -@samp{x + x} has the same sign as @samp{x}. - -@item -If the sum of two values with opposite sign is zero, the result is -positive for all rounding modes expect towards @minus{}infinity, for -which it is negative. - -@item -The sign of a product or quotient is negative when exactly one -of the operands is negative. -@end itemize - -The default definition is true if @var{mode} is a floating-point -mode and the target format is IEEE@. -@end defmac - -@defmac MODE_HAS_SIGN_DEPENDENT_ROUNDING (@var{mode}) -If defined, this macro should be true for @var{mode} if it has at -least one rounding mode in which @samp{x} and @samp{-x} can be -rounded to numbers of different magnitude. Two such modes are -towards @minus{}infinity and towards +infinity. - -The default definition of this macro is true if @var{mode} is -a floating-point mode and the target format is IEEE@. -@end defmac - @defmac ROUND_TOWARDS_ZERO If defined, this macro should be true if the prevailing rounding -mode is towards zero. A true value has the following effects: +mode is towards zero. -@itemize @bullet -@item -@code{MODE_HAS_SIGN_DEPENDENT_ROUNDING} will be false for all modes. - -@item -@file{libgcc.a}'s floating-point emulator will round towards zero -rather than towards nearest. - -@item -The compiler's floating-point emulator will round towards zero after -doing arithmetic, and when converting from the internal float format to -the target format. -@end itemize - -The macro does not affect the parsing of string literals. When the -primary rounding mode is towards zero, library functions like -@code{strtod} might still round towards nearest, and the compiler's -parser should behave like the target's @code{strtod} where possible. +Defining this macro only affects the way @file{libgcc.a} emulates +floating-point arithmetic. Not defining this macro is equivalent to returning zero. @end defmac @@ -1488,9 +1400,7 @@ This macro should return true if floats with @var{size} bits do not have a NaN or infinity representation, but use the largest exponent for normal numbers instead. -Defining this macro to true for @var{size} causes @code{MODE_HAS_NANS} -and @code{MODE_HAS_INFINITIES} to be false for @var{size}-bit modes. -It also affects the way @file{libgcc.a} and @file{real.c} emulate +Defining this macro only affects the way @file{libgcc.a} emulates floating-point arithmetic. The default definition of this macro returns false for all sizes. diff --git a/gcc/dojump.c b/gcc/dojump.c index fb8d139b111..46aa4f2ebb8 100644 --- a/gcc/dojump.c +++ b/gcc/dojump.c @@ -304,8 +304,6 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) break; } - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: case COMPOUND_EXPR: /* Lowered by gimplify.c. */ gcc_unreachable (); @@ -515,6 +513,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) if (BRANCH_COST >= 4 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1))) goto normal; + case TRUTH_ANDIF_EXPR: if (if_false_label == NULL_RTX) { drop_through_label = gen_label_rtx (); @@ -535,6 +534,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) if (BRANCH_COST >= 4 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1))) goto normal; + case TRUTH_ORIF_EXPR: if (if_true_label == NULL_RTX) { drop_through_label = gen_label_rtx (); diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index ad09949cc15..fff0859e0be 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -130,6 +130,32 @@ dwarf2out_do_frame (void) ); } +/* Decide whether to emit frame unwind via assembler directives. */ + +int +dwarf2out_do_cfi_asm (void) +{ + int enc; + + if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ()) + return false; + if (!eh_personality_libfunc) + return true; + if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE) + return false; + + /* Make sure the personality encoding is one the assembler can support. + In particular, aligned addresses can't be handled. */ + enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1); + if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel) + return false; + enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0); + if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel) + return false; + + return true; +} + /* The size of the target's pointer type. */ #ifndef PTR_SIZE #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) @@ -667,7 +693,7 @@ dwarf2out_cfi_label (void) { static char label[20]; - if (flag_dwarf2_cfi_asm) + if (dwarf2out_do_cfi_asm ()) { /* In this case, we will be emitting the asm directive instead of the label, so just return a placeholder to keep the rest of the @@ -691,7 +717,7 @@ add_fde_cfi (const char *label, dw_cfi_ref cfi) { dw_cfi_ref *list_head = &cie_cfi_head; - if (flag_dwarf2_cfi_asm) + if (dwarf2out_do_cfi_asm ()) { if (label) { @@ -1255,9 +1281,6 @@ compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size, barrier_args_size [INSN_UID (dest)] = cur_args_size; VEC_safe_push (rtx, heap, *next, dest); } - else - gcc_assert (barrier_args_size[INSN_UID (dest)] - == cur_args_size); } } @@ -1315,8 +1338,6 @@ compute_barrier_args_size (void) { /* The insns starting with this label have been already scanned or are in the worklist. */ - gcc_assert (barrier_args_size[INSN_UID (insn)] - == cur_args_size); break; } } @@ -2767,7 +2788,7 @@ output_call_frame_info (int for_eh) return; /* Nothing to do if the assembler's doing it all. */ - if (flag_dwarf2_cfi_asm) + if (dwarf2out_do_cfi_asm ()) return; /* If we make FDEs linkonce, we may have to emit an empty label for @@ -3187,7 +3208,7 @@ dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, dwarf2out_source_line (line, file); #endif - if (flag_dwarf2_cfi_asm) + if (dwarf2out_do_cfi_asm ()) { int enc; rtx ref; @@ -3242,7 +3263,7 @@ dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, dw_fde_ref fde; char label[MAX_ARTIFICIAL_LABEL_BYTES]; - if (flag_dwarf2_cfi_asm) + if (dwarf2out_do_cfi_asm ()) fprintf (asm_out_file, "\t.cfi_endproc\n"); /* Output a label to mark the endpoint of the code generated for this @@ -3451,15 +3472,7 @@ typedef struct dw_loc_list_struct GTY(()) #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) -static const char *dwarf_stack_op_name (unsigned); -static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom, - unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); -static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref); -static unsigned long size_of_loc_descr (dw_loc_descr_ref); -static unsigned long size_of_locs (dw_loc_descr_ref); -static void output_loc_operands (dw_loc_descr_ref); -static void output_loc_sequence (dw_loc_descr_ref); /* Convert a DWARF stack opcode into its string name. */ @@ -3795,6 +3808,25 @@ new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, return descr; } +/* Return a pointer to a newly allocated location description for + REG and OFFSET. */ + +static inline dw_loc_descr_ref +new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset) +{ + if (offset) + { + if (reg <= 31) + return new_loc_descr (DW_OP_breg0 + reg, offset, 0); + else + return new_loc_descr (DW_OP_bregx, reg, offset); + } + else if (reg <= 31) + return new_loc_descr (DW_OP_reg0 + reg, 0, 0); + else + return new_loc_descr (DW_OP_regx, reg, 0); +} + /* Add a location description term to a location description expression. */ static inline void @@ -4295,18 +4327,7 @@ build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) if (cfa->indirect) { - if (cfa->base_offset) - { - if (cfa->reg <= 31) - head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); - else - head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); - } - else if (cfa->reg <= 31) - head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); - else - head = new_loc_descr (DW_OP_regx, cfa->reg, 0); - + head = new_reg_loc_descr (cfa->reg, cfa->base_offset); head->dw_loc_oprnd1.val_class = dw_val_class_const; tmp = new_loc_descr (DW_OP_deref, 0, 0); add_loc_descr (&head, tmp); @@ -4317,17 +4338,7 @@ build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) } } else - { - if (offset == 0) - if (cfa->reg <= 31) - head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); - else - head = new_loc_descr (DW_OP_regx, cfa->reg, 0); - else if (cfa->reg <= 31) - head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0); - else - head = new_loc_descr (DW_OP_bregx, cfa->reg, offset); - } + head = new_reg_loc_descr (cfa->reg, offset); return head; } @@ -4346,21 +4357,15 @@ build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment) /* When CFA is defined as FP+OFFSET, emulate stack alignment. */ if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0) { - if (dwarf_fp <= 31) - head = new_loc_descr (DW_OP_breg0 + dwarf_fp, 0, 0); - else - head = new_loc_descr (DW_OP_bregx, dwarf_fp, 0); - + head = new_reg_loc_descr (dwarf_fp, 0); add_loc_descr (&head, int_loc_descriptor (alignment)); add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0)); add_loc_descr (&head, int_loc_descriptor (offset)); add_loc_descr (&head, new_loc_descr (DW_OP_plus, 0, 0)); } - else if (dwarf_fp <= 31) - head = new_loc_descr (DW_OP_breg0 + dwarf_fp, offset, 0); else - head = new_loc_descr (DW_OP_bregx, dwarf_fp, offset); + head = new_reg_loc_descr (dwarf_fp, offset); return head; } @@ -9642,11 +9647,7 @@ reg_loc_descriptor (rtx rtl, enum var_init_status initialized) static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized) { - dw_loc_descr_ref reg_loc_descr; - if (regno <= 31) - reg_loc_descr = new_loc_descr (DW_OP_reg0 + regno, 0, 0); - else - reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0); + dw_loc_descr_ref reg_loc_descr = new_reg_loc_descr (regno, 0); if (initialized == VAR_INIT_STATUS_UNINITIALIZED) add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0)); @@ -9809,10 +9810,7 @@ based_loc_descr (rtx reg, HOST_WIDE_INT offset, = DWARF_FRAME_REGNUM (cfa.indirect ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM); - if (base_reg <= 31) - return new_loc_descr (DW_OP_breg0 + base_reg, offset, 0); - else - return new_loc_descr (DW_OP_bregx, base_reg, offset); + return new_reg_loc_descr (base_reg, offset); } offset += frame_pointer_fb_offset; diff --git a/gcc/errors.c b/gcc/errors.c index ec70d55ccb1..a1ccfeff43d 100644 --- a/gcc/errors.c +++ b/gcc/errors.c @@ -40,7 +40,7 @@ int have_error = 0; /* Print a warning message - output produced, but there may be problems. */ -void +bool warning (int opt ATTRIBUTE_UNUSED, const char *format, ...) { va_list ap; @@ -50,6 +50,7 @@ warning (int opt ATTRIBUTE_UNUSED, const char *format, ...) vfprintf (stderr, format, ap); va_end (ap); fputc('\n', stderr); + return true; } diff --git a/gcc/errors.h b/gcc/errors.h index 29c16f3f333..ec080da03d4 100644 --- a/gcc/errors.h +++ b/gcc/errors.h @@ -33,7 +33,7 @@ along with GCC; see the file COPYING3. If not see version of warning(). For those, you'd pass an OPT_W* value from options.h, but in generator programs it has no effect, so it's OK to just pass zero for calls from generator-only files. */ -extern void warning (int, const char *, ...) ATTRIBUTE_PRINTF_2 ATTRIBUTE_COLD; +extern bool warning (int, const char *, ...) ATTRIBUTE_PRINTF_2 ATTRIBUTE_COLD; extern void error (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_COLD; extern void fatal (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1 ATTRIBUTE_COLD; extern void internal_error (const char *, ...) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1 ATTRIBUTE_COLD; diff --git a/gcc/except.c b/gcc/except.c index 962dd0b8b64..77a3049ba5e 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -148,9 +148,9 @@ struct eh_region GTY(()) /* A list of catch blocks, a surrounding try block, and the label for continuing after a catch. */ struct eh_region_u_try { - struct eh_region *catch; + struct eh_region *eh_catch; struct eh_region *last_catch; - } GTY ((tag ("ERT_TRY"))) try; + } GTY ((tag ("ERT_TRY"))) eh_try; /* The list through the catch handlers, the list of type objects matched, and the list of associated filters. */ @@ -159,7 +159,7 @@ struct eh_region GTY(()) struct eh_region *prev_catch; tree type_list; tree filter_list; - } GTY ((tag ("ERT_CATCH"))) catch; + } GTY ((tag ("ERT_CATCH"))) eh_catch; /* A tree_list of allowed types. */ struct eh_region_u_allowed { @@ -171,7 +171,7 @@ struct eh_region GTY(()) for a throw. */ struct eh_region_u_throw { tree type; - } GTY ((tag ("ERT_THROW"))) throw; + } GTY ((tag ("ERT_THROW"))) eh_throw; /* Retain the cleanup expression even after expansion so that we can match up fixup regions. */ @@ -479,14 +479,14 @@ gen_eh_region_catch (struct eh_region *t, tree type_or_list) } c = gen_eh_region (ERT_CATCH, t->outer); - c->u.catch.type_list = type_list; - l = t->u.try.last_catch; - c->u.catch.prev_catch = l; + c->u.eh_catch.type_list = type_list; + l = t->u.eh_try.last_catch; + c->u.eh_catch.prev_catch = l; if (l) - l->u.catch.next_catch = c; + l->u.eh_catch.next_catch = c; else - t->u.try.catch = c; - t->u.try.last_catch = c; + t->u.eh_try.eh_catch = c; + t->u.eh_try.last_catch = c; return c; } @@ -683,7 +683,7 @@ remove_unreachable_regions (rtx insns) /* TRY regions are reachable if any of its CATCH regions are reachable. */ struct eh_region *c; - for (c = r->u.try.catch; c ; c = c->u.catch.next_catch) + for (c = r->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch) if (reachable[c->region_number]) { kill_it = false; @@ -988,17 +988,17 @@ duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map, switch (cur->type) { case ERT_TRY: - if (cur->u.try.catch) - REMAP (cur->u.try.catch); - if (cur->u.try.last_catch) - REMAP (cur->u.try.last_catch); + if (cur->u.eh_try.eh_catch) + REMAP (cur->u.eh_try.eh_catch); + if (cur->u.eh_try.last_catch) + REMAP (cur->u.eh_try.last_catch); break; case ERT_CATCH: - if (cur->u.catch.next_catch) - REMAP (cur->u.catch.next_catch); - if (cur->u.catch.prev_catch) - REMAP (cur->u.catch.prev_catch); + if (cur->u.eh_catch.next_catch) + REMAP (cur->u.eh_catch.next_catch); + if (cur->u.eh_catch.prev_catch) + REMAP (cur->u.eh_catch.prev_catch); break; case ERT_CLEANUP: @@ -1290,21 +1290,21 @@ assign_filter_values (void) case ERT_CATCH: /* Whatever type_list is (NULL or true list), we build a list of filters for the region. */ - r->u.catch.filter_list = NULL_TREE; + r->u.eh_catch.filter_list = NULL_TREE; - if (r->u.catch.type_list != NULL) + if (r->u.eh_catch.type_list != NULL) { /* Get a filter value for each of the types caught and store them in the region's dedicated list. */ - tree tp_node = r->u.catch.type_list; + tree tp_node = r->u.eh_catch.type_list; for (;tp_node; tp_node = TREE_CHAIN (tp_node)) { int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node)); tree flt_node = build_int_cst (NULL_TREE, flt); - r->u.catch.filter_list - = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list); + r->u.eh_catch.filter_list + = tree_cons (NULL_TREE, flt_node, r->u.eh_catch.filter_list); } } else @@ -1314,8 +1314,8 @@ assign_filter_values (void) int flt = add_ttypes_entry (ttypes, NULL); tree flt_node = build_int_cst (NULL_TREE, flt); - r->u.catch.filter_list - = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list); + r->u.eh_catch.filter_list + = tree_cons (NULL_TREE, flt_node, r->u.eh_catch.filter_list); } break; @@ -1400,17 +1400,17 @@ build_post_landing_pads (void) Rapid prototyping sez a sequence of ifs. */ { struct eh_region *c; - for (c = region->u.try.catch; c ; c = c->u.catch.next_catch) + for (c = region->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch) { - if (c->u.catch.type_list == NULL) + if (c->u.eh_catch.type_list == NULL) emit_jump (c->label); else { /* Need for one cmp/jump per type caught. Each type list entry has a matching entry in the filter list (see assign_filter_values). */ - tree tp_node = c->u.catch.type_list; - tree flt_node = c->u.catch.filter_list; + tree tp_node = c->u.eh_catch.type_list; + tree flt_node = c->u.eh_catch.filter_list; for (; tp_node; ) { @@ -1437,7 +1437,7 @@ build_post_landing_pads (void) seq = get_insns (); end_sequence (); - emit_to_new_bb_before (seq, region->u.try.catch->label); + emit_to_new_bb_before (seq, region->u.eh_try.eh_catch->label); break; @@ -1651,7 +1651,7 @@ sjlj_find_directly_reachable_regions (struct sjlj_lp_info *lp_info) type_thrown = NULL_TREE; if (region->type == ERT_THROW) { - type_thrown = region->u.throw.type; + type_thrown = region->u.eh_throw.type; region = region->outer; } @@ -2204,28 +2204,28 @@ remove_eh_handler (struct eh_region *region) if (region->type == ERT_CATCH) { - struct eh_region *try, *next, *prev; + struct eh_region *eh_try, *next, *prev; - for (try = region->next_peer; - try->type == ERT_CATCH; - try = try->next_peer) + for (eh_try = region->next_peer; + eh_try->type == ERT_CATCH; + eh_try = eh_try->next_peer) continue; - gcc_assert (try->type == ERT_TRY); + gcc_assert (eh_try->type == ERT_TRY); - next = region->u.catch.next_catch; - prev = region->u.catch.prev_catch; + next = region->u.eh_catch.next_catch; + prev = region->u.eh_catch.prev_catch; if (next) - next->u.catch.prev_catch = prev; + next->u.eh_catch.prev_catch = prev; else - try->u.try.last_catch = prev; + eh_try->u.eh_try.last_catch = prev; if (prev) - prev->u.catch.next_catch = next; + prev->u.eh_catch.next_catch = next; else { - try->u.try.catch = next; + eh_try->u.eh_try.eh_catch = next; if (! next) - remove_eh_handler (try); + remove_eh_handler (eh_try); } } } @@ -2388,10 +2388,10 @@ reachable_next_level (struct eh_region *region, tree type_thrown, struct eh_region *c; enum reachable_code ret = RNL_NOT_CAUGHT; - for (c = region->u.try.catch; c ; c = c->u.catch.next_catch) + for (c = region->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch) { /* A catch-all handler ends the search. */ - if (c->u.catch.type_list == NULL) + if (c->u.eh_catch.type_list == NULL) { add_reachable_handler (info, region, c); return RNL_CAUGHT; @@ -2400,7 +2400,7 @@ reachable_next_level (struct eh_region *region, tree type_thrown, if (type_thrown) { /* If we have at least one type match, end the search. */ - tree tp_node = c->u.catch.type_list; + tree tp_node = c->u.eh_catch.type_list; for (; tp_node; tp_node = TREE_CHAIN (tp_node)) { @@ -2438,7 +2438,7 @@ reachable_next_level (struct eh_region *region, tree type_thrown, ret = RNL_MAYBE_CAUGHT; else { - tree tp_node = c->u.catch.type_list; + tree tp_node = c->u.eh_catch.type_list; bool maybe_reachable = false; /* Compute the potential reachability of this handler and @@ -2562,7 +2562,7 @@ foreach_reachable_handler (int region_number, bool is_resx, } else if (region->type == ERT_THROW) { - type_thrown = region->u.throw.type; + type_thrown = region->u.eh_throw.type; region = region->outer; } @@ -2645,7 +2645,7 @@ can_throw_internal_1 (int region_number, bool is_resx) region = region->outer; else if (region->type == ERT_THROW) { - type_thrown = region->u.throw.type; + type_thrown = region->u.eh_throw.type; region = region->outer; } @@ -2705,7 +2705,7 @@ can_throw_external_1 (int region_number, bool is_resx) region = region->outer; else if (region->type == ERT_THROW) { - type_thrown = region->u.throw.type; + type_thrown = region->u.eh_throw.type; region = region->outer; } @@ -3109,14 +3109,14 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region) search outer regions. Use a magic -3 value to record that we haven't done the outer search. */ next = -3; - for (c = region->u.try.last_catch; c ; c = c->u.catch.prev_catch) + for (c = region->u.eh_try.last_catch; c ; c = c->u.eh_catch.prev_catch) { - if (c->u.catch.type_list == NULL) + if (c->u.eh_catch.type_list == NULL) { /* Retrieve the filter from the head of the filter list where we have stored it (see assign_filter_values). */ int filter - = TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.filter_list)); + = TREE_INT_CST_LOW (TREE_VALUE (c->u.eh_catch.filter_list)); next = add_action_record (ar_hash, filter, 0); } @@ -3141,7 +3141,7 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region) next = add_action_record (ar_hash, 0, 0); } - flt_node = c->u.catch.filter_list; + flt_node = c->u.eh_catch.filter_list; for (; flt_node; flt_node = TREE_CHAIN (flt_node)) { int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node)); diff --git a/gcc/expr.c b/gcc/expr.c index eae8093d61e..7cc8783e0bc 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -1,6 +1,6 @@ /* Convert tree expression to rtl instructions, for GNU compiler. Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This file is part of GCC. @@ -2074,12 +2074,31 @@ emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize) } else { - gcc_assert (bytepos == 0 && XVECLEN (src, 0)); - dest = assign_stack_temp (GET_MODE (dest), - GET_MODE_SIZE (GET_MODE (dest)), 0); - emit_move_insn (adjust_address (dest, GET_MODE (tmps[i]), bytepos), - tmps[i]); - dst = dest; + enum machine_mode dest_mode = GET_MODE (dest); + enum machine_mode tmp_mode = GET_MODE (tmps[i]); + int dest_size = GET_MODE_SIZE (dest_mode); + int tmp_size = GET_MODE_SIZE (tmp_mode); + + gcc_assert (bytepos == 0 + && XVECLEN (src, 0) + && dest_size == tmp_size); + + if (GET_MODE_ALIGNMENT (dest_mode) + >= GET_MODE_ALIGNMENT (tmp_mode)) + { + dest = assign_stack_temp (dest_mode, dest_size, 0); + emit_move_insn (adjust_address (dest, + tmp_mode, + bytepos), + tmps[i]); + dst = dest; + } + else + { + dest = assign_stack_temp (tmp_mode, tmp_size, 0); + emit_move_insn (dest, tmps[i]); + dst = adjust_address (dest, dest_mode, bytepos); + } break; } } @@ -7944,20 +7963,20 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, if (mode == BLKmode) { HOST_WIDE_INT size = GET_MODE_BITSIZE (ext_mode); - rtx new; + rtx new_rtx; /* If the reference doesn't use the alias set of its type, we cannot create the temporary using that type. */ if (component_uses_parent_alias_set (exp)) { - new = assign_stack_local (ext_mode, size, 0); - set_mem_alias_set (new, get_alias_set (exp)); + new_rtx = assign_stack_local (ext_mode, size, 0); + set_mem_alias_set (new_rtx, get_alias_set (exp)); } else - new = assign_stack_temp_for_type (ext_mode, size, 0, type); + new_rtx = assign_stack_temp_for_type (ext_mode, size, 0, type); - emit_move_insn (new, op0); - op0 = copy_rtx (new); + emit_move_insn (new_rtx, op0); + op0 = copy_rtx (new_rtx); PUT_MODE (op0, BLKmode); set_mem_attributes (op0, exp, 1); } @@ -8198,9 +8217,9 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, HOST_WIDE_INT temp_size = MAX (int_size_in_bytes (inner_type), (HOST_WIDE_INT) GET_MODE_SIZE (TYPE_MODE (type))); - rtx new = assign_stack_temp_for_type (TYPE_MODE (type), - temp_size, 0, type); - rtx new_with_op0_mode = adjust_address (new, GET_MODE (op0), 0); + rtx new_rtx = assign_stack_temp_for_type (TYPE_MODE (type), + temp_size, 0, type); + rtx new_with_op0_mode = adjust_address (new_rtx, GET_MODE (op0), 0); gcc_assert (!TREE_ADDRESSABLE (exp)); @@ -8212,7 +8231,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, else emit_move_insn (new_with_op0_mode, op0); - op0 = new; + op0 = new_rtx; } op0 = adjust_address (op0, TYPE_MODE (type), 0); @@ -8970,7 +8989,10 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, /* If no set-flag instruction, must generate a conditional store into a temporary variable. Drop through and handle this like && and ||. */ - + /* Although TRUTH_{AND,OR}IF_EXPR aren't present in GIMPLE, they + are occassionally created by folding during expansion. */ + case TRUTH_ANDIF_EXPR: + case TRUTH_ORIF_EXPR: if (! ignore && (target == 0 || modifier == EXPAND_STACK_PARM @@ -9170,8 +9192,6 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, case POSTDECREMENT_EXPR: case LOOP_EXPR: case EXIT_EXPR: - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: /* Lowered by gimplify.c. */ gcc_unreachable (); @@ -9997,16 +10017,16 @@ try_tablejump (tree index_type, tree index_expr, tree minval, tree range, int vector_mode_valid_p (enum machine_mode mode) { - enum mode_class class = GET_MODE_CLASS (mode); + enum mode_class mclass = GET_MODE_CLASS (mode); enum machine_mode innermode; /* Doh! What's going on? */ - if (class != MODE_VECTOR_INT - && class != MODE_VECTOR_FLOAT - && class != MODE_VECTOR_FRACT - && class != MODE_VECTOR_UFRACT - && class != MODE_VECTOR_ACCUM - && class != MODE_VECTOR_UACCUM) + if (mclass != MODE_VECTOR_INT + && mclass != MODE_VECTOR_FLOAT + && mclass != MODE_VECTOR_FRACT + && mclass != MODE_VECTOR_UFRACT + && mclass != MODE_VECTOR_ACCUM + && mclass != MODE_VECTOR_UACCUM) return 0; /* Hardware support. Woo hoo! */ diff --git a/gcc/final.c b/gcc/final.c index 099942a37a0..d24d8fdb177 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -2007,11 +2007,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED, if (LABEL_NAME (insn)) (*debug_hooks->label) (insn); - if (app_on) - { - fputs (ASM_APP_OFF, file); - app_on = 0; - } + app_disable (); next = next_nonnote_insn (insn); if (next != 0 && JUMP_P (next)) @@ -2111,11 +2107,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED, else switch_to_section (current_function_section ()); - if (app_on) - { - fputs (ASM_APP_OFF, file); - app_on = 0; - } + app_disable (); #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC) if (GET_CODE (body) == ADDR_VEC) @@ -2189,11 +2181,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED, { expanded_location loc; - if (! app_on) - { - fputs (ASM_APP_ON, file); - app_on = 1; - } + app_enable (); loc = expand_location (ASM_INPUT_SOURCE_LOCATION (body)); if (*loc.file && loc.line) fprintf (asm_out_file, "%s %i \"%s\" 1\n", @@ -2233,11 +2221,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED, /* Output the insn using them. */ if (string[0]) { - if (! app_on) - { - fputs (ASM_APP_ON, file); - app_on = 1; - } + app_enable (); if (expanded.file && expanded.line) fprintf (asm_out_file, "%s %i \"%s\" 1\n", ASM_COMMENT_START, expanded.line, expanded.file); @@ -2252,11 +2236,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED, break; } - if (app_on) - { - fputs (ASM_APP_OFF, file); - app_on = 0; - } + app_disable (); if (GET_CODE (body) == SEQUENCE) { diff --git a/gcc/flags.h b/gcc/flags.h index e797d95c885..cfd278f747e 100644 --- a/gcc/flags.h +++ b/gcc/flags.h @@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see #include "coretypes.h" #include "options.h" +#include "real.h" enum debug_info_type { @@ -115,12 +116,6 @@ extern int optimize_size; extern bool extra_warnings; -/* Nonzero to warn about unused variables, functions et.al. Use - set_Wunused() to update the -Wunused-* flags that correspond to the - -Wunused option. */ - -extern void set_Wunused (int setting); - /* Used to set the level of -Wstrict-aliasing, when no level is specified. The external way to set the default level is to use -Wstrict-aliasing=level. diff --git a/gcc/fold-const.c b/gcc/fold-const.c index f8085dc3709..eac31ef1a79 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -1885,8 +1885,7 @@ const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc) flag_rounding_math is set, or if GCC's software emulation is unable to accurately represent the result. */ if ((flag_rounding_math - || (REAL_MODE_FORMAT_COMPOSITE_P (mode) - && !flag_unsafe_math_optimizations)) + || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations)) && (inexact || !real_identical (&result, &value))) return NULL_TREE; @@ -3391,17 +3390,17 @@ static int twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p) { enum tree_code code = TREE_CODE (arg); - enum tree_code_class class = TREE_CODE_CLASS (code); + enum tree_code_class tclass = TREE_CODE_CLASS (code); /* We can handle some of the tcc_expression cases here. */ - if (class == tcc_expression && code == TRUTH_NOT_EXPR) - class = tcc_unary; - else if (class == tcc_expression + if (tclass == tcc_expression && code == TRUTH_NOT_EXPR) + tclass = tcc_unary; + else if (tclass == tcc_expression && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR || code == COMPOUND_EXPR)) - class = tcc_binary; + tclass = tcc_binary; - else if (class == tcc_expression && code == SAVE_EXPR + else if (tclass == tcc_expression && code == SAVE_EXPR && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0))) { /* If we've already found a CVAL1 or CVAL2, this expression is @@ -3409,11 +3408,11 @@ twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p) if (*cval1 || *cval2) return 0; - class = tcc_unary; + tclass = tcc_unary; *save_p = 1; } - switch (class) + switch (tclass) { case tcc_unary: return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p); @@ -3484,16 +3483,16 @@ eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1) { tree type = TREE_TYPE (arg); enum tree_code code = TREE_CODE (arg); - enum tree_code_class class = TREE_CODE_CLASS (code); + enum tree_code_class tclass = TREE_CODE_CLASS (code); /* We can handle some of the tcc_expression cases here. */ - if (class == tcc_expression && code == TRUTH_NOT_EXPR) - class = tcc_unary; - else if (class == tcc_expression + if (tclass == tcc_expression && code == TRUTH_NOT_EXPR) + tclass = tcc_unary; + else if (tclass == tcc_expression && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)) - class = tcc_binary; + tclass = tcc_binary; - switch (class) + switch (tclass) { case tcc_unary: return fold_build1 (code, type, @@ -6734,10 +6733,8 @@ fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1) if ((code == EQ_EXPR || code == NE_EXPR || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type)) && (TREE_TYPE (arg1_unw) == shorter_type - || (TYPE_PRECISION (shorter_type) - > TYPE_PRECISION (TREE_TYPE (arg1_unw))) || ((TYPE_PRECISION (shorter_type) - == TYPE_PRECISION (TREE_TYPE (arg1_unw))) + >= TYPE_PRECISION (TREE_TYPE (arg1_unw))) && (TYPE_UNSIGNED (shorter_type) == TYPE_UNSIGNED (TREE_TYPE (arg1_unw)))) || (TREE_CODE (arg1_unw) == INTEGER_CST diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 38a653aad68..3bdfb527f6b 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,39 @@ +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 36901 + * f95-lang.c (gfc_mark_addressable): Use "pedwarn (0," instead of + 'pedwarn0'. + +2008-08-09 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/37011 + * symbol.c (gfc_add_extension): New function. + * decl.c (gfc_get_type_attr_spec): Call it. + (gfc_match_derived_decl): Set symbol extension attribute from + attr.extension. + * gfortran.h : Add prototype for gfc_add_extension. + +2008-08-08 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 28875 + * options.c (set_Wall): Replace set_Wunused by warn_unused. + +2008-08-08 Daniel Kraft <d@domob.eu> + + * gfortran.h (gfc_finalizer): Replaced member `procedure' by two + new members `proc_sym' and `proc_tree' to store the symtree after + resolution. + (gfc_find_sym_in_symtree): Made public. + * decl.c (gfc_match_final_decl): Adapted for new member name. + * interface.c (gfc_find_sym_in_symtree): Made public. + (gfc_extend_expr), (gfc_extend_assign): Changed call accordingly. + * module.c (mio_finalizer), (mio_f2k_derived), (mio_full_f2k_derived): + New methods for module-file IO of f2k_derived. + (mio_symbol): Do IO of f2k_derived namespace. + * resolve.c (gfc_resolve_finalizers): Adapted for new member name and + finding the symtree for the symbol here. + * symbol.c (gfc_free_finalizer): Adapted for new members. + 2008-07-30 Ralf Wildenhues <Ralf.Wildenhues@gmx.de> * gfc-internals.texi: Update to GFDL 1.2. Do not list GPL as diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c index 8b9b8c0e868..12497808a4e 100644 --- a/gcc/fortran/decl.c +++ b/gcc/fortran/decl.c @@ -6340,8 +6340,7 @@ gfc_get_type_attr_spec (symbol_attribute *attr, char *name) } else if (name && gfc_match(" , extends ( %n )", name) == MATCH_YES) { - if (gfc_notify_std (GFC_STD_F2003, "Fortran 2003: derived type " - "extended at %C") == FAILURE) + if (gfc_add_extension (attr, &gfc_current_locus) == FAILURE) return MATCH_ERROR; } else @@ -6385,7 +6384,9 @@ gfc_match_derived_decl (void) seen_attr = true; } while (is_type_attr_spec == MATCH_YES); - /* Deal with derived type extensions. */ + /* Deal with derived type extensions. The extension attribute has + been added to 'attr' but now the parent type must be found and + checked. */ if (parent[0]) extended = check_extended_derived_type (parent); @@ -6457,7 +6458,7 @@ gfc_match_derived_decl (void) /* Add the extended derived type as the first component. */ gfc_add_component (sym, parent, &p); - sym->attr.extension = 1; + sym->attr.extension = attr.extension; extended->refs++; gfc_set_sym_referenced (extended); @@ -6682,6 +6683,7 @@ cleanup: } + /* Match a FINAL declaration inside a derived type. */ match @@ -6762,7 +6764,7 @@ gfc_match_final_decl (void) /* Check if we already have this symbol in the list, this is an error. */ for (f = gfc_current_block ()->f2k_derived->finalizers; f; f = f->next) - if (f->procedure == sym) + if (f->proc_sym == sym) { gfc_error ("'%s' at %C is already defined as FINAL procedure!", name); @@ -6773,7 +6775,8 @@ gfc_match_final_decl (void) gcc_assert (gfc_current_block ()->f2k_derived); ++sym->refs; f = XCNEW (gfc_finalizer); - f->procedure = sym; + f->proc_sym = sym; + f->proc_tree = NULL; f->where = gfc_current_locus; f->next = gfc_current_block ()->f2k_derived->finalizers; gfc_current_block ()->f2k_derived->finalizers = f; diff --git a/gcc/fortran/f95-lang.c b/gcc/fortran/f95-lang.c index d2768b112dd..5f39593efd8 100644 --- a/gcc/fortran/f95-lang.c +++ b/gcc/fortran/f95-lang.c @@ -604,8 +604,8 @@ gfc_mark_addressable (tree exp) IDENTIFIER_POINTER (DECL_NAME (x))); return false; } - pedwarn0 ("register variable %qs used in nested function", - IDENTIFIER_POINTER (DECL_NAME (x))); + pedwarn (0, "register variable %qs used in nested function", + IDENTIFIER_POINTER (DECL_NAME (x))); } else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)) { @@ -629,7 +629,7 @@ gfc_mark_addressable (tree exp) } #endif - pedwarn0 ("address of register variable %qs requested", + pedwarn (0, "address of register variable %qs requested", IDENTIFIER_POINTER (DECL_NAME (x))); } diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 51192481326..ccd2c0305ca 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -1958,10 +1958,20 @@ extern iterator_stack *iter_stack; typedef struct gfc_finalizer { struct gfc_finalizer* next; - gfc_symbol* procedure; locus where; /* Where the FINAL declaration occurred. */ + + /* Up to resolution, we want the gfc_symbol, there we lookup the corresponding + symtree and later need only that. This way, we can access and call the + finalizers from every context as they should be "always accessible". I + don't make this a union because we need the information whether proc_sym is + still referenced or not for dereferencing it on deleting a gfc_finalizer + structure. */ + gfc_symbol* proc_sym; + gfc_symtree* proc_tree; } gfc_finalizer; +#define gfc_get_finalizer() XCNEW (gfc_finalizer) + /************************ Function prototypes *************************/ @@ -2160,7 +2170,8 @@ gfc_try gfc_add_volatile (symbol_attribute *, const char *, locus *); gfc_try gfc_add_proc (symbol_attribute *attr, const char *name, locus *where); gfc_try gfc_add_access (symbol_attribute *, gfc_access, const char *, locus *); -gfc_try gfc_add_is_bind_c(symbol_attribute *, const char *, locus *, int); +gfc_try gfc_add_is_bind_c (symbol_attribute *, const char *, locus *, int); +gfc_try gfc_add_extension (symbol_attribute *, locus *); gfc_try gfc_add_value (symbol_attribute *, const char *, locus *); gfc_try gfc_add_flavor (symbol_attribute *, sym_flavor, const char *, locus *); gfc_try gfc_add_entry (symbol_attribute *, const char *, locus *); @@ -2399,6 +2410,7 @@ gfc_try gfc_extend_assign (gfc_code *, gfc_namespace *); gfc_try gfc_add_interface (gfc_symbol *); gfc_interface *gfc_current_interface_head (void); void gfc_set_current_interface_head (gfc_interface *); +gfc_symtree* gfc_find_sym_in_symtree (gfc_symbol*); /* io.c */ extern gfc_st_label format_asterisk; diff --git a/gcc/fortran/interface.c b/gcc/fortran/interface.c index 84fa660dfaf..ba384013032 100644 --- a/gcc/fortran/interface.c +++ b/gcc/fortran/interface.c @@ -2513,8 +2513,8 @@ find_symtree0 (gfc_symtree *root, gfc_symbol *sym) /* Find a symtree for a symbol. */ -static gfc_symtree * -find_sym_in_symtree (gfc_symbol *sym) +gfc_symtree * +gfc_find_sym_in_symtree (gfc_symbol *sym) { gfc_symtree *st; gfc_namespace *ns; @@ -2652,7 +2652,7 @@ gfc_extend_expr (gfc_expr *e) /* Change the expression node to a function call. */ e->expr_type = EXPR_FUNCTION; - e->symtree = find_sym_in_symtree (sym); + e->symtree = gfc_find_sym_in_symtree (sym); e->value.function.actual = actual; e->value.function.esym = NULL; e->value.function.isym = NULL; @@ -2718,7 +2718,7 @@ gfc_extend_assign (gfc_code *c, gfc_namespace *ns) /* Replace the assignment with the call. */ c->op = EXEC_ASSIGN_CALL; - c->symtree = find_sym_in_symtree (sym); + c->symtree = gfc_find_sym_in_symtree (sym); c->expr = NULL; c->expr2 = NULL; c->ext.actual = actual; diff --git a/gcc/fortran/module.c b/gcc/fortran/module.c index ed575f9574f..7da5be16b56 100644 --- a/gcc/fortran/module.c +++ b/gcc/fortran/module.c @@ -3168,6 +3168,78 @@ mio_namespace_ref (gfc_namespace **nsp) } +/* Save/restore the f2k_derived namespace of a derived-type symbol. */ + +static void +mio_finalizer (gfc_finalizer **f) +{ + if (iomode == IO_OUTPUT) + { + gcc_assert (*f); + gcc_assert ((*f)->proc_tree); /* Should already be resolved. */ + mio_symtree_ref (&(*f)->proc_tree); + } + else + { + *f = gfc_get_finalizer (); + (*f)->where = gfc_current_locus; /* Value should not matter. */ + (*f)->next = NULL; + + mio_symtree_ref (&(*f)->proc_tree); + (*f)->proc_sym = NULL; + } +} + +static void +mio_f2k_derived (gfc_namespace *f2k) +{ + /* Handle the list of finalizer procedures. */ + mio_lparen (); + if (iomode == IO_OUTPUT) + { + gfc_finalizer *f; + for (f = f2k->finalizers; f; f = f->next) + mio_finalizer (&f); + } + else + { + f2k->finalizers = NULL; + while (peek_atom () != ATOM_RPAREN) + { + gfc_finalizer *cur; + mio_finalizer (&cur); + cur->next = f2k->finalizers; + f2k->finalizers = cur; + } + } + mio_rparen (); +} + +static void +mio_full_f2k_derived (gfc_symbol *sym) +{ + mio_lparen (); + + if (iomode == IO_OUTPUT) + { + if (sym->f2k_derived) + mio_f2k_derived (sym->f2k_derived); + } + else + { + if (peek_atom () != ATOM_RPAREN) + { + sym->f2k_derived = gfc_get_namespace (NULL, 0); + mio_f2k_derived (sym->f2k_derived); + } + else + gcc_assert (!sym->f2k_derived); + } + + mio_rparen (); +} + + /* Unlike most other routines, the address of the symbol node is already fixed on input and the name/module has already been filled in. */ @@ -3230,6 +3302,9 @@ mio_symbol (gfc_symbol *sym) sym->component_access = MIO_NAME (gfc_access) (sym->component_access, access_types); + /* Load/save the f2k_derived namespace of a derived-type symbol. */ + mio_full_f2k_derived (sym); + mio_namelist (sym); /* Add the fields that say whether this is from an intrinsic module, diff --git a/gcc/fortran/options.c b/gcc/fortran/options.c index 7b7916d4603..4ecb8f998e3 100644 --- a/gcc/fortran/options.c +++ b/gcc/fortran/options.c @@ -376,7 +376,7 @@ set_Wall (int setting) gfc_option.warn_intrinsics_std = setting; gfc_option.warn_character_truncation = setting; - set_Wunused (setting); + warn_unused = setting; warn_return_type = setting; warn_switch = setting; diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c index f977de56ce2..c6a241a8545 100644 --- a/gcc/fortran/resolve.c +++ b/gcc/fortran/resolve.c @@ -7472,22 +7472,29 @@ gfc_resolve_finalizers (gfc_symbol* derived) gfc_finalizer* i; int my_rank; + /* Skip this finalizer if we already resolved it. */ + if (list->proc_tree) + { + prev_link = &(list->next); + continue; + } + /* Check this exists and is a SUBROUTINE. */ - if (!list->procedure->attr.subroutine) + if (!list->proc_sym->attr.subroutine) { gfc_error ("FINAL procedure '%s' at %L is not a SUBROUTINE", - list->procedure->name, &list->where); + list->proc_sym->name, &list->where); goto error; } /* We should have exactly one argument. */ - if (!list->procedure->formal || list->procedure->formal->next) + if (!list->proc_sym->formal || list->proc_sym->formal->next) { gfc_error ("FINAL procedure at %L must have exactly one argument", &list->where); goto error; } - arg = list->procedure->formal->sym; + arg = list->proc_sym->formal->sym; /* This argument must be of our type. */ if (arg->ts.type != BT_DERIVED || arg->ts.derived != derived) @@ -7541,16 +7548,16 @@ gfc_resolve_finalizers (gfc_symbol* derived) { /* Argument list might be empty; that is an error signalled earlier, but we nevertheless continued resolving. */ - if (i->procedure->formal) + if (i->proc_sym->formal) { - gfc_symbol* i_arg = i->procedure->formal->sym; + gfc_symbol* i_arg = i->proc_sym->formal->sym; const int i_rank = (i_arg->as ? i_arg->as->rank : 0); if (i_rank == my_rank) { gfc_error ("FINAL procedure '%s' declared at %L has the same" " rank (%d) as '%s'", - list->procedure->name, &list->where, my_rank, - i->procedure->name); + list->proc_sym->name, &list->where, my_rank, + i->proc_sym->name); goto error; } } @@ -7560,6 +7567,10 @@ gfc_resolve_finalizers (gfc_symbol* derived) if (!arg->as || arg->as->rank == 0) seen_scalar = true; + /* Find the symtree for this procedure. */ + gcc_assert (!list->proc_tree); + list->proc_tree = gfc_find_sym_in_symtree (list->proc_sym); + prev_link = &list->next; continue; @@ -7581,7 +7592,8 @@ error: derived->name, &derived->declared_at); /* TODO: Remove this error when finalization is finished. */ - gfc_error ("Finalization at %L is not yet implemented", &derived->declared_at); + gfc_error ("Finalization at %L is not yet implemented", + &derived->declared_at); return result; } diff --git a/gcc/fortran/symbol.c b/gcc/fortran/symbol.c index d4cbd0b6684..6b64bcf4353 100644 --- a/gcc/fortran/symbol.c +++ b/gcc/fortran/symbol.c @@ -1468,6 +1468,27 @@ gfc_add_is_bind_c (symbol_attribute *attr, const char *name, locus *where, } +/* Set the extension field for the given symbol_attribute. */ + +gfc_try +gfc_add_extension (symbol_attribute *attr, locus *where) +{ + if (where == NULL) + where = &gfc_current_locus; + + if (attr->extension) + gfc_error_now ("Duplicate EXTENDS attribute specified at %L", where); + else + attr->extension = 1; + + if (gfc_notify_std (GFC_STD_F2003, "Fortran 2003: EXTENDS at %L", where) + == FAILURE) + return FAILURE; + + return SUCCESS; +} + + gfc_try gfc_add_explicit_interface (gfc_symbol *sym, ifsrc source, gfc_formal_arglist * formal, locus *where) @@ -2965,9 +2986,12 @@ gfc_free_finalizer (gfc_finalizer* el) { if (el) { - --el->procedure->refs; - if (!el->procedure->refs) - gfc_free_symbol (el->procedure); + if (el->proc_sym) + { + --el->proc_sym->refs; + if (!el->proc_sym->refs) + gfc_free_symbol (el->proc_sym); + } gfc_free (el); } diff --git a/gcc/function.c b/gcc/function.c index 637775160eb..98b8da07365 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -932,59 +932,60 @@ find_temp_slot_from_address (rtx x) return 0; } -/* Indicate that NEW is an alternate way of referring to the temp slot - that previously was known by OLD. */ +/* Indicate that NEW_RTX is an alternate way of referring to the temp + slot that previously was known by OLD_RTX. */ void -update_temp_slot_address (rtx old, rtx new) +update_temp_slot_address (rtx old_rtx, rtx new_rtx) { struct temp_slot *p; - if (rtx_equal_p (old, new)) + if (rtx_equal_p (old_rtx, new_rtx)) return; - p = find_temp_slot_from_address (old); + p = find_temp_slot_from_address (old_rtx); - /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW - is a register, see if one operand of the PLUS is a temporary - location. If so, NEW points into it. Otherwise, if both OLD and - NEW are a PLUS and if there is a register in common between them. - If so, try a recursive call on those values. */ + /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and + NEW_RTX is a register, see if one operand of the PLUS is a + temporary location. If so, NEW_RTX points into it. Otherwise, + if both OLD_RTX and NEW_RTX are a PLUS and if there is a register + in common between them. If so, try a recursive call on those + values. */ if (p == 0) { - if (GET_CODE (old) != PLUS) + if (GET_CODE (old_rtx) != PLUS) return; - if (REG_P (new)) + if (REG_P (new_rtx)) { - update_temp_slot_address (XEXP (old, 0), new); - update_temp_slot_address (XEXP (old, 1), new); + update_temp_slot_address (XEXP (old_rtx, 0), new_rtx); + update_temp_slot_address (XEXP (old_rtx, 1), new_rtx); return; } - else if (GET_CODE (new) != PLUS) + else if (GET_CODE (new_rtx) != PLUS) return; - if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0))) - update_temp_slot_address (XEXP (old, 1), XEXP (new, 1)); - else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0))) - update_temp_slot_address (XEXP (old, 0), XEXP (new, 1)); - else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1))) - update_temp_slot_address (XEXP (old, 1), XEXP (new, 0)); - else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1))) - update_temp_slot_address (XEXP (old, 0), XEXP (new, 0)); + if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0))) + update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1)); + else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0))) + update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1)); + else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1))) + update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0)); + else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1))) + update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0)); return; } /* Otherwise add an alias for the temp's address. */ else if (p->address == 0) - p->address = new; + p->address = new_rtx; else { if (GET_CODE (p->address) != EXPR_LIST) p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX); - p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address); + p->address = gen_rtx_EXPR_LIST (VOIDmode, new_rtx, p->address); } } @@ -1210,7 +1211,7 @@ static int cfa_offset; static rtx instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) { - rtx new; + rtx new_rtx; HOST_WIDE_INT offset; if (x == virtual_incoming_args_rtx) @@ -1219,24 +1220,24 @@ instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) { /* Replace virtual_incoming_args_rtx with internal arg pointer if DRAP is used to realign stack. */ - new = crtl->args.internal_arg_pointer; + new_rtx = crtl->args.internal_arg_pointer; offset = 0; } else - new = arg_pointer_rtx, offset = in_arg_offset; + new_rtx = arg_pointer_rtx, offset = in_arg_offset; } else if (x == virtual_stack_vars_rtx) - new = frame_pointer_rtx, offset = var_offset; + new_rtx = frame_pointer_rtx, offset = var_offset; else if (x == virtual_stack_dynamic_rtx) - new = stack_pointer_rtx, offset = dynamic_offset; + new_rtx = stack_pointer_rtx, offset = dynamic_offset; else if (x == virtual_outgoing_args_rtx) - new = stack_pointer_rtx, offset = out_arg_offset; + new_rtx = stack_pointer_rtx, offset = out_arg_offset; else if (x == virtual_cfa_rtx) { #ifdef FRAME_POINTER_CFA_OFFSET - new = frame_pointer_rtx; + new_rtx = frame_pointer_rtx; #else - new = arg_pointer_rtx; + new_rtx = arg_pointer_rtx; #endif offset = cfa_offset; } @@ -1244,7 +1245,7 @@ instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) return NULL_RTX; *poffset = offset; - return new; + return new_rtx; } /* A subroutine of instantiate_virtual_regs, called via for_each_rtx. @@ -1258,7 +1259,7 @@ instantiate_virtual_regs_in_rtx (rtx *loc, void *data) { HOST_WIDE_INT offset; bool *changed = (bool *) data; - rtx x, new; + rtx x, new_rtx; x = *loc; if (x == 0) @@ -1267,21 +1268,21 @@ instantiate_virtual_regs_in_rtx (rtx *loc, void *data) switch (GET_CODE (x)) { case REG: - new = instantiate_new_reg (x, &offset); - if (new) + new_rtx = instantiate_new_reg (x, &offset); + if (new_rtx) { - *loc = plus_constant (new, offset); + *loc = plus_constant (new_rtx, offset); if (changed) *changed = true; } return -1; case PLUS: - new = instantiate_new_reg (XEXP (x, 0), &offset); - if (new) + new_rtx = instantiate_new_reg (XEXP (x, 0), &offset); + if (new_rtx) { - new = plus_constant (new, offset); - *loc = simplify_gen_binary (PLUS, GET_MODE (x), new, XEXP (x, 1)); + new_rtx = plus_constant (new_rtx, offset); + *loc = simplify_gen_binary (PLUS, GET_MODE (x), new_rtx, XEXP (x, 1)); if (changed) *changed = true; return -1; @@ -1327,7 +1328,7 @@ instantiate_virtual_regs_in_insn (rtx insn) HOST_WIDE_INT offset; int insn_code, i; bool any_change = false; - rtx set, new, x, seq; + rtx set, new_rtx, x, seq; /* There are some special cases to be handled first. */ set = single_set (insn); @@ -1337,17 +1338,17 @@ instantiate_virtual_regs_in_insn (rtx insn) to mean that the underlying register gets assigned the inverse transformation. This is used, for example, in the handling of non-local gotos. */ - new = instantiate_new_reg (SET_DEST (set), &offset); - if (new) + new_rtx = instantiate_new_reg (SET_DEST (set), &offset); + if (new_rtx) { start_sequence (); for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL); - x = simplify_gen_binary (PLUS, GET_MODE (new), SET_SRC (set), + x = simplify_gen_binary (PLUS, GET_MODE (new_rtx), SET_SRC (set), GEN_INT (-offset)); - x = force_operand (x, new); - if (x != new) - emit_move_insn (new, x); + x = force_operand (x, new_rtx); + if (x != new_rtx) + emit_move_insn (new_rtx, x); seq = get_insns (); end_sequence (); @@ -1361,15 +1362,15 @@ instantiate_virtual_regs_in_insn (rtx insn) new add insn. The difference between this and falling through to the generic case is avoiding a new pseudo and eliminating a move insn in the initial rtl stream. */ - new = instantiate_new_reg (SET_SRC (set), &offset); - if (new && offset != 0 + new_rtx = instantiate_new_reg (SET_SRC (set), &offset); + if (new_rtx && offset != 0 && REG_P (SET_DEST (set)) && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) { start_sequence (); x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, - new, GEN_INT (offset), SET_DEST (set), + new_rtx, GEN_INT (offset), SET_DEST (set), 1, OPTAB_LIB_WIDEN); if (x != SET_DEST (set)) emit_move_insn (SET_DEST (set), x); @@ -1392,7 +1393,7 @@ instantiate_virtual_regs_in_insn (rtx insn) && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0) && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1) && GET_CODE (recog_data.operand[2]) == CONST_INT - && (new = instantiate_new_reg (recog_data.operand[1], &offset))) + && (new_rtx = instantiate_new_reg (recog_data.operand[1], &offset))) { offset += INTVAL (recog_data.operand[2]); @@ -1402,7 +1403,7 @@ instantiate_virtual_regs_in_insn (rtx insn) && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) { start_sequence (); - emit_move_insn (SET_DEST (set), new); + emit_move_insn (SET_DEST (set), new_rtx); seq = get_insns (); end_sequence (); @@ -1416,10 +1417,10 @@ instantiate_virtual_regs_in_insn (rtx insn) /* Using validate_change and apply_change_group here leaves recog_data in an invalid state. Since we know exactly what we want to check, do those two by hand. */ - if (safe_insn_predicate (insn_code, 1, new) + if (safe_insn_predicate (insn_code, 1, new_rtx) && safe_insn_predicate (insn_code, 2, x)) { - *recog_data.operand_loc[1] = recog_data.operand[1] = new; + *recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx; *recog_data.operand_loc[2] = recog_data.operand[2] = x; any_change = true; @@ -1474,11 +1475,11 @@ instantiate_virtual_regs_in_insn (rtx insn) break; case REG: - new = instantiate_new_reg (x, &offset); - if (new == NULL) + new_rtx = instantiate_new_reg (x, &offset); + if (new_rtx == NULL) continue; if (offset == 0) - x = new; + x = new_rtx; else { start_sequence (); @@ -1489,7 +1490,7 @@ instantiate_virtual_regs_in_insn (rtx insn) /* ??? Recognize address_operand and/or "p" constraints to see if (plus new offset) is a valid before we put this through expand_simple_binop. */ - x = expand_simple_binop (GET_MODE (x), PLUS, new, + x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx, GEN_INT (offset), NULL_RTX, 1, OPTAB_LIB_WIDEN); seq = get_insns (); @@ -1499,21 +1500,21 @@ instantiate_virtual_regs_in_insn (rtx insn) break; case SUBREG: - new = instantiate_new_reg (SUBREG_REG (x), &offset); - if (new == NULL) + new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset); + if (new_rtx == NULL) continue; if (offset != 0) { start_sequence (); - new = expand_simple_binop (GET_MODE (new), PLUS, new, + new_rtx = expand_simple_binop (GET_MODE (new_rtx), PLUS, new_rtx, GEN_INT (offset), NULL_RTX, 1, OPTAB_LIB_WIDEN); seq = get_insns (); end_sequence (); emit_insn_before (seq, insn); } - x = simplify_gen_subreg (recog_data.operand_mode[i], new, - GET_MODE (new), SUBREG_BYTE (x)); + x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx, + GET_MODE (new_rtx), SUBREG_BYTE (x)); break; default: @@ -2261,6 +2262,11 @@ assign_parm_find_entry_rtl (struct assign_parm_data_all *all, entry_parm ? data->partial : 0, current_function_decl, &all->stack_args_size, &data->locate); + /* Update parm_stack_boundary if this parameter is passed in the + stack. */ + if (!in_regs && crtl->parm_stack_boundary < data->locate.boundary) + crtl->parm_stack_boundary = data->locate.boundary; + /* Adjust offsets to include the pretend args. */ pretend_bytes = all->extra_pretend_bytes - pretend_bytes; data->locate.slot_offset.constant += pretend_bytes; @@ -4834,6 +4840,7 @@ thread_prologue_and_epilogue_insns (void) #endif edge_iterator ei; + rtl_profile_for_bb (ENTRY_BLOCK_PTR); #ifdef HAVE_prologue if (HAVE_prologue) { @@ -4880,6 +4887,7 @@ thread_prologue_and_epilogue_insns (void) if (e == NULL) goto epilogue_done; + rtl_profile_for_bb (EXIT_BLOCK_PTR); #ifdef HAVE_return if (optimize && HAVE_return) { @@ -5029,6 +5037,7 @@ thread_prologue_and_epilogue_insns (void) cfg_layout_finalize (); } epilogue_done: + default_rtl_profile (); if (inserted) { diff --git a/gcc/function.h b/gcc/function.h index 1153fb0b4c4..eb85e3c37af 100644 --- a/gcc/function.h +++ b/gcc/function.h @@ -339,6 +339,9 @@ struct rtl_data GTY(()) to call other functions. */ unsigned int preferred_stack_boundary; + /* The minimum alignment of parameter stack. */ + unsigned int parm_stack_boundary; + /* The largest alignment of slot allocated on the stack. */ unsigned int max_used_stack_slot_alignment; diff --git a/gcc/gcc.c b/gcc/gcc.c index 7914e4b6f35..75dc67d0e8e 100644 --- a/gcc/gcc.c +++ b/gcc/gcc.c @@ -819,7 +819,7 @@ static const char *cpp_unique_options = in turn cause preprocessor symbols to be defined specially. */ static const char *cpp_options = "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\ - %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\ + %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\ %{undef} %{save-temps:-fpch-preprocess}"; /* This contains cpp options which are not passed when the preprocessor @@ -8044,7 +8044,7 @@ include_spec_function (int argc, const char **argv) if (argc != 1) abort (); - file = find_a_file (&startfile_prefixes, argv[0], R_OK, 0); + file = find_a_file (&startfile_prefixes, argv[0], R_OK, true); read_specs (file ? file : argv[0], FALSE); return NULL; diff --git a/gcc/gengtype.c b/gcc/gengtype.c index b65af7ed1f9..2fe6fa5b67e 100644 --- a/gcc/gengtype.c +++ b/gcc/gengtype.c @@ -314,6 +314,10 @@ read_input_line (FILE *list, char **herep, char **linep, char *line; int c = getc (list); + /* Read over whitespace. */ + while (c == '\n' || c == ' ') + c = getc (list); + if (c == EOF) { *linep = 0; diff --git a/gcc/gimple.c b/gcc/gimple.c index 69cfd4e1db8..6e8971f4ec1 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -285,6 +285,8 @@ static inline gimple gimple_build_call_1 (tree fn, unsigned nargs) { gimple s = gimple_build_with_ops (GIMPLE_CALL, 0, nargs + 3); + if (TREE_CODE (fn) == FUNCTION_DECL) + fn = build_fold_addr_expr (fn); gimple_set_op (s, 1, fn); return s; } @@ -370,22 +372,22 @@ void extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p, tree *op2_p) { - enum gimple_rhs_class class; + enum gimple_rhs_class grhs_class; *subcode_p = TREE_CODE (expr); - class = get_gimple_rhs_class (*subcode_p); + grhs_class = get_gimple_rhs_class (*subcode_p); - if (class == GIMPLE_BINARY_RHS) + if (grhs_class == GIMPLE_BINARY_RHS) { *op1_p = TREE_OPERAND (expr, 0); *op2_p = TREE_OPERAND (expr, 1); } - else if (class == GIMPLE_UNARY_RHS) + else if (grhs_class == GIMPLE_UNARY_RHS) { *op1_p = TREE_OPERAND (expr, 0); *op2_p = NULL_TREE; } - else if (class == GIMPLE_SINGLE_RHS) + else if (grhs_class == GIMPLE_SINGLE_RHS) { *op1_p = expr; *op2_p = NULL_TREE; @@ -1276,16 +1278,16 @@ gimple_seq gimple_seq_copy (gimple_seq src) { gimple_stmt_iterator gsi; - gimple_seq new = gimple_seq_alloc (); + gimple_seq new_seq = gimple_seq_alloc (); gimple stmt; for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi)) { stmt = gimple_copy (gsi_stmt (gsi)); - gimple_seq_add_stmt (&new, stmt); + gimple_seq_add_stmt (&new_seq, stmt); } - return new; + return new_seq; } diff --git a/gcc/gimple.h b/gcc/gimple.h index 0c11f3ebfa7..2f6af03117e 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -1834,6 +1834,17 @@ gimple_assign_set_rhs_code (gimple s, enum tree_code code) } +/* Return the gimple rhs class of the code of the expression computed on + the rhs of assignment statement GS. + This will never return GIMPLE_INVALID_RHS. */ + +static inline enum gimple_rhs_class +gimple_assign_rhs_class (const_gimple gs) +{ + return get_gimple_rhs_class (gimple_assign_rhs_code (gs)); +} + + /* Return true if S is a type-cast assignment. */ static inline bool @@ -1894,7 +1905,7 @@ gimple_call_set_lhs (gimple gs, tree lhs) /* Return the tree node representing the function called by call - statement GS. This may or may not be a FUNCTION_DECL node. */ + statement GS. */ static inline tree gimple_call_fn (const_gimple gs) @@ -1926,6 +1937,17 @@ gimple_call_set_fn (gimple gs, tree fn) } +/* Set FNDECL to be the function called by call statement GS. */ + +static inline void +gimple_call_set_fndecl (gimple gs, tree decl) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); + gimple_set_op (gs, 1, build_fold_addr_expr (decl)); +} + + /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. Otherwise return NULL. This function is analogous to get_callee_fndecl in tree land. */ @@ -1933,8 +1955,13 @@ gimple_call_set_fn (gimple gs, tree fn) static inline tree gimple_call_fndecl (const_gimple gs) { - tree decl = gimple_call_fn (gs); - return (TREE_CODE (decl) == FUNCTION_DECL) ? decl : NULL_TREE; + tree addr = gimple_call_fn (gs); + if (TREE_CODE (addr) == ADDR_EXPR) + { + gcc_assert (TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL); + return TREE_OPERAND (addr, 0); + } + return NULL_TREE; } @@ -1946,9 +1973,9 @@ gimple_call_return_type (const_gimple gs) tree fn = gimple_call_fn (gs); tree type = TREE_TYPE (fn); - /* See through pointers. */ - if (POINTER_TYPE_P (type)) - type = TREE_TYPE (type); + /* See through the pointer. */ + gcc_assert (POINTER_TYPE_P (type)); + type = TREE_TYPE (type); gcc_assert (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE); @@ -1986,7 +2013,7 @@ gimple_call_set_chain (gimple gs, tree chain) GIMPLE_CHECK (gs, GIMPLE_CALL); gcc_assert (chain == NULL || TREE_CODE (chain) == ADDR_EXPR - || DECL_P (chain)); + || SSA_VAR_P (chain)); gimple_set_op (gs, 2, chain); } diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 555a5b64c7e..43c8df991fc 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -1842,17 +1842,13 @@ gimplify_conversion (tree *expr_p) /* Attempt to avoid NOP_EXPR by producing reference to a subtype. For example this fold (subclass *)&A into &A->subclass avoiding a need for statement. */ - if (TREE_CODE (*expr_p) == NOP_EXPR + if (CONVERT_EXPR_P (*expr_p) && POINTER_TYPE_P (TREE_TYPE (*expr_p)) && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0))) - && (tem = maybe_fold_offset_to_reference + && (tem = maybe_fold_offset_to_address (TREE_OPERAND (*expr_p, 0), - integer_zero_node, TREE_TYPE (TREE_TYPE (*expr_p))))) - { - tree ptr_type = build_pointer_type (TREE_TYPE (tem)); - if (useless_type_conversion_p (TREE_TYPE (*expr_p), ptr_type)) - *expr_p = build_fold_addr_expr_with_type (tem, ptr_type); - } + integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE) + *expr_p = tem; /* If we still have a conversion at the toplevel, then canonicalize some constructs. */ @@ -2294,14 +2290,14 @@ gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value) fndecl = get_callee_fndecl (*expr_p); if (fndecl && DECL_BUILT_IN (fndecl)) { - tree new = fold_call_expr (*expr_p, !want_value); + tree new_tree = fold_call_expr (*expr_p, !want_value); - if (new && new != *expr_p) + if (new_tree && new_tree != *expr_p) { /* There was a transformation of this call which computes the same value, but in a more efficient way. Return and try again. */ - *expr_p = new; + *expr_p = new_tree; return GS_OK; } @@ -2452,14 +2448,14 @@ gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value) /* Try this again in case gimplification exposed something. */ if (ret != GS_ERROR) { - tree new = fold_call_expr (*expr_p, !want_value); + tree new_tree = fold_call_expr (*expr_p, !want_value); - if (new && new != *expr_p) + if (new_tree && new_tree != *expr_p) { /* There was a transformation of this call which computes the same value, but in a more efficient way. Return and try again. */ - *expr_p = new; + *expr_p = new_tree; return GS_OK; } } @@ -3636,25 +3632,25 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, if (size > 0 && !can_move_by_pieces (size, align)) { - tree new; + tree new_tree; if (notify_temp_creation) return GS_ERROR; - new = create_tmp_var_raw (type, "C"); + new_tree = create_tmp_var_raw (type, "C"); - gimple_add_tmp_var (new); - TREE_STATIC (new) = 1; - TREE_READONLY (new) = 1; - DECL_INITIAL (new) = ctor; - if (align > DECL_ALIGN (new)) + gimple_add_tmp_var (new_tree); + TREE_STATIC (new_tree) = 1; + TREE_READONLY (new_tree) = 1; + DECL_INITIAL (new_tree) = ctor; + if (align > DECL_ALIGN (new_tree)) { - DECL_ALIGN (new) = align; - DECL_USER_ALIGN (new) = 1; + DECL_ALIGN (new_tree) = align; + DECL_USER_ALIGN (new_tree) = 1; } - walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL); + walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL); - TREE_OPERAND (*expr_p, 1) = new; + TREE_OPERAND (*expr_p, 1) = new_tree; /* This is no longer an assignment of a CONSTRUCTOR, but we still may have processing to do on the LHS. So @@ -3913,7 +3909,7 @@ gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, /* If we're assigning from a constant constructor, move the constructor expression to the RHS of the MODIFY_EXPR. */ if (DECL_INITIAL (*from_p) - && TYPE_READONLY (TREE_TYPE (*from_p)) + && TREE_READONLY (*from_p) && !TREE_THIS_VOLATILE (*from_p) && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR) { @@ -4844,7 +4840,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p) } else { - gimple try; + gimple gtry; gimple_seq seq; enum gimple_try_flags kind; @@ -4854,10 +4850,10 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p) kind = GIMPLE_TRY_FINALLY; seq = gsi_split_seq_after (iter); - try = gimple_build_try (seq, gimple_wce_cleanup (wce), kind); + gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind); /* Do not use gsi_replace here, as it may scan operands. We want to do a simple structural modification only. */ - *gsi_stmt_ptr (&iter) = try; + *gsi_stmt_ptr (&iter) = gtry; iter = gsi_start (seq); } } @@ -6735,30 +6731,24 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, The second is gimple immediate saving a need for extra statement. */ if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST - && (tmp = maybe_fold_offset_to_reference + && (tmp = maybe_fold_offset_to_address (TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1), - TREE_TYPE (TREE_TYPE (*expr_p))))) - { - tree ptr_type = build_pointer_type (TREE_TYPE (tmp)); - if (useless_type_conversion_p (TREE_TYPE (*expr_p), ptr_type)) - { - *expr_p = build_fold_addr_expr_with_type (tmp, ptr_type); - break; - } - } + TREE_TYPE (*expr_p)))) + { + *expr_p = tmp; + break; + } /* Convert (void *)&a + 4 into (void *)&a[1]. */ if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),0))) - && (tmp = maybe_fold_offset_to_reference + && (tmp = maybe_fold_offset_to_address (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0), TREE_OPERAND (*expr_p, 1), - TREE_TYPE (TREE_TYPE - (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), - 0)))))) + TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), + 0))))) { - tmp = build_fold_addr_expr (tmp); *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp); break; } diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index af1cc0fd787..a129a74c7ff 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -281,15 +281,17 @@ ipcp_lattice_from_jfunc (struct ipa_node_params *info, struct ipcp_lattice *lat, lat->type = IPA_BOTTOM; } -/* True when OLD and NEW values are not the same. */ +/* True when OLD_LAT and NEW_LAT values are not the same. */ + static bool -ipcp_lattice_changed (struct ipcp_lattice *old, struct ipcp_lattice *new) +ipcp_lattice_changed (struct ipcp_lattice *old_lat, + struct ipcp_lattice *new_lat) { - if (old->type == new->type) + if (old_lat->type == new_lat->type) { - if (!ipcp_lat_is_const (old)) + if (!ipcp_lat_is_const (old_lat)) return false; - if (ipcp_lats_are_equal (old, new)) + if (ipcp_lats_are_equal (old_lat, new_lat)) return false; } return true; @@ -807,7 +809,7 @@ ipcp_update_callgraph (void) if (ipcp_need_redirect_p (cs)) { cgraph_redirect_edge_callee (cs, orig_callee); - gimple_call_set_fn (cs->call_stmt, orig_callee->decl); + gimple_call_set_fndecl (cs->call_stmt, orig_callee->decl); } } } diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index b2321e374f8..f1ee4d6febc 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,13 @@ +2008-08-12 Ulrich Weigand <uweigand@de.ibm.com> + + * typeck.c (convert): Do not check for TARGET_FLOAT_FORMAT. + +2008-08-08 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 28875 + * lang.c (java_handle_option): Replace set_Wunused with + warn_unused. + 2008-07-30 Ralf Wildenhues <Ralf.Wildenhues@gmx.de> * gcj.texi: Update copyright years. Do not list GPL as diff --git a/gcc/java/lang.c b/gcc/java/lang.c index 27383762add..d049aeb2bc1 100644 --- a/gcc/java/lang.c +++ b/gcc/java/lang.c @@ -221,7 +221,7 @@ java_handle_option (size_t scode, const char *arg, int value) flag_wall = value; /* When -Wall given, enable -Wunused. We do this because the C compiler does it, and people expect it. */ - set_Wunused (value); + warn_unused = value; break; case OPT_fenable_assertions_: diff --git a/gcc/java/typeck.c b/gcc/java/typeck.c index 1028c73ad14..e812f31b829 100644 --- a/gcc/java/typeck.c +++ b/gcc/java/typeck.c @@ -131,8 +131,7 @@ convert (tree type, tree expr) if (type == char_type_node || type == promoted_char_type_node) return fold_convert (type, expr); if ((really_constant_p (expr) || ! flag_unsafe_math_optimizations) - && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE - && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT) + && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE) return convert_ieee_real_to_integer (type, expr); else { diff --git a/gcc/jump.c b/gcc/jump.c index 595363b1adb..c0ab6909a2a 100644 --- a/gcc/jump.c +++ b/gcc/jump.c @@ -1552,12 +1552,22 @@ rtx_renumbered_equal_p (const_rtx x, const_rtx y) if (reg_renumber[reg_x] >= 0) { + if (!subreg_offset_representable_p (reg_renumber[reg_x], + GET_MODE (SUBREG_REG (x)), + byte_x, + GET_MODE (x))) + return 0; reg_x = subreg_regno_offset (reg_renumber[reg_x], GET_MODE (SUBREG_REG (x)), byte_x, GET_MODE (x)); byte_x = 0; } + else if (!subreg_offset_representable_p (reg_x, + GET_MODE (SUBREG_REG (x)), + byte_x, + GET_MODE (x))) + return 0; } else { @@ -1573,12 +1583,22 @@ rtx_renumbered_equal_p (const_rtx x, const_rtx y) if (reg_renumber[reg_y] >= 0) { + if (!subreg_offset_representable_p (reg_renumber[reg_y], + GET_MODE (SUBREG_REG (y)), + byte_y, + GET_MODE (y))) + return 0; reg_y = subreg_regno_offset (reg_renumber[reg_y], GET_MODE (SUBREG_REG (y)), byte_y, GET_MODE (y)); byte_y = 0; } + else if (!subreg_offset_representable_p (reg_y, + GET_MODE (SUBREG_REG (y)), + byte_y, + GET_MODE (y))) + return 0; } else { diff --git a/gcc/machmode.h b/gcc/machmode.h index 440e7bb1899..8db9f75b573 100644 --- a/gcc/machmode.h +++ b/gcc/machmode.h @@ -202,7 +202,7 @@ extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES]; /* Return the mode of the inner elements in a vector. */ extern const unsigned char mode_inner[NUM_MACHINE_MODES]; -#define GET_MODE_INNER(MODE) mode_inner[MODE] +#define GET_MODE_INNER(MODE) ((enum machine_mode) mode_inner[MODE]) /* Get the size in bytes of the basic parts of an object of mode MODE. */ diff --git a/gcc/matrix-reorg.c b/gcc/matrix-reorg.c index 846a813898f..66145518f53 100644 --- a/gcc/matrix-reorg.c +++ b/gcc/matrix-reorg.c @@ -1755,16 +1755,20 @@ record_all_accesses_in_func (void) sbitmap_free (visited_stmts_1); } -/* Used when we want to convert the expression: RESULT = something * ORIG to RESULT = something * NEW. If ORIG and NEW are power of 2, shift operations can be done, else division and multiplication. */ +/* Used when we want to convert the expression: RESULT = something * + ORIG to RESULT = something * NEW_VAL. If ORIG and NEW_VAL are power + of 2, shift operations can be done, else division and + multiplication. */ + static tree -compute_offset (HOST_WIDE_INT orig, HOST_WIDE_INT new, tree result) +compute_offset (HOST_WIDE_INT orig, HOST_WIDE_INT new_val, tree result) { int x, y; tree result1, ratio, log, orig_tree, new_tree; x = exact_log2 (orig); - y = exact_log2 (new); + y = exact_log2 (new_val); if (x != -1 && y != -1) { @@ -1783,7 +1787,7 @@ compute_offset (HOST_WIDE_INT orig, HOST_WIDE_INT new, tree result) return result1; } orig_tree = build_int_cst (TREE_TYPE (result), orig); - new_tree = build_int_cst (TREE_TYPE (result), new); + new_tree = build_int_cst (TREE_TYPE (result), new_val); ratio = fold_build2 (TRUNC_DIV_EXPR, TREE_TYPE (result), result, orig_tree); result1 = fold_build2 (MULT_EXPR, TREE_TYPE (result), ratio, new_tree); diff --git a/gcc/omp-low.c b/gcc/omp-low.c index cda05a449ca..d6c5500319a 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -3222,7 +3222,7 @@ optimize_omp_library_calls (gimple entry_stmt) != TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (built_in)))) continue; - gimple_call_set_fn (call, build_fold_addr_expr (built_in)); + gimple_call_set_fndecl (call, built_in); } } } diff --git a/gcc/optabs.c b/gcc/optabs.c index 158e75999d8..5d2545dd3b9 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -3759,14 +3759,17 @@ expand_copysign (rtx op0, rtx op1, rtx target) with two operands: an output TARGET and an input OP0. TARGET *must* be nonzero, and the output is always stored there. CODE is an rtx code such that (CODE OP0) is an rtx that describes - the value that is stored into TARGET. */ + the value that is stored into TARGET. -void -emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code) + Return false if expansion failed. */ + +bool +maybe_emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code) { rtx temp; enum machine_mode mode0 = insn_data[icode].operand[1].mode; rtx pat; + rtx last = get_last_insn (); temp = target; @@ -3779,6 +3782,11 @@ emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code) temp = gen_reg_rtx (GET_MODE (temp)); pat = GEN_FCN (icode) (temp, op0); + if (!pat) + { + delete_insns_since (last); + return false; + } if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX && code != UNKNOWN) add_equal_note (pat, temp, code, op0, NULL_RTX); @@ -3787,6 +3795,19 @@ emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code) if (temp != target) emit_move_insn (target, temp); + return true; +} +/* Generate an instruction whose insn-code is INSN_CODE, + with two operands: an output TARGET and an input OP0. + TARGET *must* be nonzero, and the output is always stored there. + CODE is an rtx code such that (CODE OP0) is an rtx that describes + the value that is stored into TARGET. */ + +void +emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code) +{ + bool ok = maybe_emit_unop_insn (icode, target, op0, code); + gcc_assert (ok); } struct no_conflict_data @@ -5140,6 +5161,7 @@ expand_fix (rtx to, rtx from, int unsignedp) if (icode != CODE_FOR_nothing) { + rtx last = get_last_insn (); if (fmode != GET_MODE (from)) from = convert_to_mode (fmode, from, 0); @@ -5153,11 +5175,14 @@ expand_fix (rtx to, rtx from, int unsignedp) if (imode != GET_MODE (to)) target = gen_reg_rtx (imode); - emit_unop_insn (icode, target, from, - doing_unsigned ? UNSIGNED_FIX : FIX); - if (target != to) - convert_move (to, target, unsignedp); - return; + if (maybe_emit_unop_insn (icode, target, from, + doing_unsigned ? UNSIGNED_FIX : FIX)) + { + if (target != to) + convert_move (to, target, unsignedp); + return; + } + delete_insns_since (last); } } @@ -5365,13 +5390,18 @@ expand_sfix_optab (rtx to, rtx from, convert_optab tab) icode = convert_optab_handler (tab, imode, fmode)->insn_code; if (icode != CODE_FOR_nothing) { + rtx last = get_last_insn (); if (fmode != GET_MODE (from)) from = convert_to_mode (fmode, from, 0); if (imode != GET_MODE (to)) target = gen_reg_rtx (imode); - emit_unop_insn (icode, target, from, UNKNOWN); + if (!maybe_emit_unop_insn (icode, target, from, UNKNOWN)) + { + delete_insns_since (last); + continue; + } if (target != to) convert_move (to, target, 0); return true; diff --git a/gcc/optabs.h b/gcc/optabs.h index 30a28d4816d..4d0ce5245ea 100644 --- a/gcc/optabs.h +++ b/gcc/optabs.h @@ -722,6 +722,7 @@ extern rtx expand_copysign (rtx, rtx, rtx); /* Generate an instruction with a given INSN_CODE with an output and an input. */ extern void emit_unop_insn (int, rtx, rtx, enum rtx_code); +extern bool maybe_emit_unop_insn (int, rtx, rtx, enum rtx_code); /* Emit one rtl insn to compare two rtx's. */ extern void emit_cmp_insn (rtx, rtx, enum rtx_code, rtx, enum machine_mode, diff --git a/gcc/opts.c b/gcc/opts.c index 54512513f42..8dd8b8265fd 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -63,9 +63,6 @@ HOST_WIDE_INT larger_than_size; bool warn_frame_larger_than; HOST_WIDE_INT frame_larger_than_size; -/* Hack for cooperation between set_Wunused and set_Wextra. */ -static bool maybe_warn_unused_parameter; - /* Type(s) of debugging information we are producing (if any). See flags.h for the definitions of the different possible types of debugging information. */ @@ -1667,7 +1664,7 @@ common_handle_option (size_t scode, const char *arg, int value, break; case OPT_Wunused: - set_Wunused (value); + warn_unused = value; break; case OPT_aux_info: @@ -2037,7 +2034,6 @@ static void set_Wextra (int setting) { extra_warnings = setting; - warn_unused_parameter = (setting && maybe_warn_unused_parameter); /* We save the value of warn_uninitialized, since if they put -Wuninitialized on the command line, we need to generate a @@ -2048,23 +2044,6 @@ set_Wextra (int setting) warn_uninitialized = 2; } -/* Initialize unused warning flags. */ -void -set_Wunused (int setting) -{ - warn_unused_function = setting; - warn_unused_label = setting; - /* Unused function parameter warnings are reported when either - ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified. - Thus, if -Wextra has already been seen, set warn_unused_parameter; - otherwise set maybe_warn_extra_parameter, which will be picked up - by set_Wextra. */ - maybe_warn_unused_parameter = setting; - warn_unused_parameter = (setting && extra_warnings); - warn_unused_variable = setting; - warn_unused_value = setting; -} - /* Used to set the level of strict aliasing warnings, when no level is specified (i.e., when -Wstrict-aliasing, and not -Wstrict-aliasing=level was given). diff --git a/gcc/passes.c b/gcc/passes.c index e29be3f3722..167f845fb03 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -450,13 +450,13 @@ next_pass_1 (struct opt_pass **list, struct opt_pass *pass) pass is already in the list. */ if (pass->static_pass_number) { - struct opt_pass *new; + struct opt_pass *new_pass; - new = XNEW (struct opt_pass); - memcpy (new, pass, sizeof (*new)); - new->next = NULL; + new_pass = XNEW (struct opt_pass); + memcpy (new_pass, pass, sizeof (*new_pass)); + new_pass->next = NULL; - new->todo_flags_start &= ~TODO_mark_first_instance; + new_pass->todo_flags_start &= ~TODO_mark_first_instance; /* Indicate to register_dump_files that this pass has duplicates, and so it should rename the dump file. The first instance will @@ -465,10 +465,10 @@ next_pass_1 (struct opt_pass **list, struct opt_pass *pass) if (pass->name) { pass->static_pass_number -= 1; - new->static_pass_number = -pass->static_pass_number; + new_pass->static_pass_number = -pass->static_pass_number; } - *list = new; + *list = new_pass; } else { @@ -645,9 +645,9 @@ init_optimization_passes (void) only examines PHIs to discover const/copy propagation opportunities. */ NEXT_PASS (pass_phi_only_cprop); + NEXT_PASS (pass_dse); NEXT_PASS (pass_reassoc); NEXT_PASS (pass_dce); - NEXT_PASS (pass_dse); NEXT_PASS (pass_forwprop); NEXT_PASS (pass_phiopt); NEXT_PASS (pass_object_sizes); diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index 92ce6b27606..212ae98a6ca 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,7 @@ +2008-08-09 Joseph S. Myers <joseph@codesourcery.com> + + * sv.po: Update. + 2008-05-11 Joseph S. Myers <joseph@codesourcery.com> * zh_CN.po: Update. diff --git a/gcc/po/sv.po b/gcc/po/sv.po index dc7abc802ad..c341898a080 100644 --- a/gcc/po/sv.po +++ b/gcc/po/sv.po @@ -11,7 +11,7 @@ msgstr "" "Project-Id-Version: gcc 4.3.0\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2008-03-05 17:23+0100\n" -"PO-Revision-Date: 2008-05-06 21:51+0200\n" +"PO-Revision-Date: 2008-08-07 20:38+0200\n" "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n" "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n" "MIME-Version: 1.0\n" @@ -27175,7 +27175,7 @@ msgstr "omdefinition av %q#T" #: cp/class.c:5246 #, gcc-internal-format msgid "%q#T has virtual functions and accessible non-virtual destructor" -msgstr "%q#T har virtuella funktioner och åtkomlig icketrivial destruerare" +msgstr "%q#T har virtuella funktioner och åtkomlig ickevirtuell destruerare" #: cp/class.c:5348 #, gcc-internal-format diff --git a/gcc/print-tree.c b/gcc/print-tree.c index b76a180fbdb..16ba3929fab 100644 --- a/gcc/print-tree.c +++ b/gcc/print-tree.c @@ -74,12 +74,12 @@ dump_addr (FILE *file, const char *prefix, const void *addr) void print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) { - enum tree_code_class class; + enum tree_code_class tclass; if (node == 0) return; - class = TREE_CODE_CLASS (TREE_CODE (node)); + tclass = TREE_CODE_CLASS (TREE_CODE (node)); /* Always print the slot this node is in, and its code, address and name if any. */ @@ -88,7 +88,7 @@ print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]); dump_addr (file, " ", node); - if (class == tcc_declaration) + if (tclass == tcc_declaration) { if (DECL_NAME (node)) fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); @@ -99,7 +99,7 @@ print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D', DECL_UID (node)); } - else if (class == tcc_type) + else if (tclass == tcc_type) { if (TYPE_NAME (node)) { @@ -188,7 +188,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) int hash; struct bucket *b; enum machine_mode mode; - enum tree_code_class class; + enum tree_code_class tclass; int len; int i; expanded_location xloc; @@ -198,7 +198,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) return; code = TREE_CODE (node); - class = TREE_CODE_CLASS (code); + tclass = TREE_CODE_CLASS (code); /* Don't get too deep in nesting. If the user wants to see deeper, it is easy to use the address of a lowest-level node @@ -210,7 +210,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) return; } - if (indent > 8 && (class == tcc_type || class == tcc_declaration)) + if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration)) { print_node_brief (file, prefix, node, indent); return; @@ -251,7 +251,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) dump_addr (file, " ", node); /* Print the name, if any. */ - if (class == tcc_declaration) + if (tclass == tcc_declaration) { if (DECL_NAME (node)) fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); @@ -262,7 +262,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D', DECL_UID (node)); } - else if (class == tcc_type) + else if (tclass == tcc_type) { if (TYPE_NAME (node)) { diff --git a/gcc/profile.c b/gcc/profile.c index b6cddc2295f..7489579ca27 100644 --- a/gcc/profile.c +++ b/gcc/profile.c @@ -821,8 +821,8 @@ branch_prob (void) || (LOCATION_LINE (e->goto_locus) != LOCATION_LINE (gimple_location (last))))) { - basic_block new = split_edge (e); - single_succ_edge (new)->goto_locus = e->goto_locus; + basic_block new_bb = split_edge (e); + single_succ_edge (new_bb)->goto_locus = e->goto_locus; } if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL)) && e->dest != EXIT_BLOCK_PTR) diff --git a/gcc/real.c b/gcc/real.c index b0717569683..da311c8f67f 100644 --- a/gcc/real.c +++ b/gcc/real.c @@ -1443,20 +1443,30 @@ rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den) /* Render R as a decimal floating point constant. Emit DIGITS significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing - zeros. */ + zeros. If MODE is VOIDmode, round to nearest value. Otherwise, round + to a string that, when parsed back in mode MODE, yields the same value. */ #define M_LOG10_2 0.30102999566398119521 void -real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size, - size_t digits, int crop_trailing_zeros) +real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig, + size_t buf_size, size_t digits, + int crop_trailing_zeros, enum machine_mode mode) { + const struct real_format *fmt = NULL; const REAL_VALUE_TYPE *one, *ten; REAL_VALUE_TYPE r, pten, u, v; int dec_exp, cmp_one, digit; size_t max_digits; char *p, *first, *last; bool sign; + bool round_up; + + if (mode != VOIDmode) + { + fmt = REAL_MODE_FORMAT (mode); + gcc_assert (fmt); + } r = *r_orig; switch (r.cl) @@ -1672,17 +1682,31 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size, digit = rtd_divmod (&r, &pten); /* Round the result. */ - if (digit == 5) + if (fmt && fmt->round_towards_zero) { - /* Round to nearest. If R is nonzero there are additional - nonzero digits to be extracted. */ + /* If the format uses round towards zero when parsing the string + back in, we need to always round away from zero here. */ if (cmp_significand_0 (&r)) digit++; - /* Round to even. */ - else if ((p[-1] - '0') & 1) - digit++; + round_up = digit > 0; } - if (digit > 5) + else + { + if (digit == 5) + { + /* Round to nearest. If R is nonzero there are additional + nonzero digits to be extracted. */ + if (cmp_significand_0 (&r)) + digit++; + /* Round to even. */ + else if ((p[-1] - '0') & 1) + digit++; + } + + round_up = digit > 5; + } + + if (round_up) { while (p > first) { @@ -1716,6 +1740,26 @@ real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size, /* Append the exponent. */ sprintf (last, "e%+d", dec_exp); + +#ifdef ENABLE_CHECKING + /* Verify that we can read the original value back in. */ + if (mode != VOIDmode) + { + real_from_string (&r, str); + real_convert (&r, mode, &r); + gcc_assert (real_identical (&r, r_orig)); + } +#endif +} + +/* Likewise, except always uses round-to-nearest. */ + +void +real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size, + size_t digits, int crop_trailing_zeros) +{ + real_to_decimal_for_mode (str, r_orig, buf_size, + digits, crop_trailing_zeros, VOIDmode); } /* Render R as a hexadecimal floating point constant. Emit DIGITS @@ -2389,9 +2433,8 @@ static void round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r) { int p2, np2, i, w; - unsigned long sticky; - bool guard, lsb; int emin2m1, emax2; + bool round_up = false; if (r->decimal) { @@ -2463,21 +2506,28 @@ round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r) } } - /* There are P2 true significand bits, followed by one guard bit, - followed by one sticky bit, followed by stuff. Fold nonzero - stuff into the sticky bit. */ + if (!fmt->round_towards_zero) + { + /* There are P2 true significand bits, followed by one guard bit, + followed by one sticky bit, followed by stuff. Fold nonzero + stuff into the sticky bit. */ + unsigned long sticky; + bool guard, lsb; + + sticky = 0; + for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i) + sticky |= r->sig[i]; + sticky |= r->sig[w] + & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1); - sticky = 0; - for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i) - sticky |= r->sig[i]; - sticky |= - r->sig[w] & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1); + guard = test_significand_bit (r, np2 - 1); + lsb = test_significand_bit (r, np2); - guard = test_significand_bit (r, np2 - 1); - lsb = test_significand_bit (r, np2); + /* Round to even. */ + round_up = guard && (sticky || lsb); + } - /* Round to even. */ - if (guard && (sticky || lsb)) + if (round_up) { REAL_VALUE_TYPE u; get_zero (&u, 0); @@ -2817,6 +2867,8 @@ const struct real_format ieee_single_format = 128, 31, 31, + false, + true, true, true, true, @@ -2836,6 +2888,8 @@ const struct real_format mips_single_format = 128, 31, 31, + false, + true, true, true, true, @@ -2855,6 +2909,8 @@ const struct real_format motorola_single_format = 128, 31, 31, + false, + true, true, true, true, @@ -2862,6 +2918,38 @@ const struct real_format motorola_single_format = true, true }; + +/* SPU Single Precision (Extended-Range Mode) format is the same as IEEE + single precision with the following differences: + - Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT + are generated. + - NaNs are not supported. + - The range of non-zero numbers in binary is + (001)[1.]000...000 to (255)[1.]111...111. + - Denormals can be represented, but are treated as +0.0 when + used as an operand and are never generated as a result. + - -0.0 can be represented, but a zero result is always +0.0. + - the only supported rounding mode is trunction (towards zero). */ +const struct real_format spu_single_format = + { + encode_ieee_single, + decode_ieee_single, + 2, + 24, + 24, + -125, + 129, + 31, + 31, + true, + false, + false, + false, + true, + true, + false, + false + }; /* IEEE double-precision format. */ @@ -3062,6 +3150,8 @@ const struct real_format ieee_double_format = 1024, 63, 63, + false, + true, true, true, true, @@ -3081,6 +3171,8 @@ const struct real_format mips_double_format = 1024, 63, 63, + false, + true, true, true, true, @@ -3100,6 +3192,8 @@ const struct real_format motorola_double_format = 1024, 63, 63, + false, + true, true, true, true, @@ -3437,6 +3531,8 @@ const struct real_format ieee_extended_motorola_format = 16384, 95, 95, + false, + true, true, true, true, @@ -3456,6 +3552,8 @@ const struct real_format ieee_extended_intel_96_format = 16384, 79, 79, + false, + true, true, true, true, @@ -3475,6 +3573,8 @@ const struct real_format ieee_extended_intel_128_format = 16384, 79, 79, + false, + true, true, true, true, @@ -3496,6 +3596,8 @@ const struct real_format ieee_extended_intel_96_round_53_format = 16384, 79, 79, + false, + true, true, true, true, @@ -3582,6 +3684,8 @@ const struct real_format ibm_extended_format = 1024, 127, -1, + false, + true, true, true, true, @@ -3601,6 +3705,8 @@ const struct real_format mips_extended_format = 1024, 127, -1, + false, + true, true, true, true, @@ -3862,6 +3968,8 @@ const struct real_format ieee_quad_format = 16384, 127, 127, + false, + true, true, true, true, @@ -3881,6 +3989,8 @@ const struct real_format mips_quad_format = 16384, 127, 127, + false, + true, true, true, true, @@ -4184,6 +4294,8 @@ const struct real_format vax_f_format = false, false, false, + false, + false, false }; @@ -4203,6 +4315,8 @@ const struct real_format vax_d_format = false, false, false, + false, + false, false }; @@ -4222,6 +4336,8 @@ const struct real_format vax_g_format = false, false, false, + false, + false, false }; @@ -4291,6 +4407,8 @@ const struct real_format decimal_single_format = 96, 31, 31, + false, + true, true, true, true, @@ -4311,6 +4429,8 @@ const struct real_format decimal_double_format = 384, 63, 63, + false, + true, true, true, true, @@ -4331,6 +4451,8 @@ const struct real_format decimal_quad_format = 6144, 127, 127, + false, + true, true, true, true, @@ -4374,6 +4496,8 @@ const struct real_format real_internal_format = MAX_EXP, -1, -1, + false, + false, true, true, false, diff --git a/gcc/real.h b/gcc/real.h index 633229969a7..8cdf471e742 100644 --- a/gcc/real.h +++ b/gcc/real.h @@ -147,6 +147,10 @@ struct real_format or -1 for a complex encoding. */ int signbit_rw; + /* Default rounding mode for operations on this format. */ + bool round_towards_zero; + bool has_sign_dependent_rounding; + /* Properties of the format. */ bool has_nans; bool has_inf; @@ -168,15 +172,32 @@ extern const struct real_format * #define REAL_MODE_FORMAT(MODE) \ (real_format_for_mode[DECIMAL_FLOAT_MODE_P (MODE) \ - ? ((MODE - MIN_MODE_DECIMAL_FLOAT) \ + ? (((MODE) - MIN_MODE_DECIMAL_FLOAT) \ + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) \ - : (MODE - MIN_MODE_FLOAT)]) + : ((MODE) - MIN_MODE_FLOAT)]) + +#define FLOAT_MODE_FORMAT(MODE) \ + (REAL_MODE_FORMAT (SCALAR_FLOAT_MODE_P (MODE)? (MODE) \ + : GET_MODE_INNER (MODE))) /* The following macro determines whether the floating point format is composite, i.e. may contain non-consecutive mantissa bits, in which case compile-time FP overflow may not model run-time overflow. */ -#define REAL_MODE_FORMAT_COMPOSITE_P(MODE) \ - ((REAL_MODE_FORMAT(MODE))->pnan < (REAL_MODE_FORMAT (MODE))->p) +#define MODE_COMPOSITE_P(MODE) \ + (FLOAT_MODE_P (MODE) \ + && FLOAT_MODE_FORMAT (MODE)->pnan < FLOAT_MODE_FORMAT (MODE)->p) + +/* Accessor macros for format properties. */ +#define MODE_HAS_NANS(MODE) \ + (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans) +#define MODE_HAS_INFINITIES(MODE) \ + (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf) +#define MODE_HAS_SIGNED_ZEROS(MODE) \ + (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero) +#define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \ + (FLOAT_MODE_P (MODE) \ + && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding) + /* Declare functions in real.c. */ @@ -216,6 +237,11 @@ extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *); extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t, size_t, int); +/* Render R as a decimal floating point constant, rounded so as to be + parsed back to the same value when interpreted in mode MODE. */ +extern void real_to_decimal_for_mode (char *, const REAL_VALUE_TYPE *, size_t, + size_t, int, enum machine_mode); + /* Render R as a hexadecimal floating point constant. */ extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *, size_t, size_t, int); @@ -259,6 +285,7 @@ extern unsigned int real_hash (const REAL_VALUE_TYPE *); extern const struct real_format ieee_single_format; extern const struct real_format mips_single_format; extern const struct real_format motorola_single_format; +extern const struct real_format spu_single_format; extern const struct real_format ieee_double_format; extern const struct real_format mips_double_format; extern const struct real_format motorola_double_format; diff --git a/gcc/recog.c b/gcc/recog.c index cd47155ad4e..44d3b40b643 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -2672,6 +2672,7 @@ split_all_insns (void) rtx insn, next; bool finish = false; + rtl_profile_for_bb (bb); for (insn = BB_HEAD (bb); !finish ; insn = next) { /* Can't use `next_real_insn' because that might go across @@ -2714,6 +2715,7 @@ split_all_insns (void) } } + default_rtl_profile (); if (changed) find_many_sub_basic_blocks (blocks); @@ -2966,6 +2968,7 @@ peephole2_optimize (void) FOR_EACH_BB_REVERSE (bb) { + rtl_profile_for_bb (bb); /* Indicate that all slots except the last holds invalid data. */ for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i) peep2_insn_data[i].insn = NULL_RTX; @@ -3182,6 +3185,7 @@ peephole2_optimize (void) } } + default_rtl_profile (); for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i) BITMAP_FREE (peep2_insn_data[i].live_before); BITMAP_FREE (live); diff --git a/gcc/reload.c b/gcc/reload.c index 93fff404569..5a79c44e874 100644 --- a/gcc/reload.c +++ b/gcc/reload.c @@ -1403,13 +1403,36 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc, else remove_address_replacements (rld[i].in); } - rld[i].in = in; - rld[i].in_reg = in_reg; + /* When emitting reloads we don't necessarily look at the in- + and outmode, but also directly at the operands (in and out). + So we can't simply overwrite them with whatever we have found + for this (to-be-merged) reload, we have to "merge" that too. + Reusing another reload already verified that we deal with the + same operands, just possibly in different modes. So we + overwrite the operands only when the new mode is larger. + See also PR33613. */ + if (!rld[i].in + || GET_MODE_SIZE (GET_MODE (in)) + > GET_MODE_SIZE (GET_MODE (rld[i].in))) + rld[i].in = in; + if (!rld[i].in_reg + || (in_reg + && GET_MODE_SIZE (GET_MODE (in_reg)) + > GET_MODE_SIZE (GET_MODE (rld[i].in_reg)))) + rld[i].in_reg = in_reg; } if (out != 0) { - rld[i].out = out; - rld[i].out_reg = outloc ? *outloc : 0; + if (!rld[i].out + || (out + && GET_MODE_SIZE (GET_MODE (out)) + > GET_MODE_SIZE (GET_MODE (rld[i].out)))) + rld[i].out = out; + if (outloc + && (!rld[i].out_reg + || GET_MODE_SIZE (GET_MODE (*outloc)) + > GET_MODE_SIZE (GET_MODE (rld[i].out_reg)))) + rld[i].out_reg = *outloc; } if (reg_class_subset_p (rclass, rld[i].rclass)) rld[i].rclass = rclass; diff --git a/gcc/reload1.c b/gcc/reload1.c index 9b81062216f..3abd6b24e33 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -8009,9 +8009,11 @@ gen_reload (rtx out, rtx in, int opnum, enum reload_type type) #ifdef SECONDARY_MEMORY_NEEDED /* If we need a memory location to do the move, do it that way. */ - else if ((REG_P (in) || GET_CODE (in) == SUBREG) + else if ((REG_P (in) + || (GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in)))) && reg_or_subregno (in) < FIRST_PSEUDO_REGISTER - && (REG_P (out) || GET_CODE (out) == SUBREG) + && (REG_P (out) + || (GET_CODE (out) == SUBREG && REG_P (SUBREG_REG (out)))) && reg_or_subregno (out) < FIRST_PSEUDO_REGISTER && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)), REGNO_REG_CLASS (reg_or_subregno (out)), diff --git a/gcc/reorg.c b/gcc/reorg.c index 25f410aad2d..59c6eecf2c2 100644 --- a/gcc/reorg.c +++ b/gcc/reorg.c @@ -1529,12 +1529,12 @@ try_merge_delay_insns (rtx insn, rtx thread) { if (! annul_p) { - rtx new; + rtx new_rtx; update_block (dtrial, thread); - new = delete_from_delay_slot (dtrial); + new_rtx = delete_from_delay_slot (dtrial); if (INSN_DELETED_P (thread)) - thread = new; + thread = new_rtx; INSN_FROM_TARGET_P (next_to_match) = 0; } else @@ -1567,12 +1567,12 @@ try_merge_delay_insns (rtx insn, rtx thread) { if (GET_MODE (merged_insns) == SImode) { - rtx new; + rtx new_rtx; update_block (XEXP (merged_insns, 0), thread); - new = delete_from_delay_slot (XEXP (merged_insns, 0)); + new_rtx = delete_from_delay_slot (XEXP (merged_insns, 0)); if (INSN_DELETED_P (thread)) - thread = new; + thread = new_rtx; } else { diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index 262c9194937..6fd77ff1543 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -1740,9 +1740,8 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, so we can distinguish it from a register-register-copy. In IEEE floating point, x-0 is not the same as x. */ - - if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT - || ! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations) + if (!(HONOR_SIGNED_ZEROS (mode) + && HONOR_SIGN_DEPENDENT_ROUNDING (mode)) && trueop1 == CONST0_RTX (mode)) return op0; #endif @@ -3080,8 +3079,7 @@ simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode, is unable to accurately represent the result. */ if ((flag_rounding_math - || (REAL_MODE_FORMAT_COMPOSITE_P (mode) - && !flag_unsafe_math_optimizations)) + || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations)) && (inexact || !real_identical (&result, &value))) return NULL_RTX; diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 1e035f3bf93..f7386283660 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,4 +1,407 @@ +2008-08-14 Rafael Avila de Espindola <espindola@google.com> + + * gcc.dg/visibility-14.c: New test. + * gcc.dg/visibility-15.c: New test. + * gcc.dg/visibility-16.c: New test. + * gcc.dg/visibility-17.c: New test. + * gcc.dg/visibility-18.c: New test. + * gcc.dg/visibility-19.c: New test. + +2008-08-14 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/34600 + * g++.dg/parse/crash43.C: New. + +2008-08-14 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c/28152 + * gcc.dg/parser-pr28152.c: New. + * gcc.dg/parser-pr28152-2.c: New. + +2008-08-14 Dorit Nuzman <dorit@il.ibm.com> + + * gcc.dg/vect/vect-outer-4g.c: Change loop bound. + * gcc.dg/vect/vect-outer-4k.c: Likewise. + * gcc.dg/vect/vect-outer-4l.c: Likewise. + * gcc.dg/vect/vect-outer-4f.c: Likewise. + * gcc.dg/vect/vect-outer-4a.c: Vectorizable. Remove obsolete comment. + * gcc.dg/vect/vect-outer-4i.c: Likewise. + * gcc.dg/vect/vect-outer-4b.c: Likewise. + * gcc.dg/vect/vect-outer-4j.c: Likewise. + +2008-08-14 Uros Bizjak <ubizjak@gmail.com> + + PR target/37101 + * gcc.target/i386/pr37101.c: New test. + +2008-08-14 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/37103 + * gcc.c-torture/execute/20080813-1.c: New test. + +2008-08-13 H.J. Lu <hongjiu.lu@intel.com> + + * gcc.target/i386/incoming-1.c: Skip *-*-darwin*. + * gcc.target/i386/incoming-2.c: Likewise. + * gcc.target/i386/incoming-3.c: Likewise. + * gcc.target/i386/incoming-4.c: Likewise. + * gcc.target/i386/incoming-5.c: Likewise. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 30551 + * gcc.dg/pr30551.c: New. + * gcc.dg/pr30551-2.c: New. + * gcc.dg/pr30551-3.c: New. + * gcc.dg/pr30551-4.c: New. + * gcc.dg/pr30551-5.c: New. + * gcc.dg/pr30551-6.c: New. + * gcc.dg/tree-ssa/reassoc-3.c: Don't compile with -pedantic-errors. + * g++.dg/warn/pr30551.C: New. + * g++.dg/warn/pr30551-2.C: New. + +2008-08-13 Richard Guenther <rguenther@suse.de> + + * gcc.dg/tree-ssa/ssa-ccp-21.c: New testcase. + * gcc.dg/tree-ssa/ssa-ccp-22.c: Likewise. + * gcc.dg/tree-ssa/ssa-ccp-23.c: Likewise. + +2008-08-13 Samuel Tardieu <sam@rfc1149.net> + + PR ada/36777 + * gnat.dg/protected_self_ref1.adb, gnat.dg/protected_self_ref2.adb: + New. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c/15236 + * gcc.dg/pr15236.c: New. + * gcc.dg/torture/pr25183.c: Update. + +2008-08-13 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 35635 + * gcc.dg/pr35635.c: New. + * gcc.dg/Wconversion-integer.c: Update. + * gcc.dg/Wconversion-integer-no-sign.c: Update. + * gcc.dg/Wsign-conversion.c: Update. + * g++.dg/warn/pr35635.C: New. + * g++.dg/warn/Wconversion-integer.C: Update. + * g++.dg/warn/Wsign-conversion.C: Update. + +2008-08-13 Richard Guenther <rguenther@suse.de> + + PR tree-optimization/15255 + * gcc.dg/tree-ssa/reassoc-14.c: New testcase. + * gcc.dg/tree-ssa/reassoc-15.c: Likewise. + * gcc.dg/tree-ssa/reassoc-16.c: Likewise. + * gcc.dg/torture/reassoc-1.c: Likewise. + * gcc.dg/tree-ssa/recip-2.c: Adjust. + * gcc.dg/tree-ssa/recip-6.c: Likewise. + * gcc.dg/tree-ssa/recip-7.c: Likewise. + * gfortran.dg/reassoc_4.f: Likewise. + +2008-08-12 Janis Johnson <janis187@us.ibm.com> + + * gcc.target/i386/pr32000-2.c: Use dg-skip-if for target expression. + * gcc.target/i386/stackalign/return-3.c: Ditto. + * gcc.target/sparc/ultrasp3.c: Ditto. + * lib/target-supports-dg.exp (dg-require-effective-target): Error + if argument is not a single effective-target keyword. + + PR testsuite/36087 + * gcc.dg/var-expand3.c: Fix name of dump file. + +2008-08-12 Paolo Carlini <paolo.carlini@oracle.com> + + * g++.old-deja/g++.other/decl5.C: Expand new expected errors. + +2008-08-12 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/37087 + * g++.dg/template/crash80.C: New. + * g++.old-deja/g++.other/decl5.C: Adjust. + +2008-08-12 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/37014 + * gcc.c-torture/compile/20080812-1.c: New test. + + PR tree-optimization/37084 + * g++.dg/tree-ssa/pr37084.C: New test. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * gcc.c-torture/execute/20031003-1.c (main): Update test to + accommodate SPU single-precision rounding mode. + * gcc.c-torture/execute/conversion.c (test_float_to_integer, + test_float_to_longlong_integer): Likewise. + * gcc.c-torture/execute/ieee/rbug.c (main): Likewise. + * gcc.dg/hex-round-1.c: Skip test on SPU. + * gcc.dg/hex-round-2.c: Likewise. + +2008-08-12 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * gcc.c-torture/execute/ieee/inf-2.c (testf): Skip on the SPU. + +2008-08-12 Jakub Jelinek <jakub@redhat.com> + + PR c++/36688 + * g++.dg/init/const6.C: New test. + +2008-08-12 Ira Rosen <irar@il.ibm.com> + + * gcc.dg/vect/vect-multitypes-12.c: New. + * gcc.dg/vect/vect-multitypes-13.c, gcc.dg/vect/vect-multitypes-14.c, + gcc.dg/vect/vect-multitypes-15.c : Likewise. + * gcc.dg/vect/vect-reduc-dot-u8a.c: Avoid vectorization of the + init loop. + * gcc.dg/vect/vect-72.c, gcc.dg/vect/vect-strided-store-a-u8-i2.c: + Likewise. + * gcc.dg/vect/vect-reduc-dot-u8b.c: Avoid vectorization of the init + loop. + Should be vectorizable on targets that support vector unpack. + * gcc.dg/vect/vect-widen-mult-u8.c, + gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c, + gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c: Likewise. + * gcc.dg/vect/vect-35.c: Should be vectorizable on targets that + support vector pack. Avoid vectorization of the init loop. + * gcc.dg/vect/vect-reduc-pattern-1b.c: Should be vectorizable on + targets that support vector unpack. + * gcc.dg/vect/vect-reduc-pattern-2b.c, + gcc.dg/vect/vect-reduc-dot-s8c.c, gcc.dg/vect/vect-112.c: Likewise. + +2008-08-11 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/36998 + * gcc.dg/pr36998.c: New test. + +2008-08-11 Andreas Krebbel <krebbel1@de.ibm.com> + + * gcc.target/s390/20080806-1.c: Move testcase ... + * gcc.c-torture/compile/20080806-1.c: ... to here and make it + stack size sensitive. + +2008-08-10 Samuel Tardieu <sam@rfc1149.net> + + * gnat.dg/exp0_eval.adb: New. + +2008-08-10 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR middle-end/20644 + * gcc.dg/uninit-pr20644-O0.c: New. + * gcc.dg/uninit-pr20644.c: New. + +2008-08-10 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 36901 + * gcc.dg/pr36901.h: Do not depend on limits.h. + * gcc.dg/pr36901-3.c: Update. + * gcc.dg/pr36901-4.c: Update. + +2008-08-09 Andrew Pinski <andrew_pinski@playstation.sony.com> + + PR middle-end/36238 + * gcc.c-torture/compile/pr36238.c: New testcase. + +2008-08-09 Richard Sandiford <rdsandiford@googlemail.com> + + * lib/target-supports.exp (check_profiling_available): Return false + for -p and -pg on MIPS16 targets. + +2008-08-09 Richard Guenther <rguenther@suse.de> + + * gcc.dg/tree-ssa/inline-2.c: New testcase. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c/17880 + * gcc.dg/sequence-pt-pr17880.c: New. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR c++/12242 + * g++.dg/warn/pr12242.C: New. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 36901 + * gcc.dg/pr36901-1.c: New. + * gcc.dg/pr36901-3.c: New. + * gcc.dg/pr36901-2.c: New. + * gcc.dg/pr36901-4.c: New. + * gcc.dg/pr36901-system.h: New. + * gcc.dg/pr36901.h: New. + * gcc.target/powerpc/altivec-macros.c: Update. + * gcc.target/i386/regparm.c: Update. + * gcc.dg/funcdef-var-1.c: Update. + * gcc.dg/parm-mismatch-1.c: Update. + * gcc.dg/attr-noinline.c: Update. + * gcc.dg/wtr-static-1.c: Update. + * gcc.dg/redecl-11.c: Update. + * gcc.dg/pr27953.c: Update. + * gcc.dg/proto-1.c: Update. + * gcc.dg/decl-3.c: Update. + * gcc.dg/redecl-13.c: Update. + * gcc.dg/pr15360-1.c: Update. + * gcc.dg/redecl-15.c: Update. + * gcc.dg/enum-compat-1.c: Update. + * gcc.dg/dll-3.c: Update. + * gcc.dg/array-5.c: Update. + * gcc.dg/Wredundant-decls-2.c: Update. + * gcc.dg/inline4.c: Update. + * gcc.dg/redecl-2.c: Update. + * gcc.dg/inline-14.c: Update. + * gcc.dg/tls/diag-3.c: Update. + * gcc.dg/funcdef-var-2.c: Update. + * gcc.dg/20041213-1.c: Update. + * gcc.dg/old-style-then-proto-1.c: Update. + * gcc.dg/decl-2.c: Update. + * gcc.dg/redecl-12.c: Update. + * gcc.dg/decl-4.c: Update. + * gcc.dg/Wshadow-1.c: Update. + * gcc.dg/transparent-union-2.c: Update. + * gcc.dg/visibility-7.c: Update. + * gcc.dg/dll-2.c: Update. + * gcc.dg/redecl-16.c: Update. + * gcc.dg/inline1.c: Update. + * gcc.dg/decl-8.c: Update. + * gcc.dg/nested-redef-1.c: Update. + * gcc.dg/inline3.c: Update. + * gcc.dg/redecl-1.c: Update. + * gcc.dg/inline5.c: Update. + * gcc.dg/pr35899.c: Update. + * gcc.dg/noncompile/label-lineno-1.c: Update. + * gcc.dg/noncompile/label-1.c: Update. + * gcc.dg/noncompile/20020220-1.c: Update. + * gcc.dg/noncompile/redecl-1.c: Update. + * gcc.dg/redecl-5.c: Update. + * gcc.dg/qual-return-3.c: Update. + * gcc.dg/label-decl-4.c: Update. + +2008-08-09 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 7651 + * g++.dg/warn/Wuninitializable-member.C: New. + * g++.dg/warn/Wuninitializable-member-no.C: New. + +2008-08-08 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 28875 + * gcc.dg/unused-6-no.c: New. + * gcc.dg/unused-6-WallWextra.c: New. + +2008-08-08 Volker Reichelt <v.reichelt@netcologne.de> + + PR c++/35985 + * g++.dg/inherit/base3.C: New. + +2008-08-08 Dorit Nuzman <dorit@il.ibm.com> + + * lib/target-supports.exp (check_effective_target_vect_floatint_cvt): + Add powerpc. + +2008-08-08 Daniel Kraft <d@domob.eu> + + * gfortran.dg/finalize_9.f03: New test. + * gfortran.dg/module_md5_1.f90: Adapted MD5-sum for changed module + file format. + +2008-08-08 Richard Guenther <rguenther@suse.de> + + * gcc.dg/tree-ssa/ssa-ccp-20.c: New testcase. + +2008-08-08 Richard Guenther <rguenther@suse.de> + + PR tree-optimization/37056 + * gcc.c-torture/compile/pr37056.c: New testcase. + +2008-08-07 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> + + * gcc.dg/Wcxx-compat-2.c: Check for bool/_Bool. + +2008-08-07 Douglas Gregor <doug.gregor@gmail.com> + + * g++.dg/cpp0x/decltype12.C: New. + +2008-08-07 H.J. Lu <hongjiu.lu@intel.com> + + PR target/36992 + * gcc.target/i386/pr36992-1.c: Scan movq. + * gcc.target/i386/pr36992-2.c: Use "-O2 -msse4" instead of + "-O0 -msse2". Scan movq. + +2008-08-07 Richard Guenther <rguenther@suse.de> + + PR middle-end/37042 + * gcc.dg/Wstrict-aliasing-bogus-ref-all-2.c: New testcase. + +2008-08-07 Andreas Krebbel <krebbel1@de.ibm.com> + + * gcc.c-torture/compile/20080806-1.c: Move testcase ... + * gcc.target/s390/20080806-1.c: ... to here. + +2008-08-06 Douglas Gregor <doug.gregor@gmail.com> + + PR c++/36460 + * g++.dg/cpp0x/bracket3.C: Add another test case for the >> + warning under -Wc++0x-compat. + * g++.dg/cpp0x/bracket4.C: Add testcase for PR c++/36460. + +2008-08-06 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> + + * gcc.dg/Wcxx-compat-2.c: Adjust test for more warnings. + +2008-08-06 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 26785 + * g++.dg/warn/pr26785.C: New. + +2008-08-06 Victor Kaplansky <victork@il.ibm.com> + + * gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c: New test. + +2008-08-06 Manuel Lopez-Ibanez <manu@gcc.gnu.org> + + PR 8715 + * gcc.dg/pr8715.c: New. + * g++.dg/warn/pr8715.C: New. + +2008-08-06 Marc Gauthier <marc@tensilica.com> + + * lib/target-supports.exp (check_profiling_available): Match more + processor names for Xtensa. + * g++.old-deja/g++.jason/thunk3.C: Likewise. + * gcc.dg/intmax_t-1.c: Likewise. + * gcc.dg/sibcall-3.c: Likewise. + * gcc.dg/sibcall-4.c: Likewise. + * gcc.c-torture/compile/20001226-1.c: Likewise. + +2008-08-06 H.J. Lu <hongjiu.lu@intel.com> + + PR middle-end/37010 + * gcc.dg/torture/stackalign/push-1.c: New. + +2008-08-06 Michael Matz <matz@suse.de> + + PR target/36613 + * gcc.target/i386/pr36613.c: New testcase. + +2008-08-06 H.J. Lu <hongjiu.lu@intel.com> + + PR middle-end/37009 + * gcc.dg/torture/stackalign/alloca-2.c: New. + * gcc.dg/torture/stackalign/alloca-3.c: Likewise. + * gcc.dg/torture/stackalign/alloca-4.c: Likewise. + * gcc.dg/torture/stackalign/vararg-3.c: Likewise. + * gcc.target/i386/incoming-1.c: Likewise. + * gcc.target/i386/incoming-2.c: Likewise. + * gcc.target/i386/incoming-3.c: Likewise. + * gcc.target/i386/incoming-4.c: Likewise. + * gcc.target/i386/incoming-5.c: Likewise. + 2008-08-06 Aldy Hernandez <aldyh@redhat.com> + PR middle-end/35432 * gcc.c-torture/compile/pr35432.c: New file. @@ -9,7 +412,7 @@ 2008-08-06 Andreas Krebbel <krebbel1@de.ibm.com> - * gcc.c-torture/compile/20080806-1.c: New testcase. + * gcc.c-torture/compile/20080806-1.c: New testcase. 2008-08-06 Maxim Kuvyrkov <maxim@codesourcery.com> diff --git a/gcc/testsuite/ChangeLog-1993-2007 b/gcc/testsuite/ChangeLog-1993-2007 index c7a8e3e2ffe..2447b7f8593 100644 --- a/gcc/testsuite/ChangeLog-1993-2007 +++ b/gcc/testsuite/ChangeLog-1993-2007 @@ -7537,7 +7537,7 @@ vectorizable. 2007-07-01 Uros Bizjak <ubizjak@gmail.com> - Volker Reichelt <reichelt@netcologne.de> + Volker Reichelt <v.reichelt@netcologne.de> PR middle-end/32559 * gcc.dg/pr32559.c: New test. @@ -11152,7 +11152,7 @@ PR fortran/31011 * gfortran.dg/parameter_array_section_2.f90: New test. -2007-03-08 Volker Reichelt <reichelt@netcologne.de> +2007-03-08 Volker Reichelt <v.reichelt@netcologne.de> PR c++/30852 * g++.dg/ext/offsetof1.C: Add cases with volatile. diff --git a/gcc/testsuite/g++.dg/cpp0x/bracket3.C b/gcc/testsuite/g++.dg/cpp0x/bracket3.C index eb1ef02297d..4ef7a0e9d30 100644 --- a/gcc/testsuite/g++.dg/cpp0x/bracket3.C +++ b/gcc/testsuite/g++.dg/cpp0x/bracket3.C @@ -3,3 +3,8 @@ template<int N> struct X {}; X<1 >> 2> x; // { dg-warning "will be treated as|suggest parentheses" } + +// From cp/parser.c +typedef int Y; +template <int V> struct Foo {}; +Foo<Y () >> 5> r; // { dg-warning "will be treated as|suggest parentheses" } diff --git a/gcc/testsuite/g++.dg/cpp0x/bracket4.C b/gcc/testsuite/g++.dg/cpp0x/bracket4.C index 2ac5ff3d734..c0743fb7ff5 100644 --- a/gcc/testsuite/g++.dg/cpp0x/bracket4.C +++ b/gcc/testsuite/g++.dg/cpp0x/bracket4.C @@ -1,6 +1,5 @@ // { dg-do "compile" } // { dg-options "-std=c++0x" } - template<typename T> struct vector { }; @@ -25,3 +24,12 @@ void f() { vector<vector<int>>() + 2; } + +// PR c++/36460 +template <class a> +class A {}; +template <class b> +class B {}; + +A<B<void()>> x; + diff --git a/gcc/testsuite/g++.dg/warn/Wconversion-integer.C b/gcc/testsuite/g++.dg/warn/Wconversion-integer.C index 46900825a8b..42d9cb00044 100644 --- a/gcc/testsuite/g++.dg/warn/Wconversion-integer.C +++ b/gcc/testsuite/g++.dg/warn/Wconversion-integer.C @@ -42,8 +42,8 @@ void h (int x) uc = x ? 1U : -1; /* { dg-warning "conversion" } */ uc = x ? SCHAR_MIN : 1U; /* { dg-warning "conversion" } */ - uc = x ? 1 : -1; /* { dg-warning "conversion" } */ - uc = x ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */ + uc = x ? 1 : -1; /* Warned by -Wsign-conversion. */ + uc = x ? SCHAR_MIN : 1; /* Warned by -Wsign-conversion. */ ui = x ? 1U : -1; /* Warned by -Wsign-conversion. */ ui = x ? INT_MIN : 1U; /* Warned by -Wsign-conversion. */ ui = ui ? SCHAR_MIN : 1U; /* Warned by -Wsign-conversion. */ diff --git a/gcc/testsuite/g++.dg/warn/Wsign-conversion.C b/gcc/testsuite/g++.dg/warn/Wsign-conversion.C index b097446c3f8..83fe2ed660b 100644 --- a/gcc/testsuite/g++.dg/warn/Wsign-conversion.C +++ b/gcc/testsuite/g++.dg/warn/Wsign-conversion.C @@ -42,15 +42,15 @@ void h (int x) uc = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ uc = x ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ - uc = x ? 1 : -1; - uc = x ? SCHAR_MIN : 1; + uc = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ + uc = x ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ - ui = x ? 1 : -1; /* { dg-warning "conversion" } */ - ui = ui ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */ + ui = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ + ui = ui ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */ uc = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ diff --git a/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C b/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C index 1b235ef58e9..d91982f7ed0 100644 --- a/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C +++ b/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C @@ -1,4 +1,4 @@ -// { dg-do run { xfail rs6000-*-* powerpc-*-eabi m68k-*-coff mn10300-*-* v850-*-* sh-*-* sh64-*-* h8*-*-* xtensa-*-* m32r*-*-* } } +// { dg-do run { xfail rs6000-*-* powerpc-*-eabi m68k-*-coff mn10300-*-* v850-*-* sh-*-* sh64-*-* h8*-*-* xtensa*-*-* m32r*-*-* } } // Test that variadic function calls using thunks work right. // Note that this will break on any target that uses the generic thunk // support, because it doesn't support variadic functions. diff --git a/gcc/testsuite/g++.old-deja/g++.other/decl5.C b/gcc/testsuite/g++.old-deja/g++.other/decl5.C index f8c447c01d3..fccc18c8933 100644 --- a/gcc/testsuite/g++.old-deja/g++.other/decl5.C +++ b/gcc/testsuite/g++.old-deja/g++.other/decl5.C @@ -16,7 +16,7 @@ struct A { int m; }; struct Z; - expand me; + expand me; // { dg-error "error: 'expand' does not name a type" } void foo(struct A::e); void foo(struct A::z); // { dg-warning "" } extra qualification }; @@ -71,7 +71,7 @@ namespace NMS }; } -NMS::D thing; +NMS::D thing; // { dg-error "error: 'D' in namespace 'NMS' does not name a type" } void NMS::fn() { i = 3; diff --git a/gcc/testsuite/gcc.c-torture/compile/20001226-1.c b/gcc/testsuite/gcc.c-torture/compile/20001226-1.c index 19701ab3877..64cf37cb840 100644 --- a/gcc/testsuite/gcc.c-torture/compile/20001226-1.c +++ b/gcc/testsuite/gcc.c-torture/compile/20001226-1.c @@ -3,7 +3,7 @@ /* { dg-do assemble } */ /* { dg-xfail-if "function larger than 64K" { m6811-*-* } { "*" } { "" } } */ /* { dg-skip-if "too much code for avr" { "avr-*-*" } { "*" } { "" } } */ -/* { dg-xfail-if "jump beyond 128K not supported" { xtensa-*-* } { "-O0" } { "" } } */ +/* { dg-xfail-if "jump beyond 128K not supported" { xtensa*-*-* } { "-O0" } { "" } } */ /* { dg-xfail-if "PR36698" { spu-*-* } { "-O0" } { "" } } */ /* { dg-skip-if "" { m32c-*-* } { "*" } { "" } } */ diff --git a/gcc/testsuite/gcc.c-torture/compile/20080806-1.c b/gcc/testsuite/gcc.c-torture/compile/20080806-1.c index 33f0857d5c2..c54e7397f5d 100644 --- a/gcc/testsuite/gcc.c-torture/compile/20080806-1.c +++ b/gcc/testsuite/gcc.c-torture/compile/20080806-1.c @@ -1,3 +1,11 @@ +/* This used to ICE on s390x due to a reload bug. */ + +#if defined(STACK_SIZE) && (STACK_SIZE < 65536) + #define BYTES 64 +#else + #define BYTES 65400 +#endif + int gl2; typedef __SIZE_TYPE__ size_t; @@ -7,7 +15,7 @@ void f1 () { int i2; - unsigned char bf[64 * 1024 + 4]; + unsigned char bf[BYTES]; for (i2 = 0; i2 < 3; i2++) { diff --git a/gcc/testsuite/gcc.c-torture/execute/20031003-1.c b/gcc/testsuite/gcc.c-torture/execute/20031003-1.c index 5d39d799e50..5d172e7e604 100644 --- a/gcc/testsuite/gcc.c-torture/execute/20031003-1.c +++ b/gcc/testsuite/gcc.c-torture/execute/20031003-1.c @@ -19,9 +19,15 @@ int main() #if INT_MAX == 2147483647 if (f1() != 2147483647) abort (); +#ifdef __SPU__ + /* SPU float rounds towards zero. */ + if (f2() != 0x7fffff80) + abort (); +#else if (f2() != 2147483647) abort (); #endif +#endif return 0; } diff --git a/gcc/testsuite/gcc.c-torture/execute/conversion.c b/gcc/testsuite/gcc.c-torture/execute/conversion.c index 9e62acfd2ad..82d681acfe6 100644 --- a/gcc/testsuite/gcc.c-torture/execute/conversion.c +++ b/gcc/testsuite/gcc.c-torture/execute/conversion.c @@ -284,9 +284,15 @@ test_float_to_integer() abort(); if (f2u(1.99) != 1) abort(); +#ifdef __SPU__ + /* SPU float rounds towards zero. */ + if (f2u((float) ((~0U) >> 1)) != 0x7fffff80) + abort(); +#else if (f2u((float) ((~0U) >> 1)) != (~0U) >> 1 && /* 0x7fffffff */ f2u((float) ((~0U) >> 1)) != ((~0U) >> 1) + 1) abort(); +#endif if (f2u((float) ~((~0U) >> 1)) != ~((~0U) >> 1)) /* 0x80000000 */ abort(); @@ -439,9 +445,15 @@ test_float_to_longlong_integer() abort(); if (f2ull(1.99) != 1LL) abort(); +#ifdef __SPU__ + /* SPU float rounds towards zero. */ + if (f2ull((float) ((~0ULL) >> 1)) != 0x7fffff8000000000ULL) + abort(); +#else if (f2ull((float) ((~0ULL) >> 1)) != (~0ULL) >> 1 && /* 0x7fffffff */ f2ull((float) ((~0ULL) >> 1)) != ((~0ULL) >> 1) + 1) abort(); +#endif if (f2ull((float) ~((~0ULL) >> 1)) != ~((~0ULL) >> 1)) /* 0x80000000 */ abort(); diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/inf-2.c b/gcc/testsuite/gcc.c-torture/execute/ieee/inf-2.c index 40270c0f6ab..1823b35ff0f 100644 --- a/gcc/testsuite/gcc.c-torture/execute/ieee/inf-2.c +++ b/gcc/testsuite/gcc.c-torture/execute/ieee/inf-2.c @@ -25,6 +25,9 @@ void test(double f, double i) void testf(float f, float i) { +#ifndef __SPU__ + /* The SPU single-precision floating point format does not support Inf. */ + if (f == __builtin_inff()) abort (); if (f == -__builtin_inff()) @@ -44,6 +47,7 @@ void testf(float f, float i) abort (); if (f < -__builtin_inff()) abort (); +#endif } void testl(long double f, long double i) diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/rbug.c b/gcc/testsuite/gcc.c-torture/execute/ieee/rbug.c index ce13d7e9eed..1586bd7d43b 100644 --- a/gcc/testsuite/gcc.c-torture/execute/ieee/rbug.c +++ b/gcc/testsuite/gcc.c-torture/execute/ieee/rbug.c @@ -41,8 +41,14 @@ main () k = 0x8234508000000001ULL; x = s (k); k = (unsigned long long) x; +#ifdef __SPU__ + /* SPU float rounds towards zero. */ + if (k != 0x8234500000000000ULL) + abort (); +#else if (k != 0x8234510000000000ULL) abort (); +#endif exit (0); } diff --git a/gcc/testsuite/gcc.dg/20041213-1.c b/gcc/testsuite/gcc.dg/20041213-1.c index f7ef30a62f9..be1ab00241c 100644 --- a/gcc/testsuite/gcc.dg/20041213-1.c +++ b/gcc/testsuite/gcc.dg/20041213-1.c @@ -1,33 +1,33 @@ /* { dg-do compile } */ /* { dg-options "" } */ /* test redeclarations with void and implicit int */ -extern foo1(); /* { dg-error "previous declaration" } */ +extern foo1(); /* { dg-message "note: previous declaration" } */ extern void foo1(); /* { dg-error "conflicting types" } */ -extern void foo2(); /* { dg-error "previous declaration" } */ +extern void foo2(); /* { dg-message "note: previous declaration" } */ extern foo2(); /* { dg-error "conflicting types" } */ -void foo3() {} /* { dg-error "previous definition" } */ +void foo3() {} /* { dg-message "note: previous definition" } */ extern foo3(); /* { dg-error "conflicting types" } */ -extern foo4(); /* { dg-error "previous declaration" } */ +extern foo4(); /* { dg-message "note: previous declaration" } */ void foo4() {} /* { dg-error "conflicting types" } */ -extern void foo5(); /* { dg-warning "previous declaration" } */ +extern void foo5(); /* { dg-message "note: previous declaration" } */ foo5() {} /* { dg-warning "conflicting types" } */ -foo6() {} /* { dg-error "previous definition" } */ +foo6() {} /* { dg-message "note: previous definition" } */ extern void foo6(); /* { dg-error "conflicting types" } */ -foo7() {} /* { dg-error "previous definition" } */ +foo7() {} /* { dg-message "note: previous definition" } */ void foo7() {} /* { dg-error "conflicting types" } */ -void foo8() {} /* { dg-error "previous definition" } */ +void foo8() {} /* { dg-message "note: previous definition" } */ foo8() {} /* { dg-error "conflicting types" } */ -int use9() { foo9(); } /* { dg-warning "previous implicit declaration" } */ +int use9() { foo9(); } /* { dg-message "note: previous implicit declaration" } */ extern void foo9(); /* { dg-warning "conflicting types" } */ -int use10() { foo10(); } /* { dg-warning "previous implicit declaration" } */ +int use10() { foo10(); } /* { dg-message "note: previous implicit declaration" } */ void foo10() {} /* { dg-warning "conflicting types" } */ diff --git a/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c b/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c index 0847db28da9..c17d502d8f3 100644 --- a/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c +++ b/gcc/testsuite/gcc.dg/Wconversion-integer-no-sign.c @@ -42,8 +42,8 @@ void h (int x) uc = x ? 1U : -1; /* { dg-warning "conversion" } */ uc = x ? SCHAR_MIN : 1U; /* { dg-warning "conversion" } */ - uc = x ? 1 : -1; /* { dg-warning "conversion" } */ - uc = x ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */ + uc = x ? 1 : -1; /* Warned by -Wsign-conversion. */ + uc = x ? SCHAR_MIN : 1; /* Warned by -Wsign-conversion. */ ui = x ? 1U : -1; /* Warned by -Wsign-conversion. */ ui = x ? INT_MIN : 1U; /* Warned by -Wsign-conversion. */ ui = ui ? SCHAR_MIN : 1U; /* Warned by -Wsign-conversion. */ diff --git a/gcc/testsuite/gcc.dg/Wconversion-integer.c b/gcc/testsuite/gcc.dg/Wconversion-integer.c index 9e3b948251c..b2101076f93 100644 --- a/gcc/testsuite/gcc.dg/Wconversion-integer.c +++ b/gcc/testsuite/gcc.dg/Wconversion-integer.c @@ -44,15 +44,15 @@ void h (int x) /* { dg-warning "negative integer implicitly converted to unsigned type" "" { target *-*-* } 43 } */ uc = x ? SCHAR_MIN : 1U; /* { dg-warning "conversion" } */ /* { dg-warning "negative integer implicitly converted to unsigned type" "" { target *-*-* } 45 } */ - uc = x ? 1 : -1; /* { dg-warning "conversion" } */ - uc = x ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */ + uc = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ + uc = x ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ - ui = x ? 1 : -1; /* { dg-warning "conversion" } */ - ui = ui ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */ + ui = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ + ui = ui ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */ uc = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ diff --git a/gcc/testsuite/gcc.dg/Wcxx-compat-2.c b/gcc/testsuite/gcc.dg/Wcxx-compat-2.c index 5a46fbe4bd5..a091c6dd8b5 100644 --- a/gcc/testsuite/gcc.dg/Wcxx-compat-2.c +++ b/gcc/testsuite/gcc.dg/Wcxx-compat-2.c @@ -1,35 +1,36 @@ /* { dg-options "-Wc++-compat" } */ -int bool; -int catch; -int char16_t; -int char32_t; -int class; +_Bool foo; /* This is okay. */ +int bool; /* { dg-warning "keyword" } */ +int catch; /* { dg-warning "keyword" } */ +int char16_t; /* { dg-warning "keyword" } */ +int char32_t; /* { dg-warning "keyword" } */ +int class; /* { dg-warning "keyword" } */ int const_cast; /* { dg-warning "keyword" } */ -int decltype; -int delete; +int decltype; /* { dg-warning "keyword" } */ +int delete; /* { dg-warning "keyword" } */ int dynamic_cast; /* { dg-warning "keyword" } */ -int explicit; -int export; -int false; -int friend; +int explicit; /* { dg-warning "keyword" } */ +int export; /* { dg-warning "keyword" } */ +int false; /* { dg-warning "keyword" } */ +int friend; /* { dg-warning "keyword" } */ int mutable; /* { dg-warning "keyword" } */ -int namespace; -int new; -int operator; -int private; -int protected; -int public; +int namespace; /* { dg-warning "keyword" } */ +int new; /* { dg-warning "keyword" } */ +int operator; /* { dg-warning "keyword" } */ +int private; /* { dg-warning "keyword" } */ +int protected; /* { dg-warning "keyword" } */ +int public; /* { dg-warning "keyword" } */ int reinterpret_cast; /* { dg-warning "keyword" } */ int static_assert; /* { dg-warning "keyword" } */ int static_cast; /* { dg-warning "keyword" } */ -int template; -int this; -int throw; -int true; -int try; -int typename; -int typeid; -int using; -int virtual; +int template; /* { dg-warning "keyword" } */ +int this; /* { dg-warning "keyword" } */ +int throw; /* { dg-warning "keyword" } */ +int true; /* { dg-warning "keyword" } */ +int try; /* { dg-warning "keyword" } */ +int typename; /* { dg-warning "keyword" } */ +int typeid; /* { dg-warning "keyword" } */ +int using; /* { dg-warning "keyword" } */ +int virtual; /* { dg-warning "keyword" } */ int wchar_t; diff --git a/gcc/testsuite/gcc.dg/Wredundant-decls-2.c b/gcc/testsuite/gcc.dg/Wredundant-decls-2.c index b10840fcf95..89f57b427c6 100644 --- a/gcc/testsuite/gcc.dg/Wredundant-decls-2.c +++ b/gcc/testsuite/gcc.dg/Wredundant-decls-2.c @@ -2,21 +2,21 @@ /* { dg-do compile } */ /* { dg-options "-Wredundant-decls" } */ -int j = 5; /* { dg-warning "previous" } */ +int j = 5; /* { dg-message "note: previous" } */ int j; /* { dg-warning "redundant" } */ static int k; -static int k = 5; /* { dg-warning "previous" } */ +static int k = 5; /* { dg-message "note: previous" } */ static int k; /* { dg-warning "redundant" } */ -static int l = 5; /* { dg-warning "previous" } */ +static int l = 5; /* { dg-message "note: previous" } */ static int l; /* { dg-warning "redundant" } */ -static int m; /* { dg-warning "previous" } */ +static int m; /* { dg-message "note: previous" } */ static int m; /* { dg-warning "redundant" } */ static int m = 5; -int n; /* { dg-warning "previous" } */ +int n; /* { dg-message "note: previous" } */ int n; /* { dg-warning "redundant" } */ int n = 5; diff --git a/gcc/testsuite/gcc.dg/Wshadow-1.c b/gcc/testsuite/gcc.dg/Wshadow-1.c index 6dd2eb6791a..40073f337b4 100644 --- a/gcc/testsuite/gcc.dg/Wshadow-1.c +++ b/gcc/testsuite/gcc.dg/Wshadow-1.c @@ -10,7 +10,7 @@ void foo (double decl1) /* { dg-warning "shadows a global decl" } */ { } -void foo1 (int d) /* { dg-error "previous definition" } */ +void foo1 (int d) /* { dg-message "note: previous definition" } */ { double d; /* { dg-bogus "warning" "warning in place of error" } */ /* { dg-error "redeclared as different" "" { target *-*-* } 15 } */ diff --git a/gcc/testsuite/gcc.dg/Wsign-conversion.c b/gcc/testsuite/gcc.dg/Wsign-conversion.c index 45edd3b4361..0300850f904 100644 --- a/gcc/testsuite/gcc.dg/Wsign-conversion.c +++ b/gcc/testsuite/gcc.dg/Wsign-conversion.c @@ -42,15 +42,15 @@ void h (int x) uc = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ uc = x ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ - uc = x ? 1 : -1; - uc = x ? SCHAR_MIN : 1; + uc = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ + uc = x ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ - ui = x ? 1 : -1; /* { dg-warning "conversion" } */ - ui = ui ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */ + ui = x ? 1 : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ + ui = ui ? SCHAR_MIN : 1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */ uc = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */ diff --git a/gcc/testsuite/gcc.dg/arm-g2.c b/gcc/testsuite/gcc.dg/arm-g2.c index a15b280cc10..031b93657da 100644 --- a/gcc/testsuite/gcc.dg/arm-g2.c +++ b/gcc/testsuite/gcc.dg/arm-g2.c @@ -1,6 +1,7 @@ /* Verify that hardware multiply is preferred on XScale. */ /* { dg-do compile } */ /* { dg-options "-mcpu=xscale -O2" } */ +/* { dg-skip-if "Test is specific to the Xscale" { arm*-*-* } { "-march=*" } { "-march=xscale" } } */ /* { dg-require-effective-target arm32 } */ /* Brett Gaines' test case. */ diff --git a/gcc/testsuite/gcc.dg/arm-mmx-1.c b/gcc/testsuite/gcc.dg/arm-mmx-1.c index e4535eebefd..21cc47912c0 100644 --- a/gcc/testsuite/gcc.dg/arm-mmx-1.c +++ b/gcc/testsuite/gcc.dg/arm-mmx-1.c @@ -1,8 +1,11 @@ /* Verify that if IP is saved to ensure stack alignment, we don't load it into sp. */ /* { dg-do compile } */ +/* { dg-skip-if "Test is specific to the iWMMXt" { arm*-*-* } { "-mcpu=*" } { "-mcpu=iwmmxt" } } */ +/* { dg-skip-if "Test is specific to the iWMMXt" { arm*-*-* } { "-mabi=*" } { "-mabi=iwmmxt" } } */ +/* { dg-skip-if "Test is specific to the iWMMXt" { arm*-*-* } { "-mfloat-abi=softfp" } { "" } } */ +/* { dg-skip-if "Test is specific to the iWMMXt" { arm*-*-* } { "-march=*" } { "-march=iwmmxt" } } */ /* { dg-options "-O -mno-apcs-frame -mcpu=iwmmxt -mabi=iwmmxt" } */ -/* { dg-skip-if "" { *-*-* } { "-mfloat-abi=softfp" } { "" } } */ /* { dg-require-effective-target arm32 } */ /* { dg-final { scan-assembler "ldmfd\[ ]sp!.*ip,\[ ]*pc" } } */ diff --git a/gcc/testsuite/gcc.dg/arm-scd42-2.c b/gcc/testsuite/gcc.dg/arm-scd42-2.c index 1c257c173b6..0c372983a54 100644 --- a/gcc/testsuite/gcc.dg/arm-scd42-2.c +++ b/gcc/testsuite/gcc.dg/arm-scd42-2.c @@ -1,6 +1,7 @@ /* Verify that mov is preferred on XScale for loading a 2 byte constant. */ /* { dg-do compile } */ /* { dg-options "-mcpu=xscale -O" } */ +/* { dg-skip-if "Test is specific to the Xscale" { arm*-*-* } { "-march=*" } { "-march=xscale" } } */ /* { dg-require-effective-target arm32 } */ unsigned load2(void) __attribute__ ((naked)); diff --git a/gcc/testsuite/gcc.dg/array-5.c b/gcc/testsuite/gcc.dg/array-5.c index a4053da72a2..4083c92ffc9 100644 --- a/gcc/testsuite/gcc.dg/array-5.c +++ b/gcc/testsuite/gcc.dg/array-5.c @@ -13,7 +13,7 @@ extern char arr1[1]; char arr1[1]; extern char arr2[0]; char arr2[0]; -extern char arr3[0]; /* { dg-error "previous declaration" } */ +extern char arr3[0]; /* { dg-message "note: previous declaration" } */ char arr3[1]; /* { dg-error "conflicting types" } */ /* Variable size matches. */ diff --git a/gcc/testsuite/gcc.dg/attr-noinline.c b/gcc/testsuite/gcc.dg/attr-noinline.c index 9124e4f7688..9f7abcd07e8 100644 --- a/gcc/testsuite/gcc.dg/attr-noinline.c +++ b/gcc/testsuite/gcc.dg/attr-noinline.c @@ -13,19 +13,19 @@ static inline void __attribute__((__noinline__)) function_declaration_both_after static void function_declaration_both_after(void) {} -static void function_declaration_noinline_before(void) __attribute__((__noinline__)); /* { dg-warning "previous declaration" "" } */ +static void function_declaration_noinline_before(void) __attribute__((__noinline__)); /* { dg-message "note: previous declaration" "" } */ static inline void function_declaration_noinline_before(void) {} /* { dg-warning "follows declaration with attribute noinline" "" } */ -static inline void function_declaration_noinline_after(void) {} /* { dg-warning "previous definition" "" } */ +static inline void function_declaration_noinline_after(void) {} /* { dg-message "note: previous definition" "" } */ static void function_declaration_noinline_after(void) __attribute__((__noinline__)); /* { dg-warning "follows inline declaration" "" } */ -static inline void function_declaration_inline_before(void); /* { dg-warning "previous declaration" "" } */ +static inline void function_declaration_inline_before(void); /* { dg-message "note: previous declaration" "" } */ static void __attribute__((__noinline__)) function_declaration_inline_before(void) {} /* { dg-warning "follows inline declaration" "" } */ -static inline void function_declaration_inline_noinline_before(void); /* { dg-warning "previous declaration" "" } */ +static inline void function_declaration_inline_noinline_before(void); /* { dg-message "note: previous declaration" "" } */ static void function_declaration_inline_noinline_before(void) __attribute__((__noinline__)); /* { dg-warning "follows inline declaration" "" } */ @@ -33,11 +33,11 @@ static void function_declaration_inline_noinline_before(void) {} static inline void function_declaration_inline_noinline_after(void); -static void function_declaration_inline_noinline_after(void) {} /* { dg-warning "previous definition" "" } */ +static void function_declaration_inline_noinline_after(void) {} /* { dg-message "note: previous definition" "" } */ static void function_declaration_inline_noinline_after(void) __attribute__((__noinline__)); /* { dg-warning "follows inline declaration" "" } */ -static void function_declaration_noinline_inline_before(void) __attribute__((__noinline__)); /* { dg-warning "previous declaration" "" } */ +static void function_declaration_noinline_inline_before(void) __attribute__((__noinline__)); /* { dg-message "note: previous declaration" "" } */ static inline void function_declaration_noinline_inline_before(void); /* { dg-warning "follows declaration with attribute noinline" "" } */ diff --git a/gcc/testsuite/gcc.dg/decl-2.c b/gcc/testsuite/gcc.dg/decl-2.c index ab1532e82b9..40d744c926b 100644 --- a/gcc/testsuite/gcc.dg/decl-2.c +++ b/gcc/testsuite/gcc.dg/decl-2.c @@ -7,7 +7,7 @@ void foo(void) { char - c /* { dg-error "previous declaration" } */ + c /* { dg-message "note: previous declaration" } */ ; int i; int diff --git a/gcc/testsuite/gcc.dg/decl-3.c b/gcc/testsuite/gcc.dg/decl-3.c index 5bbe19cd224..cba0b906db3 100644 --- a/gcc/testsuite/gcc.dg/decl-3.c +++ b/gcc/testsuite/gcc.dg/decl-3.c @@ -1,5 +1,5 @@ /* PR c/9928 */ /* { dg-do compile } */ -enum { CODES }; /* { dg-error "previous definition" } */ +enum { CODES }; /* { dg-message "note: previous definition" } */ enum { CODES }; /* { dg-error "conflicting types|redeclaration of enumerator" } */ diff --git a/gcc/testsuite/gcc.dg/decl-4.c b/gcc/testsuite/gcc.dg/decl-4.c index acc7e77e2ea..ce640c99c16 100644 --- a/gcc/testsuite/gcc.dg/decl-4.c +++ b/gcc/testsuite/gcc.dg/decl-4.c @@ -1,10 +1,10 @@ /* Redeclaration of parameters is an error. PR 13728. */ /* { dg-do compile } */ -void f (int fred, /* { dg-error "previous definition" "" } */ +void f (int fred, /* { dg-message "note: previous definition" "" } */ int fred); /* { dg-error "redefinition of parameter" "" } */ -void f2 (int fred, /* { dg-error "previous definition" "" } */ +void f2 (int fred, /* { dg-message "note: previous definition" "" } */ int fred) /* { dg-error "redefinition of parameter" "" } */ { } diff --git a/gcc/testsuite/gcc.dg/decl-8.c b/gcc/testsuite/gcc.dg/decl-8.c index ba757197f53..d0da48f7b59 100644 --- a/gcc/testsuite/gcc.dg/decl-8.c +++ b/gcc/testsuite/gcc.dg/decl-8.c @@ -3,8 +3,8 @@ /* { dg-do compile } */ /* { dg-options "" } */ -typedef int I; /* { dg-error "previous declaration of 'I' was here" } */ +typedef int I; /* { dg-message "note: previous declaration of 'I' was here" } */ typedef int I; /* { dg-error "redefinition of typedef 'I'" } */ -typedef int I1; /* { dg-error "previous declaration of 'I1' was here" } */ +typedef int I1; /* { dg-message "note: previous declaration of 'I1' was here" } */ typedef long I1; /* { dg-error "conflicting types for 'I1'" } */ diff --git a/gcc/testsuite/gcc.dg/dll-2.c b/gcc/testsuite/gcc.dg/dll-2.c index 3b8b60eee41..334299f3a27 100644 --- a/gcc/testsuite/gcc.dg/dll-2.c +++ b/gcc/testsuite/gcc.dg/dll-2.c @@ -11,12 +11,12 @@ /* { dg-require-dll "" } */ __declspec (dllimport) int foo1 (); -__declspec (dllexport) int foo1 (); /* { dg-warning "previous dllimport ignored" } */ +__declspec (dllexport) int foo1 (); /* { dg-message "note: previous dllimport ignored" } */ __declspec (dllexport) int foo2 (); __declspec (dllimport) int foo2 (); /* { dg-warning "dllimport ignored" } */ __declspec (dllimport) int bar1; -__declspec (dllexport) int bar1; /* { dg-warning "previous dllimport ignored" } */ +__declspec (dllexport) int bar1; /* { dg-message "note: previous dllimport ignored" } */ __declspec (dllexport) int bar2; __declspec (dllimport) int bar2; /* { dg-warning "dllimport ignored" } */ diff --git a/gcc/testsuite/gcc.dg/dll-3.c b/gcc/testsuite/gcc.dg/dll-3.c index 0a3f7df0988..4272891a848 100644 --- a/gcc/testsuite/gcc.dg/dll-3.c +++ b/gcc/testsuite/gcc.dg/dll-3.c @@ -5,7 +5,7 @@ /* { dg-do compile { target i?86-pc-mingw* } } */ __declspec (dllimport) int foo1 (); -__declspec (dllexport) int foo1 (); /* { dg-warning "previous dllimport ignored" } */ +__declspec (dllexport) int foo1 (); /* { dg-message "note: previous dllimport ignored" } */ __declspec (dllexport) int foo2 (); __declspec (dllimport) int foo2 (); /* { dg-warning "dllimport ignored" } */ diff --git a/gcc/testsuite/gcc.dg/enum-compat-1.c b/gcc/testsuite/gcc.dg/enum-compat-1.c index 04a6e758eff..18d1f7fe715 100644 --- a/gcc/testsuite/gcc.dg/enum-compat-1.c +++ b/gcc/testsuite/gcc.dg/enum-compat-1.c @@ -25,7 +25,7 @@ enum e3 v3; enum e4 *p = &v3; /* { dg-warning "incompatible" "incompatible pointer" } */ enum e3 *q = &v3; -void g(enum e3); /* { dg-error "declaration" "error at first decl" } */ +void g(enum e3); /* { dg-message "note: previous declaration" "error at first decl" } */ void g(enum e4); /* { dg-error "conflicting types" "error at second decl" } */ void h(enum e3); diff --git a/gcc/testsuite/gcc.dg/funcdef-var-1.c b/gcc/testsuite/gcc.dg/funcdef-var-1.c index a685af7ac1c..63a56838afe 100644 --- a/gcc/testsuite/gcc.dg/funcdef-var-1.c +++ b/gcc/testsuite/gcc.dg/funcdef-var-1.c @@ -5,6 +5,6 @@ /* { dg-options "-Wmissing-prototypes" } */ extern __typeof(foo) foo __asm__(""); /* { dg-error "undeclared" } */ -/* { dg-error "previous declaration" "previous declaration" { target *-*-* } 7 } */ +/* { dg-message "note: previous declaration" "previous declaration" { target *-*-* } 7 } */ void *foo (void) {} /* { dg-error "redeclared as different kind of symbol" } */ /* { dg-warning "no previous prototype" "no previous prototype" { target *-*-* } 9 } */ diff --git a/gcc/testsuite/gcc.dg/funcdef-var-2.c b/gcc/testsuite/gcc.dg/funcdef-var-2.c index 744987ebf3b..b3eb2ce6a01 100644 --- a/gcc/testsuite/gcc.dg/funcdef-var-2.c +++ b/gcc/testsuite/gcc.dg/funcdef-var-2.c @@ -6,6 +6,6 @@ /* { dg-options "-Wmissing-prototypes" } */ int foo; -/* { dg-error "previous declaration" "previous declaration" { target *-*-* } 8 } */ +/* { dg-message "note: previous declaration" "previous declaration" { target *-*-* } 8 } */ void foo () {} /* { dg-error "redeclared as different kind of symbol" } */ /* { dg-warning "no previous prototype" "no previous prototype" { target *-*-* } 10 } */ diff --git a/gcc/testsuite/gcc.dg/hex-round-1.c b/gcc/testsuite/gcc.dg/hex-round-1.c index 3276ad46378..e1283cae37b 100644 --- a/gcc/testsuite/gcc.dg/hex-round-1.c +++ b/gcc/testsuite/gcc.dg/hex-round-1.c @@ -1,6 +1,7 @@ /* Test for hexadecimal float rounding: bug 21720. */ /* { dg-do link } */ /* { dg-options "-O -std=gnu99" } */ +/* { dg-skip-if "SPU float rounds towards zero" { spu-*-* } } */ #include <float.h> diff --git a/gcc/testsuite/gcc.dg/hex-round-2.c b/gcc/testsuite/gcc.dg/hex-round-2.c index ba9b8bf3d02..af49536abac 100644 --- a/gcc/testsuite/gcc.dg/hex-round-2.c +++ b/gcc/testsuite/gcc.dg/hex-round-2.c @@ -2,6 +2,7 @@ in number. */ /* { dg-do link } */ /* { dg-options "-O -std=gnu99" } */ +/* { dg-skip-if "SPU float rounds towards zero" { spu-*-* } } */ #include <float.h> diff --git a/gcc/testsuite/gcc.dg/inline-14.c b/gcc/testsuite/gcc.dg/inline-14.c index cef62776fbb..15b2d404c11 100644 --- a/gcc/testsuite/gcc.dg/inline-14.c +++ b/gcc/testsuite/gcc.dg/inline-14.c @@ -3,7 +3,7 @@ /* { dg-options "-std=c99" } */ extern inline int func1 (void) -{ /* { dg-error "previous definition" } */ +{ /* { dg-message "note: previous definition" } */ return 1; } @@ -13,7 +13,7 @@ inline int func1 (void) /* { dg-error "redefinition" } */ } inline int func2 (void) -{ /* { dg-error "previous definition" } */ +{ /* { dg-message "note: previous definition" } */ return 2; } diff --git a/gcc/testsuite/gcc.dg/inline1.c b/gcc/testsuite/gcc.dg/inline1.c index f7a7eb4b956..c660fe3146b 100644 --- a/gcc/testsuite/gcc.dg/inline1.c +++ b/gcc/testsuite/gcc.dg/inline1.c @@ -3,6 +3,6 @@ /* This test is expected to fail with an error for the redefinition of foo. This violates the constraint of 6.9#3 (no more than one external definition of an identifier with internal linkage in the same translation unit). */ -static inline int foo(void) { return 1; } /* { dg-error "previous definition of" } */ +static inline int foo(void) { return 1; } /* { dg-message "note: previous definition of" } */ static inline int foo(void) { return 0; } /* { dg-error "redefinition of" } */ diff --git a/gcc/testsuite/gcc.dg/inline3.c b/gcc/testsuite/gcc.dg/inline3.c index 64f6d8bbee5..d7fd8dba60c 100644 --- a/gcc/testsuite/gcc.dg/inline3.c +++ b/gcc/testsuite/gcc.dg/inline3.c @@ -3,5 +3,5 @@ /* This testcase should fail since we're redefining foo in the same translation unit. */ extern inline int foo(void) { return 0; } -inline int foo (void) { return 1; } /* { dg-error "previous definition of" } */ +inline int foo (void) { return 1; } /* { dg-message "note: previous definition of" } */ int foo (void) { return 2; } /* { dg-error "redefinition of" } */ diff --git a/gcc/testsuite/gcc.dg/inline4.c b/gcc/testsuite/gcc.dg/inline4.c index a5c7dda0a02..64cea7515ab 100644 --- a/gcc/testsuite/gcc.dg/inline4.c +++ b/gcc/testsuite/gcc.dg/inline4.c @@ -2,5 +2,5 @@ /* { dg-options "-Wall -std=gnu89" } */ /* This testcase should fail since we're redefining foo in the same translation unit. */ -int foo (void) { return 2; } /* { dg-error "previous definition of" } */ +int foo (void) { return 2; } /* { dg-message "note: previous definition of" } */ extern inline int foo (void) { return 1; } /* { dg-error "redefinition of" } */ diff --git a/gcc/testsuite/gcc.dg/inline5.c b/gcc/testsuite/gcc.dg/inline5.c index 86a2776251b..40fb7cd910b 100644 --- a/gcc/testsuite/gcc.dg/inline5.c +++ b/gcc/testsuite/gcc.dg/inline5.c @@ -2,5 +2,5 @@ /* { dg-options "-Wall -std=gnu89" } */ /* This testcase should fail since we're redefining foo in the same translation unit. */ -extern inline int foo (void) { return 2; } /* { dg-error "previous definition of" } */ +extern inline int foo (void) { return 2; } /* { dg-message "note: previous definition of" } */ extern inline int foo (void) { return 1; } /* { dg-error "redefinition of" } */ diff --git a/gcc/testsuite/gcc.dg/intmax_t-1.c b/gcc/testsuite/gcc.dg/intmax_t-1.c index 9ac0cb9f037..00b503c2509 100644 --- a/gcc/testsuite/gcc.dg/intmax_t-1.c +++ b/gcc/testsuite/gcc.dg/intmax_t-1.c @@ -1,6 +1,6 @@ /* { dg-do compile } */ /* { dg-options "-Wall" } */ -/* { dg-error "" "" { target { { *arm*-*-*elf* xtensa-*-elf* } || vxworks_kernel } } 0 } */ +/* { dg-error "" "" { target { { *arm*-*-*elf* xtensa*-*-elf* } || vxworks_kernel } } 0 } */ /* Compile with -Wall to get a warning if built-in and system intmax_t don't match. */ diff --git a/gcc/testsuite/gcc.dg/label-decl-4.c b/gcc/testsuite/gcc.dg/label-decl-4.c index 7b2a195c1b2..3cfe965fd5d 100644 --- a/gcc/testsuite/gcc.dg/label-decl-4.c +++ b/gcc/testsuite/gcc.dg/label-decl-4.c @@ -7,8 +7,8 @@ void f (void) { __label__ a, b, a; /* { dg-error "duplicate label declaration 'a'" } */ - /* { dg-error "previous declaration of 'a' was here" "previous" { target *-*-* } 9 } */ - __label__ c; /* { dg-error "previous declaration of 'c' was here" } */ + /* { dg-message "note: previous declaration of 'a' was here" "previous" { target *-*-* } 9 } */ + __label__ c; /* { dg-message "note: previous declaration of 'c' was here" } */ __label__ c; /* { dg-error "duplicate label declaration 'c'" } */ return; } diff --git a/gcc/testsuite/gcc.dg/nested-redef-1.c b/gcc/testsuite/gcc.dg/nested-redef-1.c index acc961dac23..a3786b0c302 100644 --- a/gcc/testsuite/gcc.dg/nested-redef-1.c +++ b/gcc/testsuite/gcc.dg/nested-redef-1.c @@ -36,7 +36,7 @@ enum e0 { enum e1 { E2 = sizeof(enum e2 { E2 }), /* { dg-error "redeclaration of enumerator 'E2'" } */ - /* { dg-error "previous definition" "previous E2" { target *-*-* } 38 } */ + /* { dg-message "note: previous definition" "previous E2" { target *-*-* } 38 } */ E3 }; diff --git a/gcc/testsuite/gcc.dg/noncompile/20020220-1.c b/gcc/testsuite/gcc.dg/noncompile/20020220-1.c index aa57dc3d493..3063f422c9b 100644 --- a/gcc/testsuite/gcc.dg/noncompile/20020220-1.c +++ b/gcc/testsuite/gcc.dg/noncompile/20020220-1.c @@ -6,7 +6,7 @@ int foo (const char*, const char*); void bar (void) { const char *s = "bar"; - int i; /* { dg-error "previous declaration" } */ + int i; /* { dg-message "note: previous declaration" } */ int size = 2; int i = foo (s, s + size); /* { dg-error "redeclaration of" } */ } diff --git a/gcc/testsuite/gcc.dg/noncompile/label-1.c b/gcc/testsuite/gcc.dg/noncompile/label-1.c index e9bde7b3b7b..58d212f9675 100644 --- a/gcc/testsuite/gcc.dg/noncompile/label-1.c +++ b/gcc/testsuite/gcc.dg/noncompile/label-1.c @@ -28,7 +28,7 @@ void c(void) /* can't have two labels with the same name in the same function */ void d(void) { - l: dummy(); /* { dg-error "previous definition" "prev def same scope" } */ + l: dummy(); /* { dg-message "note: previous definition" "prev def same scope" } */ l: dummy(); /* { dg-error "duplicate label" "dup label same scope" } */ goto l; } @@ -36,7 +36,7 @@ void d(void) /* even at different scopes */ void e(void) { - l: dummy(); /* { dg-error "previous definition" "prev def diff scope" } */ + l: dummy(); /* { dg-message "note: previous definition" "prev def diff scope" } */ { l: dummy(); /* { dg-error "duplicate label" "dup label diff scope" } */ } @@ -150,7 +150,7 @@ void m(void) void n(void) { - __label__ l; /* { dg-error "previous declaration" "outer label decl" } */ + __label__ l; /* { dg-message "note: previous declaration" "outer label decl" } */ void nest(void) { l: goto l; /* { dg-error "duplicate label" "inner label defn" } */ diff --git a/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c b/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c index 76d4d96edaf..6d4def7ea19 100644 --- a/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c +++ b/gcc/testsuite/gcc.dg/noncompile/label-lineno-1.c @@ -4,7 +4,7 @@ void foo(int i) { - my_label: /* { dg-error "previous definition" "prev label" } */ + my_label: /* { dg-message "note: previous definition" "prev label" } */ i++; diff --git a/gcc/testsuite/gcc.dg/noncompile/redecl-1.c b/gcc/testsuite/gcc.dg/noncompile/redecl-1.c index 416c258c0d4..732db0098db 100644 --- a/gcc/testsuite/gcc.dg/noncompile/redecl-1.c +++ b/gcc/testsuite/gcc.dg/noncompile/redecl-1.c @@ -4,6 +4,6 @@ int foo () { - int bar; /* { dg-error "previous.*decl" "previous.*decl" } */ + int bar; /* { dg-message "note: previous.*decl" "previous.*decl" } */ volatile int bar; /* { dg-error "conflicting type qualifiers" "conflicting type qualifiers" } */ } diff --git a/gcc/testsuite/gcc.dg/old-style-then-proto-1.c b/gcc/testsuite/gcc.dg/old-style-then-proto-1.c index 4d9c215a5dc..7d76287b0d1 100644 --- a/gcc/testsuite/gcc.dg/old-style-then-proto-1.c +++ b/gcc/testsuite/gcc.dg/old-style-then-proto-1.c @@ -7,38 +7,38 @@ void f1() {} void f1(void); /* { dg-warning "prototype for 'f1' follows non-prototype definition" } */ -void f2() {} /* { dg-error "previous definition of 'f2' was here" } */ +void f2() {} /* { dg-message "note: previous definition of 'f2' was here" } */ void f2(int); /* { dg-error "prototype for 'f2' declares more arguments than previous old-style definition" } */ -void f3(a) int a; {} /* { dg-error "previous definition of 'f3' was here" } */ +void f3(a) int a; {} /* { dg-message "note: previous definition of 'f3' was here" } */ void f3(void); /* { dg-error "prototype for 'f3' declares fewer arguments than previous old-style definition" } */ void f4(a) int a; {} void f4(int); /* { dg-warning "prototype for 'f4' follows non-prototype definition" } */ -void f5(a) int a; {} /* { dg-error "previous definition of 'f5' was here" } */ +void f5(a) int a; {} /* { dg-message "note: previous definition of 'f5' was here" } */ void f5(int, int); /* { dg-error "prototype for 'f5' declares more arguments than previous old-style definition" } */ -void f6(a) int a; {} /* { dg-error "previous definition of 'f6' was here" } */ +void f6(a) int a; {} /* { dg-message "note: previous definition of 'f6' was here" } */ void f6(int, ...); /* { dg-error "conflicting types for 'f6'" } */ -void f7(a, b) int a, b; {} /* { dg-error "previous definition of 'f7' was here" } */ +void f7(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f7' was here" } */ void f7(int); /* { dg-error "prototype for 'f7' declares fewer arguments than previous old-style definition" } */ -void f8(a, b) int a, b; {} /* { dg-error "previous definition of 'f8' was here" } */ +void f8(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f8' was here" } */ void f8(int, ...); /* { dg-error "conflicting types for 'f8'" } */ void f9(a, b) int a, b; {} void f9(int, int); /* { dg-warning "prototype for 'f9' follows non-prototype definition" } */ -void f10(a, b) int a, b; {} /* { dg-error "previous definition of 'f10' was here" } */ +void f10(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f10' was here" } */ void f10(int, long); /* { dg-error "prototype for 'f10' declares argument 2 with incompatible type" } */ -void f11(a, b) int a, b; {} /* { dg-error "previous definition of 'f11' was here" } */ +void f11(a, b) int a, b; {} /* { dg-message "note: previous definition of 'f11' was here" } */ void f11(long, int); /* { dg-error "prototype for 'f11' declares argument 1 with incompatible type" } */ void f12(a, b) const int a; volatile int b; {} void f12(volatile int, const int); /* { dg-warning "prototype for 'f12' follows non-prototype definition" } */ -void f13(a) const int a[2][2]; {} /* { dg-error "previous definition of 'f13' was here" } */ +void f13(a) const int a[2][2]; {} /* { dg-message "note: previous definition of 'f13' was here" } */ void f13(volatile int [2][2]); /* { dg-error "prototype for 'f13' declares argument 1 with incompatible type" } */ diff --git a/gcc/testsuite/gcc.dg/parm-mismatch-1.c b/gcc/testsuite/gcc.dg/parm-mismatch-1.c index ba8a538fb51..8f62e122b8a 100644 --- a/gcc/testsuite/gcc.dg/parm-mismatch-1.c +++ b/gcc/testsuite/gcc.dg/parm-mismatch-1.c @@ -4,15 +4,15 @@ /* { dg-do compile } */ /* { dg-options "" } */ -void f0(); /* { dg-error "previous declaration of 'f0' was here" } */ +void f0(); /* { dg-message "note: previous declaration of 'f0' was here" } */ void f0(int, ...); /* { dg-error "conflicting types for 'f0'" } */ /* { dg-message "note: a parameter list with an ellipsis can't match an empty parameter name list declaration" "note" { target *-*-* } 8 } */ -void f1(int, ...); /* { dg-error "previous declaration of 'f1' was here" } */ +void f1(int, ...); /* { dg-message "note: previous declaration of 'f1' was here" } */ void f1(); /* { dg-error "conflicting types for 'f1'" } */ /* { dg-message "note: a parameter list with an ellipsis can't match an empty parameter name list declaration" "note" { target *-*-* } 11 } */ -void f2(); /* { dg-error "previous declaration of 'f2' was here" } */ +void f2(); /* { dg-message "note: previous declaration of 'f2' was here" } */ void f2(char); /* { dg-error "conflicting types for 'f2'" } */ /* { dg-message "note: an argument type that has a default promotion can't match an empty parameter name list declaration" "note" { target *-*-* } 14 } */ -void f3(char); /* { dg-error "previous declaration of 'f3' was here" } */ +void f3(char); /* { dg-message "note: previous declaration of 'f3' was here" } */ void f3(); /* { dg-error "conflicting types for 'f3'" } */ /* { dg-message "note: an argument type that has a default promotion can't match an empty parameter name list declaration" "note" { target *-*-* } 17 } */ diff --git a/gcc/testsuite/gcc.dg/pr15360-1.c b/gcc/testsuite/gcc.dg/pr15360-1.c index 6abb2500671..4f900d7ea19 100644 --- a/gcc/testsuite/gcc.dg/pr15360-1.c +++ b/gcc/testsuite/gcc.dg/pr15360-1.c @@ -15,10 +15,10 @@ extern int b = 1; /* { dg-warning "initialized and declared" "extern init warnin static int b; static int b; -static int c; /* { dg-error "previous declaration" "" } */ +static int c; /* { dg-message "note: previous declaration" "" } */ int c; /* { dg-error "non-static" "correct error" } */ -static int d; /* { dg-error "previous declaration" "" } */ +static int d; /* { dg-message "note: previous declaration" "" } */ int d = 1; /* { dg-error "non-static" "correct error" } */ void foo (void) { extern int e = 1; } /* { dg-error "has both" "extern init in function" } */ diff --git a/gcc/testsuite/gcc.dg/pr27953.c b/gcc/testsuite/gcc.dg/pr27953.c index 7df46b1d8e1..245b59e0ba8 100644 --- a/gcc/testsuite/gcc.dg/pr27953.c +++ b/gcc/testsuite/gcc.dg/pr27953.c @@ -5,4 +5,4 @@ void foo(struct A a) {} /* { dg-warning "declared inside parameter list" } */ /* { dg-error "incomplete type" "" { target *-*-* } 3 } */ void foo() {} /* { dg-error "redefinition" } */ -/* { dg-error "previous definition" "" { target *-*-* } 3 } */ +/* { dg-message "note: previous definition" "" { target *-*-* } 3 } */ diff --git a/gcc/testsuite/gcc.dg/pr35899.c b/gcc/testsuite/gcc.dg/pr35899.c index 113cbc87a7d..4ce4ac589f1 100644 --- a/gcc/testsuite/gcc.dg/pr35899.c +++ b/gcc/testsuite/gcc.dg/pr35899.c @@ -5,7 +5,7 @@ int foo (void) { - int a = bar (); /* { dg-warning "previous implicit declaration" } */ + int a = bar (); /* { dg-message "note: previous implicit declaration" } */ return a; } diff --git a/gcc/testsuite/gcc.dg/proto-1.c b/gcc/testsuite/gcc.dg/proto-1.c index 13c59a8a54b..62d0209b08f 100644 --- a/gcc/testsuite/gcc.dg/proto-1.c +++ b/gcc/testsuite/gcc.dg/proto-1.c @@ -1,5 +1,5 @@ /* PR c/28502 */ /* { dg-do compile } */ -void foo() {} /* { dg-error "previous" } */ +void foo() {} /* { dg-message "note: previous" } */ void foo(void[]); /* { dg-error "array of voids" } */ diff --git a/gcc/testsuite/gcc.dg/qual-return-3.c b/gcc/testsuite/gcc.dg/qual-return-3.c index 7a92046da81..e65f86d547d 100644 --- a/gcc/testsuite/gcc.dg/qual-return-3.c +++ b/gcc/testsuite/gcc.dg/qual-return-3.c @@ -6,7 +6,7 @@ /* { dg-do compile } */ /* { dg-options "" } */ -int foo (); /* { dg-error "previous declaration" "different qualifiers" } */ +int foo (); /* { dg-message "note: previous declaration" "different qualifiers" } */ const int foo () { return 0; } /* { dg-error "conflicting types" "different qualifiers" } */ void bar (void); diff --git a/gcc/testsuite/gcc.dg/redecl-1.c b/gcc/testsuite/gcc.dg/redecl-1.c index 61d6e5b307a..6a7d8faecaf 100644 --- a/gcc/testsuite/gcc.dg/redecl-1.c +++ b/gcc/testsuite/gcc.dg/redecl-1.c @@ -9,8 +9,8 @@ /* Extern at function scope, clashing with extern at file scope */ -extern int foo1; /* { dg-error "previous" } */ -extern int bar1(int); /* { dg-error "previous" } */ +extern int foo1; /* { dg-message "note: previous" } */ +extern int bar1(int); /* { dg-message "note: previous" } */ void test1(void) { @@ -22,8 +22,8 @@ void test1(void) void test2(void) { - extern double foo2; /* { dg-error "previous" } */ - extern double bar2(double); /* { dg-error "previous" } */ + extern double foo2; /* { dg-message "note: previous" } */ + extern double bar2(double); /* { dg-message "note: previous" } */ } extern int foo2; /* { dg-error "conflict" } */ @@ -36,9 +36,9 @@ typedef float baz3; /* { dg-bogus } */ void prime3(void) { - extern int foo3; /* { dg-error "previous" } */ - extern int bar3(int); /* { dg-error "previous" } */ - extern int baz3; /* { dg-error "previous" } */ + extern int foo3; /* { dg-message "note: previous" } */ + extern int bar3(int); /* { dg-message "note: previous" } */ + extern int baz3; /* { dg-message "note: previous" } */ } void test3(void) @@ -58,7 +58,7 @@ void prime4(void) void test4(void) { extern double bar4(double); /* { dg-error "conflict" } */ -/* { dg-error "previous implicit declaration" "" { target *-*-* } 55 } */ +/* { dg-message "note: previous implicit declaration" "" { target *-*-* } 55 } */ } /* Implicit decl, clashing with extern at previous function scope. */ @@ -66,7 +66,7 @@ void test4(void) void prime5(void) { extern double bar5(double); /* { dg-message "note: previous declaration" "" } */ -} /* { dg-error "previous implicit declaration" "" { target *-*-* } 68 } */ +} /* { dg-message "note: previous implicit declaration" "" { target *-*-* } 68 } */ void test5(void) { @@ -75,7 +75,7 @@ void test5(void) /* Extern then static, both at file scope. */ -extern int test6(int); /* { dg-error "previous" "" } */ +extern int test6(int); /* { dg-message "note: previous" "" } */ static int test6(int x) /* { dg-error "follows non-static" } */ { return x; } @@ -84,7 +84,7 @@ static int test6(int x) /* { dg-error "follows non-static" } */ void prime7(void) { - extern int test7(int); /* { dg-error "previous" "" } */ + extern int test7(int); /* { dg-message "note: previous" "" } */ } static int test7(int x) /* { dg-error "follows non-static" } */ @@ -94,7 +94,7 @@ static int test7(int x) /* { dg-error "follows non-static" } */ void prime8(void) { - test8(); /* { dg-error "previous" "" } */ + test8(); /* { dg-message "note: previous" "" } */ /* { dg-warning "implicit" "implicit" { target *-*-* } 97 } */ } diff --git a/gcc/testsuite/gcc.dg/redecl-11.c b/gcc/testsuite/gcc.dg/redecl-11.c index e4ce0b830ea..5540e40503c 100644 --- a/gcc/testsuite/gcc.dg/redecl-11.c +++ b/gcc/testsuite/gcc.dg/redecl-11.c @@ -5,5 +5,5 @@ /* { dg-options "" } */ int f(int (*)[]); -void g() { int f(int (*)[2]); } /* { dg-error "previous declaration of 'f' was here" } */ +void g() { int f(int (*)[2]); } /* { dg-message "note: previous declaration of 'f' was here" } */ int f(int (*)[3]); /* { dg-error "conflicting types for 'f'" } */ diff --git a/gcc/testsuite/gcc.dg/redecl-12.c b/gcc/testsuite/gcc.dg/redecl-12.c index 58041ef8e35..711b8a3fcae 100644 --- a/gcc/testsuite/gcc.dg/redecl-12.c +++ b/gcc/testsuite/gcc.dg/redecl-12.c @@ -5,5 +5,5 @@ /* { dg-options "" } */ extern int a[]; -void f(void) { extern int a[]; extern int a[10]; } /* { dg-error "previous declaration of 'a' was here" } */ +void f(void) { extern int a[]; extern int a[10]; } /* { dg-message "note: previous declaration of 'a' was here" } */ extern int a[5]; /* { dg-error "conflicting types for 'a'" } */ diff --git a/gcc/testsuite/gcc.dg/redecl-13.c b/gcc/testsuite/gcc.dg/redecl-13.c index 84eeb4eaeb5..3f05d0fb168 100644 --- a/gcc/testsuite/gcc.dg/redecl-13.c +++ b/gcc/testsuite/gcc.dg/redecl-13.c @@ -5,5 +5,5 @@ /* { dg-options "" } */ extern int a[]; -void f(void) { extern int a[10]; } /* { dg-error "previous declaration of 'a' was here" } */ +void f(void) { extern int a[10]; } /* { dg-message "note: previous declaration of 'a' was here" } */ extern int a[5]; /* { dg-error "conflicting types for 'a'" } */ diff --git a/gcc/testsuite/gcc.dg/redecl-15.c b/gcc/testsuite/gcc.dg/redecl-15.c index 5ed0eac3fde..d2f48bd79b2 100644 --- a/gcc/testsuite/gcc.dg/redecl-15.c +++ b/gcc/testsuite/gcc.dg/redecl-15.c @@ -7,7 +7,7 @@ void f (void) { - g(); /* { dg-warning "previous implicit declaration of 'g' was here" } */ + g(); /* { dg-message "note: previous implicit declaration of 'g' was here" } */ { void g(); /* { dg-warning "conflicting types for 'g'" } */ } diff --git a/gcc/testsuite/gcc.dg/redecl-16.c b/gcc/testsuite/gcc.dg/redecl-16.c index 52941cb084b..560b373fb3f 100644 --- a/gcc/testsuite/gcc.dg/redecl-16.c +++ b/gcc/testsuite/gcc.dg/redecl-16.c @@ -14,5 +14,5 @@ f (void) { extern IA5P a[]; } -IAP a[] = { 0 }; /* { dg-error "previous definition" } */ +IAP a[] = { 0 }; /* { dg-message "note: previous definition" } */ extern IA10P a[]; /* { dg-error "conflicting types" } */ diff --git a/gcc/testsuite/gcc.dg/redecl-2.c b/gcc/testsuite/gcc.dg/redecl-2.c index b1b7dc929de..fa0d5e44785 100644 --- a/gcc/testsuite/gcc.dg/redecl-2.c +++ b/gcc/testsuite/gcc.dg/redecl-2.c @@ -7,56 +7,56 @@ void fa0 (void) { - int a0; /* { dg-error "previous declaration" } */ + int a0; /* { dg-message "note: previous declaration" } */ int a0; /* { dg-error "redeclaration" } */ } void fa1 (void) { - int a1; /* { dg-error "previous declaration" } */ + int a1; /* { dg-message "note: previous declaration" } */ static int a1; /* { dg-error "redeclaration" } */ } void fa2 (void) { - int a2; /* { dg-error "previous declaration" } */ + int a2; /* { dg-message "note: previous declaration" } */ extern int a2; /* { dg-error "follows declaration with no linkage" } */ } void fa3 (void) { - static int a3; /* { dg-error "previous declaration" } */ + static int a3; /* { dg-message "note: previous declaration" } */ int a3; /* { dg-error "redeclaration" } */ } void fa4 (void) { - static int a4; /* { dg-error "previous declaration" } */ + static int a4; /* { dg-message "note: previous declaration" } */ static int a4; /* { dg-error "redeclaration" } */ } void fa5 (void) { - static int a5; /* { dg-error "previous declaration" } */ + static int a5; /* { dg-message "note: previous declaration" } */ extern int a5; /* { dg-error "follows declaration with no linkage" } */ } void fa6 (void) { - extern int a6; /* { dg-error "previous declaration" } */ + extern int a6; /* { dg-message "note: previous declaration" } */ int a6; /* { dg-error "follows extern declaration" } */ } void fa7 (void) { - extern int a7; /* { dg-error "previous declaration" } */ + extern int a7; /* { dg-message "note: previous declaration" } */ static int a7; /* { dg-error "follows extern declaration" } */ } diff --git a/gcc/testsuite/gcc.dg/redecl-5.c b/gcc/testsuite/gcc.dg/redecl-5.c index a689295bb85..15b1f8c8ec4 100644 --- a/gcc/testsuite/gcc.dg/redecl-5.c +++ b/gcc/testsuite/gcc.dg/redecl-5.c @@ -7,7 +7,7 @@ void f (void) { - long z(); /* { dg-error "previous implicit declaration" } */ + long z(); /* { dg-message "note: previous implicit declaration" } */ } void diff --git a/gcc/testsuite/gcc.dg/sibcall-3.c b/gcc/testsuite/gcc.dg/sibcall-3.c index 38f3e37622d..a33d4d34502 100644 --- a/gcc/testsuite/gcc.dg/sibcall-3.c +++ b/gcc/testsuite/gcc.dg/sibcall-3.c @@ -5,7 +5,7 @@ Copyright (C) 2002 Free Software Foundation Inc. Contributed by Hans-Peter Nilsson <hp@bitrange.com> */ -/* { dg-do run { xfail arc-*-* avr-*-* cris-*-* crisv32-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa-*-* } } */ +/* { dg-do run { xfail arc-*-* avr-*-* cris-*-* crisv32-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa*-*-* } } */ /* -mlongcall disables sibcall patterns. */ /* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */ /* { dg-options "-O2 -foptimize-sibling-calls" } */ diff --git a/gcc/testsuite/gcc.dg/sibcall-4.c b/gcc/testsuite/gcc.dg/sibcall-4.c index 535efb64504..e13db6bb74f 100644 --- a/gcc/testsuite/gcc.dg/sibcall-4.c +++ b/gcc/testsuite/gcc.dg/sibcall-4.c @@ -5,7 +5,7 @@ Copyright (C) 2002 Free Software Foundation Inc. Contributed by Hans-Peter Nilsson <hp@bitrange.com> */ -/* { dg-do run { xfail arc-*-* avr-*-* cris-*-* crisv32-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa-*-* } } */ +/* { dg-do run { xfail arc-*-* avr-*-* cris-*-* crisv32-*-* h8300-*-* hppa*64*-*-* m32r-*-* m68hc1?-*-* mcore-*-* mn10300-*-* xstormy16-*-* v850*-*-* vax-*-* xtensa*-*-* } } */ /* -mlongcall disables sibcall patterns. */ /* { dg-skip-if "" { powerpc*-*-* } { "-mlongcall" } { "" } } */ /* { dg-options "-O2 -foptimize-sibling-calls" } */ diff --git a/gcc/testsuite/gcc.dg/tls/diag-3.c b/gcc/testsuite/gcc.dg/tls/diag-3.c index 45d89b43722..1a7994c69e7 100644 --- a/gcc/testsuite/gcc.dg/tls/diag-3.c +++ b/gcc/testsuite/gcc.dg/tls/diag-3.c @@ -1,10 +1,10 @@ /* Report invalid extern and __thread combinations. */ /* { dg-require-effective-target tls } */ -extern int j; /* { dg-error "previous declaration" } */ +extern int j; /* { dg-message "note: previous declaration" } */ __thread int j; /* { dg-error "follows non-thread-local" } */ -extern __thread int i; /* { dg-error "previous declaration" } */ +extern __thread int i; /* { dg-message "note: previous declaration" } */ int i; /* { dg-error "follows thread-local" } */ extern __thread int k; /* This is fine. */ diff --git a/gcc/testsuite/gcc.dg/torture/pr25183.c b/gcc/testsuite/gcc.dg/torture/pr25183.c index a6c624cf472..0157b806c7d 100644 --- a/gcc/testsuite/gcc.dg/torture/pr25183.c +++ b/gcc/testsuite/gcc.dg/torture/pr25183.c @@ -12,11 +12,11 @@ static enum err E_; int error() { switch (E_) { - case err_IO : break; /* { dg-warning "overflow" } */ - case err_NM : break; /* { dg-warning "overflow" } */ - case err_EOF : break; /* { dg-warning "overflow" } */ - case err_SE : break; /* { dg-warning "overflow" } */ - case err_PT : break; /* { dg-warning "overflow" } */ + case err_IO : break; + case err_NM : break; + case err_EOF : break; + case err_SE : break; + case err_PT : break; default : return 0; } } diff --git a/gcc/testsuite/gcc.dg/transparent-union-2.c b/gcc/testsuite/gcc.dg/transparent-union-2.c index f466c4aa2be..09fbb4d9722 100644 --- a/gcc/testsuite/gcc.dg/transparent-union-2.c +++ b/gcc/testsuite/gcc.dg/transparent-union-2.c @@ -5,14 +5,14 @@ typedef union { int *i; long *l; } U __attribute__((transparent_union)); -extern void f0 (U); /* { dg-error "previous declaration" } */ +extern void f0 (U); /* { dg-message "note: previous declaration" } */ extern void f0 (void *); /* { dg-error "conflicting types" } */ -extern void f1 (U); /* { dg-error "previous declaration" } */ +extern void f1 (U); /* { dg-message "note: previous declaration" } */ extern void f1 (unsigned long); /* { dg-error "conflicting types" } */ -extern void f2 (void *); /* { dg-error "previous declaration" } */ +extern void f2 (void *); /* { dg-message "note: previous declaration" } */ extern void f2 (U); /* { dg-error "conflicting types" } */ -extern void f3 (unsigned long); /* { dg-error "previous declaration" } */ +extern void f3 (unsigned long); /* { dg-message "note: previous declaration" } */ extern void f3 (U); /* { dg-error "conflicting types" } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c b/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c index 6103c400ecb..178e6a44822 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/reassoc-3.c @@ -1,3 +1,4 @@ +/* { dg-options "" } */ int main(int a, int b, int c, int d) { int e = (a & ~b) & (~c & d); diff --git a/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c b/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c index af628053ad5..be754145e7d 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/recip-2.c @@ -1,7 +1,9 @@ /* { dg-do compile } */ /* { dg-options "-O1 -funsafe-math-optimizations -fdump-tree-recip" } */ -float e(float a, float b, float c, float d, float e, float f) +float u, v, w, x, y, z; + +void e(float a, float b, float c, float d, float e, float f) { if (a < b) { @@ -20,7 +22,12 @@ float e(float a, float b, float c, float d, float e, float f) /* This should not be left as a multiplication. */ c = 1 / c; - return a + b + c + d + e + f; + u = a; + v = b; + w = c; + x = d; + y = e; + z = f; } /* { dg-final { scan-tree-dump-times " / " 2 "recip" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c b/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c index 60fefd01da5..b3334fb862a 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/recip-6.c @@ -5,7 +5,9 @@ extern int f2(); -double f1(double y, double z, double w) +double m, n, o; + +void f1(double y, double z, double w) { double b, c, d, e, f; @@ -18,7 +20,9 @@ double f1(double y, double z, double w) e = c / y; f = 1 / y; - return d + e + f; + m = d; + n = e; + o = f; } /* { dg-final { scan-tree-dump-times " / " 1 "recip" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c b/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c index af1bf3c008b..98bbdca6e2c 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/recip-7.c @@ -5,7 +5,9 @@ extern double h(); -double f(int x, double z, double w) +double m, n, o; + +void f(int x, double z, double w) { double b, c, d, e, f; double y = h (); @@ -19,7 +21,9 @@ double f(int x, double z, double w) e = c / y; f = 1 / y; - return d + e + f; + m = d; + n = e; + o = f; } /* { dg-final { scan-tree-dump-times " / " 1 "recip" } } */ diff --git a/gcc/testsuite/gcc.dg/var-expand3.c b/gcc/testsuite/gcc.dg/var-expand3.c index 7930ad94dec..a9d0fe917b8 100644 --- a/gcc/testsuite/gcc.dg/var-expand3.c +++ b/gcc/testsuite/gcc.dg/var-expand3.c @@ -1,5 +1,5 @@ /* { dg-do run { target { powerpc*-*-* && vmx_hw } } }} */ -/* { dg-options "-O2 -funroll-loops -ffast-math -fvariable-expansion-in-unroller -maltivec -fdump-rtl-loop2" } */ +/* { dg-options "-O2 -funroll-loops -ffast-math -fvariable-expansion-in-unroller -maltivec -fdump-rtl-loop2_unroll" } */ #include "altivec.h" extern void abort (void); diff --git a/gcc/testsuite/gcc.dg/vect/vect-112.c b/gcc/testsuite/gcc.dg/vect/vect-112.c index 4b963eb2661..0bc185b361e 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-112.c +++ b/gcc/testsuite/gcc.dg/vect/vect-112.c @@ -32,7 +32,7 @@ int main (void) return main1 (); } -/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-35.c b/gcc/testsuite/gcc.dg/vect/vect-35.c index 569907c50b2..d75308f22fe 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-35.c +++ b/gcc/testsuite/gcc.dg/vect/vect-35.c @@ -18,6 +18,8 @@ int main1 () for (i = 0; i < N; i++) { s.b[i] = 3*i; + if (i%3 == 0) + s.b[i] = 3*i; } /* Dependence analysis fails cause s.a and s.b may overlap. diff --git a/gcc/testsuite/gcc.dg/vect/vect-72.c b/gcc/testsuite/gcc.dg/vect/vect-72.c index 95bc7caede0..67a19751952 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-72.c +++ b/gcc/testsuite/gcc.dg/vect/vect-72.c @@ -18,6 +18,9 @@ int main1 () for (i=0; i < N+1; i++) { ib[i] = i; + /* Avoid vectorization. */ + if (i%3 == 0) + ib[i] = 5; } for (i = 1; i < N+1; i++) diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c index 8fd1a03db14..d7bcc9a2e8c 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c @@ -6,8 +6,7 @@ signed short in[N+M]; signed short coeff[M]; signed short out[N]; -/* Outer-loop vectorization. - Currently not vectorized because of multiple-data-types in the inner-loop. */ +/* Outer-loop vectorization. */ void foo (){ @@ -23,9 +22,5 @@ foo (){ } } -/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */ -/* FORNOW. not vectorized until we support 0-stride acceses like coeff[j]. should be: - { scan-tree-dump-not "multiple types in nested loop." "vect" { xfail *-*-* } } } */ - -/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */ +/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_widen_mult_hi_to_si && vect_pack_trunc } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c index ba2f7b4d0df..407315a8dc3 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c @@ -6,8 +6,7 @@ signed short in[N+M]; signed short coeff[M]; int out[N]; -/* Outer-loop vectorization. - Currently not vectorized because of multiple-data-types in the inner-loop. */ +/* Outer-loop vectorization. */ void foo (){ @@ -23,9 +22,5 @@ foo (){ } } -/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */ -/* FORNOW. not vectorized until we support 0-stride acceses like coeff[j]. should be: - { scan-tree-dump-not "multiple types in nested loop." "vect" { xfail *-*-* } } } */ - -/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */ +/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_widen_mult_hi_to_si } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c index cef37c42321..88d6b7abccd 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4f.c @@ -2,7 +2,7 @@ #include <stdarg.h> #include "tree-vect.h" -#define N 40 +#define N 96 #define M 128 unsigned short in[N+M]; unsigned int out[N]; diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c index cef37c42321..88d6b7abccd 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4g.c @@ -2,7 +2,7 @@ #include <stdarg.h> #include "tree-vect.h" -#define N 40 +#define N 96 #define M 128 unsigned short in[N+M]; unsigned int out[N]; diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c index bc43c5bc6d5..a244ac20ac2 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4i.c @@ -1,13 +1,17 @@ -/* { dg-do compile } */ +/* { dg-require-effective-target vect_int } */ -#define N 40 +#include <stdarg.h> +#include "tree-vect.h" + +#define N 96 #define M 128 unsigned char in[N+M]; unsigned short out[N]; /* Outer-loop vectorization. */ -/* Not vectorized due to multiple-types in the inner-loop. */ +/* Multiple-types in the inner-loop. */ +__attribute__ ((noinline)) unsigned short foo (){ int i,j; @@ -24,5 +28,22 @@ foo (){ return s; } -/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */ +int main (void) +{ + check_vect (); + int i; + unsigned short s; + + for (i = 0; i < N+M; i++) + in[i] = (unsigned char)i; + + s = foo (); + + if (s != 34048) + abort (); + + return 0; +} + +/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_unpack } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c index 7e1b7ec81ee..db8f61c5e37 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4j.c @@ -1,12 +1,11 @@ /* { dg-do compile } */ -#define N 40 +#define N 96 #define M 128 unsigned char in[N+M]; unsigned short out[N]; /* Outer-loop vectorization. */ -/* Not vectorized due to multiple-types in the inner-loop. */ void foo (){ @@ -22,5 +21,5 @@ foo (){ } } -/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */ +/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_unpack } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c index cef37c42321..88d6b7abccd 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4k.c @@ -2,7 +2,7 @@ #include <stdarg.h> #include "tree-vect.h" -#define N 40 +#define N 96 #define M 128 unsigned short in[N+M]; unsigned int out[N]; diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c index cef37c42321..88d6b7abccd 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4l.c @@ -2,7 +2,7 @@ #include <stdarg.h> #include "tree-vect.h" -#define N 40 +#define N 96 #define M 128 unsigned short in[N+M]; unsigned int out[N]; diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c index 081a5305a0d..80377bae9a4 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c +++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-s8c.c @@ -11,8 +11,7 @@ signed char X[N] __attribute__ ((__aligned__(16))); signed char Y[N] __attribute__ ((__aligned__(16))); /* char->int->int dot product. - Not detected as a dot-product pattern. - Currently fails to be vectorized due to presence of type conversions. */ + Not detected as a dot-product pattern. */ __attribute__ ((noinline)) int foo3(int len) { int i; @@ -42,6 +41,5 @@ int main (void) return 0; } -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */ - +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c index 38f8a6955ba..d8aefdad1a6 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c +++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8a.c @@ -44,6 +44,8 @@ int main (void) for (i=0; i<N; i++) { X[i] = i; Y[i] = 64-i; + if (i%5 == 0) + X[i] = i; } dot = foo (N); diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c index bfe3769008b..5496f6af920 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c +++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-dot-u8b.c @@ -39,6 +39,9 @@ int main (void) for (i=0; i<N; i++) { X[i] = i; Y[i] = 64-i; + /* Avoid vectorization. */ + if (i%100 == 0) + X[i] = i; } dot = foo (N); @@ -54,7 +57,7 @@ int main (void) targets that support accumulation into int (powerpc, ia64) we'd have: dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_udot_qi || vect_widen_mult_qi_to_hi } } */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {target vect_widen_mult_qi_to_hi} } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c index 7d8bbf38001..6effa87ebb5 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c +++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c @@ -35,6 +35,6 @@ main (void) } /* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_qi_to_si } } } */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_si } } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si || vect_unpack } } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c index b24df184896..53d5f0d5cce 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c +++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c @@ -35,6 +35,6 @@ main (void) } /* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_qi_to_si } } } */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_si } } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si && vect_unpack } } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c b/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c index dc6c6e3c400..8548d267ede 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c +++ b/gcc/testsuite/gcc.dg/vect/vect-strided-store-a-u8-i2.c @@ -24,8 +24,8 @@ main1 () { a[i] = i; b[i] = i * 2; - if (a[i] == 178) - abort(); + if (i%3 == 0) + a[i] = 10; } for (i = 0; i < N; i++) diff --git a/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c b/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c index 6052943ae07..63bd00227d7 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c +++ b/gcc/testsuite/gcc.dg/vect/vect-widen-mult-u8.c @@ -28,6 +28,8 @@ int main (void) for (i=0; i<N; i++) { X[i] = i; Y[i] = 64-i; + if (i%4 == 0) + X[i] = 5; } foo1 (N); @@ -40,6 +42,6 @@ int main (void) return 0; } -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_qi_to_hi } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c b/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c index 8307af4435a..31eb3f62054 100644 --- a/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c +++ b/gcc/testsuite/gcc.dg/vect/wrapv-vect-reduc-dot-s8b.c @@ -40,6 +40,8 @@ int main (void) for (i=0; i<N; i++) { X[i] = i; Y[i] = 64-i; + if (i%5 == 0) + X[i] = i; } dot = foo (N); @@ -57,6 +59,6 @@ int main (void) dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_sdot_qi } } */ /* In the meantime expect: */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_mult_qi_to_hi } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_mult_qi_to_hi || vect_unpack } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/visibility-7.c b/gcc/testsuite/gcc.dg/visibility-7.c index aaa8165e3e0..016f3dda6f3 100644 --- a/gcc/testsuite/gcc.dg/visibility-7.c +++ b/gcc/testsuite/gcc.dg/visibility-7.c @@ -5,7 +5,7 @@ extern int __attribute__((visibility ("hidden"))) -xyzzy; /* { dg-warning "previous declaration" "" } */ +xyzzy; /* { dg-message "note: previous declaration" "" } */ int __attribute__((visibility ("protected"))) diff --git a/gcc/testsuite/gcc.dg/wtr-static-1.c b/gcc/testsuite/gcc.dg/wtr-static-1.c index 42760e8cf6b..318b2f32ca2 100644 --- a/gcc/testsuite/gcc.dg/wtr-static-1.c +++ b/gcc/testsuite/gcc.dg/wtr-static-1.c @@ -4,7 +4,7 @@ /* { dg-do compile } */ /* { dg-options "-Wtraditional" } */ -static void testfunc1(void); /* { dg-warning "previous declaration" } */ +static void testfunc1(void); /* { dg-message "note: previous declaration" } */ void testfunc1() {} /* { dg-warning "non-static.*follows static" "non-static follows static" } */ # 11 "sys-header.h" 3 diff --git a/gcc/testsuite/gcc.target/i386/pr32000-2.c b/gcc/testsuite/gcc.target/i386/pr32000-2.c index 7230258045d..639b121dc1e 100644 --- a/gcc/testsuite/gcc.target/i386/pr32000-2.c +++ b/gcc/testsuite/gcc.target/i386/pr32000-2.c @@ -1,5 +1,5 @@ /* { dg-do run } */ -/* { dg-require-effective-target ilp32 && dfp } */ +/* { dg-skip-if "" { ! { ilp32 && dfp } } } */ /* { dg-options "-O -msse2 -std=gnu99 -mpreferred-stack-boundary=2" } */ #include "sse2-check.h" diff --git a/gcc/testsuite/gcc.target/i386/pr36992-1.c b/gcc/testsuite/gcc.target/i386/pr36992-1.c index aad6f7cd14d..7cd24cccf3e 100644 --- a/gcc/testsuite/gcc.target/i386/pr36992-1.c +++ b/gcc/testsuite/gcc.target/i386/pr36992-1.c @@ -9,4 +9,4 @@ test (__m128i b) return _mm_move_epi64 (b); } -/* { dg-final { scan-assembler-times "mov\[qd\]\[ \\t\]+.*%xmm" 1 } } */ +/* { dg-final { scan-assembler-times "movq\[ \\t\]+.*%xmm" 1 } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr36992-2.c b/gcc/testsuite/gcc.target/i386/pr36992-2.c index eb9c3a28fee..17696a5b276 100644 --- a/gcc/testsuite/gcc.target/i386/pr36992-2.c +++ b/gcc/testsuite/gcc.target/i386/pr36992-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } -/* { dg-options "-O0 -msse2" } */ +/* { dg-options "-O2 -msse4" } */ #include <emmintrin.h> @@ -9,4 +9,4 @@ test (__m128i b) return _mm_move_epi64 (b); } -/* { dg-final { scan-assembler-not "%mm" } } */ +/* { dg-final { scan-assembler-times "movq\[ \\t\]+.*%xmm" 1 } } */ diff --git a/gcc/testsuite/gcc.target/i386/regparm.c b/gcc/testsuite/gcc.target/i386/regparm.c index 7334c972d4d..9db191c7275 100644 --- a/gcc/testsuite/gcc.target/i386/regparm.c +++ b/gcc/testsuite/gcc.target/i386/regparm.c @@ -3,7 +3,7 @@ /* { dg-options "-W -Wall" } */ /* Verify that GCC correctly detects non-matching regparm attributes. */ -int __attribute__((regparm(3))) f (void); /* { dg-error "previous" } */ +int __attribute__((regparm(3))) f (void); /* { dg-message "note: previous" } */ int __attribute__((regparm(2))) f (void) { /* { dg-error "conflicting" } */ return 0; diff --git a/gcc/testsuite/gcc.target/i386/stackalign/return-3.c b/gcc/testsuite/gcc.target/i386/stackalign/return-3.c index d8ab69bbea0..8a682b8fca6 100644 --- a/gcc/testsuite/gcc.target/i386/stackalign/return-3.c +++ b/gcc/testsuite/gcc.target/i386/stackalign/return-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-require-effective-target ilp32 && dfp } */ +/* { dg-skip-if "" { ! { ilp32 && dfp } } } */ /* { dg-options "-msse -std=gnu99 -mpreferred-stack-boundary=2" } */ /* This compile only test is to detect an assertion failure in stack branch diff --git a/gcc/testsuite/gcc.target/powerpc/altivec-macros.c b/gcc/testsuite/gcc.target/powerpc/altivec-macros.c index d95a68dd966..ef497a44161 100644 --- a/gcc/testsuite/gcc.target/powerpc/altivec-macros.c +++ b/gcc/testsuite/gcc.target/powerpc/altivec-macros.c @@ -55,9 +55,9 @@ _Pragma ("__vector") /* { dg-warning "redefined" "pixel redefined" { target *-*-* } 48 } */ /* { dg-warning "redefined" "bool redefined" { target *-*-* } 49 } */ -/* { dg-warning "previous" "prev __vector defn" { target *-*-* } 24 } */ -/* { dg-warning "previous" "prev __pixel defn" { target *-*-* } 27 } */ -/* { dg-warning "previous" "prev __bool defn" { target *-*-* } 30 } */ -/* { dg-warning "previous" "prev vector defn" { target *-*-* } 33 } */ -/* { dg-warning "previous" "prev pixel defn" { target *-*-* } 36 } */ -/* { dg-warning "previous" "prev bool defn" { target *-*-* } 39 } */ +/* { dg-message "note: previous" "prev __vector defn" { target *-*-* } 24 } */ +/* { dg-message "note: previous" "prev __pixel defn" { target *-*-* } 27 } */ +/* { dg-message "note: previous" "prev __bool defn" { target *-*-* } 30 } */ +/* { dg-message "note: previous" "prev vector defn" { target *-*-* } 33 } */ +/* { dg-message "note: previous" "prev pixel defn" { target *-*-* } 36 } */ +/* { dg-message "note: previous" "prev bool defn" { target *-*-* } 39 } */ diff --git a/gcc/testsuite/gcc.target/sparc/ultrasp3.c b/gcc/testsuite/gcc.target/sparc/ultrasp3.c index 1e028add878..87025881361 100644 --- a/gcc/testsuite/gcc.target/sparc/ultrasp3.c +++ b/gcc/testsuite/gcc.target/sparc/ultrasp3.c @@ -1,5 +1,5 @@ /* { dg-do run } */ -/* { dg-require-effective-target ilp32 && ultrasparc_hw } */ +/* { dg-skip-if "" { ! { ilp32 && ultrasparc_hw } } } */ /* { dg-options "-mcpu=ultrasparc -mv8plus" } */ extern void abort (void); diff --git a/gcc/testsuite/gfortran.dg/module_md5_1.f90 b/gcc/testsuite/gfortran.dg/module_md5_1.f90 index b9bb5fa1eb6..f52426fbd00 100644 --- a/gcc/testsuite/gfortran.dg/module_md5_1.f90 +++ b/gcc/testsuite/gfortran.dg/module_md5_1.f90 @@ -10,5 +10,5 @@ program test use foo print *, pi end program test -! { dg-final { scan-module "foo" "MD5:2350094d1d87eb25ab22af5f8e96e011" } } +! { dg-final { scan-module "foo" "MD5:596df8f39d3ddc0b847771cadcb26274" } } ! { dg-final { cleanup-modules "foo" } } diff --git a/gcc/testsuite/lib/target-supports-dg.exp b/gcc/testsuite/lib/target-supports-dg.exp index 4bff5fa4424..0f8c7255b55 100644 --- a/gcc/testsuite/lib/target-supports-dg.exp +++ b/gcc/testsuite/lib/target-supports-dg.exp @@ -117,6 +117,9 @@ proc dg-require-named-sections { args } { proc dg-require-effective-target { args } { set args [lreplace $args 0 0] + if { [llength $args] != 1 } { + error "syntax error, need a single effective-target keyword" + } if { ![is-effective-target [lindex $args 0]] } { upvar dg-do-what dg-do-what set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index d82829e2058..2c9165c3c04 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -439,6 +439,14 @@ proc check_profiling_available { test_what } { return 0 } + # We don't yet support profiling for MIPS16. + if { [istarget mips*-*-*] + && ![check_effective_target_nomips16] + && ([lindex $test_what 1] == "-p" + || [lindex $test_what 1] == "-pg") } { + return 0 + } + # MinGW does not support -p. if { [istarget *-*-mingw*] && [lindex $test_what 1] == "-p" } { return 0 @@ -476,7 +484,7 @@ proc check_profiling_available { test_what } { || [istarget m68k-*-uclinux*] || [istarget mips*-*-elf*] || [istarget xstormy16-*] - || [istarget xtensa-*-elf] + || [istarget xtensa*-*-elf] || [istarget *-*-vxworks*] } { set profiling_available_saved 0 } else { @@ -1203,6 +1211,8 @@ proc check_effective_target_vect_floatint_cvt { } { } else { set et_vect_floatint_cvt_saved 0 if { [istarget i?86-*-*] + || ([istarget powerpc*-*-*] + && ![istarget powerpc-*-linux*paired*]) || [istarget x86_64-*-*] } { set et_vect_floatint_cvt_saved 1 } diff --git a/gcc/toplev.c b/gcc/toplev.c index 66a86b69e6a..fd2ca136bf4 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -1673,6 +1673,19 @@ process_options (void) This can happen with incorrect pre-processed input. */ debug_hooks = &do_nothing_debug_hooks; + /* This replaces set_Wunused. */ + if (warn_unused_function == -1) + warn_unused_function = warn_unused; + if (warn_unused_label == -1) + warn_unused_label = warn_unused; + /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */ + if (warn_unused_parameter == -1) + warn_unused_parameter = (warn_unused && extra_warnings); + if (warn_unused_variable == -1) + warn_unused_variable = warn_unused; + if (warn_unused_value == -1) + warn_unused_value = warn_unused; + /* Allow the front end to perform consistency checks and do further initialization based on the command line options. This hook also sets the original filename if appropriate (e.g. foo.i -> foo.c) diff --git a/gcc/toplev.h b/gcc/toplev.h index f1e4fe500f6..ddf46cd7f9d 100644 --- a/gcc/toplev.h +++ b/gcc/toplev.h @@ -56,18 +56,20 @@ extern void _fatal_insn (const char *, const_rtx, const char *, int, const char #endif extern void internal_error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2) ATTRIBUTE_NORETURN; -extern void warning0 (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); /* Pass one of the OPT_W* from options.h as the first parameter. */ -extern void warning (int, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); -extern void warning_at (location_t, int, const char *, ...) +extern bool warning (int, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); +extern bool warning_at (location_t, int, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4); extern void error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); extern void fatal_error (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2) ATTRIBUTE_NORETURN; -extern void pedwarn0 (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); /* Pass one of the OPT_W* from options.h as the first parameter. */ -extern void pedwarn (int, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); -extern void permerror (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); +extern bool pedwarn (int, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3); +extern bool pedwarn_at (location_t, int, const char *, ...) + ATTRIBUTE_GCC_DIAG(3,4); +extern bool permerror (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); +extern bool permerror_at (location_t, const char *, ...) + ATTRIBUTE_GCC_DIAG(2,3); extern void sorry (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); extern void inform (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); extern void verbatim (const char *, ...) ATTRIBUTE_GCC_DIAG(1,2); diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 00979bd82ab..99978efe35b 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -3810,9 +3810,17 @@ verify_stmt (gimple_stmt_iterator *gsi) didn't see a function declaration before the call. */ if (is_gimple_call (stmt)) { - tree decl = gimple_call_fn (stmt); + tree decl; - if (TREE_CODE (decl) == FUNCTION_DECL + if (!is_gimple_call_addr (gimple_call_fn (stmt))) + { + error ("invalid function in call statement"); + return true; + } + + decl = gimple_call_fndecl (stmt); + if (decl + && TREE_CODE (decl) == FUNCTION_DECL && DECL_LOOPING_CONST_OR_PURE_P (decl) && (!DECL_PURE_P (decl)) && (!TREE_READONLY (decl))) diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c index 66ea1e75840..ffac189f449 100644 --- a/gcc/tree-dump.c +++ b/gcc/tree-dump.c @@ -832,9 +832,9 @@ dump_register (const char *suffix, const char *swtch, const char *glob, static int next_dump = FIRST_AUTO_NUMBERED_DUMP; int num = next_dump++; - size_t this = extra_dump_files_in_use++; + size_t count = extra_dump_files_in_use++; - if (this >= extra_dump_files_alloced) + if (count >= extra_dump_files_alloced) { if (extra_dump_files_alloced == 0) extra_dump_files_alloced = 32; @@ -845,14 +845,14 @@ dump_register (const char *suffix, const char *swtch, const char *glob, extra_dump_files_alloced); } - memset (&extra_dump_files[this], 0, sizeof (struct dump_file_info)); - extra_dump_files[this].suffix = suffix; - extra_dump_files[this].swtch = swtch; - extra_dump_files[this].glob = glob; - extra_dump_files[this].flags = flags; - extra_dump_files[this].num = num; + memset (&extra_dump_files[count], 0, sizeof (struct dump_file_info)); + extra_dump_files[count].suffix = suffix; + extra_dump_files[count].swtch = swtch; + extra_dump_files[count].glob = glob; + extra_dump_files[count].flags = flags; + extra_dump_files[count].num = num; - return this + TDI_end; + return count + TDI_end; } diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index 140cbc54953..a8885e36d1a 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -480,18 +480,18 @@ replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf, gimple_stmt_iterator *gsi) { tree label; - gimple_seq new; + gimple_seq new_seq; treemple temp; temp.tp = tp; - new = find_goto_replacement (tf, temp); - if (!new) + new_seq = find_goto_replacement (tf, temp); + if (!new_seq) return; - if (gimple_seq_singleton_p (new) - && gimple_code (gimple_seq_first_stmt (new)) == GIMPLE_GOTO) + if (gimple_seq_singleton_p (new_seq) + && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO) { - *tp = gimple_goto_dest (gimple_seq_first_stmt (new)); + *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq)); return; } @@ -500,7 +500,7 @@ replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf, *tp = label; gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING); - gsi_insert_seq_after (gsi, gimple_seq_copy (new), GSI_CONTINUE_LINKING); + gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING); } /* The real work of replace_goto_queue. Returns with TSI updated to @@ -1665,15 +1665,15 @@ lower_catch (struct leh_state *state, gimple tp) { struct eh_region *catch_region; tree eh_label; - gimple x, catch; + gimple x, gcatch; - catch = gsi_stmt (gsi); + gcatch = gsi_stmt (gsi); catch_region = gen_eh_region_catch (try_region, - gimple_catch_types (catch)); + gimple_catch_types (gcatch)); this_state.cur_region = catch_region; this_state.prev_try = state->prev_try; - lower_eh_constructs_1 (&this_state, gimple_catch_handler (catch)); + lower_eh_constructs_1 (&this_state, gimple_catch_handler (gcatch)); eh_label = create_artificial_label (); set_eh_region_tree_label (catch_region, eh_label); @@ -1681,16 +1681,16 @@ lower_catch (struct leh_state *state, gimple tp) x = gimple_build_label (eh_label); gsi_insert_before (&gsi, x, GSI_SAME_STMT); - if (gimple_seq_may_fallthru (gimple_catch_handler (catch))) + if (gimple_seq_may_fallthru (gimple_catch_handler (gcatch))) { if (!out_label) out_label = create_artificial_label (); x = gimple_build_goto (out_label); - gimple_seq_add_stmt (gimple_catch_handler_ptr (catch), x); + gimple_seq_add_stmt (gimple_catch_handler_ptr (gcatch), x); } - gsi_insert_seq_before (&gsi, gimple_catch_handler (catch), + gsi_insert_seq_before (&gsi, gimple_catch_handler (gcatch), GSI_SAME_STMT); gsi_remove (&gsi, false); } diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index a10586128e8..ef9e75c88c6 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -154,7 +154,7 @@ insert_decl_map (copy_body_data *id, tree key, tree value) static tree remap_ssa_name (tree name, copy_body_data *id) { - tree new; + tree new_tree; tree *n; gcc_assert (TREE_CODE (name) == SSA_NAME); @@ -165,7 +165,7 @@ remap_ssa_name (tree name, copy_body_data *id) /* Do not set DEF_STMT yet as statement is not copied yet. We do that in copy_bb. */ - new = remap_decl (SSA_NAME_VAR (name), id); + new_tree = remap_decl (SSA_NAME_VAR (name), id); /* We might've substituted constant or another SSA_NAME for the variable. @@ -173,15 +173,15 @@ remap_ssa_name (tree name, copy_body_data *id) Replace the SSA name representing RESULT_DECL by variable during inlining: this saves us from need to introduce PHI node in a case return value is just partly initialized. */ - if ((TREE_CODE (new) == VAR_DECL || TREE_CODE (new) == PARM_DECL) + if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL) && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL || !id->transform_return_to_modify)) { - new = make_ssa_name (new, NULL); - insert_decl_map (id, name, new); - SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new) + new_tree = make_ssa_name (new_tree, NULL); + insert_decl_map (id, name, new_tree); + SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree) = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name); - TREE_TYPE (new) = TREE_TYPE (SSA_NAME_VAR (new)); + TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree)); if (gimple_nop_p (SSA_NAME_DEF_STMT (name))) { /* By inlining function having uninitialized variable, we might @@ -202,24 +202,24 @@ remap_ssa_name (tree name, copy_body_data *id) gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb); gimple init_stmt; - init_stmt = gimple_build_assign (new, - fold_convert (TREE_TYPE (new), + init_stmt = gimple_build_assign (new_tree, + fold_convert (TREE_TYPE (new_tree), integer_zero_node)); gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT); - SSA_NAME_IS_DEFAULT_DEF (new) = 0; + SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0; } else { - SSA_NAME_DEF_STMT (new) = gimple_build_nop (); + SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop (); if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) == name) - set_default_def (SSA_NAME_VAR (new), new); + set_default_def (SSA_NAME_VAR (new_tree), new_tree); } } } else - insert_decl_map (id, name, new); - return new; + insert_decl_map (id, name, new_tree); + return new_tree; } /* Remap DECL during the copying of the BLOCK tree for the function. */ @@ -295,31 +295,31 @@ remap_decl (tree decl, copy_body_data *id) static tree remap_type_1 (tree type, copy_body_data *id) { - tree new, t; + tree new_tree, t; /* We do need a copy. build and register it now. If this is a pointer or reference type, remap the designated type and make a new pointer or reference type. */ if (TREE_CODE (type) == POINTER_TYPE) { - new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id), + new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id), TYPE_MODE (type), TYPE_REF_CAN_ALIAS_ALL (type)); - insert_decl_map (id, type, new); - return new; + insert_decl_map (id, type, new_tree); + return new_tree; } else if (TREE_CODE (type) == REFERENCE_TYPE) { - new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id), + new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id), TYPE_MODE (type), TYPE_REF_CAN_ALIAS_ALL (type)); - insert_decl_map (id, type, new); - return new; + insert_decl_map (id, type, new_tree); + return new_tree; } else - new = copy_node (type); + new_tree = copy_node (type); - insert_decl_map (id, type, new); + insert_decl_map (id, type, new_tree); /* This is a new type, not a copy of an old type. Need to reassociate variants. We can handle everything except the main variant lazily. */ @@ -327,47 +327,47 @@ remap_type_1 (tree type, copy_body_data *id) if (type != t) { t = remap_type (t, id); - TYPE_MAIN_VARIANT (new) = t; - TYPE_NEXT_VARIANT (new) = TYPE_NEXT_VARIANT (t); - TYPE_NEXT_VARIANT (t) = new; + TYPE_MAIN_VARIANT (new_tree) = t; + TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t); + TYPE_NEXT_VARIANT (t) = new_tree; } else { - TYPE_MAIN_VARIANT (new) = new; - TYPE_NEXT_VARIANT (new) = NULL; + TYPE_MAIN_VARIANT (new_tree) = new_tree; + TYPE_NEXT_VARIANT (new_tree) = NULL; } if (TYPE_STUB_DECL (type)) - TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type), id); + TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id); /* Lazily create pointer and reference types. */ - TYPE_POINTER_TO (new) = NULL; - TYPE_REFERENCE_TO (new) = NULL; + TYPE_POINTER_TO (new_tree) = NULL; + TYPE_REFERENCE_TO (new_tree) = NULL; - switch (TREE_CODE (new)) + switch (TREE_CODE (new_tree)) { case INTEGER_TYPE: case REAL_TYPE: case FIXED_POINT_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: - t = TYPE_MIN_VALUE (new); + t = TYPE_MIN_VALUE (new_tree); if (t && TREE_CODE (t) != INTEGER_CST) - walk_tree (&TYPE_MIN_VALUE (new), copy_tree_body_r, id, NULL); + walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL); - t = TYPE_MAX_VALUE (new); + t = TYPE_MAX_VALUE (new_tree); if (t && TREE_CODE (t) != INTEGER_CST) - walk_tree (&TYPE_MAX_VALUE (new), copy_tree_body_r, id, NULL); - return new; + walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL); + return new_tree; case FUNCTION_TYPE: - TREE_TYPE (new) = remap_type (TREE_TYPE (new), id); - walk_tree (&TYPE_ARG_TYPES (new), copy_tree_body_r, id, NULL); - return new; + TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id); + walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL); + return new_tree; case ARRAY_TYPE: - TREE_TYPE (new) = remap_type (TREE_TYPE (new), id); - TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id); + TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id); + TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id); break; case RECORD_TYPE: @@ -376,14 +376,14 @@ remap_type_1 (tree type, copy_body_data *id) { tree f, nf = NULL; - for (f = TYPE_FIELDS (new); f ; f = TREE_CHAIN (f)) + for (f = TYPE_FIELDS (new_tree); f ; f = TREE_CHAIN (f)) { t = remap_decl (f, id); - DECL_CONTEXT (t) = new; + DECL_CONTEXT (t) = new_tree; TREE_CHAIN (t) = nf; nf = t; } - TYPE_FIELDS (new) = nreverse (nf); + TYPE_FIELDS (new_tree) = nreverse (nf); } break; @@ -393,10 +393,10 @@ remap_type_1 (tree type, copy_body_data *id) gcc_unreachable (); } - walk_tree (&TYPE_SIZE (new), copy_tree_body_r, id, NULL); - walk_tree (&TYPE_SIZE_UNIT (new), copy_tree_body_r, id, NULL); + walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL); + walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL); - return new; + return new_tree; } tree @@ -504,28 +504,28 @@ static tree remap_blocks (tree block, copy_body_data *id) { tree t; - tree new = block; + tree new_tree = block; if (!block) return NULL; - remap_block (&new, id); - gcc_assert (new != block); + remap_block (&new_tree, id); + gcc_assert (new_tree != block); for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t)) - add_lexical_block (new, remap_blocks (t, id)); - return new; + add_lexical_block (new_tree, remap_blocks (t, id)); + return new_tree; } static void copy_statement_list (tree *tp) { tree_stmt_iterator oi, ni; - tree new; + tree new_tree; - new = alloc_stmt_list (); - ni = tsi_start (new); + new_tree = alloc_stmt_list (); + ni = tsi_start (new_tree); oi = tsi_start (*tp); - *tp = new; + *tp = new_tree; for (; !tsi_end_p (oi); tsi_next (&oi)) tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT); @@ -679,7 +679,7 @@ remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data) n = (tree *) pointer_map_contains (id->decl_map, decl); if (n) { - tree type, new, old; + tree type, new_tree, old; /* If we happen to get an ADDR_EXPR in n->value, strip it manually here as we'll eventually get ADDR_EXPRs @@ -689,23 +689,23 @@ remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data) fold_indirect_ref does other useful transformations, try that first, though. */ type = TREE_TYPE (TREE_TYPE (*n)); - new = unshare_expr (*n); + new_tree = unshare_expr (*n); old = *tp; - *tp = gimple_fold_indirect_ref (new); + *tp = gimple_fold_indirect_ref (new_tree); if (!*tp) { - if (TREE_CODE (new) == ADDR_EXPR) + if (TREE_CODE (new_tree) == ADDR_EXPR) { - *tp = fold_indirect_ref_1 (type, new); + *tp = fold_indirect_ref_1 (type, new_tree); /* ??? We should either assert here or build a VIEW_CONVERT_EXPR instead of blindly leaking incompatible types to our IL. */ if (! *tp) - *tp = TREE_OPERAND (new, 0); + *tp = TREE_OPERAND (new_tree, 0); } else { - *tp = build1 (INDIRECT_REF, type, new); + *tp = build1 (INDIRECT_REF, type, new_tree); TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); } } @@ -908,7 +908,7 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) n = (tree *) pointer_map_contains (id->decl_map, decl); if (n) { - tree new; + tree new_tree; tree old; /* If we happen to get an ADDR_EXPR in n->value, strip it manually here as we'll eventually get ADDR_EXPRs @@ -917,23 +917,23 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) but we absolutely rely on that. As fold_indirect_ref does other useful transformations, try that first, though. */ tree type = TREE_TYPE (TREE_TYPE (*n)); - new = unshare_expr (*n); + new_tree = unshare_expr (*n); old = *tp; - *tp = gimple_fold_indirect_ref (new); + *tp = gimple_fold_indirect_ref (new_tree); if (! *tp) { - if (TREE_CODE (new) == ADDR_EXPR) + if (TREE_CODE (new_tree) == ADDR_EXPR) { - *tp = fold_indirect_ref_1 (type, new); + *tp = fold_indirect_ref_1 (type, new_tree); /* ??? We should either assert here or build a VIEW_CONVERT_EXPR instead of blindly leaking incompatible types to our IL. */ if (! *tp) - *tp = TREE_OPERAND (new, 0); + *tp = TREE_OPERAND (new_tree, 0); } else { - *tp = build1 (INDIRECT_REF, type, new); + *tp = build1 (INDIRECT_REF, type, new_tree); TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old); } @@ -1260,10 +1260,9 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, /* With return slot optimization we can end up with non-gimple (foo *)&this->m, fix that here. */ - if ((is_gimple_assign (stmt) - && gimple_assign_rhs_code (stmt) == NOP_EXPR - && !is_gimple_val (gimple_assign_rhs1 (stmt))) - || id->regimplify) + if (is_gimple_assign (stmt) + && gimple_assign_rhs_code (stmt) == NOP_EXPR + && !is_gimple_val (gimple_assign_rhs1 (stmt))) { tree new_rhs; new_rhs = force_gimple_operand_gsi (©_gsi, @@ -1547,7 +1546,7 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) FOR_EACH_EDGE (old_edge, ei, bb->succs) if (!(old_edge->flags & EDGE_EH)) { - edge new; + edge new_edge; flags = old_edge->flags; @@ -1555,9 +1554,9 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags && old_edge->dest->aux != EXIT_BLOCK_PTR) flags |= EDGE_FALLTHRU; - new = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags); - new->count = old_edge->count * count_scale / REG_BR_PROB_BASE; - new->probability = old_edge->probability; + new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags); + new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE; + new_edge->probability = old_edge->probability; } if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK) @@ -1795,9 +1794,9 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, /* Use aux pointers to map the original blocks to copy. */ FOR_EACH_BB_FN (bb, cfun_to_copy) { - basic_block new = copy_bb (id, bb, frequency_scale, count_scale); - bb->aux = new; - new->aux = bb; + basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale); + bb->aux = new_bb; + new_bb->aux = bb; } last = last_basic_block; @@ -3554,18 +3553,18 @@ 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 = NULL_TREE, new; + tree chain = NULL_TREE, new_tree; chain = TREE_CHAIN (*tp); /* Copy the node. */ - new = copy_node (*tp); + new_tree = copy_node (*tp); /* Propagate mudflap marked-ness. */ if (flag_mudflap && mf_marked_p (*tp)) - mf_mark (new); + mf_mark (new_tree); - *tp = new; + *tp = new_tree; /* Now, restore the chain, if appropriate. That will cause walk_tree to walk into the chain as well. */ @@ -3583,17 +3582,17 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) { /* CONSTRUCTOR nodes need special handling because we need to duplicate the vector of elements. */ - tree new; + tree new_tree; - new = copy_node (*tp); + new_tree = copy_node (*tp); /* Propagate mudflap marked-ness. */ if (flag_mudflap && mf_marked_p (*tp)) - mf_mark (new); + mf_mark (new_tree); - CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc, + CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (*tp)); - *tp = new; + *tp = new_tree; } else if (TREE_CODE_CLASS (code) == tcc_type) *walk_subtrees = 0; @@ -4093,10 +4092,10 @@ copy_arguments_for_versioning (tree orig_parm, copy_body_data * id) arg_copy = &orig_parm; for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg)) { - tree new = remap_decl (*parg, id); - lang_hooks.dup_lang_specific_decl (new); - TREE_CHAIN (new) = TREE_CHAIN (*parg); - *parg = new; + tree new_tree = remap_decl (*parg, id); + lang_hooks.dup_lang_specific_decl (new_tree); + TREE_CHAIN (new_tree) = TREE_CHAIN (*parg); + *parg = new_tree; } return orig_parm; } @@ -4110,10 +4109,10 @@ copy_static_chain (tree static_chain, copy_body_data * id) chain_copy = &static_chain; for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar)) { - tree new = remap_decl (*pvar, id); - lang_hooks.dup_lang_specific_decl (new); - TREE_CHAIN (new) = TREE_CHAIN (*pvar); - *pvar = new; + tree new_tree = remap_decl (*pvar, id); + lang_hooks.dup_lang_specific_decl (new_tree); + TREE_CHAIN (new_tree) = TREE_CHAIN (*pvar); + *pvar = new_tree; } return static_chain; } diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c index fb61731893a..f0c55905060 100644 --- a/gcc/tree-into-ssa.c +++ b/gcc/tree-into-ssa.c @@ -638,15 +638,15 @@ repl_map_free (void *p) } -/* Return the names replaced by NEW (i.e., REPL_TBL[NEW].SET). */ +/* Return the names replaced by NEW_TREE (i.e., REPL_TBL[NEW_TREE].SET). */ static inline bitmap -names_replaced_by (tree new) +names_replaced_by (tree new_tree) { struct repl_map_d m; void **slot; - m.name = new; + m.name = new_tree; slot = htab_find_slot (repl_tbl, (void *) &m, NO_INSERT); /* If N was not registered in the replacement table, return NULL. */ @@ -657,20 +657,20 @@ names_replaced_by (tree new) } -/* Add OLD to REPL_TBL[NEW].SET. */ +/* Add OLD to REPL_TBL[NEW_TREE].SET. */ static inline void -add_to_repl_tbl (tree new, tree old) +add_to_repl_tbl (tree new_tree, tree old) { struct repl_map_d m, *mp; void **slot; - m.name = new; + m.name = new_tree; slot = htab_find_slot (repl_tbl, (void *) &m, INSERT); if (*slot == NULL) { mp = XNEW (struct repl_map_d); - mp->name = new; + mp->name = new_tree; mp->set = BITMAP_ALLOC (NULL); *slot = (void *) mp; } @@ -681,23 +681,23 @@ add_to_repl_tbl (tree new, tree old) } -/* Add a new mapping NEW -> OLD REPL_TBL. Every entry N_i in REPL_TBL +/* Add a new mapping NEW_TREE -> OLD REPL_TBL. Every entry N_i in REPL_TBL represents the set of names O_1 ... O_j replaced by N_i. This is used by update_ssa and its helpers to introduce new SSA names in an already formed SSA web. */ static void -add_new_name_mapping (tree new, tree old) +add_new_name_mapping (tree new_tree, tree old) { timevar_push (TV_TREE_SSA_INCREMENTAL); - /* OLD and NEW must be different SSA names for the same symbol. */ - gcc_assert (new != old && SSA_NAME_VAR (new) == SSA_NAME_VAR (old)); + /* OLD and NEW_TREE must be different SSA names for the same symbol. */ + gcc_assert (new_tree != old && SSA_NAME_VAR (new_tree) == SSA_NAME_VAR (old)); /* If this mapping is for virtual names, we will need to update virtual operands. If this is a mapping for .MEM, then we gather the symbols associated with each name. */ - if (!is_gimple_reg (new)) + if (!is_gimple_reg (new_tree)) { tree sym; @@ -712,7 +712,7 @@ add_new_name_mapping (tree new, tree old) will make more sense to rename the symbols from scratch. Otherwise, the insertion of PHI nodes for each of the old names in these mappings will be very slow. */ - sym = SSA_NAME_VAR (new); + sym = SSA_NAME_VAR (new_tree); bitmap_set_bit (update_ssa_stats.virtual_symbols, DECL_UID (sym)); } @@ -726,16 +726,16 @@ add_new_name_mapping (tree new, tree old) } /* Update the REPL_TBL table. */ - add_to_repl_tbl (new, old); + add_to_repl_tbl (new_tree, old); /* If OLD had already been registered as a new name, then all the - names that OLD replaces should also be replaced by NEW. */ + names that OLD replaces should also be replaced by NEW_TREE. */ if (is_new_name (old)) - bitmap_ior_into (names_replaced_by (new), names_replaced_by (old)); + bitmap_ior_into (names_replaced_by (new_tree), names_replaced_by (old)); - /* Register NEW and OLD in NEW_SSA_NAMES and OLD_SSA_NAMES, + /* Register NEW_TREE and OLD in NEW_SSA_NAMES and OLD_SSA_NAMES, respectively. */ - SET_BIT (new_ssa_names, SSA_NAME_VERSION (new)); + SET_BIT (new_ssa_names, SSA_NAME_VERSION (new_tree)); SET_BIT (old_ssa_names, SSA_NAME_VERSION (old)); /* Update mapping counter to use in the virtual mapping heuristic. */ @@ -2757,12 +2757,12 @@ create_new_def_for (tree old_name, gimple stmt, def_operand_p def) update_ssa. */ void -register_new_name_mapping (tree new ATTRIBUTE_UNUSED, tree old ATTRIBUTE_UNUSED) +register_new_name_mapping (tree new_Tree ATTRIBUTE_UNUSED, tree old ATTRIBUTE_UNUSED) { if (need_to_initialize_update_ssa_p) init_update_ssa (); - add_new_name_mapping (new, old); + add_new_name_mapping (new_Tree, old); } diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c index 7d15077073b..3f77b2cb1f6 100644 --- a/gcc/tree-mudflap.c +++ b/gcc/tree-mudflap.c @@ -897,7 +897,7 @@ mf_xform_derefs (void) basic_block bb, next; gimple_stmt_iterator i; int saved_last_basic_block = last_basic_block; - enum gimple_rhs_class class; + enum gimple_rhs_class grhs_class; bb = ENTRY_BLOCK_PTR ->next_bb; do @@ -915,8 +915,8 @@ mf_xform_derefs (void) gimple_location (s), integer_one_node); mf_xform_derefs_1 (&i, gimple_assign_rhs1_ptr (s), gimple_location (s), integer_zero_node); - class = get_gimple_rhs_class (gimple_assign_rhs_code (s)); - if (class == GIMPLE_BINARY_RHS) + grhs_class = get_gimple_rhs_class (gimple_assign_rhs_code (s)); + if (grhs_class == GIMPLE_BINARY_RHS) mf_xform_derefs_1 (&i, gimple_assign_rhs2_ptr (s), gimple_location (s), integer_zero_node); break; diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c index 8f4ab047ae9..cfa1dd4b1ee 100644 --- a/gcc/tree-nested.c +++ b/gcc/tree-nested.c @@ -363,8 +363,7 @@ init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi, { tree t; - t = create_tmp_var_for (info, TREE_TYPE (TREE_TYPE (gimple_call_fn (call))), - NULL); + t = create_tmp_var_for (info, gimple_call_return_type (call), NULL); gimple_call_set_lhs (call, t); if (! gsi_end_p (*gsi)) gimple_set_location (call, gimple_location (gsi_stmt (*gsi))); @@ -1851,8 +1850,8 @@ convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p, switch (gimple_code (stmt)) { case GIMPLE_CALL: - decl = gimple_call_fn (stmt); - if (TREE_CODE (decl) != FUNCTION_DECL) + decl = gimple_call_fndecl (stmt); + if (!decl) break; target_context = decl_function_context (decl); if (target_context && !DECL_NO_STATIC_CHAIN (decl)) diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c index 94245a4678b..e26149fd1b4 100644 --- a/gcc/tree-predcom.c +++ b/gcc/tree-predcom.c @@ -267,7 +267,7 @@ typedef struct chain /* For combination chains, the operator and the two chains that are combined, and the type of the result. */ - enum tree_code operator; + enum tree_code op; tree rslt_type; struct chain *ch1, *ch2; @@ -409,7 +409,7 @@ dump_chain (FILE *file, chain_p chain) if (chain->type == CT_COMBINATION) { fprintf (file, " equal to %p %s %p in type ", - (void *) chain->ch1, op_symbol_code (chain->operator), + (void *) chain->ch1, op_symbol_code (chain->op), (void *) chain->ch2); print_generic_expr (file, chain->rslt_type, TDF_SLIM); fprintf (file, "\n"); @@ -1224,12 +1224,12 @@ determine_roots (struct loop *loop, } /* Replace the reference in statement STMT with temporary variable - NEW. If SET is true, NEW is instead initialized to the value of + NEW_TREE. If SET is true, NEW_TREE is instead initialized to the value of the reference in the statement. IN_LHS is true if the reference is in the lhs of STMT, false if it is in rhs. */ static void -replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs) +replace_ref_with (gimple stmt, tree new_tree, bool set, bool in_lhs) { tree val; gimple new_stmt; @@ -1245,7 +1245,7 @@ replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs) remove_phi_node (&psi, false); /* Turn the phi node into GIMPLE_ASSIGN. */ - new_stmt = gimple_build_assign (val, new); + new_stmt = gimple_build_assign (val, new_tree); gsi_insert_before (&bsi, new_stmt, GSI_NEW_STMT); return; } @@ -1256,11 +1256,11 @@ replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs) bsi = gsi_for_stmt (stmt); - /* If we do not need to initialize NEW, just replace the use of OLD. */ + /* If we do not need to initialize NEW_TREE, just replace the use of OLD. */ if (!set) { gcc_assert (!in_lhs); - gimple_assign_set_rhs_from_tree (&bsi, new); + gimple_assign_set_rhs_from_tree (&bsi, new_tree); stmt = gsi_stmt (bsi); update_stmt (stmt); return; @@ -1306,7 +1306,7 @@ replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs) val = gimple_assign_lhs (stmt); } - new_stmt = gimple_build_assign (new, unshare_expr (val)); + new_stmt = gimple_build_assign (new_tree, unshare_expr (val)); gsi_insert_after (&bsi, new_stmt, GSI_NEW_STMT); } @@ -1406,7 +1406,7 @@ get_init_expr (chain_p chain, unsigned index) tree e1 = get_init_expr (chain->ch1, index); tree e2 = get_init_expr (chain->ch2, index); - return fold_build2 (chain->operator, chain->rslt_type, e1, e2); + return fold_build2 (chain->op, chain->rslt_type, e1, e2); } else return VEC_index (tree, chain->inits, index); @@ -2347,7 +2347,7 @@ combine_chains (chain_p ch1, chain_p ch2) new_chain = XCNEW (struct chain); new_chain->type = CT_COMBINATION; - new_chain->operator = op; + new_chain->op = op; new_chain->ch1 = ch1; new_chain->ch2 = ch2; new_chain->rslt_type = rslt_type; diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index df055f84fe7..5708eedf3b2 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -519,7 +519,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, case BOOLEAN_TYPE: { unsigned int quals = TYPE_QUALS (node); - enum tree_code_class class; + enum tree_code_class tclass; if (quals & TYPE_QUAL_CONST) pp_string (buffer, "const "); @@ -528,16 +528,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, else if (quals & TYPE_QUAL_RESTRICT) pp_string (buffer, "restrict "); - class = TREE_CODE_CLASS (TREE_CODE (node)); + tclass = TREE_CODE_CLASS (TREE_CODE (node)); - if (class == tcc_declaration) + if (tclass == tcc_declaration) { if (DECL_NAME (node)) dump_decl_name (buffer, node, flags); else pp_string (buffer, "<unnamed type decl>"); } - else if (class == tcc_type) + else if (tclass == tcc_type) { if (TYPE_NAME (node)) { diff --git a/gcc/tree-ssa-alias-warnings.c b/gcc/tree-ssa-alias-warnings.c index 67d7f94ea3d..5bae978187a 100644 --- a/gcc/tree-ssa-alias-warnings.c +++ b/gcc/tree-ssa-alias-warnings.c @@ -889,6 +889,10 @@ nonstandard_alias_p (tree ptr, tree alias, bool ptr_ptr) tree ptr_type = get_otype (ptr, true); tree alias_type = get_otype (alias, ptr_ptr); + /* If this is a ref-all pointer the access is ok. */ + if (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (ptr))) + return false; + /* XXX: for now, say it's OK if the alias escapes. Not sure this is needed in general, but otherwise GCC will not bootstrap. */ diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index b867bba08d5..ff8af4f14dd 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -528,17 +528,10 @@ likely_value (gimple stmt) && !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)) return VARYING; - /* A GIMPLE_CALL is assumed to be varying. NOTE: This may be overly - conservative, in the presence of const and pure calls. */ - if (code == GIMPLE_CALL) - return VARYING; - /* Note that only a GIMPLE_SINGLE_RHS assignment can satisfy is_gimple_min_invariant, so we do not consider calls or other forms of assignment. */ - if (code == GIMPLE_ASSIGN - && (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) - == GIMPLE_SINGLE_RHS) + if (gimple_assign_single_p (stmt) && is_gimple_min_invariant (gimple_assign_rhs1 (stmt))) return CONSTANT; @@ -630,15 +623,23 @@ surely_varying_stmt_p (gimple stmt) return true; } - /* If it contains a call, it is varying. */ + /* If it is a call and does not return a value or is not a + builtin and not an indirect call, it is varying. */ if (is_gimple_call (stmt)) - return true; + { + tree fndecl; + if (!gimple_call_lhs (stmt) + || ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE + && !DECL_BUILT_IN (fndecl))) + return true; + } /* Anything other than assignments and conditional jumps are not interesting for CCP. */ if (gimple_code (stmt) != GIMPLE_ASSIGN - && (gimple_code (stmt) != GIMPLE_COND) - && (gimple_code (stmt) != GIMPLE_SWITCH)) + && gimple_code (stmt) != GIMPLE_COND + && gimple_code (stmt) != GIMPLE_SWITCH + && gimple_code (stmt) != GIMPLE_CALL) return true; return false; @@ -987,18 +988,26 @@ ccp_fold (gimple stmt) useless_type_conversion_p places for pointer type conversions do not apply here. Substitution later will only substitute to allowed places. */ - if ((subcode == NOP_EXPR || subcode == CONVERT_EXPR) - && ((POINTER_TYPE_P (TREE_TYPE (lhs)) - && POINTER_TYPE_P (TREE_TYPE (op0)) - /* Do not allow differences in volatile qualification - as this might get us confused as to whether a - propagation destination statement is volatile - or not. See PR36988. */ - && (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (lhs))) - == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op0))))) - || useless_type_conversion_p (TREE_TYPE (lhs), - TREE_TYPE (op0)))) - return op0; + if (IS_CONVERT_EXPR_CODE_P (subcode) + && POINTER_TYPE_P (TREE_TYPE (lhs)) + && POINTER_TYPE_P (TREE_TYPE (op0)) + /* Do not allow differences in volatile qualification + as this might get us confused as to whether a + propagation destination statement is volatile + or not. See PR36988. */ + && (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (lhs))) + == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op0))))) + { + tree tem; + /* Still try to generate a constant of correct type. */ + if (!useless_type_conversion_p (TREE_TYPE (lhs), + TREE_TYPE (op0)) + && ((tem = maybe_fold_offset_to_address + (op0, integer_zero_node, TREE_TYPE (lhs))) + != NULL_TREE)) + return tem; + return op0; + } return fold_unary (subcode, gimple_expr_type (stmt), op0); } @@ -1024,6 +1033,18 @@ ccp_fold (gimple stmt) op1 = val->value; } + /* Fold &foo + CST into an invariant reference if possible. */ + if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR + && TREE_CODE (op0) == ADDR_EXPR + && TREE_CODE (op1) == INTEGER_CST) + { + tree lhs = gimple_assign_lhs (stmt); + tree tem = maybe_fold_offset_to_address (op0, op1, + TREE_TYPE (lhs)); + if (tem != NULL_TREE) + return tem; + } + return fold_binary (subcode, gimple_expr_type (stmt), op0, op1); } @@ -1034,11 +1055,42 @@ ccp_fold (gimple stmt) break; case GIMPLE_CALL: - /* It may be possible to fold away calls to builtin functions if - their arguments are constants. At present, such folding will not - be attempted, as likely_value classifies all calls as VARYING. */ - gcc_unreachable (); - break; + { + tree fn = gimple_call_fn (stmt); + prop_value_t *val; + + if (TREE_CODE (fn) == SSA_NAME) + { + val = get_value (fn); + if (val->lattice_val == CONSTANT) + fn = val->value; + } + if (TREE_CODE (fn) == ADDR_EXPR + && DECL_BUILT_IN (TREE_OPERAND (fn, 0))) + { + tree *args = XALLOCAVEC (tree, gimple_call_num_args (stmt)); + tree call, retval; + unsigned i; + for (i = 0; i < gimple_call_num_args (stmt); ++i) + { + args[i] = gimple_call_arg (stmt, i); + if (TREE_CODE (args[i]) == SSA_NAME) + { + val = get_value (args[i]); + if (val->lattice_val == CONSTANT) + args[i] = val->value; + } + } + call = build_call_array (gimple_call_return_type (stmt), + fn, gimple_call_num_args (stmt), args); + retval = fold_call_expr (call, false); + if (retval) + /* fold_call_expr wraps the result inside a NOP_EXPR. */ + STRIP_NOPS (retval); + return retval; + } + return NULL_TREE; + } case GIMPLE_COND: { @@ -1916,15 +1968,15 @@ maybe_fold_offset_to_reference (tree base, tree offset, tree orig_type) so it needs to be removed and new COMPONENT_REF constructed. The wrong COMPONENT_REF are often constructed by folding the (type *)&object within the expression (type *)&object+offset */ - if (handled_component_p (base) && 0) + if (handled_component_p (base)) { HOST_WIDE_INT sub_offset, size, maxsize; tree newbase; newbase = get_ref_base_and_extent (base, &sub_offset, &size, &maxsize); gcc_assert (newbase); - gcc_assert (!(sub_offset & (BITS_PER_UNIT - 1))); - if (size == maxsize) + if (size == maxsize + && !(sub_offset & (BITS_PER_UNIT - 1))) { base = newbase; if (sub_offset) @@ -1956,6 +2008,63 @@ maybe_fold_offset_to_reference (tree base, tree offset, tree orig_type) return ret; } +/* Attempt to express (ORIG_TYPE)&BASE+OFFSET as &BASE->field_of_orig_type + or &BASE[index] or by combination of those. + + Before attempting the conversion strip off existing component refs. */ + +tree +maybe_fold_offset_to_address (tree addr, tree offset, tree orig_type) +{ + tree t; + + gcc_assert (POINTER_TYPE_P (TREE_TYPE (addr)) + && POINTER_TYPE_P (orig_type)); + + t = maybe_fold_offset_to_reference (addr, offset, TREE_TYPE (orig_type)); + if (t != NULL_TREE) + { + tree orig = addr; + tree ptr_type; + + /* For __builtin_object_size to function correctly we need to + make sure not to fold address arithmetic so that we change + reference from one array to another. This would happen for + example for + + struct X { char s1[10]; char s2[10] } s; + char *foo (void) { return &s.s2[-4]; } + + where we need to avoid generating &s.s1[6]. As the C and + C++ frontends create different initial trees + (char *) &s.s1 + -4 vs. &s.s1[-4] we have to do some + sophisticated comparisons here. Note that checking for the + condition after the fact is easier than trying to avoid doing + the folding. */ + STRIP_NOPS (orig); + if (TREE_CODE (orig) == ADDR_EXPR) + orig = TREE_OPERAND (orig, 0); + if ((TREE_CODE (orig) == ARRAY_REF + || (TREE_CODE (orig) == COMPONENT_REF + && TREE_CODE (TREE_TYPE (TREE_OPERAND (orig, 1))) == ARRAY_TYPE)) + && (TREE_CODE (t) == ARRAY_REF + || (TREE_CODE (t) == COMPONENT_REF + && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 1))) == ARRAY_TYPE)) + && !operand_equal_p (TREE_CODE (orig) == ARRAY_REF + ? TREE_OPERAND (orig, 0) : orig, + TREE_CODE (t) == ARRAY_REF + ? TREE_OPERAND (t, 0) : t, 0)) + return NULL_TREE; + + ptr_type = build_pointer_type (TREE_TYPE (t)); + if (!useless_type_conversion_p (orig_type, ptr_type)) + return NULL_TREE; + return build_fold_addr_expr_with_type (t, ptr_type); + } + + return NULL_TREE; +} + /* A subroutine of fold_stmt_r. Attempt to simplify *(BASE+OFFSET). Return the simplified expression, or NULL if nothing could be done. */ @@ -2191,16 +2300,10 @@ fold_stmt_r (tree *expr_p, int *walk_subtrees, void *data) if (POINTER_TYPE_P (TREE_TYPE (expr)) && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))) - && (t = maybe_fold_offset_to_reference - (TREE_OPERAND (expr, 0), - integer_zero_node, - TREE_TYPE (TREE_TYPE (expr))))) - { - tree ptr_type = build_pointer_type (TREE_TYPE (t)); - if (!useless_type_conversion_p (TREE_TYPE (expr), ptr_type)) - return NULL_TREE; - t = build_fold_addr_expr_with_type (t, ptr_type); - } + && (t = maybe_fold_offset_to_address (TREE_OPERAND (expr, 0), + integer_zero_node, + TREE_TYPE (TREE_TYPE (expr))))) + return t; break; /* ??? Could handle more ARRAY_REFs here, as a variant of INDIRECT_REF. @@ -2683,15 +2786,10 @@ fold_gimple_assign (gimple_stmt_iterator *si) && POINTER_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt)))) { tree type = gimple_expr_type (stmt); - tree t = maybe_fold_offset_to_reference (gimple_assign_rhs1 (stmt), - integer_zero_node, - TREE_TYPE (type)); + tree t = maybe_fold_offset_to_address (gimple_assign_rhs1 (stmt), + integer_zero_node, type); if (t) - { - tree ptr_type = build_pointer_type (TREE_TYPE (t)); - if (useless_type_conversion_p (type, ptr_type)) - return build_fold_addr_expr_with_type (t, ptr_type); - } + return t; } break; diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c index 1d0605e68b5..1eedf7544af 100644 --- a/gcc/tree-ssa-loop-niter.c +++ b/gcc/tree-ssa-loop-niter.c @@ -2034,7 +2034,6 @@ static tree get_val_for (tree x, tree base) { gimple stmt; - tree nx, val, retval, rhs1, rhs2; gcc_assert (is_gimple_min_invariant (base)); @@ -2050,33 +2049,30 @@ get_val_for (tree x, tree base) /* STMT must be either an assignment of a single SSA name or an expression involving an SSA name and a constant. Try to fold that expression using the value for the SSA name. */ - rhs1 = gimple_assign_rhs1 (stmt); - rhs2 = gimple_assign_rhs2 (stmt); - if (TREE_CODE (rhs1) == SSA_NAME) - nx = rhs1; - else if (rhs2 && TREE_CODE (rhs2) == SSA_NAME) - nx = rhs2; - else - gcc_unreachable (); - - /* NX is now the SSA name for which we want to discover the base value. */ - val = get_val_for (nx, base); - if (rhs2) - { - /* If this is a binary expression, fold it. If folding is - not possible, return a tree expression with the RHS of STMT. */ - rhs1 = (nx == rhs1) ? val : rhs1; - rhs2 = (nx == rhs2) ? val : rhs2; - retval = fold_binary (gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), rhs1, rhs2); - if (retval == NULL_TREE) - retval= build2 (gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), rhs1, rhs2); + if (gimple_assign_ssa_name_copy_p (stmt)) + return get_val_for (gimple_assign_rhs1 (stmt), base); + else if (gimple_assign_rhs_class (stmt) == GIMPLE_UNARY_RHS + && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME) + { + return fold_build1 (gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), + get_val_for (gimple_assign_rhs1 (stmt), base)); + } + else if (gimple_assign_rhs_class (stmt) == GIMPLE_BINARY_RHS) + { + tree rhs1 = gimple_assign_rhs1 (stmt); + tree rhs2 = gimple_assign_rhs2 (stmt); + if (TREE_CODE (rhs1) == SSA_NAME) + rhs1 = get_val_for (rhs1, base); + else if (TREE_CODE (rhs2) == SSA_NAME) + rhs2 = get_val_for (rhs2, base); + else + gcc_unreachable (); + return fold_build2 (gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), rhs1, rhs2); } else - retval = val; - - return retval; + gcc_unreachable (); } @@ -2918,6 +2914,12 @@ stmt_dominates_stmt_p (gimple s1, gimple s2) { gimple_stmt_iterator bsi; + if (gimple_code (s2) == GIMPLE_PHI) + return false; + + if (gimple_code (s1) == GIMPLE_PHI) + return true; + for (bsi = gsi_start_bb (bb1); gsi_stmt (bsi) != s2; gsi_next (&bsi)) if (gsi_stmt (bsi) == s1) return true; diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index dfc00bcdd12..844ec9d1ad0 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -533,7 +533,7 @@ execute_cse_reciprocals (void) if (!fndecl) continue; - gimple_call_set_fn (stmt1, fndecl); + gimple_call_set_fndecl (stmt1, fndecl); update_stmt (stmt1); gimple_assign_set_rhs_code (stmt, MULT_EXPR); @@ -840,7 +840,7 @@ execute_convert_to_rsqrt (void) fold_stmt_inplace (stmt1); update_stmt (stmt1); - gimple_call_set_fn (stmt, fndecl); + gimple_call_set_fndecl (stmt, fndecl); update_stmt (stmt); } } diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 336c54ec700..9e8ff56495e 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -2436,7 +2436,7 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref, { case CALL_EXPR: { - tree folded; + tree folded, sc = currop->op1; unsigned int nargs = 0; tree *args = XNEWVEC (tree, VEC_length (vn_reference_op_s, ref->operands) - 1); @@ -2453,6 +2453,14 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref, : currop->op0, nargs, args); free (args); + if (sc) + { + pre_expr scexpr = get_or_alloc_expr_for (sc); + sc = find_or_generate_expression (block, scexpr, stmts, domstmt); + if (!sc) + return NULL_TREE; + CALL_EXPR_STATIC_CHAIN (folded) = sc; + } return folded; } break; diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index a3facd8baa1..be68331faf2 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -727,6 +727,415 @@ eliminate_using_constants (enum tree_code opcode, } } + +static void linearize_expr_tree (VEC(operand_entry_t, heap) **, gimple, + bool, bool); + +/* Structure for tracking and counting operands. */ +typedef struct oecount_s { + int cnt; + enum tree_code oecode; + tree op; +} oecount; + +DEF_VEC_O(oecount); +DEF_VEC_ALLOC_O(oecount,heap); + +/* The heap for the oecount hashtable and the sorted list of operands. */ +static VEC (oecount, heap) *cvec; + +/* Hash function for oecount. */ + +static hashval_t +oecount_hash (const void *p) +{ + const oecount *c = VEC_index (oecount, cvec, (size_t)p - 42); + return htab_hash_pointer (c->op) ^ (hashval_t)c->oecode; +} + +/* Comparison function for oecount. */ + +static int +oecount_eq (const void *p1, const void *p2) +{ + const oecount *c1 = VEC_index (oecount, cvec, (size_t)p1 - 42); + const oecount *c2 = VEC_index (oecount, cvec, (size_t)p2 - 42); + return (c1->oecode == c2->oecode + && c1->op == c2->op); +} + +/* Comparison function for qsort sorting oecount elements by count. */ + +static int +oecount_cmp (const void *p1, const void *p2) +{ + const oecount *c1 = (const oecount *)p1; + const oecount *c2 = (const oecount *)p2; + return c1->cnt - c2->cnt; +} + +/* Walks the linear chain with result *DEF searching for an operation + with operand OP and code OPCODE removing that from the chain. *DEF + is updated if there is only one operand but no operation left. */ + +static void +zero_one_operation (tree *def, enum tree_code opcode, tree op) +{ + gimple stmt = SSA_NAME_DEF_STMT (*def); + + do + { + tree name = gimple_assign_rhs1 (stmt); + + /* If this is the operation we look for and one of the operands + is ours simply propagate the other operand into the stmts + single use. */ + if (gimple_assign_rhs_code (stmt) == opcode + && (name == op + || gimple_assign_rhs2 (stmt) == op)) + { + gimple use_stmt; + use_operand_p use; + gimple_stmt_iterator gsi; + if (name == op) + name = gimple_assign_rhs2 (stmt); + gcc_assert (has_single_use (gimple_assign_lhs (stmt))); + single_imm_use (gimple_assign_lhs (stmt), &use, &use_stmt); + if (gimple_assign_lhs (stmt) == *def) + *def = name; + SET_USE (use, name); + if (TREE_CODE (name) != SSA_NAME) + update_stmt (use_stmt); + gsi = gsi_for_stmt (stmt); + gsi_remove (&gsi, true); + release_defs (stmt); + return; + } + + /* Continue walking the chain. */ + gcc_assert (name != op + && TREE_CODE (name) == SSA_NAME); + stmt = SSA_NAME_DEF_STMT (name); + } + while (1); +} + +/* Builds one statement performing OP1 OPCODE OP2 using TMPVAR for + the result. Places the statement after the definition of either + OP1 or OP2. Returns the new statement. */ + +static gimple +build_and_add_sum (tree tmpvar, tree op1, tree op2, enum tree_code opcode) +{ + gimple op1def = NULL, op2def = NULL; + gimple_stmt_iterator gsi; + tree op; + gimple sum; + + /* Create the addition statement. */ + sum = gimple_build_assign_with_ops (opcode, tmpvar, op1, op2); + op = make_ssa_name (tmpvar, sum); + gimple_assign_set_lhs (sum, op); + + /* Find an insertion place and insert. */ + if (TREE_CODE (op1) == SSA_NAME) + op1def = SSA_NAME_DEF_STMT (op1); + if (TREE_CODE (op2) == SSA_NAME) + op2def = SSA_NAME_DEF_STMT (op2); + if ((!op1def || gimple_nop_p (op1def)) + && (!op2def || gimple_nop_p (op2def))) + { + gsi = gsi_start_bb (single_succ (ENTRY_BLOCK_PTR)); + gsi_insert_before (&gsi, sum, GSI_NEW_STMT); + } + else if ((!op1def || gimple_nop_p (op1def)) + || (op2def && !gimple_nop_p (op2def) + && stmt_dominates_stmt_p (op1def, op2def))) + { + if (gimple_code (op2def) == GIMPLE_PHI) + { + gsi = gsi_start_bb (gimple_bb (op2def)); + gsi_insert_before (&gsi, sum, GSI_NEW_STMT); + } + else + { + gsi = gsi_for_stmt (op2def); + gsi_insert_after (&gsi, sum, GSI_NEW_STMT); + } + } + else + { + if (gimple_code (op1def) == GIMPLE_PHI) + { + gsi = gsi_start_bb (gimple_bb (op1def)); + gsi_insert_before (&gsi, sum, GSI_NEW_STMT); + } + else + { + gsi = gsi_for_stmt (op1def); + gsi_insert_after (&gsi, sum, GSI_NEW_STMT); + } + } + update_stmt (sum); + + return sum; +} + +/* Perform un-distribution of divisions and multiplications. + A * X + B * X is transformed into (A + B) * X and A / X + B / X + to (A + B) / X for real X. + + The algorithm is organized as follows. + + - First we walk the addition chain *OPS looking for summands that + are defined by a multiplication or a real division. This results + in the candidates bitmap with relevant indices into *OPS. + + - Second we build the chains of multiplications or divisions for + these candidates, counting the number of occurences of (operand, code) + pairs in all of the candidates chains. + + - Third we sort the (operand, code) pairs by number of occurence and + process them starting with the pair with the most uses. + + * For each such pair we walk the candidates again to build a + second candidate bitmap noting all multiplication/division chains + that have at least one occurence of (operand, code). + + * We build an alternate addition chain only covering these + candidates with one (operand, code) operation removed from their + multiplication/division chain. + + * The first candidate gets replaced by the alternate addition chain + multiplied/divided by the operand. + + * All candidate chains get disabled for further processing and + processing of (operand, code) pairs continues. + + The alternate addition chains built are re-processed by the main + reassociation algorithm which allows optimizing a * x * y + b * y * x + to (a + b ) * x * y in one invocation of the reassociation pass. */ + +static bool +undistribute_ops_list (enum tree_code opcode, + VEC (operand_entry_t, heap) **ops, struct loop *loop) +{ + unsigned int length = VEC_length (operand_entry_t, *ops); + operand_entry_t oe1; + unsigned i, j; + sbitmap candidates, candidates2; + unsigned nr_candidates, nr_candidates2; + sbitmap_iterator sbi0; + VEC (operand_entry_t, heap) **subops; + htab_t ctable; + bool changed = false; + + if (length <= 1 + || opcode != PLUS_EXPR) + return false; + + /* Build a list of candidates to process. */ + candidates = sbitmap_alloc (length); + sbitmap_zero (candidates); + nr_candidates = 0; + for (i = 0; VEC_iterate (operand_entry_t, *ops, i, oe1); ++i) + { + enum tree_code dcode; + gimple oe1def; + + if (TREE_CODE (oe1->op) != SSA_NAME) + continue; + oe1def = SSA_NAME_DEF_STMT (oe1->op); + if (!is_gimple_assign (oe1def)) + continue; + dcode = gimple_assign_rhs_code (oe1def); + if ((dcode != MULT_EXPR + && dcode != RDIV_EXPR) + || !is_reassociable_op (oe1def, dcode, loop)) + continue; + + SET_BIT (candidates, i); + nr_candidates++; + } + + if (nr_candidates < 2) + { + sbitmap_free (candidates); + return false; + } + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "searching for un-distribute opportunities "); + print_generic_expr (dump_file, + VEC_index (operand_entry_t, *ops, + sbitmap_first_set_bit (candidates))->op, 0); + fprintf (dump_file, " %d\n", nr_candidates); + } + + /* Build linearized sub-operand lists and the counting table. */ + cvec = NULL; + ctable = htab_create (15, oecount_hash, oecount_eq, NULL); + subops = XCNEWVEC (VEC (operand_entry_t, heap) *, + VEC_length (operand_entry_t, *ops)); + EXECUTE_IF_SET_IN_SBITMAP (candidates, 0, i, sbi0) + { + gimple oedef; + enum tree_code oecode; + unsigned j; + + oedef = SSA_NAME_DEF_STMT (VEC_index (operand_entry_t, *ops, i)->op); + oecode = gimple_assign_rhs_code (oedef); + linearize_expr_tree (&subops[i], oedef, + associative_tree_code (oecode), false); + + for (j = 0; VEC_iterate (operand_entry_t, subops[i], j, oe1); ++j) + { + oecount c; + void **slot; + size_t idx; + c.oecode = oecode; + c.cnt = 1; + c.op = oe1->op; + VEC_safe_push (oecount, heap, cvec, &c); + idx = VEC_length (oecount, cvec) + 41; + slot = htab_find_slot (ctable, (void *)idx, INSERT); + if (!*slot) + { + *slot = (void *)idx; + } + else + { + VEC_pop (oecount, cvec); + VEC_index (oecount, cvec, (size_t)*slot - 42)->cnt++; + } + } + } + htab_delete (ctable); + + /* Sort the counting table. */ + qsort (VEC_address (oecount, cvec), VEC_length (oecount, cvec), + sizeof (oecount), oecount_cmp); + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + oecount *c; + fprintf (dump_file, "Candidates:\n"); + for (j = 0; VEC_iterate (oecount, cvec, j, c); ++j) + { + fprintf (dump_file, " %u %s: ", c->cnt, + c->oecode == MULT_EXPR + ? "*" : c->oecode == RDIV_EXPR ? "/" : "?"); + print_generic_expr (dump_file, c->op, 0); + fprintf (dump_file, "\n"); + } + } + + /* Process the (operand, code) pairs in order of most occurence. */ + candidates2 = sbitmap_alloc (length); + while (!VEC_empty (oecount, cvec)) + { + oecount *c = VEC_last (oecount, cvec); + if (c->cnt < 2) + break; + + /* Now collect the operands in the outer chain that contain + the common operand in their inner chain. */ + sbitmap_zero (candidates2); + nr_candidates2 = 0; + EXECUTE_IF_SET_IN_SBITMAP (candidates, 0, i, sbi0) + { + gimple oedef; + enum tree_code oecode; + unsigned j; + tree op = VEC_index (operand_entry_t, *ops, i)->op; + + /* If we undistributed in this chain already this may be + a constant. */ + if (TREE_CODE (op) != SSA_NAME) + continue; + + oedef = SSA_NAME_DEF_STMT (op); + oecode = gimple_assign_rhs_code (oedef); + if (oecode != c->oecode) + continue; + + for (j = 0; VEC_iterate (operand_entry_t, subops[i], j, oe1); ++j) + { + if (oe1->op == c->op) + { + SET_BIT (candidates2, i); + ++nr_candidates2; + break; + } + } + } + + if (nr_candidates2 >= 2) + { + operand_entry_t oe1, oe2; + tree tmpvar; + gimple prod; + int first = sbitmap_first_set_bit (candidates2); + + /* Build the new addition chain. */ + oe1 = VEC_index (operand_entry_t, *ops, first); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Building ("); + print_generic_expr (dump_file, oe1->op, 0); + } + tmpvar = create_tmp_var (TREE_TYPE (oe1->op), NULL); + add_referenced_var (tmpvar); + zero_one_operation (&oe1->op, c->oecode, c->op); + EXECUTE_IF_SET_IN_SBITMAP (candidates2, first+1, i, sbi0) + { + gimple sum; + oe2 = VEC_index (operand_entry_t, *ops, i); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, " + "); + print_generic_expr (dump_file, oe2->op, 0); + } + zero_one_operation (&oe2->op, c->oecode, c->op); + sum = build_and_add_sum (tmpvar, oe1->op, oe2->op, opcode); + oe2->op = fold_convert (TREE_TYPE (oe2->op), integer_zero_node); + oe2->rank = 0; + oe1->op = gimple_get_lhs (sum); + } + + /* Apply the multiplication/division. */ + prod = build_and_add_sum (tmpvar, oe1->op, c->op, c->oecode); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, ") %s ", c->oecode == MULT_EXPR ? "*" : "/"); + print_generic_expr (dump_file, c->op, 0); + fprintf (dump_file, "\n"); + } + + /* Record it in the addition chain and disable further + undistribution with this op. */ + oe1->op = gimple_assign_lhs (prod); + oe1->rank = get_rank (oe1->op); + VEC_free (operand_entry_t, heap, subops[first]); + + changed = true; + } + + VEC_pop (oecount, cvec); + } + + for (i = 0; i < VEC_length (operand_entry_t, *ops); ++i) + VEC_free (operand_entry_t, heap, subops[i]); + free (subops); + VEC_free (oecount, heap, cvec); + sbitmap_free (candidates); + sbitmap_free (candidates2); + + return changed; +} + + /* Perform various identities and other optimizations on the list of operand entries, stored in OPS. The tree code for the binary operation between all the operands is OPCODE. */ @@ -1097,7 +1506,8 @@ should_break_up_subtract (gimple stmt) if (TREE_CODE (lhs) == SSA_NAME && (immusestmt = get_single_immediate_use (lhs)) && is_gimple_assign (immusestmt) - && gimple_assign_rhs_code (immusestmt) == PLUS_EXPR) + && (gimple_assign_rhs_code (immusestmt) == PLUS_EXPR + || gimple_assign_rhs_code (immusestmt) == MULT_EXPR)) return true; return false; } @@ -1125,7 +1535,8 @@ break_up_subtract (gimple stmt, gimple_stmt_iterator *gsip) Place the operands of the expression tree in the vector named OPS. */ static void -linearize_expr_tree (VEC(operand_entry_t, heap) **ops, gimple stmt) +linearize_expr_tree (VEC(operand_entry_t, heap) **ops, gimple stmt, + bool is_associative, bool set_visited) { gimple_stmt_iterator gsinow, gsilhs; tree binlhs = gimple_assign_rhs1 (stmt); @@ -1136,7 +1547,8 @@ linearize_expr_tree (VEC(operand_entry_t, heap) **ops, gimple stmt) enum tree_code rhscode = gimple_assign_rhs_code (stmt); struct loop *loop = loop_containing_stmt (stmt); - gimple_set_visited (stmt, true); + if (set_visited) + gimple_set_visited (stmt, true); if (TREE_CODE (binlhs) == SSA_NAME) { @@ -1160,6 +1572,13 @@ linearize_expr_tree (VEC(operand_entry_t, heap) **ops, gimple stmt) { tree temp; + /* If this is not a associative operation like division, give up. */ + if (!is_associative) + { + add_to_ops_vec (ops, binrhs); + return; + } + if (!binrhsisreassoc) { add_to_ops_vec (ops, binrhs); @@ -1203,7 +1622,8 @@ linearize_expr_tree (VEC(operand_entry_t, heap) **ops, gimple stmt) gsinow = gsi_for_stmt (stmt); gsilhs = gsi_for_stmt (SSA_NAME_DEF_STMT (binlhs)); gsi_move_before (&gsilhs, &gsinow); - linearize_expr_tree (ops, SSA_NAME_DEF_STMT (binlhs)); + linearize_expr_tree (ops, SSA_NAME_DEF_STMT (binlhs), + is_associative, set_visited); add_to_ops_vec (ops, binrhs); } @@ -1344,7 +1764,16 @@ reassociate_bb (basic_block bb) /* If this was part of an already processed statement, we don't need to touch it again. */ if (gimple_visited_p (stmt)) - continue; + { + /* This statement might have become dead because of previous + reassociations. */ + if (has_zero_uses (gimple_get_lhs (stmt))) + { + gsi_remove (&gsi, true); + release_defs (stmt); + } + continue; + } lhs = gimple_assign_lhs (stmt); rhs1 = gimple_assign_rhs1 (stmt); @@ -1375,12 +1804,21 @@ reassociate_bb (basic_block bb) continue; gimple_set_visited (stmt, true); - linearize_expr_tree (&ops, stmt); + linearize_expr_tree (&ops, stmt, true, true); qsort (VEC_address (operand_entry_t, ops), VEC_length (operand_entry_t, ops), sizeof (operand_entry_t), sort_by_operand_rank); optimize_ops_list (rhs_code, &ops); + if (undistribute_ops_list (rhs_code, &ops, + loop_containing_stmt (stmt))) + { + qsort (VEC_address (operand_entry_t, ops), + VEC_length (operand_entry_t, ops), + sizeof (operand_entry_t), + sort_by_operand_rank); + optimize_ops_list (rhs_code, &ops); + } if (VEC_length (operand_entry_t, ops) == 1) { diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index f6492bdafd8..f502440b46f 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -686,12 +686,12 @@ copy_reference_ops_from_call (gimple call, vn_reference_op_s temp; unsigned i; - /* Copy the call_expr opcode, type, function being called, and - arguments. */ + /* Copy the type, opcode, function being called and static chain. */ memset (&temp, 0, sizeof (temp)); temp.type = gimple_call_return_type (call); temp.opcode = CALL_EXPR; temp.op0 = gimple_call_fn (call); + temp.op1 = gimple_call_chain (call); VEC_safe_push (vn_reference_op_s, heap, *result, &temp); /* Copy the call arguments. As they can be references as well, @@ -701,7 +701,6 @@ copy_reference_ops_from_call (gimple call, tree callarg = gimple_call_arg (call, i); copy_reference_ops_from_ref (callarg, result); } - return; } /* Create a vector of vn_reference_op_s structures from REF, a diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 6fb9bdd9168..4198498800b 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -4346,8 +4346,8 @@ create_variable_info_for (tree decl, const char *name) { unsigned int index = VEC_length (varinfo_t, varmap); varinfo_t vi; - tree decltype = TREE_TYPE (decl); - tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decltype); + tree decl_type = TREE_TYPE (decl); + tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decl_type); bool is_global = DECL_P (decl) ? is_global_var (decl) : false; VEC (fieldoff_s,heap) *fieldstack = NULL; @@ -4355,7 +4355,7 @@ create_variable_info_for (tree decl, const char *name) return create_function_info_for (decl, name); if (var_can_have_subvars (decl) && use_field_sensitive) - push_fields_onto_fieldstack (decltype, &fieldstack, 0); + push_fields_onto_fieldstack (decl_type, &fieldstack, 0); /* If the variable doesn't have subvars, we may end up needing to sort the field list and create fake variables for all the diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index c308a359dd5..74968bf5539 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -1414,20 +1414,23 @@ warn_uninit (tree t, const char *gmsgid, void *data) location = (context != NULL && gimple_has_location (context)) ? gimple_location (context) : DECL_SOURCE_LOCATION (var); - warning_at (location, OPT_Wuninitialized, gmsgid, var); xloc = expand_location (location); floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl)); - if (xloc.file != floc.file - || xloc.line < floc.line - || xloc.line > LOCATION_LINE (cfun->function_end_locus)) - inform ("%J%qD was declared here", var, var); + if (warning_at (location, OPT_Wuninitialized, gmsgid, var)) + { + TREE_NO_WARNING (var) = 1; - TREE_NO_WARNING (var) = 1; + if (xloc.file != floc.file + || xloc.line < floc.line + || xloc.line > LOCATION_LINE (cfun->function_end_locus)) + inform ("%J%qD was declared here", var, var); + } } struct walk_data { gimple stmt; bool always_executed; + bool warn_possibly_uninitialized; }; /* Called via walk_tree, look for SSA_NAMEs that have empty definitions @@ -1448,7 +1451,7 @@ warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_) if (data->always_executed) warn_uninit (t, "%qD is used uninitialized in this function", data->stmt); - else + else if (data->warn_possibly_uninitialized) warn_uninit (t, "%qD may be used uninitialized in this function", data->stmt); *walk_subtrees = 0; @@ -1494,12 +1497,14 @@ warn_uninitialized_phi (gimple phi) } static unsigned int -execute_early_warn_uninitialized (void) +warn_uninitialized_vars (bool warn_possibly_uninitialized) { gimple_stmt_iterator gsi; basic_block bb; struct walk_data data; + data.warn_possibly_uninitialized = warn_possibly_uninitialized; + calculate_dominance_info (CDI_POST_DOMINATORS); FOR_EACH_BB (bb) @@ -1519,6 +1524,19 @@ execute_early_warn_uninitialized (void) } static unsigned int +execute_early_warn_uninitialized (void) +{ + /* Currently, this pass runs always but + execute_late_warn_uninitialized only runs with optimization. With + optimization we want to warn about possible uninitialized as late + as possible, thus don't do it here. However, without + optimization we need to warn here about "may be uninitialized". + */ + warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize); + return 0; +} + +static unsigned int execute_late_warn_uninitialized (void) { basic_block bb; @@ -1527,7 +1545,7 @@ execute_late_warn_uninitialized (void) /* Re-do the plain uninitialized variable check, as optimization may have straightened control flow. Do this first so that we don't accidentally get a "may be" warning when we'd have seen an "is" warning later. */ - execute_early_warn_uninitialized (); + warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1); FOR_EACH_BB (bb) for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index e53780f1ef6..d5bff5a4822 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -374,6 +374,7 @@ vect_recog_widen_mult_pattern (gimple last_stmt, tree dummy; tree var; enum tree_code dummy_code; + bool dummy_bool; if (!is_gimple_assign (last_stmt)) return NULL; @@ -414,7 +415,7 @@ vect_recog_widen_mult_pattern (gimple last_stmt, if (!vectype || !supportable_widening_operation (WIDEN_MULT_EXPR, last_stmt, vectype, &dummy, &dummy, &dummy_code, - &dummy_code)) + &dummy_code, &dummy_bool, &dummy)) return NULL; *type_in = vectype; diff --git a/gcc/tree-vect-transform.c b/gcc/tree-vect-transform.c index e466594f0cf..eb370775cba 100644 --- a/gcc/tree-vect-transform.c +++ b/gcc/tree-vect-transform.c @@ -59,8 +59,8 @@ static tree vect_init_vector (gimple, tree, tree, gimple_stmt_iterator *); static void vect_finish_stmt_generation (gimple stmt, gimple vec_stmt, gimple_stmt_iterator *); static bool vect_is_simple_cond (tree, loop_vec_info); -static void vect_create_epilog_for_reduction (tree, gimple, enum tree_code, - gimple); +static void vect_create_epilog_for_reduction + (tree, gimple, int, enum tree_code, gimple); static tree get_initial_def_for_reduction (gimple, tree, tree *); /* Utility function dealing with loop peeling (not peeling itself). */ @@ -580,6 +580,10 @@ vect_model_simple_cost (stmt_vec_info stmt_info, int ncopies, int i; int inside_cost = 0, outside_cost = 0; + /* The SLP costs were already calculated during SLP tree build. */ + if (PURE_SLP_STMT (stmt_info)) + return; + inside_cost = ncopies * TARG_VEC_STMT_COST; /* FORNOW: Assuming maximum 2 args per stmts. */ @@ -629,11 +633,15 @@ vect_model_store_cost (stmt_vec_info stmt_info, int ncopies, int group_size; int inside_cost = 0, outside_cost = 0; + /* The SLP costs were already calculated during SLP tree build. */ + if (PURE_SLP_STMT (stmt_info)) + return; + if (dt == vect_constant_def || dt == vect_invariant_def) outside_cost = TARG_SCALAR_TO_VEC_COST; /* Strided access? */ - if (DR_GROUP_FIRST_DR (stmt_info)) + if (DR_GROUP_FIRST_DR (stmt_info) && !slp_node) group_size = vect_cost_strided_group_size (stmt_info); /* Not a strided access. */ else @@ -683,6 +691,10 @@ vect_model_load_cost (stmt_vec_info stmt_info, int ncopies, slp_tree slp_node) struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr; int inside_cost = 0, outside_cost = 0; + /* The SLP costs were already calculated during SLP tree build. */ + if (PURE_SLP_STMT (stmt_info)) + return; + /* Strided accesses? */ first_stmt = DR_GROUP_FIRST_DR (stmt_info); if (first_stmt && !slp_node) @@ -1812,7 +1824,7 @@ get_initial_def_for_induction (gimple iv_phi) if (vect_print_dump_info (REPORT_DETAILS)) { - fprintf (vect_dump, "transform induction: created def-use cycle:"); + fprintf (vect_dump, "transform induction: created def-use cycle: "); print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM); fprintf (vect_dump, "\n"); print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM); @@ -2044,6 +2056,10 @@ vect_get_vec_def_for_stmt_copy (enum vect_def_type dt, tree vec_oprnd) vec_stmt_for_operand = STMT_VINFO_RELATED_STMT (def_stmt_info); gcc_assert (vec_stmt_for_operand); vec_oprnd = gimple_get_lhs (vec_stmt_for_operand); + if (gimple_code (vec_stmt_for_operand) == GIMPLE_PHI) + vec_oprnd = PHI_RESULT (vec_stmt_for_operand); + else + vec_oprnd = gimple_get_lhs (vec_stmt_for_operand); return vec_oprnd; } @@ -2239,6 +2255,11 @@ get_initial_def_for_reduction (gimple stmt, tree init_val, tree *adjustment_def) VECT_DEF is a vector of partial results. REDUC_CODE is the tree-code for the epilog reduction. + NCOPIES is > 1 in case the vectorization factor (VF) is bigger than the + number of elements that we can fit in a vectype (nunits). In this case + we have to generate more than one vector stmt - i.e - we need to "unroll" + the vector stmt by a factor VF/nunits. For more details see documentation + in vectorizable_operation. STMT is the scalar reduction stmt that is being vectorized. REDUCTION_PHI is the phi-node that carries the reduction computation. @@ -2282,10 +2303,12 @@ get_initial_def_for_reduction (gimple stmt, tree init_val, tree *adjustment_def) static void vect_create_epilog_for_reduction (tree vect_def, gimple stmt, + int ncopies, enum tree_code reduc_code, gimple reduction_phi) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); + stmt_vec_info prev_phi_info; tree vectype; enum machine_mode mode; loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); @@ -2293,7 +2316,7 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, basic_block exit_bb; tree scalar_dest; tree scalar_type; - gimple new_phi; + gimple new_phi = NULL, phi; gimple_stmt_iterator exit_gsi; tree vec_dest; tree new_temp = NULL_TREE; @@ -2304,7 +2327,7 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, tree bitsize, bitpos, bytesize; enum tree_code code = gimple_assign_rhs_code (stmt); tree adjustment_def; - tree vec_initial_def; + tree vec_initial_def, def; tree orig_name; imm_use_iterator imm_iter; use_operand_p use_p; @@ -2314,7 +2337,8 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, gimple use_stmt; bool nested_in_vect_loop = false; VEC(gimple,heap) *phis = NULL; - int i; + enum vect_def_type dt = vect_unknown_def_type; + int j, i; if (nested_in_vect_loop_p (loop, stmt)) { @@ -2344,25 +2368,34 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, /*** 1. Create the reduction def-use cycle ***/ - /* 1.1 set the loop-entry arg of the reduction-phi: */ /* For the case of reduction, vect_get_vec_def_for_operand returns the scalar def before the loop, that defines the initial value of the reduction variable. */ vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt, &adjustment_def); - add_phi_arg (reduction_phi, vec_initial_def, loop_preheader_edge (loop)); - - /* 1.2 set the loop-latch arg for the reduction-phi: */ - add_phi_arg (reduction_phi, vect_def, loop_latch_edge (loop)); - if (vect_print_dump_info (REPORT_DETAILS)) + phi = reduction_phi; + def = vect_def; + for (j = 0; j < ncopies; j++) { - fprintf (vect_dump, "transform reduction: created def-use cycle:"); - print_gimple_stmt (vect_dump, reduction_phi, 0, TDF_SLIM); - fprintf (vect_dump, "\n"); - print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vect_def), 0, TDF_SLIM); - } + /* 1.1 set the loop-entry arg of the reduction-phi: */ + add_phi_arg (phi, vec_initial_def, loop_preheader_edge (loop)); + + /* 1.2 set the loop-latch arg for the reduction-phi: */ + if (j > 0) + def = vect_get_vec_def_for_stmt_copy (dt, def); + add_phi_arg (phi, def, loop_latch_edge (loop)); + if (vect_print_dump_info (REPORT_DETAILS)) + { + fprintf (vect_dump, "transform reduction: created def-use cycle: "); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); + fprintf (vect_dump, "\n"); + print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0, TDF_SLIM); + } + + phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi)); + } /*** 2. Create epilog code The reduction epilog code operates across the elements of the vector @@ -2386,7 +2419,7 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, s_out3 = extract_field <v_out2, 0> # step 2 s_out4 = adjust_result <s_out3> # step 3 - (step 3 is optional, and step2 1 and 2 may be combined). + (step 3 is optional, and steps 1 and 2 may be combined). Lastly, the uses of s_out0 are replaced by s_out4. ***/ @@ -2395,8 +2428,22 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, v_out1 = phi <v_loop> */ exit_bb = single_exit (loop)->dest; - new_phi = create_phi_node (SSA_NAME_VAR (vect_def), exit_bb); - SET_PHI_ARG_DEF (new_phi, single_exit (loop)->dest_idx, vect_def); + def = vect_def; + prev_phi_info = NULL; + for (j = 0; j < ncopies; j++) + { + phi = create_phi_node (SSA_NAME_VAR (vect_def), exit_bb); + set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo)); + if (j == 0) + new_phi = phi; + else + { + def = vect_get_vec_def_for_stmt_copy (dt, def); + STMT_VINFO_RELATED_STMT (prev_phi_info) = phi; + } + SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def); + prev_phi_info = vinfo_for_stmt (phi); + } exit_gsi = gsi_after_labels (exit_bb); /* 2.2 Get the relevant tree-code to use in the epilog for schemes 2,3 @@ -2437,6 +2484,9 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, if (nested_in_vect_loop) goto vect_finalize_reduction; + /* FORNOW */ + gcc_assert (ncopies = 1); + /* 2.3 Create the reduction code, using one of the three schemes described above. */ @@ -2652,15 +2702,19 @@ vect_finalize_reduction: { stmt_vec_info stmt_vinfo = vinfo_for_stmt (exit_phi); - /* FORNOW. Currently not supporting the case that an inner-loop reduction - is not used in the outer-loop (but only outside the outer-loop). */ + /* FORNOW. Currently not supporting the case that an inner-loop + reduction is not used in the outer-loop (but only outside the + outer-loop). */ gcc_assert (STMT_VINFO_RELEVANT_P (stmt_vinfo) && !STMT_VINFO_LIVE_P (stmt_vinfo)); - epilog_stmt = adjustment_def ? epilog_stmt : new_phi; + epilog_stmt = adjustment_def ? epilog_stmt : new_phi; STMT_VINFO_VEC_STMT (stmt_vinfo) = epilog_stmt; - set_vinfo_for_stmt (epilog_stmt, + set_vinfo_for_stmt (epilog_stmt, new_stmt_vec_info (epilog_stmt, loop_vinfo)); + if (adjustment_def) + STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) = + STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi)); continue; } @@ -2733,7 +2787,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, tree def; gimple def_stmt; enum vect_def_type dt; - gimple new_phi; + gimple new_phi = NULL; tree scalar_type; bool is_simple_use; gimple orig_stmt; @@ -2742,23 +2796,17 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, int i; int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; - stmt_vec_info prev_stmt_info; + int epilog_copies; + stmt_vec_info prev_stmt_info, prev_phi_info; + gimple first_phi = NULL; + bool single_defuse_cycle = false; tree reduc_def; gimple new_stmt = NULL; int j; tree ops[3]; if (nested_in_vect_loop_p (loop, stmt)) - { - loop = loop->inner; - /* FORNOW. This restriction should be relaxed. */ - if (ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } - } + loop = loop->inner; gcc_assert (ncopies >= 1); @@ -2992,18 +3040,52 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, /* Create the destination vector */ vec_dest = vect_create_destination_var (scalar_dest, vectype); - /* Create the reduction-phi that defines the reduction-operand. */ - new_phi = create_phi_node (vec_dest, loop->header); - /* In case the vectorization factor (VF) is bigger than the number of elements that we can fit in a vectype (nunits), we have to generate more than one vector stmt - i.e - we need to "unroll" the vector stmt by a factor VF/nunits. For more details see documentation in vectorizable_operation. */ + /* If the reduction is used in an outer loop we need to generate + VF intermediate results, like so (e.g. for ncopies=2): + r0 = phi (init, r0) + r1 = phi (init, r1) + r0 = x0 + r0; + r1 = x1 + r1; + (i.e. we generate VF results in 2 registers). + In this case we have a separate def-use cycle for each copy, and therefore + for each copy we get the vector def for the reduction variable from the + respective phi node created for this copy. + + Otherwise (the reduction is unused in the loop nest), we can combine + together intermediate results, like so (e.g. for ncopies=2): + r = phi (init, r) + r = x0 + r; + r = x1 + r; + (i.e. we generate VF/2 results in a single register). + In this case for each copy we get the vector def for the reduction variable + from the vectorized reduction operation generated in the previous iteration. + */ + + if (STMT_VINFO_RELEVANT (stmt_info) == vect_unused_in_loop) + { + single_defuse_cycle = true; + epilog_copies = 1; + } + else + epilog_copies = ncopies; + prev_stmt_info = NULL; + prev_phi_info = NULL; for (j = 0; j < ncopies; j++) { + if (j == 0 || !single_defuse_cycle) + { + /* Create the reduction-phi that defines the reduction-operand. */ + new_phi = create_phi_node (vec_dest, loop->header); + set_vinfo_for_stmt (new_phi, new_stmt_vec_info (new_phi, loop_vinfo)); + } + /* Handle uses. */ if (j == 0) { @@ -3015,6 +3097,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, /* Get the vector def for the reduction variable from the phi node */ reduc_def = PHI_RESULT (new_phi); + first_phi = new_phi; } else { @@ -3023,9 +3106,12 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, if (op_type == ternary_op) loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def1); - /* Get the vector def for the reduction variable from the vectorized - reduction operation generated in the previous iteration (j-1) */ - reduc_def = gimple_assign_lhs (new_stmt); + if (single_defuse_cycle) + reduc_def = gimple_assign_lhs (new_stmt); + else + reduc_def = PHI_RESULT (new_phi); + + STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi; } /* Arguments are ready. create the new vector stmt. */ @@ -3044,11 +3130,15 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, else STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; prev_stmt_info = vinfo_for_stmt (new_stmt); + prev_phi_info = vinfo_for_stmt (new_phi); } /* Finalize the reduction-phi (set it's arguments) and create the epilog reduction code. */ - vect_create_epilog_for_reduction (new_temp, stmt, epilog_reduc_code, new_phi); + if (!single_defuse_cycle) + new_temp = gimple_assign_lhs (*vec_stmt); + vect_create_epilog_for_reduction (new_temp, stmt, epilog_copies, + epilog_reduc_code, first_phi); return true; } @@ -3096,7 +3186,6 @@ vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt) int nunits_in; int nunits_out; loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); tree fndecl, new_temp, def, rhs_type, lhs_type; gimple def_stmt; enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type}; @@ -3200,14 +3289,6 @@ vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt) needs to be generated. */ gcc_assert (ncopies >= 1); - /* FORNOW. This restriction should be relaxed. */ - if (nested_in_vect_loop_p (loop, stmt) && ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } - if (!vec_stmt) /* transformation not required. */ { STMT_VINFO_TYPE (stmt_info) = call_vec_info_type; @@ -3222,14 +3303,6 @@ vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt) if (vect_print_dump_info (REPORT_DETAILS)) fprintf (vect_dump, "transform operation."); - /* FORNOW. This restriction should be relaxed. */ - if (nested_in_vect_loop_p (loop, stmt) && ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } - /* Handle def. */ scalar_dest = gimple_call_lhs (stmt); vec_dest = vect_create_destination_var (scalar_dest, vectype_out); @@ -3424,7 +3497,6 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, tree vec_oprnd0 = NULL_TREE, vec_oprnd1 = NULL_TREE; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); enum tree_code code, code1 = ERROR_MARK, code2 = ERROR_MARK; tree decl1 = NULL_TREE, decl2 = NULL_TREE; tree new_temp; @@ -3444,6 +3516,9 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, int i; VEC(tree,heap) *vec_oprnds0 = NULL; tree vop0; + tree integral_type; + tree dummy; + bool dummy_bool; /* Is STMT a vectorizable conversion? */ @@ -3496,6 +3571,8 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, || (!INTEGRAL_TYPE_P (rhs_type) && !INTEGRAL_TYPE_P (lhs_type))) return false; + integral_type = INTEGRAL_TYPE_P (rhs_type) ? vectype_in : vectype_out; + if (modifier == NARROW) ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_out; else @@ -3510,14 +3587,6 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, needs to be generated. */ gcc_assert (ncopies >= 1); - /* FORNOW. This restriction should be relaxed. */ - if (nested_in_vect_loop_p (loop, stmt) && ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } - /* Check the operands of the operation. */ if (!vect_is_simple_use (op0, loop_vinfo, &def_stmt, &def, &dt[0])) { @@ -3528,17 +3597,18 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, /* Supportable by target? */ if ((modifier == NONE - && !targetm.vectorize.builtin_conversion (code, vectype_in)) + && !targetm.vectorize.builtin_conversion (code, integral_type)) || (modifier == WIDEN && !supportable_widening_operation (code, stmt, vectype_in, &decl1, &decl2, - &code1, &code2)) + &code1, &code2, + &dummy_bool, &dummy)) || (modifier == NARROW && !supportable_narrowing_operation (code, stmt, vectype_in, - &code1))) + &code1, &dummy_bool, &dummy))) { if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "op not supported by target."); + fprintf (vect_dump, "conversion not supported by target."); return false; } @@ -3581,7 +3651,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, vect_get_vec_defs_for_stmt_copy (dt, &vec_oprnds0, NULL); builtin_decl = - targetm.vectorize.builtin_conversion (code, vectype_in); + targetm.vectorize.builtin_conversion (code, integral_type); for (i = 0; VEC_iterate (tree, vec_oprnds0, i, vop0); i++) { /* Arguments are ready. create the new vector stmt. */ @@ -3829,11 +3899,19 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED, stmt_vec_info stmt_info = vinfo_for_stmt (phi); tree vectype = STMT_VINFO_VECTYPE (stmt_info); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); + struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); int nunits = TYPE_VECTOR_SUBPARTS (vectype); int ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits; tree vec_def; gcc_assert (ncopies >= 1); + /* FORNOW. This restriction should be relaxed. */ + if (nested_in_vect_loop_p (loop, phi) && ncopies > 1) + { + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "multiple types in nested loop."); + return false; + } if (!STMT_VINFO_RELEVANT_P (stmt_info)) return false; @@ -3885,7 +3963,6 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi, stmt_vec_info stmt_info = vinfo_for_stmt (stmt); tree vectype = STMT_VINFO_VECTYPE (stmt_info); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); enum tree_code code; enum machine_mode vec_mode; tree new_temp; @@ -3914,13 +3991,6 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi, if (slp_node) ncopies = 1; gcc_assert (ncopies >= 1); - /* FORNOW. This restriction should be relaxed. */ - if (nested_in_vect_loop_p (loop, stmt) && ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } if (!STMT_VINFO_RELEVANT_P (stmt_info)) return false; @@ -4239,7 +4309,6 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, tree vec_oprnd0=NULL, vec_oprnd1=NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); enum tree_code code, code1 = ERROR_MARK; tree new_temp; tree def; @@ -4253,6 +4322,10 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, int ncopies; int j; tree vectype_in; + tree intermediate_type = NULL_TREE, narrow_type, double_vec_dest; + bool double_op = false; + tree first_vector, second_vector; + tree vec_oprnd2 = NULL_TREE, vec_oprnd3 = NULL_TREE, last_oprnd = NULL_TREE; if (!STMT_VINFO_RELEVANT_P (stmt_info)) return false; @@ -4282,18 +4355,12 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, if (!vectype_out) return false; nunits_out = TYPE_VECTOR_SUBPARTS (vectype_out); - if (nunits_in != nunits_out / 2) /* FORNOW */ + if (nunits_in != nunits_out / 2 + && nunits_in != nunits_out/4) return false; ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_out; gcc_assert (ncopies >= 1); - /* FORNOW. This restriction should be relaxed. */ - if (nested_in_vect_loop_p (loop, stmt) && ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } if (! ((INTEGRAL_TYPE_P (TREE_TYPE (scalar_dest)) && INTEGRAL_TYPE_P (TREE_TYPE (op0))) @@ -4311,7 +4378,8 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, } /* Supportable by target? */ - if (!supportable_narrowing_operation (code, stmt, vectype_in, &code1)) + if (!supportable_narrowing_operation (code, stmt, vectype_in, &code1, + &double_op, &intermediate_type)) return false; STMT_VINFO_VECTYPE (stmt_info) = vectype_in; @@ -4331,8 +4399,15 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, ncopies); /* Handle def. */ - vec_dest = vect_create_destination_var (scalar_dest, vectype_out); - + /* In case of double demotion, we first generate demotion operation to the + intermediate type, and then from that type to the final one. */ + if (double_op) + narrow_type = intermediate_type; + else + narrow_type = vectype_out; + vec_dest = vect_create_destination_var (scalar_dest, narrow_type); + double_vec_dest = vect_create_destination_var (scalar_dest, vectype_out); + /* In case the vectorization factor (VF) is bigger than the number of elements that we can fit in a vectype (nunits), we have to generate more than one vector stmt - i.e - we need to "unroll" the @@ -4343,22 +4418,59 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, /* Handle uses. */ if (j == 0) { - vec_oprnd0 = vect_get_vec_def_for_operand (op0, stmt, NULL); - vec_oprnd1 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd0); + vec_oprnd0 = vect_get_vec_def_for_operand (op0, stmt, NULL); + vec_oprnd1 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd0); + if (double_op) + { + /* For double demotion we need four operands. */ + vec_oprnd2 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd1); + vec_oprnd3 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd2); + } } else { - vec_oprnd0 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd1); - vec_oprnd1 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd0); + vec_oprnd0 = vect_get_vec_def_for_stmt_copy (dt[0], last_oprnd); + vec_oprnd1 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd0); + if (double_op) + { + /* For double demotion we need four operands. */ + vec_oprnd2 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd1); + vec_oprnd3 = vect_get_vec_def_for_stmt_copy (dt[0], vec_oprnd2); + } } - /* Arguments are ready. Create the new vector stmt. */ + /* Arguments are ready. Create the new vector stmts. */ new_stmt = gimple_build_assign_with_ops (code1, vec_dest, vec_oprnd0, - vec_oprnd1); - new_temp = make_ssa_name (vec_dest, new_stmt); - gimple_assign_set_lhs (new_stmt, new_temp); + vec_oprnd1); + first_vector = make_ssa_name (vec_dest, new_stmt); + gimple_assign_set_lhs (new_stmt, first_vector); vect_finish_stmt_generation (stmt, new_stmt, gsi); + /* In the next iteration we will get copy for this operand. */ + last_oprnd = vec_oprnd1; + + if (double_op) + { + /* For double demotion operation we first generate two demotion + operations from the source type to the intermediate type, and + then combine the results in one demotion to the destination + type. */ + new_stmt = gimple_build_assign_with_ops (code1, vec_dest, vec_oprnd2, + vec_oprnd3); + second_vector = make_ssa_name (vec_dest, new_stmt); + gimple_assign_set_lhs (new_stmt, second_vector); + vect_finish_stmt_generation (stmt, new_stmt, gsi); + + new_stmt = gimple_build_assign_with_ops (code1, double_vec_dest, + first_vector, second_vector); + new_temp = make_ssa_name (double_vec_dest, new_stmt); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); + + /* In the next iteration we will get copy for this operand. */ + last_oprnd = vec_oprnd3; + } + if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; else @@ -4390,7 +4502,6 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, tree vec_oprnd0=NULL, vec_oprnd1=NULL; stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); enum tree_code code, code1 = ERROR_MARK, code2 = ERROR_MARK; tree decl1 = NULL_TREE, decl2 = NULL_TREE; int op_type; @@ -4405,6 +4516,9 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, int ncopies; int j; tree vectype_in; + tree intermediate_type = NULL_TREE, first_vector, second_vector; + bool double_op; + tree wide_type, double_vec_dest; if (!STMT_VINFO_RELEVANT_P (stmt_info)) return false; @@ -4435,18 +4549,11 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, if (!vectype_out) return false; nunits_out = TYPE_VECTOR_SUBPARTS (vectype_out); - if (nunits_out != nunits_in / 2) /* FORNOW */ + if (nunits_out != nunits_in / 2 && nunits_out != nunits_in/4) return false; ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_in; gcc_assert (ncopies >= 1); - /* FORNOW. This restriction should be relaxed. */ - if (nested_in_vect_loop_p (loop, stmt) && ncopies > 1) - { - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "multiple types in nested loop."); - return false; - } if (! ((INTEGRAL_TYPE_P (TREE_TYPE (scalar_dest)) && INTEGRAL_TYPE_P (TREE_TYPE (op0))) @@ -4477,9 +4584,14 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, /* Supportable by target? */ if (!supportable_widening_operation (code, stmt, vectype_in, - &decl1, &decl2, &code1, &code2)) + &decl1, &decl2, &code1, &code2, + &double_op, &intermediate_type)) return false; + /* Binary widening operation can only be supported directly by the + architecture. */ + gcc_assert (!(double_op && op_type == binary_op)); + STMT_VINFO_VECTYPE (stmt_info) = vectype_in; if (!vec_stmt) /* transformation not required. */ @@ -4498,7 +4610,13 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, ncopies); /* Handle def. */ - vec_dest = vect_create_destination_var (scalar_dest, vectype_out); + if (double_op) + wide_type = intermediate_type; + else + wide_type = vectype_out; + + vec_dest = vect_create_destination_var (scalar_dest, wide_type); + double_vec_dest = vect_create_destination_var (scalar_dest, vectype_out); /* In case the vectorization factor (VF) is bigger than the number of elements that we can fit in a vectype (nunits), we have to generate @@ -4525,22 +4643,75 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, /* Arguments are ready. Create the new vector stmt. We are creating two vector defs because the widened result does not fit in one vector. The vectorized stmt can be expressed as a call to a target builtin, - or a using a tree-code. */ + or a using a tree-code. In case of double promotion (from char to int, + for example), the promotion is performed in two phases: first we + generate a promotion operation from the source type to the intermediate + type (short in case of char->int promotion), and then for each of the + created vectors we generate a promotion statement from the intermediate + type to the destination type. */ /* Generate first half of the widened result: */ - new_stmt = vect_gen_widened_results_half (code1, vectype_out, decl1, + new_stmt = vect_gen_widened_results_half (code1, wide_type, decl1, vec_oprnd0, vec_oprnd1, op_type, vec_dest, gsi, stmt); - if (j == 0) - STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; + if (is_gimple_call (new_stmt)) + first_vector = gimple_call_lhs (new_stmt); else - STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; - prev_stmt_info = vinfo_for_stmt (new_stmt); + first_vector = gimple_assign_lhs (new_stmt); + + if (!double_op) + { + if (j == 0) + STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; + else + STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; + prev_stmt_info = vinfo_for_stmt (new_stmt); + } /* Generate second half of the widened result: */ - new_stmt = vect_gen_widened_results_half (code2, vectype_out, decl2, + new_stmt = vect_gen_widened_results_half (code2, wide_type, decl2, vec_oprnd0, vec_oprnd1, op_type, vec_dest, gsi, stmt); - STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; - prev_stmt_info = vinfo_for_stmt (new_stmt); + if (is_gimple_call (new_stmt)) + second_vector = gimple_call_lhs (new_stmt); + else + second_vector = gimple_assign_lhs (new_stmt); + if (!double_op) + { + STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; + prev_stmt_info = vinfo_for_stmt (new_stmt); + } + else + { + /* FIRST_VECTOR and SECOND_VECTOR are the results of source type + to intermediate type promotion. Now we generate promotions + for both of them to the destination type (i.e., four + statements). */ + new_stmt = vect_gen_widened_results_half (code1, vectype_out, + decl1, first_vector, NULL_TREE, op_type, + double_vec_dest, gsi, stmt); + if (j == 0) + STMT_VINFO_VEC_STMT (stmt_info) = new_stmt; + else + STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; + prev_stmt_info = vinfo_for_stmt (new_stmt); + + new_stmt = vect_gen_widened_results_half (code2, vectype_out, + decl2, first_vector, NULL_TREE, op_type, + double_vec_dest, gsi, stmt); + STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; + prev_stmt_info = vinfo_for_stmt (new_stmt); + + new_stmt = vect_gen_widened_results_half (code1, vectype_out, + decl1, second_vector, NULL_TREE, op_type, + double_vec_dest, gsi, stmt); + STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; + prev_stmt_info = vinfo_for_stmt (new_stmt); + + new_stmt = vect_gen_widened_results_half (code2, vectype_out, + decl2, second_vector, NULL_TREE, op_type, + double_vec_dest, gsi, stmt); + STMT_VINFO_RELATED_STMT (prev_stmt_info) = new_stmt; + prev_stmt_info = vinfo_for_stmt (new_stmt); + } } *vec_stmt = STMT_VINFO_VEC_STMT (stmt_info); @@ -4865,8 +5036,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, if (!vec_stmt) /* transformation not required. */ { STMT_VINFO_TYPE (stmt_info) = store_vec_info_type; - if (!PURE_SLP_STMT (stmt_info)) - vect_model_store_cost (stmt_info, ncopies, dt, NULL); + vect_model_store_cost (stmt_info, ncopies, dt, NULL); return true; } diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c index 22e2e0c4cee..78f82624c23 100644 --- a/gcc/tree-vectorizer.c +++ b/gcc/tree-vectorizer.c @@ -147,6 +147,7 @@ along with GCC; see the file COPYING3. If not see #include "hashtab.h" #include "tree-vectorizer.h" #include "tree-pass.h" +#include "langhooks.h" /************************************************************************* General Vectorization Utilities @@ -2136,12 +2137,17 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, gimple *def_stmt, vectorizing the operation, if available. - DECL1 and DECL2 are decls of target builtin functions to be used when vectorizing the operation, if available. In this case, - CODE1 and CODE2 are CALL_EXPR. */ + CODE1 and CODE2 are CALL_EXPR. + - DOUBLE_OP determines if the operation is a double cast, like + char->short->int + - INTERM_TYPE is the intermediate type required to perform the + widening operation (short in the above example) */ bool supportable_widening_operation (enum tree_code code, gimple stmt, tree vectype, tree *decl1, tree *decl2, - enum tree_code *code1, enum tree_code *code2) + enum tree_code *code1, enum tree_code *code2, + bool *double_op, tree *interm_type) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); loop_vec_info loop_info = STMT_VINFO_LOOP_VINFO (stmt_info); @@ -2154,6 +2160,8 @@ supportable_widening_operation (enum tree_code code, gimple stmt, tree vectype, tree wide_vectype = get_vectype_for_scalar_type (type); enum tree_code c1, c2; + *double_op = false; + /* The result of a vectorized widening operation usually requires two vectors (because the widened results do not fit int one vector). The generated vector results would normally be expected to be generated in the same @@ -2264,12 +2272,57 @@ supportable_widening_operation (enum tree_code code, gimple stmt, tree vectype, vec_mode = TYPE_MODE (vectype); if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) == CODE_FOR_nothing - || insn_data[icode1].operand[0].mode != TYPE_MODE (wide_vectype) || (icode2 = optab_handler (optab2, vec_mode)->insn_code) - == CODE_FOR_nothing - || insn_data[icode2].operand[0].mode != TYPE_MODE (wide_vectype)) + == CODE_FOR_nothing) return false; + /* Check if it's a double cast, like char->int. In such case the intermediate + type is short, and we check that char->short->int operaion is supported by + the target. */ + if (insn_data[icode1].operand[0].mode != TYPE_MODE (wide_vectype) + || insn_data[icode2].operand[0].mode != TYPE_MODE (wide_vectype)) + { + if (code == NOP_EXPR) + { + enum machine_mode intermediate_mode = + insn_data[icode1].operand[0].mode; + tree intermediate_type = + lang_hooks.types.type_for_mode (intermediate_mode, + TYPE_UNSIGNED (vectype)); + optab optab3 = optab_for_tree_code (c1, intermediate_type, + optab_default); + optab optab4 = optab_for_tree_code (c2, intermediate_type, + optab_default); + + if (!optab3 || !optab4) + return false; + + if ((icode1 = optab1->handlers[(int) vec_mode].insn_code) + == CODE_FOR_nothing + || insn_data[icode1].operand[0].mode != intermediate_mode + || (icode2 = optab2->handlers[(int) vec_mode].insn_code) + == CODE_FOR_nothing + || insn_data[icode2].operand[0].mode != intermediate_mode + || (icode1 = optab3->handlers[(int) intermediate_mode].insn_code) + == CODE_FOR_nothing + || insn_data[icode1].operand[0].mode != TYPE_MODE (wide_vectype) + || (icode2 = optab4->handlers[(int) intermediate_mode].insn_code) + == CODE_FOR_nothing + || insn_data[icode2].operand[0].mode != TYPE_MODE (wide_vectype)) + return false; + else + { + *double_op = true; + *interm_type = intermediate_type; + *code1 = c1; + *code2 = c2; + return true; + } + } + + return false; + } + *code1 = c1; *code2 = c2; return true; @@ -2288,16 +2341,21 @@ supportable_widening_operation (enum tree_code code, gimple stmt, tree vectype, Output: - CODE1 is the code of a vector operation to be used when - vectorizing the operation, if available. */ + vectorizing the operation, if available. + - DOUBLE_OP determines if the operation is a double cast, like + int->short->char + - INTERMIDIATE_TYPE is the intermediate type required to perform the + widening operation (short in the above example) */ bool supportable_narrowing_operation (enum tree_code code, const_gimple stmt, const_tree vectype, - enum tree_code *code1) + enum tree_code *code1, bool *double_op, + tree *intermediate_type) { enum machine_mode vec_mode; enum insn_code icode1; - optab optab1; + optab optab1, interm_optab; tree type = gimple_expr_type (stmt); tree narrow_vectype = get_vectype_for_scalar_type (type); enum tree_code c1; @@ -2331,10 +2389,30 @@ supportable_narrowing_operation (enum tree_code code, return false; vec_mode = TYPE_MODE (vectype); - if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) == CODE_FOR_nothing - || insn_data[icode1].operand[0].mode != TYPE_MODE (narrow_vectype)) + if ((icode1 = optab_handler (optab1, vec_mode)->insn_code) + == CODE_FOR_nothing) return false; + /* In case of NUNITS_IN == NUNITS_OUT/4 check that the it is possible to + perform the operation using an intermediate type of NUNITS_OUT/2. */ + if (insn_data[icode1].operand[0].mode != TYPE_MODE (narrow_vectype)) + { + enum machine_mode intermediate_mode = insn_data[icode1].operand[0].mode; + *intermediate_type = lang_hooks.types.type_for_mode (intermediate_mode, + TYPE_UNSIGNED (vectype)); + interm_optab = optab_for_tree_code (VEC_PACK_TRUNC_EXPR, + *intermediate_type, optab_default); + if (!interm_optab) + return false; + + if ((icode1 = interm_optab->handlers[(int) intermediate_mode].insn_code) + == CODE_FOR_nothing + || insn_data[icode1].operand[0].mode != TYPE_MODE (narrow_vectype)) + return false; + + *double_op = true; + } + *code1 = c1; return true; } diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index ea80a8d3d30..cf7c5b123e9 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -671,9 +671,9 @@ extern enum dr_alignment_support vect_supportable_dr_alignment (struct data_reference *); extern bool reduction_code_for_scalar_code (enum tree_code, enum tree_code *); extern bool supportable_widening_operation (enum tree_code, gimple, tree, - tree *, tree *, enum tree_code *, enum tree_code *); + tree *, tree *, enum tree_code *, enum tree_code *, bool *, tree *); extern bool supportable_narrowing_operation (enum tree_code, const_gimple, - const_tree, enum tree_code *); + const_tree, enum tree_code *, bool *, tree *); /* Creation and deletion of loop and stmt info structs. */ extern loop_vec_info new_loop_vec_info (struct loop *loop); diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 40bec2e1d4d..af4060c6a1e 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -6383,9 +6383,9 @@ simplify_cond_using_ranges (gimple stmt) able to simplify this conditional. */ if (vr->type == VR_RANGE) { - tree new = test_for_singularity (cond_code, op0, op1, vr); + tree new_tree = test_for_singularity (cond_code, op0, op1, vr); - if (new) + if (new_tree) { if (dump_file) { @@ -6396,7 +6396,7 @@ simplify_cond_using_ranges (gimple stmt) gimple_cond_set_code (stmt, EQ_EXPR); gimple_cond_set_lhs (stmt, op0); - gimple_cond_set_rhs (stmt, new); + gimple_cond_set_rhs (stmt, new_tree); update_stmt (stmt); @@ -6413,9 +6413,9 @@ simplify_cond_using_ranges (gimple stmt) with integral types here, so no need to worry about issues with inverting FP comparisons. */ cond_code = invert_tree_comparison (cond_code, false); - new = test_for_singularity (cond_code, op0, op1, vr); + new_tree = test_for_singularity (cond_code, op0, op1, vr); - if (new) + if (new_tree) { if (dump_file) { @@ -6426,7 +6426,7 @@ simplify_cond_using_ranges (gimple stmt) gimple_cond_set_code (stmt, NE_EXPR); gimple_cond_set_lhs (stmt, op0); - gimple_cond_set_rhs (stmt, new); + gimple_cond_set_rhs (stmt, new_tree); update_stmt (stmt); diff --git a/gcc/tree.c b/gcc/tree.c index cdecd707f00..c92beef74ca 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -2594,7 +2594,7 @@ substitute_in_expr (tree exp, tree f, tree r) { enum tree_code code = TREE_CODE (exp); tree op0, op1, op2, op3; - tree new, inner; + tree new_tree, inner; /* We handle TREE_LIST and COMPONENT_REF separately. */ if (code == TREE_LIST) @@ -2626,7 +2626,7 @@ substitute_in_expr (tree exp, tree f, tree r) if (op0 == TREE_OPERAND (exp, 0)) return exp; - new = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), + new_tree = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, TREE_OPERAND (exp, 1), NULL_TREE); } else @@ -2652,7 +2652,7 @@ substitute_in_expr (tree exp, tree f, tree r) if (op0 == TREE_OPERAND (exp, 0)) return exp; - new = fold_build1 (code, TREE_TYPE (exp), op0); + new_tree = fold_build1 (code, TREE_TYPE (exp), op0); break; case 2: @@ -2662,7 +2662,7 @@ substitute_in_expr (tree exp, tree f, tree r) if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) return exp; - new = fold_build2 (code, TREE_TYPE (exp), op0, op1); + new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1); break; case 3: @@ -2674,7 +2674,7 @@ substitute_in_expr (tree exp, tree f, tree r) && op2 == TREE_OPERAND (exp, 2)) return exp; - new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); + new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); break; case 4: @@ -2688,7 +2688,7 @@ substitute_in_expr (tree exp, tree f, tree r) && op3 == TREE_OPERAND (exp, 3)) return exp; - new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); + new_tree = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); break; default: @@ -2714,7 +2714,7 @@ substitute_in_expr (tree exp, tree f, tree r) } if (copy) - new = fold (copy); + new_tree = fold (copy); else return exp; } @@ -2724,8 +2724,8 @@ substitute_in_expr (tree exp, tree f, tree r) gcc_unreachable (); } - TREE_READONLY (new) = TREE_READONLY (exp); - return new; + TREE_READONLY (new_tree) = TREE_READONLY (exp); + return new_tree; } /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement @@ -3915,7 +3915,7 @@ merge_decl_attributes (tree olddecl, tree newdecl) The second instance of `foo' nullifies the dllimport. */ tree -merge_dllimport_decl_attributes (tree old, tree new) +merge_dllimport_decl_attributes (tree old, tree new_tree) { tree a; int delete_dllimport_p = 1; @@ -3926,16 +3926,16 @@ merge_dllimport_decl_attributes (tree old, tree new) is not dllimport'd. We also remove a `new' dllimport if the old list contains dllexport: dllexport always overrides dllimport, regardless of the order of declaration. */ - if (!VAR_OR_FUNCTION_DECL_P (new)) + if (!VAR_OR_FUNCTION_DECL_P (new_tree)) delete_dllimport_p = 0; - else if (DECL_DLLIMPORT_P (new) + else if (DECL_DLLIMPORT_P (new_tree) && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old))) { - DECL_DLLIMPORT_P (new) = 0; + DECL_DLLIMPORT_P (new_tree) = 0; warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: " - "dllimport ignored", new); + "dllimport ignored", new_tree); } - else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new)) + else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree)) { /* Warn about overriding a symbol that has already been used, e.g.: extern int __attribute__ ((dllimport)) foo; @@ -3945,27 +3945,27 @@ merge_dllimport_decl_attributes (tree old, tree new) if (TREE_USED (old)) { warning (0, "%q+D redeclared without dllimport attribute " - "after being referenced with dll linkage", new); + "after being referenced with dll linkage", new_tree); /* If we have used a variable's address with dllimport linkage, keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the decl may already have had TREE_CONSTANT computed. We still remove the attribute so that assembler code refers to '&foo rather than '_imp__foo'. */ if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old)) - DECL_DLLIMPORT_P (new) = 1; + DECL_DLLIMPORT_P (new_tree) = 1; } /* Let an inline definition silently override the external reference, but otherwise warn about attribute inconsistency. */ - else if (TREE_CODE (new) == VAR_DECL - || !DECL_DECLARED_INLINE_P (new)) + else if (TREE_CODE (new_tree) == VAR_DECL + || !DECL_DECLARED_INLINE_P (new_tree)) warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: " - "previous dllimport ignored", new); + "previous dllimport ignored", new_tree); } else delete_dllimport_p = 0; - a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new)); + a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree)); if (delete_dllimport_p) { @@ -5253,7 +5253,7 @@ iterative_hash_expr (const_tree t, hashval_t val) { int i; enum tree_code code; - char class; + char tclass; if (t == NULL_TREE) return iterative_hash_pointer (t, val); @@ -5322,16 +5322,16 @@ iterative_hash_expr (const_tree t, hashval_t val) } /* else FALL THROUGH */ default: - class = TREE_CODE_CLASS (code); + tclass = TREE_CODE_CLASS (code); - if (class == tcc_declaration) + if (tclass == tcc_declaration) { /* DECL's have a unique ID */ val = iterative_hash_host_wide_int (DECL_UID (t), val); } else { - gcc_assert (IS_EXPR_CODE_CLASS (class)); + gcc_assert (IS_EXPR_CODE_CLASS (tclass)); val = iterative_hash_object (code, val); diff --git a/gcc/tree.h b/gcc/tree.h index 5f5b37d4ef8..3f8065da736 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4744,6 +4744,7 @@ extern void fold_undefer_overflow_warnings (bool, const_gimple, int); extern void fold_undefer_and_ignore_overflow_warnings (void); extern bool fold_deferring_overflow_warnings_p (void); extern tree maybe_fold_offset_to_reference (tree, tree, tree); +extern tree maybe_fold_offset_to_address (tree, tree, tree); extern tree maybe_fold_stmt_addition (tree, tree, tree); extern tree force_fit_type_double (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT, diff --git a/gcc/value-prof.c b/gcc/value-prof.c index b94a3f96b47..7f776ccaf89 100644 --- a/gcc/value-prof.c +++ b/gcc/value-prof.c @@ -333,12 +333,12 @@ gimple_duplicate_stmt_histograms (struct function *fun, gimple stmt, histogram_value val; for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next) { - histogram_value new = gimple_alloc_histogram_value (fun, val->type, NULL, NULL); - memcpy (new, val, sizeof (*val)); - new->hvalue.stmt = stmt; - new->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new->hvalue.counters) * new->n_counters); - memcpy (new->hvalue.counters, val->hvalue.counters, sizeof (*new->hvalue.counters) * new->n_counters); - gimple_add_histogram_value (fun, stmt, new); + histogram_value new_val = gimple_alloc_histogram_value (fun, val->type, NULL, NULL); + memcpy (new_val, val, sizeof (*val)); + new_val->hvalue.stmt = stmt; + new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters); + memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters); + gimple_add_histogram_value (fun, stmt, new_val); } } @@ -541,10 +541,8 @@ static tree gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count, gcov_type all) { - gimple stmt1, stmt2, stmt3, label1, label2; + gimple stmt1, stmt2, stmt3; tree tmp1, tmp2, tmpv; - tree label_decl1 = create_artificial_label (); - tree label_decl2 = create_artificial_label (); gimple bb1end, bb2end, bb3end; basic_block bb, bb2, bb3, bb4; tree optype, op1, op2; @@ -573,17 +571,13 @@ gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count, bb1end = stmt3; tmp2 = create_tmp_var (optype, "PROF"); - label1 = gimple_build_label (label_decl1); stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2, op1, tmpv); - gsi_insert_before (&gsi, label1, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); bb2end = stmt1; - label2 = gimple_build_label (label_decl2); stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2, op1, op2); - gsi_insert_before (&gsi, label2, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); bb3end = stmt1; @@ -702,9 +696,6 @@ gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all) { gimple stmt1, stmt2, stmt3, stmt4; tree tmp2, tmp3; - tree label_decl1 = create_artificial_label (); - tree label_decl2 = create_artificial_label (); - gimple label1, label2; gimple bb1end, bb2end, bb3end; basic_block bb, bb2, bb3, bb4; tree optype, op1, op2; @@ -736,16 +727,12 @@ gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all) bb1end = stmt4; /* tmp2 == op2-1 inherited from previous block. */ - label1 = gimple_build_label (label_decl1); stmt1 = gimple_build_assign_with_ops (BIT_AND_EXPR, result, op1, tmp2); - gsi_insert_before (&gsi, label1, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); bb2end = stmt1; - label2 = gimple_build_label (label_decl2); stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result, op1, op2); - gsi_insert_before (&gsi, label2, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); bb3end = stmt1; @@ -861,10 +848,6 @@ gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts, { gimple stmt1, stmt2, stmt3; tree tmp1; - tree label_decl1 = create_artificial_label (); - tree label_decl2 = create_artificial_label (); - tree label_decl3 = create_artificial_label (); - gimple label1, label2, label3; gimple bb1end, bb2end = NULL, bb3end; basic_block bb, bb2, bb3, bb4; tree optype, op1, op2; @@ -894,26 +877,19 @@ gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts, if (ncounts) /* Assumed to be 0 or 1 */ { - label1 = gimple_build_label (label_decl1); stmt1 = gimple_build_assign_with_ops (MINUS_EXPR, result, result, tmp1); stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE); - gsi_insert_before (&gsi, label1, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT); bb2end = stmt2; } /* Fallback case. */ - label2 = gimple_build_label (label_decl2); stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), result, result, tmp1); - gsi_insert_before (&gsi, label2, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); bb3end = stmt1; - label3 = gimple_build_label (label_decl3); - gsi_insert_before (&gsi, label3, GSI_SAME_STMT); - /* Fix CFG. */ /* Edge e23 connects bb2 to bb3, etc. */ /* However block 3 is optional; if it is not there, references @@ -1098,9 +1074,6 @@ gimple_ic (gimple stmt, gimple call, struct cgraph_node *direct_call, { gimple stmt1, stmt2, stmt3; tree tmp1, tmpv, tmp; - tree label_decl1 = create_artificial_label (); - tree label_decl2 = create_artificial_label (); - gimple label1, label2; gimple bb1end, bb2end, bb3end; basic_block bb, bb2, bb3, bb4; tree optype = build_pointer_type (void_type_node); @@ -1124,16 +1097,11 @@ gimple_ic (gimple stmt, gimple call, struct cgraph_node *direct_call, gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT); bb1end = stmt3; - label1 = gimple_build_label (label_decl1); stmt1 = gimple_copy (stmt); gimple_call_set_fn (stmt, build_addr (direct_call->decl, current_function_decl)); - gsi_insert_before (&gsi, label1, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); bb2end = stmt1; - - label2 = gimple_build_label (label_decl2); - gsi_insert_before (&gsi, label2, GSI_SAME_STMT); bb3end = stmt; /* Fix CFG. */ @@ -1287,9 +1255,6 @@ gimple_stringop_fixed_value (gimple stmt, tree value, int prob, gcov_type count, { gimple stmt1, stmt2, stmt3; tree tmp1, tmpv; - tree label_decl1 = create_artificial_label (); - tree label_decl2 = create_artificial_label (); - gimple label1, label2; gimple bb1end, bb2end; basic_block bb, bb2, bb3, bb4; edge e12, e13, e23, e24, e34; @@ -1325,17 +1290,13 @@ gimple_stringop_fixed_value (gimple stmt, tree value, int prob, gcov_type count, gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT); bb1end = stmt3; - label1 = gimple_build_label (label_decl1); stmt1 = gimple_copy (stmt); gimple_call_set_arg (stmt1, 2, value); - gsi_insert_before (&gsi, label1, GSI_SAME_STMT); gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); region = lookup_stmt_eh_region (stmt); if (region >= 0) add_stmt_to_eh_region (stmt1, region); bb2end = stmt1; - label2 = gimple_build_label (label_decl2); - gsi_insert_before (&gsi, label2, GSI_SAME_STMT); /* Fix CFG. */ /* Edge e23 connects bb2 to bb3, etc. */ @@ -1581,13 +1542,11 @@ gimple_indirect_call_to_profile (gimple stmt, histogram_values *values) { tree callee; - if (gimple_code (stmt) != GIMPLE_CALL) + if (gimple_code (stmt) != GIMPLE_CALL + || gimple_call_fndecl (stmt) != NULL_TREE) return; callee = gimple_call_fn (stmt); - - if (TREE_CODE (callee) == FUNCTION_DECL) - return; VEC_reserve (histogram_value, heap, *values, 3); |