diff options
| author | Diego Novillo <dnovillo@google.com> | 2013-03-20 15:17:37 +0000 |
|---|---|---|
| committer | Diego Novillo <dnovillo@google.com> | 2013-03-20 15:17:37 +0000 |
| commit | f6c272cbbba232c5a954030166967ab1b46b8a9c (patch) | |
| tree | 2184e12caee7cb11fc09920542a6c67a14a68882 | |
| parent | f613c9f17c460cb1357a7377a2153a81311cde75 (diff) | |
Merged revisions 196697-196698,196700-196701,196704-196706,196709,196721-196748,196750-196751,196753,196755-196758,196762,196764-196765,196767-196771,196773-196779,196781-196784,196788-196792,196795-196797,196799-196800,196804 via svnmerge from
svn+ssh://gcc.gnu.org/svn/gcc/trunk
git-svn-id: https://gcc.gnu.org/svn/gcc/branches/google/integration@196830 138bc75d-0d04-0410-961f-82ee72b054a4
122 files changed, 2966 insertions, 1882 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e94d20db947..803ae88d3bd 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,198 @@ +2013-03-19 Ian Bolton <ian.bolton@arm.com> + + * config/aarch64/aarch64.md (*sub<mode>3_carryin): New pattern. + (*subsi3_carryin_uxtw): Likewise. + +2013-03-19 Ian Bolton <ian.bolton@arm.com> + + * config/aarch64/aarch64.md (*ror<mode>3_insn): New pattern. + (*rorsi3_insn_uxtw): Likewise. + +2013-03-19 Ian Bolton <ian.bolton@arm.com> + + * config/aarch64/aarch64.md (*extr<mode>5_insn): New pattern. + (*extrsi5_insn_uxtw): Likewise. + +2013-03-19 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56273 + * passes.c (init_optimization_passes): Move second VRP after DOM. + +2013-03-19 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/i386.md (*movti_internal): Merge from + *movti_internal_rex64 and *movti_internal_sse. Use x64 isa attribute. + (*movdi_internal): Merge with *movdi_internal_rex64. Use x64 and + nox64 isa attributes. + +2013-03-18 Richard Biener <rguenther@suse.de> + + * tree-ssa-structalias.c (find): Use gcc_checking_assert. + (unite): Likewise. + (merge_node_constraints): Likewise. + (build_succ_graph): Likewise. + (valid_graph_edge): Inline into single caller. + (unify_nodes): Likewise. Use bitmap_set_bit return value + and cache varinfo. + (scc_visit): Fix formatting and variable use. + (do_sd_constraint): Use gcc_checking_assert. + (do_ds_constraint): Likewise. + (do_complex_constraint): Likewise. + (condense_visit): Likewise. Cleanup. + (dump_pred_graph): New function. + (perform_var_substitution): Dump the pred-graph before + variable substitution. + (find_equivalent_node): Use gcc_checking_assert. + (rewrite_constraints): Guard checking loop with ENABLE_CHECKING. + +2013-03-18 Richard Biener <rguenther@suse.de> + + * tree-vect-loop-manip.c (vect_create_cond_for_alias_checks): + Remove cond_expr_stmt_list argument and do not gimplify the + built expression. + (vect_loop_versioning): Adjust. + * tree-vect-data-refs.c (vect_create_addr_base_for_vector_ref): + Cleanup to use less temporaries. + (vect_create_data_ref_ptr): Cleanup. + +2013-03-18 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/56635 + * fold-const.c (operand_equal_p): For MEM_REF and TARGET_MEM_REF, + require types_compatible_p types. + +2013-03-18 Nick Clifton <nickc@redhat.com> + + * config/stormy16/stormy16.c (xstormy16_expand_prologue): Remove + spurious backslash. + + * config/mn10300/mn10300.c (mn10300_get_live_callee_saved_regs): + Add missing line to comment describing function. + +2013-03-18 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56210 + * tree-ssa-structalias.c (find_func_aliases_for_builtin_call): + Handle string / character search functions. + * tree-ssa-alias.c (ref_maybe_used_by_call_p_1): Likewise. + +2013-03-18 Richard Biener <rguenther@suse.de> + + PR middle-end/56483 + * cfgexpand.c (expand_gimple_cond): Inline gimple_cond_single_var_p + and implement properly. + * gimple.h (gimple_cond_single_var_p): Remove. + +2013-03-18 Richard Biener <rguenther@suse.de> + + * tree-data-ref.h (find_data_references_in_loop): Declare. + * tree-data-ref.c (get_references_in_stmt): Use a stack + vector pre-allocated in the callers. + (find_data_references_in_stmt): Adjust. + (graphite_find_data_references_in_stmt): Likewise. + (create_rdg_vertices): Likewise. + (find_data_references_in_loop): Export. + * tree-vect-data-refs.c (vect_analyze_data_ref_dependences): + Compute dependences here... + (vect_analyze_data_refs): ...not here. When we encounter + a non-vectorizable data reference in basic-block vectorization + truncate the data reference vector. Do not bother to + fixup data-dependence information for gather loads. + * tree-vect-slp.c (vect_slp_analyze_bb_1): Check the number + of data references, as reported. + +2013-03-18 Richard Biener <rguenther@suse.de> + + PR tree-optimization/3713 + * tree-ssa-sccvn.c (visit_copy): Simplify. Always propagate + has_constants and expr. + (stmt_has_constants): Properly valueize SSA names when deciding + whether the stmt has constants. + +2013-03-18 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-manip.c (find_uses_to_rename): Do not scan the + whole function when there is nothing to do. + * tree-ssa-loop.c (pass_vectorize): Remove TODO_update_ssa. + * tree-vectorizer.c (vectorize_loops): Update virtual and + loop-closed SSA once. + * tree-vect-loop.c (vect_transform_loop): Do not update SSA here. + +2013-03-18 Richard Biener <rguenther@suse.de> + + PR middle-end/56113 + * domwalk.c (bb_postorder): New global static. + (cmp_bb_postorder): New function. + (walk_dominator_tree): Replace scheme imposing an order for + visiting dominator sons by one sorting them at the time they + are pushed on the stack. + +2013-03-18 Richard Biener <rguenther@suse.de> + + PR tree-optimization/39326 + * tree-ssa-loop-im.c (refs_independent_p): Exploit symmetry. + (struct mem_ref): Replace mem member with ao_ref typed member. + (MEM_ANALYZABLE): Adjust. + (memref_eq): Likewise. + (mem_ref_alloc): Likewise. + (gather_mem_refs_stmt): Likewise. + (mem_refs_may_alias_p): Use the ao_ref to query the alias oracle. + (execute_sm_if_changed_flag_set): Adjust. + (execute_sm): Likewise. + (ref_always_accessed_p): Likewise. + (refs_independent_p): Likewise. + (can_sm_ref_p): Likewise. + +2013-03-18 Jakub Jelinek <jakub@redhat.com> + + PR c/56566 + * tree.c (tree_int_cst_min_precision): For integer_zerop (value) + return 1 even for !unsignedp. + +2013-03-17 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/i386.md (isa): Add x64 and nox64. + (enabled): Define x64 for TARGET_64BIT and nox64 for !TARGET_64BIT. + (*pushtf): Enable *roF alternative for x64 isa only. + (*pushxf): Merge with *pushxf_nointeger. Use Yx*r constraint. Set + mode attribute of integer alternatives to DImode for TARGET_64BIT. + (*pushdf): Merge with *pushdf_rex64. Use x64 and nox64 isa attributes. + (*movtf_internal): Merge from *movtf_internal_rex64 and + *movtf_internal_sse. Use x64 and nox64 isa attributes. + (*movxf_internal): Merge with *movxf_internal_rex64. Use x64 and + nox64 isa attributes. + (*movdf_internal): Merge with *movdf_internal_rex64. Use x64 and + nox64 isa attributes. + * config/i386/constraints.md (Yd): Do not set for TARGET_64BIT. + +2013-03-17 Uros Bizjak <ubizjak@gmail.com> + + * config/alpha/alpha.c (TARGET_LRA_P): New define. + +2013-03-17 Jakub Jelinek <jakub@redhat.com> + + PR target/56640 + * config/arm/arm.h (REG_CLASS_NAMES): Add "SFP_REG" and "AFP_REG" + class names. Remove trailing comma after "ALL_REGS". + +2013-03-16 Jan Hubicka <jh@suse.cz> + + * cgraph.h (cgraph_get_create_real_symbol_node): Declare. + * cgraph.c (cgraph_get_create_real_symbol_node): New function. + * cgrpahbuild.c: Use cgraph_get_create_real_symbol_node instead + of cgraph_get_create_node. + * ipa-prop.c (ipa_make_edge_direct_to_target): Likewise. + +2013-03-16 Jason Merrill <jason@redhat.com> + + PR debug/49090 + * dwarf2out.c (gen_generic_params_dies): Indicate default arguments + with DW_AT_default_value. + +2013-03-16 Jakub Jelinek <jakub@redhat.com> + + * BASE-VER: Set to 4.9.0. + 2013-03-14 Andi Kleen <ak@linux.intel.com> PR target/56619 @@ -5,35 +200,36 @@ __ATOMIC_HLE_RELEASE. Document __builtin_ia32 TSX intrincs. Document _x* TSX intrinsics. -2013-03-14 Edgar E. Iglesias <edgar.iglesias@xilinx.com> - David Holsgrove <david.holsgrove@xilinx.com> +2013-03-14 Edgar E. Iglesias <edgar.iglesias@xilinx.com> + David Holsgrove <david.holsgrove@xilinx.com> * configure.ac: Add MicroBlaze TLS support detection. * configure: Regenerate. - * config/microblaze/microblaze-protos.h: (microblaze_cannot_force_const_mem, - microblaze_tls_referenced_p, symbol_mentioned_p, label_mentioned_p): - Add prototypes. - * config/microblaze/microblaze.c (microblaze_address_type): Add ADDRESS_TLS - and tls_reloc address types. + * config/microblaze/microblaze-protos.h + (microblaze_cannot_force_const_mem, microblaze_tls_referenced_p, + symbol_mentioned_p, label_mentioned_p): Add prototypes. + * config/microblaze/microblaze.c (microblaze_address_type): Add + ADDRESS_TLS and tls_reloc address types. (microblaze_address_info): Add tls_reloc. (TARGET_HAVE_TLS): Define. (get_tls_get_addr, microblaze_tls_symbol_p, microblaze_tls_operand_p_1, microblaze_tls_referenced_p, microblaze_cannot_force_const_mem, - symbol_mentioned_p, label_mentioned_p, tls_mentioned_p, load_tls_operand, - microblaze_call_tls_get_addr, microblaze_legitimize_tls_address): New functions. + symbol_mentioned_p, label_mentioned_p, tls_mentioned_p, + load_tls_operand, microblaze_call_tls_get_addr, + microblaze_legitimize_tls_address): New functions. (microblaze_classify_unspec): Handle UNSPEC_TLS. (get_base_reg): Use microblaze_tls_symbol_p. (microblaze_classify_address): Handle TLS. - (microblaze_legitimate_pic_operand): Use symbol_mentioned_p, label_mentioned_p - and microblaze_tls_referenced_p. + (microblaze_legitimate_pic_operand): Use symbol_mentioned_p, + label_mentioned_p and microblaze_tls_referenced_p. (microblaze_legitimize_address): Handle TLS. (microblaze_address_insns): Handle ADDRESS_TLS. (pic_address_needs_scratch): Handle TLS. (print_operand_address): Handle TLS. (microblaze_expand_prologue): Check TLS_NEEDS_GOT. (microblaze_expand_move): Handle TLS. - (microblaze_legitimate_constant_p): Check microblaze_cannot_force_const_mem - and microblaze_tls_symbol_p. + (microblaze_legitimate_constant_p): Check + microblaze_cannot_force_const_mem and microblaze_tls_symbol_p. (TARGET_CANNOT_FORCE_CONST_MEM): Define. * config/microblaze/microblaze.h (TLS_NEEDS_GOT): Define (PIC_OFFSET_TABLE_REGNUM): Set. @@ -41,7 +237,8 @@ * config/microblaze/microblaze.md (UNSPEC_TLS): Define. (addsi3, movsi_internal2, movdf_internal): Update constraints * config/microblaze/predicates.md (arith_plus_operand): Define - (move_operand): Redefine as move_src_operand, check microblaze_tls_referenced_p. + (move_operand): Redefine as move_src_operand, + check microblaze_tls_referenced_p. 2013-03-14 Ian Bolton <ian.bolton@arm.com> @@ -139,7 +336,7 @@ PR target/56591 * config/avr/avr.c (avr_print_operand): Add space after '%c' in output_operand_lossage message. - + 2013-03-11 Richard Earnshaw <rearnsha@arm.com> PR target/56470 @@ -484,9 +681,9 @@ 2013-03-04 David Holsgrove <david.holsgrove@xilinx.com> - * config/microblaze/microblaze.c (microblaze_valid_pic_const): New + * config/microblaze/microblaze.c (microblaze_valid_pic_const): New (microblaze_legitimate_pic_operand): Likewise - * config/microblaze/microblaze.h (LEGITIMATE_PIC_OPERAND_P): calls + * config/microblaze/microblaze.h (LEGITIMATE_PIC_OPERAND_P): calls new function microblaze_legitimate_pic_operand * config/microblaze/microblaze-protos.h (microblaze_legitimate_pic_operand): Declare. @@ -538,8 +735,8 @@ DRIVER_SELF_SPECS. * config/microblaze/microblaze.md: New bswapsi2 and bswaphi2. instructions emitted if TARGET_REORDER. - * config/microblaze/microblaze.opt: New option -mxl-reorder set to 1 - or 0 for -m/-mno case, but initialises as 2 to detect default use case + * config/microblaze/microblaze.opt: New option -mxl-reorder set to 1 + or 0 for -m/-mno case, but initialises as 2 to detect default use case separately. 2013-03-01 Xinliang David Li <davidxl@google.com> @@ -709,8 +906,7 @@ pointer_set_destroy on not_executed_last_iteration. PR middle-end/56461 - * tree-vect-loop.c (vectorizable_reduction): Release vect_defs - vector. + * tree-vect-loop.c (vectorizable_reduction): Release vect_defs vector. PR middle-end/56461 * ipa-pure-const.c (propagate): Use FOR_EACH_FUNCTION instead of @@ -826,8 +1022,7 @@ 2013-02-26 Marek Polacek <polacek@redhat.com> PR tree-optimization/56426 - * tree-ssa-loop.c (tree_ssa_loop_init): Always call - scev_initialize. + * tree-ssa-loop.c (tree_ssa_loop_init): Always call scev_initialize. 2013-02-26 Richard Biener <rguenther@suse.de> @@ -871,8 +1066,9 @@ Iain Sandoe <iain@codesourcery.com> Nathan Froyd <froydnj@codesourcery.com> Chao-ying Fu <fu@mips.com> + * doc/extend.texi: (micromips, nomicromips, nocompression): - Document new function attributes. + Document new function attributes. * doc/invoke.texi (minterlink-compressed, mmicromips, m14k, m14ke, m14kec): Document new options. (minterlink-mips16): Update documentation. @@ -1022,7 +1218,7 @@ Chao-ying Fu <fu@mips.com> * doc/extend.texi: (micromips, nomicromips, nocompression): - Document new function attributes. + Document new function attributes. * doc/invoke.texi (minterlink-compressed, mmicromips, m14k, m14ke, m14kec): Document new options. (minterlink-mips16): Update documentation. @@ -1257,8 +1453,8 @@ 2013-02-20 Jan Hubicka <jh@suse.cz> PR tree-optimization/56265 - * ipa-prop.c (ipa_make_edge_direct_to_target): Fixup callgraph when target is - referenced for firs ttime. + * ipa-prop.c (ipa_make_edge_direct_to_target): Fixup callgraph + when target is referenced for first time. 2013-02-20 Richard Biener <rguenther@suse.de> @@ -1269,8 +1465,7 @@ not return anything. (rename_ssa_copies): Do not remove unused locals. * tree-ssa-ccp.c (do_ssa_ccp): Likewise. - * tree-ssanames.c (pass_release_ssa_names): Remove unused - locals first. + * tree-ssanames.c (pass_release_ssa_names): Remove unused locals first. * passes.c (execute_function_todo): Do not schedule unused locals removal if cleanup_tree_cfg did something. * tree-ssa-live.c (remove_unused_locals): Dump statistics @@ -1279,8 +1474,7 @@ 2013-02-20 Richard Biener <rguenther@suse.de> PR tree-optimization/56398 - * tree-vect-loop-manip.c (adjust_debug_stmts): Skip - SSA default defs. + * tree-vect-loop-manip.c (adjust_debug_stmts): Skip SSA default defs. 2013-02-20 Martin Jambor <mjambor@suse.cz> @@ -1289,7 +1483,7 @@ restricted pointers to arrays. 2013-02-20 Richard Biener <rguenther@suse.de> - Jakub Jelinek <jakub@redhat.com> + Jakub Jelinek <jakub@redhat.com> PR tree-optimization/56396 * tree-ssa-ccp.c (n_const_val): New static variable. @@ -1326,7 +1520,7 @@ * config/microblaze/microblaze.c: microblaze_has_clz = 0 Add version check for v8.10.a to enable microblaze_has_clz - * config/microblaze/microblaze.h: Add TARGET_HAS_CLZ as combined + * config/microblaze/microblaze.h: Add TARGET_HAS_CLZ as combined version and TARGET_PATTERN_COMPARE check * config/microblaze/microblaze.md: New clzsi2 instruction @@ -1344,11 +1538,10 @@ 2012-02-19 Andrey Belevantsev <abel@ispras.ru> PR middle-end/55889 - * sel-sched.c: Include ira.h. (implicit_clobber_conflict_p): New function. (moveup_expr): Use it. - * Makefile.in (sel-sched.o): Depend on ira.h. + * Makefile.in (sel-sched.o): Depend on ira.h. 2013-02-19 Richard Biener <rguenther@suse.de> @@ -1379,8 +1572,7 @@ * genopinit.c (raw_optab_handler): Use this_fn_optabs. (swap_optab_enable): Same. (init_all_optabs): Use argument instead of global. - * tree.h (struct tree_optimization_option): New field - target_optabs. + * tree.h (struct tree_optimization_option): New field target_optabs. * expr.h (init_all_optabs): Add argument to prototype. (TREE_OPTIMIZATION_OPTABS): New. (save_optabs_if_changed): Protoize. @@ -1404,8 +1596,8 @@ PR target/56214 * config/pa/predicates.md (base14_operand): Except for BLKmode, QImode - and HImode, require all displacements to be an integer multiple of their - mode size. + and HImode, require all displacements to be an integer multiple of + their mode size. * config/pa/pa.c (pa_legitimate_address_p): For REG+BASE addresses, only allow QImode and HImode when reload is in progress and strict is true. Likewise for symbolic addresses. Use base14_operand to check @@ -1446,18 +1638,17 @@ 2013-02-16 Edgar E. Iglesias <edgar.iglesias@gmail.com> - * config/microblaze/microblaze.c (microblaze_asm_trampoline_template): + * config/microblaze/microblaze.c (microblaze_asm_trampoline_template): Replace with a microblaze version. (microblaze_trampoline_init): Adapt for microblaze. - * gcc/config/microblaze/microblaze.h (TRAMPOLINE_SIZE): Adapt for + * config/microblaze/microblaze.h (TRAMPOLINE_SIZE): Adapt for microblaze. 2013-02-16 Jakub Jelinek <jakub@redhat.com> Dodji Seketeli <dodji@redhat.com> PR asan/56330 - * asan.c (get_mem_refs_of_builtin_call): White space and style - cleanup. + * asan.c (get_mem_refs_of_builtin_call): White space and style cleanup. (instrument_mem_region_access): Do not forget to always put instrumentation of the of 'base' and 'base + len' in a "if (len != 0) statement, even for cases where either 'base' or 'base + len' @@ -1547,13 +1738,12 @@ re-initializing preserved loops. * loop-unswitch.c (unswitch_single_loop): Return whether we unswitched the loop. Do not verify loop state here. - (unswitch_loops): When we unswitched a loop discover new - loops. + (unswitch_loops): When we unswitched a loop discover new loops. 2013-02-13 Kostya Serebryany <kcc@google.com> - * config/i386/i386.c: Use 0x7fff8000 as asan_shadow_offset on x86_64 - linux. + * config/i386/i386.c: Use 0x7fff8000 as asan_shadow_offset + on x86_64 linux. * sanitizer.def: Rename __asan_init to __asan_init_v1. 2013-02-12 Dodji Seketeli <dodji@redhat.com> diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 70b5b3b51d8..288f9b4f7ba 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20130316 +20130320 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 784448558ad..fb2ca01de45 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,7 @@ +2013-03-16 Eric Botcazou <ebotcazou@adacore.com> + + * gnatvsn.ads (Library_Version): Bump to 4.9. + 2013-03-08 Cesar Strauss <cestrauss@gmail.com> PR ada/52123 diff --git a/gcc/ada/gnatvsn.ads b/gcc/ada/gnatvsn.ads index 418be05b750..c680ec2dea0 100644 --- a/gcc/ada/gnatvsn.ads +++ b/gcc/ada/gnatvsn.ads @@ -82,7 +82,7 @@ package Gnatvsn is -- Prefix generated by binder. If it is changed, be sure to change -- GNAT.Compiler_Version.Ver_Prefix as well. - Library_Version : constant String := "4.8"; + Library_Version : constant String := "4.9"; -- Library version. This value must be updated when the compiler -- version number Gnat_Static_Version_String is updated. -- diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index 5acc42d73f5..7242b2107f4 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -1886,9 +1886,14 @@ expand_gimple_cond (basic_block bb, gimple stmt) be cleaned up by combine. But some pattern matchers like if-conversion work better when there's only one compare, so make up for this here as special exception if TER would have made the same change. */ - if (gimple_cond_single_var_p (stmt) - && SA.values + if (SA.values && TREE_CODE (op0) == SSA_NAME + && TREE_CODE (TREE_TYPE (op0)) == BOOLEAN_TYPE + && TREE_CODE (op1) == INTEGER_CST + && ((gimple_cond_code (stmt) == NE_EXPR + && integer_zerop (op1)) + || (gimple_cond_code (stmt) == EQ_EXPR + && integer_onep (op1))) && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0))) { gimple second = SSA_NAME_DEF_STMT (op0); diff --git a/gcc/cgraph.c b/gcc/cgraph.c index 79d686b6186..930ccd862fe 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -2595,4 +2595,47 @@ verify_cgraph (void) FOR_EACH_FUNCTION (node) verify_cgraph_node (node); } + +/* Create external decl node for DECL. + The difference i nbetween cgraph_get_create_node and + cgraph_get_create_real_symbol_node is that cgraph_get_create_node + may return inline clone, while cgraph_get_create_real_symbol_node + will create a new node in this case. + FIXME: This function should be removed once clones are put out of decl + hash. */ + +struct cgraph_node * +cgraph_get_create_real_symbol_node (tree decl) +{ + struct cgraph_node *first_clone = cgraph_get_node (decl); + struct cgraph_node *node; + /* create symbol table node. even if inline clone exists, we can not take + it as a target of non-inlined call. */ + node = cgraph_get_node (decl); + if (node && !node->global.inlined_to) + return node; + + node = cgraph_create_node (decl); + + /* ok, we previously inlined the function, then removed the offline copy and + now we want it back for external call. this can happen when devirtualizing + while inlining function called once that happens after extern inlined and + virtuals are already removed. in this case introduce the external node + and make it available for call. */ + if (first_clone) + { + first_clone->clone_of = node; + node->clones = first_clone; + symtab_prevail_in_asm_name_hash ((symtab_node) node); + symtab_insert_node_to_hashtable ((symtab_node) node); + if (dump_file) + fprintf (dump_file, "Introduced new external node " + "(%s/%i) and turned into root of the clone tree.\n", + xstrdup (cgraph_node_name (node)), node->uid); + } + else if (dump_file) + fprintf (dump_file, "Introduced new external node " + "(%s/%i).\n", xstrdup (cgraph_node_name (node)), node->uid); + return node; +} #include "gt-cgraph.h" diff --git a/gcc/cgraph.h b/gcc/cgraph.h index 5df7fb478b4..8ab7ae18102 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -575,6 +575,7 @@ struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void); struct cgraph_node * cgraph_create_node (tree); struct cgraph_node * cgraph_create_empty_node (void); struct cgraph_node * cgraph_get_create_node (tree); +struct cgraph_node * cgraph_get_create_real_symbol_node (tree); struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree); struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT, HOST_WIDE_INT, tree, tree); diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c index fb01f24ec07..a74a4c043e3 100644 --- a/gcc/cgraphbuild.c +++ b/gcc/cgraphbuild.c @@ -73,7 +73,7 @@ record_reference (tree *tp, int *walk_subtrees, void *data) decl = get_base_var (*tp); if (TREE_CODE (decl) == FUNCTION_DECL) { - struct cgraph_node *node = cgraph_get_create_node (decl); + struct cgraph_node *node = cgraph_get_create_real_symbol_node (decl); if (!ctx->only_vars) cgraph_mark_address_taken_node (node); ipa_record_reference ((symtab_node)ctx->varpool_node, @@ -143,7 +143,7 @@ record_eh_tables (struct cgraph_node *node, struct function *fun) { struct cgraph_node *per_node; - per_node = cgraph_get_create_node (DECL_FUNCTION_PERSONALITY (node->symbol.decl)); + per_node = cgraph_get_create_real_symbol_node (DECL_FUNCTION_PERSONALITY (node->symbol.decl)); ipa_record_reference ((symtab_node)node, (symtab_node)per_node, IPA_REF_ADDR, NULL); cgraph_mark_address_taken_node (per_node); } @@ -223,7 +223,7 @@ mark_address (gimple stmt, tree addr, void *data) addr = get_base_address (addr); if (TREE_CODE (addr) == FUNCTION_DECL) { - struct cgraph_node *node = cgraph_get_create_node (addr); + struct cgraph_node *node = cgraph_get_create_real_symbol_node (addr); cgraph_mark_address_taken_node (node); ipa_record_reference ((symtab_node)data, (symtab_node)node, @@ -252,7 +252,7 @@ mark_load (gimple stmt, tree t, void *data) { /* ??? This can happen on platforms with descriptors when these are directly manipulated in the code. Pretend that it's an address. */ - struct cgraph_node *node = cgraph_get_create_node (t); + struct cgraph_node *node = cgraph_get_create_real_symbol_node (t); cgraph_mark_address_taken_node (node); ipa_record_reference ((symtab_node)data, (symtab_node)node, @@ -330,7 +330,7 @@ build_cgraph_edges (void) { tree fn = gimple_omp_parallel_child_fn (stmt); ipa_record_reference ((symtab_node)node, - (symtab_node)cgraph_get_create_node (fn), + (symtab_node)cgraph_get_create_real_symbol_node (fn), IPA_REF_ADDR, stmt); } if (gimple_code (stmt) == GIMPLE_OMP_TASK) @@ -338,12 +338,12 @@ build_cgraph_edges (void) tree fn = gimple_omp_task_child_fn (stmt); if (fn) ipa_record_reference ((symtab_node)node, - (symtab_node) cgraph_get_create_node (fn), + (symtab_node) cgraph_get_create_real_symbol_node (fn), IPA_REF_ADDR, stmt); fn = gimple_omp_task_copy_fn (stmt); if (fn) ipa_record_reference ((symtab_node)node, - (symtab_node)cgraph_get_create_node (fn), + (symtab_node)cgraph_get_create_real_symbol_node (fn), IPA_REF_ADDR, stmt); } } diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index 76a51259728..c99e188a7b5 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -1790,6 +1790,34 @@ (set_attr "mode" "SI")] ) +(define_insn "*sub<mode>3_carryin" + [(set + (match_operand:GPI 0 "register_operand" "=r") + (minus:GPI (minus:GPI + (match_operand:GPI 1 "register_operand" "r") + (ltu:GPI (reg:CC CC_REGNUM) (const_int 0))) + (match_operand:GPI 2 "register_operand" "r")))] + "" + "sbc\\t%<w>0, %<w>1, %<w>2" + [(set_attr "v8type" "adc") + (set_attr "mode" "<MODE>")] +) + +;; zero_extend version of the above +(define_insn "*subsi3_carryin_uxtw" + [(set + (match_operand:DI 0 "register_operand" "=r") + (zero_extend:DI + (minus:SI (minus:SI + (match_operand:SI 1 "register_operand" "r") + (ltu:SI (reg:CC CC_REGNUM) (const_int 0))) + (match_operand:SI 2 "register_operand" "r"))))] + "" + "sbc\\t%w0, %w1, %w2" + [(set_attr "v8type" "adc") + (set_attr "mode" "SI")] +) + (define_insn "*sub_uxt<mode>_multp2" [(set (match_operand:GPI 0 "register_operand" "=rk") (minus:GPI (match_operand:GPI 4 "register_operand" "r") @@ -2703,6 +2731,62 @@ (set_attr "mode" "<MODE>")] ) +(define_insn "*extr<mode>5_insn" + [(set (match_operand:GPI 0 "register_operand" "=r") + (ior:GPI (ashift:GPI (match_operand:GPI 1 "register_operand" "r") + (match_operand 3 "const_int_operand" "n")) + (lshiftrt:GPI (match_operand:GPI 2 "register_operand" "r") + (match_operand 4 "const_int_operand" "n"))))] + "UINTVAL (operands[3]) < GET_MODE_BITSIZE (<MODE>mode) && + (UINTVAL (operands[3]) + UINTVAL (operands[4]) == GET_MODE_BITSIZE (<MODE>mode))" + "extr\\t%<w>0, %<w>1, %<w>2, %4" + [(set_attr "v8type" "shift") + (set_attr "mode" "<MODE>")] +) + +;; zero_extend version of the above +(define_insn "*extrsi5_insn_uxtw" + [(set (match_operand:DI 0 "register_operand" "=r") + (zero_extend:DI + (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "r") + (match_operand 3 "const_int_operand" "n")) + (lshiftrt:SI (match_operand:SI 2 "register_operand" "r") + (match_operand 4 "const_int_operand" "n")))))] + "UINTVAL (operands[3]) < 32 && + (UINTVAL (operands[3]) + UINTVAL (operands[4]) == 32)" + "extr\\t%w0, %w1, %w2, %4" + [(set_attr "v8type" "shift") + (set_attr "mode" "SI")] +) + +(define_insn "*ror<mode>3_insn" + [(set (match_operand:GPI 0 "register_operand" "=r") + (rotate:GPI (match_operand:GPI 1 "register_operand" "r") + (match_operand 2 "const_int_operand" "n")))] + "UINTVAL (operands[2]) < GET_MODE_BITSIZE (<MODE>mode)" +{ + operands[3] = GEN_INT (<sizen> - UINTVAL (operands[2])); + return "ror\\t%<w>0, %<w>1, %3"; +} + [(set_attr "v8type" "shift") + (set_attr "mode" "<MODE>")] +) + +;; zero_extend version of the above +(define_insn "*rorsi3_insn_uxtw" + [(set (match_operand:DI 0 "register_operand" "=r") + (zero_extend:DI + (rotate:SI (match_operand:SI 1 "register_operand" "r") + (match_operand 2 "const_int_operand" "n"))))] + "UINTVAL (operands[2]) < 32" +{ + operands[3] = GEN_INT (32 - UINTVAL (operands[2])); + return "ror\\t%w0, %w1, %3"; +} + [(set_attr "v8type" "shift") + (set_attr "mode" "SI")] +) + (define_insn "*<ANY_EXTEND:optab><GPI:mode>_ashl<SHORT:mode>" [(set (match_operand:GPI 0 "register_operand" "=r") (ANY_EXTEND:GPI diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c index 6926055f206..15cfd5ea866 100644 --- a/gcc/config/alpha/alpha.c +++ b/gcc/config/alpha/alpha.c @@ -9872,6 +9872,9 @@ alpha_canonicalize_comparison (int *code, rtx *op0, rtx *op1, #undef TARGET_LEGITIMATE_ADDRESS_P #define TARGET_LEGITIMATE_ADDRESS_P alpha_legitimate_address_p +#undef TARGET_LRA_P +#define TARGET_LRA_P hook_bool_void_true + #undef TARGET_CONDITIONAL_REGISTER_USAGE #define TARGET_CONDITIONAL_REGISTER_USAGE alpha_conditional_register_usage diff --git a/gcc/config/arm/arm.h b/gcc/config/arm/arm.h index 6d336e89ee9..05aea3577d7 100644 --- a/gcc/config/arm/arm.h +++ b/gcc/config/arm/arm.h @@ -1166,7 +1166,9 @@ enum reg_class "IWMMXT_GR_REGS", \ "CC_REG", \ "VFPCC_REG", \ - "ALL_REGS", \ + "SFP_REG", \ + "AFP_REG", \ + "ALL_REGS" \ } /* Define which registers fit in which classes. diff --git a/gcc/config/i386/constraints.md b/gcc/config/i386/constraints.md index d567fd78693..ec7c856c1ac 100644 --- a/gcc/config/i386/constraints.md +++ b/gcc/config/i386/constraints.md @@ -116,8 +116,7 @@ "@internal Any integer register when zero extensions with AND are disabled.") (define_register_constraint "Yd" - "(TARGET_64BIT - || (TARGET_INTEGER_DFMODE_MOVES && optimize_function_for_speed_p (cfun))) + "TARGET_INTEGER_DFMODE_MOVES && optimize_function_for_speed_p (cfun) ? GENERAL_REGS : NO_REGS" "@internal Any integer register when integer DFmode moves are enabled.") diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index 24d1012d5ce..e7eaabb333c 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -651,12 +651,14 @@ (define_attr "movu" "0,1" (const_string "0")) ;; Used to control the "enabled" attribute on a per-instruction basis. -(define_attr "isa" "base,sse2,sse2_noavx,sse3,sse4,sse4_noavx,noavx,avx, - avx2,noavx2,bmi2,fma4,fma" +(define_attr "isa" "base,x64,nox64,sse2,sse2_noavx,sse3,sse4,sse4_noavx, + noavx,avx,avx2,noavx2,bmi2,fma4,fma" (const_string "base")) (define_attr "enabled" "" - (cond [(eq_attr "isa" "sse2") (symbol_ref "TARGET_SSE2") + (cond [(eq_attr "isa" "x64") (symbol_ref "TARGET_64BIT") + (eq_attr "isa" "nox64") (symbol_ref "!TARGET_64BIT") + (eq_attr "isa" "sse2") (symbol_ref "TARGET_SSE2") (eq_attr "isa" "sse2_noavx") (symbol_ref "TARGET_SSE2 && !TARGET_AVX") (eq_attr "isa" "sse3") (symbol_ref "TARGET_SSE3") @@ -1654,6 +1656,40 @@ ;; Move instructions. +;; Reload patterns to support multi-word load/store +;; with non-offsetable address. +(define_expand "reload_noff_store" + [(parallel [(match_operand 0 "memory_operand" "=m") + (match_operand 1 "register_operand" "r") + (match_operand:DI 2 "register_operand" "=&r")])] + "TARGET_64BIT" +{ + rtx mem = operands[0]; + rtx addr = XEXP (mem, 0); + + emit_move_insn (operands[2], addr); + mem = replace_equiv_address_nv (mem, operands[2]); + + emit_insn (gen_rtx_SET (VOIDmode, mem, operands[1])); + DONE; +}) + +(define_expand "reload_noff_load" + [(parallel [(match_operand 0 "register_operand" "=r") + (match_operand 1 "memory_operand" "m") + (match_operand:DI 2 "register_operand" "=r")])] + "TARGET_64BIT" +{ + rtx mem = operands[1]; + rtx addr = XEXP (mem, 0); + + emit_move_insn (operands[2], addr); + mem = replace_equiv_address_nv (mem, operands[2]); + + emit_insn (gen_rtx_SET (VOIDmode, operands[0], mem)); + DONE; +}) + (define_expand "movoi" [(set (match_operand:OI 0 "nonimmediate_operand") (match_operand:OI 1 "general_operand"))] @@ -1758,10 +1794,11 @@ ] (const_string "OI")))]) -(define_insn "*movti_internal_rex64" +(define_insn "*movti_internal" [(set (match_operand:TI 0 "nonimmediate_operand" "=!r ,o ,x,x ,m") (match_operand:TI 1 "general_operand" "riFo,re,C,xm,x"))] - "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))" + "(TARGET_64BIT || TARGET_SSE) + && !(MEM_P (operands[0]) && MEM_P (operands[1]))" { switch (which_alternative) { @@ -1793,12 +1830,14 @@ gcc_unreachable (); } } - [(set_attr "type" "*,*,sselog1,ssemov,ssemov") + [(set_attr "isa" "x64,x64,*,*,*") + (set_attr "type" "*,*,sselog1,ssemov,ssemov") (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex") (set (attr "mode") (cond [(eq_attr "alternative" "0,1") (const_string "DI") - (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") + (ior (not (match_test "TARGET_SSE2")) + (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")) (const_string "V4SF") (and (eq_attr "alternative" "4") (match_test "TARGET_SSE_TYPELESS_STORES")) @@ -1818,81 +1857,20 @@ [(const_int 0)] "ix86_split_long_move (operands); DONE;") -(define_insn "*movti_internal_sse" - [(set (match_operand:TI 0 "nonimmediate_operand" "=x,x ,m") - (match_operand:TI 1 "vector_move_operand" "C ,xm,x"))] - "TARGET_SSE && !TARGET_64BIT - && !(MEM_P (operands[0]) && MEM_P (operands[1]))" -{ - switch (which_alternative) - { - case 0: - return standard_sse_constant_opcode (insn, operands[1]); - case 1: - case 2: - /* TDmode values are passed as TImode on the stack. Moving them - to stack may result in unaligned memory access. */ - if (misaligned_operand (operands[0], TImode) - || misaligned_operand (operands[1], TImode)) - { - if (get_attr_mode (insn) == MODE_V4SF) - return "%vmovups\t{%1, %0|%0, %1}"; - else - return "%vmovdqu\t{%1, %0|%0, %1}"; - } - else - { - if (get_attr_mode (insn) == MODE_V4SF) - return "%vmovaps\t{%1, %0|%0, %1}"; - else - return "%vmovdqa\t{%1, %0|%0, %1}"; - } - default: - gcc_unreachable (); - } -} - [(set_attr "type" "sselog1,ssemov,ssemov") - (set_attr "prefix" "maybe_vex") - (set (attr "mode") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") - (const_string "V4SF") - (and (eq_attr "alternative" "2") - (match_test "TARGET_SSE_TYPELESS_STORES")) - (const_string "V4SF") - (match_test "TARGET_AVX") - (const_string "TI") - (ior (not (match_test "TARGET_SSE2")) - (match_test "optimize_function_for_size_p (cfun)")) - (const_string "V4SF") - ] - (const_string "TI")))]) - -(define_insn "*movdi_internal_rex64" +(define_insn "*movdi_internal" [(set (match_operand:DI 0 "nonimmediate_operand" - "=r,r ,r,m ,*y,m*y,?*y,?r ,?*Ym,*x,m ,*x,*x,?r ,?*Yi,?*x,?*Ym") + "=r ,o ,r,r ,r,m ,*y,m*y,*y,?*y,?r ,?*Ym,*x,m ,*x,*x,?r ,?*Yi,?*x,?*Ym") (match_operand:DI 1 "general_operand" - "Z ,rem,i,re,C ,*y ,m ,*Ym,r ,C ,*x,*x,m ,*Yi,r ,*Ym,*x"))] - "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))" + "riFo,riF,Z,rem,i,re,C ,*y ,m ,m ,*Ym,r ,C ,*x,*x,m ,*Yi,r ,*Ym,*x"))] + "!(MEM_P (operands[0]) && MEM_P (operands[1]))" { switch (get_attr_type (insn)) { - case TYPE_SSECVT: - if (SSE_REG_P (operands[0])) - return "movq2dq\t{%1, %0|%0, %1}"; - else - return "movdq2q\t{%1, %0|%0, %1}"; - - case TYPE_SSEMOV: - if (get_attr_mode (insn) == MODE_V4SF) - return "%vmovaps\t{%1, %0|%0, %1}"; - else if (get_attr_mode (insn) == MODE_TI) - return "%vmovdqa\t{%1, %0|%0, %1}"; + case TYPE_MULTI: + return "#"; - /* Handle broken assemblers that require movd instead of movq. */ - if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1])) - return "%vmovd\t{%1, %0|%0, %1}"; - else - return "%vmovq\t{%1, %0|%0, %1}"; + case TYPE_MMX: + return "pxor\t%0, %0"; case TYPE_MMXMOV: /* Handle broken assemblers that require movd instead of movq. */ @@ -1904,8 +1882,27 @@ case TYPE_SSELOG1: return standard_sse_constant_opcode (insn, operands[1]); - case TYPE_MMX: - return "pxor\t%0, %0"; + case TYPE_SSEMOV: + switch (get_attr_mode (insn)) + { + case MODE_DI: + return "%vmovq\t{%1, %0|%0, %1}"; + case MODE_TI: + return "%vmovdqa\t{%1, %0|%0, %1}"; + case MODE_V4SF: + return "%vmovaps\t{%1, %0|%0, %1}"; + case MODE_V2SF: + gcc_assert (!TARGET_AVX); + return "movlps\t{%1, %0|%0, %1}"; + default: + gcc_unreachable (); + } + + case TYPE_SSECVT: + if (SSE_REG_P (operands[0])) + return "movq2dq\t{%1, %0|%0, %1}"; + else + return "movdq2q\t{%1, %0|%0, %1}"; case TYPE_LEA: return "lea{q}\t{%E1, %0|%0, %E1}"; @@ -1914,7 +1911,7 @@ gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1])); if (get_attr_mode (insn) == MODE_SI) return "mov{l}\t{%k1, %k0|%k0, %k1}"; - else if (which_alternative == 2) + else if (which_alternative == 4) return "movabs{q}\t{%1, %0|%0, %1}"; else if (ix86_use_lea_for_mov (insn, operands)) return "lea{q}\t{%E1, %0|%0, %E1}"; @@ -1922,16 +1919,27 @@ return "mov{q}\t{%1, %0|%0, %1}"; } } - [(set (attr "type") - (cond [(eq_attr "alternative" "4") + [(set (attr "isa") + (cond [(eq_attr "alternative" "0,1,8") + (const_string "nox64") + (eq_attr "alternative" "2,3,4,5,9,10,11,16,17") + (const_string "x64") + (eq_attr "alternative" "18,19") + (const_string "sse2") + ] + (const_string "*"))) + (set (attr "type") + (cond [(eq_attr "alternative" "0,1") + (const_string "multi") + (eq_attr "alternative" "6") (const_string "mmx") - (eq_attr "alternative" "5,6,7,8") + (eq_attr "alternative" "7,8,9,10,11") (const_string "mmxmov") - (eq_attr "alternative" "9") + (eq_attr "alternative" "12") (const_string "sselog1") - (eq_attr "alternative" "10,11,12,13,14") + (eq_attr "alternative" "13,14,15,16,17") (const_string "ssemov") - (eq_attr "alternative" "15,16") + (eq_attr "alternative" "18,19") (const_string "ssecvt") (match_operand 1 "pic_32bit_operand") (const_string "lea") @@ -1939,159 +1947,43 @@ (const_string "imov"))) (set (attr "modrm") (if_then_else - (and (eq_attr "alternative" "2") (eq_attr "type" "imov")) + (and (eq_attr "alternative" "4") (eq_attr "type" "imov")) (const_string "0") (const_string "*"))) (set (attr "length_immediate") (if_then_else - (and (eq_attr "alternative" "2") (eq_attr "type" "imov")) + (and (eq_attr "alternative" "4") (eq_attr "type" "imov")) (const_string "8") (const_string "*"))) (set (attr "prefix_rex") - (if_then_else (eq_attr "alternative" "7,8") - (const_string "1") - (const_string "*"))) - (set (attr "prefix_data16") - (if_then_else (eq_attr "alternative" "10") + (if_then_else (eq_attr "alternative" "10,11") (const_string "1") (const_string "*"))) (set (attr "prefix") - (if_then_else (eq_attr "alternative" "9,10,11,12,13,14") + (if_then_else (eq_attr "type" "sselog1,ssemov") (const_string "maybe_vex") (const_string "orig"))) + (set (attr "prefix_data16") + (if_then_else (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI")) + (const_string "1") + (const_string "*"))) (set (attr "mode") - (cond [(eq_attr "alternative" "0") - (const_string "SI") - (eq_attr "alternative" "9,11") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") - (const_string "V4SF") - (match_test "TARGET_AVX") - (const_string "TI") - (match_test "optimize_function_for_size_p (cfun)") - (const_string "V4SF") - ] - (const_string "TI")) - ] - (const_string "DI")))]) - -;; Reload patterns to support multi-word load/store -;; with non-offsetable address. -(define_expand "reload_noff_store" - [(parallel [(match_operand 0 "memory_operand" "=m") - (match_operand 1 "register_operand" "r") - (match_operand:DI 2 "register_operand" "=&r")])] - "TARGET_64BIT" -{ - rtx mem = operands[0]; - rtx addr = XEXP (mem, 0); - - emit_move_insn (operands[2], addr); - mem = replace_equiv_address_nv (mem, operands[2]); - - emit_insn (gen_rtx_SET (VOIDmode, mem, operands[1])); - DONE; -}) - -(define_expand "reload_noff_load" - [(parallel [(match_operand 0 "register_operand" "=r") - (match_operand 1 "memory_operand" "m") - (match_operand:DI 2 "register_operand" "=r")])] - "TARGET_64BIT" -{ - rtx mem = operands[1]; - rtx addr = XEXP (mem, 0); - - emit_move_insn (operands[2], addr); - mem = replace_equiv_address_nv (mem, operands[2]); - - emit_insn (gen_rtx_SET (VOIDmode, operands[0], mem)); - DONE; -}) - -(define_insn "*movdi_internal" - [(set (match_operand:DI 0 "nonimmediate_operand" - "=r ,o ,*y,m*y,*y,*x,m ,*x,*x,*x,m ,*x,*x,?*x,?*Ym") - (match_operand:DI 1 "general_operand" - "riFo,riF,C ,*y ,m ,C ,*x,*x,m ,C ,*x,*x,m ,*Ym,*x"))] - "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))" -{ - switch (get_attr_type (insn)) - { - case TYPE_SSECVT: - if (SSE_REG_P (operands[0])) - return "movq2dq\t{%1, %0|%0, %1}"; - else - return "movdq2q\t{%1, %0|%0, %1}"; - - case TYPE_SSEMOV: - switch (get_attr_mode (insn)) - { - case MODE_TI: - return "%vmovdqa\t{%1, %0|%0, %1}"; - case MODE_DI: - return "%vmovq\t{%1, %0|%0, %1}"; - case MODE_V4SF: - return "%vmovaps\t{%1, %0|%0, %1}"; - case MODE_V2SF: - return "movlps\t{%1, %0|%0, %1}"; - default: - gcc_unreachable (); - } - - case TYPE_MMXMOV: - return "movq\t{%1, %0|%0, %1}"; - - case TYPE_SSELOG1: - return standard_sse_constant_opcode (insn, operands[1]); - - case TYPE_MMX: - return "pxor\t%0, %0"; - - case TYPE_MULTI: - return "#"; + (cond [(eq_attr "alternative" "2") + (const_string "SI") + (eq_attr "alternative" "12,14") + (cond [(ior (not (match_test "TARGET_SSE2")) + (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")) + (const_string "V4SF") + (match_test "TARGET_AVX") + (const_string "TI") + (match_test "optimize_function_for_size_p (cfun)") + (const_string "V4SF") + ] + (const_string "TI")) - default: - gcc_unreachable (); - } -} - [(set (attr "isa") - (cond [(eq_attr "alternative" "5,6,7,8,13,14") - (const_string "sse2") - (eq_attr "alternative" "9,10,11,12") - (const_string "noavx") - ] - (const_string "*"))) - (set (attr "type") - (cond [(eq_attr "alternative" "0,1") - (const_string "multi") - (eq_attr "alternative" "2") - (const_string "mmx") - (eq_attr "alternative" "3,4") - (const_string "mmxmov") - (eq_attr "alternative" "5,9") - (const_string "sselog1") - (eq_attr "alternative" "13,14") - (const_string "ssecvt") - ] - (const_string "ssemov"))) - (set (attr "prefix") - (if_then_else (eq_attr "alternative" "5,6,7,8") - (const_string "maybe_vex") - (const_string "orig"))) - (set (attr "mode") - (cond [(eq_attr "alternative" "9,11") - (const_string "V4SF") - (eq_attr "alternative" "10,12") - (const_string "V2SF") - (eq_attr "alternative" "5,7") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") - (const_string "V4SF") - (match_test "TARGET_AVX") - (const_string "TI") - (match_test "optimize_function_for_size_p (cfun)") - (const_string "V4SF") - ] - (const_string "TI")) + (and (eq_attr "alternative" "13,15") + (not (match_test "TARGET_SSE2"))) + (const_string "V2SF") ] (const_string "DI")))]) @@ -2184,6 +2076,7 @@ (const_string "V4SF") ] (const_string "TI")) + (and (eq_attr "alternative" "8,9,10,11") (not (match_test "TARGET_SSE2"))) (const_string "SF") @@ -2582,16 +2475,17 @@ ;; Floating point push instructions. (define_insn "*pushtf" - [(set (match_operand:TF 0 "push_operand" "=<,<,<") - (match_operand:TF 1 "general_no_elim_operand" "x,Fo,*r"))] - "TARGET_SSE" + [(set (match_operand:TF 0 "push_operand" "=<,<") + (match_operand:TF 1 "general_no_elim_operand" "x,*roF"))] + "TARGET_64BIT || TARGET_SSE" { /* This insn should be already split before reg-stack. */ gcc_unreachable (); } - [(set_attr "type" "multi") - (set_attr "unit" "sse,*,*") - (set_attr "mode" "TF,SI,SI")]) + [(set_attr "isa" "*,x64") + (set_attr "type" "multi") + (set_attr "unit" "sse,*") + (set_attr "mode" "TF,DI")]) ;; %%% Kill this when call knows how to work this out. (define_split @@ -2603,33 +2497,21 @@ (define_insn "*pushxf" [(set (match_operand:XF 0 "push_operand" "=<,<") - (match_operand:XF 1 "general_no_elim_operand" "f,ro"))] - "optimize_function_for_speed_p (cfun)" -{ - /* This insn should be already split before reg-stack. */ - gcc_unreachable (); -} - [(set_attr "type" "multi") - (set_attr "unit" "i387,*") - (set_attr "mode" "XF,SI")]) - -;; Size of pushxf is 3 (for sub) + 2 (for fstp) + memory operand size. -;; Size of pushxf using integer instructions is 3+3*memory operand size -;; Pushing using integer instructions is longer except for constants -;; and direct memory references (assuming that any given constant is pushed -;; only once, but this ought to be handled elsewhere). - -(define_insn "*pushxf_nointeger" - [(set (match_operand:XF 0 "push_operand" "=<,<") - (match_operand:XF 1 "general_no_elim_operand" "f,*rFo"))] - "optimize_function_for_size_p (cfun)" + (match_operand:XF 1 "general_no_elim_operand" "f,Yx*roF"))] + "" { /* This insn should be already split before reg-stack. */ gcc_unreachable (); } [(set_attr "type" "multi") (set_attr "unit" "i387,*") - (set_attr "mode" "XF,SI")]) + (set (attr "mode") + (cond [(eq_attr "alternative" "1") + (if_then_else (match_test "TARGET_64BIT") + (const_string "DI") + (const_string "SI")) + ] + (const_string "XF")))]) ;; %%% Kill this when call knows how to work this out. (define_split @@ -2640,34 +2522,18 @@ (set (mem:XF (reg:P SP_REG)) (match_dup 1))] "operands[2] = GEN_INT (-GET_MODE_SIZE (XFmode));") -(define_insn "*pushdf_rex64" - [(set (match_operand:DF 0 "push_operand" "=<,<,<") - (match_operand:DF 1 "general_no_elim_operand" "f,Yd*rFm,x"))] - "TARGET_64BIT" -{ - /* This insn should be already split before reg-stack. */ - gcc_unreachable (); -} - [(set_attr "type" "multi") - (set_attr "unit" "i387,*,*") - (set_attr "mode" "DF,DI,DF")]) - -;; Size of pushdf is 3 (for sub) + 2 (for fstp) + memory operand size. -;; Size of pushdf using integer instructions is 2+2*memory operand size -;; On the average, pushdf using integers can be still shorter. - (define_insn "*pushdf" - [(set (match_operand:DF 0 "push_operand" "=<,<,<") - (match_operand:DF 1 "general_no_elim_operand" "f,Yd*rFo,x"))] - "!TARGET_64BIT" + [(set (match_operand:DF 0 "push_operand" "=<,<,<,<") + (match_operand:DF 1 "general_no_elim_operand" "f,Yd*roF,rmF,x"))] + "" { /* This insn should be already split before reg-stack. */ gcc_unreachable (); } - [(set_attr "isa" "*,*,sse2") + [(set_attr "isa" "*,nox64,x64,sse2") (set_attr "type" "multi") - (set_attr "unit" "i387,*,*") - (set_attr "mode" "DF,DI,DF")]) + (set_attr "unit" "i387,*,*,sse") + (set_attr "mode" "DF,SI,DI,DF")]) ;; %%% Kill this when call knows how to work this out. (define_split @@ -2692,7 +2558,7 @@ (define_insn "*pushsf" [(set (match_operand:SF 0 "push_operand" "=<,<,<") - (match_operand:SF 1 "general_no_elim_operand" "f,rFm,x"))] + (match_operand:SF 1 "general_no_elim_operand" "f,rmF,x"))] "!TARGET_64BIT" { /* Anything else should be already split before reg-stack. */ @@ -2736,10 +2602,7 @@ [(set (match_operand:TF 0 "nonimmediate_operand") (match_operand:TF 1 "nonimmediate_operand"))] "TARGET_64BIT || TARGET_SSE" -{ - ix86_expand_move (TFmode, operands); - DONE; -}) + "ix86_expand_move (TFmode, operands); DONE;") (define_expand "mov<mode>" [(set (match_operand:X87MODEF 0 "nonimmediate_operand") @@ -2747,10 +2610,11 @@ "" "ix86_expand_move (<MODE>mode, operands); DONE;") -(define_insn "*movtf_internal_rex64" +(define_insn "*movtf_internal" [(set (match_operand:TF 0 "nonimmediate_operand" "=x,x ,m,?*r ,!o") (match_operand:TF 1 "general_operand" "C ,xm,x,*roF,*rC"))] - "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1])) + "(TARGET_64BIT || TARGET_SSE) + && !(MEM_P (operands[0]) && MEM_P (operands[1])) && (!can_create_pseudo_p () || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) || GET_CODE (operands[1]) != CONST_DOUBLE @@ -2792,7 +2656,8 @@ gcc_unreachable (); } } - [(set_attr "type" "sselog1,ssemov,ssemov,*,*") + [(set_attr "isa" "*,*,*,x64,x64") + (set_attr "type" "sselog1,ssemov,ssemov,*,*") (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*") (set (attr "mode") (cond [(eq_attr "alternative" "3,4") @@ -2810,101 +2675,13 @@ ] (const_string "TI")))]) -(define_insn "*movtf_internal_sse" - [(set (match_operand:TF 0 "nonimmediate_operand" "=x,x ,m") - (match_operand:TF 1 "general_operand" "C ,xm,x"))] - "TARGET_SSE && !TARGET_64BIT - && !(MEM_P (operands[0]) && MEM_P (operands[1])) - && (!can_create_pseudo_p () - || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) - || GET_CODE (operands[1]) != CONST_DOUBLE - || (optimize_function_for_size_p (cfun) - && standard_sse_constant_p (operands[1]) - && !memory_operand (operands[0], TFmode)) - || (!TARGET_MEMORY_MISMATCH_STALL - && memory_operand (operands[0], TFmode)))" -{ - switch (which_alternative) - { - case 0: - return standard_sse_constant_opcode (insn, operands[1]); - case 1: - case 2: - /* Handle misaligned load/store since we - don't have movmisaligntf pattern. */ - if (misaligned_operand (operands[0], TFmode) - || misaligned_operand (operands[1], TFmode)) - { - if (get_attr_mode (insn) == MODE_V4SF) - return "%vmovups\t{%1, %0|%0, %1}"; - else - return "%vmovdqu\t{%1, %0|%0, %1}"; - } - else - { - if (get_attr_mode (insn) == MODE_V4SF) - return "%vmovaps\t{%1, %0|%0, %1}"; - else - return "%vmovdqa\t{%1, %0|%0, %1}"; - } - default: - gcc_unreachable (); - } -} - [(set_attr "type" "sselog1,ssemov,ssemov") - (set_attr "prefix" "maybe_vex") - (set (attr "mode") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") - (const_string "V4SF") - (and (eq_attr "alternative" "2") - (match_test "TARGET_SSE_TYPELESS_STORES")) - (const_string "V4SF") - (match_test "TARGET_AVX") - (const_string "TI") - (ior (not (match_test "TARGET_SSE2")) - (match_test "optimize_function_for_size_p (cfun)")) - (const_string "V4SF") - ] - (const_string "TI")))]) - -(define_insn "*movxf_internal_rex64" - [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,?Yx*r ,!o") - (match_operand:XF 1 "general_operand" "fm,f,G,Yx*roF,Yx*rC"))] - "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1])) - && (!can_create_pseudo_p () - || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) - || GET_CODE (operands[1]) != CONST_DOUBLE - || (optimize_function_for_size_p (cfun) - && standard_80387_constant_p (operands[1]) > 0 - && !memory_operand (operands[0], XFmode)) - || (!TARGET_MEMORY_MISMATCH_STALL - && memory_operand (operands[0], XFmode)))" -{ - switch (which_alternative) - { - case 0: - case 1: - return output_387_reg_move (insn, operands); - - case 2: - return standard_80387_constant_opcode (operands[1]); - - case 3: - case 4: - return "#"; - - default: - gcc_unreachable (); - } -} - [(set_attr "type" "fmov,fmov,fmov,multi,multi") - (set_attr "mode" "XF,XF,XF,SI,SI")]) - -;; Possible store forwarding (partial memory) stall in alternative 4. +;; Possible store forwarding (partial memory) stall in alternatives 4 and 5. (define_insn "*movxf_internal" - [(set (match_operand:XF 0 "nonimmediate_operand" "=f,m,f,?Yx*r ,!o") - (match_operand:XF 1 "general_operand" "fm,f,G,Yx*roF,Yx*rF"))] - "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1])) + [(set (match_operand:XF 0 "nonimmediate_operand" + "=f,m,f,?Yx*r ,!o ,!o") + (match_operand:XF 1 "general_operand" + "fm,f,G,Yx*roF,Yx*rF,Yx*rC"))] + "!(MEM_P (operands[0]) && MEM_P (operands[1])) && (!can_create_pseudo_p () || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) || GET_CODE (operands[1]) != CONST_DOUBLE @@ -2925,166 +2702,30 @@ case 3: case 4: + case 5: return "#"; default: gcc_unreachable (); } } - [(set_attr "type" "fmov,fmov,fmov,multi,multi") - (set_attr "mode" "XF,XF,XF,SI,SI")]) - -(define_insn "*movdf_internal_rex64" - [(set (match_operand:DF 0 "nonimmediate_operand" - "=Yf*f,m ,Yf*f,?r,?m,?r,?r,x,x,x,m,Yi,r") - (match_operand:DF 1 "general_operand" - "Yf*fm,Yf*f,G ,rm,rC,C ,F ,C,x,m,x,r ,Yi"))] - "TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1])) - && (!can_create_pseudo_p () - || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) - || GET_CODE (operands[1]) != CONST_DOUBLE - || (optimize_function_for_size_p (cfun) - && ((!(TARGET_SSE2 && TARGET_SSE_MATH) - && standard_80387_constant_p (operands[1]) > 0) - || (TARGET_SSE2 && TARGET_SSE_MATH - && standard_sse_constant_p (operands[1])))) - || memory_operand (operands[0], DFmode))" -{ - switch (which_alternative) - { - case 0: - case 1: - return output_387_reg_move (insn, operands); - - case 2: - return standard_80387_constant_opcode (operands[1]); - - case 3: - case 4: - return "mov{q}\t{%1, %0|%0, %1}"; - - case 5: - return "mov{l}\t{%1, %k0|%k0, %1}"; - - case 6: - return "movabs{q}\t{%1, %0|%0, %1}"; - - case 7: - return standard_sse_constant_opcode (insn, operands[1]); - - case 8: - case 9: - case 10: - switch (get_attr_mode (insn)) - { - case MODE_V2DF: - return "%vmovapd\t{%1, %0|%0, %1}"; - case MODE_V4SF: - return "%vmovaps\t{%1, %0|%0, %1}"; - - case MODE_DI: - return "%vmovq\t{%1, %0|%0, %1}"; - case MODE_DF: - if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1])) - return "vmovsd\t{%1, %0, %0|%0, %0, %1}"; - return "%vmovsd\t{%1, %0|%0, %1}"; - case MODE_V1DF: - return "%vmovlpd\t{%1, %d0|%d0, %1}"; - case MODE_V2SF: - return "%vmovlps\t{%1, %d0|%d0, %1}"; - default: - gcc_unreachable (); - } - - case 11: - case 12: - /* Handle broken assemblers that require movd instead of movq. */ - return "%vmovd\t{%1, %0|%0, %1}"; - - default: - gcc_unreachable(); - } -} - [(set (attr "type") - (cond [(eq_attr "alternative" "0,1,2") - (const_string "fmov") - (eq_attr "alternative" "3,4,5,6") - (const_string "imov") - (eq_attr "alternative" "7") - (const_string "sselog1") - ] - (const_string "ssemov"))) - (set (attr "modrm") - (if_then_else - (and (eq_attr "alternative" "6") (eq_attr "type" "imov")) - (const_string "0") - (const_string "*"))) - (set (attr "length_immediate") - (if_then_else - (and (eq_attr "alternative" "6") (eq_attr "type" "imov")) - (const_string "8") - (const_string "*"))) - (set (attr "prefix") - (if_then_else (eq_attr "alternative" "0,1,2,3,4,5,6") - (const_string "orig") - (const_string "maybe_vex"))) - (set (attr "prefix_data16") - (if_then_else (eq_attr "mode" "V1DF") - (const_string "1") - (const_string "*"))) + [(set_attr "isa" "*,*,*,*,nox64,x64") + (set_attr "type" "fmov,fmov,fmov,multi,multi,multi") (set (attr "mode") - (cond [(eq_attr "alternative" "0,1,2") - (const_string "DF") - (eq_attr "alternative" "3,4,6,11,12") - (const_string "DI") - (eq_attr "alternative" "5") - (const_string "SI") - - /* xorps is one byte shorter for !TARGET_AVX. */ - (eq_attr "alternative" "7") - (cond [(match_test "TARGET_AVX") - (const_string "V2DF") - (match_test "optimize_function_for_size_p (cfun)") - (const_string "V4SF") - (match_test "TARGET_SSE_LOAD0_BY_PXOR") - (const_string "TI") - ] - (const_string "V2DF")) - - /* For architectures resolving dependencies on - whole SSE registers use APD move to break dependency - chains, otherwise use short move to avoid extra work. - - movaps encodes one byte shorter for !TARGET_AVX. */ - (eq_attr "alternative" "8") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") - (const_string "V4SF") - (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY") - (const_string "V2DF") - (match_test "TARGET_AVX") - (const_string "DF") - (match_test "optimize_function_for_size_p (cfun)") - (const_string "V4SF") - ] - (const_string "DF")) - /* For architectures resolving dependencies on register - parts we may avoid extra work to zero out upper part - of register. */ - (eq_attr "alternative" "9") - (if_then_else - (match_test "TARGET_SSE_SPLIT_REGS") - (const_string "V1DF") - (const_string "DF")) + (cond [(eq_attr "alternative" "3,4,5") + (if_then_else (match_test "TARGET_64BIT") + (const_string "DI") + (const_string "SI")) ] - (const_string "DF")))]) + (const_string "XF")))]) ;; Possible store forwarding (partial memory) stall in alternative 4. (define_insn "*movdf_internal" [(set (match_operand:DF 0 "nonimmediate_operand" - "=Yf*f,m ,Yf*f,?Yd*r ,!o ,x,x,x,m,*x,*x,*x,m") + "=Yf*f,m ,Yf*f,?Yd*r ,!o ,?r,?m,?r,?r,x,x,x,m,*x,*x,*x,m ,Yi,r") (match_operand:DF 1 "general_operand" - "Yf*fm,Yf*f,G ,Yd*roF,Yd*rF,C,x,m,x,C ,*x,m ,*x"))] - "!TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1])) + "Yf*fm,Yf*f,G ,Yd*roF,Yd*rF,rm,rC,C ,F ,C,x,m,x,C ,*x,m ,*x,r ,Yi"))] + "!(MEM_P (operands[0]) && MEM_P (operands[1])) && (!can_create_pseudo_p () || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) || GET_CODE (operands[1]) != CONST_DOUBLE @@ -3094,7 +2735,7 @@ || (TARGET_SSE2 && TARGET_SSE_MATH && standard_sse_constant_p (operands[1]))) && !memory_operand (operands[0], DFmode)) - || (!TARGET_MEMORY_MISMATCH_STALL + || ((TARGET_64BIT || !TARGET_MEMORY_MISMATCH_STALL) && memory_operand (operands[0], DFmode)))" { switch (which_alternative) @@ -3111,15 +2752,25 @@ return "#"; case 5: - case 9: - return standard_sse_constant_opcode (insn, operands[1]); - case 6: + return "mov{q}\t{%1, %0|%0, %1}"; + case 7: + return "mov{l}\t{%1, %k0|%k0, %1}"; + case 8: + return "movabs{q}\t{%1, %0|%0, %1}"; + + case 9: + case 13: + return standard_sse_constant_opcode (insn, operands[1]); + case 10: case 11: case 12: + case 14: + case 15: + case 16: switch (get_attr_mode (insn)) { case MODE_V2DF: @@ -3136,30 +2787,51 @@ case MODE_V1DF: return "%vmovlpd\t{%1, %d0|%d0, %1}"; case MODE_V2SF: - return "%vmovlps\t{%1, %d0|%d0, %1}"; + gcc_assert (!TARGET_AVX); + return "movlps\t{%1, %0|%0, %1}"; default: gcc_unreachable (); } + case 17: + case 18: + /* Handle broken assemblers that require movd instead of movq. */ + return "%vmovd\t{%1, %0|%0, %1}"; + default: gcc_unreachable (); } } [(set (attr "isa") - (if_then_else (eq_attr "alternative" "5,6,7,8") - (const_string "sse2") - (const_string "*"))) + (cond [(eq_attr "alternative" "3,4") + (const_string "nox64") + (eq_attr "alternative" "5,6,7,8,17,18") + (const_string "x64") + (eq_attr "alternative" "9,10,11,12") + (const_string "sse2") + ] + (const_string "*"))) (set (attr "type") (cond [(eq_attr "alternative" "0,1,2") (const_string "fmov") (eq_attr "alternative" "3,4") (const_string "multi") - (eq_attr "alternative" "5,9") + (eq_attr "alternative" "5,6,7,8") + (const_string "imov") + (eq_attr "alternative" "9,13") (const_string "sselog1") ] (const_string "ssemov"))) + (set (attr "modrm") + (if_then_else (eq_attr "alternative" "8") + (const_string "0") + (const_string "*"))) + (set (attr "length_immediate") + (if_then_else (eq_attr "alternative" "8") + (const_string "8") + (const_string "*"))) (set (attr "prefix") - (if_then_else (eq_attr "alternative" "0,1,2,3,4") + (if_then_else (eq_attr "alternative" "0,1,2,3,4,5,6,7,8") (const_string "orig") (const_string "maybe_vex"))) (set (attr "prefix_data16") @@ -3167,21 +2839,16 @@ (const_string "1") (const_string "*"))) (set (attr "mode") - (cond [(eq_attr "alternative" "0,1,2") - (const_string "DF") - (eq_attr "alternative" "3,4") + (cond [(eq_attr "alternative" "3,4,7") (const_string "SI") - - /* For SSE1, we have many fewer alternatives. */ - (not (match_test "TARGET_SSE2")) - (if_then_else - (eq_attr "alternative" "5,6,9,10") - (const_string "V4SF") - (const_string "V2SF")) + (eq_attr "alternative" "5,6,8,17,18") + (const_string "DI") /* xorps is one byte shorter for !TARGET_AVX. */ - (eq_attr "alternative" "5,9") - (cond [(match_test "TARGET_AVX") + (eq_attr "alternative" "9,13") + (cond [(not (match_test "TARGET_SSE2")) + (const_string "V4SF") + (match_test "TARGET_AVX") (const_string "V2DF") (match_test "optimize_function_for_size_p (cfun)") (const_string "V4SF") @@ -3195,8 +2862,9 @@ chains, otherwise use short move to avoid extra work. movaps encodes one byte shorter for !TARGET_AVX. */ - (eq_attr "alternative" "6,10") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") + (eq_attr "alternative" "10,14") + (cond [(ior (not (match_test "TARGET_SSE2")) + (match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL")) (const_string "V4SF") (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY") (const_string "V2DF") @@ -3210,11 +2878,17 @@ /* For architectures resolving dependencies on register parts we may avoid extra work to zero out upper part of register. */ - (eq_attr "alternative" "7,11") - (if_then_else - (match_test "TARGET_SSE_SPLIT_REGS") - (const_string "V1DF") + (eq_attr "alternative" "11,15") + (cond [(not (match_test "TARGET_SSE2")) + (const_string "V2SF") + (match_test "TARGET_SSE_SPLIT_REGS") + (const_string "V1DF") + ] (const_string "DF")) + + (and (eq_attr "alternative" "12,16") + (not (match_test "TARGET_SSE2"))) + (const_string "V2SF") ] (const_string "DF")))]) diff --git a/gcc/config/mn10300/mn10300.c b/gcc/config/mn10300/mn10300.c index f490e2d8e21..df563d03eac 100644 --- a/gcc/config/mn10300/mn10300.c +++ b/gcc/config/mn10300/mn10300.c @@ -622,6 +622,7 @@ mn10300_can_use_rets_insn (void) /* Returns the set of live, callee-saved registers as a bitmask. The callee-saved extended registers cannot be stored individually, so + all of them will be included in the mask if any one of them is used. Also returns the number of bytes in the registers in the mask if BYTES_SAVED is not NULL. */ diff --git a/gcc/config/stormy16/stormy16.c b/gcc/config/stormy16/stormy16.c index 3e20d209a18..278ac17dcc8 100644 --- a/gcc/config/stormy16/stormy16.c +++ b/gcc/config/stormy16/stormy16.c @@ -1082,7 +1082,7 @@ xstormy16_expand_prologue (void) gen_rtx_MEM (Pmode, stack_pointer_rtx), reg); XVECEXP (dwarf, 0, 1) = gen_rtx_SET (Pmode, stack_pointer_rtx, - plus_constant (Pmode, \ + plus_constant (Pmode, stack_pointer_rtx, GET_MODE_SIZE (Pmode))); add_reg_note (insn, REG_FRAME_RELATED_EXPR, dwarf); diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 77f3f824c0a..b2796b6ca13 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,163 @@ +2013-03-17 Jason Merrill <jason@redhat.com> + + PR c++/54359 + PR c++/56639 + * parser.c (cp_parser_direct_declarator): Bail if we see a + qualified-id not at namespace scope. + + PR c++/17232 + PR c++/56642 + * typeck2.c (abstract_virtuals_error_sfinae): Revert complete_type + change for now. + +2013-03-16 Jason Merrill <jason@redhat.com> + + * decl.c (grokdeclarator): Assert that we won't see a pointer to + METHOD_TYPE. + + PR c++/54277 + * cp-tree.h (WILDCARD_TYPE_P): Split out from... + (MAYBE_CLASS_TYPE_P): ...here. + * semantics.c (lambda_capture_field_type): Only build a + magic decltype for wildcard types. + (lambda_proxy_type): Likewise. + (finish_non_static_data_member): Get the quals from + the object. + + PR c++/55931 + * parser.c (cp_parser_template_argument): Don't + fold_non_dependent_expr. + + * parser.c (cp_parser_lambda_declarator_opt): Use + cp_parser_trailing_type_id. + + PR c++/45917 + * parser.c (cp_parser_template_id): Don't forget access checks. + + PR c++/52374 + * pt.c (tsubst_qualified_id): Use current_nonlambda_class_type. + + PR c++/54764 + PR c++/55972 + * name-lookup.h (tag_scope): Add ts_lambda. + * semantics.c (begin_lambda_type): Use it. + * decl.c (xref_tag_1): Set CLASSTYPE_LAMBDA_EXPR. + * pt.c (check_default_tmpl_args): Ignore lambdas. + (push_template_decl_real): Handle lambdas. + * tree.c (no_linkage_check): Adjust lambda check. + + PR c++/56039 + * tree.c (strip_typedefs_expr): Complain about lambda, don't abort. + + PR c++/54359 + * parser.c (cp_parser_direct_declarator): Fix late return + for out-of-class defn of member function. + + PR c++/55357 + * semantics.c (maybe_add_lambda_conv_op): Clear DECL_NAME of copied + parms to avoid duplicate -Wshadow warnings. + + * search.c (lookup_base): Handle NULL_TREE. + + PR c++/56481 + * semantics.c (potential_constant_expression_1): Use of 'this' in + a non-constexpr function makes the expression not potentially + constant. + + N3276 + PR c++/52748 + * cp-tree.h (tsubst_flags): Add tf_decltype. + * call.c (build_cxx_call): Don't build a temporary if it's set. + (build_over_call): Make sure it's only passed to build_cxx_call. + * parser.c (cp_parser_primary_expression): Add decltype_p parm. + (cp_parser_unary_expression): Likewise. + (cp_parser_cast_expression): Likewise. + (cp_parser_binary_expression): Likewise. + (cp_parser_assignment_expression): Likewise. + (cp_parser_postfix_expression): Likewise. Pass tf_decltype. + (cp_parser_explicit_instantiation): Add decltype_p. Force a + temporary for a call on the LHS of a comma. + (cp_parser_decltype): Pass true to decltype_p parms. + * pt.c (tsubst) [DECLTYPE_TYPE]: Pass tf_decltype. + (tsubst_copy_and_build): Pass tf_decltype down only for + CALL_EXPR and the RHS of COMPOUND_EXPR. + * tree.c (build_cplus_new): Call complete_type_or_maybe_complain. + + * cp-tree.h (abstract_class_use): New enum. + * typeck2.c (pending_abstract_type): Add use field. + (abstract_virtuals_error_sfinae): Add overloads taking + abstract_class_use instead of tree. + * typeck.c (build_static_cast_1): Call it. + * except.c (is_admissible_throw_operand_or_catch_parameter): Call it. + * pt.c: Adjust calls. + * decl.c (cp_finish_decl): Don't handle functions specially. + (grokdeclarator): Always check return type. + * init.c (build_new_1): Adjust call. + + DR 337 + PR c++/17232 + * pt.c (tsubst) [ARRAY_TYPE]: Use abstract_virtuals_error_sfinae. + * typeck2.c (abstract_virtuals_error_sfinae): Call complete_type. + + DR 657 + * pt.c (tsubst_function_type): Call abstract_virtuals_error_sfinae. + (tsubst_arg_types): Likewise. + + DR 1518 + PR c++/54835 + * call.c (convert_like_real): Check for explicit constructors + even for value-initialization. + + PR c++/54946 + * pt.c (convert_nontype_argument): Handle invalid pointer. + + * parser.c (cp_parser_lambda_expression): Use nreverse. + + PR c++/56447 + PR c++/55532 + * pt.c (instantiate_class_template_1): Instantiate lambda capture + list here. + (tsubst_copy_and_build): Not here. + + PR c++/55017 + * method.c (walk_field_subobs): Disallow copy of rvalue ref. + + PR c++/55240 + * parser.c (parsing_nsdmi): New. + * semantics.c (outer_automatic_var_p): Check it. + (finish_id_expression): Likewise. + * cp-tree.h: Declare it. + + PR c++/55241 + * error.c (dump_expr) [SIZEOF_EXPR]: Print sizeof... properly. + + * parser.c (lookup_literal_operator): Correct parm/arg naming + mixup. + + PR c++/56238 + * pt.c (fold_non_dependent_expr_sfinae): Check + instantiation_dependent_expression_p. + + PR c++/56095 + * class.c (resolve_address_of_overloaded_function): Accept a + reference to function for target_type. + (instantiate_type): Likewise. + * pt.c (convert_nontype_argument): Pass it to + convert_nontype_argument_function. + +2013-03-16 Jakub Jelinek <jakub@redhat.com> + + * tree.c (cp_tree_equal): Fix a pasto. + + PR c++/56607 + * typeck.c (cp_build_binary_op): When calling warn_for_div_by_zero, + pass op1 through maybe_constant_value first. + +2013-03-16 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/56582 + * semantics.c (cxx_eval_array_reference): Check for negative index. + 2013-03-14 Jason Merrill <jason@redhat.com> PR c++/56614 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 530835b87c8..8362c756c39 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -5856,6 +5856,17 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, tree convfn = cand->fn; unsigned i; + /* When converting from an init list we consider explicit + constructors, but actually trying to call one is an error. */ + if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn) + /* Unless this is for direct-list-initialization. */ + && !(BRACE_ENCLOSED_INITIALIZER_P (expr) + && CONSTRUCTOR_IS_DIRECT_INIT (expr))) + { + error ("converting to %qT from initializer list would use " + "explicit constructor %qD", totype, convfn); + } + /* If we're initializing from {}, it's value-initialization. */ if (BRACE_ENCLOSED_INITIALIZER_P (expr) && CONSTRUCTOR_NELTS (expr) == 0 @@ -5874,20 +5885,6 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, expr = mark_rvalue_use (expr); - /* When converting from an init list we consider explicit - constructors, but actually trying to call one is an error. */ - if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn) - /* Unless this is for direct-list-initialization. */ - && !(BRACE_ENCLOSED_INITIALIZER_P (expr) - && CONSTRUCTOR_IS_DIRECT_INIT (expr)) - /* Unless we're calling it for value-initialization from an - empty list, since that is handled separately in 8.5.4. */ - && cand->num_convs > 0) - { - error ("converting to %qT from initializer list would use " - "explicit constructor %qD", totype, convfn); - } - /* Set user_conv_p on the argument conversions, so rvalue/base handling knows not to allow any more UDCs. */ for (i = 0; i < cand->num_convs; ++i) @@ -6696,6 +6693,10 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain) /* else continue to get conversion error. */ } + /* N3276 magic doesn't apply to nested calls. */ + int decltype_flag = (complain & tf_decltype); + complain &= ~tf_decltype; + /* Find maximum size of vector to hold converted arguments. */ parmlen = list_length (parm); nargs = vec_safe_length (args) + (first_arg != NULL_TREE ? 1 : 0); @@ -7067,7 +7068,7 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain) return error_mark_node; } - return build_cxx_call (fn, nargs, argarray, complain); + return build_cxx_call (fn, nargs, argarray, complain|decltype_flag); } /* Build and return a call to FN, using NARGS arguments in ARGARRAY. @@ -7109,12 +7110,20 @@ build_cxx_call (tree fn, int nargs, tree *argarray, if (VOID_TYPE_P (TREE_TYPE (fn))) return fn; - fn = require_complete_type_sfinae (fn, complain); - if (fn == error_mark_node) - return error_mark_node; + /* 5.2.2/11: If a function call is a prvalue of object type: if the + function call is either the operand of a decltype-specifier or the + right operand of a comma operator that is the operand of a + decltype-specifier, a temporary object is not introduced for the + prvalue. The type of the prvalue may be incomplete. */ + if (!(complain & tf_decltype)) + { + fn = require_complete_type_sfinae (fn, complain); + if (fn == error_mark_node) + return error_mark_node; - if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn))) - fn = build_cplus_new (TREE_TYPE (fn), fn, complain); + if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn))) + fn = build_cplus_new (TREE_TYPE (fn), fn, complain); + } return convert_from_reference (fn); } diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 746c29d2dea..b48b353d596 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -7148,7 +7148,8 @@ resolve_address_of_overloaded_function (tree target_type, gcc_assert (is_overloaded_fn (overload)); /* Check that the TARGET_TYPE is reasonable. */ - if (TYPE_PTRFN_P (target_type)) + if (TYPE_PTRFN_P (target_type) + || TYPE_REFFN_P (target_type)) /* This is OK. */; else if (TYPE_PTRMEMFUNC_P (target_type)) /* This is OK, too. */ @@ -7419,10 +7420,11 @@ instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags) if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs))) { - if (same_type_p (lhstype, TREE_TYPE (rhs))) + tree fntype = non_reference (lhstype); + if (same_type_p (fntype, TREE_TYPE (rhs))) return rhs; if (flag_ms_extensions - && TYPE_PTRMEMFUNC_P (lhstype) + && TYPE_PTRMEMFUNC_P (fntype) && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs))) /* Microsoft allows `A::f' to be resolved to a pointer-to-member. */ @@ -7431,7 +7433,7 @@ instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags) { if (flags & tf_error) error ("cannot convert %qE from type %qT to type %qT", - rhs, TREE_TYPE (rhs), lhstype); + rhs, TREE_TYPE (rhs), fntype); return error_mark_node; } } diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index c3b2aecf3b1..7ce1acb06d7 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -463,6 +463,19 @@ typedef enum impl_conv_void { ICV_THIRD_IN_FOR /* for increment expression */ } impl_conv_void; +/* Possible invalid uses of an abstract class that might not have a + specific associated declaration. */ +typedef enum abstract_class_use { + ACU_UNKNOWN, /* unknown or decl provided */ + ACU_CAST, /* cast to abstract class */ + ACU_NEW, /* new-expression of abstract class */ + ACU_THROW, /* throw-expression of abstract class */ + ACU_CATCH, /* catch-parameter of abstract class */ + ACU_ARRAY, /* array of abstract class */ + ACU_RETURN, /* return type of abstract class */ + ACU_PARM /* parameter type of abstract class */ +} abstract_class_use; + /* Macros for access to language-specific slots in an identifier. */ #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ @@ -1207,17 +1220,20 @@ enum languages { lang_c, lang_cplusplus, lang_java }; /* The _DECL for this _TYPE. */ #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) -/* Nonzero if T is a class (or struct or union) type. Also nonzero - for template type parameters, typename types, and instantiated - template template parameters. Keep these checks in ascending code - order. */ -#define MAYBE_CLASS_TYPE_P(T) \ +/* Nonzero if T is a type that could resolve to any kind of concrete type + at instantiation time. */ +#define WILDCARD_TYPE_P(T) \ (TREE_CODE (T) == TEMPLATE_TYPE_PARM \ || TREE_CODE (T) == TYPENAME_TYPE \ || TREE_CODE (T) == TYPEOF_TYPE \ || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \ - || TREE_CODE (T) == DECLTYPE_TYPE \ - || CLASS_TYPE_P (T)) + || TREE_CODE (T) == DECLTYPE_TYPE) + +/* Nonzero if T is a class (or struct or union) type. Also nonzero + for template type parameters, typename types, and instantiated + template template parameters. Keep these checks in ascending code + order. */ +#define MAYBE_CLASS_TYPE_P(T) (WILDCARD_TYPE_P (T) || CLASS_TYPE_P (T)) /* Set CLASS_TYPE_P for T to VAL. T must be a class, struct, or union type. */ @@ -4190,6 +4206,9 @@ enum tsubst_flags { conversion might be permissible, not actually performing the conversion. */ + tf_decltype = 1 << 7, /* We are the operand of decltype. + Used to implement the special rules + for calls in decltype (5.2.2/11). */ tf_partial = 1 << 8, /* Doing initial explicit argument substitution in fn_type_unification. */ /* Convenient substitution flags combinations. */ @@ -4259,6 +4278,7 @@ extern int comparing_specializations; extern int cp_unevaluated_operand; extern tree cp_convert_range_for (tree, tree, tree); +extern bool parsing_nsdmi (void); /* in pt.c */ @@ -5982,7 +6002,9 @@ extern tree binfo_or_else (tree, tree); extern void cxx_readonly_error (tree, enum lvalue_use); extern void complete_type_check_abstract (tree); extern int abstract_virtuals_error (tree, tree); +extern int abstract_virtuals_error (abstract_class_use, tree); extern int abstract_virtuals_error_sfinae (tree, tree, tsubst_flags_t); +extern int abstract_virtuals_error_sfinae (abstract_class_use, tree, tsubst_flags_t); extern tree store_init_value (tree, tree, vec<tree, va_gc>**, int); extern void check_narrowing (tree, tree); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index d7b84095090..88fb93565c8 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -6434,11 +6434,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, /* Check for abstractness of the type. Notice that there is no need to strip array types here since the check for those types is already done within create_array_type_for_decl. */ - if (TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == METHOD_TYPE) - abstract_virtuals_error (decl, TREE_TYPE (type)); - else - abstract_virtuals_error (decl, type); + abstract_virtuals_error (decl, type); if (TREE_TYPE (decl) == error_mark_node) /* No initialization required. */ @@ -8665,6 +8661,7 @@ grokdeclarator (const cp_declarator *declarator, bool template_type_arg = false; bool template_parm_flag = false; bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr); + source_location saved_loc = input_location; const char *errmsg; signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed); @@ -9349,7 +9346,6 @@ grokdeclarator (const cp_declarator *declarator, if (declspecs->std_attributes) { /* Apply the c++11 attributes to the type preceding them. */ - source_location saved_loc = input_location; input_location = declspecs->locations[ds_std_attribute]; decl_attributes (&type, declspecs->std_attributes, 0); input_location = saved_loc; @@ -9437,11 +9433,10 @@ grokdeclarator (const cp_declarator *declarator, error ("%qs declared as function returning an array", name); return error_mark_node; } - /* When decl_context == NORMAL we emit a better error message - later in abstract_virtuals_error. */ - if (decl_context == TYPENAME && ABSTRACT_CLASS_TYPE_P (type)) - error ("%qs declared as function returning an abstract " - "class type", name); + + input_location = declspecs->locations[ds_type_spec]; + abstract_virtuals_error (ACU_RETURN, type); + input_location = saved_loc; /* Pick up type qualifiers which should be applied to `this'. */ memfn_quals = declarator->u.function.qualifiers; @@ -9644,9 +9639,11 @@ grokdeclarator (const cp_declarator *declarator, but to the target of the pointer. */ type_quals = TYPE_UNQUALIFIED; + /* This code used to handle METHOD_TYPE, but I don't think it's + possible to get it here anymore. */ + gcc_assert (TREE_CODE (type) != METHOD_TYPE); if (declarator->kind == cdk_ptrmem - && (TREE_CODE (type) == FUNCTION_TYPE - || (memfn_quals && TREE_CODE (type) == METHOD_TYPE))) + && TREE_CODE (type) == FUNCTION_TYPE) { memfn_quals |= type_memfn_quals (type); type = build_memfn_type (type, @@ -11901,11 +11898,12 @@ lookup_and_check_tag (enum tag_types tag_code, tree name, static tree xref_tag_1 (enum tag_types tag_code, tree name, - tag_scope scope, bool template_header_p) + tag_scope orig_scope, bool template_header_p) { enum tree_code code; tree t; tree context = NULL_TREE; + tag_scope scope; gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); @@ -11925,6 +11923,11 @@ xref_tag_1 (enum tag_types tag_code, tree name, gcc_unreachable (); } + if (orig_scope == ts_lambda) + scope = ts_current; + else + scope = orig_scope; + /* In case of anonymous name, xref_tag is only called to make type node and push name. Name lookup is not required. */ if (ANON_AGGRNAME_P (name)) @@ -11998,6 +12001,10 @@ xref_tag_1 (enum tag_types tag_code, tree name, { t = make_class_type (code); TYPE_CONTEXT (t) = context; + if (orig_scope == ts_lambda) + /* Remember that we're declaring a lambda to avoid bogus errors + in push_template_decl. */ + CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node; t = pushtag (name, t, scope); } } diff --git a/gcc/cp/error.c b/gcc/cp/error.c index c2bf54dcb2c..c3dce1dd5b3 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -1783,6 +1783,8 @@ resolve_virtual_fun_from_obj_type_ref (tree ref) static void dump_expr (tree t, int flags) { + tree op; + if (t == 0) return; @@ -2316,14 +2318,20 @@ dump_expr (tree t, int flags) gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR); pp_cxx_ws_string (cxx_pp, "__alignof__"); } + op = TREE_OPERAND (t, 0); + if (PACK_EXPANSION_P (op)) + { + pp_string (cxx_pp, "..."); + op = PACK_EXPANSION_PATTERN (op); + } pp_cxx_whitespace (cxx_pp); pp_cxx_left_paren (cxx_pp); if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t)) - dump_type (TREE_TYPE (TREE_OPERAND (t, 0)), flags); + dump_type (TREE_TYPE (op), flags); else if (TYPE_P (TREE_OPERAND (t, 0))) - dump_type (TREE_OPERAND (t, 0), flags); + dump_type (op, flags); else - dump_expr (TREE_OPERAND (t, 0), flags); + dump_expr (op, flags); pp_cxx_right_paren (cxx_pp); break; diff --git a/gcc/cp/except.c b/gcc/cp/except.c index 216ec103f52..52ba1cdeae5 100644 --- a/gcc/cp/except.c +++ b/gcc/cp/except.c @@ -972,16 +972,8 @@ is_admissible_throw_operand_or_catch_parameter (tree t, bool is_throw) /* 10.4/3 An abstract class shall not be used as a parameter type, as a function return type or as type of an explicit conversion. */ - else if (ABSTRACT_CLASS_TYPE_P (type)) - { - if (is_throw) - error ("expression %qE of abstract class type %qT cannot " - "be used in throw-expression", expr, type); - else - error ("cannot declare catch parameter to be of abstract " - "class type %qT", type); - return false; - } + else if (abstract_virtuals_error (is_throw ? ACU_THROW : ACU_CATCH, type)) + return false; else if (!is_throw && TREE_CODE (type) == REFERENCE_TYPE && TYPE_REF_IS_RVALUE (type)) diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 697f11ff52e..679c47d7dd9 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -2301,7 +2301,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts, return error_mark_node; } - if (abstract_virtuals_error_sfinae (NULL_TREE, elt_type, complain)) + if (abstract_virtuals_error_sfinae (ACU_NEW, elt_type, complain)) return error_mark_node; is_initialized = (type_build_ctor_call (elt_type) || *init != NULL); diff --git a/gcc/cp/method.c b/gcc/cp/method.c index ff29b596892..55c7e50d308 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -1115,6 +1115,19 @@ walk_field_subobs (tree fields, tree fnname, special_function_kind sfk, "initialize %q+#D", field); } } + else if (sfk == sfk_copy_constructor) + { + /* 12.8p11b5 */ + if (TREE_CODE (mem_type) == REFERENCE_TYPE + && TYPE_REF_IS_RVALUE (mem_type)) + { + if (diag) + error ("copying non-static data member %q#D of rvalue " + "reference type", field); + if (deleted_p) + *deleted_p = true; + } + } if (!CLASS_TYPE_P (mem_type)) continue; diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h index f9a0fbe4dcb..b88ada37c96 100644 --- a/gcc/cp/name-lookup.h +++ b/gcc/cp/name-lookup.h @@ -132,10 +132,11 @@ typedef enum tag_scope { ts_global = 1, /* All scopes. This is the 3.4.1 [basic.lookup.unqual] lookup mentioned in [basic.lookup.elab]/2. */ - ts_within_enclosing_non_class = 2 /* Search within enclosing non-class + ts_within_enclosing_non_class = 2, /* Search within enclosing non-class only, for friend class lookup according to [namespace.memdef]/3 and [class.friend]/9. */ + ts_lambda = 3 /* Declaring a lambda closure. */ } tag_scope; typedef struct GTY(()) cp_class_binding { diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index ff4faa32d3c..23fe3f302a0 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -1802,7 +1802,7 @@ static tree cp_parser_nested_name_specifier static tree cp_parser_qualifying_entity (cp_parser *, bool, bool, bool, bool, bool); static tree cp_parser_postfix_expression - (cp_parser *, bool, bool, bool, cp_id_kind *); + (cp_parser *, bool, bool, bool, bool, cp_id_kind *); static tree cp_parser_postfix_open_square_expression (cp_parser *, tree, bool); static tree cp_parser_postfix_dot_deref_expression @@ -1832,7 +1832,7 @@ static vec<tree, va_gc> *cp_parser_new_initializer static tree cp_parser_delete_expression (cp_parser *); static tree cp_parser_cast_expression - (cp_parser *, bool, bool, cp_id_kind *); + (cp_parser *, bool, bool, bool, cp_id_kind *); static tree cp_parser_binary_expression (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *); static tree cp_parser_question_colon_clause @@ -1843,6 +1843,8 @@ static enum tree_code cp_parser_assignment_operator_opt (cp_parser *); static tree cp_parser_expression (cp_parser *, bool, cp_id_kind *); +static tree cp_parser_expression + (cp_parser *, bool, bool, cp_id_kind *); static tree cp_parser_constant_expression (cp_parser *, bool, bool *); static tree cp_parser_builtin_offsetof @@ -3559,21 +3561,20 @@ lookup_literal_operator (tree name, vec<tree, va_gc> *args) unsigned int ix; bool found = true; tree fn = OVL_CURRENT (fns); - tree argtypes = NULL_TREE; - argtypes = TYPE_ARG_TYPES (TREE_TYPE (fn)); - if (argtypes != NULL_TREE) + tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (fn)); + if (parmtypes != NULL_TREE) { - for (ix = 0; ix < vec_safe_length (args) && argtypes != NULL_TREE; - ++ix, argtypes = TREE_CHAIN (argtypes)) + for (ix = 0; ix < vec_safe_length (args) && parmtypes != NULL_TREE; + ++ix, parmtypes = TREE_CHAIN (parmtypes)) { - tree targ = TREE_VALUE (argtypes); - tree tparm = TREE_TYPE ((*args)[ix]); - bool ptr = TREE_CODE (targ) == POINTER_TYPE; - bool arr = TREE_CODE (tparm) == ARRAY_TYPE; - if ((ptr || arr || !same_type_p (targ, tparm)) + tree tparm = TREE_VALUE (parmtypes); + tree targ = TREE_TYPE ((*args)[ix]); + bool ptr = TREE_CODE (tparm) == POINTER_TYPE; + bool arr = TREE_CODE (targ) == ARRAY_TYPE; + if ((ptr || arr || !same_type_p (tparm, targ)) && (!ptr || !arr - || !same_type_p (TREE_TYPE (targ), - TREE_TYPE (tparm)))) + || !same_type_p (TREE_TYPE (tparm), + TREE_TYPE (targ)))) found = false; } if (found @@ -3582,7 +3583,7 @@ lookup_literal_operator (tree name, vec<tree, va_gc> *args) depending on how exactly should user-defined literals work in presence of default arguments on the literal operator parameters. */ - && argtypes == void_list_node) + && parmtypes == void_list_node) return fn; } } @@ -3901,6 +3902,7 @@ cp_parser_primary_expression (cp_parser *parser, bool address_p, bool cast_p, bool template_arg_p, + bool decltype_p, cp_id_kind *idk) { cp_token *token = NULL; @@ -4052,7 +4054,7 @@ cp_parser_primary_expression (cp_parser *parser, else { /* Parse the parenthesized expression. */ - expr = cp_parser_expression (parser, cast_p, idk); + expr = cp_parser_expression (parser, cast_p, decltype_p, idk); /* Let the front end know that this expression was enclosed in parentheses. This matters in case, for example, the expression is of the form `A::B', since @@ -4404,6 +4406,17 @@ cp_parser_primary_expression (cp_parser *parser, } } +static inline tree +cp_parser_primary_expression (cp_parser *parser, + bool address_p, + bool cast_p, + bool template_arg_p, + cp_id_kind *idk) +{ + return cp_parser_primary_expression (parser, address_p, cast_p, template_arg_p, + /*decltype*/false, idk); +} + /* Parse an id-expression. id-expression: @@ -5365,7 +5378,7 @@ cp_parser_qualifying_entity (cp_parser *parser, static tree cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, - bool member_access_only_p, + bool member_access_only_p, bool decltype_p, cp_id_kind * pidk_return) { cp_token *token; @@ -5626,11 +5639,17 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, postfix_expression = cp_parser_primary_expression (parser, address_p, cast_p, /*template_arg_p=*/false, + decltype_p, &idk); } break; } + /* Note that we don't need to worry about calling build_cplus_new on a + class-valued CALL_EXPR in decltype when it isn't the end of the + postfix-expression; unary_complex_lvalue will take care of that for + all these cases. */ + /* Keep looping until the postfix-expression is complete. */ while (true) { @@ -5669,8 +5688,12 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, bool is_builtin_constant_p; bool saved_integral_constant_expression_p = false; bool saved_non_integral_constant_expression_p = false; + int complain = tf_warning_or_error; vec<tree, va_gc> *args; + if (decltype_p) + complain |= tf_decltype; + is_member_access = false; is_builtin_constant_p @@ -5727,7 +5750,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, postfix_expression = perform_koenig_lookup (postfix_expression, args, /*include_std=*/false, - tf_warning_or_error); + complain); } else postfix_expression @@ -5753,7 +5776,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, postfix_expression = perform_koenig_lookup (postfix_expression, args, /*include_std=*/false, - tf_warning_or_error); + complain); } } } @@ -5785,21 +5808,21 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL : LOOKUP_NORMAL), /*fn_p=*/NULL, - tf_warning_or_error)); + complain)); } else postfix_expression = finish_call_expr (postfix_expression, &args, /*disallow_virtual=*/false, /*koenig_p=*/false, - tf_warning_or_error); + complain); } else if (TREE_CODE (postfix_expression) == OFFSET_REF || TREE_CODE (postfix_expression) == MEMBER_REF || TREE_CODE (postfix_expression) == DOTSTAR_EXPR) postfix_expression = (build_offset_ref_call_from_tree (postfix_expression, &args, - tf_warning_or_error)); + complain)); else if (idk == CP_ID_KIND_QUALIFIED) /* A call to a static class member, or a namespace-scope function. */ @@ -5807,14 +5830,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, = finish_call_expr (postfix_expression, &args, /*disallow_virtual=*/true, koenig_p, - tf_warning_or_error); + complain); else /* All other function calls. */ postfix_expression = finish_call_expr (postfix_expression, &args, /*disallow_virtual=*/false, koenig_p, - tf_warning_or_error); + complain); /* The POSTFIX_EXPRESSION is certainly no longer an id. */ idk = CP_ID_KIND_NONE; @@ -6415,7 +6438,7 @@ cp_parser_pseudo_destructor_name (cp_parser* parser, static tree cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p, - cp_id_kind * pidk) + bool decltype_p, cp_id_kind * pidk) { cp_token *token; enum tree_code unary_operator; @@ -6636,7 +6659,9 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p, cast_expression = cp_parser_cast_expression (parser, unary_operator == ADDR_EXPR, - /*cast_p=*/false, pidk); + /*cast_p=*/false, + /*decltype*/false, + pidk); /* Now, build an appropriate representation. */ switch (unary_operator) { @@ -6682,9 +6707,18 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p, return cp_parser_postfix_expression (parser, address_p, cast_p, /*member_access_only_p=*/false, + decltype_p, pidk); } +static inline tree +cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p, + cp_id_kind * pidk) +{ + return cp_parser_unary_expression (parser, address_p, cast_p, + /*decltype*/false, pidk); +} + /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a unary-operator, the corresponding tree code is returned. */ @@ -7163,7 +7197,7 @@ cp_parser_tokens_start_cast_expression (cp_parser *parser) static tree cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p, - cp_id_kind * pidk) + bool decltype_p, cp_id_kind * pidk) { /* If it's a `(', then we might be looking at a cast. */ if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) @@ -7237,7 +7271,9 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p, cp_parser_parse_definitely (parser); expr = cp_parser_cast_expression (parser, /*address_p=*/false, - /*cast_p=*/true, pidk); + /*cast_p=*/true, + /*decltype_p=*/false, + pidk); /* Warn about old-style casts, if so requested. */ if (warn_old_style_cast @@ -7263,7 +7299,8 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p, /* If we get here, then it's not a cast, so it must be a unary-expression. */ - return cp_parser_unary_expression (parser, address_p, cast_p, pidk); + return cp_parser_unary_expression (parser, address_p, cast_p, + decltype_p, pidk); } /* Parse a binary expression of the general form: @@ -7348,6 +7385,7 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p, static tree cp_parser_binary_expression (cp_parser* parser, bool cast_p, bool no_toplevel_fold_p, + bool decltype_p, enum cp_parser_prec prec, cp_id_kind * pidk) { @@ -7362,7 +7400,7 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p, /* Parse the first expression. */ current.lhs = cp_parser_cast_expression (parser, /*address_p=*/false, - cast_p, pidk); + cast_p, decltype_p, pidk); current.lhs_type = ERROR_MARK; current.prec = prec; @@ -7499,6 +7537,15 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p, return current.lhs; } +static tree +cp_parser_binary_expression (cp_parser* parser, bool cast_p, + bool no_toplevel_fold_p, + enum cp_parser_prec prec, + cp_id_kind * pidk) +{ + return cp_parser_binary_expression (parser, cast_p, no_toplevel_fold_p, + /*decltype*/false, prec, pidk); +} /* Parse the `? expression : assignment-expression' part of a conditional-expression. The LOGICAL_OR_EXPR is the @@ -7568,12 +7615,13 @@ cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr) throw-expression CAST_P is true if this expression is the target of a cast. + DECLTYPE_P is true if this expression is the operand of decltype. Returns a representation for the expression. */ static tree cp_parser_assignment_expression (cp_parser* parser, bool cast_p, - cp_id_kind * pidk) + bool decltype_p, cp_id_kind * pidk) { tree expr; @@ -7587,6 +7635,7 @@ cp_parser_assignment_expression (cp_parser* parser, bool cast_p, { /* Parse the binary expressions (logical-or-expression). */ expr = cp_parser_binary_expression (parser, cast_p, false, + decltype_p, PREC_NOT_OPERATOR, pidk); /* If the next token is a `?' then we're actually looking at a conditional-expression. */ @@ -7632,6 +7681,14 @@ cp_parser_assignment_expression (cp_parser* parser, bool cast_p, return expr; } +static tree +cp_parser_assignment_expression (cp_parser* parser, bool cast_p, + cp_id_kind * pidk) +{ + return cp_parser_assignment_expression (parser, cast_p, + /*decltype*/false, pidk); +} + /* Parse an (optional) assignment-operator. assignment-operator: one of @@ -7723,11 +7780,14 @@ cp_parser_assignment_operator_opt (cp_parser* parser) expression , assignment-expression CAST_P is true if this expression is the target of a cast. + DECLTYPE_P is true if this expression is the immediate operand of decltype, + except possibly parenthesized or on the RHS of a comma (N3276). Returns a representation of the expression. */ static tree -cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk) +cp_parser_expression (cp_parser* parser, bool cast_p, bool decltype_p, + cp_id_kind * pidk) { tree expression = NULL_TREE; location_t loc = UNKNOWN_LOCATION; @@ -7738,7 +7798,19 @@ cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk) /* Parse the next assignment-expression. */ assignment_expression - = cp_parser_assignment_expression (parser, cast_p, pidk); + = cp_parser_assignment_expression (parser, cast_p, decltype_p, pidk); + + /* We don't create a temporary for a call that is the immediate operand + of decltype or on the RHS of a comma. But when we see a comma, we + need to create a temporary for a call on the LHS. */ + if (decltype_p && !processing_template_decl + && TREE_CODE (assignment_expression) == CALL_EXPR + && CLASS_TYPE_P (TREE_TYPE (assignment_expression)) + && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) + assignment_expression + = build_cplus_new (TREE_TYPE (assignment_expression), + assignment_expression, tf_warning_or_error); + /* If this is the first assignment-expression, we can just save it away. */ if (!expression) @@ -7762,6 +7834,12 @@ cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk) return expression; } +static inline tree +cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk) +{ + return cp_parser_expression (parser, cast_p, /*decltype*/false, pidk); +} + /* Parse a constant-expression. constant-expression: @@ -8196,19 +8274,8 @@ cp_parser_lambda_expression (cp_parser* parser) cp_parser_skip_to_end_of_block_or_statement (parser); /* The capture list was built up in reverse order; fix that now. */ - { - tree newlist = NULL_TREE; - tree elt, next; - - for (elt = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); - elt; elt = next) - { - next = TREE_CHAIN (elt); - TREE_CHAIN (elt) = newlist; - newlist = elt; - } - LAMBDA_EXPR_CAPTURE_LIST (lambda_expr) = newlist; - } + LAMBDA_EXPR_CAPTURE_LIST (lambda_expr) + = nreverse (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr)); if (ok) maybe_add_lambda_conv_op (type); @@ -8487,7 +8554,8 @@ cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr) if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF)) { cp_lexer_consume_token (parser->lexer); - LAMBDA_EXPR_RETURN_TYPE (lambda_expr) = cp_parser_type_id (parser); + LAMBDA_EXPR_RETURN_TYPE (lambda_expr) + = cp_parser_trailing_type_id (parser); } /* The function parameters must be in scope all the way until after the @@ -11299,7 +11367,7 @@ cp_parser_decltype (cp_parser *parser) /* Parse a class member access. */ expr = cp_parser_postfix_expression (parser, /*address_p=*/false, - /*cast_p=*/false, + /*cast_p=*/false, /*decltype*/true, /*member_access_only_p=*/true, NULL); if (expr @@ -11327,7 +11395,8 @@ cp_parser_decltype (cp_parser *parser) parser->greater_than_is_operator_p = true; /* Parse a full expression. */ - expr = cp_parser_expression (parser, /*cast_p=*/false, NULL); + expr = cp_parser_expression (parser, /*cast_p=*/false, + /*decltype*/true, NULL); /* The `>' token might be the end of a template-id or template-parameter-list now. */ @@ -12750,7 +12819,7 @@ cp_parser_template_id (cp_parser *parser, error_at (token->location, "parse error in template argument list"); } - pop_deferring_access_checks (); + pop_to_parent_deferring_access_checks (); return template_id; } @@ -13266,7 +13335,6 @@ cp_parser_template_argument (cp_parser* parser) argument = cp_parser_constant_expression (parser, /*allow_non_constant_p=*/false, /*non_constant_p=*/NULL); - argument = fold_non_dependent_expr (argument); if (!maybe_type_id) return argument; if (!cp_parser_next_token_ends_template_argument_p (parser)) @@ -16299,6 +16367,8 @@ cp_parser_direct_declarator (cp_parser* parser, tree exception_specification; tree late_return; tree attrs; + bool memfn = (member_p || (pushed_scope + && CLASS_TYPE_P (pushed_scope))); is_declarator = true; @@ -16315,7 +16385,7 @@ cp_parser_direct_declarator (cp_parser* parser, attrs = cp_parser_std_attribute_spec_seq (parser); late_return = (cp_parser_late_return_type_opt - (parser, member_p ? cv_quals : -1)); + (parser, memfn ? cv_quals : -1)); /* Parse the virt-specifier-seq. */ virt_specifiers = cp_parser_virt_specifier_seq_opt (parser); @@ -16637,9 +16707,18 @@ cp_parser_direct_declarator (cp_parser* parser, handle_declarator:; scope = get_scope_of_declarator (declarator); if (scope) - /* Any names that appear after the declarator-id for a - member are looked up in the containing scope. */ - pushed_scope = push_scope (scope); + { + /* Any names that appear after the declarator-id for a + member are looked up in the containing scope. */ + if (at_function_scope_p ()) + { + /* But declarations with qualified-ids can't appear in a + function. */ + cp_parser_error (parser, "qualified-id in declaration"); + break; + } + pushed_scope = push_scope (scope); + } parser->in_declarator_p = true; if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p) || (declarator && declarator->kind == cdk_id)) @@ -16939,6 +17018,19 @@ inject_this_parameter (tree ctype, cp_cv_quals quals) current_class_ptr = this_parm; } +/* Return true iff our current scope is a non-static data member + initializer. */ + +bool +parsing_nsdmi (void) +{ + /* We recognize NSDMI context by the context-less 'this' pointer set up + by the function above. */ + if (current_class_ptr && DECL_CONTEXT (current_class_ptr) == NULL_TREE) + return true; + return false; +} + /* Parse a late-specified return type, if any. This is not a separate non-terminal, but part of a function declarator, which looks like @@ -22033,7 +22125,7 @@ static tree cp_parser_simple_cast_expression (cp_parser *parser) { return cp_parser_cast_expression (parser, /*address_p=*/false, - /*cast_p=*/false, NULL); + /*cast_p=*/false, /*decltype*/false, NULL); } /* Parse a functional cast to TYPE. Returns an expression @@ -26830,7 +26922,7 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl) op = (token->type == CPP_PLUS_PLUS ? PREINCREMENT_EXPR : PREDECREMENT_EXPR); cp_lexer_consume_token (parser->lexer); - lhs = cp_parser_cast_expression (parser, false, false, NULL); + lhs = cp_parser_simple_cast_expression (parser); if (lhs != decl) return error_mark_node; return build2 (op, TREE_TYPE (decl), decl, NULL_TREE); diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index eb9fc7f94c7..427447913ec 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -4306,6 +4306,13 @@ check_default_tmpl_args (tree decl, tree parms, bool is_primary, local scope. */ return true; + if (TREE_CODE (decl) == TYPE_DECL + && TREE_TYPE (decl) + && LAMBDA_TYPE_P (TREE_TYPE (decl))) + /* A lambda doesn't have an explicit declaration; don't complain + about the parms of the enclosing class. */ + return true; + if (current_class_type && !TYPE_BEING_DEFINED (current_class_type) && DECL_LANG_SPECIFIC (decl) @@ -4674,6 +4681,8 @@ push_template_decl_real (tree decl, bool is_friend) if (!ctx || TREE_CODE (ctx) == FUNCTION_DECL || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx)) + || (TREE_CODE (decl) == TYPE_DECL + && LAMBDA_TYPE_P (TREE_TYPE (decl))) || (is_friend && !DECL_TEMPLATE_INFO (decl))) { if (DECL_LANG_SPECIFIC (decl) @@ -5044,9 +5053,8 @@ fold_non_dependent_expr_sfinae (tree expr, tsubst_flags_t complain) as two declarations of the same function, for example. */ if (processing_template_decl - && !type_dependent_expression_p (expr) - && potential_constant_expression (expr) - && !value_dependent_expression_p (expr)) + && !instantiation_dependent_expression_p (expr) + && potential_constant_expression (expr)) { HOST_WIDE_INT saved_processing_template_decl; @@ -5554,15 +5562,19 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) qualification conversion. Let's strip everything. */ else if (TREE_CODE (expr) == NOP_EXPR && TYPE_PTROBV_P (type)) { - STRIP_NOPS (expr); - gcc_assert (TREE_CODE (expr) == ADDR_EXPR); - gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE); - /* Skip the ADDR_EXPR only if it is part of the decay for - an array. Otherwise, it is part of the original argument - in the source code. */ - if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE) - expr = TREE_OPERAND (expr, 0); - expr_type = TREE_TYPE (expr); + tree probe = expr; + STRIP_NOPS (probe); + if (TREE_CODE (probe) == ADDR_EXPR + && TREE_CODE (TREE_TYPE (probe)) == POINTER_TYPE) + { + /* Skip the ADDR_EXPR only if it is part of the decay for + an array. Otherwise, it is part of the original argument + in the source code. */ + if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe, 0))) == ARRAY_TYPE) + probe = TREE_OPERAND (probe, 0); + expr = probe; + expr_type = TREE_TYPE (expr); + } } /* [temp.arg.nontype]/5, bullet 1 @@ -5641,6 +5653,13 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) expr, expr); return NULL_TREE; } + if (POINTER_TYPE_P (expr_type)) + { + error ("%qE is not a valid template argument for %qT" + "because it is not the address of a variable", + expr, type); + return NULL_TREE; + } /* Other values, like integer constants, might be valid non-type arguments of some other type. */ return error_mark_node; @@ -5788,7 +5807,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) return NULL_TREE; } - expr = convert_nontype_argument_function (TREE_TYPE (type), expr); + expr = convert_nontype_argument_function (type, expr); if (!expr || expr == error_mark_node) return expr; @@ -8992,12 +9011,26 @@ instantiate_class_template_1 (tree type) } } - if (CLASSTYPE_LAMBDA_EXPR (type)) + if (tree expr = CLASSTYPE_LAMBDA_EXPR (type)) { tree decl = lambda_function (type); if (decl) { instantiate_decl (decl, false, false); + + /* We need to instantiate the capture list from the template + after we've instantiated the closure members, but before we + consider adding the conversion op. Also keep any captures + that may have been added during instantiation of the op(). */ + tree tmpl_expr = CLASSTYPE_LAMBDA_EXPR (pattern); + tree tmpl_cap + = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr), + args, tf_warning_or_error, NULL_TREE, + false, false); + + LAMBDA_EXPR_CAPTURE_LIST (expr) + = chainon (tmpl_cap, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr))); + maybe_add_lambda_conv_op (type); } else @@ -10826,6 +10859,9 @@ tsubst_arg_types (tree arg_types, } return error_mark_node; } + /* DR 657. */ + if (abstract_virtuals_error_sfinae (ACU_PARM, type, complain)) + return error_mark_node; /* Do array-to-pointer, function-to-pointer conversion, and ignore top-level qualifiers as required. */ @@ -10888,10 +10924,8 @@ tsubst_function_type (tree t, return_type = tsubst (TREE_TYPE (t), args, complain, in_decl); if (return_type == error_mark_node) return error_mark_node; - /* The standard does not presently indicate that creation of a - function type with an invalid return type is a deduction failure. - However, that is clearly analogous to creating an array of "void" - or a reference to a reference. This is core issue #486. */ + /* DR 486 clarifies that creation of a function type with an + invalid return type is a deduction failure. */ if (TREE_CODE (return_type) == ARRAY_TYPE || TREE_CODE (return_type) == FUNCTION_TYPE) { @@ -10904,6 +10938,9 @@ tsubst_function_type (tree t, } return error_mark_node; } + /* And DR 657. */ + if (abstract_virtuals_error_sfinae (ACU_RETURN, return_type, complain)) + return error_mark_node; /* Substitute the argument types. */ arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE, @@ -11625,13 +11662,9 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) error ("creating array of %qT", type); return error_mark_node; } - if (ABSTRACT_CLASS_TYPE_P (type)) - { - if (complain & tf_error) - error ("creating array of %qT, which is an abstract class type", - type); - return error_mark_node; - } + + if (abstract_virtuals_error_sfinae (ACU_ARRAY, type, complain)) + return error_mark_node; r = build_cplus_array_type (type, domain); @@ -11757,7 +11790,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) ++c_inhibit_evaluation_warnings; type = tsubst_expr (DECLTYPE_TYPE_EXPR (t), args, - complain, in_decl, + complain|tf_decltype, in_decl, /*integral_constant_expression_p=*/false); --cp_unevaluated_operand; @@ -12010,7 +12043,7 @@ tsubst_qualified_id (tree qualified_id, tree args, else if (TYPE_P (scope)) { expr = (adjust_result_of_qualified_name_lookup - (expr, scope, current_class_type)); + (expr, scope, current_nonlambda_class_type ())); expr = (finish_qualified_id_expr (scope, expr, done, address_p && PTRMEM_OK_P (qualified_id), QUALIFIED_NAME_IS_TEMPLATE (qualified_id), @@ -13393,6 +13426,12 @@ tsubst_copy_and_build (tree t, if (EXPR_HAS_LOCATION (t)) input_location = EXPR_LOCATION (t); + /* N3276 decltype magic only applies to calls at the top level or on the + right side of a comma. */ + if (TREE_CODE (t) != CALL_EXPR + && TREE_CODE (t) != COMPOUND_EXPR) + complain &= ~tf_decltype; + switch (TREE_CODE (t)) { case USING_DECL: @@ -13824,10 +13863,16 @@ tsubst_copy_and_build (tree t, complain)); case COMPOUND_EXPR: - RETURN (build_x_compound_expr (EXPR_LOCATION (t), - RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1)), - complain)); + { + tree op0 = tsubst_copy_and_build (TREE_OPERAND (t, 0), args, + complain & ~tf_decltype, in_decl, + /*function_p=*/false, + integral_constant_expression_p); + RETURN (build_x_compound_expr (EXPR_LOCATION (t), + op0, + RECUR (TREE_OPERAND (t, 1)), + complain)); + } case CALL_EXPR: { @@ -13838,6 +13883,10 @@ tsubst_copy_and_build (tree t, bool koenig_p; tree ret; + /* Don't pass tf_decltype down to subexpressions. */ + tsubst_flags_t decltype_flag = (complain & tf_decltype); + complain &= ~tf_decltype; + function = CALL_EXPR_FN (t); /* When we parsed the expression, we determined whether or not Koenig lookup should be performed. */ @@ -14004,6 +14053,9 @@ tsubst_copy_and_build (tree t, if (DECL_P (function)) mark_used (function); + /* Put back tf_decltype for the actual call. */ + complain |= decltype_flag; + if (TREE_CODE (function) == OFFSET_REF) ret = build_offset_ref_call_from_tree (function, &call_args, complain); @@ -14471,12 +14523,6 @@ tsubst_copy_and_build (tree t, declaration of the op() for later calls to lambda_function. */ complete_type (type); - /* The capture list refers to closure members, so this needs to - wait until after we finish instantiating the type. Also keep - any captures that may have been added during instantiation. */ - LAMBDA_EXPR_CAPTURE_LIST (r) - = chainon (RECUR (LAMBDA_EXPR_CAPTURE_LIST (t)), - LAMBDA_EXPR_CAPTURE_LIST (r)); LAMBDA_EXPR_THIS_CAPTURE (r) = NULL_TREE; RETURN (build_lambda_object (r)); diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 4cc02ba7dfc..54a5e4ae75d 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -188,6 +188,14 @@ lookup_base (tree t, tree base, base_access access, tree t_binfo; base_kind bk; + /* "Nothing" is definitely not derived from Base. */ + if (t == NULL_TREE) + { + if (kind_ptr) + *kind_ptr = bk_not_base; + return NULL_TREE; + } + if (t == error_mark_node || base == error_mark_node) { if (kind_ptr) diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index e909b984681..5143e4bd582 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -1574,9 +1574,7 @@ finish_non_static_data_member (tree decl, tree object, tree qualifying_scope) else { /* Set the cv qualifiers. */ - int quals = (current_class_ref - ? cp_type_quals (TREE_TYPE (current_class_ref)) - : TYPE_UNQUALIFIED); + int quals = cp_type_quals (TREE_TYPE (object)); if (DECL_MUTABLE_P (decl)) quals &= ~TYPE_QUAL_CONST; @@ -2884,7 +2882,8 @@ outer_var_p (tree decl) { return ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL) && DECL_FUNCTION_SCOPE_P (decl) - && DECL_CONTEXT (decl) != current_function_decl); + && (DECL_CONTEXT (decl) != current_function_decl + || parsing_nsdmi ())); } /* As above, but also checks that DECL is automatic. */ @@ -3041,12 +3040,14 @@ finish_id_expression (tree id_expression, return integral_constant_value (decl); } + if (parsing_nsdmi ()) + containing_function = NULL_TREE; /* If we are in a lambda function, we can move out until we hit 1. the context, 2. a non-lambda function, or 3. a non-default capturing lambda function. */ - while (context != containing_function - && LAMBDA_FUNCTION_P (containing_function)) + else while (context != containing_function + && LAMBDA_FUNCTION_P (containing_function)) { lambda_expr = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function)); @@ -7007,6 +7008,13 @@ cxx_eval_array_reference (const constexpr_call *call, tree t, *non_constant_p = true; return t; } + else if (tree_int_cst_lt (index, integer_zero_node)) + { + if (!allow_non_constant) + error ("negative array subscript"); + *non_constant_p = true; + return t; + } i = tree_low_cst (index, 0); if (TREE_CODE (ary) == CONSTRUCTOR) return (*CONSTRUCTOR_ELTS (ary))[i].value; @@ -8487,6 +8495,13 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags) STRIP_NOPS (x); if (is_this_parameter (x)) { + if (DECL_CONTEXT (x) + && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x))) + { + if (flags & tf_error) + error ("use of %<this%> in a constant expression"); + return false; + } if (want_rval && DECL_CONTEXT (x) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x))) { @@ -8967,7 +8982,7 @@ begin_lambda_type (tree lambda) /* Create the new RECORD_TYPE for this lambda. */ type = xref_tag (/*tag_code=*/record_type, name, - /*scope=*/ts_within_enclosing_non_class, + /*scope=*/ts_lambda, /*template_header_p=*/false); } @@ -9039,7 +9054,7 @@ tree lambda_capture_field_type (tree expr) { tree type; - if (type_dependent_expression_p (expr)) + if (!TREE_TYPE (expr) || WILDCARD_TYPE_P (TREE_TYPE (expr))) { type = cxx_make_type (DECLTYPE_TYPE); DECLTYPE_TYPE_EXPR (type) = expr; @@ -9248,7 +9263,7 @@ lambda_proxy_type (tree ref) if (REFERENCE_REF_P (ref)) ref = TREE_OPERAND (ref, 0); type = TREE_TYPE (ref); - if (!dependent_type_p (type)) + if (type && !WILDCARD_TYPE_P (type)) return type; type = cxx_make_type (DECLTYPE_TYPE); DECLTYPE_TYPE_EXPR (type) = ref; @@ -9661,7 +9676,11 @@ maybe_add_lambda_conv_op (tree type) DECL_STATIC_FUNCTION_P (fn) = 1; DECL_ARGUMENTS (fn) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop))); for (arg = DECL_ARGUMENTS (fn); arg; arg = DECL_CHAIN (arg)) - DECL_CONTEXT (arg) = fn; + { + /* Avoid duplicate -Wshadow warnings. */ + DECL_NAME (arg) = NULL_TREE; + DECL_CONTEXT (arg) = fn; + } if (nested) DECL_INTERFACE_KNOWN (fn) = 1; diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 178b80aa24f..a1cce647b24 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -469,6 +469,9 @@ build_cplus_new (tree type, tree init, tsubst_flags_t complain) tree rval = build_aggr_init_expr (type, init); tree slot; + if (!complete_type_or_maybe_complain (type, init, complain)) + return error_mark_node; + /* Make sure that we're not trying to create an instance of an abstract class. */ if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain)) @@ -1418,7 +1421,8 @@ strip_typedefs_expr (tree t) } case LAMBDA_EXPR: - gcc_unreachable (); + error ("lambda-expression in a constant expression"); + return error_mark_node; default: break; @@ -2024,11 +2028,12 @@ no_linkage_check (tree t, bool relaxed_p) if (TYPE_PTRMEMFUNC_P (t)) goto ptrmem; /* Lambda types that don't have mangling scope have no linkage. We - check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because + check CLASSTYPE_LAMBDA_EXPR for error_mark_node because when we get here from pushtag none of the lambda information is set up yet, so we want to assume that the lambda has linkage and fix it up later if not. */ if (CLASSTYPE_LAMBDA_EXPR (t) + && CLASSTYPE_LAMBDA_EXPR (t) != error_mark_node && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE) return t; /* Fall through. */ @@ -2486,7 +2491,7 @@ cp_tree_equal (tree t1, tree t2) t1 = TREE_OPERAND (t1, 0); for (code2 = TREE_CODE (t2); CONVERT_EXPR_CODE_P (code2) - || code1 == NON_LVALUE_EXPR; + || code2 == NON_LVALUE_EXPR; code2 = TREE_CODE (t2)) t2 = TREE_OPERAND (t2, 0); diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 58ebcc0ab2d..3ced8586663 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -4015,7 +4015,7 @@ cp_build_binary_op (location_t location, { enum tree_code tcode0 = code0, tcode1 = code1; - warn_for_div_by_zero (location, op1); + warn_for_div_by_zero (location, maybe_constant_value (op1)); if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE) tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); @@ -4051,7 +4051,7 @@ cp_build_binary_op (location_t location, case TRUNC_MOD_EXPR: case FLOOR_MOD_EXPR: - warn_for_div_by_zero (location, op1); + warn_for_div_by_zero (location, maybe_constant_value (op1)); if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE @@ -6238,6 +6238,12 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p, if (TREE_CODE (type) == VOID_TYPE) return convert_to_void (expr, ICV_CAST, complain); + /* [class.abstract] + An abstract class shall not be used ... as the type of an explicit + conversion. */ + if (abstract_virtuals_error_sfinae (ACU_CAST, type, complain)) + return error_mark_node; + /* [expr.static.cast] An expression e can be explicitly converted to a type T using a diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index d227a821d43..24b55938527 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -141,6 +141,9 @@ struct GTY((chain_next ("%h.next"))) pending_abstract_type { /* Type which will be checked for abstractness. */ tree type; + /* Kind of use in an unnamed declarator. */ + abstract_class_use use; + /* Position of the declaration. This is only needed for IDENTIFIER_NODEs, because DECLs already carry locus information. */ location_t locus; @@ -181,6 +184,7 @@ pat_compare (const void* val1, const void* val2) static GTY ((param_is (struct pending_abstract_type))) htab_t abstract_pending_vars = NULL; +static int abstract_virtuals_error_sfinae (tree, tree, abstract_class_use, tsubst_flags_t); /* This function is called after TYPE is completed, and will check if there are pending declarations for which we still need to verify the abstractness @@ -231,7 +235,8 @@ complete_type_check_abstract (tree type) location. Notice that this is only needed if the decl is an IDENTIFIER_NODE. */ input_location = pat->locus; - abstract_virtuals_error (pat->decl, pat->type); + abstract_virtuals_error_sfinae (pat->decl, pat->type, pat->use, + tf_warning_or_error); pat = pat->next; } } @@ -244,11 +249,13 @@ complete_type_check_abstract (tree type) /* If TYPE has abstract virtual functions, issue an error about trying to create an object of that type. DECL is the object declared, or - NULL_TREE if the declaration is unavailable. Returns 1 if an error - occurred; zero if all was well. */ + NULL_TREE if the declaration is unavailable, in which case USE specifies + the kind of invalid use. Returns 1 if an error occurred; zero if + all was well. */ -int -abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) +static int +abstract_virtuals_error_sfinae (tree decl, tree type, abstract_class_use use, + tsubst_flags_t complain) { vec<tree, va_gc> *pure; @@ -280,6 +287,7 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) pat = ggc_alloc_pending_abstract_type (); pat->type = type; pat->decl = decl; + pat->use = use; pat->locus = ((decl && DECL_P (decl)) ? DECL_SOURCE_LOCATION (decl) : input_location); @@ -308,8 +316,14 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) error ("cannot declare variable %q+D to be of abstract " "type %qT", decl, type); else if (TREE_CODE (decl) == PARM_DECL) - error ("cannot declare parameter %q+D to be of abstract type %qT", - decl, type); + { + if (DECL_NAME (decl)) + error ("cannot declare parameter %q+D to be of abstract type %qT", + decl, type); + else + error ("cannot declare parameter to be of abstract type %qT", + type); + } else if (TREE_CODE (decl) == FIELD_DECL) error ("cannot declare field %q+D to be of abstract type %qT", decl, type); @@ -324,8 +338,34 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) else error ("invalid abstract type for %q+D", decl); } - else - error ("cannot allocate an object of abstract type %qT", type); + else switch (use) + { + case ACU_ARRAY: + error ("creating array of %qT, which is an abstract class type", type); + break; + case ACU_CAST: + error ("invalid cast to abstract class type %qT", type); + break; + case ACU_NEW: + error ("invalid new-expression of abstract class type %qT", type); + break; + case ACU_RETURN: + error ("invalid abstract return type %qT", type); + break; + case ACU_PARM: + error ("invalid abstract parameter type %qT", type); + break; + case ACU_THROW: + error ("expression of abstract class type %qT cannot " + "be used in throw-expression", type); + break; + case ACU_CATCH: + error ("cannot declare catch parameter to be of abstract " + "class type %qT", type); + break; + default: + error ("cannot allocate an object of abstract type %qT", type); + } /* Only go through this once. */ if (pure->length ()) @@ -347,14 +387,24 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) again. */ pure->truncate (0); } - else - inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)), - " since type %qT has pure virtual functions", - type); return 1; } +int +abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) +{ + return abstract_virtuals_error_sfinae (decl, type, ACU_UNKNOWN, complain); +} + +int +abstract_virtuals_error_sfinae (abstract_class_use use, tree type, + tsubst_flags_t complain) +{ + return abstract_virtuals_error_sfinae (NULL_TREE, type, use, complain); +} + + /* Wrapper for the above function in the common case of wanting errors. */ int @@ -363,6 +413,12 @@ abstract_virtuals_error (tree decl, tree type) return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error); } +int +abstract_virtuals_error (abstract_class_use use, tree type) +{ + return abstract_virtuals_error_sfinae (use, type, tf_warning_or_error); +} + /* 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_KIND indicates the @@ -1729,7 +1785,7 @@ build_functional_cast (tree exp, tree parms, tsubst_flags_t complain) if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)) return error_mark_node; - if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain)) + if (abstract_virtuals_error_sfinae (ACU_CAST, type, complain)) return error_mark_node; /* [expr.type.conv] diff --git a/gcc/domwalk.c b/gcc/domwalk.c index 4a8ed26d3ba..8c1ddc69490 100644 --- a/gcc/domwalk.c +++ b/gcc/domwalk.c @@ -128,6 +128,21 @@ along with GCC; see the file COPYING3. If not see which is currently an abstraction over walking tree statements. Thus the dominator walker is currently only useful for trees. */ +static int *bb_postorder; + +static int +cmp_bb_postorder (const void *a, const void *b) +{ + basic_block bb1 = *(basic_block *)const_cast<void *>(a); + basic_block bb2 = *(basic_block *)const_cast<void *>(b); + if (bb1->index == bb2->index) + return 0; + /* Place higher completion number first (pop off lower number first). */ + if (bb_postorder[bb1->index] > bb_postorder[bb2->index]) + return -1; + return 1; +} + /* Recursively walk the dominator tree. WALK_DATA contains a set of callbacks to perform pass-specific @@ -143,9 +158,17 @@ walk_dominator_tree (struct dom_walk_data *walk_data, basic_block bb) basic_block dest; basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks * 2); int sp = 0; - sbitmap visited = sbitmap_alloc (last_basic_block + 1); - bitmap_clear (visited); - bitmap_set_bit (visited, ENTRY_BLOCK_PTR->index); + int *postorder, postorder_num; + + if (walk_data->dom_direction == CDI_DOMINATORS) + { + postorder = XNEWVEC (int, n_basic_blocks); + postorder_num = inverted_post_order_compute (postorder); + bb_postorder = XNEWVEC (int, last_basic_block); + for (int i = 0; i < postorder_num; ++i) + bb_postorder[postorder[i]] = i; + free (postorder); + } while (true) { @@ -186,16 +209,25 @@ walk_dominator_tree (struct dom_walk_data *walk_data, basic_block bb) if (walk_data->before_dom_children) (*walk_data->before_dom_children) (walk_data, bb); - bitmap_set_bit (visited, bb->index); - /* Mark the current BB to be popped out of the recursion stack once children are processed. */ worklist[sp++] = bb; worklist[sp++] = NULL; + int saved_sp = sp; for (dest = first_dom_son (walk_data->dom_direction, bb); dest; dest = next_dom_son (walk_data->dom_direction, dest)) worklist[sp++] = dest; + if (walk_data->dom_direction == CDI_DOMINATORS) + switch (sp - saved_sp) + { + case 0: + case 1: + break; + default: + qsort (&worklist[saved_sp], sp - saved_sp, + sizeof (basic_block), cmp_bb_postorder); + } } /* NULL is used to mark pop operations in the recursion stack. */ while (sp > 0 && !worklist[sp - 1]) @@ -217,44 +249,16 @@ walk_dominator_tree (struct dom_walk_data *walk_data, basic_block bb) } } if (sp) - { - int spp; - spp = sp - 1; - if (walk_data->dom_direction == CDI_DOMINATORS) - /* Find the dominator son that has all its predecessors - visited and continue with that. */ - while (1) - { - edge_iterator ei; - edge e; - bool found = true; - bb = worklist[spp]; - FOR_EACH_EDGE (e, ei, bb->preds) - { - if (!dominated_by_p (CDI_DOMINATORS, e->src, e->dest) - && !bitmap_bit_p (visited, e->src->index)) - { - found = false; - break; - } - } - if (found) - break; - /* If we didn't find a dom child with all visited - predecessors just use the candidate we were checking. - This happens for candidates in irreducible loops. */ - if (!worklist[spp - 1]) - break; - --spp; - } - bb = worklist[spp]; - worklist[spp] = worklist[--sp]; - } + bb = worklist[--sp]; else break; } + if (walk_data->dom_direction == CDI_DOMINATORS) + { + free (bb_postorder); + bb_postorder = NULL; + } free (worklist); - sbitmap_free (visited); } void diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index d7faaac9f85..51e57378dad 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -10238,6 +10238,7 @@ gen_generic_params_dies (tree t) tree parms, args; int parms_num, i; dw_die_ref die = NULL; + int non_default; if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t))) return; @@ -10257,9 +10258,14 @@ gen_generic_params_dies (tree t) parms_num = TREE_VEC_LENGTH (parms); args = lang_hooks.get_innermost_generic_args (t); + if (TREE_CHAIN (args) && TREE_CODE (TREE_CHAIN (args)) == INTEGER_CST) + non_default = int_cst_value (TREE_CHAIN (args)); + else + non_default = TREE_VEC_LENGTH (args); for (i = 0; i < parms_num; i++) { tree parm, arg, arg_pack_elems; + dw_die_ref parm_die; parm = TREE_VEC_ELT (parms, i); arg = TREE_VEC_ELT (args, i); @@ -10274,12 +10280,14 @@ gen_generic_params_dies (tree t) pack elements of ARG. Note that ARG would then be an argument pack. */ if (arg_pack_elems) - template_parameter_pack_die (TREE_VALUE (parm), - arg_pack_elems, - die); + parm_die = template_parameter_pack_die (TREE_VALUE (parm), + arg_pack_elems, + die); else - generic_parameter_die (TREE_VALUE (parm), arg, - true /* Emit DW_AT_name */, die); + parm_die = generic_parameter_die (TREE_VALUE (parm), arg, + true /* emit name */, die); + if (i >= non_default) + add_AT_flag (parm_die, DW_AT_default_value, 1); } } } diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 26cfc0e83e4..de7117e8e87 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -2572,13 +2572,14 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags) flags &= ~OEP_CONSTANT_ADDRESS_OF; /* Require equal access sizes, and similar pointer types. We can have incomplete types for array references of - variable-sized arrays from the Fortran frontent - though. */ + variable-sized arrays from the Fortran frontend + though. Also verify the types are compatible. */ return ((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1)) || (TYPE_SIZE (TREE_TYPE (arg0)) && TYPE_SIZE (TREE_TYPE (arg1)) && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)), TYPE_SIZE (TREE_TYPE (arg1)), flags))) + && types_compatible_p (TREE_TYPE (arg0), TREE_TYPE (arg1)) && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg0, 1))) == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg1, 1)))) && OP_SAME (0) && OP_SAME (1)); diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index ec9fbaa734b..00bbcd1a201 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,17 @@ +2013-03-18 Tobias Burnus <burnus@net-b.de> + + * gfortran.h (gfc_option_t): Remove flag_whole_file. + * invoke.texi (-fno-whole-file): Remove. + * lang.opt (fwhole-file): Change to Ignore. + * options.c (gfc_init_options, gfc_post_options, + gfc_handle_option): Remove !flag_whole_file handling + * parse.c (resolve_all_program_units, translate_all_program_units, + gfc_parse_file): Ditto. + * resolve.c (resolve_global_procedure): Ditto. + * trans-decl.c (gfc_get_symbol_decl, gfc_get_extern_function_decl, + gfc_create_module_variable): Ditto. + * trans-types.c (gfc_get_derived_type): Ditto. + 2013-03-15 Tobias Burnus <burnus@net-b.de> PR fortran/56615 @@ -218,7 +232,7 @@ results for functions without extra result variable. 2013-01-29 Janus Weil <janus@gcc.gnu.org> - Mikael Morin <mikael@gcc.gnu.org> + Mikael Morin <mikael@gcc.gnu.org> PR fortran/54107 * gfortran.h (gfc_component): Delete members 'formal' and 'formal_ns'. diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 18bbf7954c3..76d27971f05 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -2297,7 +2297,6 @@ typedef struct int flag_init_character; char flag_init_character_value; int flag_align_commons; - int flag_whole_file; int flag_protect_parens; int flag_realloc_lhs; int flag_aggressive_function_elimination; diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi index db958f9b37f..12c200e818a 100644 --- a/gcc/fortran/invoke.texi +++ b/gcc/fortran/invoke.texi @@ -180,7 +180,7 @@ and warnings}. -finit-real=@var{<zero|inf|-inf|nan|snan>} @gol -fmax-array-constructor=@var{n} -fmax-stack-var-size=@var{n} -fno-align-commons @gol --fno-automatic -fno-protect-parens -fno-underscoring -fno-whole-file @gol +-fno-automatic -fno-protect-parens -fno-underscoring @gol -fsecond-underscore -fpack-derived -frealloc-lhs -frecursive @gol -frepack-arrays -fshort-enums -fstack-arrays } @@ -1291,22 +1291,6 @@ in the source, even if the names as seen by the linker are mangled to prevent accidental linking between procedures with incompatible interfaces. -@item -fno-whole-file -@opindex @code{fno-whole-file} -This flag causes the compiler to resolve and translate each procedure in -a file separately. - -By default, the whole file is parsed and placed in a single front-end tree. -During resolution, in addition to all the usual checks and fixups, references -to external procedures that are in the same file effect resolution of -that procedure, if not already done, and a check of the interfaces. The -dependences are resolved by changing the order in which the file is -translated into the backend tree. Thus, a procedure that is referenced -is translated before the reference and the duplication of backend tree -declarations eliminated. - -The @option{-fno-whole-file} option is deprecated and may lead to wrong code. - @item -fsecond-underscore @opindex @code{fsecond-underscore} @cindex underscore diff --git a/gcc/fortran/lang.opt b/gcc/fortran/lang.opt index fbe8a1b2fb9..dbc3f6bafda 100644 --- a/gcc/fortran/lang.opt +++ b/gcc/fortran/lang.opt @@ -594,8 +594,8 @@ Fortran Append underscores to externally visible names fwhole-file -Fortran -Compile all program units at once and check all interfaces +Fortran Ignore +Does nothing. Preserved for backward compatibility. fworking-directory Fortran diff --git a/gcc/fortran/options.c b/gcc/fortran/options.c index fba1a3f3a88..3f5de036908 100644 --- a/gcc/fortran/options.c +++ b/gcc/fortran/options.c @@ -124,7 +124,6 @@ gfc_init_options (unsigned int decoded_options_count, gfc_option.flag_real8_kind = 0; gfc_option.flag_dollar_ok = 0; gfc_option.flag_underscoring = 1; - gfc_option.flag_whole_file = 1; gfc_option.flag_f2c = 0; gfc_option.flag_second_underscore = -1; gfc_option.flag_implicit_none = 0; @@ -264,14 +263,6 @@ gfc_post_options (const char **pfilename) sorry ("-fexcess-precision=standard for Fortran"); flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; - /* Whole program needs whole file mode. */ - if (flag_whole_program) - gfc_option.flag_whole_file = 1; - - /* Enable whole-file mode if LTO is in effect. */ - if (flag_lto) - gfc_option.flag_whole_file = 1; - /* Fortran allows associative math - but we cannot reassociate if we want traps or signed zeros. Cf. also flag_protect_parens. */ if (flag_associative_math == -1) @@ -430,9 +421,6 @@ gfc_post_options (const char **pfilename) gfc_option.warn_tabs = 0; } - if (pedantic && gfc_option.flag_whole_file) - gfc_option.flag_whole_file = 2; - /* Optimization implies front end optimization, unless the user specified it directly. */ @@ -823,10 +811,6 @@ gfc_handle_option (size_t scode, const char *arg, int value, gfc_option.flag_underscoring = value; break; - case OPT_fwhole_file: - gfc_option.flag_whole_file = value; - break; - case OPT_fsecond_underscore: gfc_option.flag_second_underscore = value; break; diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c index 6ee7b7fb85c..a7fa7dc597e 100644 --- a/gcc/fortran/parse.c +++ b/gcc/fortran/parse.c @@ -4382,8 +4382,7 @@ add_global_program (void) } -/* Resolve all the program units when whole file scope option - is active. */ +/* Resolve all the program units. */ static void resolve_all_program_units (gfc_namespace *gfc_global_ns_list) { @@ -4424,9 +4423,8 @@ clean_up_modules (gfc_gsymbol *gsym) } -/* Translate all the program units when whole file scope option - is active. This could be in a different order to resolution if - there are forward references in the file. */ +/* Translate all the program units. This could be in a different order + to resolution if there are forward references in the file. */ static void translate_all_program_units (gfc_namespace *gfc_global_ns_list, bool main_in_tu) @@ -4551,8 +4549,7 @@ loop: accept_statement (st); add_global_program (); parse_progunit (ST_NONE); - if (gfc_option.flag_whole_file) - goto prog_units; + goto prog_units; break; case ST_SUBROUTINE: @@ -4560,8 +4557,7 @@ loop: push_state (&s, COMP_SUBROUTINE, gfc_new_block); accept_statement (st); parse_progunit (ST_NONE); - if (gfc_option.flag_whole_file) - goto prog_units; + goto prog_units; break; case ST_FUNCTION: @@ -4569,8 +4565,7 @@ loop: push_state (&s, COMP_FUNCTION, gfc_new_block); accept_statement (st); parse_progunit (ST_NONE); - if (gfc_option.flag_whole_file) - goto prog_units; + goto prog_units; break; case ST_BLOCK_DATA: @@ -4597,8 +4592,7 @@ loop: push_state (&s, COMP_PROGRAM, gfc_new_block); main_program_symbol (gfc_current_ns, "MAIN__"); parse_progunit (st); - if (gfc_option.flag_whole_file) - goto prog_units; + goto prog_units; break; } @@ -4615,19 +4609,9 @@ loop: if (s.state == COMP_MODULE) { gfc_dump_module (s.sym->name, errors_before == errors); - if (!gfc_option.flag_whole_file) - { - if (errors == 0) - gfc_generate_module_code (gfc_current_ns); - pop_state (); - gfc_done_2 (); - } - else - { - gfc_current_ns->derived_types = gfc_derived_types; - gfc_derived_types = NULL; - goto prog_units; - } + gfc_current_ns->derived_types = gfc_derived_types; + gfc_derived_types = NULL; + goto prog_units; } else { @@ -4660,9 +4644,6 @@ prog_units: done: - if (!gfc_option.flag_whole_file) - goto termination; - /* Do the resolution. */ resolve_all_program_units (gfc_global_ns_list); @@ -4681,8 +4662,6 @@ prog_units: /* Do the translation. */ translate_all_program_units (gfc_global_ns_list, seen_program); -termination: - gfc_end_source_files (); return SUCCESS; diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c index bb0b946c9b3..e9b6fb9be43 100644 --- a/gcc/fortran/resolve.c +++ b/gcc/fortran/resolve.c @@ -2145,15 +2145,14 @@ resolve_global_procedure (gfc_symbol *sym, locus *where, if ((gsym->type != GSYM_UNKNOWN && gsym->type != type)) gfc_global_used (gsym, where); - if (gfc_option.flag_whole_file - && (sym->attr.if_source == IFSRC_UNKNOWN - || sym->attr.if_source == IFSRC_IFBODY) - && gsym->type != GSYM_UNKNOWN - && gsym->ns - && gsym->ns->resolved != -1 - && gsym->ns->proc_name - && not_in_recursive (sym, gsym->ns) - && not_entry_self_reference (sym, gsym->ns)) + if ((sym->attr.if_source == IFSRC_UNKNOWN + || sym->attr.if_source == IFSRC_IFBODY) + && gsym->type != GSYM_UNKNOWN + && gsym->ns + && gsym->ns->resolved != -1 + && gsym->ns->proc_name + && not_in_recursive (sym, gsym->ns) + && not_entry_self_reference (sym, gsym->ns)) { gfc_symbol *def_sym; @@ -2364,7 +2363,7 @@ resolve_global_procedure (gfc_symbol *sym, locus *where, "an explicit interface", sym->name, &sym->declared_at); } - if (gfc_option.flag_whole_file == 1 + if (!pedantic || ((gfc_option.warn_std & GFC_STD_LEGACY) && !(gfc_option.warn_std & GFC_STD_GNU))) gfc_errors_to_warnings (1); diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c index 7806bbbd878..0e853bac6a1 100644 --- a/gcc/fortran/trans-decl.c +++ b/gcc/fortran/trans-decl.c @@ -1341,15 +1341,14 @@ gfc_get_symbol_decl (gfc_symbol * sym) && sym->attr.flavor == FL_PARAMETER) intrinsic_array_parameter = true; - /* If use associated and whole file compilation, use the module + /* If use associated compilation, use the module declaration. */ - if (gfc_option.flag_whole_file - && (sym->attr.flavor == FL_VARIABLE - || sym->attr.flavor == FL_PARAMETER) - && sym->attr.use_assoc - && !intrinsic_array_parameter - && sym->module - && gfc_get_module_backend_decl (sym)) + if ((sym->attr.flavor == FL_VARIABLE + || sym->attr.flavor == FL_PARAMETER) + && sym->attr.use_assoc + && !intrinsic_array_parameter + && sym->module + && gfc_get_module_backend_decl (sym)) { if (sym->ts.type == BT_CLASS && sym->backend_decl) GFC_DECL_CLASS(sym->backend_decl) = 1; @@ -1646,12 +1645,11 @@ gfc_get_extern_function_decl (gfc_symbol * sym) return the backend_decl. */ gsym = gfc_find_gsymbol (gfc_gsym_root, sym->name); - if (gfc_option.flag_whole_file - && (!sym->attr.use_assoc || sym->attr.if_source != IFSRC_DECL) - && !sym->backend_decl - && gsym && gsym->ns - && ((gsym->type == GSYM_SUBROUTINE) || (gsym->type == GSYM_FUNCTION)) - && (gsym->ns->proc_name->backend_decl || !sym->attr.intrinsic)) + if ((!sym->attr.use_assoc || sym->attr.if_source != IFSRC_DECL) + && !sym->backend_decl + && gsym && gsym->ns + && ((gsym->type == GSYM_SUBROUTINE) || (gsym->type == GSYM_FUNCTION)) + && (gsym->ns->proc_name->backend_decl || !sym->attr.intrinsic)) { if (!gsym->ns->proc_name->backend_decl) { @@ -1703,9 +1701,7 @@ gfc_get_extern_function_decl (gfc_symbol * sym) if (sym->module) gsym = gfc_find_gsymbol (gfc_gsym_root, sym->module); - if (gfc_option.flag_whole_file - && gsym && gsym->ns - && gsym->type == GSYM_MODULE) + if (gsym && gsym->ns && gsym->type == GSYM_MODULE) { gfc_symbol *s; @@ -4047,8 +4043,7 @@ gfc_create_module_variable (gfc_symbol * sym) decl = sym->backend_decl; gcc_assert (sym->ns->proc_name->attr.flavor == FL_MODULE); - /* -fwhole-file mixes up the contexts so these asserts are unnecessary. */ - if (!(gfc_option.flag_whole_file && sym->attr.use_assoc)) + if (!sym->attr.use_assoc) { gcc_assert (TYPE_CONTEXT (decl) == NULL_TREE || TYPE_CONTEXT (decl) == sym->ns->proc_name->backend_decl); diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c index 30561ee7ecf..cdac0dacc12 100644 --- a/gcc/fortran/trans-types.c +++ b/gcc/fortran/trans-types.c @@ -2370,19 +2370,16 @@ gfc_get_derived_type (gfc_symbol * derived) } /* If use associated, use the module type for this one. */ - if (gfc_option.flag_whole_file - && derived->backend_decl == NULL - && derived->attr.use_assoc - && derived->module - && gfc_get_module_backend_decl (derived)) + if (derived->backend_decl == NULL + && derived->attr.use_assoc + && derived->module + && gfc_get_module_backend_decl (derived)) goto copy_derived_types; - /* If a whole file compilation, the derived types from an earlier - namespace can be used as the canonical type. */ - if (gfc_option.flag_whole_file - && derived->backend_decl == NULL - && !derived->attr.use_assoc - && gfc_global_ns_list) + /* The derived types from an earlier namespace can be used as the + canonical type. */ + if (derived->backend_decl == NULL && !derived->attr.use_assoc + && gfc_global_ns_list) { for (ns = gfc_global_ns_list; ns->translated && !got_canonical; diff --git a/gcc/gimple.h b/gcc/gimple.h index 1bbd7d76a11..475d2ea9ee7 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -2750,23 +2750,6 @@ gimple_cond_false_p (const_gimple gs) return false; } -/* Check if conditional statement GS is of the form 'if (var != 0)' or - 'if (var == 1)' */ - -static inline bool -gimple_cond_single_var_p (gimple gs) -{ - if (gimple_cond_code (gs) == NE_EXPR - && gimple_cond_rhs (gs) == boolean_false_node) - return true; - - if (gimple_cond_code (gs) == EQ_EXPR - && gimple_cond_rhs (gs) == boolean_true_node) - return true; - - return false; -} - /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */ static inline void diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index f68349363b0..2b293a995c1 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -2117,7 +2117,6 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target) we may create the first reference to the object in the unit. */ if (!callee || callee->global.inlined_to) { - struct cgraph_node *first_clone = callee; /* We are better to ensure we can refer to it. In the case of static functions we are out of luck, since we already @@ -2133,31 +2132,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target) xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid); return NULL; } - - /* Create symbol table node. Even if inline clone exists, we can not take - it as a target of non-inlined call. */ - callee = cgraph_create_node (target); - - /* OK, we previously inlined the function, then removed the offline copy and - now we want it back for external call. This can happen when devirtualizing - while inlining function called once that happens after extern inlined and - virtuals are already removed. In this case introduce the external node - and make it available for call. */ - if (first_clone) - { - first_clone->clone_of = callee; - callee->clones = first_clone; - symtab_prevail_in_asm_name_hash ((symtab_node)callee); - symtab_insert_node_to_hashtable ((symtab_node)callee); - if (dump_file) - fprintf (dump_file, "ipa-prop: Introduced new external node " - "(%s/%i) and turned into root of the clone tree.\n", - xstrdup (cgraph_node_name (callee)), callee->uid); - } - else if (dump_file) - fprintf (dump_file, "ipa-prop: Introduced new external node " - "(%s/%i).\n", - xstrdup (cgraph_node_name (callee)), callee->uid); + callee = cgraph_get_create_real_symbol_node (target); } ipa_check_create_node_params (); diff --git a/gcc/langhooks.h b/gcc/langhooks.h index 4bc1bd571dd..80d4ef3b8a6 100644 --- a/gcc/langhooks.h +++ b/gcc/langhooks.h @@ -407,8 +407,10 @@ struct lang_hooks struct lang_hooks_for_lto lto; - /* Returns the generic parameters of an instantiation of - a generic type or decl, e.g. C++ template instantiation. */ + /* Returns a TREE_VEC of the generic parameters of an instantiation of + a generic type or decl, e.g. C++ template instantiation. If + TREE_CHAIN of the return value is set, it is an INTEGER_CST + indicating how many of the elements are non-default. */ tree (*get_innermost_generic_parms) (const_tree); /* Returns the TREE_VEC of arguments of an instantiation diff --git a/gcc/passes.c b/gcc/passes.c index 8390223e88e..5f9330672fc 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -1488,7 +1488,6 @@ init_optimization_passes (void) NEXT_PASS (pass_lower_vector_ssa); NEXT_PASS (pass_cse_reciprocals); NEXT_PASS (pass_reassoc); - NEXT_PASS (pass_vrp); NEXT_PASS (pass_strength_reduction); NEXT_PASS (pass_dominator); /* The only const/copy propagation opportunities left after @@ -1497,6 +1496,7 @@ init_optimization_passes (void) only examines PHIs to discover const/copy propagation opportunities. */ NEXT_PASS (pass_phi_only_cprop); + NEXT_PASS (pass_vrp); NEXT_PASS (pass_cd_dce); NEXT_PASS (pass_tracer); diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index 10b4f3b1712..1f2e5257604 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,7 @@ +2013-03-17 Joseph Myers <joseph@codesourcery.com> + + * sv.po: Update. + 2013-03-15 Joseph Myers <joseph@codesourcery.com> * gcc.pot: Regenerate. diff --git a/gcc/po/sv.po b/gcc/po/sv.po index 404d8848189..da2fdc5aab5 100644 --- a/gcc/po/sv.po +++ b/gcc/po/sv.po @@ -16,7 +16,7 @@ msgstr "" "Project-Id-Version: gcc 4.8-b20130224\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2013-02-24 01:09+0000\n" -"PO-Revision-Date: 2013-03-10 16:27+0100\n" +"PO-Revision-Date: 2013-03-17 10:56+0100\n" "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n" "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n" "Language: sv\n" @@ -1204,7 +1204,7 @@ msgstr " Det finns inga flaggor med de eftersökta egenskaperna\n" #: opts.c:1054 #, c-format msgid " None found. Use --help=%s to show *all* the options supported by the %s front-end\n" -msgstr " Det fanns inga. Använd --help=%s för att visa *alla* flaggorna som stöds av framänden %s\n" +msgstr " Det fanns inga. Använd --help=%s för att visa *alla* flaggorna som stödjs av framänden %s\n" #: opts.c:1060 #, c-format @@ -1237,7 +1237,7 @@ msgstr "Följande flaggor är specifika för just språket" #: opts.c:1175 msgid "The following options are supported by the language " -msgstr "Följande flaggor stöds av språket" +msgstr "Följande flaggor stödjs av språket" #: opts.c:1186 msgid "The following options are not documented" @@ -4896,7 +4896,7 @@ msgstr "får inte använda både -EB och -EL" #: config/mips/r3900.h:37 msgid "-mhard-float not supported" -msgstr "-mhard-float stöds inte" +msgstr "-mhard-float stödjs inte" #: config/mips/r3900.h:39 msgid "-msingle-float and -msoft-float cannot both be specified" @@ -4944,7 +4944,7 @@ msgstr "-private_bundle är inte tillåten med -dynamiclib" #: config/vax/netbsd-elf.h:51 msgid "the -shared option is not currently supported for VAX ELF" -msgstr "flaggan -shared stöds för närvarande inte för VAX ELF" +msgstr "flaggan -shared stödjs för närvarande inte för VAX ELF" #: config/i386/mingw-w64.h:82 config/i386/mingw32.h:115 #: config/i386/cygwin.h:113 @@ -4985,7 +4985,7 @@ msgstr "ingen processortyp angiven för länkning" #: config/vax/vax.h:46 config/vax/vax.h:47 msgid "profiling not supported with -mg" -msgstr "profilering stöds inte med -mg" +msgstr "profilering stödjs inte med -mg" #: gcc.c:704 msgid "-fuse-linker-plugin is not supported in this configuration" @@ -5015,7 +5015,7 @@ msgstr "går inte att använda både -m32 och -m64" #: config/s390/tpf.h:109 msgid "static is not supported on TPF-OS" -msgstr "static stöds inte på TPF-OS" +msgstr "static stödjs inte på TPF-OS" #: config/rs6000/freebsd64.h:161 config/rs6000/freebsd64.h:173 msgid "consider using `-pg' instead of `-p' with gprof(1)" @@ -6470,9 +6470,8 @@ msgid "Deprecated in favor of -std=gnu++11" msgstr "Undanbedes till förmån för -std=gnu++11" #: c-family/c.opt:1382 -#, fuzzy msgid "Conform to the ISO 201y(7?) C++ draft standard with GNU extensions (experimental and incomplete support)" -msgstr "Följ standarden ISO 2011 C++ med GNU-utökningar (experimetellt och ofullständigt stöd)" +msgstr "Följ standardutkastet ISO 201y(7?) C++ med GNU-utökningar (experimetellt och ofullständigt stöd)" #: c-family/c.opt:1386 msgid "Conform to the ISO 2011 C standard with GNU extensions (experimental and incomplete support)" @@ -6587,9 +6586,9 @@ msgid "-mpointer-size=[no,32,short,64,long]\tSet the default pointer size" msgstr "-mpointer-size=[no,32,short,64,long]\tSätt standardstorlek på pekare" #: config/vms/vms.opt:42 -#, fuzzy, c-format +#, c-format msgid "unknown pointer size model %qs" -msgstr "okänd TLS-modell %qs" +msgstr "okänd pekarstorlekmodell %qs" #: config/mcore/mcore.opt:23 msgid "Generate code for the M*Core M210" @@ -7070,9 +7069,8 @@ msgid "Assume target CPU is configured as big endian" msgstr "Antag att mål-CPU:n är konfigurerad för rak byteordning" #: config/aarch64/aarch64.opt:68 -#, fuzzy msgid "Generate code which uses only the general registers" -msgstr "Generera kod som använder hårdvaruflyttalsinstruktioner" +msgstr "Generera kod som använder endast generella register" #: config/aarch64/aarch64.opt:72 config/arm/arm.opt:151 #: config/microblaze/microblaze.opt:64 @@ -7080,9 +7078,8 @@ msgid "Assume target CPU is configured as little endian" msgstr "Antag att mål-CPU:n är konfigurerad med omvänd byteordning" #: config/aarch64/aarch64.opt:76 -#, fuzzy msgid "Specify the code model" -msgstr "Välj kodmodell" +msgstr "Ange kodmodellen" #: config/aarch64/aarch64.opt:80 msgid "Don't assume that unaligned accesses are handled by the system" @@ -7097,14 +7094,12 @@ msgid "Specify TLS dialect" msgstr "Ange TLS-dialekt" #: config/aarch64/aarch64.opt:92 -#, fuzzy msgid "-march=ARCH\tUse features of architecture ARCH" -msgstr "-mcpu=CPU\tAnvänd funktioner i och schemalägg kod för angiven CPU" +msgstr "-march=ARK\tAnvänd funktioner i arkitekturen ARK" #: config/aarch64/aarch64.opt:96 -#, fuzzy msgid "-mcpu=CPU\tUse features of and optimize for CPU" -msgstr "-mcpu=CPU\tAnvänd funktioner i och schemalägg kod för angiven CPU" +msgstr "-mcpu=CPU\tAnvänd funktioner i och optimera för angiven CPU" #: config/aarch64/aarch64.opt:100 msgid "-mtune=CPU\tOptimize for CPU" @@ -7438,9 +7433,8 @@ msgid "Split unaligned 8 byte vector moves before post-modify address generation msgstr "Dela ojusterade 8-bytes vektorerförflyttningar före adressgenerering efter ändring." #: config/epiphany/epiphany.opt:132 -#, fuzzy msgid "Use the floating point unit for integer add/subtract." -msgstr "Använd flyttalskonverteringsinstruktioner i hårdvara" +msgstr "Använd flyttalsenheten för addition/subtraktion av heltal." #: config/epiphany/epiphany.opt:136 msgid "Set register to hold -1." @@ -7673,9 +7667,8 @@ msgid "sizeof(long double) is 12" msgstr "sizeof(long double) är 12" #: config/i386/i386.opt:90 -#, fuzzy msgid "Use 80-bit long double" -msgstr "Använd 128-bitars long double" +msgstr "Använd 80-bitars long double" #: config/i386/i386.opt:94 config/s390/s390.opt:105 #: config/sparc/long-double-switch.opt:27 config/alpha/alpha.opt:102 @@ -7732,14 +7725,12 @@ msgid "Known code models (for use with the -mcmodel= option):" msgstr "Kända kodmodeller (att användas med flaggan -mcmodel=):" #: config/i386/i386.opt:171 -#, fuzzy msgid "Use given address mode" -msgstr "Använd angiven x86-64 kodmodell" +msgstr "Använd angivet adressläge" #: config/i386/i386.opt:175 -#, fuzzy msgid "Known address mode (for use with the -maddress-mode= option):" -msgstr "Kända kodmodeller (att användas med flaggan -mcmodel=):" +msgstr "Kända adresslägen (att användas med flaggan -maddress-mode=):" #: config/i386/i386.opt:184 msgid "%<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead" @@ -7888,12 +7879,9 @@ msgstr "Generera cld-instruktioner i funktionsprologen" msgid "Generate vzeroupper instruction before a transfer of control flow out of" msgstr "Generera vzeroupper-instruktion före en övergång av kontrollflödet ut ur" -# Det avbrutna meddelandet är felrapporterat: -# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47103 #: config/i386/i386.opt:421 -#, fuzzy msgid "Do dispatch scheduling if processor is bdver1 or bdver2 or bdver3 and Haifa scheduling" -msgstr "Gör sändningsschemaläggning om processorn är bdver1 eller bdver2 och Haifa-schemaläggning" +msgstr "Gör sändningsschemaläggning om processorn är bdver1 eller bdver2 eller bdver3 och Haifa-schemaläggning" #: config/i386/i386.opt:426 msgid "Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer." @@ -8008,32 +7996,28 @@ msgid "Support Hardware Lock Elision prefixes" msgstr "Stöd prefix får hårdvarulåselidering" #: config/i386/i386.opt:544 -#, fuzzy msgid "Support RDSEED instruction" -msgstr "Använd SmartMIPS-instruktioner" +msgstr "Använd instruktionen RDSEED" #: config/i386/i386.opt:548 msgid "Support PREFETCHW instruction" msgstr "Stöd instruktionen PREFETCHW" #: config/i386/i386.opt:552 -#, fuzzy msgid "Support flag-preserving add-carry instructions" -msgstr "Stöd kodgenerering av crc32-instruktioner." +msgstr "Stöd flaggbevarande add-carry-instruktioner" #: config/i386/i386.opt:556 msgid "Support FXSAVE and FXRSTOR instructions" msgstr "Stöd instruktionerna FXSAVE och FXRSTOR" #: config/i386/i386.opt:560 -#, fuzzy msgid "Support XSAVE and XRSTOR instructions" -msgstr "Stöd anrop mellan Thumb- och ARM-instruktionsuppsättningar" +msgstr "Stöd instruktionerna XSAVE och XRSTOR" #: config/i386/i386.opt:564 -#, fuzzy msgid "Support XSAVEOPT instruction" -msgstr "Stöd inbyggda MMX-funktioner" +msgstr "Stöd instruktionen XSAVEOPT" #: config/i386/i386.opt:568 msgid "Support TBM built-in functions and code generation" @@ -8096,9 +8080,8 @@ msgid "Split 32-byte AVX unaligned store" msgstr "Dela 32-bytes AVX ojusterade lagringar" #: config/i386/i386.opt:628 -#, fuzzy msgid "Support RTM built-in functions and code generation" -msgstr "Stöd inbyggda TBM-funktioner och -kodgenerering " +msgstr "Stöd inbyggda RTM-funktioner och -kodgenerering " #: config/pa/pa64-hpux.opt:23 msgid "Assume code will be linked by GNU ld" @@ -8202,9 +8185,8 @@ msgid "Enable backend debugging" msgstr "Aktivera bakändefelsökning" #: config/v850/v850.opt:41 -#, fuzzy msgid "Do not use the callt instruction (default)" -msgstr "Använd inte callt-instruktionen" +msgstr "Använd inte callt-instruktionen (standard)" #: config/v850/v850.opt:45 msgid "Reuse r30 on a per function basis" @@ -8267,43 +8249,36 @@ msgid "Compile for the v850e2v3 processor" msgstr "Kompilera för processorn v850e2v3" #: config/v850/v850.opt:117 -#, fuzzy msgid "Compile for the v850e3v5 processor" -msgstr "Kompilera för processorn v850e" +msgstr "Kompilera för processorn v850e3v5" #: config/v850/v850.opt:124 -#, fuzzy msgid "Enable v850e3v5 loop instructions" -msgstr "Använd clip-instruktionener" +msgstr "Använd slinginstruktionerna i v850e3v5" #: config/v850/v850.opt:128 msgid "Set the max size of data eligible for the ZDA area" msgstr "Ange den maximala storleken på data som är lämpliga för ZDA-arean" #: config/v850/v850.opt:135 -#, fuzzy msgid "Enable relaxing in the assembler" -msgstr "Aktivera ordningsheuristiken i schemaläggaren" +msgstr "Aktivera avslappning i assemblern" #: config/v850/v850.opt:139 -#, fuzzy msgid "Prohibit PC relative jumps" -msgstr "Förhindra PC-relativa funktionsanrop" +msgstr "Förhindra PC-relativa hopp" #: config/v850/v850.opt:143 -#, fuzzy msgid "Inhibit the use of hardware floating point instructions" -msgstr "Förhindra användningen av alla flyttalsinstruktioner i hårdvara" +msgstr "Stäng av användningen av alla flyttalsinstruktioner i hårdvara" #: config/v850/v850.opt:147 -#, fuzzy msgid "Allow the use of hardware floating point instructions for V850E2V3 and up" -msgstr "Tillåt användningen av flyttalsinstruktioner och -ABI i hårdvara" +msgstr "Tillåt användningen av flyttalsinstruktioner för V850E2V3 och uppåt" #: config/v850/v850.opt:151 -#, fuzzy msgid "Enable support for the RH850 ABI. This is the default" -msgstr "Möjliggör användning av RX FPU-instruktionerna. Detta är standard." +msgstr "Aktivera stöd för ABI:et RH850. Detta är standard." #: config/v850/v850.opt:155 msgid "Enable support for the old GCC ABI" @@ -8764,9 +8739,8 @@ msgid "Use UltraSPARC Visual Instruction Set version 3.0 extensions" msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 3.0" #: config/sparc/sparc.opt:78 -#, fuzzy msgid "Use UltraSPARC Compare-and-Branch extensions" -msgstr "Utnyttja UltraSPARC-utökningen sammansmält multiplicera-addera" +msgstr "Utnyttja UltraSPARC-utökningen jämför-och-grena" #: config/sparc/sparc.opt:82 msgid "Use UltraSPARC Fused Multiply-Add extensions" @@ -9395,7 +9369,6 @@ msgid "Maximum size of global and static variables which can be placed into the msgstr "Maximal storlek på globala och statiska variabler som kan placeras i den lilla dataarean." #: config/rx/rx.opt:90 -#, fuzzy msgid "Generate assembler output that is compatible with the Renesas AS100 assembler. This may restrict some of the compiler's capabilities. The default is to generate GAS compatible syntax." msgstr "Genereara assemblerutdatat som är kompatibel med Renesas AS100-assembler. Detta kan begränsa några av kompilatorns egenskaper. Standard är att generera GAS-kopatibel sysntax." @@ -10130,9 +10103,8 @@ msgid "Deprecated. Use -matomic= instead to select the atomic model" msgstr "Undanbedes. Använd -matomic= istället för att välja den atomära modellen" #: config/sh/sh.opt:327 -#, fuzzy msgid "Specify the model for atomic operations" -msgstr "Generera kod för inbyggda atomiska operationer" +msgstr "Ange modellen för atomiska operationer" #: config/sh/sh.opt:331 msgid "Use tas.b instruction for __atomic_test_and_set" @@ -10155,14 +10127,12 @@ msgid "Pretend a branch-around-a-move is a conditional move." msgstr "Låtsas en gren-runt-en-förflyttning är en villkorlig förflyttning." #: config/sh/sh.opt:353 -#, fuzzy msgid "Enable the use of the fsca instruction" -msgstr "Möjliggör användning av de korta load-instruktionerna" +msgstr "Aktivera användningen av instruktionen fsca" #: config/sh/sh.opt:357 -#, fuzzy msgid "Enable the use of the fsrra instruction" -msgstr "Möjliggör användning av de korta load-instruktionerna" +msgstr "Aktivera användningen av instruktionen fsrra" #: config/fr30/fr30.opt:23 msgid "Assume small address space" @@ -10481,9 +10451,8 @@ msgid "Prevent the use of all floating-point operations" msgstr "Förhindra användningen av alla flyttalsoperationer" #: config/mips/mips.opt:274 -#, fuzzy msgid "Use MCU instructions" -msgstr "Använd MIPS-3D-instruktioner" +msgstr "Använd MCU-instruktioner" #: config/mips/mips.opt:278 msgid "Do not use a cache-flushing function before calling stack trampolines" @@ -10578,9 +10547,8 @@ msgid "Compile with 64 bit longs and pointers." msgstr "Kompilera för 64-bitars långa och pekare." #: config/tilegx/tilegx.opt:45 -#, fuzzy msgid "Use given TILE-Gx code model" -msgstr "Använd angiven x86-64 kodmodell" +msgstr "Använd angiven TILE-Gx kodmodell" #: java/lang.opt:122 msgid "Warn if deprecated empty statements are found" @@ -10735,9 +10703,8 @@ msgid "Optimize for speed disregarding exact standards compliance" msgstr "Optimera för hastighet och bortse från exakt efterlevnad av standarder" #: common.opt:453 -#, fuzzy msgid "Optimize for debugging experience rather than speed or size" -msgstr "Optimera för storlek istället för hastighet" +msgstr "Optimera för bekväm felsökning snarare än storlek eller hastighet" #: common.opt:493 msgid "This switch is deprecated; use -Wextra instead" @@ -11246,9 +11213,8 @@ msgid "Enable Graphite Identity transformation" msgstr "Aktivera Graphite-identitetstransformation" #: common.opt:1202 -#, fuzzy msgid "Enable hoisting adjacent loads to encourage generating conditional move" -msgstr "Aktivera lyftningslast från villkorliga pekare." +msgstr "Aktivera närliggande lyftningslast för att uppmuntra generering av villkorliga förflyttningar." #: common.opt:1207 msgid "Mark all loops as parallel" @@ -11299,9 +11265,9 @@ msgid "-fstack-reuse=[all|named_vars|none] Set stack reuse level for local varia msgstr "-fstack-reuse=[all|named_vars|none] Ställ in stackåteranvändningsnivån för lokala variabler." #: common.opt:1262 -#, fuzzy, c-format +#, c-format msgid "unknown Stack Reuse Level %qs" -msgstr "okänd TLS-modell %qs" +msgstr "okänd stackåteranvändningsmodell %qs" #: common.opt:1275 msgid "Convert conditional jumps in innermost loops to branchless equivalents" @@ -11442,9 +11408,8 @@ msgid "Link-time optimization with number of parallel jobs or jobserver." msgstr "Optimeringar vid länktillfället med flera parallella jobb eller jobbserver." #: common.opt:1451 -#, fuzzy msgid "Partition symbols and vars at linktime based on object files they originate from" -msgstr "Partitionera funktioner och variabler vid länktillfället baserat på vilka objektfiler de härrör från" +msgstr "Partitionera symboler och variabler vid länktillfället baserat på vilka objektfiler de härrör från" #: common.opt:1455 msgid "Partition functions and vars at linktime into approximately same sized buckets" @@ -11479,9 +11444,8 @@ msgid "Report on permanent memory allocation" msgstr "Rapportera om permanent minnesallokering" #: common.opt:1488 -#, fuzzy msgid "Report on permanent memory allocation in WPA only" -msgstr "Rapportera om permanent minnesallokering" +msgstr "Rapportera bara om permanent minnesallokering i WPA" #: common.opt:1495 msgid "Attempt to merge identical constants and constant variables" @@ -11532,9 +11496,8 @@ msgid "When possible do not generate stack frames" msgstr "Låt bli att generera stackramar när det är möjligt" #: common.opt:1543 -#, fuzzy msgid "Enable all optimization info dumps on stderr" -msgstr "Aktivera slingoptimeringar på trädnivå" +msgstr "Aktivera alla optimeringsinformationsdumpar på standard fel" #: common.opt:1547 msgid "-fopt-info[-<type>=filename]\tDump compiler optimization details" @@ -11649,9 +11612,8 @@ msgid "Insert code to profile values of expressions" msgstr "Lägg in kod för att profilera värden av uttryck" #: common.opt:1664 -#, fuzzy msgid "Report on consistency of profile" -msgstr "internt konsistensfel" +msgstr "Rapportera om intern konsistens hos prifilen" #: common.opt:1671 msgid "-frandom-seed=<string>\tMake compile reproducible using <string>" @@ -11927,9 +11889,8 @@ msgid "Enable loop header copying on trees" msgstr "Aktivera slinghuvdkopiering av träd" #: common.opt:2004 -#, fuzzy msgid "Enable coalescing of copy-related user variables that are inlined" -msgstr "Utför variabelspårning och tagga också variabler som är oinitierade" +msgstr "Aktivera sammanläggning av kopieringsrelaterade användarvariabler som är inline:ade" #: common.opt:2008 msgid "Enable coalescing of all copy-related user variables" @@ -12090,14 +12051,12 @@ msgid "Just generate unwind tables for exception handling" msgstr "Generera bara upprullningstabeller för undantagshantering" #: common.opt:2180 -#, fuzzy msgid "Use the bfd linker instead of the default linker" -msgstr "Använd tunnskiftaren i hårdvara istället för emulering" +msgstr "Använd bfd-länkaren istället för standardlänkaren" #: common.opt:2184 -#, fuzzy msgid "Use the gold linker instead of the default linker" -msgstr "Använd tunnskiftaren i hårdvara istället för emulering" +msgstr "Använd gold-länkaren istället för standardlänkaren" #: common.opt:2196 msgid "Perform variable tracking" @@ -12120,9 +12079,8 @@ msgid "Enable loop vectorization on trees" msgstr "Aktivera slingvektorisering i träd" #: common.opt:2226 -#, fuzzy msgid "-ftree-vectorizer-verbose=<number>\tThis switch is deprecated. Use -fopt-info instead." -msgstr "-ftree-vectorizer-verbose=<tal>\tAnge hur mångordig vektoriseraren skall vara" +msgstr "-ftree-vectorizer-verbose=<tal>\tDenna flagga bör undvikas. Använd -fopt-info istället." #: common.opt:2230 msgid "Enable basic block vectorization (SLP) on trees" @@ -12210,14 +12168,12 @@ msgid "Record gcc command line switches in DWARF DW_AT_producer." msgstr "Notera gcc:s kommandoradsflaggor i DWARF DW_AT_producer." #: common.opt:2331 -#, fuzzy msgid "Don't generate debug information in separate .dwo files" -msgstr "Generera felsökningsinformation i standardformat" +msgstr "Generera inte felsökningsinformation i separata .dwo-filer" #: common.opt:2335 -#, fuzzy msgid "Generate debug information in separate .dwo files" -msgstr "Generera felsökningsinformation i standardformat" +msgstr "Generera felsökningsinformation i separata .dwo-filer" #: common.opt:2339 msgid "Generate debug information in STABS format" @@ -12256,9 +12212,8 @@ msgid "-iplugindir=<dir>\tSet <dir> to be the default plugin directory" msgstr "-iplugindir=<kat>\tSätt <kat> att vara standardbibliotek för insticksmoduler" #: common.opt:2378 -#, fuzzy msgid "-imultiarch <dir>\tSet <dir> to be the multiarch include subdirectory" -msgstr "-imultilib <kat>\tSätt <kat> att vara inkluderingsunderbiblioteket för multibibliotek" +msgstr "-imultiarch <kat>\tSätt <kat> att vara inkluderingsunderbiblioteket för multiarkitekturer" #: common.opt:2400 msgid "-o <file>\tPlace output into <file>" @@ -12332,9 +12287,8 @@ msgid "expected pointer" msgstr "pekare förväntades" #: go/gofrontend/expressions.cc:5610 -#, fuzzy msgid "invalid comparison of nil with nil" -msgstr "ogiltig jämförelsekod i gimple-villkor" +msgstr "ogiltig jämförelsekod av nil med nil" #: go/gofrontend/expressions.cc:5616 go/gofrontend/expressions.cc:5634 msgid "incompatible types in binary expression" @@ -12526,7 +12480,6 @@ msgid "invalid receive on send-only channel" msgstr "ogiltig receive på kanal endast för sändning" #: go/gofrontend/parse.cc:2982 -#, fuzzy msgid "parentheses required around this composite literal to avoid parsing ambiguity" msgstr "parenteser krävs runt denna sammansatta literal för att undvika tvetydigheter i tolkningen" @@ -12612,7 +12565,6 @@ msgid "invalid comparison of non-comparable array" msgstr "ogiltig jämförelse av ojämförbar vektor" #: go/gofrontend/types.cc:627 -#, fuzzy msgid "multiple-value function call in single-value context" msgstr "flervärt funktionsanrop i sammanhang för enstaka värde" @@ -12690,14 +12642,14 @@ msgid "missing method %s%s%s" msgstr "metoden saknas %s%s%s" #: go/gofrontend/types.cc:6966 -#, fuzzy, c-format +#, c-format msgid "method %s%s%s requires a pointer receiver" -msgstr "metoden %s%s%s kräver en pekare" +msgstr "metoden %s%s%s kräver en pekarmottagare" #: go/gofrontend/types.cc:6984 -#, fuzzy, c-format +#, c-format msgid "method %s%s%s is marked go:nointerface" -msgstr "metoden %s%s%s kräver en pekare" +msgstr "metoden %s%s%s är märkt go:nointerface" #. Warn about and ignore all others for now, but store them. #: attribs.c:426 c-family/c-common.c:8019 objc/objc-act.c:4952 @@ -12707,9 +12659,9 @@ msgid "%qE attribute directive ignored" msgstr "attributdirektivet %qE ignorerat" #: attribs.c:430 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%E::%E%> scoped attribute directive ignored" -msgstr "attributdirektivet %qE ignorerat" +msgstr "attributdirektivet %<%E::%E%> med räckvidd ignorerat" #: attribs.c:439 #, gcc-internal-format @@ -12720,9 +12672,9 @@ msgstr "fel antal argument angivet för attributet %qE" #. type-specifier, outside of the definition of, a class #. type. Ignore it. #: attribs.c:452 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "attribute ignored" -msgstr "attributet %qE ignorerat" +msgstr "attributet ignorerat" #: attribs.c:454 #, gcc-internal-format @@ -12747,7 +12699,7 @@ msgstr "typattribut ignoreras efter att typen redan är definierad" #: bb-reorder.c:2095 #, gcc-internal-format, gfc-internal-format msgid "multiple hot/cold transitions found (bb %i)" -msgstr "flera varmt/kallt-övergångar funna (bb %i)" +msgstr "flera varmt/kallt-övergångar funna (gb %i)" #: bt-load.c:1547 #, gcc-internal-format @@ -12887,14 +12839,14 @@ msgid "non-integer argument 1 to __atomic_is_lock_free" msgstr "argument 1 till __atomic_is_lock_free är inte heltal" #: builtins.c:5764 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "__builtin_thread_pointer is not supported on this target" -msgstr "__builtin_eh_return stöds inte på denna målarkitektur" +msgstr "__builtin_thread_pointer stödjs inte på denna målarkitektur" #: builtins.c:5784 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "__builtin_set_thread_pointer is not supported on this target" -msgstr "__builtin_eh_return stöds inte på denna målarkitektur" +msgstr "__builtin_eh_thread_pointer stödjs inte på denna målarkitektur" #. All valid uses of __builtin_va_arg_pack () are removed during #. inlining. @@ -13003,7 +12955,7 @@ msgstr "stackskyddet skyddar inte funktioner: alla lokala vektorer är mindre ä #: cfghooks.c:110 #, gcc-internal-format, gfc-internal-format msgid "bb %d on wrong place" -msgstr "bb %d på fel plats" +msgstr "gb %d på fel plats" #: cfghooks.c:116 #, gcc-internal-format, gfc-internal-format @@ -13076,9 +13028,9 @@ msgid "verify_flow_info failed" msgstr "verify_flow_info misslyckades" #: cfghooks.c:293 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "%s does not support dump_bb_for_graph" -msgstr "%s stödjer inte duplicate_block" +msgstr "%s stödjer inte dump_bb_for_graph" #: cfghooks.c:330 #, gcc-internal-format, gfc-internal-format @@ -13181,24 +13133,24 @@ msgid "size of loop %d should be %d, not %d" msgstr "storlek på slinga %d borde vara %d, inte %d" #: cfgloop.c:1363 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "loop with header %d not in loop tree" -msgstr "Aktivera slinghuvdkopiering av träd" +msgstr "slinga med huvud %d är inte i slingträd" #: cfgloop.c:1380 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "bb %d does not belong to loop %d" -msgstr "bb %d tillhör inte slinga %d" +msgstr "gb %d tillhör inte slinga %d" #: cfgloop.c:1392 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "bb %d has father loop %d, should be loop %d" -msgstr "storlek på slinga %d borde vara %d, inte %d" +msgstr "gb %d har faderslinga %d, borde vara slinga %d" #: cfgloop.c:1409 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "loop %d%'s header is not a loop header" -msgstr "slinga %d:s huvud har inte exakt 2 poster" +msgstr "slinga %d:s huvud är inte ett slinghuvud" #: cfgloop.c:1415 #, gcc-internal-format @@ -13206,14 +13158,14 @@ msgid "loop %d%'s header does not have exactly 2 entries" msgstr "slinga %d:s huvud har inte exakt 2 poster" #: cfgloop.c:1422 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "loop %d%'s latch does not have an edge to its header" -msgstr "slinga %d:s koppling har inte huvud som efterföljare" +msgstr "slinga %d:s koppling har inte en båge som huvud" #: cfgloop.c:1427 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "loop %d%'s latch is not dominated by its header" -msgstr "slinga %d:s koppling har inte huvud som efterföljare" +msgstr "slinga %d:s koppling domineras inte av dess huvud" #: cfgloop.c:1435 #, gcc-internal-format @@ -13308,12 +13260,12 @@ msgstr "instruktion %d grundblockspekare är %d, skall vara %d" #: cfgrtl.c:2110 #, gcc-internal-format, gfc-internal-format msgid "insn %d in header of bb %d has non-NULL basic block" -msgstr "instruktion %d i huvud till bb %d har icke-NULL grundblock" +msgstr "instruktion %d i huvud till gb %d har icke-NULL grundblock" #: cfgrtl.c:2118 #, gcc-internal-format, gfc-internal-format msgid "insn %d in footer of bb %d has non-NULL basic block" -msgstr "instruktion %d i foten till bb %d har icke-NULL grundblock" +msgstr "instruktion %d i foten till gb %d har icke-NULL grundblock" #: cfgrtl.c:2141 #, gcc-internal-format @@ -13326,14 +13278,14 @@ msgid "EDGE_CROSSING incorrectly set across same section" msgstr "EDGE_CROSSING felaktigt satt över samma sektion" #: cfgrtl.c:2165 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "fallthru edge crosses section boundary in bb %i" -msgstr "fall-igenom-båge korsar sektionsgräns (bb %i)" +msgstr "fall-igenom-båge korsar sektionsgräns i gb %i" #: cfgrtl.c:2171 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "EH edge crosses section boundary in bb %i" -msgstr "EH-båge korsar sektionsgräns (gb %i)" +msgstr "EH-båge korsar sektionsgräns gb %i" #: cfgrtl.c:2178 #, gcc-internal-format @@ -13341,49 +13293,49 @@ msgid "EDGE_CROSSING missing across section boundary" msgstr "EDGE_CROSSING saknas över sektionsgräns" #: cfgrtl.c:2205 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "missing REG_EH_REGION note at the end of bb %i" -msgstr "REG_EH_REGION-notering saknas i slutet av bb %i" +msgstr "REG_EH_REGION-notering saknas i slutet av gb %i" #: cfgrtl.c:2210 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "too many exception handling edges in bb %i" -msgstr "för många utgående bågar från bb %i" +msgstr "för många undantagshanteringsbågar från gb %i" #: cfgrtl.c:2218 #, gcc-internal-format, gfc-internal-format msgid "too many outgoing branch edges from bb %i" -msgstr "för många utgående bågar från bb %i" +msgstr "för många utgående bågar från gb %i" #: cfgrtl.c:2223 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "fallthru edge after unconditional jump in bb %i" -msgstr "fall igenom-båge efter ovillkorligt hopp %i" +msgstr "fall igenom-båge efter ovillkorligt hopp i gb %i" #: cfgrtl.c:2228 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "wrong number of branch edges after unconditional jump in bb %i" -msgstr "fel antal förgreningsbågar efter ovillkorligt hopp %i" +msgstr "fel antal förgreningsbågar efter ovillkorligt hopp i gb %i" #: cfgrtl.c:2235 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "wrong amount of branch edges after conditional jump in bb %i" -msgstr "fel antal förgreningsbågar efter villkorligt hopp %i" +msgstr "fel antal förgreningsbågar efter villkorligt hopp i gb %i" #: cfgrtl.c:2241 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "abnormal call edges for non-call insn in bb %i" -msgstr "anropsbågar för instruktion som inte är anrop i bb %i" +msgstr "onormala anropsbågar för instruktion som inte är anrop i gb %i" #: cfgrtl.c:2246 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "sibcall edges for non-call insn in bb %i" -msgstr "anropsbågar för instruktion som inte är anrop i bb %i" +msgstr "syskonanropsbågar för instruktion som inte är anrop i gb %i" #: cfgrtl.c:2256 #, gcc-internal-format, gfc-internal-format msgid "abnormal edges for no purpose in bb %i" -msgstr "onormala bågar utan syfte i bb %i" +msgstr "onormala bågar utan syfte i gb %i" #: cfgrtl.c:2268 #, gcc-internal-format, gfc-internal-format @@ -13413,7 +13365,7 @@ msgstr "i grundblock %d:" #: cfgrtl.c:2371 cfgrtl.c:2461 #, gcc-internal-format, gfc-internal-format msgid "insn %d outside of basic blocks has non-NULL bb field" -msgstr "instruktion %d utanför grundblock har ett icke-NULL bb-fält" +msgstr "instruktion %d utanför grundblock har ett icke-NULL gb-fält" #: cfgrtl.c:2379 #, gcc-internal-format, gfc-internal-format @@ -13453,7 +13405,7 @@ msgstr "grundblock inte utlagda i ordning" #: cfgrtl.c:2516 #, gcc-internal-format, gfc-internal-format msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)" -msgstr "antal bb-noter i instruktionskedjan (%d) != n_basic_blocks (%d)" +msgstr "antal gb-noter i instruktionskedjan (%d) != n_basic_blocks (%d)" #: cgraph.c:2211 #, gcc-internal-format @@ -13486,9 +13438,9 @@ msgid "execution count is negative" msgstr "exekveringsräknare är negativ" #: cgraph.c:2328 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "inline clone in same comdat group list" -msgstr "noden är ensam i en comdat-grupp" +msgstr "inline-klon i samma comdat-grupplista" #: cgraph.c:2333 #, gcc-internal-format @@ -13501,9 +13453,9 @@ msgid "inline clone with address taken" msgstr "inline-klon som man tar adressen till" #: cgraph.c:2343 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "inline clone is forced to output" -msgstr "inline-klon behövs" +msgstr "inline-klon tvingas till utdata" #: cgraph.c:2350 #, gcc-internal-format, gfc-internal-format @@ -13681,9 +13633,9 @@ msgid "%q+D alias in between function and variable is not supported" msgstr "aliaset %q+D mellan funktion och variabel stödjs inte" #: cgraphunit.c:1127 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%q+D aliased declaration" -msgstr "%q+D använd före deklarationen" +msgstr "%q+D aliasad deklaration" #: cgraphunit.c:1199 #, gcc-internal-format @@ -14013,12 +13965,12 @@ msgstr "gemensam symbolfelsökningsinformation är inte strukturerad som symbol+ #: dbxout.c:3832 #, gcc-internal-format msgid "global destructors not supported on this target" -msgstr "globala destruerare stöds inte på denna målarkitektur" +msgstr "globala destruerare stödjs inte på denna målarkitektur" #: dbxout.c:3849 #, gcc-internal-format msgid "global constructors not supported on this target" -msgstr "globala konstruerare stöds inte för denna målarkitektur" +msgstr "globala konstruerare stödjs inte för denna målarkitektur" #: diagnostic.c:1145 #, gcc-internal-format, gfc-internal-format @@ -14046,9 +13998,9 @@ msgid "ignoring unknown option %q.*s in %<-fdump-%s%>" msgstr "ignorerar okänt alternativ %q.*s i %<-fdump-%s%>" #: dumpfile.c:831 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unknown option %q.*s in %<-fopt-info-%s%>" -msgstr "ignorerar okänt alternativ %q.*s i %<-fdump-%s%>" +msgstr "okänt alternativ %q.*s i %<-fopt-info-%s%>" #: dumpfile.c:862 #, gcc-internal-format @@ -14058,7 +14010,7 @@ msgstr "ignorerar flaggan %<-fopt-info-%s%> som möjligen står i konflikt" #: dwarf2out.c:1034 #, gcc-internal-format msgid "multiple EH personalities are supported only with assemblers supporting .cfi_personality directive" -msgstr "multipla EH-personligheter stöds endast med assemblerare som stödjer direktivet .cfi.personality." +msgstr "multipla EH-personligheter stödjs endast med assemblerare som stödjer direktivet .cfi.personality." #: dwarf2out.c:10986 #, gcc-internal-format, gfc-internal-format @@ -14098,7 +14050,7 @@ msgstr "argumentet till %<__builtin_eh_return_regno%> måste vara konstant" #: except.c:2163 #, gcc-internal-format msgid "__builtin_eh_return not supported on this target" -msgstr "__builtin_eh_return stöds inte på denna målarkitektur" +msgstr "__builtin_eh_return stödjs inte på denna målarkitektur" #: except.c:3222 except.c:3247 #, gcc-internal-format, gfc-internal-format @@ -14148,7 +14100,7 @@ msgstr "verify_eh_tree misslyckades" #: explow.c:1445 #, gcc-internal-format msgid "stack limits not supported on this target" -msgstr "stackgränser stöds inte på denna målarkitektur" +msgstr "stackgränser stödjs inte på denna målarkitektur" #: expmed.c:1729 #, gcc-internal-format @@ -14338,7 +14290,7 @@ msgstr "systemsökväg %qs är inte absolut" #: gcc.c:2626 #, gcc-internal-format msgid "-pipe not supported" -msgstr "-pipe stöds inte" +msgstr "-pipe stödjs inte" #: gcc.c:2788 #, gcc-internal-format @@ -14510,9 +14462,9 @@ msgid "spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC" msgstr "spec-fel: mer än ett argument till SYSROOT_HEADERS_SUFFIX_SPEC" #: gcc.c:6643 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unrecognized command line option %<-%s%>" -msgstr "okänd kommandoradsflagga %<-fdump-%s%>" +msgstr "okänd kommandoradsflagga %<-%s%>" #. The error status indicates that only one set of fixed #. headers should be built. @@ -14577,9 +14529,9 @@ msgid "multilib exclusions %qs is invalid" msgstr "multilib-undantag %qs är ogiltiga" #: gcc.c:7602 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "multilib select %qs %qs is invalid" -msgstr "multilib-val %qs är ogiltigt" +msgstr "multilib-val %qs %qs är ogiltigt" #: gcc.c:7758 #, gcc-internal-format @@ -14642,9 +14594,9 @@ msgid "argument to %%:compare-debug-auxbase-opt does not end in .gk" msgstr "argumentet till %%:compare-debug-auxbase-opt slutar inte i .gk" #: gcc.c:8524 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "too few arguments to %%:replace-extension" -msgstr "för få argument till funktion" +msgstr "för få argument till %%:replace-extension" #: ggc-common.c:456 ggc-common.c:464 ggc-common.c:538 ggc-common.c:557 #: ggc-page.c:2311 ggc-page.c:2342 ggc-page.c:2349 @@ -14841,9 +14793,9 @@ msgid "inconsistent operand constraints in an %<asm%>" msgstr "inkonsistenta operandbegränsningar i en %<asm%>" #: lra-constraints.c:3438 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Maximum number of LRA constraint passes is achieved (%d)\n" -msgstr "Maximalt antal villkorliga lagringspar som kan sänkas" +msgstr "Maximalt antal LRA-begränsningspass uppnått (%d)\n" #: lra-constraints.c:3537 #, gcc-internal-format, gfc-internal-format @@ -14914,7 +14866,7 @@ msgstr "bytekodström: oväntad tagg %s" #: lto-streamer-out.c:307 #, gcc-internal-format msgid "tree code %qs is not supported in LTO streams" -msgstr "trädkod %qs stöds inte i LTO-strömmar" +msgstr "trädkod %qs stödjs inte i LTO-strömmar" #: lto-streamer.c:163 #, gcc-internal-format, gfc-internal-format @@ -15015,7 +14967,7 @@ msgstr "ogiltig gren till/från OpenMP-strukturerat block" #: opts-common.c:997 #, gcc-internal-format msgid "command line option %qs is not supported by this configuration" -msgstr "kommandoradsflaggan %qs stöds inte av denna konfiguration" +msgstr "kommandoradsflaggan %qs stödjs inte av denna konfiguration" #: opts-common.c:1007 #, gcc-internal-format @@ -15059,9 +15011,9 @@ msgid "unrecognized command line option %<-fdump-%s%>" msgstr "okänd kommandoradsflagga %<-fdump-%s%>" #: opts-global.c:394 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unrecognized command line option %<-fopt-info-%s%>" -msgstr "okänd kommandoradsflagga %<-fdump-%s%>" +msgstr "okänd kommandoradsflagga %<-fopt-info-%s%>" #: opts-global.c:415 opts-global.c:423 #, gcc-internal-format @@ -15089,9 +15041,9 @@ msgid "%<-femit-struct-debug-detailed=dir:...%> must allow at least as much as % msgstr "%<-femit-struct-debug-detailed=kat:...%> måste tillåta åtminstone så mycket som %<-femit-struct-debug-detailed=ind:...%>" #: opts.c:542 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "argument to %<-O%> should be a non-negative integer, %<g%>, %<s%> or %<fast%>" -msgstr "argumentet till %qs skall vara ett ickenegativt heltal" +msgstr "argumentet till %<-O%> skall vara ett ickenegativt heltal, %<g%>, %<s%> eller %<fast%>" #: opts.c:669 #, gcc-internal-format @@ -15171,7 +15123,7 @@ msgstr "okänd stackkontrollparameter ”%s”" #: opts.c:1701 #, gcc-internal-format, gfc-internal-format msgid "dwarf version %d is not supported" -msgstr "dwarf-version %d stöds inte" +msgstr "dwarf-version %d stödjs inte" #: opts.c:1791 #, gcc-internal-format, gfc-internal-format @@ -15785,24 +15737,24 @@ msgid "%D renamed after being referenced in assembly" msgstr "%D byter namn efter att ha refererats i assembler" #: symtab.c:586 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "function symbol is not function" -msgstr "funktion som returnerar en funktion" +msgstr "funktionssymbol som inte är en funktion" #: symtab.c:594 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "variable symbol is not variable" -msgstr "attributet %qE är bara tillämpligt på variabler" +msgstr "variabelsymbol är inte en variabel" #: symtab.c:600 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "node has unknown type" -msgstr "noden har fel klonlista" +msgstr "noden har okänd typ" #: symtab.c:607 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "node not found in symtab decl hashtable" -msgstr "nod finns inte i cgraph-hash" +msgstr "nod finns inte i hash-tabellen för symboltabelldeklarationer" #: symtab.c:615 #, gcc-internal-format @@ -15810,14 +15762,14 @@ msgid "assembler name hash list corrupted" msgstr "hashlistan över assemblernamn trasig" #: symtab.c:628 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "node not found in symtab assembler name hash" -msgstr "nod finns inte i cgraph-hash" +msgstr "nod finns inte i hashen av symboltabellassemblernamn" #: symtab.c:635 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "double linked list of assembler names corrupted" -msgstr "dubbellänkad lista av kloner trasig" +msgstr "dubbellänkad lista av assemblernamn är trasig" #: symtab.c:643 #, gcc-internal-format @@ -15840,34 +15792,34 @@ msgid "same_comdat_group is not a circular list" msgstr "same_comdat_group är inte en cirkulär lista" #: symtab.c:686 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "verify_symtab_node failed" -msgstr "verify_cgraph_node misslyckades" +msgstr "verify_symtab_node misslyckades" #: targhooks.c:165 #, gcc-internal-format msgid "__builtin_saveregs not supported by this target" -msgstr "__builtin_saveregs stöds inte på denna målarkitektur" +msgstr "__builtin_saveregs stödjs inte på denna målarkitektur" #: targhooks.c:810 #, gcc-internal-format msgid "nested functions not supported on this target" -msgstr "nästade funktioner stöds inte på denna målarkitektur" +msgstr "nästade funktioner stödjs inte på denna målarkitektur" #: targhooks.c:823 #, gcc-internal-format msgid "nested function trampolines not supported on this target" -msgstr "nästade funktionstrampoliner stöds inte för denna målarkitektur" +msgstr "nästade funktionstrampoliner stödjs inte för denna målarkitektur" #: targhooks.c:1233 #, gcc-internal-format msgid "target attribute is not supported on this machine" -msgstr "målattribut stöds inte på denna maskin" +msgstr "målattribut stödjs inte på denna maskin" #: targhooks.c:1243 #, gcc-internal-format msgid "#pragma GCC target is not supported for this machine" -msgstr "#pragma GCC target stöds inte för denna maskin" +msgstr "#pragma GCC target stödjs inte för denna maskin" #: tlink.c:489 #, gcc-internal-format @@ -15912,7 +15864,7 @@ msgstr "%q+D är definierad men inte använd" #: toplev.c:938 #, gcc-internal-format msgid "-frecord-gcc-switches is not supported by the current target" -msgstr "-frecord-gcc-switches stöds inte för den aktuella målarkitekturen" +msgstr "-frecord-gcc-switches stödjs inte för den aktuella målarkitekturen" #: toplev.c:986 #, gcc-internal-format @@ -15940,9 +15892,9 @@ msgid "this target does not support %qs" msgstr "denna målarkitektur stödjer inte %s" #: toplev.c:1255 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "Graphite loop optimizations cannot be used (-fgraphite, -fgraphite-identity, -floop-block, -floop-interchange, -floop-strip-mine, -floop-parallelize-all, and -ftree-loop-linear)" -msgstr "Graphite-slingoptimeringar kan inte användas (-fgraphite, -fgraphite-identity, -floop-block, -floop-flatten, -floop-interchange, -floop-strip-mine, -floop-parallelize-all och -ftree-loop-linear)" +msgstr "Graphite-slingoptimeringar kan inte användas (-fgraphite, -fgraphite-identity, -floop-block, -floop-interchange, -floop-strip-mine, -floop-parallelize-all och -ftree-loop-linear)" #: toplev.c:1262 #, gcc-internal-format @@ -15957,7 +15909,7 @@ msgstr "-fstrict-volatile-bitfields avaktiverat; det är inkomatibelt med ABI-ve #: toplev.c:1299 #, gcc-internal-format msgid "instruction scheduling not supported on this target machine" -msgstr "instruktionsschemaläggning stöds inte för denna målmaskin" +msgstr "instruktionsschemaläggning stödjs inte för denna målmaskin" #: toplev.c:1303 #, gcc-internal-format @@ -15967,7 +15919,7 @@ msgstr "denna målmaskin har inte fördröjda grenar" #: toplev.c:1317 #, gcc-internal-format, gfc-internal-format msgid "-f%sleading-underscore not supported on this target machine" -msgstr "-f%sleading-underscore stöds inte på denna målmaskin" +msgstr "-f%sleading-underscore stödjs inte på denna målmaskin" #: toplev.c:1360 #, gcc-internal-format @@ -15987,7 +15939,7 @@ msgstr "variabelspårning begärd, men oanvändbar om den inte felsökningsinfor #: toplev.c:1409 #, gcc-internal-format msgid "variable tracking requested, but not supported by this debug format" -msgstr "variabel spårning begärd, men stöds inte av detta felsökningsformat" +msgstr "variabel spårning begärd, men stödjs inte av detta felsökningsformat" #: toplev.c:1446 #, gcc-internal-format @@ -15997,27 +15949,27 @@ msgstr "var-tracking-assignments ändrar selektiv schemaläggning" #: toplev.c:1469 #, gcc-internal-format msgid "-ffunction-sections not supported for this target" -msgstr "-ffunction-sections stöds inte för denna målarkitektur" +msgstr "-ffunction-sections stödjs inte för denna målarkitektur" #: toplev.c:1474 #, gcc-internal-format msgid "-fdata-sections not supported for this target" -msgstr "-fdata-sections stöds inte för denna målarkitektur" +msgstr "-fdata-sections stödjs inte för denna målarkitektur" #: toplev.c:1482 #, gcc-internal-format msgid "-fprefetch-loop-arrays not supported for this target" -msgstr "-fprefetch-loop-arrays stöds inte för denna målarkitektur" +msgstr "-fprefetch-loop-arrays stödjs inte för denna målarkitektur" #: toplev.c:1488 #, gcc-internal-format msgid "-fprefetch-loop-arrays not supported for this target (try -march switches)" -msgstr "-fprefetch-loop-arrays stöds inte för denna målarkitektur (försök med -march-flaggor)" +msgstr "-fprefetch-loop-arrays stödjs inte för denna målarkitektur (försök med -march-flaggor)" #: toplev.c:1497 #, gcc-internal-format msgid "-fprefetch-loop-arrays is not supported with -Os" -msgstr "-fprefetch-loop-arrays stöds inte med -Os" +msgstr "-fprefetch-loop-arrays stödjs inte med -Os" #: toplev.c:1508 #, gcc-internal-format @@ -16027,7 +15979,7 @@ msgstr "-fassociative-math avslagen, andra flaggor går före" #: toplev.c:1524 #, gcc-internal-format msgid "-fstack-protector not supported for this target" -msgstr "-fstack-protector stöds inte av denna målarkitektur" +msgstr "-fstack-protector stödjs inte av denna målarkitektur" #: toplev.c:1537 #, gcc-internal-format @@ -16035,9 +15987,9 @@ msgid "unwind tables currently require a frame pointer for correctness" msgstr "at rulla ut tabeller kräver för närvarande en rampekare för att bli rätt" #: toplev.c:1547 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-fsanitize=address not supported for this target" -msgstr "-fdata-sections stöds inte för denna målarkitektur" +msgstr "-fsanitize=address stödjs inte för denna målarkitektur" #: toplev.c:1808 #, gcc-internal-format @@ -16365,9 +16317,9 @@ msgid "mismatching comparison operand types" msgstr "typen på operander i jämförelse stämmer inte överens" #: tree-cfg.c:3172 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "vector comparison returning a boolean" -msgstr "ogiltig resultattyp i vektorjämförelse" +msgstr "vektorjämförelse returnerar en boolean" #: tree-cfg.c:3186 #, gcc-internal-format @@ -16585,39 +16537,39 @@ msgid "invalid operand to switch statement" msgstr "ogiltig operand till switch-sats" #: tree-cfg.c:4101 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "non-integral type switch statement" -msgstr "ogiltig operand till switch-sats" +msgstr "annat än heltalstyp i en switch-sats" #: tree-cfg.c:4109 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid default case label in switch statement" -msgstr "%<default%>-etikett som inte ligger i en switch-sats" +msgstr "ogiltig standardfallsetikett i en switch-sats" #: tree-cfg.c:4121 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid case label in switch statement" -msgstr "case-etikett är inte i en switch-sats" +msgstr "ogiltig case-etikett i en switch-sats" #: tree-cfg.c:4128 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid case range in switch statement" -msgstr "ogiltig operand till switch-sats" +msgstr "ogiltigt case-intervall i en switch-sats" #: tree-cfg.c:4138 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type mismatch for case label in switch statement" -msgstr "case-etikett är inte i en switch-sats" +msgstr "typer stämmer inte för case-etikett i en switch-sats" #: tree-cfg.c:4148 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type precision mismatch in switch statement" -msgstr "case-etikett är inte i en switch-sats" +msgstr "typprecision stämmer inte i en switch-sats" #: tree-cfg.c:4157 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "case labels not sorted in switch statement" -msgstr "case-etikett är inte i en switch-sats" +msgstr "case-etiketter är inte sorterade i en switch-sats" #: tree-cfg.c:4202 #, gcc-internal-format @@ -16680,9 +16632,9 @@ msgid "gimple_bb (phi) is set to a wrong basic block" msgstr "gimple_bb (phi) är satt till ett felaktigt grundblock" #: tree-cfg.c:4603 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "PHI node with location" -msgstr "härifrån" +msgstr "PHI-nod med plats" #: tree-cfg.c:4614 tree-cfg.c:4663 #, gcc-internal-format @@ -16727,7 +16679,7 @@ msgstr "EXIT_BLOCK har IL associerat med sig" #: tree-cfg.c:4764 #, gcc-internal-format, gfc-internal-format msgid "fallthru to exit from bb %d" -msgstr "fall igenom till utgång från bb %d" +msgstr "fall igenom till utgång från gb %d" #: tree-cfg.c:4788 #, gcc-internal-format @@ -16764,17 +16716,17 @@ msgstr "sant/falskt-båge efter en icke-GIMPLE_COND i gb %d" #: tree-cfg.c:4899 tree-cfg.c:4921 tree-cfg.c:4938 tree-cfg.c:5007 #, gcc-internal-format, gfc-internal-format msgid "wrong outgoing edge flags at end of bb %d" -msgstr "felaktiga utgående bågeflaggor vid slutet av bb %d" +msgstr "felaktiga utgående bågeflaggor vid slutet av gb %d" #: tree-cfg.c:4909 #, gcc-internal-format, gfc-internal-format msgid "explicit goto at end of bb %d" -msgstr "uttrycklig goto vid slutet av bb %d" +msgstr "uttrycklig goto vid slutet av gb %d" #: tree-cfg.c:4943 #, gcc-internal-format, gfc-internal-format msgid "return edge does not point to exit in bb %d" -msgstr "returbåge pekar inte på utgång i bb %d" +msgstr "returbåge pekar inte på utgång i gb %d" #: tree-cfg.c:4973 #, gcc-internal-format @@ -16817,14 +16769,14 @@ msgid "ignoring return value of function declared with attribute warn_unused_res msgstr "ignorerar returvärdet av funktion deklarerad med attributet warn_unused_result" #: tree-diagnostic.c:202 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "in definition of macro %qs" -msgstr "omdefiniering av %q+D" +msgstr "i definitionen av makrot %qs" #: tree-diagnostic.c:219 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "in expansion of macro %qs" -msgstr "%s:%d: i expansion av konstantuttryck i från %qs" +msgstr "i expansionen av makrot %qs" #: tree-eh.c:4368 #, gcc-internal-format, gfc-internal-format @@ -16965,7 +16917,7 @@ msgstr "mudflap kan inte följa extern %qE av okänd storlek" #: tree-nomudflap.c:45 #, gcc-internal-format msgid "mudflap: this language is not supported" -msgstr "mudflap: detta språk stöds inte" +msgstr "mudflap: detta språk stödjs inte" #: tree-profile.c:407 #, gcc-internal-format @@ -17188,9 +17140,9 @@ msgid "vector operation will be expanded with a single scalar operation" msgstr "vektoroperationen kommer expanderas med en ensam skalär operation" #: tree-vect-generic.c:909 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "vector condition will be expanded piecewise" -msgstr "vektoroperationen kommer expanderas bitvis" +msgstr "vektorvillkor kommer expanderas bitvis" #: tree-vect-generic.c:1218 #, gcc-internal-format @@ -17530,7 +17482,7 @@ msgstr "trådlokal COMMON-data är inte implementerat" #: varasm.c:1852 #, gcc-internal-format msgid "requested alignment for %q+D is greater than implemented alignment of %wu" -msgstr "efterfrågad justering för %q+D är större än implementerad justering av %wu" +msgstr "begärd justering för %q+D är större än implementerad justering av %wu" #: varasm.c:1940 c/c-decl.c:4353 #, gcc-internal-format @@ -17560,17 +17512,17 @@ msgstr "svagdeklaration av %q+D måste vara publik" #: varasm.c:5272 #, gcc-internal-format msgid "weak declaration of %q+D not supported" -msgstr "svagdeklaration av %q+D stöds inte" +msgstr "svagdeklaration av %q+D stödjs inte" #: varasm.c:5301 varasm.c:5598 #, gcc-internal-format msgid "only weak aliases are supported in this configuration" -msgstr "bara svaga alias stöds i denna konfiguration" +msgstr "bara svaga alias stödjs i denna konfiguration" #: varasm.c:5490 #, gcc-internal-format msgid "weakref is not supported in this configuration" -msgstr "weakref stöds inte i denna konfiguration" +msgstr "weakref stödjs inte i denna konfiguration" #: varasm.c:5513 varasm.c:5595 #, gcc-internal-format @@ -17590,12 +17542,12 @@ msgstr "weakref %q+D måste ha statisk länkklass" #: varasm.c:5588 #, gcc-internal-format msgid "alias definitions not supported in this configuration" -msgstr "aliasdefinitioner stöds inte i denna konfiguration" +msgstr "aliasdefinitioner stödjs inte i denna konfiguration" #: varasm.c:5807 config/sol2.c:155 config/i386/winnt.c:254 #, gcc-internal-format msgid "visibility attribute not supported in this configuration; ignored" -msgstr "synlighetsattribut stöds inte för denna konfiguration, ignoreras" +msgstr "synlighetsattribut stödjs inte för denna konfiguration, ignoreras" #: varpool.c:240 #, gcc-internal-format @@ -18111,12 +18063,12 @@ msgstr "attributet %qE har bara effekt på publika objekt" #: c-family/c-common.c:6890 #, gcc-internal-format msgid "destructor priorities are not supported" -msgstr "destruerarprioriteter stöds ej" +msgstr "destruerarprioriteter stödjs ej" #: c-family/c-common.c:6892 #, gcc-internal-format msgid "constructor priorities are not supported" -msgstr "konstruerarprioriteter stöds ej" +msgstr "konstruerarprioriteter stödjs ej" #: c-family/c-common.c:6910 #, gcc-internal-format, gfc-internal-format @@ -18207,27 +18159,27 @@ msgstr "attributet ”section” är inte tillåten för %q+D" #: c-family/c-common.c:7265 #, gcc-internal-format msgid "section attributes are not supported for this target" -msgstr "attributet ”section” stöds inte för denna målarkitektur" +msgstr "attributet ”section” stödjs inte för denna målarkitektur" #: c-family/c-common.c:7284 #, gcc-internal-format msgid "requested alignment is not an integer constant" -msgstr "efterfrågad minnesjustering är inte en heltalskonstant" +msgstr "begärd minnesjustering är inte en heltalskonstant" #: c-family/c-common.c:7291 #, gcc-internal-format msgid "requested alignment is not a power of 2" -msgstr "efterfrågad minnesjustering är inte en potens av 2" +msgstr "begärd minnesjustering är inte en potens av 2" #: c-family/c-common.c:7296 #, gcc-internal-format msgid "requested alignment is too large" -msgstr "efterfrågad minnesjustering är för stor" +msgstr "begärd minnesjustering är för stor" #: c-family/c-common.c:7379 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "requested alignment %d is larger than %d" -msgstr "efterfrågad minnesjustering är för stor" +msgstr "begärd minnesjustering %d är större än %d" #: c-family/c-common.c:7436 #, gcc-internal-format @@ -18925,9 +18877,9 @@ msgstr "indexvärdet är utanför gränsen" #: c-family/c-common.c:11481 c-family/c-common.c:11531 #: c-family/c-common.c:11546 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conversion of scalar %qT to vector %qT involves truncation" -msgstr "konvertering av skalär till vektor innebär avhuggning" +msgstr "konvertering av skalären %qT till vektorn %qT innebär avhuggning" #: c-family/c-format.c:103 c-family/c-format.c:290 #, gcc-internal-format @@ -19334,7 +19286,7 @@ msgstr "flyttalskonstant utan suffix" #: c-family/c-lex.c:738 #, gcc-internal-format msgid "unsupported non-standard suffix on floating constant" -msgstr "icke-standardsuffix på flyttalskonstant stöds inte" +msgstr "icke-standardsuffix på flyttalskonstant stödjs inte" #: c-family/c-lex.c:743 #, gcc-internal-format @@ -19444,7 +19396,7 @@ msgstr "-fexcess-precision=standard för C++" #: c-family/c-opts.c:835 #, gcc-internal-format msgid "-fno-gnu89-inline is only supported in GNU99 or C99 mode" -msgstr "-fno-gnu89-inline stöds endast i GNU99- C99-läge" +msgstr "-fno-gnu89-inline stödjs endast i GNU99- C99-läge" #: c-family/c-opts.c:875 #, gcc-internal-format @@ -19477,9 +19429,9 @@ msgid "-Wformat-security ignored without -Wformat" msgstr "-Wformat-security ignorerad utan -Wformat" #: c-family/c-opts.c:910 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "external TLS initialization functions not supported on this target" -msgstr "nästade funktioner stöds inte på denna målarkitektur" +msgstr "externa TLS-initieringsfunktioner stödjs inte på denna målarkitektur" #: c-family/c-opts.c:930 #, gcc-internal-format @@ -19829,12 +19781,12 @@ msgstr "skräp vid slutet av %<#pragma %s%>" #: c-family/c-pragma.c:1117 #, gcc-internal-format msgid "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported for C++" -msgstr "%<#pragma STDC FLOAT_CONST_DECIMAL64%> stöds inte för C++" +msgstr "%<#pragma STDC FLOAT_CONST_DECIMAL64%> stödjs inte för C++" #: c-family/c-pragma.c:1126 #, gcc-internal-format msgid "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported on this target" -msgstr "%<#pragma STDC FLOAT_CONST_DECIMAL64%> stöds inte på denna målarkitektur" +msgstr "%<#pragma STDC FLOAT_CONST_DECIMAL64%> stödjs inte på denna målarkitektur" #: c-family/c-pragma.c:1132 #, gcc-internal-format @@ -20058,9 +20010,9 @@ msgid "%qE 2.95 vtable-compatibility attribute applies only to C++ classes" msgstr "%qE 2.95-vtable-kompatibilitetsattribut är bara tillämpligt på C++-klasser" #: config/darwin.c:2689 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "protected visibility attribute not supported in this configuration; ignored" -msgstr "synlighetsattribut stöds inte för denna konfiguration, ignoreras" +msgstr "synlighetsattributet skyddat stödjs inte för denna konfiguration, ignoreras" #: config/darwin.c:2847 #, gcc-internal-format, gfc-internal-format @@ -20175,7 +20127,7 @@ msgstr "ignorerar %<#pragma align%> för explicit justerad %q+D" #: config/vxworks.c:144 #, gcc-internal-format msgid "PIC is only supported for RTPs" -msgstr "PIC stöds endast för RTP:er" +msgstr "PIC stödjs endast för RTP:er" #. Mach-O supports 'weak imports', and 'weak definitions' in coalesced #. sections. machopic_select_section ensures that weak variables go in @@ -20185,7 +20137,7 @@ msgstr "PIC stöds endast för RTP:er" #: config/darwin.h:442 #, gcc-internal-format msgid "alias definitions not supported in Mach-O; ignored" -msgstr "aliasdefinitioner stöds inte i Mach-O, ignoreras" +msgstr "aliasdefinitioner stödjs inte i Mach-O, ignoreras" #. No profiling. #: config/vx-common.h:89 @@ -20194,53 +20146,53 @@ msgid "profiler support for VxWorks" msgstr "profileringsstöd för VxWorks" #: config/aarch64/aarch64-builtins.c:1032 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "incompatible type for argument %d, expected %<const int%>" -msgstr "inkompatibel typ för argument %d av %qE" +msgstr "inkompatibel typ för argument %d, %<const int%> förväntades" #: config/aarch64/aarch64.c:3643 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "function profiling" -msgstr "Aktivera funktionsprofilering" +msgstr "funktionsprofilering" #: config/aarch64/aarch64.c:4623 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "missing feature modifier after %qs" -msgstr "filnamn saknas efter %qs" +msgstr "funktionsmodifierare saknas efter %qs" #. Extension not found in list. #: config/aarch64/aarch64.c:4644 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unknown feature modifier %qs" -msgstr "okänd TLS-modell %qs" +msgstr "okänd funktionsmodifierare %qs" #: config/aarch64/aarch64.c:4675 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "missing arch name in -march=%qs" -msgstr "sökväg saknas efter %qs" +msgstr "arkitekturnamn saknas i -march=%qs" #. ARCH name not found in list. #: config/aarch64/aarch64.c:4699 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unknown value %qs for -march" -msgstr "okänt värde %qs till -mmacosx-version-min" +msgstr "okänt värde %qs till -march" #: config/aarch64/aarch64.c:4724 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "missing cpu name in -mcpu=%qs" -msgstr "sökväg saknas efter %qs" +msgstr "cpu-namn saknas i -mcpu=%qs" #. CPU name not found in list. #: config/aarch64/aarch64.c:4747 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unknown value %qs for -mcpu" -msgstr "felaktigt värde %qs till flaggan -mcpu" +msgstr "okänt värde %qs till -mcpu" #. CPU name not found in list. #: config/aarch64/aarch64.c:4771 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unknown value %qs for -mtune" -msgstr "felaktigt värde %qs till flaggan -mtune" +msgstr "okänt värde %qs till -mtune" #: config/aarch64/aarch64.c:4879 #, gcc-internal-format @@ -20249,19 +20201,19 @@ msgstr "kodmodell %qs med -f%s" #: config/aarch64/aarch64.c:5198 config/aarch64/aarch64.c:5306 #: config/aarch64/aarch64.c:5545 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs and floating point or vector arguments" -msgstr "Använd flyttalsinstruktioner i hårdvara" +msgstr "%qs och flyttals- eller vektorargument" #: config/aarch64/aarch64.c:6421 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "lane out of range" -msgstr "operandnummer utanför intervall" +msgstr "bana utanför intervall" #: config/aarch64/aarch64.c:6431 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "constant out of range" -msgstr "konstant argument utanför intervallet för %qs" +msgstr "konstant utanför intervall" #: config/alpha/alpha.c:295 #, gcc-internal-format @@ -20296,17 +20248,17 @@ msgstr "fp-mjukvarukomplettering kräver -mtrap-precision=i" #: config/alpha/alpha.c:393 #, gcc-internal-format msgid "rounding mode not supported for VAX floats" -msgstr "avrundningsläge stöds inte för VAX-flyttal" +msgstr "avrundningsläge stödjs inte för VAX-flyttal" #: config/alpha/alpha.c:398 #, gcc-internal-format msgid "trap mode not supported for VAX floats" -msgstr "läge för fällor (trap mode) stöds inte för VAX-flyttal" +msgstr "läge för fällor (trap mode) stödjs inte för VAX-flyttal" #: config/alpha/alpha.c:402 #, gcc-internal-format msgid "128-bit long double not supported for VAX floats" -msgstr "128-bitars long double stöds inte för VAX-flyttal" +msgstr "128-bitars long double stödjs inte för VAX-flyttal" #: config/alpha/alpha.c:430 #, gcc-internal-format, gfc-internal-format @@ -20367,7 +20319,7 @@ msgstr "-fpic och -mapcs-reent är inkompatibla" #: config/arm/arm.c:1801 #, gcc-internal-format msgid "APCS reentrant code not supported. Ignored" -msgstr "APCS-återanropsbar kod stöds inte. Ignoreras" +msgstr "APCS-återanropsbar kod stödjs inte. Ignoreras" #: config/arm/arm.c:1809 #, gcc-internal-format @@ -20377,7 +20329,7 @@ msgstr "-g med -mno-apcs-frame ger kanske inte vettig felsökning" #: config/arm/arm.c:1812 #, gcc-internal-format msgid "passing floating point arguments in fp regs not yet supported" -msgstr "att skicka flyttalsargument i fp-register stöds ännu inte" +msgstr "att skicka flyttalsargument i fp-register stödjs ännu inte" #: config/arm/arm.c:1815 #, gcc-internal-format @@ -20405,9 +20357,9 @@ msgid "AAPCS does not support -mcallee-super-interworking" msgstr "AAPCS stödjer inte -mcallee-super-interworking" #: config/arm/arm.c:1923 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "iWMMXt and NEON are incompatible" -msgstr "-mvsx och -mpaired är inkompatibla" +msgstr "iWMMXt och NEON är inkompatibla" #: config/arm/arm.c:1927 #, gcc-internal-format @@ -20467,7 +20419,7 @@ msgstr "målprocessorn stödjer inte ojusterade åtkomster" #: config/arm/arm.c:2087 #, gcc-internal-format msgid "-freorder-blocks-and-partition not supported on this architecture" -msgstr "-freorder-blocks-and-partition stöds inte på denna arkitektur" +msgstr "-freorder-blocks-and-partition stödjs inte på denna arkitektur" #: config/arm/arm.c:4148 #, gcc-internal-format @@ -20541,9 +20493,9 @@ msgid "mask must be an immediate" msgstr "mask måste vara en omedelbar" #: config/arm/arm.c:21827 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "the range of mask should be in 0 to 255" -msgstr "argument till attribut %qE skall vara mellan 0 och 255" +msgstr "intervallet för masken skall vara i 0 till 255" #: config/arm/arm.c:22015 #, gcc-internal-format @@ -20681,34 +20633,34 @@ msgid "%qs expects 1 argument but %d given" msgstr "%qs förväntar sig 1 argument men %d gavs" #: config/avr/avr-c.c:76 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs expects a fixed-point value as argument" -msgstr "%qs förväntar sig ett konstant argument" +msgstr "%qs förväntar sig ett fixdecimalvärde som argument" #: config/avr/avr-c.c:102 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "using %qs with unsigned type has no effect" -msgstr "attributet %qE har ingen effekt" +msgstr "att använda %qs med en teckenlös typ har ingen effekt" #: config/avr/avr-c.c:107 config/avr/avr-c.c:173 config/avr/avr-c.c:230 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "no matching fixed-point overload found for %qs" -msgstr "det finns ingen matchande mall för %qD" +msgstr "ingen matchande fixdecimalöverlagring funnen för %qs" #: config/avr/avr-c.c:124 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs expects 2 arguments but %d given" -msgstr "%qs förväntar sig ett konstant argument" +msgstr "%qs förväntar 2 argument men gavs %d" #: config/avr/avr-c.c:136 config/avr/avr-c.c:201 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs expects a fixed-point value as first argument" -msgstr "%qs förväntar sig ett konstant argument" +msgstr "%qs förväntar sig ett fixdecimalvärde som första argument" #: config/avr/avr-c.c:144 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs expects an integer value as second argument" -msgstr "%qs förväntar sig ett konstant argument" +msgstr "%qs förväntar sig ett heltalsvärde som andra argument" #: config/avr/avr.c:573 #, gcc-internal-format @@ -20736,9 +20688,9 @@ msgid "%qs appears to be a misspelled %s handler" msgstr "%qs verkar vara en felstavad %s-hanterare" #: config/avr/avr.c:838 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<builtin_return_address%> contains only 2 bytes of address" -msgstr "”builtin_return_address” innehåller bara 2 byte adress" +msgstr "%<builtin_return_address%> innehåller bara 2 byte adress" #: config/avr/avr.c:2047 #, gcc-internal-format @@ -20808,7 +20760,7 @@ msgstr "den oinitierade variabeln %q+D placerad i programminnesområdet" #: config/avr/avr.c:8394 #, gcc-internal-format msgid "MCU %qs supported for assembler only" -msgstr "MCU %qs stöds endast i assembler" +msgstr "MCU %qs stödjs endast i assembler" #: config/avr/avr.c:11718 #, gcc-internal-format, gfc-internal-format @@ -20979,7 +20931,7 @@ msgstr "okänd CRIS-cpu-version angiven i -mtune= : %s" #: config/cris/cris.c:2674 #, gcc-internal-format msgid "-fPIC and -fpic are not supported in this configuration" -msgstr "-fPIC och -fpic stöds inte i denna konfiguration" +msgstr "-fPIC och -fpic stödjs inte i denna konfiguration" #: config/cris/cris.c:2932 #, gcc-internal-format @@ -21140,9 +21092,9 @@ msgid "this builtin function is only available on the fr450" msgstr "denna inbyggda funktion är endast tillgänglig i fr450" #: config/h8300/h8300.c:320 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-msx is not supported in coff" -msgstr "-f%s stöds inte: ignoreras" +msgstr "-msx stödjs inte i coff" #: config/h8300/h8300.c:342 #, gcc-internal-format @@ -21150,24 +21102,24 @@ msgid "-ms2600 is used without -ms" msgstr "-ms2600 används utan -ms" #: config/h8300/h8300.c:348 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-mn is used without -mh or -ms or -msx" -msgstr "-mn används utan -mh eller -ms" +msgstr "-mn används utan -mh eller -ms eller -msx" #: config/h8300/h8300.c:354 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-mexr is used without -ms" -msgstr "-ms2600 används utan -ms" +msgstr "-mexr används utan -ms" #: config/h8300/h8300.c:360 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-mint32 is not supported for H8300 and H8300L targets" -msgstr "%<__int128%> stöds inte för denna målarkitektur" +msgstr "-mint32 stödjs inte för målen H8300 och H8300L" #: config/h8300/h8300.c:366 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-mexr is used without -ms or -msx" -msgstr "-mn används utan -mh eller -ms" +msgstr "-mexr används utan -ms eller -msx" #: config/h8300/h8300.c:372 #, gcc-internal-format @@ -21201,20 +21153,20 @@ msgid "-mstringop-strategy=rep_8byte not supported for 32-bit code" msgstr "-mstringop-strategy=rep_8byte stödjs inte för 32-bitarskod" #: config/i386/i386.c:3160 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "address mode %qs not supported in the %s bit mode" -msgstr "kodmodellen %qs stöds inte i %s-bitsläge" +msgstr "adressläget %qs stödjs inte i %s-bitsläge" #: config/i386/i386.c:3179 config/i386/i386.c:3188 config/i386/i386.c:3200 #: config/i386/i386.c:3211 config/i386/i386.c:3222 #, gcc-internal-format msgid "code model %qs not supported in the %s bit mode" -msgstr "kodmodellen %qs stöds inte i %s-bitsläge" +msgstr "kodmodellen %qs stödjs inte i %s-bitsläge" #: config/i386/i386.c:3191 config/i386/i386.c:3203 #, gcc-internal-format msgid "code model %qs not supported in x32 mode" -msgstr "kodmodellen %qs stöds inte i x32-läge" +msgstr "kodmodellen %qs stödjs inte i x32-läge" #: config/i386/i386.c:3209 config/i386/i386.c:3218 #, gcc-internal-format, gfc-internal-format @@ -21318,9 +21270,9 @@ msgid "unknown option for -mrecip=%s" msgstr "okänt alternativ till -mrecip=%s" #: config/i386/i386.c:4229 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "attribute %<target%> argument not a string" -msgstr "argument till attribut %qE är inte en sträng" +msgstr "argument till attribut %<target%> är inte en sträng" #: config/i386/i386.c:4295 config/i386/i386.c:4342 #, gcc-internal-format, gfc-internal-format @@ -21505,9 +21457,9 @@ msgid "unsupported operand size for extended register" msgstr "ej stödd operandstorlek för utökat register" #: config/i386/i386.c:14206 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "non-integer operand used with operand code 'z'" -msgstr "operand som inte är heltal använt med operandkod ”%c”" +msgstr "operand som inte är heltal använt med operandkod ”z”" #: config/i386/i386.c:28755 #, gcc-internal-format @@ -21530,9 +21482,9 @@ msgid "Function versions cannot be marked as gnu_inline, bodies have to be gener msgstr "Funktionsversioner kan inte markeras som gnu_inline, kropparna måste vara genererade" #: config/i386/i386.c:29067 config/i386/i386.c:29512 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "Virtual function multiversioning not supported" -msgstr "stackgränsuttryck stöds inte" +msgstr "Multiversionering av virtuell funktion stödjs inte" #: config/i386/i386.c:29132 #, gcc-internal-format @@ -21540,24 +21492,24 @@ msgid "missing %<target%> attribute for multi-versioned %D" msgstr "saknat attribut %<target%> för flerversionsers %D" #: config/i386/i386.c:29135 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration of %D" -msgstr "tidigare deklaration av %q+D" +msgstr "tidigare deklaration av %D" #: config/i386/i386.c:29351 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "multiversioning needs ifunc which is not supported in this configuration" -msgstr "ifunc stödjs inte i denna konfiguration" +msgstr "multiversionering behöver ifunc som inte stödjs i denna konfiguration" #: config/i386/i386.c:29695 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "Parameter to builtin must be a string constant or literal" -msgstr "argument till %qs måste vara en 2-bitars literal utan tecken" +msgstr "Parameter till inbyggd måste vara en stränkonstant eller -literal" #: config/i386/i386.c:29720 config/i386/i386.c:29770 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Parameter to builtin not valid: %s" -msgstr "Argumentet till -ffpe-trap är inte giltigt: %s" +msgstr "Parameter till inbyggd är inte giltig: %s" #: config/i386/i386.c:30171 config/i386/i386.c:31114 #, gcc-internal-format @@ -21635,9 +21587,9 @@ msgid "last argument must be scale 1, 2, 4, 8" msgstr "sista argumentet ha skala 1, 2, 4, 8" #: config/i386/i386.c:32311 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "the xabort's argument must be an 8-bit immediate" -msgstr "det sista argumentet måste vara en 8-bitars omedelbar" +msgstr "argumentet till xabort måste vara en 8-bitars omedelbar" #: config/i386/i386.c:34646 #, gcc-internal-format @@ -21814,7 +21766,7 @@ msgstr "ogiltigt målvärde för memregs ”%d”" #: config/m32c/m32c.c:2918 #, gcc-internal-format msgid "%qE attribute is not supported for R8C target" -msgstr "attributet %qE stöds inte för denna målarkitekturen R8C" +msgstr "attributet %qE stödjs inte för denna målarkitekturen R8C" #. The argument must be a constant integer. #: config/m32c/m32c.c:2934 config/sh/sh.c:9570 config/sh/sh.c:9676 @@ -21850,22 +21802,22 @@ msgstr "-mcpu=%s står i konflikt med -march=%s" #: config/m68k/m68k.c:547 #, gcc-internal-format msgid "-mpcrel -fPIC is not currently supported on selected cpu" -msgstr "-mpcrel -fPIC stöds för närvarande inte på den valda cpu:n" +msgstr "-mpcrel -fPIC stödjs för närvarande inte på den valda cpu:n" #: config/m68k/m68k.c:609 #, gcc-internal-format, gfc-internal-format msgid "-falign-labels=%d is not supported" -msgstr "-falign-labels=%d stöds ej" +msgstr "-falign-labels=%d stödjs ej" #: config/m68k/m68k.c:614 #, gcc-internal-format, gfc-internal-format msgid "-falign-loops=%d is not supported" -msgstr "-falign-loops=%d stöds ej" +msgstr "-falign-loops=%d stödjs ej" #: config/m68k/m68k.c:621 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-fstack-limit- options are not supported on this cpu" -msgstr "stackgränser stöds inte på denna målarkitektur" +msgstr "-fstack-limit-flaggor stödjs inte på denna målarkitektur" #: config/m68k/m68k.c:736 #, gcc-internal-format @@ -21880,7 +21832,7 @@ msgstr "interrupt_thread är tillgängligt endast för fido" #: config/m68k/m68k.c:1077 config/rs6000/rs6000.c:18850 #, gcc-internal-format msgid "stack limit expression is not supported" -msgstr "stackgränsuttryck stöds inte" +msgstr "stackgränsuttryck stödjs inte" #: config/mcore/mcore.c:2939 #, gcc-internal-format @@ -21965,12 +21917,12 @@ msgstr "felformaterat #pragma call" #: config/mep/mep.c:351 #, gcc-internal-format msgid "-fpic is not supported" -msgstr "-fpic stöds inte" +msgstr "-fpic stödjs inte" #: config/mep/mep.c:353 #, gcc-internal-format msgid "-fPIC is not supported" -msgstr "-fPIC stöds inte" +msgstr "-fPIC stödjs inte" #: config/mep/mep.c:355 #, gcc-internal-format @@ -22161,9 +22113,9 @@ msgid "unexpected %d byte cop instruction" msgstr "oväntad %d-byte cop-instruktion" #: config/microblaze/microblaze.c:1311 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-fPIC/-fpic not supported for this target" -msgstr "-fstack-protector stöds inte av denna målarkitektur" +msgstr "-fPIC/-fpic stödjs inte av denna målarkitektur" #: config/microblaze/microblaze.c:1323 #, gcc-internal-format @@ -22228,7 +22180,7 @@ msgstr "ogiltigt argument inbyggd funktion" #: config/mips/mips.c:14190 #, gcc-internal-format msgid "built-in function %qE not supported for MIPS16" -msgstr "inbyggd funktion %qE stöds inte för MIPS16" +msgstr "inbyggd funktion %qE stödjs inte för MIPS16" #: config/mips/mips.c:14787 #, gcc-internal-format @@ -22311,14 +22263,14 @@ msgid "the %qs architecture does not support branch-likely instructions" msgstr "arkitekturen %qs stödjer inte trolig gren-instruktioner" #: config/mips/mips.c:16621 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot generate position-independent code for %qs" -msgstr "Generera positionsoberoende kod om möjligt (stort läge)" +msgstr "kan inte generera positionsoberoende kod för %qs" #: config/mips/mips.c:16624 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "position-independent code requires %qs" -msgstr "Avaktivera positionsoberoende kod (PIC) för användning i OS-kärnkod" +msgstr "positionsoberoende kod behöver %qs" #: config/mips/mips.c:16657 #, gcc-internal-format @@ -22368,7 +22320,7 @@ msgstr "funktionsprofilering för mips16" #: config/mmix/mmix.c:295 #, gcc-internal-format, gfc-internal-format msgid "-f%s not supported: ignored" -msgstr "-f%s stöds inte: ignoreras" +msgstr "-f%s stödjs inte: ignoreras" #: config/mmix/mmix.c:725 #, gcc-internal-format @@ -22424,7 +22376,7 @@ msgstr "-mtune= förväntar sig mn10300, am33, am33-2 eller am34" #: config/pa/pa.c:501 #, gcc-internal-format msgid "PIC code generation is not supported in the portable runtime model" -msgstr "PIC-kodgenerering stöds inte i den portabla körtidsmodellen" +msgstr "PIC-kodgenerering stödjs inte i den portabla körtidsmodellen" #: config/pa/pa.c:506 #, gcc-internal-format @@ -22434,7 +22386,7 @@ msgstr "PIC-kodsgenerering är inte inte kompatibelt med snabba indirekta anrop" #: config/pa/pa.c:511 #, gcc-internal-format msgid "-g is only supported when using GAS on this processor," -msgstr "-g stöds bara när man använder GAS på denna processor," +msgstr "-g stödjs bara när man använder GAS på denna processor," #: config/pa/pa.c:512 #, gcc-internal-format @@ -22664,7 +22616,7 @@ msgstr "-m64 kräver PowerPC64-arkitektur, aktiverar" #: config/rs6000/rs6000.c:2405 #, gcc-internal-format msgid "-malign-power is not supported for 64-bit Darwin; it is incompatible with the installed C and C++ libraries" -msgstr "-malign-power stöds inte för 64-bitars Darwin, det är inkompatibelt med de installerade C- och C++-biblioteken" +msgstr "-malign-power stödjs inte för 64-bitars Darwin, det är inkompatibelt med de installerade C- och C++-biblioteken" #: config/rs6000/rs6000.c:2542 #, gcc-internal-format @@ -22672,9 +22624,9 @@ msgid "not configured for SPE ABI" msgstr "inte konfigurerad för SPE-ABI:" #: config/rs6000/rs6000.c:2547 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "not configured for SPE instruction set" -msgstr "Använd inte instruktionsuppsättning för PowerPC" +msgstr "inte konfigurerad för instruktionsuppsättningen SPE" #: config/rs6000/rs6000.c:2553 #, gcc-internal-format @@ -22694,12 +22646,12 @@ msgstr "SPE stödjs inte på denna målarkitektur" #: config/rs6000/rs6000.c:2595 #, gcc-internal-format msgid "-mmultiple is not supported on little endian systems" -msgstr "-mmultiple stöds inte på system med omvänd byteordning" +msgstr "-mmultiple stödjs inte på system med omvänd byteordning" #: config/rs6000/rs6000.c:2602 #, gcc-internal-format msgid "-mstring is not supported on little endian systems" -msgstr "-mstring stöds inte på system med omvänd byteordning" +msgstr "-mstring stödjs inte på system med omvänd byteordning" #: config/rs6000/rs6000.c:2711 #, gcc-internal-format, gfc-internal-format @@ -23077,7 +23029,7 @@ msgstr "soft-float och long-double-128 är inkompatibla" #: config/rs6000/aix53.h:40 config/rs6000/aix61.h:40 #, gcc-internal-format msgid "-maix64 required: 64-bit computation with 32-bit addressing not yet supported" -msgstr "-maix64 krävs: 64-bitsberäkningar med 32-bitars adressering stöds inte än" +msgstr "-maix64 krävs: 64-bitsberäkningar med 32-bitars adressering stödjs inte än" #: config/rs6000/aix61.h:47 config/rs6000/freebsd64.h:107 #: config/rs6000/linux64.h:130 @@ -23086,24 +23038,24 @@ msgid "-mcmodel incompatible with other toc options" msgstr "-mcmodel är inkompatibel med andra toc-flaggor" #: config/rs6000/e500.h:37 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "AltiVec and SPE instructions cannot coexist" -msgstr "AltiVec- och E500-instruktioner kan inte samexistera" +msgstr "AltiVec- och SPE-instruktioner kan inte samexistera" #: config/rs6000/e500.h:39 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "VSX and SPE instructions cannot coexist" -msgstr "VSX- och E500-instruktioner kan inte samexistera" +msgstr "VSX- och SPE-instruktioner kan inte samexistera" #: config/rs6000/e500.h:41 #, fuzzy, gcc-internal-format msgid "64-bit SPE not supported" -msgstr "64-bitars E500 stöds inte" +msgstr "64-bitars E500 stödjs inte" #: config/rs6000/e500.h:43 #, gcc-internal-format msgid "E500 and FPRs not supported" -msgstr "E500 och FPR:er stöds inte" +msgstr "E500 och FPR:er stödjs inte" #: config/rs6000/freebsd64.h:100 config/rs6000/linux64.h:123 #, gcc-internal-format @@ -23125,7 +23077,7 @@ msgstr "-m64 kräver en PowerPC64-CPU" #: config/rs6000/rs6000.h:1687 #, gcc-internal-format msgid "RETURN_ADDRESS_OFFSET not supported" -msgstr "RETURN_ADDRESS_OFFSET stöds inte" +msgstr "RETURN_ADDRESS_OFFSET stödjs inte" #. The macro SUBTARGET_OVERRIDE_OPTIONS is provided for subtargets, to #. get control in TARGET_OPTION_OVERRIDE. @@ -23177,12 +23129,12 @@ msgstr "-mcall-aixdesc måste ha rak byteordning" #: config/rs6000/sysv4.h:198 #, gcc-internal-format msgid "-msecure-plt not supported by your assembler" -msgstr "-msecure-plt stöds inte av din assembler" +msgstr "-msecure-plt stödjs inte av din assembler" #: config/rs6000/sysv4.h:217 #, gcc-internal-format, gfc-internal-format msgid "-m%s not supported in this configuration" -msgstr "-m%s stöds inte i denna konfiguration" +msgstr "-m%s stödjs inte i denna konfiguration" #: config/rx/rx.c:641 #, gcc-internal-format, gfc-internal-format @@ -23217,12 +23169,12 @@ msgstr "RX FPU-instruktioner stödjer inte NaN:er och oändligheter" #: config/s390/s390.c:1596 #, gcc-internal-format, gfc-internal-format msgid "z/Architecture mode not supported on %s" -msgstr "z/Architecture-läge stöds inte på %s" +msgstr "z/Architecture-läge stödjs inte på %s" #: config/s390/s390.c:1598 #, gcc-internal-format msgid "64-bit ABI not supported in ESA/390 mode" -msgstr "64-bits ABI stöds inte i ESA/390-läge" +msgstr "64-bits ABI stödjs inte i ESA/390-läge" #: config/s390/s390.c:1610 #, gcc-internal-format, gfc-internal-format @@ -23242,7 +23194,7 @@ msgstr "-mhard-dfp kan inte användas tillsammans med -msoft-float" #: config/s390/s390.c:1651 #, gcc-internal-format msgid "-mbackchain -mpacked-stack -mhard-float are not supported in combination" -msgstr "-mbackchain -mpacked-stack -mhard-float stöds inte i kombination" +msgstr "-mbackchain -mpacked-stack -mhard-float stödjs inte i kombination" #: config/s390/s390.c:1657 #, gcc-internal-format @@ -23297,7 +23249,7 @@ msgstr "utrullningstabeller kräver för närvarande antingen en rampekare eller #: config/sh/sh.c:8284 #, gcc-internal-format msgid "__builtin_saveregs not supported by this subtarget" -msgstr "__builtin_saveregs stöds inte på denna målunderarkitektur" +msgstr "__builtin_saveregs stödjs inte på denna målunderarkitektur" #: config/sh/sh.c:9439 #, gcc-internal-format @@ -23307,7 +23259,7 @@ msgstr "attributet %qE är bara tillämpligt på avbrottsfunktioner" #: config/sh/sh.c:9509 #, gcc-internal-format msgid "%qE attribute is supported only for SH2A" -msgstr "attributet %qE stöds endast för SH2A" +msgstr "attributet %qE stödjs endast för SH2A" #: config/sh/sh.c:9539 #, gcc-internal-format @@ -23355,12 +23307,12 @@ msgstr "oimplementerat - shmedia-profilering" #: config/sh/vxworks.h:43 #, gcc-internal-format msgid "-mrelax is only supported for RTP PIC" -msgstr "-mrelax stöds endast för RTP PIC" +msgstr "-mrelax stödjs endast för RTP PIC" #: config/sparc/sparc.c:1001 #, gcc-internal-format, gfc-internal-format msgid "%s is not supported by this configuration" -msgstr "%s stöds inte i denna konfiguration" +msgstr "%s stödjs inte i denna konfiguration" #: config/sparc/sparc.c:1008 #, gcc-internal-format @@ -23375,7 +23327,7 @@ msgstr "felaktigt värde (%s) till flaggan -mcmodel=" #: config/sparc/sparc.c:1033 #, gcc-internal-format msgid "-mcmodel= is not supported on 32 bit systems" -msgstr "-mcmodel= stöds inte på 32-bitars system" +msgstr "-mcmodel= stödjs inte på 32-bitars system" #: config/sparc/sparc.c:1040 #, gcc-internal-format @@ -23673,12 +23625,12 @@ msgstr "booleska register krävs för flyttalsalternativet" #: config/xtensa/xtensa.c:2213 #, gcc-internal-format, gfc-internal-format msgid "-f%s is not supported with CONST16 instructions" -msgstr "-f%s stöds inte med CONST16-instruktioner" +msgstr "-f%s stödjs inte med CONST16-instruktioner" #: config/xtensa/xtensa.c:2220 #, gcc-internal-format msgid "PIC is required but not supported with CONST16 instructions" -msgstr "PIC krävs men stöds inte med CONST16-instruktioner" +msgstr "PIC krävs men stödjs inte med CONST16-instruktioner" #: config/xtensa/xtensa.c:3275 #, gcc-internal-format @@ -25242,7 +25194,7 @@ msgstr "ISO C stödjer inte mättning av typer" #: c/c-decl.c:9235 #, gcc-internal-format msgid "%<__int128%> is not supported for this target" -msgstr "%<__int128%> stöds inte för denna målarkitektur" +msgstr "%<__int128%> stödjs inte för denna målarkitektur" #: c/c-decl.c:9240 #, gcc-internal-format @@ -25257,7 +25209,7 @@ msgstr "ISO C stödjer inte decimala flyttal" #: c/c-decl.c:9488 c/c-decl.c:9732 c/c-parser.c:6232 #, gcc-internal-format msgid "fixed-point types not supported for this target" -msgstr "fixdecimaltyper stöds inte för denna målarkitektur" +msgstr "fixdecimaltyper stödjs inte för denna målarkitektur" #: c/c-decl.c:9490 #, gcc-internal-format @@ -29015,7 +28967,7 @@ msgstr "namn använt i en designerad initierare i GNU-stil för en vektor" #: cp/decl.c:4780 cp/typeck2.c:1085 cp/typeck2.c:1189 #, gcc-internal-format msgid "non-trivial designated initializers not supported" -msgstr "icketriviala designerade initierare stöds inte" +msgstr "icketriviala designerade initierare stödjs inte" #: cp/decl.c:4785 #, gcc-internal-format @@ -32286,7 +32238,7 @@ msgstr "en deklaration förväntades" #: cp/parser.c:3934 #, gcc-internal-format msgid "fixed-point types not supported in C++" -msgstr "fixdecimaltyper stöds inte i C++" +msgstr "fixdecimaltyper stödjs inte i C++" #: cp/parser.c:4025 #, gcc-internal-format @@ -35332,7 +35284,7 @@ msgstr "begärt init_priority är reserverad för internt bruk" #: cp/tree.c:3193 #, gcc-internal-format msgid "%qE attribute is not supported on this platform" -msgstr "attributet %qE stöds inte på denna plattform" +msgstr "attributet %qE stödjs inte på denna plattform" #: cp/tree.c:3220 #, fuzzy, gcc-internal-format @@ -37610,7 +37562,7 @@ msgstr "Initiering av allokerbar komponent vid %C är inte tillåtet" #: fortran/decl.c:2110 fortran/decl.c:2146 #, gcc-internal-format, gfc-internal-format msgid "Old-style type declaration %s*%d not supported at %C" -msgstr "Gammaldags typdeklaration %s*%d stöds inte vid %C" +msgstr "Gammaldags typdeklaration %s*%d stödjs inte vid %C" #: fortran/decl.c:2151 #, gcc-internal-format, gfc-internal-format @@ -37635,7 +37587,7 @@ msgstr "Ett skalärt initieringsuttryck förväntades vid %C" #: fortran/decl.c:2254 #, gcc-internal-format, gfc-internal-format msgid "Kind %d not supported for type %s at %C" -msgstr "Sorten %d stöds inte för typen %s vid %C" +msgstr "Sorten %d stödjs inte för typen %s vid %C" #: fortran/decl.c:2267 #, gcc-internal-format, gfc-internal-format @@ -37650,7 +37602,7 @@ msgstr "Högerparentes eller komma saknas vid %C" #: fortran/decl.c:2375 #, gcc-internal-format, gfc-internal-format msgid "Kind %d is not supported for CHARACTER at %C" -msgstr "Sorten %d stöds inte för typen CHARACTER vid %C" +msgstr "Sorten %d stödjs inte för typen CHARACTER vid %C" #: fortran/decl.c:2507 #, gcc-internal-format, gfc-internal-format @@ -41651,7 +41603,7 @@ msgstr "Fri radlängd måste vara minst tre" #: fortran/options.c:836 #, gcc-internal-format msgid "-static-libgfortran is not supported in this configuration" -msgstr "-static-libgfortran stöds inte i denna konfiguration" +msgstr "-static-libgfortran stödjs inte i denna konfiguration" #: fortran/options.c:891 #, gcc-internal-format, gfc-internal-format @@ -47099,13 +47051,13 @@ msgstr "skapar selektor för icke existerande metod %qE" #~ msgstr "skräp vid slutet av %<#pragma extern_prefix%>" #~ msgid "#pragma extern_prefix not supported on this target" -#~ msgstr "#pragma extern_prefix stöds inte på denna målarkitektur" +#~ msgstr "#pragma extern_prefix stödjs inte på denna målarkitektur" #~ msgid "internal and protected visibility attributes not supported in this configuration; ignored" -#~ msgstr "synlighetsattributen internal och protected stöds inte för denna konfiguration, ignoreras" +#~ msgstr "synlighetsattributen internal och protected stödjs inte för denna konfiguration, ignoreras" #~ msgid "FPA is unsupported in the AAPCS" -#~ msgstr "FPA stöds inte i AAPCS" +#~ msgstr "FPA stödjs inte i AAPCS" #~ msgid "iWMMXt and hardware floating point" #~ msgstr "iWMMXt och hårdvaruflyttal" @@ -47126,7 +47078,7 @@ msgstr "skapar selektor för icke existerande metod %qE" #~ msgstr "-maix64 och POWER-arkitekturen är inkompatibla" #~ msgid "-m64 not supported in this configuration" -#~ msgstr "-m64 stöds inte i denna konfiguration" +#~ msgstr "-m64 stödjs inte i denna konfiguration" #~ msgid "ambiguous overload for ternary %<operator?:%> in %<%E ? %E : %E%>" #~ msgstr "tvetydig överlagring för treställig %<operator?:%> i %<%E ? %E : %E%>" diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index caf8f6d1e2f..6769ff794aa 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,7 +1,55 @@ +2013-03-19 Ian Bolton <ian.bolton@arm.com> + + * gcc.target/aarch64/sbc.c: New test. + +2013-03-19 Ian Bolton <ian.bolton@arm.com> + + * gcc.target/aarch64/ror.c: New test. + +2013-03-19 Ian Bolton <ian.bolton@arm.com> + + * gcc.target/aarch64/extr.c: New test. + +2013-03-19 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56273 + * gcc.dg/tree-ssa/vrp47.c: Adjust. + * c-c++-common/uninit-17.c: Likewise. + +2013-03-18 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/56635 + * g++.dg/torture/pr56635.C: New test. + +2013-03-18 Richard Biener <rguenther@suse.de> + + PR tree-optimization/3713 + * g++.dg/ipa/devirt-12.C: New testcase. + +2013-03-18 Jakub Jelinek <jakub@redhat.com> + + PR c/56566 + * c-c++-common/pr56566.c: New test. + +2013-03-17 Jason Merrill <jason@redhat.com> + + * g++.dg/template/abstract-dr337.C: XFAIL. + +2013-03-16 Jakub Jelinek <jakub@redhat.com> + + PR c++/56607 + * g++.dg/warn/Wdiv-by-zero-2.C: New test. + * c-c++-common/pr56607.c: New test. + +2013-03-16 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/56582 + * g++.dg/cpp0x/constexpr-array5.C: New. + 2013-03-15 Tobias Burnus <burnus@net-b.de> - PR fortran/56615 - * gfortran.dg/transfer_intrinsic_5.f90: New. + PR fortran/56615 + * gfortran.dg/transfer_intrinsic_5.f90: New. 2013-03-15 Kai Tietz <ktietz@redhat.com> @@ -443,7 +491,7 @@ 2013-02-20 Jan Hubicka <jh@suse.cz> PR tree-optimization/56265 - * testsuite/g++.dg/ipa/devirt-11.C: New testcase. + * g++.dg/ipa/devirt-11.C: New testcase. 2013-02-20 Richard Biener <rguenther@suse.de> @@ -547,7 +595,7 @@ 2013-02-15 Tobias Burnus <burnus@net-b.de> PR fortran/56318 - * gcc/testsuite/gfortran.dg/matmul_9.f90: New. + * gfortran.dg/matmul_9.f90: New. 2013-02-15 Tobias Burnus <burnus@net-b.de> @@ -630,9 +678,9 @@ Avoid instrumenting duplicated memory access in the same basic block * c-c++-common/asan/no-redundant-instrumentation-1.c: New test. - * testsuite/c-c++-common/asan/no-redundant-instrumentation-2.c: Likewise. - * testsuite/c-c++-common/asan/no-redundant-instrumentation-3.c: Likewise. - * testsuite/c-c++-common/asan/inc.c: Likewise. + * c-c++-common/asan/no-redundant-instrumentation-2.c: Likewise. + * c-c++-common/asan/no-redundant-instrumentation-3.c: Likewise. + * c-c++-common/asan/inc.c: Likewise. 2013-02-12 Vladimir Makarov <vmakarov@redhat.com> diff --git a/gcc/testsuite/c-c++-common/pr56566.c b/gcc/testsuite/c-c++-common/pr56566.c new file mode 100644 index 00000000000..e753d933a4f --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr56566.c @@ -0,0 +1,14 @@ +/* PR c/56566 */ +/* { dg-do compile } */ +/* { dg-options "" } */ + +struct S1 { enum E1 { N1 = -1, Z1 = 0 } e : 1; }; +struct S2 { enum E2 { N2 = -1 } e : 1; }; +struct S3 { enum E3 { Z3 = 0 } e : 1; }; +struct S4 { enum E4 { N4 = -2, Z4 = 1 } e : 2; }; +struct S5 { enum E5 { N5 = -3, Z5 = 1 } e : 3; }; +struct S6 { enum E6 { N6 = -2, Z6 = 1 } e : 1; }; // { dg-warning "too small|narrower" } +struct S7 { enum E7 { N7 = -3, Z7 = 1 } e : 2; }; // { dg-warning "too small|narrower" } +struct S8 { enum E8 { Z8 = 1 } e : 1; }; +struct S9 { enum E9 { Z9 = 2 } e : 2; }; +struct S0 { enum E0 { Z0 = 2 } e : 1; }; // { dg-warning "too small|narrower" } diff --git a/gcc/testsuite/c-c++-common/pr56607.c b/gcc/testsuite/c-c++-common/pr56607.c new file mode 100644 index 00000000000..d7faa81151a --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr56607.c @@ -0,0 +1,29 @@ +/* PR c++/56607 */ +/* { dg-do compile { target { { lp64 || ilp32 } || llp64 } } } */ +/* { dg-options "-O2 -Wdiv-by-zero" } */ + +int +f1 (void) +{ + return 1 / (sizeof (char) - 1); /* { dg-warning "division by zero" } */ +} + +int +f2 (void) +{ + const int x = sizeof (char) - 1; + return 1 / x; /* { dg-warning "division by zero" "" { target c++ } } */ +} + +int +f3 (void) +{ + return 1 / (sizeof (int) / 3 - 1); /* { dg-warning "division by zero" } */ +} + +int +f4 (void) +{ + const int x = sizeof (int) / 3 - 1; + return 1 / x; /* { dg-warning "division by zero" "" { target c++ } } */ +} diff --git a/gcc/testsuite/c-c++-common/uninit-17.c b/gcc/testsuite/c-c++-common/uninit-17.c index 1719ae85f96..fd773da78ad 100644 --- a/gcc/testsuite/c-c++-common/uninit-17.c +++ b/gcc/testsuite/c-c++-common/uninit-17.c @@ -11,9 +11,9 @@ static void bar(int a, int *ptr) { int b; /* { dg-message "declared" } */ if (b < 40) { - ptr[0] = b; + ptr[0] = b; /* { dg-warning "may be used uninitialized" } */ } - b += 1; /* { dg-warning "may be used uninitialized" } */ + b += 1; ptr++; } while (--a != 0); diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-array5.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-array5.C new file mode 100644 index 00000000000..4605b4be902 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-array5.C @@ -0,0 +1,9 @@ +// PR c++/56582 +// { dg-do compile { target c++11 } } + +// Reliable ICE +constexpr int n[3] = {}; +constexpr int k = n[-1]; // { dg-error "negative" } + +// Some random byte +constexpr char c = "foo"[-1000]; // { dg-error "negative" } diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-template4.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-template4.C new file mode 100644 index 00000000000..7adcae83abd --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-template4.C @@ -0,0 +1,26 @@ +// PR c++/55931 +// { dg-do compile { target c++11 } } + +#include <type_traits> + +template<typename Type> +class Test +{ + public: + constexpr Test(const Type val) : _value(val) {} + constexpr Type get() const {return _value;} + static void test() + { + static constexpr Test<int> x(42); + std::integral_constant<int, x.get()> i; // This is not working + } + protected: + Type _value; +}; + +int main() +{ + static constexpr Test<int> x(42); + std::integral_constant<int, x.get()> i; // This is working + Test<double>::test(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-template5.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-template5.C new file mode 100644 index 00000000000..aa80658036d --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-template5.C @@ -0,0 +1,6 @@ +// PR c++/54946 +// { dg-do compile { target c++11 } } + +template<const char*s> static void testfunc(); +constexpr struct testtype { const char* str; } test = { "abc"} ; +void (*functionpointer)() = testfunc<(const char*) test.str>; // { dg-error "" } diff --git a/gcc/testsuite/g++.dg/cpp0x/decltype-call1.C b/gcc/testsuite/g++.dg/cpp0x/decltype-call1.C new file mode 100644 index 00000000000..2616bb09046 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/decltype-call1.C @@ -0,0 +1,32 @@ +// PR c++/52748 +// N3276 +// { dg-do compile { target c++11 } } + +struct A; // { dg-error "forward declaration" } +A f(); + +decltype(f()) g1(); // OK +decltype(((f()))) g2b(); // OK +decltype(42,f()) g3(); // OK +decltype(42,45,f()) g3b(); // OK +decltype(42,45,(f())) g3c(); // OK +decltype(42,((45,(f())))) g3c(); // OK + +decltype(f(),42) g4(); // { dg-error "" } +decltype(45,f(),42) g4b(); // { dg-error "" } + +class B +{ + ~B(); // { dg-error "private" } +public: + int i; + void operator[](int); +}; +B h(); + +void i(const B&); + +decltype(h()) g5a(); // OK +decltype(h().i) g5(); // { dg-error "" } +decltype(h()[0]) g6(); // { dg-error "" } +decltype(i(h())) g7(); // { dg-error "" } diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist40.C b/gcc/testsuite/g++.dg/cpp0x/initlist40.C index f2703602c9e..8cf36be1ca1 100644 --- a/gcc/testsuite/g++.dg/cpp0x/initlist40.C +++ b/gcc/testsuite/g++.dg/cpp0x/initlist40.C @@ -1,3 +1,4 @@ +// PR c++/54835, DR 1518 // { dg-options "-std=c++0x" } struct A @@ -7,6 +8,6 @@ struct A int main() { - A a1 = { }; + A a1 = { }; // { dg-error "explicit" } A a2 = { 24 }; // { dg-error "explicit" } } diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv8.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv8.C new file mode 100644 index 00000000000..abe272a8b8b --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv8.C @@ -0,0 +1,15 @@ +// PR c++/56447 +// { dg-do compile { target c++11 } } + +template <class T> +void f() +{ + int i; + // This lambda should not have a conversion op, since it captures i + int (*p)() = [=]{ return i; }; // { dg-error "cannot convert" } +} + +int main() +{ + f<int>(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-defarg4.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-defarg4.C new file mode 100644 index 00000000000..2217954596b --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-defarg4.C @@ -0,0 +1,8 @@ +// PR c++/54764 +// { dg-require-effective-target c++11 } + +template<class T = void> +struct c +{ + int (*f)(int) = [](int i){return i + i;}; +}; diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-mutable2.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-mutable2.C new file mode 100644 index 00000000000..c54ff5c841c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-mutable2.C @@ -0,0 +1,23 @@ +// PR c++/55532 +// { dg-do compile { target c++11 } } + +struct Foo { + void doit() { + } +}; + +template<typename T> +void oops(Foo &foo, const T &) { + auto fun = [&] () mutable { + foo.doit(); + }; + auto fun2 = [=]() { + fun(); // { dg-error "" } + }; + fun2(); +} + +int main() { + Foo foo; + oops(foo, 1); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi3.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi3.C new file mode 100644 index 00000000000..da7e0bfed20 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi3.C @@ -0,0 +1,9 @@ +// PR c++/55972 +// { dg-do compile { target c++11 } } + +class C +{ + void f(); + int j = 10; + int i = [this]() { return this->j; }(); +}; diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-sfinae1.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-sfinae1.C new file mode 100644 index 00000000000..973f8a78048 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-sfinae1.C @@ -0,0 +1,55 @@ +// PR c++/56039 +// { dg-do compile { target c++11 } } + +template <bool> struct BoolSink { typedef void type; }; + +template <typename T, typename U> +struct AddRvalueReferenceImpl { typedef T type; }; + +template <typename T> +struct AddRvalueReferenceImpl<T, typename BoolSink<false && + [] { + extern T &&tref; + }>::type> { // { dg-error "lambda" } + typedef T &&type; +}; + +template <typename T> +struct AddRvalueReference : AddRvalueReferenceImpl<T, void> { }; + +namespace ImplHelpers { + template <typename T> + typename AddRvalueReference<T>::type create(void) { } +} + +template <typename T, typename U, typename ...Args> +struct IsConstructibleImpl { enum { value = 0 }; }; + +template <typename T, typename ...Args> +struct IsConstructibleImpl<T, typename BoolSink<false && + [] { + T t( ::ImplHelpers::create<Args>() ...); + }>::type, Args ...> { // { dg-error "lambda" } + enum { value = 1 }; +}; + +template <typename T, typename ...Args> +struct IsConstructible : IsConstructibleImpl<T, void, Args ...> { }; + +struct DestroyMe { + ~DestroyMe() = delete; +}; + +static_assert(+IsConstructible<int>::value, "error"); +static_assert(!IsConstructible<void>::value, "error"); +static_assert(+IsConstructible<int [1]>::value, "error"); +static_assert(!IsConstructible<DestroyMe>::value, "error"); +static_assert(!IsConstructible<int *, char *>::value, "error"); + +static_assert(+IsConstructible<int &&, int>::value, "error"); +static_assert(!IsConstructible<int &&, int &>::value, "error"); +static_assert(+IsConstructible<int &&, int &&>::value, "error"); + +// { dg-prune-output "expected" } +// { dg-prune-output "does not name a class" } +// { dg-prune-output "static assertion" } diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-shadow1.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-shadow1.C new file mode 100644 index 00000000000..bb06bfe4afa --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-shadow1.C @@ -0,0 +1,9 @@ +// PR c++/55357 +// { dg-options "-std=c++11 -Wshadow" } + +int main() { + int x = 1; // { dg-warning "shadowed" } + auto const lambda = [](int x) { // { dg-warning "shadows" } + return x; + }; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this13.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this13.C new file mode 100644 index 00000000000..090d0a13e1d --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this13.C @@ -0,0 +1,20 @@ +// PR c++/52374 +// { dg-do compile { target c++11 } } + +struct B +{ + int get() const { return 42; } +}; + +template<typename X> +struct D + : public X +{ + int get() const { return [this]() -> int { return X::get(); }(); } +}; + +int main() +{ + D<B> d; + d.get(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this9.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this9.C new file mode 100644 index 00000000000..07ddd0863de --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this9.C @@ -0,0 +1,19 @@ +// PR c++/54277 +// { dg-do compile { target c++11 } } + +struct Used +{ + void foo() { } +}; + +template <typename> +struct S +{ + Used x; + + void bar() + { + auto f = [this] { x.foo(); }; + f(); + } +}; diff --git a/gcc/testsuite/g++.dg/cpp0x/nsdmi-local.C b/gcc/testsuite/g++.dg/cpp0x/nsdmi-local.C new file mode 100644 index 00000000000..9b84c8c3ded --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/nsdmi-local.C @@ -0,0 +1,8 @@ +// PR c++/55240 +// { dg-do compile { target c++11 } } + +int main() +{ + int q = 1; // { dg-error "declared here" } + struct test { int x = q; } instance; // { dg-error "local variable" } +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv-copy1.C b/gcc/testsuite/g++.dg/cpp0x/rv-copy1.C new file mode 100644 index 00000000000..70d3d719222 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv-copy1.C @@ -0,0 +1,10 @@ +// PR c++/55017 +// { dg-do compile { target c++11 } } + +struct S { // { dg-error "rvalue ref" } + int&& rr; + S(int&& rr) : rr(static_cast<int&&>(rr)) {} +}; + +S s1(13); +S s2 = s1; // { dg-error "deleted" } diff --git a/gcc/testsuite/g++.dg/cpp0x/trailing8.C b/gcc/testsuite/g++.dg/cpp0x/trailing8.C new file mode 100644 index 00000000000..304845e66d8 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/trailing8.C @@ -0,0 +1,25 @@ +// PR c++/54359 +// { dg-require-effective-target c++11 } + +int& ref(int& x) { return x; } +const int& ref(const int& x) { return x; } + +class A { + int x; + int f() const; + auto test1() const -> decltype(this); + auto test2() const -> decltype(ref(x)); + auto test3() const -> decltype(f()); +}; + +auto A::test1() const -> decltype(this) { + return this; +} + +auto A::test2() const -> decltype(ref(x)) { + return ref(x); +} + +auto A::test3() const -> decltype(f()) { + return f(); +} diff --git a/gcc/testsuite/g++.dg/diagnostic/variadic1.C b/gcc/testsuite/g++.dg/diagnostic/variadic1.C new file mode 100644 index 00000000000..69f1f988f30 --- /dev/null +++ b/gcc/testsuite/g++.dg/diagnostic/variadic1.C @@ -0,0 +1,9 @@ +// PR c++/55241 +// { dg-do compile { target c++11 } } + +template<int N> struct B { }; +template<typename... T> struct A +{ + B<sizeof...(T)> f(); // { dg-error "sizeof\\.\\.\\." } + B<42> f(); // { dg-error "cannot be overloaded" } +}; diff --git a/gcc/testsuite/g++.dg/ipa/devirt-12.C b/gcc/testsuite/g++.dg/ipa/devirt-12.C new file mode 100644 index 00000000000..2fdf5c49b77 --- /dev/null +++ b/gcc/testsuite/g++.dg/ipa/devirt-12.C @@ -0,0 +1,22 @@ +// { dg-do compile } +// { dg-options "-std=c++11 -O -fdump-ipa-inline" } + +class Foo +{ +public: + void Bar() const + { + __builtin_puts ("Howdy!"); + } +}; + +int main() +{ + Foo x; + auto y = &Foo::Bar; + (x.*y)(); + return 0; +} + +// { dg-final { scan-ipa-dump "Inlined 1 calls, eliminated 1 functions" "inline" } } +// { dg-final { cleanup-ipa-dump "inline" } } diff --git a/gcc/testsuite/g++.dg/other/abstract5.C b/gcc/testsuite/g++.dg/other/abstract5.C new file mode 100644 index 00000000000..d13dd9e5160 --- /dev/null +++ b/gcc/testsuite/g++.dg/other/abstract5.C @@ -0,0 +1,6 @@ +struct A +{ + virtual void f() = 0; +}; + +typedef A (*fp)(); // { dg-error "abstract" } diff --git a/gcc/testsuite/g++.dg/parse/typename7.C b/gcc/testsuite/g++.dg/parse/typename7.C index 2d823f8078e..6ec76961013 100644 --- a/gcc/testsuite/g++.dg/parse/typename7.C +++ b/gcc/testsuite/g++.dg/parse/typename7.C @@ -22,7 +22,7 @@ struct B A().bar<typename T>(t); } // { dg-error "expected|parse error|no matching" } // { dg-message "candidate" "candidate note" { target *-*-* } 22 } void bad(T t) { - B<typename T>::bar(t); } // { dg-error "invalid|not a template" } + B<typename T>::bar(t); } // { dg-error "invalid|qualified-id|not a template" } }; void baz() diff --git a/gcc/testsuite/g++.dg/template/abstract-dr337.C b/gcc/testsuite/g++.dg/template/abstract-dr337.C new file mode 100644 index 00000000000..4f66c1c1188 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/abstract-dr337.C @@ -0,0 +1,13 @@ +// PR c++/17232 (DR 337) + +template<typename T> +class A { + virtual void f() = 0; +}; + +template<typename T> +void g(T (*a)[1]) {} // { dg-error "abstract" "" { xfail *-*-* } } + +int main() { + g<A<int> >(0); // { dg-error "no matching function" "" { xfail *-*-* } } +} diff --git a/gcc/testsuite/g++.dg/template/access26.C b/gcc/testsuite/g++.dg/template/access26.C new file mode 100644 index 00000000000..1c5de9a8fd2 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/access26.C @@ -0,0 +1,6 @@ +// PR c++/45917 + +template < typename T > +struct A { static int i; }; +class B { typedef int X; }; // { dg-error "private" } +void f() { A<B::X>::i = 0; } // { dg-error "this context" } diff --git a/gcc/testsuite/g++.dg/template/arrow2.C b/gcc/testsuite/g++.dg/template/arrow2.C new file mode 100644 index 00000000000..8ec9e01d0de --- /dev/null +++ b/gcc/testsuite/g++.dg/template/arrow2.C @@ -0,0 +1,12 @@ +// PR c++/56639 + +struct A { + int i; + static A* f(); +}; + +struct B { + void g() { + int (A::f()->i); + } +}; diff --git a/gcc/testsuite/g++.dg/template/sfinae-dr657.C b/gcc/testsuite/g++.dg/template/sfinae-dr657.C new file mode 100644 index 00000000000..b78b5a919c1 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae-dr657.C @@ -0,0 +1,22 @@ +// DR 657 +// Test that a return or parameter type with abstract class type causes a +// deduction failure. + +struct A +{ + A(); + A(int); + virtual void f() = 0; +}; + +template<class T> T declval(); +template<class T> int declval(...); + +template<class T> void arg(T); +template<class T> int arg(...); + +int main() +{ + int i = declval<A>(); + i = arg<A>(1); +} diff --git a/gcc/testsuite/g++.dg/torture/pr56635.C b/gcc/testsuite/g++.dg/torture/pr56635.C new file mode 100644 index 00000000000..53d6bb96ad5 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr56635.C @@ -0,0 +1,17 @@ +// PR tree-optimization/56635 +// { dg-do compile } + +struct A { _Complex double a; }; + +void +foo (A **x, A **y) +{ + A r; + if (__real__ x[0]->a) + { + r.a = y[0]->a / x[0]->a; + **x = r; + } + else + **x = **y; +} diff --git a/gcc/testsuite/g++.dg/warn/Wdiv-by-zero-2.C b/gcc/testsuite/g++.dg/warn/Wdiv-by-zero-2.C new file mode 100644 index 00000000000..d7e226ce0a5 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wdiv-by-zero-2.C @@ -0,0 +1,34 @@ +// PR c++/56607 +// { dg-do compile { target { { lp64 || ilp32 } || llp64 } } } +// { dg-options "-O2 -Wdiv-by-zero -std=c++11" } + +constexpr int sc () { return sizeof (char); } +constexpr int si () { return sizeof (int); } +constexpr int zc () { return sc () - 1; } +constexpr int zi (int d) { return si () / d - 1; } + +int +f1 (void) +{ + return 1 / zc (); // { dg-warning "division by zero" } +} + +int +f2 (void) +{ + constexpr int x = zc (); + return 1 / x; // { dg-warning "division by zero" } +} + +int +f3 (void) +{ + return 1 / zi (3); // { dg-warning "division by zero" } +} + +int +f4 (void) +{ + constexpr int x = zi (3); + return 1 / x; // { dg-warning "division by zero" } +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c index bf4f0f39e1e..d8c5841eb58 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp47.c @@ -4,7 +4,7 @@ jumps when evaluating an && condition. VRP is not able to optimize this. */ /* { dg-do compile { target { ! "mips*-*-* s390*-*-* avr-*-* mn10300-*-*" } } } */ -/* { dg-options "-O2 -fdump-tree-vrp1 -fdump-tree-dom1 -fdump-tree-dom2" } */ +/* { dg-options "-O2 -fdump-tree-vrp1 -fdump-tree-dom1 -fdump-tree-vrp2" } */ /* { dg-additional-options "-march=i586" { target { { i?86-*-* x86_64-*-* } && ia32 } } } */ /* Skip on ARM Cortex-M0, where LOGICAL_OP_NON_SHORT_CIRCUIT is set to false, leading to two conditional jumps when evaluating an && condition. VRP is @@ -40,15 +40,14 @@ int f(int x) 0 or 1. */ /* { dg-final { scan-tree-dump-times "\[xy\]\[^ \]* !=" 0 "vrp1" } } */ -/* This one needs more copy propagation that only happens in dom1. */ -/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "dom1" { xfail *-*-* } } } */ -/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "dom2" } } */ -/* { dg-final { scan-tree-dump-times "x\[^ \]* & y" 1 "vrp1" { xfail *-*-* } } } */ - -/* These two are fully simplified by VRP. */ +/* These two are fully simplified by VRP1. */ /* { dg-final { scan-tree-dump-times "x\[^ \]* \[|\] y" 1 "vrp1" } } */ /* { dg-final { scan-tree-dump-times "x\[^ \]* \\^ 1" 1 "vrp1" } } */ +/* VRP2 gets rid of the remaining & 1 operations, x and y are always + either 0 or 1. */ +/* { dg-final { scan-tree-dump-times " & 1;" 0 "vrp2" } } */ + /* { dg-final { cleanup-tree-dump "vrp1" } } */ /* { dg-final { cleanup-tree-dump "dom1" } } */ -/* { dg-final { cleanup-tree-dump "dom2" } } */ +/* { dg-final { cleanup-tree-dump "vrp2" } } */ diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index ebb7f306f7f..a387d8202e6 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -4257,11 +4257,11 @@ compute_all_dependences (vec<data_reference_p> datarefs, typedef struct data_ref_loc_d { - /* Position of the memory reference. */ - tree *pos; + /* Position of the memory reference. */ + tree *pos; - /* True if the memory reference is read. */ - bool is_read; + /* True if the memory reference is read. */ + bool is_read; } data_ref_loc; @@ -4269,15 +4269,13 @@ typedef struct data_ref_loc_d true if STMT clobbers memory, false otherwise. */ static bool -get_references_in_stmt (gimple stmt, vec<data_ref_loc> *references) +get_references_in_stmt (gimple stmt, vec<data_ref_loc, va_stack> *references) { bool clobbers_memory = false; data_ref_loc ref; tree *op0, *op1; enum gimple_code stmt_code = gimple_code (stmt); - references->create (0); - /* ASM_EXPR and CALL_EXPR may embed arbitrary side effects. As we cannot model data-references to not spelled out accesses give up if they may occur. */ @@ -4348,11 +4346,12 @@ find_data_references_in_stmt (struct loop *nest, gimple stmt, vec<data_reference_p> *datarefs) { unsigned i; - vec<data_ref_loc> references; + vec<data_ref_loc, va_stack> references; data_ref_loc *ref; bool ret = true; data_reference_p dr; + vec_stack_alloc (data_ref_loc, references, 2); if (get_references_in_stmt (stmt, &references)) { references.release (); @@ -4381,11 +4380,12 @@ graphite_find_data_references_in_stmt (loop_p nest, loop_p loop, gimple stmt, vec<data_reference_p> *datarefs) { unsigned i; - vec<data_ref_loc> references; + vec<data_ref_loc, va_stack> references; data_ref_loc *ref; bool ret = true; data_reference_p dr; + vec_stack_alloc (data_ref_loc, references, 2); if (get_references_in_stmt (stmt, &references)) { references.release (); @@ -4437,7 +4437,7 @@ find_data_references_in_bb (struct loop *loop, basic_block bb, TODO: This function should be made smarter so that it can handle address arithmetic as if they were array accesses, etc. */ -static tree +tree find_data_references_in_loop (struct loop *loop, vec<data_reference_p> *datarefs) { @@ -5005,7 +5005,7 @@ create_rdg_vertices (struct graph *rdg, vec<gimple> stmts, loop_p loop) FOR_EACH_VEC_ELT (stmts, i, stmt) { - vec<data_ref_loc> references; + vec<data_ref_loc, va_stack> references; data_ref_loc *ref; struct vertex *v = &(rdg->vertices[i]); @@ -5020,6 +5020,7 @@ create_rdg_vertices (struct graph *rdg, vec<gimple> stmts, loop_p loop) if (gimple_code (stmt) == GIMPLE_PHI) continue; + vec_stack_alloc (data_ref_loc, references, 2); get_references_in_stmt (stmt, &references); FOR_EACH_VEC_ELT (references, j, ref) { diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h index 93a75f2ef79..c5d3e86c0d1 100644 --- a/gcc/tree-data-ref.h +++ b/gcc/tree-data-ref.h @@ -382,6 +382,7 @@ extern bool find_data_references_in_stmt (struct loop *, gimple, vec<data_reference_p> *); extern bool graphite_find_data_references_in_stmt (loop_p, loop_p, gimple, vec<data_reference_p> *); +tree find_data_references_in_loop (struct loop *, vec<data_reference_p> *); struct data_reference *create_data_ref (loop_p, loop_p, tree, gimple, bool); extern bool find_loop_nest (struct loop *, vec<loop_p> *); extern struct data_dependence_relation *initialize_data_dependence_relation diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c index 2df27dda3c7..878d8407185 100644 --- a/gcc/tree-ssa-alias.c +++ b/gcc/tree-ssa-alias.c @@ -1314,6 +1314,43 @@ ref_maybe_used_by_call_p_1 (gimple call, ao_ref *ref) size); return refs_may_alias_p_1 (&dref, ref, false); } + /* These read memory pointed to by the first argument. */ + case BUILT_IN_INDEX: + case BUILT_IN_STRCHR: + case BUILT_IN_STRRCHR: + { + ao_ref dref; + ao_ref_init_from_ptr_and_size (&dref, + gimple_call_arg (call, 0), + NULL_TREE); + return refs_may_alias_p_1 (&dref, ref, false); + } + /* These read memory pointed to by the first argument with size + in the third argument. */ + case BUILT_IN_MEMCHR: + { + ao_ref dref; + ao_ref_init_from_ptr_and_size (&dref, + gimple_call_arg (call, 0), + gimple_call_arg (call, 2)); + return refs_may_alias_p_1 (&dref, ref, false); + } + /* These read memory pointed to by the first and second arguments. */ + case BUILT_IN_STRSTR: + case BUILT_IN_STRPBRK: + { + ao_ref dref; + ao_ref_init_from_ptr_and_size (&dref, + gimple_call_arg (call, 0), + NULL_TREE); + if (refs_may_alias_p_1 (&dref, ref, false)) + return true; + ao_ref_init_from_ptr_and_size (&dref, + gimple_call_arg (call, 1), + NULL_TREE); + return refs_may_alias_p_1 (&dref, ref, false); + } + /* The following builtins do not read from memory. */ case BUILT_IN_FREE: case BUILT_IN_MALLOC: diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 78ad0733016..9dc40451c1d 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -117,10 +117,14 @@ typedef struct mem_ref_locs typedef struct mem_ref { - tree mem; /* The memory itself. */ unsigned id; /* ID assigned to the memory reference (its index in memory_accesses.refs_list) */ hashval_t hash; /* Its hash value. */ + + /* The memory access itself and associated caching of alias-oracle + query meta-data. */ + ao_ref mem; + bitmap stored; /* The set of loops in that this memory location is stored to. */ vec<mem_ref_locs_p> accesses_in_loop; @@ -186,7 +190,7 @@ static bool ref_indep_loop_p (struct loop *, mem_ref_p); #define SET_ALWAYS_EXECUTED_IN(BB, VAL) ((BB)->aux = (void *) (VAL)) /* Whether the reference was analyzable. */ -#define MEM_ANALYZABLE(REF) ((REF)->mem != error_mark_node) +#define MEM_ANALYZABLE(REF) ((REF)->mem.ref != error_mark_node) static struct lim_aux_data * init_lim_data (gimple stmt) @@ -1449,7 +1453,7 @@ memref_eq (const void *obj1, const void *obj2) { const struct mem_ref *const mem1 = (const struct mem_ref *) obj1; - return operand_equal_p (mem1->mem, (const_tree) obj2, 0); + return operand_equal_p (mem1->mem.ref, (const_tree) obj2, 0); } /* Releases list of memory reference locations ACCS. */ @@ -1491,7 +1495,7 @@ static mem_ref_p mem_ref_alloc (tree mem, unsigned hash, unsigned id) { mem_ref_p ref = XNEW (struct mem_ref); - ref->mem = mem; + ao_ref_init (&ref->mem, mem); ref->id = id; ref->hash = hash; ref->stored = BITMAP_ALLOC (&lim_bitmap_obstack); @@ -1606,7 +1610,7 @@ gather_mem_refs_stmt (struct loop *loop, gimple stmt) if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Memory reference %u: ", id); - print_generic_expr (dump_file, ref->mem, TDF_SLIM); + print_generic_expr (dump_file, ref->mem.ref, TDF_SLIM); fprintf (dump_file, "\n"); } } @@ -1730,7 +1734,8 @@ analyze_memory_references (void) tree_to_aff_combination_expand. */ static bool -mem_refs_may_alias_p (tree mem1, tree mem2, struct pointer_map_t **ttae_cache) +mem_refs_may_alias_p (mem_ref_p mem1, mem_ref_p mem2, + struct pointer_map_t **ttae_cache) { /* Perform BASE + OFFSET analysis -- if MEM1 and MEM2 are based on the same object and their offset differ in such a way that the locations cannot @@ -1739,7 +1744,7 @@ mem_refs_may_alias_p (tree mem1, tree mem2, struct pointer_map_t **ttae_cache) aff_tree off1, off2; /* Perform basic offset and type-based disambiguation. */ - if (!refs_may_alias_p (mem1, mem2)) + if (!refs_may_alias_p_1 (&mem1->mem, &mem2->mem, true)) return false; /* The expansion of addresses may be a bit expensive, thus we only do @@ -1747,8 +1752,8 @@ mem_refs_may_alias_p (tree mem1, tree mem2, struct pointer_map_t **ttae_cache) if (optimize < 2) return true; - get_inner_reference_aff (mem1, &off1, &size1); - get_inner_reference_aff (mem2, &off2, &size2); + get_inner_reference_aff (mem1->mem.ref, &off1, &size1); + get_inner_reference_aff (mem2->mem.ref, &off2, &size2); aff_combination_expand (&off1, ttae_cache); aff_combination_expand (&off2, ttae_cache); aff_combination_scale (&off1, double_int_minus_one); @@ -2079,7 +2084,7 @@ execute_sm_if_changed_flag_set (struct loop *loop, mem_ref_p ref) mem_ref_loc_p loc; tree flag; vec<mem_ref_loc_p> locs = vNULL; - char *str = get_lsm_tmp_name (ref->mem, ~0); + char *str = get_lsm_tmp_name (ref->mem.ref, ~0); lsm_tmp_name_add ("_flag"); flag = create_tmp_reg (boolean_type_node, str); @@ -2121,16 +2126,16 @@ execute_sm (struct loop *loop, vec<edge> exits, mem_ref_p ref) if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Executing store motion of "); - print_generic_expr (dump_file, ref->mem, 0); + print_generic_expr (dump_file, ref->mem.ref, 0); fprintf (dump_file, " from loop %d\n", loop->num); } - tmp_var = create_tmp_reg (TREE_TYPE (ref->mem), - get_lsm_tmp_name (ref->mem, ~0)); + tmp_var = create_tmp_reg (TREE_TYPE (ref->mem.ref), + get_lsm_tmp_name (ref->mem.ref, ~0)); fmt_data.loop = loop; fmt_data.orig_loop = loop; - for_each_index (&ref->mem, force_move_till, &fmt_data); + for_each_index (&ref->mem.ref, force_move_till, &fmt_data); if (block_in_transaction (loop_preheader_edge (loop)->src) || !PARAM_VALUE (PARAM_ALLOW_STORE_DATA_RACES)) @@ -2148,7 +2153,7 @@ execute_sm (struct loop *loop, vec<edge> exits, mem_ref_p ref) /* FIXME/TODO: For the multi-threaded variant, we could avoid this load altogether, since the store is predicated by a flag. We could, do the load only if it was originally in the loop. */ - load = gimple_build_assign (tmp_var, unshare_expr (ref->mem)); + load = gimple_build_assign (tmp_var, unshare_expr (ref->mem.ref)); lim_data = init_lim_data (load); lim_data->max_loop = loop; lim_data->tgt_loop = loop; @@ -2168,11 +2173,11 @@ execute_sm (struct loop *loop, vec<edge> exits, mem_ref_p ref) if (!multi_threaded_model_p) { gimple store; - store = gimple_build_assign (unshare_expr (ref->mem), tmp_var); + store = gimple_build_assign (unshare_expr (ref->mem.ref), tmp_var); gsi_insert_on_edge (ex, store); } else - execute_sm_if_changed (ex, ref->mem, tmp_var, store_flag); + execute_sm_if_changed (ex, ref->mem.ref, tmp_var, store_flag); } /* Hoists memory references MEM_REFS out of LOOP. EXITS is the list of exit @@ -2206,9 +2211,8 @@ ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p) struct loop *must_exec; tree base; - base = get_base_address (ref->mem); - if (INDIRECT_REF_P (base) - || TREE_CODE (base) == MEM_REF) + base = ao_ref_base (&ref->mem); + if (TREE_CODE (base) == MEM_REF) base = TREE_OPERAND (base, 0); get_all_locs_in_loop (loop, ref, &locs); @@ -2255,24 +2259,33 @@ ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p) static bool refs_independent_p (mem_ref_p ref1, mem_ref_p ref2) { - if (ref1 == ref2 - || bitmap_bit_p (ref1->indep_ref, ref2->id)) + if (ref1 == ref2) return true; - if (bitmap_bit_p (ref1->dep_ref, ref2->id)) - return false; + if (!MEM_ANALYZABLE (ref1) || !MEM_ANALYZABLE (ref2)) return false; + /* Reference dependence in a loop is symmetric. */ + if (ref1->id > ref2->id) + { + mem_ref_p tem = ref1; + ref1 = ref2; + ref2 = tem; + } + + if (bitmap_bit_p (ref1->indep_ref, ref2->id)) + return true; + if (bitmap_bit_p (ref1->dep_ref, ref2->id)) + return false; + if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Querying dependency of refs %u and %u: ", ref1->id, ref2->id); - if (mem_refs_may_alias_p (ref1->mem, ref2->mem, - &memory_accesses.ttae_cache)) + if (mem_refs_may_alias_p (ref1, ref2, &memory_accesses.ttae_cache)) { bitmap_set_bit (ref1->dep_ref, ref2->id); - bitmap_set_bit (ref2->dep_ref, ref1->id); if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "dependent.\n"); return false; @@ -2280,7 +2293,6 @@ refs_independent_p (mem_ref_p ref1, mem_ref_p ref2) else { bitmap_set_bit (ref1->indep_ref, ref2->id); - bitmap_set_bit (ref2->indep_ref, ref1->id); if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "independent.\n"); return true; @@ -2371,21 +2383,21 @@ can_sm_ref_p (struct loop *loop, mem_ref_p ref) return false; /* It should be movable. */ - if (!is_gimple_reg_type (TREE_TYPE (ref->mem)) - || TREE_THIS_VOLATILE (ref->mem) - || !for_each_index (&ref->mem, may_move_till, loop)) + if (!is_gimple_reg_type (TREE_TYPE (ref->mem.ref)) + || TREE_THIS_VOLATILE (ref->mem.ref) + || !for_each_index (&ref->mem.ref, may_move_till, loop)) return false; /* If it can throw fail, we do not properly update EH info. */ - if (tree_could_throw_p (ref->mem)) + if (tree_could_throw_p (ref->mem.ref)) return false; /* If it can trap, it must be always executed in LOOP. Readonly memory locations may trap when storing to them, but tree_could_trap_p is a predicate for rvalues, so check that explicitly. */ - base = get_base_address (ref->mem); - if ((tree_could_trap_p (ref->mem) + base = get_base_address (ref->mem.ref); + if ((tree_could_trap_p (ref->mem.ref) || (DECL_P (base) && TREE_READONLY (base))) && !ref_always_accessed_p (loop, ref, true)) return false; diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c index 4645588d3e7..a0516c45c4a 100644 --- a/gcc/tree-ssa-loop-manip.c +++ b/gcc/tree-ssa-loop-manip.c @@ -443,21 +443,12 @@ find_uses_to_rename (bitmap changed_bbs, bitmap *use_blocks, bitmap need_phis) unsigned index; bitmap_iterator bi; - /* ??? If CHANGED_BBS is empty we rewrite the whole function -- why? */ - if (changed_bbs && !bitmap_empty_p (changed_bbs)) - { - EXECUTE_IF_SET_IN_BITMAP (changed_bbs, 0, index, bi) - { - find_uses_to_rename_bb (BASIC_BLOCK (index), use_blocks, need_phis); - } - } + if (changed_bbs) + EXECUTE_IF_SET_IN_BITMAP (changed_bbs, 0, index, bi) + find_uses_to_rename_bb (BASIC_BLOCK (index), use_blocks, need_phis); else - { - FOR_EACH_BB (bb) - { - find_uses_to_rename_bb (bb, use_blocks, need_phis); - } - } + FOR_EACH_BB (bb) + find_uses_to_rename_bb (bb, use_blocks, need_phis); } /* Rewrites the program into a loop closed ssa form -- i.e. inserts extra diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c index edc04eaa014..fdfb9e71262 100644 --- a/gcc/tree-ssa-loop.c +++ b/gcc/tree-ssa-loop.c @@ -245,8 +245,7 @@ struct gimple_opt_pass pass_vectorize = 0, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ - TODO_update_ssa - | TODO_ggc_collect /* todo_flags_finish */ + TODO_ggc_collect /* todo_flags_finish */ } }; diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index c63aa2d0eca..8360cc73000 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -2652,18 +2652,13 @@ static tree valueize_expr (tree expr); static bool visit_copy (tree lhs, tree rhs) { - /* Follow chains of copies to their destination. */ - while (TREE_CODE (rhs) == SSA_NAME - && SSA_VAL (rhs) != rhs) - rhs = SSA_VAL (rhs); - /* The copy may have a more interesting constant filled expression (we don't, since we know our RHS is just an SSA name). */ - if (TREE_CODE (rhs) == SSA_NAME) - { - VN_INFO (lhs)->has_constants = VN_INFO (rhs)->has_constants; - VN_INFO (lhs)->expr = VN_INFO (rhs)->expr; - } + VN_INFO (lhs)->has_constants = VN_INFO (rhs)->has_constants; + VN_INFO (lhs)->expr = VN_INFO (rhs)->expr; + + /* And finally valueize. */ + rhs = SSA_VAL (rhs); return set_ssa_val_to (lhs, rhs); } @@ -3062,25 +3057,38 @@ expr_has_constants (tree expr) static bool stmt_has_constants (gimple stmt) { + tree tem; + if (gimple_code (stmt) != GIMPLE_ASSIGN) return false; switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))) { - case GIMPLE_UNARY_RHS: - return is_gimple_min_invariant (gimple_assign_rhs1 (stmt)); + case GIMPLE_TERNARY_RHS: + tem = gimple_assign_rhs3 (stmt); + if (TREE_CODE (tem) == SSA_NAME) + tem = SSA_VAL (tem); + if (is_gimple_min_invariant (tem)) + return true; + /* Fallthru. */ case GIMPLE_BINARY_RHS: - return (is_gimple_min_invariant (gimple_assign_rhs1 (stmt)) - || is_gimple_min_invariant (gimple_assign_rhs2 (stmt))); - case GIMPLE_TERNARY_RHS: - return (is_gimple_min_invariant (gimple_assign_rhs1 (stmt)) - || is_gimple_min_invariant (gimple_assign_rhs2 (stmt)) - || is_gimple_min_invariant (gimple_assign_rhs3 (stmt))); + tem = gimple_assign_rhs2 (stmt); + if (TREE_CODE (tem) == SSA_NAME) + tem = SSA_VAL (tem); + if (is_gimple_min_invariant (tem)) + return true; + /* Fallthru. */ + case GIMPLE_SINGLE_RHS: /* Constants inside reference ops are rarely interesting, but it can take a lot of looking to find them. */ - return is_gimple_min_invariant (gimple_assign_rhs1 (stmt)); + case GIMPLE_UNARY_RHS: + tem = gimple_assign_rhs1 (stmt); + if (TREE_CODE (tem) == SSA_NAME) + tem = SSA_VAL (tem); + return is_gimple_min_invariant (tem); + default: gcc_unreachable (); } diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 31a4c49c66c..6bcd4b50f8f 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -581,7 +581,7 @@ static constraint_graph_t graph; static unsigned int find (unsigned int node) { - gcc_assert (node < graph->size); + gcc_checking_assert (node < graph->size); if (graph->rep[node] != node) return graph->rep[node] = find (graph->rep[node]); return node; @@ -595,7 +595,7 @@ find (unsigned int node) static bool unite (unsigned int to, unsigned int from) { - gcc_assert (to < graph->size && from < graph->size); + gcc_checking_assert (to < graph->size && from < graph->size); if (to != from && graph->rep[from] != to) { graph->rep[from] = to; @@ -1023,7 +1023,7 @@ merge_node_constraints (constraint_graph_t graph, unsigned int to, unsigned int i; constraint_t c; - gcc_assert (find (from) == to); + gcc_checking_assert (find (from) == to); /* Move all complex constraints from src node into to node */ FOR_EACH_VEC_ELT (graph->complex[from], i, c) @@ -1143,16 +1143,6 @@ add_graph_edge (constraint_graph_t graph, unsigned int to, } -/* Return true if {DEST.SRC} is an existing graph edge in GRAPH. */ - -static bool -valid_graph_edge (constraint_graph_t graph, unsigned int src, - unsigned int dest) -{ - return (graph->succs[dest] - && bitmap_bit_p (graph->succs[dest], src)); -} - /* Initialize the constraint graph structure to contain SIZE nodes. */ static void @@ -1319,7 +1309,7 @@ build_succ_graph (void) else if (rhs.type == ADDRESSOF) { /* x = &y */ - gcc_assert (find (rhs.var) == rhs.var); + gcc_checking_assert (find (rhs.var) == rhs.var); bitmap_set_bit (get_varinfo (lhsvar)->solution, rhsvar); } else if (lhsvar > anything_id @@ -1396,14 +1386,11 @@ scc_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) if (!bitmap_bit_p (si->visited, w)) scc_visit (graph, si, w); - { - unsigned int t = find (w); - unsigned int nnode = find (n); - gcc_assert (nnode == n); - if (si->dfs[t] < si->dfs[nnode]) - si->dfs[n] = si->dfs[t]; - } + unsigned int t = find (w); + gcc_checking_assert (find (n) == n); + if (si->dfs[t] < si->dfs[n]) + si->dfs[n] = si->dfs[t]; } /* See if any components have been identified. */ @@ -1458,8 +1445,8 @@ static void unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from, bool update_changed) { + gcc_checking_assert (to != from && find (to) == to); - gcc_assert (to != from && find (to) == to); if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Unifying %s to %s\n", get_varinfo (from)->name, @@ -1477,35 +1464,30 @@ unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from, as changed, decrease the changed count. */ if (update_changed - && bitmap_bit_p (changed, from)) - { - bitmap_clear_bit (changed, from); - bitmap_set_bit (changed, to); - } - if (get_varinfo (from)->solution) + && bitmap_clear_bit (changed, from)) + bitmap_set_bit (changed, to); + varinfo_t fromvi = get_varinfo (from); + if (fromvi->solution) { /* If the solution changes because of the merging, we need to mark the variable as changed. */ - if (bitmap_ior_into (get_varinfo (to)->solution, - get_varinfo (from)->solution)) + varinfo_t tovi = get_varinfo (to); + if (bitmap_ior_into (tovi->solution, fromvi->solution)) { if (update_changed) bitmap_set_bit (changed, to); } - BITMAP_FREE (get_varinfo (from)->solution); - if (get_varinfo (from)->oldsolution) - BITMAP_FREE (get_varinfo (from)->oldsolution); + BITMAP_FREE (fromvi->solution); + if (fromvi->oldsolution) + BITMAP_FREE (fromvi->oldsolution); if (stats.iterations > 0 - && get_varinfo (to)->oldsolution) - BITMAP_FREE (get_varinfo (to)->oldsolution); - } - if (valid_graph_edge (graph, to, to)) - { - if (graph->succs[to]) - bitmap_clear_bit (graph->succs[to], to); + && tovi->oldsolution) + BITMAP_FREE (tovi->oldsolution); } + if (graph->succs[to]) + bitmap_clear_bit (graph->succs[to], to); } /* Information needed to compute the topological ordering of a graph. */ @@ -1581,7 +1563,7 @@ do_sd_constraint (constraint_graph_t graph, constraint_t c, HOST_WIDE_INT roffset = c->rhs.offset; /* Our IL does not allow this. */ - gcc_assert (c->lhs.offset == 0); + gcc_checking_assert (c->lhs.offset == 0); /* If the solution of Y contains anything it is good enough to transfer this to the LHS. */ @@ -1668,7 +1650,7 @@ do_ds_constraint (constraint_t c, bitmap delta) bool escaped_p = false; /* Our IL does not allow this. */ - gcc_assert (c->rhs.offset == 0); + gcc_checking_assert (c->rhs.offset == 0); /* If the solution of y contains ANYTHING simply use the ANYTHING solution. This avoids needlessly increasing the points-to sets. */ @@ -1782,7 +1764,7 @@ do_complex_constraint (constraint_graph_t graph, constraint_t c, bitmap delta) bitmap solution; bool flag = false; - gcc_assert (c->rhs.type == SCALAR && c->lhs.type == SCALAR); + gcc_checking_assert (c->rhs.type == SCALAR && c->lhs.type == SCALAR); solution = get_varinfo (c->rhs.var)->solution; tmp = get_varinfo (c->lhs.var)->solution; @@ -1992,7 +1974,7 @@ condense_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) bitmap_iterator bi; unsigned int my_dfs; - gcc_assert (si->node_mapping[n] == n); + gcc_checking_assert (si->node_mapping[n] == n); bitmap_set_bit (si->visited, n); si->dfs[n] = si->current_index ++; my_dfs = si->dfs[n]; @@ -2007,14 +1989,11 @@ condense_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) if (!bitmap_bit_p (si->visited, w)) condense_visit (graph, si, w); - { - unsigned int t = si->node_mapping[w]; - unsigned int nnode = si->node_mapping[n]; - gcc_assert (nnode == n); - if (si->dfs[t] < si->dfs[nnode]) - si->dfs[n] = si->dfs[t]; - } + unsigned int t = si->node_mapping[w]; + gcc_checking_assert (si->node_mapping[n] == n); + if (si->dfs[t] < si->dfs[n]) + si->dfs[n] = si->dfs[t]; } /* Visit all the implicit predecessors. */ @@ -2027,14 +2006,11 @@ condense_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) if (!bitmap_bit_p (si->visited, w)) condense_visit (graph, si, w); - { - unsigned int t = si->node_mapping[w]; - unsigned int nnode = si->node_mapping[n]; - gcc_assert (nnode == n); - if (si->dfs[t] < si->dfs[nnode]) - si->dfs[n] = si->dfs[t]; - } + unsigned int t = si->node_mapping[w]; + gcc_assert (si->node_mapping[n] == n); + if (si->dfs[t] < si->dfs[n]) + si->dfs[n] = si->dfs[t]; } /* See if any components have been identified. */ @@ -2164,6 +2140,75 @@ label_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) } } +/* Print the pred graph in dot format. */ + +static void +dump_pred_graph (struct scc_info *si, FILE *file) +{ + unsigned int i; + + /* Only print the graph if it has already been initialized: */ + if (!graph) + return; + + /* Prints the header of the dot file: */ + fprintf (file, "strict digraph {\n"); + fprintf (file, " node [\n shape = box\n ]\n"); + fprintf (file, " edge [\n fontsize = \"12\"\n ]\n"); + fprintf (file, "\n // List of nodes and complex constraints in " + "the constraint graph:\n"); + + /* The next lines print the nodes in the graph together with the + complex constraints attached to them. */ + for (i = 0; i < graph->size; i++) + { + if (si->node_mapping[i] != i) + continue; + if (i < FIRST_REF_NODE) + fprintf (file, "\"%s\"", get_varinfo (i)->name); + else + fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); + if (graph->points_to[i] + && !bitmap_empty_p (graph->points_to[i])) + { + fprintf (file, "[label=\"%s = {", get_varinfo (i)->name); + unsigned j; + bitmap_iterator bi; + EXECUTE_IF_SET_IN_BITMAP (graph->points_to[i], 0, j, bi) + fprintf (file, " %d", j); + fprintf (file, " }\"]"); + } + fprintf (file, ";\n"); + } + + /* Go over the edges. */ + fprintf (file, "\n // Edges in the constraint graph:\n"); + for (i = 0; i < graph->size; i++) + { + unsigned j; + bitmap_iterator bi; + if (si->node_mapping[i] != i) + continue; + EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[i], 0, j, bi) + { + unsigned from = si->node_mapping[j]; + if (from < FIRST_REF_NODE) + fprintf (file, "\"%s\"", get_varinfo (from)->name); + else + fprintf (file, "\"*%s\"", get_varinfo (from - FIRST_REF_NODE)->name); + fprintf (file, " -> "); + if (i < FIRST_REF_NODE) + fprintf (file, "\"%s\"", get_varinfo (i)->name); + else + fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); + fprintf (file, ";\n"); + } + } + + /* Prints the tail of the dot file. */ + fprintf (file, "}\n"); +} + /* Perform offline variable substitution, discovering equivalence classes, and eliminating non-pointer variables. */ @@ -2188,6 +2233,14 @@ perform_var_substitution (constraint_graph_t graph) if (!bitmap_bit_p (si->visited, si->node_mapping[i])) condense_visit (graph, si, si->node_mapping[i]); + if (dump_file && (dump_flags & TDF_GRAPH)) + { + fprintf (dump_file, "\n\n// The constraint graph before var-substitution " + "in dot format:\n"); + dump_pred_graph (si, dump_file); + fprintf (dump_file, "\n\n"); + } + bitmap_clear (si->visited); /* Actually the label the nodes for pointer equivalences */ for (i = 0; i < FIRST_REF_NODE; i++) @@ -2303,7 +2356,7 @@ find_equivalent_node (constraint_graph_t graph, if (!bitmap_bit_p (graph->address_taken, node)) { - gcc_assert (label < graph->size); + gcc_checking_assert (label < graph->size); if (graph->eq_rep[label] != -1) { @@ -2320,7 +2373,7 @@ find_equivalent_node (constraint_graph_t graph, } else { - gcc_assert (label < graph->size); + gcc_checking_assert (label < graph->size); graph->pe[node] = label; if (graph->pe_rep[label] == -1) graph->pe_rep[label] = node; @@ -2400,11 +2453,12 @@ rewrite_constraints (constraint_graph_t graph, struct scc_info *si) { int i; - unsigned int j; constraint_t c; - for (j = 0; j < graph->size; j++) +#ifdef ENABLE_CHECKING + for (unsigned int j = 0; j < graph->size; j++) gcc_assert (find (j) == j); +#endif FOR_EACH_VEC_ELT (constraints, i, c) { @@ -2456,7 +2510,6 @@ rewrite_constraints (constraint_graph_t graph, rhsvar = find_equivalent_node (graph, rhsvar, rhslabel); c->lhs.var = lhsvar; c->rhs.var = rhsvar; - } } @@ -4196,6 +4249,29 @@ find_func_aliases_for_builtin_call (gimple t) return true; } break; + /* String / character search functions return a pointer into the + source string or NULL. */ + case BUILT_IN_INDEX: + case BUILT_IN_STRCHR: + case BUILT_IN_STRRCHR: + case BUILT_IN_MEMCHR: + case BUILT_IN_STRSTR: + case BUILT_IN_STRPBRK: + if (gimple_call_lhs (t)) + { + tree src = gimple_call_arg (t, 0); + get_constraint_for_ptr_offset (src, NULL_TREE, &rhsc); + constraint_expr nul; + nul.var = nothing_id; + nul.offset = 0; + nul.type = ADDRESSOF; + rhsc.safe_push (nul); + get_constraint_for (gimple_call_lhs (t), &lhsc); + process_all_all_constraints (lhsc, rhsc); + lhsc.release(); + rhsc.release(); + } + return true; /* Trampolines are special - they set up passing the static frame. */ case BUILT_IN_INIT_TRAMPOLINE: diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index fdb73c3212b..a4ad4f754a8 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -798,9 +798,21 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo, dump_printf_loc (MSG_NOTE, vect_location, "=== vect_analyze_dependences ==="); if (loop_vinfo) - ddrs = LOOP_VINFO_DDRS (loop_vinfo); + { + if (!compute_all_dependences (LOOP_VINFO_DATAREFS (loop_vinfo), + &LOOP_VINFO_DDRS (loop_vinfo), + LOOP_VINFO_LOOP_NEST (loop_vinfo), true)) + return false; + ddrs = LOOP_VINFO_DDRS (loop_vinfo); + } else - ddrs = BB_VINFO_DDRS (bb_vinfo); + { + if (!compute_all_dependences (BB_VINFO_DATAREFS (bb_vinfo), + &BB_VINFO_DDRS (bb_vinfo), + vNULL, true)) + return false; + ddrs = BB_VINFO_DDRS (bb_vinfo); + } FOR_EACH_VEC_ELT (ddrs, i, ddr) if (vect_analyze_data_ref_dependence (ddr, loop_vinfo, max_vf)) @@ -2941,7 +2953,6 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, vec<data_reference_p> datarefs; struct data_reference *dr; tree scalar_type; - bool res, stop_bb_analysis = false; if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, @@ -2950,13 +2961,9 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, if (loop_vinfo) { loop = LOOP_VINFO_LOOP (loop_vinfo); - res = compute_data_dependences_for_loop - (loop, true, - &LOOP_VINFO_LOOP_NEST (loop_vinfo), - &LOOP_VINFO_DATAREFS (loop_vinfo), - &LOOP_VINFO_DDRS (loop_vinfo)); - - if (!res) + if (!find_loop_nest (loop, &LOOP_VINFO_LOOP_NEST (loop_vinfo)) + || find_data_references_in_loop + (loop, &LOOP_VINFO_DATAREFS (loop_vinfo))) { if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, @@ -2987,17 +2994,6 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, break; } } - if (!compute_all_dependences (BB_VINFO_DATAREFS (bb_vinfo), - &BB_VINFO_DDRS (bb_vinfo), - vNULL, true)) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "not vectorized: basic block contains function" - " calls or data references that cannot be" - " analyzed"); - return false; - } datarefs = BB_VINFO_DATAREFS (bb_vinfo); } @@ -3024,12 +3020,6 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, stmt = DR_STMT (dr); stmt_info = vinfo_for_stmt (stmt); - if (stop_bb_analysis) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - continue; - } - /* Check that analysis of the data-ref succeeded. */ if (!DR_BASE_ADDRESS (dr) || !DR_OFFSET (dr) || !DR_INIT (dr) || !DR_STEP (dr)) @@ -3070,11 +3060,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; return false; } @@ -3088,11 +3074,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, "constant"); if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; if (gather) free_data_ref (dr); @@ -3109,11 +3091,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; return false; } @@ -3129,11 +3107,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; if (gather) free_data_ref (dr); @@ -3152,11 +3126,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; if (gather) free_data_ref (dr); @@ -3177,11 +3147,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; if (gather) free_data_ref (dr); @@ -3316,11 +3282,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; if (gather) free_data_ref (dr); @@ -3346,12 +3308,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } if (bb_vinfo) - { - /* Mark the statement as not vectorizable. */ - STMT_VINFO_VECTORIZABLE (stmt_info) = false; - stop_bb_analysis = true; - continue; - } + break; if (gather) { @@ -3369,14 +3326,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, if (gather) { - unsigned int j, k, n; - struct data_reference *olddr - = datarefs[i]; - vec<ddr_p> ddrs = LOOP_VINFO_DDRS (loop_vinfo); - struct data_dependence_relation *ddr, *newddr; - bool bad = false; tree off; - vec<loop_p> nest = LOOP_VINFO_LOOP_NEST (loop_vinfo); gather = 0 != vect_check_gather (stmt, loop_vinfo, NULL, &off, NULL); if (gather @@ -3396,59 +3346,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, return false; } - n = datarefs.length () - 1; - for (j = 0, k = i - 1; j < i; j++) - { - ddr = ddrs[k]; - gcc_assert (DDR_B (ddr) == olddr); - newddr = initialize_data_dependence_relation (DDR_A (ddr), dr, - nest); - ddrs[k] = newddr; - free_dependence_relation (ddr); - if (!bad - && DR_IS_WRITE (DDR_A (newddr)) - && DDR_ARE_DEPENDENT (newddr) != chrec_known) - bad = true; - k += --n; - } - - k++; - n = k + datarefs.length () - i - 1; - for (; k < n; k++) - { - ddr = ddrs[k]; - gcc_assert (DDR_A (ddr) == olddr); - newddr = initialize_data_dependence_relation (dr, DDR_B (ddr), - nest); - ddrs[k] = newddr; - free_dependence_relation (ddr); - if (!bad - && DR_IS_WRITE (DDR_B (newddr)) - && DDR_ARE_DEPENDENT (newddr) != chrec_known) - bad = true; - } - - k = ddrs.length () - - datarefs.length () + i; - ddr = ddrs[k]; - gcc_assert (DDR_A (ddr) == olddr && DDR_B (ddr) == olddr); - newddr = initialize_data_dependence_relation (dr, dr, nest); - ddrs[k] = newddr; - free_dependence_relation (ddr); datarefs[i] = dr; - - if (bad) - { - if (dump_enabled_p ()) - { - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "not vectorized: data dependence conflict" - " prevents gather load"); - dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0); - } - return false; - } - STMT_VINFO_GATHER_P (stmt_info) = true; } else if (loop_vinfo @@ -3472,6 +3370,22 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo, } } + /* If we stopped analysis at the first dataref we could not analyze + when trying to vectorize a basic-block mark the rest of the datarefs + as not vectorizable and truncate the vector of datarefs. That + avoids spending useless time in analyzing their dependence. */ + if (i != datarefs.length ()) + { + gcc_assert (bb_vinfo != NULL); + for (unsigned j = i; j < datarefs.length (); ++j) + { + data_reference_p dr = datarefs[j]; + STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr))) = false; + free_data_ref (dr); + } + datarefs.truncate (i); + } + return true; } @@ -3556,19 +3470,16 @@ vect_create_addr_base_for_vector_ref (gimple stmt, { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info); - tree data_ref_base = unshare_expr (DR_BASE_ADDRESS (dr)); + tree data_ref_base; const char *base_name; - tree data_ref_base_var; - tree vec_stmt; - tree addr_base, addr_expr; + tree addr_base; tree dest; gimple_seq seq = NULL; - tree base_offset = unshare_expr (DR_OFFSET (dr)); - tree init = unshare_expr (DR_INIT (dr)); + tree base_offset; + tree init; tree vect_ptr_type; tree step = TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dr))); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info); - tree base; if (loop_vinfo && loop && loop != (gimple_bb (stmt))->loop_father) { @@ -3580,6 +3491,12 @@ vect_create_addr_base_for_vector_ref (gimple stmt, base_offset = unshare_expr (STMT_VINFO_DR_OFFSET (stmt_info)); init = unshare_expr (STMT_VINFO_DR_INIT (stmt_info)); } + else + { + data_ref_base = unshare_expr (DR_BASE_ADDRESS (dr)); + base_offset = unshare_expr (DR_OFFSET (dr)); + init = unshare_expr (DR_INIT (dr)); + } if (loop_vinfo) base_name = get_name (data_ref_base); @@ -3590,29 +3507,17 @@ vect_create_addr_base_for_vector_ref (gimple stmt, base_name = get_name (DR_REF (dr)); } - data_ref_base_var = create_tmp_var (TREE_TYPE (data_ref_base), "batmp"); - data_ref_base = force_gimple_operand (data_ref_base, &seq, true, - data_ref_base_var); - gimple_seq_add_seq (new_stmt_list, seq); - /* Create base_offset */ base_offset = size_binop (PLUS_EXPR, fold_convert (sizetype, base_offset), fold_convert (sizetype, init)); - dest = create_tmp_var (sizetype, "base_off"); - base_offset = force_gimple_operand (base_offset, &seq, true, dest); - gimple_seq_add_seq (new_stmt_list, seq); if (offset) { - tree tmp = create_tmp_var (sizetype, "offset"); - offset = fold_build2 (MULT_EXPR, sizetype, fold_convert (sizetype, offset), step); base_offset = fold_build2 (PLUS_EXPR, sizetype, base_offset, offset); - base_offset = force_gimple_operand (base_offset, &seq, false, tmp); - gimple_seq_add_seq (new_stmt_list, seq); } /* base + base_offset */ @@ -3626,34 +3531,26 @@ vect_create_addr_base_for_vector_ref (gimple stmt, } vect_ptr_type = build_pointer_type (STMT_VINFO_VECTYPE (stmt_info)); - base = get_base_address (DR_REF (dr)); - if (base - && TREE_CODE (base) == MEM_REF) - vect_ptr_type - = build_qualified_type (vect_ptr_type, - TYPE_QUALS (TREE_TYPE (TREE_OPERAND (base, 0)))); - - vec_stmt = fold_convert (vect_ptr_type, addr_base); - addr_expr = vect_get_new_vect_var (vect_ptr_type, vect_pointer_var, - base_name); - vec_stmt = force_gimple_operand (vec_stmt, &seq, false, addr_expr); + addr_base = fold_convert (vect_ptr_type, addr_base); + dest = vect_get_new_vect_var (vect_ptr_type, vect_pointer_var, base_name); + addr_base = force_gimple_operand (addr_base, &seq, false, dest); gimple_seq_add_seq (new_stmt_list, seq); if (DR_PTR_INFO (dr) - && TREE_CODE (vec_stmt) == SSA_NAME) + && TREE_CODE (addr_base) == SSA_NAME) { - duplicate_ssa_name_ptr_info (vec_stmt, DR_PTR_INFO (dr)); + duplicate_ssa_name_ptr_info (addr_base, DR_PTR_INFO (dr)); if (offset) - mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (vec_stmt)); + mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (addr_base)); } if (dump_enabled_p ()) { dump_printf_loc (MSG_NOTE, vect_location, "created "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, vec_stmt); + dump_generic_expr (MSG_NOTE, TDF_SLIM, addr_base); } - return vec_stmt; + return addr_base; } @@ -3733,7 +3630,6 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop, gimple incr; tree step; bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info); - tree base; gcc_assert (TREE_CODE (aggr_type) == ARRAY_TYPE || TREE_CODE (aggr_type) == VECTOR_TYPE); @@ -3785,53 +3681,37 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop, dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_BASE_OBJECT (dr)); } - /* (1) Create the new aggregate-pointer variable. */ - aggr_ptr_type = build_pointer_type (aggr_type); - base = get_base_address (DR_REF (dr)); - if (base - && TREE_CODE (base) == MEM_REF) - aggr_ptr_type - = build_qualified_type (aggr_ptr_type, - TYPE_QUALS (TREE_TYPE (TREE_OPERAND (base, 0)))); - aggr_ptr = vect_get_new_vect_var (aggr_ptr_type, vect_pointer_var, base_name); - - /* Vector and array types inherit the alias set of their component + /* (1) Create the new aggregate-pointer variable. + Vector and array types inherit the alias set of their component type by default so we need to use a ref-all pointer if the data reference does not conflict with the created aggregated data reference because it is not addressable. */ - if (!alias_sets_conflict_p (get_deref_alias_set (aggr_ptr), + bool need_ref_all = false; + if (!alias_sets_conflict_p (get_alias_set (aggr_type), get_alias_set (DR_REF (dr)))) - { - aggr_ptr_type - = build_pointer_type_for_mode (aggr_type, - TYPE_MODE (aggr_ptr_type), true); - aggr_ptr = vect_get_new_vect_var (aggr_ptr_type, vect_pointer_var, - base_name); - } - + need_ref_all = true; /* Likewise for any of the data references in the stmt group. */ else if (STMT_VINFO_GROUP_SIZE (stmt_info) > 1) { gimple orig_stmt = STMT_VINFO_GROUP_FIRST_ELEMENT (stmt_info); do { - tree lhs = gimple_assign_lhs (orig_stmt); - if (!alias_sets_conflict_p (get_deref_alias_set (aggr_ptr), - get_alias_set (lhs))) + stmt_vec_info sinfo = vinfo_for_stmt (orig_stmt); + struct data_reference *sdr = STMT_VINFO_DATA_REF (sinfo); + if (!alias_sets_conflict_p (get_alias_set (aggr_type), + get_alias_set (DR_REF (sdr)))) { - aggr_ptr_type - = build_pointer_type_for_mode (aggr_type, - TYPE_MODE (aggr_ptr_type), true); - aggr_ptr - = vect_get_new_vect_var (aggr_ptr_type, vect_pointer_var, - base_name); + need_ref_all = true; break; } - - orig_stmt = STMT_VINFO_GROUP_NEXT_ELEMENT (vinfo_for_stmt (orig_stmt)); + orig_stmt = STMT_VINFO_GROUP_NEXT_ELEMENT (sinfo); } while (orig_stmt); } + aggr_ptr_type = build_pointer_type_for_mode (aggr_type, ptr_mode, + need_ref_all); + aggr_ptr = vect_get_new_vect_var (aggr_ptr_type, vect_pointer_var, base_name); + /* Note: If the dataref is in an inner-loop nested in LOOP, and we are vectorizing LOOP (i.e., outer-loop vectorization), we need to create two diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c index 559f6e9e997..ff7d53f2591 100644 --- a/gcc/tree-vect-loop-manip.c +++ b/gcc/tree-vect-loop-manip.c @@ -2271,20 +2271,14 @@ vect_vfa_segment_size (struct data_reference *dr, tree length_factor) Output: COND_EXPR - conditional expression. - COND_EXPR_STMT_LIST - statements needed to construct the conditional - expression. - The returned value is the conditional expression to be used in the if statement that controls which version of the loop gets executed at runtime. */ static void -vect_create_cond_for_alias_checks (loop_vec_info loop_vinfo, - tree * cond_expr, - gimple_seq * cond_expr_stmt_list) +vect_create_cond_for_alias_checks (loop_vec_info loop_vinfo, tree * cond_expr) { - struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); vec<ddr_p> may_alias_ddrs = LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo); int vect_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo); @@ -2333,12 +2327,14 @@ vect_create_cond_for_alias_checks (loop_vec_info loop_vinfo, dr_b = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt_b)); } - addr_base_a = - vect_create_addr_base_for_vector_ref (stmt_a, cond_expr_stmt_list, - NULL_TREE, loop); - addr_base_b = - vect_create_addr_base_for_vector_ref (stmt_b, cond_expr_stmt_list, - NULL_TREE, loop); + addr_base_a + = fold_build_pointer_plus (DR_BASE_ADDRESS (dr_a), + size_binop (PLUS_EXPR, DR_OFFSET (dr_a), + DR_INIT (dr_a))); + addr_base_b + = fold_build_pointer_plus (DR_BASE_ADDRESS (dr_b), + size_binop (PLUS_EXPR, DR_OFFSET (dr_b), + DR_INIT (dr_b))); if (!operand_equal_p (DR_STEP (dr_a), DR_STEP (dr_b), 0)) length_factor = scalar_loop_iters; @@ -2435,8 +2431,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo, &cond_expr_stmt_list); if (LOOP_REQUIRES_VERSIONING_FOR_ALIAS (loop_vinfo)) - vect_create_cond_for_alias_checks (loop_vinfo, &cond_expr, - &cond_expr_stmt_list); + vect_create_cond_for_alias_checks (loop_vinfo, &cond_expr); cond_expr = force_gimple_operand_1 (cond_expr, &gimplify_stmt_list, is_gimple_condexpr, NULL_TREE); diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 1252c5a04fc..b7c55214169 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -5773,11 +5773,6 @@ vect_transform_loop (loop_vec_info loop_vinfo) loop->nb_iterations_estimate = loop->nb_iterations_estimate - double_int_one; } - /* The memory tags and pointers in vectorized statements need to - have their SSA forms updated. FIXME, why can't this be delayed - until all the loops have been transformed? */ - update_ssa (TODO_update_ssa); - if (dump_enabled_p ()) dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location, "LOOP VECTORIZED."); if (loop->inner && dump_enabled_p ()) diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index e184326c3b5..8567eac0df2 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -2078,7 +2078,6 @@ static bb_vec_info vect_slp_analyze_bb_1 (basic_block bb) { bb_vec_info bb_vinfo; - vec<ddr_p> ddrs; vec<slp_instance> slp_instances; slp_instance instance; int i; @@ -2100,8 +2099,7 @@ vect_slp_analyze_bb_1 (basic_block bb) return NULL; } - ddrs = BB_VINFO_DDRS (bb_vinfo); - if (!ddrs.length ()) + if (BB_VINFO_DATAREFS (bb_vinfo).length () < 2) { if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c index 42ebb8d250f..9d461997516 100644 --- a/gcc/tree-vectorizer.c +++ b/gcc/tree-vectorizer.c @@ -149,7 +149,16 @@ vectorize_loops (void) free_stmt_vec_info_vec (); - return num_vectorized_loops > 0 ? TODO_cleanup_cfg : 0; + if (num_vectorized_loops > 0) + { + /* If we vectorized any loop only virtual SSA form needs to be updated. + ??? Also while we try hard to update loop-closed SSA form we fail + to properly do this in some corner-cases (see PR56286). */ + rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_only_virtuals); + return TODO_cleanup_cfg; + } + + return 0; } diff --git a/gcc/tree.c b/gcc/tree.c index 98ad5d8784b..31f8037deb8 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -6648,8 +6648,6 @@ tree_int_cst_sgn (const_tree t) unsigned int tree_int_cst_min_precision (tree value, bool unsignedp) { - int log; - /* If the value is negative, compute its negative minus 1. The latter adjustment is because the absolute value of the largest negative value is one larger than the largest positive value. This is equivalent to @@ -6659,14 +6657,14 @@ tree_int_cst_min_precision (tree value, bool unsignedp) value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value); /* Return the number of bits needed, taking into account the fact - that we need one more bit for a signed than unsigned type. */ + that we need one more bit for a signed than unsigned type. + If value is 0 or -1, the minimum precision is 1 no matter + whether unsignedp is true or false. */ if (integer_zerop (value)) - log = 0; + return 1; else - log = tree_floor_log2 (value); - - return log + 1 + !unsignedp; + return tree_floor_log2 (value) + 1 + !unsignedp; } /* Compare two constructor-element-type constants. Return 1 if the lists diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index 5412835903a..2a28f840551 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,21 @@ +2013-03-19 Janne Blomqvist <jb@gcc.gnu.org> + + * libgfortran.h: Include stdbool.h. + (enum try): Remove. + (notify_std): Change return type to bool. + * intrinsics/chmod.c: Don't include stdbool.h. + * intrinsics/execute_command_line.c: Likewise. + * io/format.c: Likewise. + * io/list_read.c (nml_parse_qualifier): Change return type to bool. + (nml_read_obj): Likewise. + (nml_get_obj_data): Likewise. + * io/transfer.c (read_block_form): Fix comment. + (write_buf): Change return type to bool. + * io/write.c: Don't include stdbool.h. + * io/write_float.def (output_float): Change return type to bool. + (output_float_FMT_G_ ## x): Change type of result variable. + * runtime/error.c (notify_std): Change return type to bool. + 2013-03-11 Tobias Burnus <burnus@net-b.de> * io/transfer.c (read_block_direct): Correct condition. diff --git a/libgfortran/intrinsics/chmod.c b/libgfortran/intrinsics/chmod.c index 363d8031582..eca3e6a2231 100644 --- a/libgfortran/intrinsics/chmod.c +++ b/libgfortran/intrinsics/chmod.c @@ -27,7 +27,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #if defined(HAVE_SYS_STAT_H) -#include <stdbool.h> #include <string.h> /* For memcpy. */ #include <sys/stat.h> /* For stat, chmod and umask. */ diff --git a/libgfortran/intrinsics/execute_command_line.c b/libgfortran/intrinsics/execute_command_line.c index fa6ea9fbc34..fd9d4835cb2 100644 --- a/libgfortran/intrinsics/execute_command_line.c +++ b/libgfortran/intrinsics/execute_command_line.c @@ -25,7 +25,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #include "libgfortran.h" #include <string.h> -#include <stdbool.h> #include <stdlib.h> #ifdef HAVE_UNISTD_H diff --git a/libgfortran/io/format.c b/libgfortran/io/format.c index ff3c6804699..c64596baf52 100644 --- a/libgfortran/io/format.c +++ b/libgfortran/io/format.c @@ -31,7 +31,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #include "format.h" #include <ctype.h> #include <string.h> -#include <stdbool.h> #include <stdlib.h> diff --git a/libgfortran/io/list_read.c b/libgfortran/io/list_read.c index fb8a841b229..22125be1afe 100644 --- a/libgfortran/io/list_read.c +++ b/libgfortran/io/list_read.c @@ -2052,7 +2052,7 @@ calls: /* Inputs a rank-dimensional qualifier, which can contain singlets, doublets, triplets or ':' with the standard meanings. */ -static try +static bool nml_parse_qualifier (st_parameter_dt *dtp, descriptor_dimension *ad, array_loop_spec *ls, int rank, char *parse_err_msg, size_t parse_err_msg_size, @@ -2079,7 +2079,7 @@ nml_parse_qualifier (st_parameter_dt *dtp, descriptor_dimension *ad, /* The next character in the stream should be the '('. */ if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; /* Process the qualifier, by dimension and triplet. */ @@ -2093,7 +2093,7 @@ nml_parse_qualifier (st_parameter_dt *dtp, descriptor_dimension *ad, /* Process a potential sign. */ if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; switch (c) { case '-': @@ -2112,7 +2112,7 @@ nml_parse_qualifier (st_parameter_dt *dtp, descriptor_dimension *ad, for (;;) { if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; switch (c) { @@ -2141,7 +2141,7 @@ nml_parse_qualifier (st_parameter_dt *dtp, descriptor_dimension *ad, case ' ': case '\t': eat_spaces (dtp); if ((c = next_char (dtp) == EOF)) - return FAILURE; + return false; break; default: @@ -2279,11 +2279,11 @@ nml_parse_qualifier (st_parameter_dt *dtp, descriptor_dimension *ad, ls[dim].idx = ls[dim].start; } eat_spaces (dtp); - return SUCCESS; + return true; err_ret: - return FAILURE; + return false; } static namelist_info * @@ -2467,7 +2467,7 @@ query_return: little data to be available. On the other hand, too much data is an error. */ -static try +static bool nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset, namelist_info **pprev_nl, char *nml_err_msg, size_t nml_err_msg_size, index_type clow, index_type chigh) @@ -2485,7 +2485,7 @@ nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset, /* This object not touched in name parsing. */ if (!nl->touched) - return SUCCESS; + return true; dtp->u.p.repeat_count = 0; eat_spaces (dtp); @@ -2532,11 +2532,11 @@ nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset, if (--dtp->u.p.repeat_count <= 0) { if (dtp->u.p.input_complete) - return SUCCESS; + return true; if (dtp->u.p.at_eol) finish_separator (dtp); if (dtp->u.p.input_complete) - return SUCCESS; + return true; dtp->u.p.saved_type = BT_UNKNOWN; free_saved (dtp); @@ -2590,18 +2590,18 @@ nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset, cmp = cmp->next) { - if (nml_read_obj (dtp, cmp, (index_type)(pdata - nl->mem_pos), + if (!nml_read_obj (dtp, cmp, (index_type)(pdata - nl->mem_pos), pprev_nl, nml_err_msg, nml_err_msg_size, - clow, chigh) == FAILURE) + clow, chigh)) { free (obj_name); - return FAILURE; + return false; } if (dtp->u.p.input_complete) { free (obj_name); - return SUCCESS; + return true; } } @@ -2625,7 +2625,7 @@ nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset, if (dtp->u.p.nml_read_error) { dtp->u.p.expanded_read = 0; - return SUCCESS; + return true; } if (dtp->u.p.saved_type == BT_UNKNOWN) @@ -2711,11 +2711,11 @@ incr_idx: "Repeat count too large for namelist object %s", nl->var_name); goto nml_err_ret; } - return SUCCESS; + return true; nml_err_ret: - return FAILURE; + return false; } /* Parses the object name, including array and substring qualifiers. It @@ -2725,7 +2725,7 @@ nml_err_ret: touched. nml_read_obj is called at the end and this reads the data in the manner specified by the object name. */ -static try +static bool nml_get_obj_data (st_parameter_dt *dtp, namelist_info **pprev_nl, char *nml_err_msg, size_t nml_err_msg_size) { @@ -2743,20 +2743,20 @@ nml_get_obj_data (st_parameter_dt *dtp, namelist_info **pprev_nl, eat_separator (dtp); if (dtp->u.p.input_complete) - return SUCCESS; + return true; if (dtp->u.p.at_eol) finish_separator (dtp); if (dtp->u.p.input_complete) - return SUCCESS; + return true; if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; switch (c) { case '=': if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; if (c != '?') { snprintf (nml_err_msg, nml_err_msg_size, @@ -2764,11 +2764,11 @@ nml_get_obj_data (st_parameter_dt *dtp, namelist_info **pprev_nl, goto nml_err_ret; } nml_query (dtp, '='); - return SUCCESS; + return true; case '?': nml_query (dtp, '?'); - return SUCCESS; + return true; case '$': case '&': @@ -2781,7 +2781,7 @@ nml_get_obj_data (st_parameter_dt *dtp, namelist_info **pprev_nl, } case '/': dtp->u.p.input_complete = 1; - return SUCCESS; + return true; default : break; @@ -2806,7 +2806,7 @@ get_name: if (!is_separator (c)) push_char (dtp, tolower(c)); if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; } while (!( c=='=' || c==' ' || c=='\t' || c =='(' || c =='%' )); unget_char (dtp, c); @@ -2866,9 +2866,9 @@ get_name: if (c == '(' && nl->var_rank) { parsed_rank = 0; - if (nml_parse_qualifier (dtp, nl->dim, nl->ls, nl->var_rank, + if (!nml_parse_qualifier (dtp, nl->dim, nl->ls, nl->var_rank, nml_err_msg, nml_err_msg_size, - &parsed_rank) == FAILURE) + &parsed_rank)) { char *nml_err_msg_end = strchr (nml_err_msg, '\0'); snprintf (nml_err_msg_end, @@ -2882,7 +2882,7 @@ get_name: qualifier_flag = 1; if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; unget_char (dtp, c); } else if (nl->var_rank > 0) @@ -2908,7 +2908,7 @@ get_name: component_flag = 1; if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; goto get_name; } @@ -2923,9 +2923,8 @@ get_name: descriptor_dimension chd[1] = { {1, clow, nl->string_length} }; array_loop_spec ind[1] = { {1, clow, nl->string_length, 1} }; - if (nml_parse_qualifier (dtp, chd, ind, -1, nml_err_msg, - nml_err_msg_size, &parsed_rank) - == FAILURE) + if (!nml_parse_qualifier (dtp, chd, ind, -1, nml_err_msg, + nml_err_msg_size, &parsed_rank)) { char *nml_err_msg_end = strchr (nml_err_msg, '\0'); snprintf (nml_err_msg_end, @@ -2946,7 +2945,7 @@ get_name: } if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; unget_char (dtp, c); } @@ -2978,15 +2977,15 @@ get_name: eat_separator (dtp); if (dtp->u.p.input_complete) - return SUCCESS; + return true; if (dtp->u.p.at_eol) finish_separator (dtp); if (dtp->u.p.input_complete) - return SUCCESS; + return true; if ((c = next_char (dtp)) == EOF) - return FAILURE; + return false; if (c != '=') { @@ -3013,15 +3012,15 @@ get_name: nl = first_nl; } - if (nml_read_obj (dtp, nl, 0, pprev_nl, nml_err_msg, nml_err_msg_size, - clow, chigh) == FAILURE) + if (!nml_read_obj (dtp, nl, 0, pprev_nl, nml_err_msg, nml_err_msg_size, + clow, chigh)) goto nml_err_ret; - return SUCCESS; + return true; nml_err_ret: - return FAILURE; + return false; } /* Entry point for namelist input. Goes through input until namelist name @@ -3104,8 +3103,7 @@ find_nml_name: while (!dtp->u.p.input_complete) { - if (nml_get_obj_data (dtp, &prev_nl, nml_err_msg, sizeof nml_err_msg) - == FAILURE) + if (!nml_get_obj_data (dtp, &prev_nl, nml_err_msg, sizeof nml_err_msg)) { if (dtp->u.p.current_unit->unit_number != options.stdin_unit) goto nml_err_ret; diff --git a/libgfortran/io/transfer.c b/libgfortran/io/transfer.c index d97a325a772..6fa954ce287 100644 --- a/libgfortran/io/transfer.c +++ b/libgfortran/io/transfer.c @@ -401,7 +401,7 @@ read_sf (st_parameter_dt *dtp, int * length) /* Function for reading the next couple of bytes from the current - file, advancing the current position. We return FAILURE on end of record or + file, advancing the current position. We return NULL on end of record or end of file. This function is only for formatted I/O, unformatted uses read_block_direct. @@ -774,7 +774,7 @@ write_block (st_parameter_dt *dtp, int length) called for unformatted files. There are three cases to consider: Stream I/O, unformatted direct, unformatted sequential. */ -static try +static bool write_buf (st_parameter_dt *dtp, void *buf, size_t nbytes) { @@ -790,12 +790,12 @@ write_buf (st_parameter_dt *dtp, void *buf, size_t nbytes) if (unlikely (have_written < 0)) { generate_error (&dtp->common, LIBERROR_OS, NULL); - return FAILURE; + return false; } dtp->u.p.current_unit->strm_pos += (gfc_offset) have_written; - return SUCCESS; + return true; } /* Unformatted direct access. */ @@ -805,23 +805,23 @@ write_buf (st_parameter_dt *dtp, void *buf, size_t nbytes) if (unlikely (dtp->u.p.current_unit->bytes_left < (gfc_offset) nbytes)) { generate_error (&dtp->common, LIBERROR_DIRECT_EOR, NULL); - return FAILURE; + return false; } if (buf == NULL && nbytes == 0) - return SUCCESS; + return true; have_written = swrite (dtp->u.p.current_unit->s, buf, nbytes); if (unlikely (have_written < 0)) { generate_error (&dtp->common, LIBERROR_OS, NULL); - return FAILURE; + return false; } dtp->u.p.current_unit->strm_pos += (gfc_offset) have_written; dtp->u.p.current_unit->bytes_left -= (gfc_offset) have_written; - return SUCCESS; + return true; } /* Unformatted sequential. */ @@ -854,7 +854,7 @@ write_buf (st_parameter_dt *dtp, void *buf, size_t nbytes) if (unlikely (to_write_subrecord < 0)) { generate_error (&dtp->common, LIBERROR_OS, NULL); - return FAILURE; + return false; } dtp->u.p.current_unit->strm_pos += (gfc_offset) to_write_subrecord; @@ -871,9 +871,9 @@ write_buf (st_parameter_dt *dtp, void *buf, size_t nbytes) if (unlikely (short_record)) { generate_error (&dtp->common, LIBERROR_SHORT_RECORD, NULL); - return FAILURE; + return false; } - return SUCCESS; + return true; } diff --git a/libgfortran/io/write.c b/libgfortran/io/write.c index f17528edc56..153da2e2038 100644 --- a/libgfortran/io/write.c +++ b/libgfortran/io/write.c @@ -31,7 +31,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #include <string.h> #include <ctype.h> #include <stdlib.h> -#include <stdbool.h> #include <errno.h> #define star_fill(p, n) memset(p, '*', n) diff --git a/libgfortran/io/write_float.def b/libgfortran/io/write_float.def index 5b76fd59650..a157f0b6328 100644 --- a/libgfortran/io/write_float.def +++ b/libgfortran/io/write_float.def @@ -110,7 +110,7 @@ determine_precision (st_parameter_dt * dtp, const fnode * f, int len) /* Output a real number according to its format which is FMT_G free. */ -static try +static bool output_float (st_parameter_dt *dtp, const fnode *f, char *buffer, size_t size, int nprinted, int precision, int sign_bit, bool zero_flag) { @@ -244,13 +244,13 @@ output_float (st_parameter_dt *dtp, const fnode *f, char *buffer, size_t size, { generate_error (&dtp->common, LIBERROR_FORMAT, "Precision not " "greater than zero in format specifier 'E' or 'D'"); - return FAILURE; + return false; } if (p <= -d || p >= d + 2) { generate_error (&dtp->common, LIBERROR_FORMAT, "Scale factor " "out of range in format specifier 'E' or 'D'"); - return FAILURE; + return false; } if (!zero_flag) @@ -532,7 +532,7 @@ output_float (st_parameter_dt *dtp, const fnode *f, char *buffer, size_t size, /* Create the ouput buffer. */ out = write_block (dtp, w); if (out == NULL) - return FAILURE; + return false; /* Check the value fits in the specified field width. */ if (nblanks < 0 || edigits == -1 || w == 1 || (w == 2 && sign != S_NONE)) @@ -541,10 +541,10 @@ output_float (st_parameter_dt *dtp, const fnode *f, char *buffer, size_t size, { gfc_char4_t *out4 = (gfc_char4_t *) out; memset4 (out4, '*', w); - return FAILURE; + return false; } star_fill (out, w); - return FAILURE; + return false; } /* See if we have space for a zero before the decimal point. */ @@ -652,7 +652,7 @@ output_float (st_parameter_dt *dtp, const fnode *f, char *buffer, size_t size, memset4 (out4, ' ' , nblanks); dtp->u.p.no_leading_blank = 0; } - return SUCCESS; + return true; } /* End of character(kind=4) internal unit code. */ /* Pad to full field width. */ @@ -745,7 +745,7 @@ output_float (st_parameter_dt *dtp, const fnode *f, char *buffer, size_t size, dtp->u.p.no_leading_blank = 0; } - return SUCCESS; + return true; } @@ -995,7 +995,7 @@ output_float_FMT_G_ ## x (st_parameter_dt *dtp, const fnode *f, \ int ubound, lbound;\ char *p, pad = ' ';\ int save_scale_factor, nb = 0;\ - try result;\ + bool result;\ int nprinted, precision;\ \ save_scale_factor = dtp->u.p.scale_factor;\ @@ -1087,7 +1087,7 @@ output_float_FMT_G_ ## x (st_parameter_dt *dtp, const fnode *f, \ p = write_block (dtp, nb);\ if (p == NULL)\ return;\ - if (result == FAILURE)\ + if (!result)\ pad = '*';\ if (unlikely (is_char4_unit (dtp)))\ {\ diff --git a/libgfortran/libgfortran.h b/libgfortran/libgfortran.h index f54edc09634..56c98715feb 100644 --- a/libgfortran/libgfortran.h +++ b/libgfortran/libgfortran.h @@ -43,6 +43,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #include <stddef.h> #include <float.h> #include <stdarg.h> +#include <stdbool.h> #if HAVE_COMPLEX_H /* Must appear before math.h on VMS systems. */ @@ -561,10 +562,6 @@ typedef enum { NOTIFICATION_SILENT, NOTIFICATION_WARNING, NOTIFICATION_ERROR } notification; -/* This is returned by notify_std and several io functions. */ -typedef enum -{ SUCCESS = 1, FAILURE } -try; /* The filename and line number don't go inside the globals structure. They are set by the rest of the program and must be linked to. */ @@ -732,7 +729,7 @@ iexport_proto(generate_error); extern void generate_warning (st_parameter_common *, const char *); internal_proto(generate_warning); -extern try notify_std (st_parameter_common *, int, const char *); +extern bool notify_std (st_parameter_common *, int, const char *); internal_proto(notify_std); extern notification notification_std(int); diff --git a/libgfortran/runtime/error.c b/libgfortran/runtime/error.c index f09fa201e89..5f048192c23 100644 --- a/libgfortran/runtime/error.c +++ b/libgfortran/runtime/error.c @@ -586,17 +586,17 @@ notification_std (int std) feature. An error/warning will be issued if the currently selected standard does not contain the requested bits. */ -try +bool notify_std (st_parameter_common *cmp, int std, const char * message) { int warning; if (!compile_options.pedantic) - return SUCCESS; + return true; warning = compile_options.warn_std & std; if ((compile_options.allow_std & std) != 0 && !warning) - return SUCCESS; + return true; if (!warning) { @@ -614,5 +614,5 @@ notify_std (st_parameter_common *cmp, int std, const char * message) estr_write (message); estr_write ("\n"); } - return FAILURE; + return false; } diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index e8211a307d0..81426dc2a89 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,44 @@ +2013-03-18 Paolo Carlini <paolo.carlini@oracle.com> + + PR libstdc++/55977 (partial, std::vector and std::deque bits) + * include/bits/stl_vector.h (_M_range_initialize(_InputIterator, + _InputIterator, std::input_iterator_tag)): Use emplace_back. + * include/bits/deque.tcc (_M_range_initialize(_InputIterator, + _InputIterator, std::input_iterator_tag)): Likewise. + * testsuite/23_containers/vector/cons/55977.cc: New. + * testsuite/23_containers/deque/cons/55977.cc: Likewise. + * testsuite/23_containers/vector/requirements/dr438/assign_neg.cc: + Adjust dg-error line number. + * testsuite/23_containers/vector/requirements/dr438/insert_neg.cc: + Likewise. + +2013-03-17 Paolo Carlini <paolo.carlini@oracle.com> + + PR libstdc++/55979 + * include/bits/stl_list.h (_M_initialize_dispatch(_InputIterator, + _InputIterator, __false_type)): Use emplace_back. + * testsuite/23_containers/list/cons/55979.cc: New. + * testsuite/23_containers/list/modifiers/1.h: Adjust. + * testsuite/23_containers/list/requirements/dr438/assign_neg.cc: + Adjust dg-error line number. + +2013-03-16 Jason Merrill <jason@redhat.com> + + PR c++/55017 + * testsuite/20_util/pair/piecewise2.cc (test01): Use std::move. + +2013-03-16 Jonathan Wakely <jwakely.gcc@gmail.com> + + PR libstdc++/56468 + * libsupc++/exception_ptr.h (type_info): Declare. + +2013-03-16 Jonathan Wakely <jwakely.gcc@gmail.com> + + PR libstdc++/56002 + * include/std/mutex (lock_guard, unique_lock, lock): Define without + depending on _GLIBCXX_HAS_GTHREADS. + * testsuite/30_threads/lock_guard/cons/1.cc: Run on all targets. + 2013-03-16 Jonathan Wakely <jwakely.gcc@gmail.com> PR libstdc++/56492 diff --git a/libstdc++-v3/include/bits/deque.tcc b/libstdc++-v3/include/bits/deque.tcc index 369e0eda531..89c5ef76ba6 100644 --- a/libstdc++-v3/include/bits/deque.tcc +++ b/libstdc++-v3/include/bits/deque.tcc @@ -381,7 +381,11 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER __try { for (; __first != __last; ++__first) +#if __cplusplus >= 201103L + emplace_back(*__first); +#else push_back(*__first); +#endif } __catch(...) { diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h index cc6edb3da7f..596760c2152 100644 --- a/libstdc++-v3/include/bits/stl_list.h +++ b/libstdc++-v3/include/bits/stl_list.h @@ -1487,7 +1487,11 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER __false_type) { for (; __first != __last; ++__first) +#if __cplusplus >= 201103L + emplace_back(*__first); +#else push_back(*__first); +#endif } // Called by list(n,v,a), and the range constructor when it turns out diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index 8af4a309174..9a53f3ebe93 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -1290,7 +1290,11 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) +#if __cplusplus >= 201103L + emplace_back(*__first); +#else push_back(*__first); +#endif } // Called by the second initialize_dispatch above diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex index e327f28c1dd..67f34185deb 100644 --- a/libstdc++-v3/include/std/mutex +++ b/libstdc++-v3/include/std/mutex @@ -45,12 +45,13 @@ #include <bits/gthr.h> #include <bits/move.h> // for std::swap -#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION +#ifdef _GLIBCXX_HAS_GTHREADS // Common base class for std::mutex and std::timed_mutex class __mutex_base { @@ -384,6 +385,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } }; #endif +#endif // _GLIBCXX_HAS_GTHREADS /// Do not acquire ownership of the mutex. struct defer_lock_t { }; @@ -719,6 +721,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } } +#ifdef _GLIBCXX_HAS_GTHREADS /// once_flag struct once_flag { @@ -790,12 +793,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION if (__e) __throw_system_error(__e); } +#endif // _GLIBCXX_HAS_GTHREADS // @} group mutexes _GLIBCXX_END_NAMESPACE_VERSION } // namespace - -#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 +#endif // _GLIBCXX_USE_C99_STDINT_TR1 #endif // C++11 diff --git a/libstdc++-v3/libsupc++/exception_ptr.h b/libstdc++-v3/libsupc++/exception_ptr.h index 7a535f22083..bbf8f85d47b 100644 --- a/libstdc++-v3/libsupc++/exception_ptr.h +++ b/libstdc++-v3/libsupc++/exception_ptr.h @@ -44,6 +44,8 @@ extern "C++" { namespace std { + class type_info; + /** * @addtogroup exceptions * @{ @@ -141,7 +143,7 @@ namespace std operator==(const exception_ptr&, const exception_ptr&) _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__)); - const class type_info* + const class std::type_info* __cxa_exception_type() const _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__)); }; diff --git a/libstdc++-v3/testsuite/20_util/pair/piecewise2.cc b/libstdc++-v3/testsuite/20_util/pair/piecewise2.cc index d53e49c78b5..0273c14ad56 100644 --- a/libstdc++-v3/testsuite/20_util/pair/piecewise2.cc +++ b/libstdc++-v3/testsuite/20_util/pair/piecewise2.cc @@ -51,7 +51,8 @@ struct Default void test01(std::tuple<NoCon&, NoCon&&> t1, std::tuple<NoCon&, NoCon&&, NoCon&> t2) { - std::pair<RefCheck1, RefCheck2>(std::piecewise_construct, t1, t2); + std::pair<RefCheck1, RefCheck2>(std::piecewise_construct, + std::move(t1), std::move(t2)); } void test02(std::tuple<> t1, std::tuple<int> t2) diff --git a/libstdc++-v3/testsuite/23_containers/deque/cons/55977.cc b/libstdc++-v3/testsuite/23_containers/deque/cons/55977.cc new file mode 100644 index 00000000000..ef2d7c01c8d --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/deque/cons/55977.cc @@ -0,0 +1,70 @@ +// { dg-do compile } +// { dg-options "-std=gnu++11" } + +// Copyright (C) 2013 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <utility> +#include <deque> +#include <iterator> + +template <class T> +struct MyAllocator +{ + std::allocator<T> base; + typedef T value_type; + + // FIXME: these types shouldn't be required. + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + template <typename U> + struct rebind + { typedef MyAllocator<U> other; }; + + MyAllocator() = default; + template <class U> + MyAllocator(const MyAllocator<U>& other) : base(other.base) {} + T* allocate(std::size_t n) { return base.allocate(n); } + void deallocate(T* p, std::size_t n) { return base.deallocate(p, n); } + template <class U, class... Args> + void construct(U* p, Args&&... args) + { + ::new (static_cast<void*>(p)) U(std::forward<Args>(args)...); + } +}; + +struct A +{ +private: + friend class MyAllocator<A>; + A(int value) : value(value) {} + int value; +public: + A() : value() {} + int get() const { return value; } +}; + +void foo() +{ + std::deque<A, MyAllocator<A>> v1; + const int i = 1; + v1.emplace_back(i); // OK + std::deque<A, MyAllocator<A>> v2(std::istream_iterator<int>(), {}); // ERROR +} diff --git a/libstdc++-v3/testsuite/23_containers/list/cons/55979.cc b/libstdc++-v3/testsuite/23_containers/list/cons/55979.cc new file mode 100644 index 00000000000..6a069bfd7e3 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/list/cons/55979.cc @@ -0,0 +1,34 @@ +// { dg-do compile } +// { dg-options "-std=gnu++11" } + +// Copyright (C) 2013 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <list> + +struct A +{ + A(int) { } + A(const A&) = delete; + A& operator=(const A&) = delete; +}; + +void foo() +{ + int i[] = {1, 2}; + std::list<A> li(i, i + 2); +} diff --git a/libstdc++-v3/testsuite/23_containers/list/modifiers/1.h b/libstdc++-v3/testsuite/23_containers/list/modifiers/1.h index 326df4b43ee..1e7767b4bee 100644 --- a/libstdc++-v3/testsuite/23_containers/list/modifiers/1.h +++ b/libstdc++-v3/testsuite/23_containers/list/modifiers/1.h @@ -89,14 +89,22 @@ modifiers1() b = list0301.begin(); list0301.insert(b, A, A + N); // should be [321 322 333 13 13] VERIFY(list0301.size() == 5); +#if __cplusplus >= 201103L + VERIFY(copy_constructor::count() == 0); +#else VERIFY(copy_constructor::count() == 3); +#endif VERIFY(m->id() == 13); // range fill at end value_type::reset(); list0301.insert(e, A, A + N); // should be [321 322 333 13 13 321 322 333] VERIFY(list0301.size() == 8); +#if __cplusplus >= 201103L + VERIFY(copy_constructor::count() == 0); +#else VERIFY(copy_constructor::count() == 3); +#endif VERIFY(e == list0301.end()); VERIFY(m->id() == 13); @@ -104,7 +112,11 @@ modifiers1() value_type::reset(); list0301.insert(m, A, A + N); VERIFY(list0301.size() == 11); +#if __cplusplus >= 201103L + VERIFY(copy_constructor::count() == 0); +#else VERIFY(copy_constructor::count() == 3); +#endif VERIFY(e == list0301.end()); VERIFY(m->id() == 13); diff --git a/libstdc++-v3/testsuite/23_containers/list/requirements/dr438/assign_neg.cc b/libstdc++-v3/testsuite/23_containers/list/requirements/dr438/assign_neg.cc index 1fc5dfb47a5..63216cb01c8 100644 --- a/libstdc++-v3/testsuite/23_containers/list/requirements/dr438/assign_neg.cc +++ b/libstdc++-v3/testsuite/23_containers/list/requirements/dr438/assign_neg.cc @@ -18,7 +18,7 @@ // <http://www.gnu.org/licenses/>. // { dg-do compile } -// { dg-error "no matching" "" { target *-*-* } 1525 } +// { dg-error "no matching" "" { target *-*-* } 1529 } #include <list> diff --git a/libstdc++-v3/testsuite/23_containers/vector/cons/55977.cc b/libstdc++-v3/testsuite/23_containers/vector/cons/55977.cc new file mode 100644 index 00000000000..295d6b1d942 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/vector/cons/55977.cc @@ -0,0 +1,60 @@ +// { dg-do compile } +// { dg-options "-std=gnu++11" } + +// Copyright (C) 2013 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <utility> +#include <vector> +#include <iterator> + +template <class T> +struct MyAllocator +{ + std::allocator<T> base; + typedef T value_type; + MyAllocator() = default; + template <class U> + MyAllocator(const MyAllocator<U>& other) : base(other.base) {} + T* allocate(std::size_t n) { return base.allocate(n); } + void deallocate(T* p, std::size_t n) { return base.deallocate(p, n); } + template <class U, class... Args> + void construct(U* p, Args&&... args) + { + ::new (static_cast<void*>(p)) U(std::forward<Args>(args)...); + } +}; + +struct A +{ +private: + friend class MyAllocator<A>; + A(int value) : value(value) {} + int value; +public: + A() : value() {} + int get() const { return value; } +}; + +void foo() +{ + std::vector<A, MyAllocator<A>> v1; + const int i = 1; + v1.emplace_back(i); // OK + std::vector<A, MyAllocator<A>> v2(std::istream_iterator<int>(), {}); // ERROR +} diff --git a/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/assign_neg.cc b/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/assign_neg.cc index eec039ccea8..8b1bdb4b3a5 100644 --- a/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/assign_neg.cc +++ b/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/assign_neg.cc @@ -18,7 +18,7 @@ // <http://www.gnu.org/licenses/>. // { dg-do compile } -// { dg-error "no matching" "" { target *-*-* } 1342 } +// { dg-error "no matching" "" { target *-*-* } 1346 } #include <vector> diff --git a/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/insert_neg.cc b/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/insert_neg.cc index a8f33c42cc1..53d24efbe76 100644 --- a/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/insert_neg.cc +++ b/libstdc++-v3/testsuite/23_containers/vector/requirements/dr438/insert_neg.cc @@ -18,7 +18,7 @@ // <http://www.gnu.org/licenses/>. // { dg-do compile } -// { dg-error "no matching" "" { target *-*-* } 1383 } +// { dg-error "no matching" "" { target *-*-* } 1387 } #include <vector> diff --git a/libstdc++-v3/testsuite/30_threads/lock_guard/cons/1.cc b/libstdc++-v3/testsuite/30_threads/lock_guard/cons/1.cc index d92e6bafe94..cd6d9143bdf 100644 --- a/libstdc++-v3/testsuite/30_threads/lock_guard/cons/1.cc +++ b/libstdc++-v3/testsuite/30_threads/lock_guard/cons/1.cc @@ -1,9 +1,6 @@ -// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* powerpc-ibm-aix* } } -// { dg-options " -std=gnu++0x -pthread" { target *-*-freebsd* *-*-netbsd* *-*-linux* powerpc-ibm-aix* } } -// { dg-options " -std=gnu++0x -pthreads" { target *-*-solaris* } } -// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } } +// { dg-do run } +// { dg-options " -std=gnu++11 " } // { dg-require-cstdint "" } -// { dg-require-gthreads "" } // Copyright (C) 2010-2013 Free Software Foundation, Inc. // diff --git a/maintainer-scripts/ChangeLog b/maintainer-scripts/ChangeLog index a848befda06..b719d684da6 100644 --- a/maintainer-scripts/ChangeLog +++ b/maintainer-scripts/ChangeLog @@ -1,3 +1,7 @@ +2013-03-16 Jakub Jelinek <jakub@redhat.com> + + * crontab: Enable snapshots from gcc-4_8-branch. + 2012-07-02 Richard Guenther <rguenther@suse.de> * crontab: Disable snapshots from gcc-4_5-branch. diff --git a/maintainer-scripts/crontab b/maintainer-scripts/crontab index e295d225b1a..4f69b985f9e 100644 --- a/maintainer-scripts/crontab +++ b/maintainer-scripts/crontab @@ -1,6 +1,7 @@ 16 0 * * * sh /home/gccadmin/scripts/update_version_svn 50 0 * * * sh /home/gccadmin/scripts/update_web_docs_svn 55 0 * * * sh /home/gccadmin/scripts/update_web_docs_libstdcxx_svn +32 22 * * 4 sh /home/gccadmin/scripts/gcc_release -s 4.8:branches/gcc-4_8-branch -l -d /sourceware/snapshot-tmp/gcc all 32 22 * * 5 sh /home/gccadmin/scripts/gcc_release -s 4.6:branches/gcc-4_6-branch -l -d /sourceware/snapshot-tmp/gcc all 32 22 * * 6 sh /home/gccadmin/scripts/gcc_release -s 4.7:branches/gcc-4_7-branch -l -d /sourceware/snapshot-tmp/gcc all -32 22 * * 7 sh /home/gccadmin/scripts/gcc_release -s 4.8:trunk -l -d /sourceware/snapshot-tmp/gcc all +32 22 * * 7 sh /home/gccadmin/scripts/gcc_release -s 4.9:trunk -l -d /sourceware/snapshot-tmp/gcc all |